fix(tui): publish synthetic reject event when ask is interrupted

When the underlying "ask" effect for a Permission or Question prompt is
interrupted (tool cancelled, session ended, parent killed, scope torn down)
rather than completing via a normal reply/reject, the Effect.ensuring
finalizer deleted the pending entry but never published a corresponding
terminal bus event. The TUI tracks prompt state via these events, so the
orphaned request stayed in sync.data.permission / sync.data.question
forever. Pressing Allow/Reject/typing a custom answer / pressing Esc all
issued SDK calls against a requestID that the server no longer had in
pending — the handler logs "reply for unknown request" and returns 200
OK silently with no event, so the TUI never dismissed and the prompt
became completely unresponsive (every option re-rendered the same view,
even exit was unreachable while the prompt held the input).

Fix: replace the unconditional pending.delete in the finalizer with an
Effect.gen that checks pending.has(id). The reply and reject paths delete
the entry themselves before publishing, so this guard fires only on the
interrupt path. When it does, delete the entry and publish a synthetic
terminal event so the TUI dismisses the orphan:

  - question/index.ts publishes Event.Rejected
  - permission/index.ts publishes Event.Replied with reply: "reject"
    (Permission has no dedicated cancellation event; "reject" is the
    accepted Reply value that signals dismissal)

Adds regression tests in both packages that fork the ask effect, wait
for it to be pending, interrupt the fiber, and assert the bus emits the
expected terminal event and the pending list is empty.

Author: sjawhar

packages/opencode/src/permission/index.ts

@@ -204,8 +204,20 @@ export const layer = Layer.effect(
       yield* bus.publish(Event.Asked, info)
       return yield* Effect.ensuring(
         Deferred.await(deferred),
-        Effect.sync(() => {
+        Effect.gen(function* () {
+          // If the entry is still here, this finalizer is running because ask was
+          // interrupted (tool cancelled, session ended, parent killed). The reply
+          // path deletes the entry itself before publishing Event.Replied, so we
+          // only fire a synthetic "reject" here for the orphan case — otherwise
+          // the TUI's sync.data.permission never receives a terminal event and the
+          // prompt stays visible forever with no way to dismiss it.
+          if (!pending.has(id)) return
           pending.delete(id)
+          yield* bus.publish(Event.Replied, {
+            sessionID: info.sessionID,
+            requestID: info.id,
+            reply: "reject",
+          })
         }),
       )
     })

packages/opencode/src/question/index.ts

@@ -173,8 +173,19 @@ export const layer = Layer.effect(
 
       return yield* Effect.ensuring(
         Deferred.await(deferred),
-        Effect.sync(() => {
+        Effect.gen(function* () {
+          // If the entry is still here, this finalizer is running because ask was
+          // interrupted (tool cancelled, session ended, parent killed). The reply
+          // and reject paths delete the entry themselves before publishing their
+          // event, so we only fire Rejected here for the orphan case — otherwise
+          // the TUI's sync.data.question never receives a terminal event and the
+          // prompt stays visible forever.
+          if (!pending.has(id)) return
           pending.delete(id)
+          yield* bus.publish(Event.Rejected, {
+            sessionID: info.sessionID,
+            requestID: info.id,
+          })
         }),
       )
     })

packages/opencode/test/permission/next.test.ts

@@ -951,6 +951,57 @@ it.instance(
   { git: true },
 )
 
+it.live("interrupt - publishes Replied(reject) so TUI orphans get dismissed", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+    const store = yield* InstanceStore.Service
+    return yield* store.provide(
+      { directory: dir },
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        const received: { sessionID: SessionID; requestID: PermissionID; reply: Permission.Reply }[] = []
+        const unsub = yield* bus.subscribeCallback(Permission.Event.Replied, (event) => {
+          received.push(event.properties)
+        })
+
+        try {
+          const fiber = yield* ask({
+            id: PermissionID.make("per_interrupt"),
+            sessionID: SessionID.make("session_interrupt"),
+            permission: "read",
+            patterns: [".env.template"],
+            metadata: {},
+            always: ["*"],
+            ruleset: [],
+          }).pipe(Effect.forkScoped)
+
+          yield* waitForPending(1)
+
+          // Simulate the tool execution being interrupted before the user replies
+          // (session ended, parent killed, scope torn down, etc.). Without the
+          // finalizer publishing a synthetic reject, the TUI's sync.data.permission
+          // would keep showing the prompt forever.
+          yield* Fiber.interrupt(fiber)
+
+          // Give the finalizer a moment to publish.
+          yield* Effect.sleep("20 millis")
+
+          expect(received).toEqual([
+            {
+              sessionID: SessionID.make("session_interrupt"),
+              requestID: PermissionID.make("per_interrupt"),
+              reply: "reject",
+            },
+          ])
+          expect(yield* list()).toHaveLength(0)
+        } finally {
+          unsub()
+        }
+      }),
+    )
+  }),
+)
+
 it.live("permission requests stay isolated by directory", () =>
   Effect.gen(function* () {
     const one = yield* tmpdirScoped({ git: true })

packages/opencode/test/question/question.test.ts

@@ -10,8 +10,9 @@ import { testEffect } from "../lib/effect"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { Bus } from "../../src/bus"
 
+const bus = Bus.layer
 const it = testEffect(
-  Layer.mergeAll(Question.layer.pipe(Layer.provideMerge(Bus.layer)), CrossSpawnSpawner.defaultLayer),
+  Layer.mergeAll(Question.layer.pipe(Layer.provide(bus)), bus, CrossSpawnSpawner.defaultLayer),
 )
 
 const askEffect = Effect.fn("QuestionTest.ask")(function* (input: {
@@ -272,6 +273,45 @@ it.instance(
   { git: true },
 )
 
+it.instance(
+  "interrupt - publishes Rejected event so TUI orphans get dismissed",
+  () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const received: { sessionID: SessionID; requestID: QuestionID }[] = []
+      const off = yield* bus.subscribeCallback(Question.Event.Rejected, (evt) => {
+        received.push({ sessionID: evt.properties.sessionID, requestID: evt.properties.requestID })
+      })
+
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [{ label: "Option 1", description: "First option" }],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+      const requestID = pending[0].id
+
+      // Simulate the tool execution being interrupted before the user replies
+      // (session ended, parent killed, scope torn down, etc.).
+      yield* Fiber.interrupt(fiber)
+
+      // Wait briefly for finalizer to publish the synthetic Rejected event.
+      yield* Effect.sleep("10 millis")
+      off()
+
+      expect(received).toEqual([{ sessionID: SessionID.make("ses_test"), requestID }])
+      const after = yield* listEffect
+      expect(after.length).toBe(0)
+    }),
+  { git: true },
+)
+
 // multiple questions tests
 
 it.instance(