Clear pending selection on paste; pop selected row on Ctrl+G

A paste is composer input like any key, so it ends the column selection instead of editing under it; Ctrl+G returns the row the operator pointed at, and the no-runtime force-push fallback shares the same pop-to-prompt contract instead of dropping silently. The overlay key paragraph now says which keys end the selection.

Author: TheGreatAxios

docs/TUI.md

@@ -666,9 +666,12 @@ key back to the prompt. On a selected row, **Enter** kills the item out of the
 queue and force-pushes it — `onForceDeliver` drops it on the same
 `port.deliver` hop a drain uses, so a steer still injects when the parent
 cycle is live and otherwise sends immediately. **Ctrl+X** drops the selected
-item outright. Esc or any other key ends the selection and falls through to
-normal handling. `Ctrl+G` stays the pop-to-edit chord: it returns the newest
-held item to an empty prompt for editing (dropping it mid-compose).
+item outright. **Ctrl+G** pops the selected item back into an empty prompt
+for editing (dropping it mid-compose); with no selection it pops the newest
+held item instead. **Esc** ends the selection; any other composer key ends it
+and falls through to normal handling, except `↑`/`↓`, which stay with the
+column. While an overlay is open, keys go to the overlay and leave the
+selection alone.
 
 When `steer > 0` and a parent tool has been in flight ≥ `STEER_WAIT_NOTICE_MS`
 (3s), the notice row adds `waiting on <tool>` (e.g. `waiting on run_shell`).

src/tui/queued-delivery-hop.test.ts

@@ -491,7 +491,14 @@ describe("closed-target recovery", () => {
           expect(calls).toHaveLength(1);
 
           expect(shell.prompt.value).toBe("");
-          expect(drainedUserRow(shell).meta).toBe("steering");
+          // The pending column carried the item until delivery, so the
+          // transcript row is a plain operator message — no [steering]
+          // label on purpose.
+          const row = drainedUserRow(shell);
+          expect(row.meta).toBeUndefined();
+          expect(shell.streamLog.map((r) => r.text).join("\n")).toContain(
+            "steer the ship",
+          );
           expect(recoveryNotices(shell)).toEqual([]);
         } finally {
           bridge.dispose();

src/tui/runtime-bridge.ts

@@ -1717,7 +1717,6 @@ export function attachSessionBridge(
       kind === "steer"
         ? enqueueSteer(shell.session, t, undefined, attachments)
         : enqueue(shell.session, t, "queue", undefined, attachments);
-    const queued = shell.session.items[shell.session.items.length - 1];
     bag.port.enqueue(t, kind);
     if (kind === "steer") bag.waitYieldWake?.();
     // No transcript echo while pending: the item lists in the column stacked

src/tui/shell.test.ts

@@ -458,6 +458,62 @@ describe("createAppShell", () => {
       { width: 80, height: 24 },
     );
   });
+
+  test("Ctrl+G pops the selected row, not the newest", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: true,
+        });
+        try {
+          setPendingQueue(shell, 2);
+          await h.renderOnce();
+          // ↑ selects the newest; ↑ again walks up to the older row.
+          h.mockInput.pressKey("\x1b[A");
+          h.mockInput.pressKey("\x1b[A");
+          await h.renderOnce();
+          expect(shellInternals(shell)?.pendingSelId).toBe(
+            shell.session.items[0]?.id,
+          );
+          h.pressKey("g", { ctrl: true });
+          await h.renderOnce();
+          expect(shell.session.items.map((i) => i.text)).toEqual(["pad-2"]);
+          expect(shell.prompt.value).toBe("pad-1");
+          expect(shellInternals(shell)?.pendingSelId).toBeNull();
+        } finally {
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+
+  test("a prompt paste ends the selection instead of editing under it", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: true,
+        });
+        try {
+          setPendingQueue(shell, 1);
+          await h.renderOnce();
+          h.mockInput.pressKey("\x1b[A");
+          await h.renderOnce();
+          expect(shellInternals(shell)?.pendingSelId).not.toBeNull();
+          await h.mockInput.pasteBracketedText("pasted");
+          await h.renderOnce();
+          expect(shellInternals(shell)?.pendingSelId).toBeNull();
+          expect(shell.prompt.value).toBe("pasted");
+          expect(shell.session.items).toHaveLength(1);
+        } finally {
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 });
 
 describe("product skin: stream + queue + overlay", () => {

src/tui/shell/keys.ts

@@ -36,6 +36,7 @@ import {
   toggleTasksPanel,
 } from "./chrome.js";
 import {
+  applyPendingCancelSelected,
   applyPendingDrop,
   applyPendingForcePush,
   applyPendingNav,
@@ -261,10 +262,18 @@ export function createShellKeyHandlers(
     const bag = shellInternals(shell);
     if (bag?.inputSuspended === true) return;
     sawBracketedPaste = true;
-    if (shell.overlayList !== null && bag?.primaryBindings.onPaste) {
-      event.preventDefault();
-      bag.primaryBindings.onPaste(new TextDecoder().decode(event.bytes));
+    if (shell.overlayList !== null) {
+      if (bag?.primaryBindings.onPaste) {
+        event.preventDefault();
+        bag.primaryBindings.onPaste(new TextDecoder().decode(event.bytes));
+      }
+      return;
     }
+    // A paste into the prompt is composer input like any other key: it ends
+    // a pending-column selection instead of editing under it. The prompt
+    // textarea still consumes the event itself, so this only drops the
+    // selection and falls through.
+    clearPendingSelection(shell);
   };
 
   const onKey = (key: KeyEvent): void => {
@@ -493,9 +502,10 @@ export function createShellKeyHandlers(
     }
 
     // A pending-column selection owns Enter (kill the held item and send it
-    // now) and ^X (drop it) outright; every other key just ends the selection
-    // and falls through to its normal handling. ↑/↓ are exempt — they stay
-    // with the column and are claimed by the nav block below.
+    // now), ^X (drop it) and ^G (pop it back for editing) outright; every
+    // other key just ends the selection and falls through to its normal
+    // handling. ↑/↓ are exempt — they stay with the column and are claimed
+    // by the nav block below.
     if (pendingSelectionActive(shell)) {
       if (
         (keyName === "return" || keyName === "kpenter") &&
@@ -512,6 +522,11 @@ export function createShellKeyHandlers(
         applyPendingDrop(shell);
         return;
       }
+      if (key.ctrl && !key.meta && !key.option && keyName === "g") {
+        key.preventDefault();
+        applyPendingCancelSelected(shell);
+        return;
+      }
       if (keyName !== "up" && keyName !== "down") {
         clearPendingSelection(shell);
       }

src/tui/shell/prompt.ts

@@ -441,11 +441,39 @@ export function applyPendingNav(shell: AppShell, delta: -1 | 1): boolean {
   return true;
 }
 
+/**
+ * No-runtime path for leaving the queue through the selected row: kill the
+ * selected item out of the queue. Same contract as applyShellCancelLast —
+ * an empty prompt gets the item back for editing; mid-draft it's dropped
+ * rather than merged, since merging would send two messages as one.
+ */
+function popSelectedToPrompt(shell: AppShell): void {
+  const bag = shellInternals(shell);
+  const sel = pendingSelIndex(shell);
+  if (bag === undefined || sel < 0) return;
+  const id = shell.session.items[sel]?.id;
+  if (id === undefined) return;
+  const { state, item: popped } = cancelItem(shell.session, id);
+  if (popped === null) return;
+  shell.session = state;
+  bag.pendingSelId = null;
+  if (shell.prompt.value.length === 0) {
+    shell.prompt.value = popped.text;
+    shell.prompt.cursorOffset = popped.text.length;
+    shell.pendingAttachments = [
+      ...shell.pendingAttachments,
+      ...(popped.attachments ?? []),
+    ];
+  }
+  paintChrome(shell);
+}
+
 /**
  * Enter on a selected pending item: kill it out of the queue and force-push —
  * deliver it now through the runtime, skipping its boundary/idle wait. With
- * no runtime attached there is nothing to deliver to, so it pops back into
- * the prompt for editing instead.
+ * no runtime attached there is nothing to deliver to, so it falls back to
+ * the cancel contract: back into an empty prompt for editing, dropped
+ * mid-draft rather than merged.
  */
 export function applyPendingForcePush(shell: AppShell): void {
   const bag = shellInternals(shell);
@@ -461,21 +489,17 @@ export function applyPendingForcePush(shell: AppShell): void {
     paintChrome(shell);
     return;
   }
-  const { state, item: popped } = cancelItem(shell.session, item.id);
-  if (popped === null) return;
-  shell.session = state;
-  bag.pendingSelId = null;
-  // Same contract as applyShellCancelLast: an empty prompt gets the item
-  // back for editing; mid-draft it's dropped rather than merged.
-  if (shell.prompt.value.length === 0) {
-    shell.prompt.value = popped.text;
-    shell.prompt.cursorOffset = popped.text.length;
-    shell.pendingAttachments = [
-      ...shell.pendingAttachments,
-      ...(popped.attachments ?? []),
-    ];
-  }
-  paintChrome(shell);
+  popSelectedToPrompt(shell);
+}
+
+/**
+ * Ctrl+G on a selected pending item: cancel that row, not the newest — the
+ * operator pointed at it. Without hooks this is the same pop-to-prompt as
+ * the force-push fallback; with a runtime attached it still only cancels,
+ * never delivers.
+ */
+export function applyPendingCancelSelected(shell: AppShell): void {
+  popSelectedToPrompt(shell);
 }
 
 /**