Keep cancellation a flag, not a text rewrite, and prove it on screen

paintStreamRow now owns turning a cancelled user row into the
"[cancelled]" prefix, reading a new cancelled flag on StreamRow.
row.text stays exactly what the operator typed, so copy-mode and
anything else reading it back are unaffected by the cancel.

Regression tests now assert on captureCharFrame() before and after a
cancel, not only on shell.streamLog, and cover a steer-kind cancel
alongside queue in session-queue.test.ts, shell.test.ts and
keybindings.test.ts.

Author: TheGreatAxios

src/tui-opentui/keybindings.test.ts

@@ -458,7 +458,7 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
 
   "Ctrl+G": {
     group: "session",
-    probe: ({ h, shell, chords }) => {
+    probe: async ({ h, shell, chords }) => {
       clearShellBridgeHooks(shell)
       setShellRunState(shell, "busy")
       shell.prompt.value = "keep"
@@ -477,6 +477,13 @@ const PROBES: Readonly<Record<string, { readonly group: Group; readonly probe: P
       // at this pulled).
       expect(rows).toEqual(["queue", "cancelled"])
 
+      // The chord's whole job is what lands on screen, not the model alone —
+      // assert on the rendered frame, not just streamLog.
+      await h.renderOnce()
+      const frame = h.captureCharFrame()
+      expect(frame).toContain("[cancelled] drop me")
+      expect(frame).toContain("keep")
+
       setShellRunState(shell, "idle")
     },
   },

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import {
   badgeCount,
+  cancelLast,
   clearInterruptFlash,
   createSessionQueue,
   drainOne,
@@ -63,6 +64,34 @@ describe("session-queue", () => {
     expect(s.interruptFlash).toBe(false)
   })
 
+  test("cancelLast retracts the newest queue item", () => {
+    let s = createSessionQueue("busy")
+    s = enqueue(s, "keep")
+    s = enqueue(s, "drop")
+    const { state, item } = cancelLast(s)
+    expect(item?.text).toBe("drop")
+    expect(badgeCount(state)).toBe(1)
+    expect(state.items[0]!.text).toBe("keep")
+  })
+
+  test("cancelLast retracts the newest steer item, same as queue", () => {
+    let s = createSessionQueue("busy")
+    s = enqueue(s, "queued")
+    s = enqueueSteer(s, "steered")
+    const { state, item } = cancelLast(s)
+    expect(item?.kind).toBe("steer")
+    expect(item?.text).toBe("steered")
+    expect(badgeCount(state)).toBe(1)
+    expect(state.items[0]!.kind).toBe("queue")
+  })
+
+  test("cancelLast on an empty queue is a no-op", () => {
+    const s = createSessionQueue("busy")
+    const { state, item } = cancelLast(s)
+    expect(item).toBeNull()
+    expect(state).toBe(s)
+  })
+
   test("setRunState toggles busy/idle", () => {
     let s = createSessionQueue("idle")
     s = setRunState(s, "busy")

src/tui-opentui/shell.test.ts

@@ -479,7 +479,7 @@ describe("product skin: stream + queue + overlay", () => {
     )
   })
 
-  test("Ctrl+G cancels the last queued message and rewrites its row", async () => {
+  test("Ctrl+G cancels the last queued message and the screen shows it", async () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
@@ -494,24 +494,76 @@ describe("product skin: stream + queue + overlay", () => {
           submitPrompt(shell, "queue")
           expect(shell.pendingQueue).toBe(2)
 
-          const before = shell.streamLog.map((row) => ({ text: row.text, meta: row.meta }))
+          const before = shell.streamLog.map((row) => ({
+            text: row.text,
+            meta: row.meta,
+            cancelled: row.cancelled,
+          }))
           expect(before).toEqual([
-            { text: "keep this one", meta: "queue" },
-            { text: "oops wrong message", meta: "queue" },
+            { text: "keep this one", meta: "queue", cancelled: undefined },
+            { text: "oops wrong message", meta: "queue", cancelled: undefined },
           ])
+          await h.renderOnce()
+          const frameBefore = h.captureCharFrame()
+          expect(frameBefore).toContain("keep this one")
+          expect(frameBefore).toContain("oops wrong message")
+          expect(frameBefore).not.toContain("[cancelled]")
 
           applyShellCancelLast(shell)
 
           expect(shell.pendingQueue).toBe(1)
           expect(shell.session.items[0]!.text).toBe("keep this one")
 
-          const after = shell.streamLog.map((row) => ({ text: row.text, meta: row.meta }))
-          // The cancelled row is rewritten, not left claiming "queue" — the
-          // first attempt's bug this test exists to catch.
+          const after = shell.streamLog.map((row) => ({
+            text: row.text,
+            meta: row.meta,
+            cancelled: row.cancelled,
+          }))
+          // The stored text is untouched — the cancel is a flag the paint
+          // layer reads, not a rewrite of what the operator typed.
           expect(after).toEqual([
-            { text: "keep this one", meta: "queue" },
-            { text: "[cancelled] oops wrong message", meta: "cancelled" },
+            { text: "keep this one", meta: "queue", cancelled: undefined },
+            { text: "oops wrong message", meta: "cancelled", cancelled: true },
           ])
+
+          // The screen, not just the model, is asserted on: this is exactly
+          // what the first attempt at this issue got wrong (the row read
+          // back unchanged from streamLog while the model looked cancelled).
+          await h.renderOnce()
+          const frameAfter = h.captureCharFrame()
+          expect(frameAfter).toContain("[cancelled] oops wrong message")
+          expect(frameAfter).toContain("keep this one")
+        } finally {
+          shell.dispose()
+        }
+      },
+      { width: 80, height: 24 },
+    )
+  })
+
+  test("Ctrl+G cancels a steered message the same way", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "busy",
+        })
+        try {
+          shell.prompt.value = "steer me now"
+          submitPrompt(shell, "steer")
+          expect(shell.pendingQueue).toBe(1)
+          expect(shell.session.items[0]!.kind).toBe("steer")
+
+          applyShellCancelLast(shell)
+
+          expect(shell.pendingQueue).toBe(0)
+          expect(shell.session.items).toHaveLength(0)
+          expect(shell.streamLog[0]?.cancelled).toBe(true)
+          expect(shell.streamLog[0]?.meta).toBe("cancelled")
+
+          await h.renderOnce()
+          expect(h.captureCharFrame()).toContain("[cancelled] steer me now")
         } finally {
           shell.dispose()
         }

src/tui-opentui/shell.ts

@@ -2924,15 +2924,11 @@ export function applyShellCancelLast(shell: AppShell): void {
   if (index !== undefined) {
     const row = streamRowAt(shell, index)
     if (row !== undefined) {
-      // The bar-and-bubble paint for a user row shows only `text`, not
-      // `meta` (see `paintStreamRow`) — copy mode reads `text` too — so the
-      // word has to land in the body itself or the visible transcript still
-      // reads as a message that will dispatch.
-      replaceStreamRowAt(shell, index, {
-        ...row,
-        text: `[cancelled] ${row.text}`,
-        meta: "cancelled",
-      })
+      // `cancelled` stays a flag, not a `text` rewrite — `paintStreamRow`
+      // owns turning it into the "[cancelled]" prefix, so `row.text` still
+      // holds what the operator actually typed for anything else that reads
+      // it (copy mode, a resumed transcript).
+      replaceStreamRowAt(shell, index, { ...row, meta: "cancelled", cancelled: true })
     }
   }
   paintChrome(shell)

src/tui-opentui/stream.ts

@@ -86,6 +86,13 @@ export type StreamRow = {
    * guessing by position once other rows have interleaved.
    */
   readonly queueItemId?: string
+  /**
+   * The queued/steered message this row echoed was cancelled before it
+   * dispatched. Kept as a flag rather than baked into `text` so the stored
+   * body stays what the operator actually typed — the paint layer alone
+   * decides how a cancelled row reads.
+   */
+  readonly cancelled?: boolean
   /**
    * Row standing for a run of repeated calls. Its subject stays the call the
    * run repeats (never a total across them, which would be a claim the
@@ -639,7 +646,8 @@ export function paintStreamRow(
 ): PaintedStreamLine {
   const fg = rowFg(row)
   if (row.role === "user") {
-    return { content: userBubbleLines(row.text, layout.width).join("\n"), fg }
+    const text = row.cancelled === true ? `[cancelled] ${row.text}` : row.text
+    return { content: userBubbleLines(text, layout.width).join("\n"), fg }
   }
   if (isThinkingRow(row)) {
     return {