fix(tui): let Ctrl+C stop the run while an approval prompt is open

A permission or operator prompt holds every key until it is answered,
so Ctrl+C never reached the interrupt while one was open. Now that
every parked approval reaches the operator, a run that keeps issuing
tool calls after a rejection can raise prompts faster than they can be
answered, which left no way to stop it short of killing the process.

Inside a decision prompt, Ctrl+C now declines the prompt the way Esc
does and then interrupts the turn. It interrupts whether or not the
shell reads as busy, since a turn started by a delivered message can
park without a composer send marking it. The interrupt bumps the
delivery generation that queued main-session prompts listen to, so
they drop instead of taking over the prompt. Esc keeps its meaning of
declining only the open prompt.

Bridge tests press the keys into wired gates: Ctrl+C on a permission
prompt, with the shell busy and idle; queued prompts dropping on the
identity abort; Ctrl+C on an operator question; and Esc declining
without interrupting.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: bwachman

src/tui/runtime-bridge.test.ts

@@ -24,10 +24,10 @@ import { streamRowCount } from "./shell/transcript";
 import { STEER_WAIT_NOTICE_MS } from "./notice-line";
 import type { Harness } from "./harness";
 import { withAppShell } from "./test-helpers";
-import { wireGates } from "./gate-wire.js";
+import { operatorCancelResult, wireGates } from "./gate-wire.js";
 import { acceptOverlaySelection } from "./shell/overlay-host.js";
 import { moveOverlaySelection } from "./shell/overlay-list.js";
-import { badgeCount } from "./delivery-queue";
+import { badgeCount, SESSION_IDENTITY_ABORT_REASON } from "./delivery-queue";
 import { LIVE_ACTIVITY_WORDS } from "./chrome-state";
 
 type RecordingPort = ReturnType<typeof createRecordingPort>;
@@ -1046,6 +1046,137 @@ describe("parallel sub-agent dispatch on the live session bridge", () => {
   });
 });
 
+describe("Ctrl+C on a decision gate", () => {
+  const shellRequest = (subject: string): PermissionRequest => ({
+    tool: "run_shell",
+    action: "Run shell command",
+    subject,
+    scopes: [],
+  });
+
+  function emitPermissionGate(
+    emitter: EventEmitter,
+    id: string,
+    signal?: AbortSignal,
+  ) {
+    let outcome: unknown;
+    emitter.emit("permission.gate", {
+      id,
+      request: shellRequest(`touch ${id}`),
+      resolve: (value: unknown) => {
+        outcome = value;
+      },
+      ...(signal !== undefined ? { signal } : {}),
+    });
+    return () => outcome;
+  }
+
+  test("declines the open permission gate and interrupts the turn", async () => {
+    await withBridge(
+      { run: "busy", wireKeys: true, gates: true },
+      async ({ h, shell, port, emitter }) => {
+        const outcome = emitPermissionGate(emitter, "req-1");
+        expect(shell.overlayKind).toBe("permissions");
+        port.clear();
+
+        h.pressKey("c", { ctrl: true });
+        await h.renderOnce();
+
+        expect(outcome()).toEqual({ allow: false });
+        expect(port.calls.some((c) => c.op === "interrupt")).toBe(true);
+        expect(shell.overlayList).toBeNull();
+      },
+    );
+  });
+
+  test("interrupts even when the shell does not read as busy", async () => {
+    // A turn started by a delivered message (a background shell exit, a
+    // worker wake) can park on a gate without a composer send marking busy.
+    await withBridge(
+      { run: "idle", wireKeys: true, gates: true },
+      async ({ h, port, emitter }) => {
+        const outcome = emitPermissionGate(emitter, "req-1");
+        port.clear();
+
+        h.pressKey("c", { ctrl: true });
+        await h.renderOnce();
+
+        expect(outcome()).toEqual({ allow: false });
+        expect(port.calls.some((c) => c.op === "interrupt")).toBe(true);
+      },
+    );
+  });
+
+  test("queued gates drop with the interrupt instead of taking over the prompt", async () => {
+    await withBridge(
+      { run: "busy", wireKeys: true, gates: true },
+      async ({ h, shell, port, emitter }) => {
+        // Production gates share the session identity signal, which the
+        // interrupt's delivery-generation bump aborts.
+        const identity = new AbortController();
+        const first = emitPermissionGate(emitter, "req-1", identity.signal);
+        const queued = emitPermissionGate(emitter, "req-2", identity.signal);
+        port.clear();
+
+        h.pressKey("c", { ctrl: true });
+        await h.renderOnce();
+        expect(first()).toEqual({ allow: false });
+        expect(port.calls.some((c) => c.op === "interrupt")).toBe(true);
+
+        identity.abort(SESSION_IDENTITY_ABORT_REASON);
+        await h.renderOnce();
+        expect(queued()).toEqual({
+          allow: false,
+          message: SESSION_IDENTITY_ABORT_REASON,
+        });
+        expect(shell.overlayList).toBeNull();
+      },
+    );
+  });
+
+  test("declines an open operator question and interrupts the turn", async () => {
+    await withBridge(
+      { run: "busy", wireKeys: true, gates: true },
+      async ({ h, port, emitter }) => {
+        let outcome: unknown;
+        emitter.emit("operator.gate", {
+          id: "ask-1",
+          question: "Proceed?",
+          options: ["Cancel", "Continue"],
+          resolve: (value: unknown) => {
+            outcome = value;
+          },
+        });
+        port.clear();
+
+        h.pressKey("c", { ctrl: true });
+        await h.renderOnce();
+
+        expect(outcome).toEqual(operatorCancelResult());
+        expect(port.calls.some((c) => c.op === "interrupt")).toBe(true);
+      },
+    );
+  });
+
+  test("Esc still declines only the open gate and leaves the turn running", async () => {
+    await withBridge(
+      { run: "busy", wireKeys: true, gates: true },
+      async ({ h, port, emitter }) => {
+        const outcome = emitPermissionGate(emitter, "req-1");
+        port.clear();
+
+        // ESC needs a disambiguation delay on the mock stdin path.
+        h.pressKey("Escape");
+        await new Promise((r) => setTimeout(r, 60));
+        await h.renderOnce();
+
+        expect(outcome()).toEqual({ allow: false });
+        expect(port.calls.some((c) => c.op === "interrupt")).toBe(false);
+      },
+    );
+  });
+});
+
 describe("calls parked on an approval gate", () => {
   type Event = { type: string; data?: unknown };
 

src/tui/shell/keys.ts

@@ -152,6 +152,13 @@ function toggleCloseOpenSurface(shell: AppShell, key: KeyEvent): boolean {
   return true;
 }
 
+/** Permission and operator gates: the overlays that hold every key. */
+function isDecisionGate(shell: AppShell): boolean {
+  return (
+    shell.overlayKind === "permissions" || shell.overlayKind === "operator"
+  );
+}
+
 /** Window in which a second Ctrl+C is read as "yes, quit". */
 export const CTRL_C_EXIT_WINDOW_MS = 2000;
 
@@ -343,6 +350,17 @@ export function createShellKeyHandlers(
     }
 
     if (shell.overlayList) {
+      // A decision gate keeps every key until it is answered, and a run that
+      // keeps raising gates (each rejection re-infers into more calls) would
+      // then leave the stop key unreachable. Ctrl+C declines the open gate the
+      // way Esc does, then interrupts the turn, which drops queued gates too.
+      if (key.ctrl && key.name === "c" && isDecisionGate(shell)) {
+        key.preventDefault();
+        abortOverlayHostReservations(shell);
+        closeInsetOverlay(shell);
+        interruptShell(shell);
+        return;
+      }
       // Checked ahead of the filter handlers: an opener chord pressed again is
       // a request to close, not a character to narrow the list with.
       if (toggleCloseOpenSurface(shell, key)) {