Settle run state on inference.done too, and drop cancel from this PR

Review found that draining the queue on inference.done was not enough:
run stayed busy until connector.reply, and a workflow/goal-governor
cycle that keeps self-continuing may never emit one. Every future Enter
then resolved to "queue" against a session nothing will ever drain
again. Settle run the same way connector.reply already does -- once
inference.done lands with no tool calls still outstanding -- using the
turn state the bridge already tracks, so no new event type is needed.

Also reverts the tool.boundary addition to inference.done entirely:
settling (or draining, when tools are still outstanding) from
runtime-bridge's own handle() covers both cases without overloading an
event that elsewhere means "a tool call finished."

Cancel-last (Ctrl+X) is pulled out of this PR -- it is a separate
feature with its own defect (the transcript row it left behind never
reflected the cancellation) and belongs in its own change, landed once
that is fixed and covered.

Author: TheGreatAxios

src/tui-opentui/keybindings.test.ts

@@ -439,7 +439,6 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
         onInterrupt: () => {
           interrupted++
         },
-        onCancelLast: () => {},
         exclusive: true,
       })
       setShellExitHandler(shell, () => {
@@ -455,23 +454,6 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
     },
   },
 
-  "Ctrl+X": {
-    group: "session",
-    probe: ({ h, shell, chords }) => {
-      let cancelled = 0
-      setShellBridgeHooks(shell, {
-        onSubmit: () => {},
-        onInterrupt: () => {},
-        onCancelLast: () => {
-          cancelled++
-        },
-        exclusive: true,
-      })
-      press(h, chords[0])
-      expect(cancelled).toBe(1)
-    },
-  },
-
   "Ctrl+D": {
     group: "host",
     // Probed on a mounted host rather than a bare shell: the row claims a
@@ -554,7 +536,6 @@ function recordSubmits(
   setShellBridgeHooks(shell, {
     onSubmit: (text, kind) => sent.push({ text, kind }),
     onInterrupt: () => {},
-        onCancelLast: () => {},
     exclusive: true,
   })
   return sent

src/tui-opentui/keybindings.ts

@@ -23,7 +23,6 @@ export const SHELL_SHORTCUTS: readonly ShellShortcut[] = [
   { keys: "Enter", description: "queue the message mid-run (badge); send straight through when idle" },
   { keys: "Alt+Enter", description: "steer at the next tool boundary; does nothing unless a run is busy" },
   { keys: "Ctrl+C", description: "interrupt the run, or clear the prompt when idle; press twice to exit" },
-  { keys: "Ctrl+X", description: "cancel the most recently queued message, if any" },
   { keys: "Ctrl+O", description: "open the command palette; press again to close it" },
   { keys: "Alt+C", description: "copy mode: pick a message, tool output, or diff; press again to close it" },
   { keys: "Alt+M", description: "take the mouse for click-to-expand and drag-scroll; off by default so drag-select and copy work" },

src/tui-opentui/prompt-chrome.test.ts

@@ -45,7 +45,6 @@ describe("bare exit / quit at the prompt", () => {
         setShellBridgeHooks(shell, {
           onSubmit: (text) => sent.push(text),
           onInterrupt: () => {},
-        onCancelLast: () => {},
           exclusive: true,
         })
         setShellExitHandler(shell, () => {
@@ -67,7 +66,6 @@ describe("bare exit / quit at the prompt", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (text) => sent.push(text),
         onInterrupt: () => {},
-        onCancelLast: () => {},
         exclusive: true,
       })
       setShellExitHandler(shell, () => {
@@ -86,7 +84,6 @@ describe("bare exit / quit at the prompt", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (text) => sent.push(text),
         onInterrupt: () => {},
-        onCancelLast: () => {},
         exclusive: true,
       })
       shell.prompt.value = "exit"

src/tui-opentui/prompt-features.test.ts

@@ -146,7 +146,6 @@ describe("image attachments", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (_text, _kind, attachments) => seen.push(attachments),
         onInterrupt: () => {},
-        onCancelLast: () => {},
         exclusive: true,
       })
       setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }))
@@ -165,7 +164,6 @@ describe("image attachments", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (text) => texts.push(text),
         onInterrupt: () => {},
-        onCancelLast: () => {},
         exclusive: true,
       })
       setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }))
@@ -197,7 +195,6 @@ describe("text paste", () => {
             setShellBridgeHooks(shell, {
               onSubmit: (text) => submitted.push(text),
               onInterrupt: () => {},
-        onCancelLast: () => {},
               exclusive: true,
             })
             setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }))
@@ -286,7 +283,6 @@ describe("sent-message recall", () => {
       setShellBridgeHooks(shell, {
         onSubmit: () => {},
         onInterrupt: () => {},
-        onCancelLast: () => {},
         exclusive: true,
       })
       shell.prompt.value = "remember me"

src/tui-opentui/runtime-bridge.test.ts

@@ -255,6 +255,71 @@ describe("attachSessionBridge", () => {
     )
   })
 
+  test("run returns to idle after a tool-less inference.done, with no connector.reply", async () => {
+    // Regression: a goal-governor / workflow cycle that keeps self-continuing
+    // may never emit connector.reply, the only other event that clears
+    // `run`. Without this, every future Enter resolves to "queue" (busy is
+    // sticky) and, once the workflow stops producing cycles, that queued
+    // message is never drained — CL-5563's bug moved one layer over.
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "busy",
+        })
+        const port = createRecordingPort()
+        const bridge = attachSessionBridge(shell, port)
+        try {
+          bridge.handle({ type: "inference.start" })
+          bridge.handle({
+            type: "inference.text.delta",
+            data: { token: "hi" },
+          })
+          bridge.handle({ type: "inference.done" })
+          expect(shell.session.run).toBe("idle")
+
+          port.clear()
+          bridge.submit("are you still there", "queue")
+          expect(port.calls).toEqual([
+            { op: "sendImmediate", text: "are you still there" },
+          ])
+        } finally {
+          bridge.dispose()
+          shell.dispose()
+        }
+      },
+      { width: 80, height: 24 },
+    )
+  })
+
+  test("run stays busy after inference.done while a tool call is still outstanding", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "busy",
+        })
+        const port = createRecordingPort()
+        const bridge = attachSessionBridge(shell, port)
+        try {
+          bridge.handle({ type: "inference.start" })
+          bridge.handle({
+            type: "inference.tool_call.start",
+            data: { call: { id: "c1", name: "bash" } },
+          })
+          bridge.handle({ type: "inference.done" })
+          expect(shell.session.run).toBe("busy")
+        } finally {
+          bridge.dispose()
+          shell.dispose()
+        }
+      },
+      { width: 80, height: 24 },
+    )
+  })
+
   test("token-by-token deltas grow one assistant row", async () => {
     await withTestRenderer(
       async (h) => {

src/tui-opentui/runtime-bridge.ts

@@ -17,7 +17,6 @@ import {
 } from "./session-queue.js"
 import {
   appendStreamRow,
-  applyShellCancelLast,
   applyShellInterrupt,
   clearShellBridgeHooks,
   paintChrome,
@@ -765,6 +764,19 @@ export function attachSessionBridge(
       )) {
         applyInbound(shell, bag, mapped)
       }
+      // inference.done is the only turn boundary every reactor cycle
+      // guarantees — reactor.done fires once, at shutdown, and a
+      // workflow/goal-governor cycle that keeps self-continuing may never
+      // emit the connector.reply `settled` depends on. Settling here too
+      // (once no tool calls are still outstanding, the same criterion
+      // connector.reply itself uses) means a queued message — or the next
+      // Enter — is never left waiting on an event that might not come
+      // again. When tools are still outstanding the turn continues, so only
+      // the drain runs; run state is untouched.
+      if (event.type === "inference.done") {
+        if (bag.turn.activeToolCalls.length === 0) settleRun()
+        else drainAtBoundary(shell, bag)
+      }
       if (settled) settleRun()
       return
     }
@@ -825,11 +837,6 @@ export function attachSessionBridge(
     paintPhase()
   }
 
-  const doCancelLast = (): void => {
-    if (bag.disposed) return
-    applyShellCancelLast(shell)
-  }
-
   const tick = (): void => {
     if (bag.disposed) return
     const nowMs = now()
@@ -893,7 +900,6 @@ export function attachSessionBridge(
     onInterrupt: () => {
       doInterrupt()
     },
-    onCancelLast: doCancelLast,
     exclusive: true,
   })
 

src/tui-opentui/session-queue.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import {
   badgeCount,
-  cancelLast,
   clearInterruptFlash,
   createSessionQueue,
   drainOne,
@@ -52,25 +51,6 @@ describe("session-queue", () => {
     expect(d3.item?.text).toBe("q1")
   })
 
-  test("cancelLast retracts the most recently queued item, not necessarily the drain-order head", () => {
-    let s = createSessionQueue("busy")
-    s = enqueue(s, "q1")
-    s = enqueueSteer(s, "s1")
-    const c1 = cancelLast(s)
-    expect(c1.item?.text).toBe("s1")
-    expect(badgeCount(c1.state)).toBe(1)
-    const c2 = cancelLast(c1.state)
-    expect(c2.item?.text).toBe("q1")
-    expect(badgeCount(c2.state)).toBe(0)
-  })
-
-  test("cancelLast on an empty queue is a no-op", () => {
-    const s = createSessionQueue("busy")
-    const c = cancelLast(s)
-    expect(c.item).toBeNull()
-    expect(c.state).toBe(s)
-  })
-
   test("Ctrl+C interrupt clears pending + sets flash + idle", () => {
     let s = createSessionQueue("busy")
     s = enqueue(s, "a")

src/tui-opentui/session-queue.ts

@@ -121,21 +121,6 @@ export function drainOrder(
   return [...steers, ...queues]
 }
 
-/**
- * Cancel the most recently queued item (undo-last), so an operator who
- * queued the wrong message can retract it before it dispatches.
- */
-export function cancelLast(
-  state: SessionQueueState,
-): { state: SessionQueueState; item: QueueItem | null } {
-  const item = state.items[state.items.length - 1] ?? null
-  if (!item) return { state, item: null }
-  return {
-    state: { ...state, items: state.items.slice(0, -1) },
-    item,
-  }
-}
-
 /** Pop next delivery item (steer-first). */
 export function drainOne(
   state: SessionQueueState,

src/tui-opentui/shell.ts

@@ -153,7 +153,6 @@ import {
 } from "./copy-path.js"
 import {
   badgeCount,
-  cancelLast,
   clearInterruptFlash,
   createSessionQueue,
   enqueue,
@@ -228,8 +227,6 @@ export type ShellBridgeHooks = {
     attachments?: readonly PendingImageAttachment[],
   ) => void
   onInterrupt: () => void
-  /** Cancel the most recently queued item; a no-op if the queue is empty. */
-  onCancelLast: () => void
   exclusive: boolean
 }
 
@@ -2661,25 +2658,6 @@ export function interruptShell(shell: AppShell): void {
   applyShellInterrupt(shell)
 }
 
-/** Local cancel-last mutation (no bridge re-entry). */
-export function applyShellCancelLast(shell: AppShell): void {
-  const { state, item } = cancelLast(shell.session)
-  if (!item) return
-  shell.session = state
-  setStatusFlash(shell, `cancelled queued message: ${item.text || "(no text)"}`)
-  paintChrome(shell)
-}
-
-/** Ctrl+X: cancel the most recently queued message, if any. */
-export function cancelLastQueued(shell: AppShell): void {
-  const hooks = getShellBridgeHooks(shell)
-  if (hooks?.exclusive) {
-    hooks.onCancelLast()
-    return
-  }
-  applyShellCancelLast(shell)
-}
-
 export function clearShellInterruptFlash(shell: AppShell): void {
   shell.session = clearInterruptFlash(shell.session)
   paintChrome(shell)
@@ -4917,12 +4895,6 @@ export function createAppShell(
       return
     }
 
-    if (key.ctrl && key.name === "x") {
-      key.preventDefault()
-      cancelLastQueued(shell)
-      return
-    }
-
     if (
       (key.name === "return" || key.name === "enter") &&
       (key.meta || key.option) &&

src/tui-opentui/stream-event-map.ts

@@ -310,11 +310,8 @@ function mapEvent(
 
     case "inference.done":
       // Cycle settled: disarm so a pre-commit retry belonging to the *next*
-      // cycle cannot retract this one's rows. inference.done is the only
-      // turn boundary the reactor guarantees per cycle (reactor.done fires
-      // once, at agent shutdown, never between turns) — drain the mid-run
-      // queue here so a text-only reply doesn't strand queued messages.
-      return [...disarmAttempt(ctx), { type: "tool.boundary" }]
+      // cycle cannot retract this one's rows.
+      return disarmAttempt(ctx)
 
     case "inference.retry": {
       const armed = ctx?.attemptArmed === true