Route mid-run Enter through the live reactor

Boundary delivery used to fall back to ordinary send when production
omitted the transport, so a queued mid-run Enter started a second
turn. Require the transport, steer via Agent.deliver, and drop queued
input on session rotation.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -81,7 +81,12 @@ In TUI chat mode there is no completion gate — the session stays open across t
 - Wires `ask_operator` to an operator-gate event resolved by a modal
 - Mounts the OpenTUI host via `mountRunnerHost` (`src/tui/runner-host.ts`), which mounts `mountProductHost` (`src/tui/product-host.ts`) over the shell (`src/tui/shell.ts`)
 - Bridges reactor events to the OpenTUI host via a plain `EventEmitter`
-- **Mid-run injection** — When a message arrives while the agent is running, it is queued in an `InjectionQueue`. On the next `inference.done` event (turn boundary), the queue is drained: each queued message is delivered via `agentProxy.deliver()` and a `"mid-run.delivered"` emitter event is fired so the badge count in the App updates. The queue is cleared on session rotation (`/clear`).
+- **Mid-run injection** — Shell `session-queue` items drain at the parent
+  `tool.boundary` through `SessionPort.deliver`. Production `routeQueuedDelivery`
+  sends steers via `agentProxy.deliver` (`Agent.deliver`) into the live reactor
+  and idle follow-ups via the existing send path. `/clear` and `/new` bump a
+  delivery generation and call `SessionBridge.clearQueuedDelivery()` so queued
+  input from the previous session cannot enter the new one.
 - **Session rotation** — Uses a serial session-operation queue (`createSessionOperationQueue`, not a boolean flag) so rotation, compaction continuation, and `agentProxy.deliver` never race a concurrent rebuild. Each operation chains onto the tail, ensuring in-flight work completes before the agent is torn down.
 
 ### Exec Runner (`src/exec/runner.ts`)

docs/TUI.md

@@ -457,17 +457,18 @@ the chord to point an operator at when Shift+Enter doesn't respond.
 Two mid-run gestures, two delivery times (CL-6290):
 
 - **Enter, mid-run** — soft steer: enqueues kind `"steer"` and delivers at the
-  next **parent** `tool.boundary` (the parent tool finishing, not a child). A
+  next **parent** `tool.boundary` (the parent tool finishing, not a child) via
+  `Agent.deliver` into the live reactor, not a new `send`. A
   long parent `run_shell` or an awaiting `task()` is parent-busy and holds
   steers. The transcript row says `[will steer next]` while pending and
   `[steering]` once delivered (`submitPrompt`, `drainSteersAtBoundary` in
   `runtime-bridge.ts`).
 - **Alt+Enter, mid-run** — follow-up: enqueues kind `"queue"` and delivers
-  only on **session-idle** (parent-idle and no live fleet lanes). Does not
-  interrupt or reinject. The transcript row says `[will follow up]` while
-  pending and `[following up]` once delivered. Idle, or with an empty prompt,
-  Alt+Enter does nothing — there is nothing to wait for. (Internal `"reinject"`
-  remains in the submit API for tests; no product chord wires it.)
+  only on **session-idle** (parent-idle and no live fleet lanes) as a `send`.
+  Does not interrupt or reinject. The transcript row says `[will follow up]`
+  while pending and `[following up]` once delivered. Idle, or with an empty
+  prompt, Alt+Enter does nothing — there is nothing to wait for. (Internal
+  `"reinject"` remains in the submit API for tests; no product chord wires it.)
 
 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/keybindings.test.ts

@@ -714,6 +714,7 @@ describe("the runner host does not shadow the prompt bindings the catalog claims
       eventEmitter: new EventEmitter(),
       send: () => {},
       interrupt: () => {},
+      deliver: () => {},
       providers: {},
       onModelSelect: () => {},
       commands: [],

src/tui/live-session-port.test.ts

@@ -8,7 +8,7 @@ type Call =
   | { op: "interrupt" }
   | { op: "deliver"; text: string; kind: QueueKind };
 
-function fakeDeps(opts?: { withDeliver?: boolean }) {
+function fakeDeps() {
   const calls: Call[] = [];
   const deps = {
     send: (text: string) => {
@@ -17,13 +17,9 @@ function fakeDeps(opts?: { withDeliver?: boolean }) {
     interrupt: () => {
       calls.push({ op: "interrupt" });
     },
-    ...(opts?.withDeliver
-      ? {
-          deliver: (text: string, kind: QueueKind) => {
-            calls.push({ op: "deliver", text, kind });
-          },
-        }
-      : {}),
+    deliver: (text: string, kind: QueueKind) => {
+      calls.push({ op: "deliver", text, kind });
+    },
   };
   return { calls, deps };
 }
@@ -69,30 +65,20 @@ describe("createLiveSessionPort", () => {
     expect(calls).toEqual([{ op: "interrupt" }]);
   });
 
-  test("deliver without deps.deliver falls back to send", () => {
+  test("deliver never calls send for steer or queue", () => {
     const { calls, deps } = fakeDeps();
     const port = createLiveSessionPort(deps);
     port.deliver(item("queued msg", "queue"));
     port.deliver(item("steer msg", "steer", "q2"));
-    expect(calls).toEqual([
-      { op: "send", text: "queued msg" },
-      { op: "send", text: "steer msg" },
-    ]);
-  });
-
-  test("deliver with deps.deliver passes text and kind", () => {
-    const { calls, deps } = fakeDeps({ withDeliver: true });
-    const port = createLiveSessionPort(deps);
-    port.deliver(item("queued msg", "queue"));
-    port.deliver(item("steer msg", "steer", "q2"));
+    expect(calls.some((c) => c.op === "send")).toBe(false);
     expect(calls).toEqual([
       { op: "deliver", text: "queued msg", kind: "queue" },
       { op: "deliver", text: "steer msg", kind: "steer" },
     ]);
   });
 
   test("full wiring: immediate → enqueue → deliver → interrupt", () => {
-    const { calls, deps } = fakeDeps({ withDeliver: true });
+    const { calls, deps } = fakeDeps();
     const port = createLiveSessionPort(deps);
 
     port.sendImmediate("start");
@@ -122,6 +108,7 @@ describe("attachment passthrough", () => {
     const port = createLiveSessionPort({
       send: (_text, attachments) => seen.push(attachments),
       interrupt: () => {},
+      deliver: () => {},
     });
     port.sendImmediate("look", [image]);
     expect(seen).toEqual([[image]]);

src/tui/live-session-port.ts

@@ -23,15 +23,8 @@ export interface LiveSessionPortDeps {
   ) => SubmitClassification;
   /** Hard interrupt current run (runner close/rebuild). */
   interrupt: () => void;
-  /**
-   * Optional: drained queue/steer item at tool boundary (or idle).
-   * Defaults to `send(text)` for both kinds — v1 runner shares send.
-   */
-  deliver?: (
-    text: string,
-    kind: QueueKind,
-    attachments?: readonly PendingImageAttachment[],
-  ) => void;
+  /** Drained queue/steer item at tool boundary (or idle). Always forwarded. */
+  deliver: (text: string, kind: QueueKind, attachments?: readonly PendingImageAttachment[]) => void;
 }
 
 /**
@@ -57,11 +50,7 @@ export function createLiveSessionPort(deps: LiveSessionPortDeps): SessionPort {
       deps.interrupt();
     },
     deliver: (item: QueueItem): void => {
-      if (deps.deliver) {
-        deps.deliver(item.text, item.kind, item.attachments);
-        return;
-      }
-      deps.send(item.text, item.attachments);
+      deps.deliver(item.text, item.kind, item.attachments);
     },
   };
 }

src/tui/product-host.test.ts

@@ -24,15 +24,18 @@ import { buildModelsFirstCatalog, modelOptionId } from "./model-catalog.js";
 
 function makeFakeSessionPort(): {
   readonly sends: string[];
+  readonly delivers: string[];
   readonly interrupts: number;
   readonly send: ProductHostConfig["send"];
   readonly interrupt: ProductHostConfig["interrupt"];
-  readonly deliver: NonNullable<ProductHostConfig["deliver"]>;
+  readonly deliver: ProductHostConfig["deliver"];
 } {
   const sends: string[] = [];
+  const delivers: string[] = [];
   let interrupts = 0;
   return {
     sends,
+    delivers,
     get interrupts() {
       return interrupts;
     },
@@ -43,7 +46,7 @@ function makeFakeSessionPort(): {
       interrupts += 1;
     },
     deliver: (text) => {
-      sends.push(text);
+      delivers.push(text);
     },
   };
 }
@@ -224,6 +227,25 @@ describe("mountProductHost", () => {
     }
   });
 
+  test("session.clear drops queued steers and idles the run (CL-7268)", async () => {
+    const { host, emitter } = await mountHeadless();
+    try {
+      host.bridge.handle({ type: "run", state: "busy" });
+      host.bridge.submit("old steer", "steer");
+      expect(host.shell.session.run).toBe("busy");
+      expect(host.shell.session.items.length).toBe(1);
+
+      emitter.emit("event", { type: "user", text: "old prompt" });
+      emitter.emit("session.clear");
+
+      expect(host.shell.streamLog).toEqual([]);
+      expect(host.shell.session.items).toEqual([]);
+      expect(host.shell.session.run).toBe("idle");
+    } finally {
+      host.dispose();
+    }
+  });
+
   test("permission.gate opens the overlay and resolves through the emitter's resolve callback", async () => {
     const { host, emitter } = await mountHeadless();
     try {
@@ -390,6 +412,7 @@ describe("flat type-to-filter model picker", () => {
       eventEmitter: new EventEmitter(),
       send: port.send,
       interrupt: port.interrupt,
+      deliver: port.deliver,
       createRenderer: async () => harness.renderer,
       models: catalog,
       onModelSelect: (id) => selected.push(id),
@@ -477,6 +500,7 @@ describe("flat type-to-filter model picker", () => {
       eventEmitter: new EventEmitter(),
       send: port.send,
       interrupt: port.interrupt,
+      deliver: port.deliver,
       createRenderer: async () => harness.renderer,
       models: catalog,
       activeModelId: () => modelOptionId("xai/thegreataxios", "grok-4.5"),
@@ -509,6 +533,7 @@ describe("flat type-to-filter model picker", () => {
       eventEmitter: new EventEmitter(),
       send: port.send,
       interrupt: port.interrupt,
+      deliver: port.deliver,
       createRenderer: async () => harness.renderer,
       models: catalog,
       activeModelId: () => modelOptionId("codex/abk-labs", "gpt-5.5"),
@@ -536,6 +561,7 @@ describe("flat type-to-filter model picker", () => {
         eventEmitter: new EventEmitter(),
         send: port.send,
         interrupt: port.interrupt,
+        deliver: port.deliver,
         createRenderer: async () => harness.renderer,
         models: catalog,
         onModelSelect: () => {},
@@ -865,6 +891,7 @@ describe("mount failure", () => {
         eventEmitter: emitter,
         send: port.send,
         interrupt: port.interrupt,
+        deliver: port.deliver,
         createRenderer: async () => harness.renderer,
       }),
     ).rejects.toThrow("gate wiring failed");

src/tui/product-host.ts

@@ -119,7 +119,7 @@ export interface ProductHostConfig {
    */
   readonly classifySubmit?: ProductHostClassifySubmit;
   readonly interrupt: ProductHostInterrupt;
-  readonly deliver?: ProductHostDeliver;
+  readonly deliver: ProductHostDeliver;
   /** Model/provider rows for the picker (id applied on select). */
   readonly models?: readonly ProductHostModelOption[];
   /**
@@ -319,8 +319,8 @@ export async function mountProductHost(config: ProductHostConfig): Promise<Produ
   const port = createLiveSessionPort({
     send: config.send,
     interrupt: config.interrupt,
+    deliver: config.deliver,
     ...(config.classifySubmit !== undefined ? { classifySubmit: config.classifySubmit } : {}),
-    ...(config.deliver !== undefined ? { deliver: config.deliver } : {}),
   });
   // Empty options accept the defaults (real clock, 250 ms tick, 15 min stall)
   // while still opting this host into the quota-retry / stall timers.
@@ -508,6 +508,7 @@ export async function mountProductHost(config: ProductHostConfig): Promise<Produ
   function onSessionClear(): void {
     if (disposed) return;
     clearTranscript(shell);
+    bridge.clearQueuedDelivery();
   }
 
   let currentModels = config.models ?? [];

src/tui/queued-delivery.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import type { PendingImageAttachment } from "./image-attachments.js";
+import { createDeliveryGeneration, routeQueuedDelivery } from "./queued-delivery.js";
+
+const image: PendingImageAttachment = {
+  id: "img-1",
+  name: "clipboard.png",
+  contentType: "image/png",
+  data: new Uint8Array([1]),
+  contentHash: "hash-1",
+};
+
+describe("routeQueuedDelivery", () => {
+  test("steer calls deliverSteer only", () => {
+    const sends: string[] = [];
+    const steers: string[] = [];
+    const deliver = routeQueuedDelivery({
+      send: (text) => {
+        sends.push(text);
+      },
+      deliverSteer: (text) => {
+        steers.push(text);
+      },
+    });
+    deliver("asap", "steer");
+    expect(steers).toEqual(["asap"]);
+    expect(sends).toEqual([]);
+  });
+
+  test("queue calls send only", () => {
+    const sends: string[] = [];
+    const steers: string[] = [];
+    const deliver = routeQueuedDelivery({
+      send: (text) => {
+        sends.push(text);
+      },
+      deliverSteer: (text) => {
+        steers.push(text);
+      },
+    });
+    deliver("later", "queue");
+    expect(sends).toEqual(["later"]);
+    expect(steers).toEqual([]);
+  });
+
+  test("forwards attachments on both kinds", () => {
+    const sent: (readonly PendingImageAttachment[] | undefined)[] = [];
+    const steered: (readonly PendingImageAttachment[] | undefined)[] = [];
+    const deliver = routeQueuedDelivery({
+      send: (_text, attachments) => {
+        sent.push(attachments);
+      },
+      deliverSteer: (_text, attachments) => {
+        steered.push(attachments);
+      },
+    });
+    deliver("asap", "steer", [image]);
+    deliver("later", "queue", [image]);
+    expect(steered).toEqual([[image]]);
+    expect(sent).toEqual([[image]]);
+  });
+});
+
+describe("createDeliveryGeneration", () => {
+  test("capture then bump → predicate false", () => {
+    const generation = createDeliveryGeneration();
+    const stillCurrent = generation.capture();
+    generation.bump();
+    expect(stillCurrent()).toBe(false);
+  });
+
+  test("capture without bump → true", () => {
+    const generation = createDeliveryGeneration();
+    const stillCurrent = generation.capture();
+    expect(stillCurrent()).toBe(true);
+  });
+
+  test("bump then new capture → true", () => {
+    const generation = createDeliveryGeneration();
+    generation.bump();
+    const stillCurrent = generation.capture();
+    expect(stillCurrent()).toBe(true);
+  });
+
+  test("two captures, bump, both stale", () => {
+    const generation = createDeliveryGeneration();
+    const first = generation.capture();
+    const second = generation.capture();
+    generation.bump();
+    expect(first()).toBe(false);
+    expect(second()).toBe(false);
+  });
+});

src/tui/queued-delivery.ts

@@ -0,0 +1,36 @@
+/**
+ * Kind routing for drained queue items, plus a generation token so a
+ * /clear|/new rotation can drop in-flight delivers that belonged to the
+ * previous session. Kind routing lives here, not on SessionPort.
+ */
+
+import type { PendingImageAttachment } from "./image-attachments.js";
+import type { ProductHostDeliver } from "./product-host.js";
+
+export interface RouteQueuedDeliveryArgs {
+  send: (text: string, attachments?: readonly PendingImageAttachment[]) => void;
+  deliverSteer: (text: string, attachments?: readonly PendingImageAttachment[]) => void;
+}
+
+export function routeQueuedDelivery(args: RouteQueuedDeliveryArgs): ProductHostDeliver {
+  return (text, kind, attachments) => {
+    if (kind === "steer") {
+      args.deliverSteer(text, attachments);
+      return;
+    }
+    args.send(text, attachments);
+  };
+}
+
+export function createDeliveryGeneration() {
+  let generation = 0;
+  return {
+    bump(): void {
+      generation += 1;
+    },
+    capture(): () => boolean {
+      const captured = generation;
+      return () => captured === generation;
+    },
+  };
+}