fix(tui): keep ungated sibling elapsed through an unrelated grant

gateOpened snapshotted every timed call into the rebase set, so an
auto-allowed sibling that was already executing reset to 0:00 when a
later gate settled. Skip ids that already carry a live elapsed clock.

Author: TheGreatAxios

src/tui/runtime-bridge.test.ts

@@ -3170,6 +3170,68 @@ describe("CL-7802 gated tool elapsed starts at grant", () => {
     );
   });
 
+  test("ungated in-flight sibling does not rebase when a later gate settles", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "busy",
+        });
+        let nowMs = 0;
+        let tick: (() => void) | undefined;
+        const bridge = attachSessionBridge(shell, createRecordingPort(), {
+          now: () => nowMs,
+          schedule: (fn) => {
+            tick = fn;
+            return () => {
+              tick = undefined;
+            };
+          },
+        });
+        try {
+          bridge.handle({ type: "inference.start", data: {} });
+          bridge.handle({
+            type: "inference.tool_call.end",
+            data: { name: "grep", callId: "sibling", arguments: "needle" },
+          });
+          const siblingIndex = streamRowCount(shell) - 1;
+          const siblingStat = () =>
+            defined(shell.streamLog[siblingIndex], "sibling row").stat;
+
+          nowMs = 60_000;
+          tick?.();
+          await h.renderOnce();
+          expect(siblingStat()).toBe("1:00");
+
+          bridge.handle({
+            type: "inference.tool_call.end",
+            data: { name: "run_shell", callId: "gated", arguments: "sleep 30" },
+          });
+          const gatedIndex = streamRowCount(shell) - 1;
+          const gatedStat = () =>
+            defined(shell.streamLog[gatedIndex], "gated row").stat;
+
+          bridge.gateOpened();
+          bridge.gateClosed();
+          await h.renderOnce();
+          expect(siblingStat()).toBe("1:00");
+          expect(gatedStat()).toBe("0:00");
+
+          nowMs = 65_000;
+          tick?.();
+          await h.renderOnce();
+          expect(siblingStat()).toBe("1:05");
+          expect(gatedStat()).toBe("0:05");
+        } finally {
+          bridge.dispose();
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+
   test("diff rows keep their +/- stat through a gate cycle", async () => {
     await withTestRenderer(
       async (h) => {

src/tui/runtime-bridge.ts

@@ -599,11 +599,13 @@ export interface BridgeBag {
    */
   toolCallStartedAt: Map<string, number>;
   /**
-   * In-flight ordinary calls announced before (or while) a decision gate
-   * stood open. `gateClosed` re-syncs their elapsed clocks to the settle so
-   * post-grant stats read time-since-grant, not time-since-announcement.
-   * `spawn_agent` ids are never rebased — the session clock owns those rows.
-   * Results and rollbacks drop their ids so the set cannot leak.
+   * In-flight ordinary calls waiting on a decision gate. `gateClosed` re-syncs
+   * their elapsed clocks to the settle so post-grant stats read
+   * time-since-grant, not time-since-announcement. Auto-allowed siblings that
+   * already carry a live elapsed clock are executing, not waiting, and stay
+   * out of the set. `spawn_agent` ids are never rebased — the session clock
+   * owns those rows. Results and rollbacks drop their ids so the set cannot
+   * leak.
    */
   gatedToolCalls: Set<string>;
   /**
@@ -1267,6 +1269,19 @@ function rebaseGatedElapsed(
   }
 }
 
+/** `clockLabel` trailer already painted on an in-flight ordinary-tool row. */
+function hasPaintedElapsedClock(
+  shell: AppShell,
+  bag: BridgeBag,
+  callId: string,
+): boolean {
+  const index = bag.toolRows.get(callId);
+  if (index === undefined) return false;
+  const row = bag.pendingRowUpdates.get(index) ?? streamRowAt(shell, index);
+  const stat = row?.stat;
+  return typeof stat === "string" && /^\d+:\d{2}$/.test(stat);
+}
+
 /**
  * User rows the shell paints ahead of the runtime's own inbound copy: a
  * reinject, which lands before the restarted run reports it, and a row the
@@ -2103,9 +2118,11 @@ export function attachSessionBridge(
   const gateOpened = (): void => {
     if (bag.disposed) return;
     bag.turn = turnStateGateOpened(bag.turn);
-    // Snapshot every timed call: each one waits out this gate, so the settle
-    // re-syncs their clocks (see gateClosed).
+    // Snapshot calls waiting on this gate. An auto-allowed sibling that
+    // already carries a live elapsed clock is executing, not waiting — leave
+    // its startedAt at announcement so post-grant stats stay honest.
     for (const callId of bag.toolCallStartedAt.keys()) {
+      if (hasPaintedElapsedClock(shell, bag, callId)) continue;
       bag.gatedToolCalls.add(callId);
     }
     paintPhase();