Drain the mid-run queue on inference.done, not reactor.done

reactor.done only fires once, at agent shutdown, never between turns,
so a plain-text reply with no tool calls left queued messages stranded
forever (reproduced in the tool-less-turn regression test). inference.done
fires on every reactor cycle regardless of what the director does next,
so it also covers goal-governor and workflow continuations that never
produce a settled connector.reply.

Also replace the internal-state readout ("queue +1 -> pending N", the
"queue" meta label repeated on the same row) with the queued message's
own text and attachments, and add Ctrl+X to cancel the most recently
queued item before it dispatches.

Author: TheGreatAxios

src/tui-opentui/keybindings.test.ts

@@ -439,6 +439,7 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
         onInterrupt: () => {
           interrupted++
         },
+        onCancelLast: () => {},
         exclusive: true,
       })
       setShellExitHandler(shell, () => {
@@ -454,6 +455,23 @@ 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
@@ -536,6 +554,7 @@ function recordSubmits(
   setShellBridgeHooks(shell, {
     onSubmit: (text, kind) => sent.push({ text, kind }),
     onInterrupt: () => {},
+        onCancelLast: () => {},
     exclusive: true,
   })
   return sent

src/tui-opentui/keybindings.ts

@@ -23,6 +23,7 @@ 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,6 +45,7 @@ describe("bare exit / quit at the prompt", () => {
         setShellBridgeHooks(shell, {
           onSubmit: (text) => sent.push(text),
           onInterrupt: () => {},
+        onCancelLast: () => {},
           exclusive: true,
         })
         setShellExitHandler(shell, () => {
@@ -66,6 +67,7 @@ describe("bare exit / quit at the prompt", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (text) => sent.push(text),
         onInterrupt: () => {},
+        onCancelLast: () => {},
         exclusive: true,
       })
       setShellExitHandler(shell, () => {
@@ -84,6 +86,7 @@ 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,6 +146,7 @@ describe("image attachments", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (_text, _kind, attachments) => seen.push(attachments),
         onInterrupt: () => {},
+        onCancelLast: () => {},
         exclusive: true,
       })
       setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }))
@@ -164,6 +165,7 @@ describe("image attachments", () => {
       setShellBridgeHooks(shell, {
         onSubmit: (text) => texts.push(text),
         onInterrupt: () => {},
+        onCancelLast: () => {},
         exclusive: true,
       })
       setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }))
@@ -195,6 +197,7 @@ describe("text paste", () => {
             setShellBridgeHooks(shell, {
               onSubmit: (text) => submitted.push(text),
               onInterrupt: () => {},
+        onCancelLast: () => {},
               exclusive: true,
             })
             setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }))
@@ -283,6 +286,7 @@ describe("sent-message recall", () => {
       setShellBridgeHooks(shell, {
         onSubmit: () => {},
         onInterrupt: () => {},
+        onCancelLast: () => {},
         exclusive: true,
       })
       shell.prompt.value = "remember me"

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

@@ -214,6 +214,47 @@ describe("attachSessionBridge", () => {
     )
   })
 
+  test("queued item delivers on a tool-less turn (inference.done, no tool calls)", async () => {
+    // Regression for CL-5563: reactor.done only fires once, at agent
+    // shutdown, never between turns — a plain-text reply with no tool calls
+    // must still drain the queue, or a queued message sits forever.
+    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.submit("follow up", "queue")
+          expect(badgeCount(shell.session)).toBe(1)
+          port.clear()
+          bridge.handle({ type: "inference.start" })
+          bridge.handle({
+            type: "inference.text.delta",
+            data: { token: "hi" },
+          })
+          bridge.handle({ type: "inference.done" })
+          expect(badgeCount(shell.session)).toBe(0)
+          const deliver = port.calls.find((c) => c.op === "deliver")
+          expect(deliver).toEqual({
+            op: "deliver",
+            item: expect.objectContaining({
+              text: "follow up",
+              kind: "queue",
+            }),
+          })
+        } 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,6 +17,7 @@ import {
 } from "./session-queue.js"
 import {
   appendStreamRow,
+  applyShellCancelLast,
   applyShellInterrupt,
   clearShellBridgeHooks,
   paintChrome,
@@ -800,10 +801,13 @@ export function attachSessionBridge(
         ? enqueueSteer(shell.session, t, undefined, attachments)
         : enqueue(shell.session, t, "queue", undefined, attachments)
     bag.port.enqueue(t, kind)
+    // Show the message itself, not the internal transition ("queue +1 →
+    // pending N") — the notice row already carries the depth once, in plain
+    // language, so this row's job is making the pending item identifiable.
     appendStreamRow(shell, {
-      role: "system",
-      text: `${kind} +1 → pending ${badgeCount(shell.session)}`,
-      meta: "queue",
+      role: "user",
+      text: userRowText(t, attached),
+      meta: kind === "steer" ? "steer" : "queue",
     })
     paintChrome(shell)
   }
@@ -821,6 +825,11 @@ export function attachSessionBridge(
     paintPhase()
   }
 
+  const doCancelLast = (): void => {
+    if (bag.disposed) return
+    applyShellCancelLast(shell)
+  }
+
   const tick = (): void => {
     if (bag.disposed) return
     const nowMs = now()
@@ -884,6 +893,7 @@ export function attachSessionBridge(
     onInterrupt: () => {
       doInterrupt()
     },
+    onCancelLast: doCancelLast,
     exclusive: true,
   })
 

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import {
   badgeCount,
+  cancelLast,
   clearInterruptFlash,
   createSessionQueue,
   drainOne,
@@ -51,6 +52,25 @@ 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,6 +121,21 @@ 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

@@ -32,6 +32,7 @@ import { stringWidth } from "../tui/view/height.js"
 import { listPathSuggestions } from "../tui/components/at-mention/list.js"
 import { parseAtState } from "../tui/components/at-mention/parse.js"
 import {
+  formatAttachmentSummary,
   readClipboardImage,
   type ClipboardImageResult,
   type PendingImageAttachment,
@@ -152,6 +153,7 @@ import {
 } from "./copy-path.js"
 import {
   badgeCount,
+  cancelLast,
   clearInterruptFlash,
   createSessionQueue,
   enqueue,
@@ -226,6 +228,8 @@ 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
 }
 
@@ -2568,6 +2572,16 @@ export function setShellRunState(shell: AppShell, run: RunState): void {
   paintChrome(shell)
 }
 
+/** Transcript echo for a user message, annotated with its attachments. */
+function userRowText(
+  text: string,
+  attachments: readonly PendingImageAttachment[],
+): string {
+  const summary = formatAttachmentSummary(attachments)
+  if (summary.length === 0) return text
+  return text.length === 0 ? `[${summary}]` : `${text}\n[${summary}]`
+}
+
 /** Submit prompt as queue (busy) or immediate user send (idle). */
 export function submitPrompt(
   shell: AppShell,
@@ -2608,14 +2622,18 @@ export function submitPrompt(
   }
 
   shell.session =
-    kind === "steer" ? enqueueSteer(shell.session, t) : enqueue(shell.session, t)
+    kind === "steer"
+      ? enqueueSteer(shell.session, t, undefined, attachments)
+      : enqueue(shell.session, t, "queue", undefined, attachments)
   shell.prompt.value = ""
   clearPendingAttachments(shell)
-  const tag = kind === "steer" ? "steer" : "queue"
+  // Show the message itself, not the internal transition ("queue +1 →
+  // pending N") — the notice row already carries the depth once, in plain
+  // language, so this row's job is making the pending item identifiable.
   appendStreamRow(shell, {
-    role: "system",
-    text: `${tag} +1 → pending ${badgeCount(shell.session)}`,
-    meta: "queue",
+    role: "user",
+    text: userRowText(t, attachments),
+    meta: kind === "steer" ? "steer" : "queue",
   })
   paintChrome(shell)
 }
@@ -2643,6 +2661,25 @@ 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)
@@ -4880,6 +4917,12 @@ 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,8 +310,11 @@ function mapEvent(
 
     case "inference.done":
       // Cycle settled: disarm so a pre-commit retry belonging to the *next*
-      // cycle cannot retract this one's rows.
-      return disarmAttempt(ctx)
+      // 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" }]
 
     case "inference.retry": {
       const armed = ctx?.attemptArmed === true