Collapse queue/steer into one mid-run gesture, add stop-and-reinject, and stop discarding queued input on interrupt

Plain Enter and Alt+Enter both waited for a turn boundary before delivering,
so an operator had two gestures with the same effect and no way to tell them
apart. Alt+Enter now hard-stops the run and restarts from the typed message
without waiting for a boundary; plain Enter always queues to steer at the
next boundary, and the transcript row says so plainly ([will steer next] /
[steering]) instead of leaving the operator to infer it from a badge count.

Interrupting used to discard every queued and steered message ("interrupt —
discarded N pending"). An operator who queued an instruction and then lost
patience was destroying the thing they were trying to deliver. Interrupt no
longer clears the queue; it reports what will steer the next run instead.

Verified live: Shift+Enter does insert a newline, but only on a terminal
that negotiates the kitty keyboard protocol (this app requests it); on a
plain terminal Enter and Shift+Enter send the same bare \r, so the chord is
silently a no-op there. Ctrl+Enter/Ctrl+J remain the newline chord that
works everywhere, and the shortcut list's existing wording already reflects
that condition rather than promising it unconditionally.

Both interrupt paths close the underlying agent, which cascades an abort
into any in-flight sub-agent dispatch (task-tool.ts forwards the parent's
operation signal into the child's own controller) — redirecting the parent
stops the fleet it dispatched too, not just its own turn. Documented in
docs/TUI.md.

Author: TheGreatAxios

docs/TUI.md

@@ -331,10 +331,51 @@ The prompt is a genuine multi-line composing area built on OpenTUI's
 `TextareaRenderable` rather than its single-line `InputRenderable`, because
 the single-line widget is hard-wired to one row, no wrapping, and strips
 newlines (`src/tui-opentui/prompt-input.ts`). Enter sends; a literal newline
-needs an explicit chord (Shift+Enter or Ctrl+Enter where the terminal reports
-the modifier via the kitty keyboard protocol, Ctrl+J everywhere else, since a
-plain terminal cannot report Shift+Enter at all). Alt+Enter is claimed by the
-shell before the textarea ever sees it, as the mid-run "steer" action.
+needs an explicit chord: Ctrl+Enter or Ctrl+J work on every terminal, and
+Shift+Enter works too on a terminal that negotiates the kitty keyboard
+protocol (this app requests it — `useKittyKeyboard` in `product-host.ts`) and
+reports the modifier back. A plain terminal sends the same bare `\r` for
+Enter and Shift+Enter, so on those Shift+Enter silently does nothing — driven
+live, this is exactly what happens, not a hypothetical. Ctrl+Enter/Ctrl+J are
+the chord to point an operator at when Shift+Enter doesn't respond.
+
+### Queue-and-steer vs. stop-and-reinject
+
+There used to be two gestures that both waited for a run to reach a turn
+boundary before delivering — a bug in its own right, since an operator had no
+way to tell them apart from the result. There are now two gestures with two
+different effects:
+
+- **Enter, mid-run** — queues the message and delivers it at the next turn
+  boundary, where it steers the run. The queued row in the transcript says
+  `[will steer next]` while pending and `[steering]` once delivered, so the
+  operator sees what will happen to it, not just a badge count
+  (`submitPrompt`, `drainAtBoundary` in `runtime-bridge.ts`).
+- **Alt+Enter, mid-run** — stops the run immediately, without waiting for a
+  boundary, and restarts from this message. A `stop — restarting from your
+  message` system row and a `[restarted here]` user row mark the cut. Idle,
+  or with an empty prompt, Alt+Enter does nothing — there is nothing to stop
+  or restart from.
+
+Interrupting (Ctrl+C) never discards a queued or steered message. It used to
+— the transcript literally said `interrupt — discarded N pending`, and an
+operator who queued an instruction and then lost patience destroyed the very
+thing they were trying to deliver. It now reports `interrupt — N queued
+message(s) will steer the next run`: the run stops, the queue survives, and
+those messages steer whatever run starts next (`interrupt` in
+`session-queue.ts` no longer clears `items`).
+
+**Sub-agent lanes on redirect.** Both Ctrl+C and Alt+Enter interrupt by
+closing the underlying agent (`runner.ts`'s `interrupt()` — "the only thing
+that aborts the reactor mid-inference"). That close cascades: it aborts the
+shared operation signal the `task` tool was given, which the tool forwards to
+the child agent's own controller, so an in-flight sub-agent dispatch is
+aborted along with the parent's turn and reports back as cancelled by the
+operator rather than being left to finish silently detached
+(`src/subagent/task-tool.ts`). Redirecting the parent — by either gesture —
+is a decision to stop the fleet it dispatched too, not just the parent's own
+turn; there is no path today to redirect the parent while leaving running
+lanes alone.
 
 Up/Down are caret motion first inside a multi-line buffer. History recall
 only fires when the caret is already at the first or last wrapped row of the
@@ -380,7 +421,8 @@ Ctrl+C interrupts a busy run (or clears a non-empty idle prompt); a second
 Ctrl+C within a 2-second window (`CTRL_C_EXIT_WINDOW_MS`) quits — this
 replaced an Ink-era yes/no exit-confirm modal with the same intent (an
 explicit second confirmation) without adding a modal (`handleCtrlC`,
-`shell.ts`).
+`shell.ts`). See "Queue-and-steer vs. stop-and-reinject" above for what
+interrupting does and does not discard, and what it does to sub-agent lanes.
 
 ## Overflows, scrolling, and key macros
 

src/tui-opentui/keybindings.test.ts

@@ -25,6 +25,7 @@ import { focusOwner } from "./focus/focus-state.js"
 import { setChromeZones } from "./shell.js"
 import {
   appendStreamRow,
+  applyShellInterrupt,
   createAppShell,
   isSlashPopupOpen,
   leaveSubagentObserve,
@@ -43,6 +44,7 @@ import {
   streamRowAt,
   streamRowCount,
   submitPrompt,
+  truncateStreamRows,
   type AppShell,
 } from "./shell.js"
 
@@ -265,7 +267,11 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
         press(h, chord)
         expect(shell.prompt.value).toBe("line\n")
       }
-      // The parenthetical in the row's description, held to the same standard.
+      // The parenthetical in the row's description, held to the same
+      // standard. Plain terminals can't report Shift on Enter (bare \r
+      // either way — confirmed live, not just assumed), but a terminal that
+      // negotiates the kitty keyboard protocol — which this app requests —
+      // can, and the widget is built to honor it when it does.
       expect(PROMPT_KEY_BINDINGS).toContainEqual({
         name: "return",
         shift: true,
@@ -440,13 +446,18 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
       setShellRunState(shell, "idle")
       shell.prompt.value = "not yet"
       press(h, chords[0])
-      // The stated condition: idle, Alt+Enter does nothing at all.
+      // The stated condition: idle, Alt+Enter does nothing — there's no run
+      // to stop and nothing to restart from a boundary that isn't coming.
       expect(sent).toEqual([])
       expect(shell.prompt.value).toBe("not yet")
 
+      // Busy: a distinct gesture from plain Enter (queue-and-steer at the
+      // next boundary) — this one is "reinject", resolved by the bridge to
+      // stop the run right now and restart from this message.
       setShellRunState(shell, "busy")
       press(h, chords[0])
-      expect(sent).toEqual([{ text: "not yet", kind: "steer" }])
+      expect(sent).toEqual([{ text: "not yet", kind: "reinject" }])
+      expect(shell.prompt.value).toBe("")
       setShellRunState(shell, "idle")
     },
   },
@@ -472,6 +483,26 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
       press(h, chords[0])
       expect(exited).toBe(1)
       setShellRunState(shell, "idle")
+
+      // Bridge-less local interrupt: what an operator sees when a message
+      // was queued and they lose patience — it must report the message
+      // will still steer, never that it was discarded.
+      clearShellBridgeHooks(shell)
+      setShellRunState(shell, "busy")
+      const rowsBefore = streamRowCount(shell)
+      shell.prompt.value = "keep me"
+      submitPrompt(shell, "queue")
+      applyShellInterrupt(shell)
+      expect(shell.pendingQueue).toBe(1)
+      expect(shell.session.items[0]!.text).toBe("keep me")
+      const notice = shell.streamLog[shell.streamLog.length - 1]
+      expect(notice?.text).toBe("interrupt — 1 queued message will steer the next run")
+      expect(notice?.text).not.toContain("discarded")
+      // Other probes in this group share one shell — leave both the queue
+      // and the transcript as this probe found them.
+      shell.session = { ...shell.session, items: [] }
+      truncateStreamRows(shell, rowsBefore)
+      setShellRunState(shell, "idle")
     },
   },
 

src/tui-opentui/keybindings.ts

@@ -20,8 +20,8 @@ export type ShellShortcut = {
 }
 
 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: "Enter", description: "queue the message to steer at the next turn boundary (badge); send straight through when idle" },
+  { keys: "Alt+Enter", description: "stop the run right now and restart from this message, without waiting for a 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+G", description: "cancel the most recently queued or steered message before it dispatches" },
   { keys: "Alt+C", description: "copy mode: pick a message, tool output, or diff; press again to close it" },

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

@@ -91,10 +91,12 @@ describe("attachSessionBridge", () => {
           await h.renderOnce()
           expect(port.calls.some((c) => c.op === "enqueue")).toBe(true)
           const enq = port.calls.find((c) => c.op === "enqueue")
+          // Plain Enter mid-run always steers now — "queue and wait quietly"
+          // isn't a separate gesture from "queue to steer" anymore.
           expect(enq).toEqual({
             op: "enqueue",
             text: "queued please",
-            kind: "queue",
+            kind: "steer",
           })
           expect(badgeCount(shell.session)).toBe(1)
           expect(shell.pendingQueue).toBe(1)
@@ -109,7 +111,7 @@ describe("attachSessionBridge", () => {
     )
   })
 
-  test("Alt+Enter mid-run hits port.enqueue steer", async () => {
+  test("Alt+Enter mid-run hard-stops and reinjects, not a boundary wait", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
@@ -121,15 +123,16 @@ describe("attachSessionBridge", () => {
         const bridge = attachSessionBridge(shell, port)
         try {
           // Direct bridge path (Alt+Enter chord is terminal-dependent in mock).
-          bridge.submit("steer now", "steer")
+          bridge.submit("stop now", "reinject")
           await h.renderOnce()
-          const enq = port.calls.find((c) => c.op === "enqueue")
-          expect(enq).toEqual({
-            op: "enqueue",
-            text: "steer now",
-            kind: "steer",
-          })
-          expect(badgeCount(shell.session)).toBe(1)
+          // No enqueue at all — this never waits for a boundary. It
+          // interrupts the live run, then sends straight through.
+          expect(port.calls.some((c) => c.op === "enqueue")).toBe(false)
+          expect(port.calls.map((c) => c.op)).toEqual(["interrupt", "sendImmediate"])
+          const sent = port.calls.find((c) => c.op === "sendImmediate")
+          expect(sent).toEqual({ op: "sendImmediate", text: "stop now" })
+          expect(shell.session.run).toBe("busy")
+          expect(badgeCount(shell.session)).toBe(0)
         } finally {
           bridge.dispose()
           shell.dispose()
@@ -139,7 +142,7 @@ describe("attachSessionBridge", () => {
     )
   })
 
-  test("Ctrl+C hits port.interrupt and clears pending", async () => {
+  test("Ctrl+C hits port.interrupt and preserves pending to steer next", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
@@ -157,7 +160,9 @@ describe("attachSessionBridge", () => {
           h.pressKey("c", { ctrl: true })
           await h.renderOnce()
           expect(port.calls.some((c) => c.op === "interrupt")).toBe(true)
-          expect(badgeCount(shell.session)).toBe(0)
+          // The fix this test now guards: interrupting must never destroy
+          // what was queued — it survives to steer whatever run comes next.
+          expect(badgeCount(shell.session)).toBe(2)
           expect(shell.session.interruptFlash).toBe(true)
           expect(shell.session.run).toBe("idle")
         } finally {

src/tui-opentui/runtime-bridge.ts

@@ -11,6 +11,7 @@ import {
   drainOne,
   enqueue,
   enqueueSteer,
+  interrupt,
   setRunState,
   type QueueItem,
   type QueueKind,
@@ -158,7 +159,7 @@ export type SessionBridge = {
   /** Operator paths — shell keys go through the same logic via exclusive hooks. */
   submit: (
     text: string,
-    kind: "queue" | "steer" | "immediate",
+    kind: "queue" | "steer" | "immediate" | "reinject",
     attachments?: readonly PendingImageAttachment[],
   ) => void
   interrupt: () => void
@@ -624,7 +625,9 @@ function drainAtBoundary(shell: AppShell, bag: BridgeBag): void {
     appendStreamRow(shell, {
       role: "user",
       text: userRowText(item.text, item.attachments ?? []),
-      meta: item.kind === "steer" ? "steer" : "queued",
+      // Distinct from the "steer" tag on the still-pending row above — this
+      // one is being handed to the run right now, not waiting for one.
+      meta: "steering",
     })
     bag.pendingEchoes.push(item.text.trim())
     bag.port.deliver(item)
@@ -901,16 +904,37 @@ export function attachSessionBridge(
 
   const submit = (
     text: string,
-    kind: "queue" | "steer" | "immediate",
+    kind: "queue" | "steer" | "immediate" | "reinject",
     attachments?: readonly PendingImageAttachment[],
   ): void => {
     if (bag.disposed) return
     const t = text.trim()
     const attached = attachments ?? []
     if (t.length === 0 && attached.length === 0) return
 
-    if (kind === "immediate" || shell.session.run === "idle") {
-      appendStreamRow(shell, { role: "user", text: userRowText(t, attached) })
+    if (kind === "reinject") {
+      // Not a boundary wait: stop the run right now, then fall straight into
+      // the immediate-send branch below with this message as the opener.
+      if (shell.session.run !== "busy") return
+      closeOpenRow(shell, bag)
+      bag.pendingEchoes.length = 0
+      shell.session = interrupt(shell.session)
+      appendStreamRow(shell, {
+        role: "system",
+        text: "stop — restarting from your message",
+        meta: "stop",
+      })
+      bag.port.interrupt()
+      bag.lastSentMessage = ""
+      bag.turn = turnStateOnInterrupt(bag.turn, now())
+    }
+
+    if (kind === "immediate" || kind === "reinject" || shell.session.run === "idle") {
+      appendStreamRow(shell, {
+        role: "user",
+        text: userRowText(t, attached),
+        ...(kind === "reinject" ? { meta: "reinject" } : {}),
+      })
       bag.pendingEchoes.push(t)
       bag.port.sendImmediate(t, attachments)
       shell.session = setRunState(shell.session, "busy")

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

@@ -52,12 +52,15 @@ describe("session-queue", () => {
     expect(d3.item?.text).toBe("q1")
   })
 
-  test("Ctrl+C interrupt clears pending + sets flash + idle", () => {
+  test("Ctrl+C interrupt sets flash + idle, and never discards pending items", () => {
     let s = createSessionQueue("busy")
     s = enqueue(s, "a")
     s = enqueueSteer(s, "b")
     s = interrupt(s)
-    expect(badgeCount(s)).toBe(0)
+    // The operator's whole complaint: interrupting used to destroy exactly
+    // what they queued. It must survive, so it can steer the next run.
+    expect(badgeCount(s)).toBe(2)
+    expect(s.items.map((i) => i.text)).toEqual(["a", "b"])
     expect(s.interruptFlash).toBe(true)
     expect(s.run).toBe("idle")
     s = clearInterruptFlash(s)

src/tui-opentui/session-queue.ts

@@ -93,15 +93,15 @@ export function enqueueSteer(
 }
 
 /**
- * Hard interrupt: discard all pending queue + steer, clear flash flag set,
- * force run to idle (caller re-sets busy when a new run starts).
+ * Hard interrupt: stop the run and set the flash flag. Queued/steered items
+ * are preserved — an operator who queued a message and then interrupted must
+ * never lose it; the items steer whichever run picks them up next.
  */
 export function interrupt(state: SessionQueueState): SessionQueueState {
   return {
+    ...state,
     run: "idle",
-    items: [],
     interruptFlash: true,
-    nextId: state.nextId,
   }
 }
 

src/tui-opentui/shell.test.ts

@@ -448,7 +448,7 @@ describe("product skin: stream + queue + overlay", () => {
     )
   })
 
-  test("Ctrl+C interrupt clears pending + flash", async () => {
+  test("Ctrl+C interrupt sets flash, and preserves pending to steer next", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
@@ -463,14 +463,18 @@ describe("product skin: stream + queue + overlay", () => {
           submitPrompt(shell, "steer")
           expect(shell.pendingQueue).toBe(2)
           interruptShell(shell)
-          expect(shell.pendingQueue).toBe(0)
+          // The bug this guards: interrupting must never discard what was
+          // queued — it stays queued to steer whatever run comes next.
+          expect(shell.pendingQueue).toBe(2)
           expect(shell.session.interruptFlash).toBe(true)
           expect(shell.session.run).toBe("idle")
           await h.renderOnce()
+          const interruptRow = shell.streamLog[shell.streamLog.length - 1]
+          expect(interruptRow?.text).toBe(
+            "interrupt — 2 queued messages will steer the next run",
+          )
           const row = noticeRow(h.captureCharFrame())
           expect(row).toContain("interrupt")
-          // An empty queue is the default state, so it stays off the row.
-          expect(row).not.toContain("queue")
         } finally {
           shell.dispose()
         }