fix(opencode): clear session status before publishing status events

.changeset/fix-stale-reload-status.md

@@ -0,0 +1,6 @@
+---
+"@kilocode/cli": patch
+"kilo-code": patch
+---
+
+Prevent failed status notifications from leaving completed sessions marked busy and blocking reload.

packages/opencode/src/session/status.ts

@@ -71,18 +71,20 @@ export const layer = Layer.effect(
       const ctx = yield* InstanceState.context
       const projectID = String(ctx.project.id)
       // kilocode_change end
-      yield* events.publish(Event.Status, { sessionID, status })
+      // kilocode_change start - clear a stopped session before publishing, so a
+      // listener failure cannot leave it busy and block a later reload
       if (status.type === "idle") {
-        yield* events.publish(Event.Idle, { sessionID })
         data.delete(sessionID)
-        // kilocode_change start
         const store = stores.get(projectID)
         store?.delete(sessionID)
         if (store && store.size === 0) stores.delete(projectID)
         byDirectory.get(ctx.directory)?.delete(sessionID)
-        // kilocode_change end
+        yield* events.publish(Event.Status, { sessionID, status })
+        yield* events.publish(Event.Idle, { sessionID })
         return
       }
+      // kilocode_change end
+      yield* events.publish(Event.Status, { sessionID, status })
       data.set(sessionID, status)
       // kilocode_change start
       let store = stores.get(projectID)
@@ -97,8 +99,8 @@ export const layer = Layer.effect(
         byDirectory.set(ctx.directory, dir)
       }
       dir.set(sessionID, projectID)
+      // kilocode_change end
     })
-    // kilocode_change end
 
     // kilocode_change start - drop this instance's sessions from the project store
     // on dispose, so a busy status set here does not outlive the instance.

packages/opencode/test/kilocode/session-status.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect } from "bun:test"
+import { Cause, Effect, Exit, Layer } from "effect"
+import { EventV2Bridge } from "../../src/event-v2-bridge"
+import { SessionID } from "../../src/session/schema"
+import { SessionStatus } from "../../src/session/status"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(SessionStatus.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer)))
+
+describe("SessionStatus idle publication", () => {
+  for (const failure of [undefined, SessionStatus.Event.Status.type, SessionStatus.Event.Idle.type]) {
+    it.instance(
+      failure
+        ? `keeps both stores cleared when ${failure} publication fails`
+        : "clears both stores before idle publication",
+      () =>
+        Effect.gen(function* () {
+          const status = yield* SessionStatus.Service
+          const events = yield* EventV2Bridge.Service
+          const id = SessionID.make(`ses_idle_publication_${failure ?? "success"}`)
+          const error = new Error("deliberate publication failure")
+          const observed: { type: string; local: boolean; global: boolean }[] = []
+
+          yield* status.set(id, { type: "busy" })
+          expect((yield* status.list()).get(id)).toEqual({ type: "busy" })
+          expect((yield* SessionStatus.listAll()).get(id)).toEqual({ type: "busy" })
+
+          const unsubscribe = yield* events.listen((event) =>
+            Effect.gen(function* () {
+              if (event.type !== SessionStatus.Event.Status.type && event.type !== SessionStatus.Event.Idle.type) return
+              observed.push({
+                type: event.type,
+                local: (yield* status.list()).has(id),
+                global: (yield* SessionStatus.listAll()).has(id),
+              })
+              if (event.type === failure) yield* Effect.die(error)
+            }),
+          )
+          yield* Effect.addFinalizer(() => unsubscribe)
+
+          const exit = yield* status.set(id, { type: "idle" }).pipe(Effect.exit)
+
+          expect(Exit.isFailure(exit)).toBe(failure !== undefined)
+          if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBe(error)
+          expect(observed).toEqual(
+            (failure === SessionStatus.Event.Status.type
+              ? [SessionStatus.Event.Status.type]
+              : [SessionStatus.Event.Status.type, SessionStatus.Event.Idle.type]
+            ).map((type) => ({ type, local: false, global: false })),
+          )
+          expect((yield* status.list()).has(id)).toBe(false)
+          expect((yield* SessionStatus.listAll()).has(id)).toBe(false)
+        }),
+    )
+  }
+})
+
+describe("SessionStatus busy publication", () => {
+  it.instance("does not record a busy status when its publication fails", () =>
+    Effect.gen(function* () {
+      const status = yield* SessionStatus.Service
+      const events = yield* EventV2Bridge.Service
+      const id = SessionID.make("ses_busy_publication_failure")
+      const error = new Error("deliberate busy publication failure")
+
+      const unsubscribe = yield* events.listen((event) =>
+        event.type === SessionStatus.Event.Status.type ? Effect.die(error) : Effect.void,
+      )
+      yield* Effect.addFinalizer(() => unsubscribe)
+
+      const exit = yield* status.set(id, { type: "busy" }).pipe(Effect.exit)
+
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBe(error)
+      expect((yield* status.list()).has(id)).toBe(false)
+      expect((yield* SessionStatus.listAll()).has(id)).toBe(false)
+    }),
+  )
+})