Keep coalesced shell tails from being cleared by a silent sibling

Author: TheGreatAxios

src/tui/runtime-bridge.ts

@@ -1084,6 +1084,15 @@ function syncShellOutputs(
     const key = preview.join("\n");
     if (bag.shellSnapshots.get(callId) === key) continue;
     bag.shellSnapshots.set(callId, key);
+    // Consecutive in-flight shells share a lane. An empty sibling snapshot
+    // must not clear a tail another member already painted.
+    if (
+      preview.length === 0 &&
+      row.previewLines !== undefined &&
+      row.previewLines.length > 0
+    ) {
+      continue;
+    }
     rowUpdates.scheduleRowUpdate(bag, index, { ...row, previewLines: preview });
   }
 }

src/tui/stream.ts

@@ -158,7 +158,7 @@ export interface StreamRow {
    */
   readonly callCount?: number;
   /**
-   * Call ids a lane absorbed (newest appended, last 32 kept). Lets a result
+   * Call ids a lane absorbed (newest appended). Lets a result
    * resolve its lane by id even though the lane's own `callId` moved to the
    * newest call.
    */

src/tui/tool-rows.test.ts

@@ -699,6 +699,55 @@ describe("a live turn", () => {
     );
   });
 
+  test("a silent sibling does not clear a coalesced pending shell tail", 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.play([
+            {
+              type: "inference.tool_call.end",
+              data: {
+                name: "run_shell",
+                callId: "sh1",
+                arguments: { command: "echo alpha" },
+              },
+            },
+            {
+              type: "inference.tool_call.end",
+              data: {
+                name: "run_shell",
+                callId: "sh2",
+                arguments: { command: "sleep 5; echo done" },
+              },
+            },
+          ]);
+          await h.renderOnce();
+          expect(shell.streamLog.length).toBe(1);
+          expect(shell.streamLog[0]?.coalesced).toBe(true);
+          expect(shell.streamLog[0]?.pending).toBe(true);
+
+          bridge.syncShellOutputs((callId) => {
+            if (callId === "sh1") return liveFeed(() => "alpha-only\n");
+            if (callId === "sh2") return liveFeed(() => "");
+            return undefined;
+          });
+          await h.renderOnce();
+          expect(shell.streamLog[0]?.previewLines).toEqual(["alpha-only"]);
+        } finally {
+          bridge.dispose();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+
   test("rollbackAttempt drops shellSnapshots for truncated run_shell calls", async () => {
     await withTestRenderer(
       async (h) => {
@@ -902,4 +951,54 @@ describe("lane paint", () => {
     pushToolResult(ok, { name: "run_shell", content: "all good" });
     expect(ok[0]?.stat).toBeUndefined();
   });
+
+  test("a coalesced shell lane keeps each call's answer behind the arrow", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "run_shell",
+      arguments: JSON.stringify({ command: "echo a" }),
+      callId: "s1",
+    });
+    pushToolCall(rows, {
+      name: "run_shell",
+      arguments: JSON.stringify({ command: "echo b" }),
+      callId: "s2",
+    });
+    pushToolResult(rows, { name: "run_shell", content: "a", callId: "s1" });
+    pushToolResult(rows, { name: "run_shell", content: "b", callId: "s2" });
+    const answers = (rows[0]?.detail ?? []).map((line) =>
+      line.map((segment) => segment.text).join(""),
+    );
+    expect(answers).not.toEqual(["answered", "answered"]);
+    expect(answers).toContain("a");
+    expect(rows[0]?.resultText).toBe("b");
+    expect(rows[0]?.previewLines).toEqual(["b"]);
+  });
+
+  test("a later zero-exit coalesced shell does not keep a leftover exit stat", () => {
+    const rows: StreamRow[] = [];
+    pushToolCall(rows, {
+      name: "run_shell",
+      arguments: JSON.stringify({ command: "false" }),
+      callId: "s1",
+    });
+    pushToolCall(rows, {
+      name: "run_shell",
+      arguments: JSON.stringify({ command: "true" }),
+      callId: "s2",
+    });
+    pushToolResult(rows, {
+      name: "run_shell",
+      content: "exit code 1\nboom",
+      callId: "s1",
+    });
+    pushToolResult(rows, {
+      name: "run_shell",
+      content: "all good",
+      callId: "s2",
+    });
+    expect(rows[0]?.pending).toBeUndefined();
+    expect(collapsed(defined(rows[0]))).toContain("true");
+    expect(rows[0]?.stat).not.toBe("exit 1");
+  });
 });

src/tui/tool-rows.ts

@@ -178,16 +178,16 @@ export function mergeToolRows(call: StreamRow, result: StreamRow): StreamRow {
       // The most recent answer is the lane's copy source (Alt+C) and, for a
       // shell lane, the settle preview's source.
       resultText: result.text,
-      ...(call.stat !== undefined ? { stat: call.stat } : {}),
       ...(isShell && shellStat !== undefined ? { stat: shellStat } : {}),
+      ...(!isShell && call.stat !== undefined ? { stat: call.stat } : {}),
       ...(isShell
         ? { previewLines: shellPreviewLines(previewSource) ?? [] }
         : {}),
       outstanding: remaining,
       ...(remaining > 0 ? { pending: true } : {}),
       detail: appendRunLine(
         call.detail ?? [],
-        failed ? "call failed" : (effAddendum ?? "answered"),
+        failed ? "call failed" : (addendum ?? "answered"),
       ),
     };
   }