@kabmo-labs/kabmo 0.8.0 → 0.9.0

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

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The harness both session-load suites share.
+ *
+ * Split out when the suite passed the per-file ceiling. It mounts the REAL
+ * `useSessionLoad` through a `Probe` component and gates every `/api/chat/:id`
+ * response, so a suite decides when — and with what — a fetch lands.
+ *
+ * The committed-history contract itself:
+ *
+ * While a run is live the timeline's rows are the STREAM's, and a committed
+ * fetch is a lagging snapshot: 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 cost the operator their own turn in both directions, measured on real
+ * sessions:
+ *
+ *   - an empty payload EMPTIED the list, so the turn they had just sent
+ *     vanished until a reload;
+ *   - 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.
+ *
+ * Both shapes needed the same hole: the guard was keyed on the AI placeholder,
+ * which the stream RELEASES at the first assistant `message_end` while the run
+ * continues. These cases pin the run as the ownership signal, and pin the two
+ * directions the guard must still let through when no run is live.
+ */
+
+import { afterAll, afterEach, beforeAll } from 'bun:test';
+import { Window } from 'happy-dom';
+import { h, render } from 'preact';
+import { act } from 'preact/test-utils';
+import { useCallback, useRef, useState } from 'preact/hooks';
+import { installDomGlobals, restoreDomGlobals } from '@/test-support/pristine-globals';
+import { useSessionLoad } from '@/client/hooks/chat/timeline/session-load';
+import type { ChatMessageData } from '@/shared/types';
+
+/** The runner's own fetch, reached through `Bun` so a leak is not mistaken for it. */
+const originalFetch = Bun.fetch;
+
+/** The optimistic bubble `executeSend` mounts for a locally sent turn. */
+export const OPTIMISTIC_USER: ChatMessageData = { id: 'msg-1-user', role: 'user', content: 'halo', date: 'Today, 12:22 PM' };
+/** The empty assistant row the stream fills. */
+export const AI_PLACEHOLDER: ChatMessageData = { id: 'msg-2-ai', role: 'ai', content: '' };
+/** The same turn as the transcript records it, under its own id. */
+export const ECHOED_TURN: ChatMessageData = { id: 'omp-echo', role: 'user', content: 'halo' };
+
+interface LoadGate {
+  url: string;
+  resolve: (body: unknown) => void;
+}
+
+export const gates: LoadGate[] = [];
+
+/** One mount's observable state: what the timeline holds and what drives it. */
+export interface ProbeApi {
+  messages: ChatMessageData[];
+  adoptedSessionIdRef: { current: string | null };
+  setMessages: (next: ChatMessageData[]) => void;
+  isGeneratingRef: { current: boolean };
+  ownRunRef: { current: boolean };
+  aiPlaceholderIdRef: { current: string | null };
+  optimisticUserIdRef: { current: string | null };
+  generatingCalls: boolean[];
+}
+
+export function makeApi(): ProbeApi {
+  return {
+    messages: [],
+    adoptedSessionIdRef: { current: null },
+    setMessages: () => {},
+    isGeneratingRef: { current: false },
+    ownRunRef: { current: false },
+    aiPlaceholderIdRef: { current: null },
+    optimisticUserIdRef: { current: null },
+    generatingCalls: [],
+  };
+}
+
+function Probe({ sessionId, api }: { sessionId: string | null; api: ProbeApi }) {
+  const [messages, setMessages] = useState<ChatMessageData[]>([]);
+  const isGeneratingRef = useRef(false);
+  const ownRunRef = useRef(false);
+  const streamRunRef = useRef(false);
+  const serverRunRef = useRef(false);
+  const aiPlaceholderIdRef = useRef<string | null>(null);
+  const optimisticUserIdRef = useRef<string | null>(null);
+  const pendingUserDisplaysRef = useRef<{ sent: string; display: string }[]>([]);
+  const metaRefreshedRef = useRef<string | null>(null);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const jumpActiveRef = useRef(false);
+  const jumpCountRef = useRef(0);
+  // Stable across renders, like the timeline's own `setGenerating` throat: a
+  // fresh identity would re-run the load effect on every render.
+  const setGenerating = useCallback((v: boolean) => {
+    isGeneratingRef.current = v;
+    api.generatingCalls.push(v);
+  }, [api]);
+
+  api.messages = messages;
+  api.setMessages = setMessages;
+  api.isGeneratingRef = isGeneratingRef;
+  api.ownRunRef = ownRunRef;
+  api.aiPlaceholderIdRef = aiPlaceholderIdRef;
+  api.optimisticUserIdRef = optimisticUserIdRef;
+
+  const { adoptedSessionIdRef } = useSessionLoad({
+    sessionId,
+    setLocalMessages: setMessages,
+    setGenerating,
+    isGeneratingRef,
+    ownRunRef,
+    streamRunRef,
+    serverRunRef,
+    aiPlaceholderIdRef,
+    optimisticUserIdRef,
+    pendingUserDisplaysRef,
+    cancelStreamingCoalescer: () => {},
+    metaRefreshedRef,
+    scrollRef,
+    jumpActiveRef,
+    jumpCountRef,
+  });
+  api.adoptedSessionIdRef = adoptedSessionIdRef;
+  return null;
+}
+
+let container: HTMLElement | undefined;
+
+beforeAll(() => {
+  installDomGlobals(new Window({ url: 'http://localhost' }));
+});
+
+afterAll(() => {
+  restoreDomGlobals();
+  globalThis.fetch = originalFetch;
+});
+
+afterEach(() => {
+  if (container) render(null, container);
+  container?.remove();
+  container = undefined;
+  gates.length = 0;
+});
+
+/** Stub the loader so the test decides when (and with what) the fetch lands. */
+export function stubChatFetch(): void {
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+    const { promise, resolve } = Promise.withResolvers<Response>();
+    gates.push({ url, resolve: (body) => resolve(new Response(JSON.stringify(body))) });
+    return promise;
+  }) as typeof fetch;
+}
+
+/** Mount the real hook and let its session-load effect register its fetch. */
+export async function mount(sessionId: string, api: ProbeApi): Promise<void> {
+  container ??= document.body.appendChild(document.createElement('div'));
+  await act(async () => {
+    render(h(Probe, { sessionId, api }), container as HTMLElement);
+  });
+  await act(async () => {});
+}
+
+/** Land the registered fetch, as the server's response would. */
+export async function resolveLoad(messages: unknown[], index = 0): Promise<void> {
+  const gate = gates[index];
+  if (!gate) throw new Error('no session fetch was registered');
+  await act(async () => {
+    gate.resolve({ session: { id: 'sess-1', messages }, hasMore: false, oldestIndex: 0 });
+  });
+  for (let i = 0; i < 3; i += 1) await act(async () => {});
+}
+
+/**
+ * Re-render the mounted Probe with a new session id, which is what the spawn
+ * adoption (`new-…` → UUID) does when the URL flips while the child streams:
+ * the session-load effect re-runs and ISSUES its history fetch at that moment,
+ * mid-run. The fetch registered before this call is `gates[0]`; the one this
+ * issues is `gates[1]`.
+ */
+export async function switchSession(sessionId: string, api: ProbeApi): Promise<void> {
+  await act(async () => {
+    render(h(Probe, { sessionId, api }), container as HTMLElement);
+  });
+  await act(async () => {});
+}
+
+/** A run this page started, with its optimistic rows already on screen. */
+export async function startLiveRun(api: ProbeApi): Promise<void> {
+  await act(async () => {
+    api.isGeneratingRef.current = true;
+    api.ownRunRef.current = true;
+    api.optimisticUserIdRef.current = OPTIMISTIC_USER.id;
+    api.setMessages([OPTIMISTIC_USER, AI_PLACEHOLDER]);
+  });
+}
+
+export const ids = (api: ProbeApi) => api.messages.map((m) => m.id);
+

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

@@ -4,7 +4,7 @@
  */
 
 /**
- * The committed-history fetch vs a run this page started.
+ * The committed-history fetch vs a run this page started, and a spawn's arrival.
  *
  * While a run is live the timeline's rows are the STREAM's, and a committed
  * fetch is a lagging snapshot: for a fresh spawn there may be no transcript on
@@ -23,170 +23,25 @@
  * which the stream RELEASES at the first assistant `message_end` while the run
  * continues. These cases pin the run as the ownership signal, and pin the two
  * directions the guard must still let through when no run is live.
+ *
+ * The harness is `session-load.test-util.ts`.
  */
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test';
-import { Window } from 'happy-dom';
-import { h, render } from 'preact';
+import { describe, expect, test } from 'bun:test';
 import { act } from 'preact/test-utils';
-import { useCallback, useRef, useState } from 'preact/hooks';
-import { installDomGlobals, restoreDomGlobals } from '@/test-support/pristine-globals';
-import { useSessionLoad } from '@/client/hooks/chat/timeline/session-load';
-import type { ChatMessageData } from '@/shared/types';
-
-/** The runner's own fetch, reached through `Bun` so a leak is not mistaken for it. */
-const originalFetch = Bun.fetch;
-
-/** The optimistic bubble `executeSend` mounts for a locally sent turn. */
-const OPTIMISTIC_USER: ChatMessageData = { id: 'msg-1-user', role: 'user', content: 'halo', date: 'Today, 12:22 PM' };
-/** The empty assistant row the stream fills. */
-const AI_PLACEHOLDER: ChatMessageData = { id: 'msg-2-ai', role: 'ai', content: '' };
-/** The same turn as the transcript records it, under its own id. */
-const ECHOED_TURN: ChatMessageData = { id: 'omp-echo', role: 'user', content: 'halo' };
-
-interface LoadGate {
-  url: string;
-  resolve: (body: unknown) => void;
-}
-
-const gates: LoadGate[] = [];
-
-/** One mount's observable state: what the timeline holds and what drives it. */
-interface ProbeApi {
-  messages: ChatMessageData[];
-  setMessages: (next: ChatMessageData[]) => void;
-  isGeneratingRef: { current: boolean };
-  ownRunRef: { current: boolean };
-  aiPlaceholderIdRef: { current: string | null };
-  optimisticUserIdRef: { current: string | null };
-  generatingCalls: boolean[];
-}
-
-function makeApi(): ProbeApi {
-  return {
-    messages: [],
-    setMessages: () => {},
-    isGeneratingRef: { current: false },
-    ownRunRef: { current: false },
-    aiPlaceholderIdRef: { current: null },
-    optimisticUserIdRef: { current: null },
-    generatingCalls: [],
-  };
-}
-
-function Probe({ sessionId, api }: { sessionId: string | null; api: ProbeApi }) {
-  const [messages, setMessages] = useState<ChatMessageData[]>([]);
-  const isGeneratingRef = useRef(false);
-  const ownRunRef = useRef(false);
-  const aiPlaceholderIdRef = useRef<string | null>(null);
-  const optimisticUserIdRef = useRef<string | null>(null);
-  const metaRefreshedRef = useRef<string | null>(null);
-  const scrollRef = useRef<HTMLDivElement>(null);
-  const jumpActiveRef = useRef(false);
-  const jumpCountRef = useRef(0);
-  // Stable across renders, like the timeline's own `setGenerating` throat: a
-  // fresh identity would re-run the load effect on every render.
-  const setGenerating = useCallback((v: boolean) => {
-    isGeneratingRef.current = v;
-    api.generatingCalls.push(v);
-  }, [api]);
-
-  api.messages = messages;
-  api.setMessages = setMessages;
-  api.isGeneratingRef = isGeneratingRef;
-  api.ownRunRef = ownRunRef;
-  api.aiPlaceholderIdRef = aiPlaceholderIdRef;
-  api.optimisticUserIdRef = optimisticUserIdRef;
-
-  useSessionLoad({
-    sessionId,
-    setLocalMessages: setMessages,
-    setGenerating,
-    isGeneratingRef,
-    ownRunRef,
-    aiPlaceholderIdRef,
-    optimisticUserIdRef,
-    cancelStreamingCoalescer: () => {},
-    metaRefreshedRef,
-    scrollRef,
-    jumpActiveRef,
-    jumpCountRef,
-  });
-  return null;
-}
-
-let container: HTMLElement | undefined;
-
-beforeAll(() => {
-  installDomGlobals(new Window({ url: 'http://localhost' }));
-});
-
-afterAll(() => {
-  restoreDomGlobals();
-  globalThis.fetch = originalFetch;
-});
-
-afterEach(() => {
-  if (container) render(null, container);
-  container?.remove();
-  container = undefined;
-  gates.length = 0;
-});
-
-/** Stub the loader so the test decides when (and with what) the fetch lands. */
-function stubChatFetch(): void {
-  globalThis.fetch = (async (input: RequestInfo | URL) => {
-    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
-    const { promise, resolve } = Promise.withResolvers<Response>();
-    gates.push({ url, resolve: (body) => resolve(new Response(JSON.stringify(body))) });
-    return promise;
-  }) as typeof fetch;
-}
-
-/** Mount the real hook and let its session-load effect register its fetch. */
-async function mount(sessionId: string, api: ProbeApi): Promise<void> {
-  container ??= document.body.appendChild(document.createElement('div'));
-  await act(async () => {
-    render(h(Probe, { sessionId, api }), container as HTMLElement);
-  });
-  await act(async () => {});
-}
-
-/** Land the registered fetch, as the server's response would. */
-async function resolveLoad(messages: unknown[], index = 0): Promise<void> {
-  const gate = gates[index];
-  if (!gate) throw new Error('no session fetch was registered');
-  await act(async () => {
-    gate.resolve({ session: { id: 'sess-1', messages }, hasMore: false, oldestIndex: 0 });
-  });
-  for (let i = 0; i < 3; i += 1) await act(async () => {});
-}
-
-/**
- * Re-render the mounted Probe with a new session id, which is what the spawn
- * adoption (`new-…` → UUID) does when the URL flips while the child streams:
- * the session-load effect re-runs and ISSUES its history fetch at that moment,
- * mid-run. The fetch registered before this call is `gates[0]`; the one this
- * issues is `gates[1]`.
- */
-async function switchSession(sessionId: string, api: ProbeApi): Promise<void> {
-  await act(async () => {
-    render(h(Probe, { sessionId, api }), container as HTMLElement);
-  });
-  await act(async () => {});
-}
-
-/** A run this page started, with its optimistic rows already on screen. */
-async function startLiveRun(api: ProbeApi): Promise<void> {
-  await act(async () => {
-    api.isGeneratingRef.current = true;
-    api.ownRunRef.current = true;
-    api.optimisticUserIdRef.current = OPTIMISTIC_USER.id;
-    api.setMessages([OPTIMISTIC_USER, AI_PLACEHOLDER]);
-  });
-}
-
-const ids = (api: ProbeApi) => api.messages.map((m) => m.id);
+import {
+  AI_PLACEHOLDER,
+  ECHOED_TURN,
+  OPTIMISTIC_USER,
+  ids,
+  makeApi,
+  mount,
+  resolveLoad,
+  gates,
+  startLiveRun,
+  stubChatFetch,
+  switchSession,
+} from '@/client/hooks/chat/timeline/session-load.test-util';
 
 describe('a committed fetch while a run this page started is live', () => {
   test('keeps the live timeline when the payload carries the turn under its own id', async () => {
@@ -271,6 +126,50 @@ describe('a committed fetch while a run this page started is live', () => {
   });
 });
 
+describe('a spawn that adopted its id after the run ended', () => {
+  /**
+   * The chat opened from a WORKSPACE (`?folderId=` and no `?sessionId=`), so the
+   * first send starts from a null session id and the URL flips to the child's
+   * UUID when the spawn answers. `isSpawnAdopt` only recognises a `new-…` →
+   * UUID move, and `isAdoptingInFlight` also required the run to still be
+   * generating — so a FAST child (the scripted one answers in milliseconds)
+   * finished before the URL flip, the reset branch ran, and the turn that had
+   * just rendered was cleared. Measured in CI on three specs at once
+   * (`rename.e2e.ts`, `editor.e2e.ts`'s drop case, `chat.e2e.ts`'s settle
+   * case): the answer was on screen and then the timeline was empty.
+   */
+  test('keeps the optimistic rows when the adopted id arrives after the run settled', async () => {
+    stubChatFetch();
+    const api = makeApi();
+    await mount('', api);
+    // The send: optimistic rows mounted, the run owned by this page…
+    await act(async () => {
+      api.isGeneratingRef.current = true;
+      api.ownRunRef.current = true;
+      api.optimisticUserIdRef.current = OPTIMISTIC_USER.id;
+      api.setMessages([OPTIMISTIC_USER, AI_PLACEHOLDER]);
+    });
+    // …and it ENDED before the spawn's id reached the URL.
+    await act(async () => {
+      api.isGeneratingRef.current = false;
+      api.ownRunRef.current = false;
+    });
+    // The spawn answered: the send path records the id it adopted, and the URL
+    // moves to it.
+    api.adoptedSessionIdRef.current = 'sess-1';
+
+    await switchSession('sess-1', api);
+    // The fetch the URL flip issued answers with the transcript omp has not
+    // written yet — the second half of the same bug, and the one that emptied
+    // the timeline even once the reset was skipped.
+    // `gates[0]`: the mount was a null session, so this flip issued the FIRST
+    // read.
+    await resolveLoad([], 0);
+
+    expect(ids(api)).toEqual([OPTIMISTIC_USER.id, AI_PLACEHOLDER.id]);
+  });
+});
+
 describe('a committed fetch with no local run', () => {
   test('lands the transcript, which is the reload-mid-run and open-a-session path', async () => {
     stubChatFetch();

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,
   };
 }