@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/client/hooks/chat/timeline/session-load.ts

@@ -23,6 +23,8 @@ import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import type { ChatMessageData } from '@/shared/types';
 import { SESSION_META_RETRY_SCHEDULE_MS } from '@/shared/lib/workspace/refresh-cadence';
 import { useSessionPagination } from '@/client/hooks/chat/timeline/session-pagination';
+import { useLostRunRecovery } from '@/client/hooks/chat/timeline/lost-run';
+import { isOwnSpawn, isSpawnArrival } from '@/client/hooks/chat/timeline/session-switch';
 
 export interface SessionDataShape {
   id?: string;
@@ -52,6 +54,12 @@ export interface UseSessionLoadDeps {
    *  UI sets `isGeneratingRef` too, and treating that as ownership discarded
    *  the whole transcript, leaving an empty timeline over a running session. */
   ownRunRef: { current: boolean };
+  /** The stream has announced the run in flight (see `streamRunRef`). */
+  streamRunRef: { current: boolean };
+  /** The SERVER reports a run for this session (the `stream` row). Together
+   *  with `streamRunRef` this is the evidence the reconnect recovery needs: a
+   *  run whose FIRST frame was lost has no `agent_start` on this client. */
+  serverRunRef: { current: boolean };
   /** Live AI placeholder ref: the row the streaming answer is filling. Read on
    *  a session switch (cleared with the optimistic user id) and by the stream
    *  callbacks; it is NOT the timeline-ownership signal — the placeholder is
@@ -60,6 +68,10 @@ export interface UseSessionLoadDeps {
   /** Live optimistic user bubble ref: cleared together with the placeholder on
    *  a session switch so stale ids cannot survive into the next session. */
   optimisticUserIdRef: { current: string | null };
+  /** Raw composer text of steer/follow-up turns awaiting omp's echo. Cleared
+   *  when a lost run is settled, or a later echo could be re-labelled with an
+   *  earlier message's text. */
+  pendingUserDisplaysRef: { current: { sent: string; display: string }[] };
   /** Drop queued stream updates belonging to the previous session (coalescer). */
   cancelStreamingCoalescer: () => void;
   metaRefreshedRef: { current: string | null };
@@ -73,7 +85,7 @@ export interface UseSessionLoadDeps {
 }
 
 export function useSessionLoad(deps: UseSessionLoadDeps) {
-  const { sessionId, setLocalMessages, setGenerating, isGeneratingRef, ownRunRef, aiPlaceholderIdRef, optimisticUserIdRef, cancelStreamingCoalescer, metaRefreshedRef, scrollRef, jumpActiveRef, jumpCountRef } = deps;
+  const { sessionId, setLocalMessages, setGenerating, isGeneratingRef, ownRunRef, streamRunRef, serverRunRef, aiPlaceholderIdRef, optimisticUserIdRef, pendingUserDisplaysRef, cancelStreamingCoalescer, metaRefreshedRef, scrollRef, jumpActiveRef, jumpCountRef } = deps;
 
   const [sessionData, setSessionData] = useState<SessionDataShape | null>(null);
   const [sessionLoading, setSessionLoading] = useState(false);
@@ -163,19 +175,16 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
    *  A committed fetch is a LAGGING snapshot while a run is live. For a fresh
    *  spawn there may be no transcript on disk at all (omp buffers its writes
    *  until the first assistant message settles), and it never carries a segment
-   *  still streaming. Applying one mid-run costs the operator their own turn in
-   *  either direction — measured on real sessions: an empty payload emptied the
-   *  list (the just-sent turn vanished), and a payload carrying the file's own
-   *  copy of that turn was merged UNDER the live rows, whose ids differ
-   *  (`msg-…-user` vs the echoed id), so the turn rendered twice.
+   *  still streaming. Applying one mid-run costs the operator their own turn —
+   *  measured: an empty payload emptied the list, and a payload carrying the
+   *  file's own copy of that turn was merged UNDER the live rows, whose ids
+   *  differ, so the turn rendered twice.
    *
    *  Keyed on the RUN THIS PAGE STARTED, never on `isGeneratingRef` alone: the
-   *  mount probe that resumes a live run's generating UI sets that flag too, so
-   *  keying on it made OPENING a streaming session discard its entire committed
-   *  transcript — measured on a real 333-message run: the timeline held 0 rows
-   *  with only a "Load earlier messages" button, and the button paged a window
-   *  into a list whose head was empty. A run adopted that way must still load
-   *  its history; the stream resume continues from there. */
+   *  mount probe that resumes a live run sets that flag too, so keying on it
+   *  made OPENING a streaming session discard its whole committed transcript
+   *  (measured: 0 rows, only a "Load earlier messages" button). An adopted run
+   *  must still load its history; the resume continues from there. */
   const timelineOwnedByLiveRun = useCallback(
     () => ownRunRef.current && isGeneratingRef.current,
     [isGeneratingRef, ownRunRef],
@@ -193,40 +202,57 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
     [isGeneratingRef],
   );
 
+  // A channel that comes back after the run's `message_end`/`agent_end` were
+  // lost with it: the timeline holds the stream's last partial segment and
+  // nothing else will ever finalize it (see `lost-run.ts`). A run that is
+  // STILL LIVE at reconnect is left alone here, but its lost segments are
+  // remembered and re-read when it settles.
+  const { reloadMessages, needsReloadRef } = useLostRunRecovery({
+    sessionId,
+    sessionIdRef,
+    adoptedSessionIdRef,
+    isGeneratingRef,
+    streamRunRef,
+    serverRunRef,
+    setGenerating,
+    setLocalMessages,
+    applyWindow,
+    aiPlaceholderIdRef,
+    optimisticUserIdRef,
+    pendingUserDisplaysRef,
+    cancelStreamingCoalescer,
+  });
+
   // Fetch session messages and details from API
   useEffect(() => {
     let active = true;
     setSessionLoading(true);
-    // Track the previous session id so a session switch (including "New
-    // Session" → new-…) clears the timeline, while the optimistic spawn
-    // transition (new-… → real UUID) keeps its bubbles.
+    // Track the previous id so a real switch clears the timeline while a
+    // spawn's arrival keeps its bubbles (see `session-switch.ts`).
     if (sessionId !== prevSessionIdRef.current) {
-      const isSpawnAdopt = sessionId && !sessionId.startsWith('new-') && prevSessionIdRef.current?.startsWith('new-');
-      // Keep the optimistic bubbles while a local send is in flight and this
-      // session is the one it spawned (a fresh spawn may not have passed
-      // through "new-…"). A reload mid-run has no adopted id, so history loads.
-      const isAdoptingInFlight = isGeneratingRef.current && adoptedSessionIdRef.current === sessionId;
-      if (!isSpawnAdopt && !isAdoptingInFlight) {
+      // A spawn's arrival keeps the optimistic rows; anything else is a switch
+      // to another session. The two shapes — `new-…` → UUID and a chat opened
+      // from a workspace whose URL moves straight to the child's UUID — and why
+      // the second one used to clear a finished turn are in `session-switch.ts`.
+      const spawnArrival = isSpawnArrival({
+        sessionId,
+        previousSessionId: prevSessionIdRef.current,
+        adoptedSessionId: adoptedSessionIdRef.current,
+      });
+      if (!spawnArrival) {
         setLocalMessages([]);
         setGenerating(false);
         adoptedSessionIdRef.current = null;
         seededModelRef.current = null;
-        // Metadata (model / thinking level) belongs to ONE session: leaving it
-        // in place let a pending "new-…" composer — and any other session's
-        // composer — display a level that session never ran with, until the
-        // fetch replaced it.
+        // Metadata and the thinking seed belong to ONE session: leaving either
+        // in place let a composer display a level its session never ran with.
         setSessionData(null);
-        // The thinking seed belongs to the previous session's spawn; keeping it
-        // would report that level for the newly opened session.
         seededThinkingLevelRef.current = null;
         // The placeholder/optimistic ids belong to the PREVIOUS session's
-        // in-flight send; message_end never arrives after a switch away (the
-        // stream is disconnected), so they must be dropped here. A stale
-        // placeholder would let the next session's stream reconcile into a row
-        // that is no longer on screen. (`setGenerating(false)` above releases
-        // the run ownership this page held — the guard reads `ownRunRef`, so a
-        // stale value there is what used to discard a mid-run session's
-        // committed history on return.)
+        // in-flight send, and `message_end` never arrives after a switch away.
+        // (`setGenerating(false)` above releases the run ownership this page
+        // held — the guard reads `ownRunRef`, so a stale value there is what
+        // discarded a mid-run session's committed history on return.)
         aiPlaceholderIdRef.current = null;
         optimisticUserIdRef.current = null;
         // Drop coalesced message_update frames queued by the previous
@@ -259,6 +285,10 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
       // means this payload is a lagging snapshot of a timeline the stream owns.
       const ownedAtIssue = timelineOwnedByLiveRun();
       const ownedByLiveRun = () => ownedAtIssue || timelineOwnedByLiveRun();
+      /** Its transcript may legitimately be missing — omp buffers its writes
+       *  until the first assistant message settles — so an empty payload is
+       *  "not written yet", never "nothing happened". */
+      const ownSpawn = () => isOwnSpawn(sessionId, adoptedSessionIdRef.current);
       fetch(`/api/chat/${sessionId}`)
         .then(res => res.json())
         .then(data => {
@@ -273,13 +303,13 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
             // operator's turn (see `timelineOwnedByLiveRun`).
             if (!ownedByLiveRun()) {
               if (fetched.length > 0) setLocalMessages(fetched);
-              // A pending "new-…" session has nothing committed by definition.
-              else if (!sessionId.startsWith('new-')) setLocalMessages([]);
+              // An own spawn has nothing committed YET (see `isOwnSpawn`).
+              else if (!ownSpawn()) setLocalMessages([]);
             }
             applyWindow(data.hasMore, data.oldestIndex);
           } else {
             setSessionData(seededSessionData());
-            if (!ownedByLiveRun()) setLocalMessages([]);
+            if (!ownedByLiveRun() && !ownSpawn()) setLocalMessages([]);
           }
         })
         .catch(err => {
@@ -313,5 +343,7 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
     adoptedSessionIdRef,
     refreshSessionMeta,
     seedSession,
+    reloadMessages,
+    needsReloadRef,
   };
 }

package/src/client/hooks/chat/timeline/session-switch.test.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `isSpawnArrival` / `isOwnSpawn` — the two questions a session-id change asks.
+ *
+ * Both are pure so every ordering can be stated directly. The orderings are the
+ * point: the browser is where they were found (three CI specs at once showed an
+ * answer on screen and then an empty timeline), but reproducing a child that
+ * answers before the URL flips is not something a browser spec can be asked to
+ * do on demand.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { isOwnSpawn, isSpawnArrival } from '@/client/hooks/chat/timeline/session-switch';
+
+describe('isSpawnArrival', () => {
+  test('the id the send path recorded is an arrival, whatever the previous id was', () => {
+    // A chat opened from a WORKSPACE: no `?sessionId=` at all, so the previous
+    // id is null and the URL moves straight to the child's UUID. This is the
+    // shape that used to clear a finished turn.
+    expect(
+      isSpawnArrival({ sessionId: 'uuid-1', previousSessionId: null, adoptedSessionId: 'uuid-1' }),
+    ).toBe(true);
+    // A pending chat, mid-run or after it: same fact.
+    expect(
+      isSpawnArrival({ sessionId: 'uuid-1', previousSessionId: 'new-9', adoptedSessionId: 'uuid-1' }),
+    ).toBe(true);
+  });
+
+  test('`new-…` → UUID is still an arrival when the record was already consumed', () => {
+    // The pending store hands the adoption to the session-state provider once,
+    // so the URL's own shape is the only evidence left.
+    expect(
+      isSpawnArrival({ sessionId: 'uuid-1', previousSessionId: 'new-9', adoptedSessionId: null }),
+    ).toBe(true);
+  });
+
+  test('opening another session is not an arrival', () => {
+    expect(
+      isSpawnArrival({ sessionId: 'uuid-2', previousSessionId: 'uuid-1', adoptedSessionId: 'uuid-1' }),
+    ).toBe(false);
+  });
+
+  test('a null or unchanged id is not an arrival', () => {
+    expect(isSpawnArrival({ sessionId: null, previousSessionId: 'uuid-1', adoptedSessionId: null })).toBe(false);
+    expect(
+      isSpawnArrival({ sessionId: 'uuid-1', previousSessionId: 'uuid-1', adoptedSessionId: 'uuid-1' }),
+    ).toBe(true);
+  });
+});
+
+describe('isOwnSpawn', () => {
+  test('a pending id and the adopted UUID are both own spawns', () => {
+    expect(isOwnSpawn('new-9', null)).toBe(true);
+    expect(isOwnSpawn('uuid-1', 'uuid-1')).toBe(true);
+  });
+
+  test('a session this page did not spawn is not one', () => {
+    expect(isOwnSpawn('uuid-2', 'uuid-1')).toBe(false);
+    expect(isOwnSpawn(null, 'uuid-1')).toBe(false);
+  });
+});

package/src/client/hooks/chat/timeline/session-switch.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Which rows a session-switch keeps, and which a committed payload may replace.
+ *
+ * Split out of `session-load.ts` for the file-size ceiling, and it is one
+ * subject rather than an arbitrary cut: both functions answer "does this arrival
+ * belong to the session the timeline is already showing?".
+ *
+ * The distinction they encode was paid for twice, in opposite directions.
+ *
+ * - **A spawn's arrival is not a session switch.** The optimistic bubbles are
+ *   the operator's own turn and the row the stream is filling; clearing them
+ *   deleted a turn that had already rendered. Two shapes reach here and only one
+ *   was ever recognised: `new-…` → UUID, and a chat opened from a WORKSPACE
+ *   (`?folderId=` and no `?sessionId=`), whose previous id is `null` and whose
+ *   URL moves straight to the child's UUID. The second was keyed on the
+ *   generating flag, so a FAST child — the scripted one answers in milliseconds
+ *   — finished before the URL flipped and the reset ran anyway. Measured in CI
+ *   on three specs at once: the answer was on screen, then the timeline was
+ *   empty. The id the send path recorded is the fact that survives either
+ *   ordering.
+ * - **A committed payload is a lagging snapshot** while a run this page started
+ *   owns the rows, and an own spawn's transcript may legitimately be empty (omp
+ *   buffers its writes until the first assistant message settles). Either way it
+ *   must not empty the timeline.
+ */
+
+/** The ids a session-switch decision needs, all of them refs. */
+export interface SessionSwitchFacts {
+  sessionId: string | null;
+  previousSessionId: string | null;
+  /** The id a spawn answered with, recorded by the send path. */
+  adoptedSessionId: string | null;
+}
+
+/**
+ * Whether this change is a spawn's arrival rather than the user opening another
+ * session — in which case the optimistic rows stay.
+ */
+export function isSpawnArrival({ sessionId, previousSessionId, adoptedSessionId }: SessionSwitchFacts): boolean {
+  if (!sessionId) return false;
+  // The recorded id is checked FIRST and covers both orderings: it is written
+  // before the URL moves, so a child that answered mid-run and one that answered
+  // after the run ended are the same fact here.
+  if (adoptedSessionId === sessionId) return true;
+  // `new-…` → UUID. Kept as a fallback for a spawn whose record was already
+  // consumed (the pending store hands the adoption to the session-state
+  // provider once), where the URL's own shape is the only evidence left.
+  return previousSessionId?.startsWith('new-') === true && !sessionId.startsWith('new-');
+}
+
+/**
+ * Whether `sessionId` is one THIS PAGE spawned, so an empty committed payload
+ * means "not written yet" rather than "nothing happened".
+ */
+export function isOwnSpawn(sessionId: string | null, adoptedSessionId: string | null): boolean {
+  if (!sessionId) return false;
+  return sessionId.startsWith('new-') || adoptedSessionId === sessionId;
+}

package/src/client/hooks/chat/timeline/spawn-target.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The worktree a pending chat picked, as a ref the SEND path can read.
+ *
+ * The composer is remounted by a stretch, a tab switch and a reload, while the
+ * send handler is created once per deps record — so a pick read from render
+ * state there would be missed, which is the one outcome the pick exists to
+ * prevent. The persisted copy is `chat.spawnTarget` (it survives a reload, and
+ * a second tab sees it); the ref is its render-visible mirror.
+ *
+ * Same shape as the waiting pick's ref (`waiting/choice.ts`), for the same
+ * reason: a value written before the send and read at send time cannot travel
+ * through props that rebuild.
+ */
+
+import { useEffect, useRef } from 'preact/hooks';
+import { useSessionState } from '@/client/hooks/workspace/session-state/index';
+
+/** Where the chat that has not started will run. */
+export interface SpawnTarget {
+  folderId: number | null;
+  /** Absolute worktree path, or null for the folder's own checkout. */
+  worktreePath: string | null;
+}
+
+/** `chat.spawnTarget` — the persisted pick, shared by both layouts' composers. */
+export const SPAWN_TARGET_KEY = 'chat.spawnTarget';
+
+export interface SpawnTargetBinding {
+  /** The pick, for a control that draws it (the composer's target picker). */
+  target: SpawnTarget | null;
+  setTarget: (next: SpawnTarget | null) => void;
+  /** The send path's view: set before the request goes out. */
+  worktreePathRef: { current: string | null };
+}
+
+export function useSpawnTarget(sessionId: string | null): SpawnTargetBinding {
+  const [target, setTarget] = useSessionState<SpawnTarget | null>(SPAWN_TARGET_KEY, null);
+  const worktreePathRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    // A pick for ANOTHER session must not leak into this one: the store is keyed
+    // by session, so a change of session id re-reads and this effect re-mirrors.
+    worktreePathRef.current = target?.worktreePath ?? null;
+  }, [target, sessionId]);
+
+  return { target, setTarget, worktreePathRef };
+}

package/src/client/hooks/chat/timeline/tool-open.test.ts

@@ -20,6 +20,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import { Window } from 'happy-dom';
 import { h, render } from 'preact';
+import { useState } from 'preact/hooks';
 import { act } from 'preact/test-utils';
 import { useToolOpenState, TOOL_OPEN_STATE_KEY, type ToolOpenState } from '@/client/hooks/chat/timeline/tool-open';
 import { SessionStateProvider } from '@/client/components/common/session-state-provider';
@@ -139,3 +140,76 @@ describe('useToolOpenState', () => {
     expect(remounted.current?.openMap.a).toBe(true);
   });
 });
+
+describe('useToolOpenState — a streaming eval opens itself', () => {
+  /**
+   * Mount a probe whose tools can be REPLACED, so a status transition is
+   * observable: the reported bug is about a card that was open for the run and
+   * must not snap shut when the call returns.
+   */
+  async function mountMutable(initial: ToolCallData[]) {
+    const api: { current: ToolOpenState | null; setTools: (next: ToolCallData[]) => void } = {
+      current: null,
+      setTools: () => {},
+    };
+    function Probe() {
+      const [tools, setTools] = useState(initial);
+      api.setTools = setTools;
+      api.current = useToolOpenState(tools, false);
+      return null;
+    }
+    container = document.createElement('div');
+    document.body.appendChild(container);
+    await act(async () => {
+      render(h(SessionStateProvider, { sessionId: SESSION, children: h(Probe, {}) }), container);
+    });
+    await act(async () => {
+      for (let i = 0; i < 8; i++) await Promise.resolve();
+    });
+    return api;
+  }
+
+  const evalTool = (partial: Partial<ToolCallData> = {}) =>
+    tool('e1', { type: 'eval', name: 'eval', title: 'Counting lines', ...partial });
+
+  test('a running eval is open, so its streamed output is visible', async () => {
+    const api = await mountMutable([evalTool({ status: 'running' })]);
+    expect(api.current?.openMap.e1).toBe(true);
+  });
+
+  test('it STAYS open once the call settles', async () => {
+    const api = await mountMutable([evalTool({ status: 'running' })]);
+    await act(async () => {
+      api.setTools([evalTool({ status: 'success', output: 'line 1' })]);
+    });
+    // Re-deriving from `status` alone closed the card at the exact moment the
+    // reader wants the result — the `wait` lesson, restated for eval.
+    expect(api.current?.openMap.e1).toBe(true);
+  });
+
+  test('a settled eval from a reloaded transcript stays closed', async () => {
+    // History is not a live run: opening every past eval would bury the
+    // conversation under scripts nobody asked to see again.
+    const api = await mountMutable([evalTool({ status: 'success', output: 'line 1' })]);
+    expect(api.current?.openMap.e1).toBe(false);
+  });
+
+  test('a running bash is still folded', async () => {
+    // The auto-open is for the card whose body IS the answer, not for every
+    // streaming call — a bash log belongs folded.
+    const api = await mountMutable([tool('b1', { status: 'running' })]);
+    expect(api.current?.openMap.b1).toBe(false);
+  });
+
+  test('the reader can still close a running eval, and it stays closed', async () => {
+    const api = await mountMutable([evalTool({ status: 'running' })]);
+    await act(async () => {
+      api.current?.toggle('e1');
+    });
+    expect(api.current?.openMap.e1).toBe(false);
+    await act(async () => {
+      api.setTools([evalTool({ status: 'success', output: 'line 1' })]);
+    });
+    expect(api.current?.openMap.e1).toBe(false);
+  });
+});

package/src/client/hooks/chat/timeline/tool-open.ts

@@ -18,7 +18,7 @@
  * session blob.
  */
 
-import { useCallback, useMemo } from 'preact/hooks';
+import { useCallback, useEffect, useMemo, useRef } from 'preact/hooks';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 import { isSkippedTool } from '@/shared/lib/chat/tool-status';
 import type { ToolCallData } from '@/shared/types/chat';
@@ -42,6 +42,22 @@ export const TOOL_OPEN_STATE_KEY = 'chat.toolOpen';
  * belongs folded, while a wait's is three short rows.
  *
  * A stored choice still wins, so closing it stays closed.
+ *
+ * An `eval` is the second such card, and it is the one a reader reported: a
+ * script cell streams its stdout as it runs, and a collapsed card showed
+ * `Running` with the output invisible for the whole call — the panel had drawn
+ * it all along, folded away, and only expanding by hand (or waiting for the
+ * call to return) revealed it. It differs from `bash` the same way `wait` does:
+ * an eval's output IS the answer, not a log to consult afterwards, and the
+ * reader is watching it arrive.
+ *
+ * A card that was OPENED because it was running stays open once it settles —
+ * `watchedIds` records that, in memory only. Collapsing at the settle would
+ * take the output away at the exact moment the reader wants to read it (the
+ * `wait` lesson above), while re-deriving from `status` alone would do exactly
+ * that. The record is deliberately not persisted: a reloaded transcript is
+ * history, and every historical eval reopening itself would bury the
+ * conversation under scripts nobody asked to see again.
  */
 function defaultOpen(tool: ToolCallData, autoOpenFirst: boolean, index: number): boolean {
   if (isSkippedTool(tool)) return false;
@@ -50,6 +66,12 @@ function defaultOpen(tool: ToolCallData, autoOpenFirst: boolean, index: number):
   return autoOpenFirst && index === 0;
 }
 
+/** True while this call is a script cell that is still producing output. */
+function isStreamingEval(tool: ToolCallData): boolean {
+  if (tool.status !== 'running') return false;
+  return (tool.name || tool.type) === 'eval';
+}
+
 export interface ToolOpenState {
   /** Resolved openness per tool id — stored choice first, default second. */
   openMap: Record<string, boolean>;
@@ -59,28 +81,50 @@ export interface ToolOpenState {
 
 export function useToolOpenState(tools: ToolCallData[], autoOpenFirst: boolean): ToolOpenState {
   const [stored, setStored] = useSessionState<Record<string, boolean>>(TOOL_OPEN_STATE_KEY, {});
+  /** Ids opened BECAUSE they were streaming; see `defaultOpen`'s eval note. */
+  const watchedRef = useRef<Set<string>>(new Set());
+
+  const streamingEvalIds = useMemo(
+    () => tools.filter(isStreamingEval).map((tool) => tool.id),
+    [tools],
+  );
+  // Recorded after the render that opened them, so the open survives the call
+  // settling. In memory only: a reloaded transcript is history.
+  useEffect(() => {
+    for (const id of streamingEvalIds) watchedRef.current.add(id);
+  }, [streamingEvalIds]);
+
+  /**
+   * The default a card is RENDERING, before any stored choice. One function for
+   * the map and for `toggle`, because a toggle that flips a different default
+   * than the one on screen takes two clicks to close an auto-opened card — the
+   * streaming eval made that reachable, since its default now depends on more
+   * than `status`.
+   */
+  const renderedDefault = useCallback(
+    (tool: ToolCallData, index: number): boolean =>
+      isStreamingEval(tool) || watchedRef.current.has(tool.id) || defaultOpen(tool, autoOpenFirst, index),
+    [autoOpenFirst],
+  );
 
   const openMap = useMemo(() => {
     const map: Record<string, boolean> = {};
     tools.forEach((tool, index) => {
       const explicit = stored[tool.id];
-      map[tool.id] = explicit === undefined ? defaultOpen(tool, autoOpenFirst, index) : explicit;
+      map[tool.id] = explicit === undefined ? renderedDefault(tool, index) : explicit;
     });
     return map;
-  }, [tools, stored, autoOpenFirst]);
+  }, [tools, stored, renderedDefault]);
 
   const toggle = useCallback(
     (toolId: string) => {
       setStored((prev) => {
         const tool = tools.find((entry) => entry.id === toolId);
-        // The first toggle of an untouched call has to flip its DERIVED default,
-        // not an absent key — otherwise an auto-opened error would need two
-        // clicks to close.
-        const current = prev[toolId] ?? (tool ? defaultOpen(tool, autoOpenFirst, tools.indexOf(tool)) : false);
+        const current = prev[toolId] ?? (tool ? renderedDefault(tool, tools.indexOf(tool)) : false);
         return { ...prev, [toolId]: !current };
       });
     },
-    [setStored, tools, autoOpenFirst],
+    [setStored, tools, renderedDefault],
   );
 
   return { openMap, toggle };