Split the thinking row when a steer echo is swallowed

Consuming an echoed message before the mapper kept the recovery handoff alive but skipped the turn bookkeeping, so reasoning after a steer folded into the row above the operator's message. Close the open row and reset the turn thinking on that path, and pin that the replayed quota prompt row is dropped by the rollback.

Author: TheGreatAxios

src/tui/runtime-bridge.test.ts

@@ -908,6 +908,8 @@ describe("same-turn failover after inference.error", () => {
         const port = createRecordingPort();
         const bridge = attachSessionBridge(shell, port);
         try {
+          bridge.submit("retry this", "immediate");
+          bridge.handle({ type: "message.received", data: { message: { content: "retry this" } } });
           bridge.handle({ type: "inference.start", data: {} });
           bridge.handle({
             type: "inference.error",
@@ -928,6 +930,10 @@ describe("same-turn failover after inference.error", () => {
 
           expect(errorRows(shell)).toEqual([]);
           expect(shell.streamLog.map((r) => r.text).join("\n")).toContain("recovered");
+          // The replay duplicates the operator's prompt; rollback drops the copy.
+          expect(shell.streamLog.filter((r) => r.role === "user").map((r) => r.text)).toEqual([
+            "retry this",
+          ]);
           // Same-turn failover, not an operator stop — recovery must not borrow interrupt.
           expect(port.calls.some((c) => c.op === "interrupt")).toBe(false);
           expect(shell.streamLog.some((r) => r.meta === "stop")).toBe(false);
@@ -940,6 +946,56 @@ describe("same-turn failover after inference.error", () => {
     );
   });
 
+  test("a steer echo at a tool boundary opens a new thinking row", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        });
+        const bridge = attachSessionBridge(shell, createRecordingPort());
+        try {
+          bridge.submit("first prompt", "immediate");
+          bridge.handle({
+            type: "message.received",
+            data: { message: { content: "first prompt" } },
+          });
+          bridge.handle({ type: "inference.start", data: {} });
+          bridge.handle({ type: "inference.thinking.delta", data: { token: "planning" } });
+          bridge.handle({
+            type: "inference.tool_call.end",
+            data: { name: "run_shell", callId: "c1", arguments: "{}" },
+          });
+          bridge.handle({ type: "inference.done", data: {} });
+          bridge.submit("steer this", "steer");
+          bridge.handle({
+            type: "tool.done",
+            data: { result: { callId: "c1", content: "ok", isError: false } },
+          });
+          bridge.handle({ type: "message.received", data: { message: { content: "steer this" } } });
+          bridge.handle({ type: "inference.start", data: {} });
+          bridge.handle({ type: "inference.thinking.delta", data: { token: "after steer" } });
+          bridge.handle({ type: "inference.text.delta", data: { token: "done" } });
+
+          const rows = shell.streamLog.map((r) => `${r.meta ?? r.role}:${r.text}`);
+          expect(rows.indexOf("thinking:planning")).toBeGreaterThan(-1);
+          expect(rows.indexOf("steering:steer this")).toBeGreaterThan(
+            rows.indexOf("thinking:planning"),
+          );
+          expect(rows.indexOf("thinking:after steer")).toBeGreaterThan(
+            rows.indexOf("steering:steer this"),
+          );
+          expect(shell.streamLog.filter((r) => r.meta === "thinking")).toHaveLength(2);
+        } finally {
+          bridge.dispose();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+
   test("interrupt then a new prompt keeps the prompt and the classified error", async () => {
     await withTestRenderer(
       async (h) => {

src/tui/runtime-bridge.ts

@@ -1078,7 +1078,13 @@ export function attachSessionBridge(
     const settled = noteEvent(event);
     // Reactor-shaped types always map first (avoids tool.done name collision).
     if (PRODUCTION_REACTOR_TYPES.has(event.type)) {
-      if (consumePendingEchoEvent(bag, event)) return;
+      if (consumePendingEchoEvent(bag, event)) {
+        // The echo skips the mapper so it cannot expire a recovery handoff,
+        // but it still starts a new turn: the next reasoning gets its own row.
+        closeOpenRow(shell, bag);
+        bag.turnThinking = null;
+        return;
+      }
       for (const mapped of mapProductionEvent(event as ReactorLikeEvent, bag.mapCtx)) {
         applyInbound(shell, bag, mapped);
       }