@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/client/hooks/chat/omp/session-list.activity.test.ts

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `sidebar:activity` — the topic a tool call republishes.
+ *
+ * Its whole reason to exist is that the STRUCTURE must not be republished per
+ * tool call (216 KB over 731 sessions, measured), so the merge has to be exact:
+ * it may only ever move the two fields a run advances mid-turn, and only
+ * forwards. Each case below is a way that goes wrong.
+ */
+
+import { afterAll, afterEach, describe, expect, test } from 'bun:test';
+
+import { restoreDomGlobals } from '@/test-support/pristine-globals';
+import {
+  mountProvider,
+  structureBody,
+  teardownProvider,
+} from '@/client/hooks/chat/omp/session-list.test-util';
+
+afterEach(teardownProvider);
+
+afterAll(() => {
+  restoreDomGlobals();
+});
+
+describe('SidebarDataProvider merges the activity topic', () => {
+  test('advances a running row past the stamp the structure shipped', async () => {
+    const harness = await mountProvider();
+    await harness.push(
+      {
+        folders: [{
+          id: 1, name: 'ws', isExpanded: true, hasMore: false, totalSessions: 1,
+          sessions: [{ id: 'a', folder_id: 1, title: 'A', updated_at: '2026-10-24T01:00:00.000Z' }],
+        }],
+        isMock: false,
+      },
+    );
+    expect(harness.holder.api?.folders[0]?.sessions?.[0].updated_at).toBe('2026-10-24T01:00:00.000Z');
+
+    await harness.push(undefined, undefined, { a: { updatedAt: '2026-10-24T01:05:00.000Z' } });
+    expect(harness.holder.api?.folders[0]?.sessions?.[0].updated_at).toBe('2026-10-24T01:05:00.000Z');
+    harness.server.stop();
+  });
+
+  test('never moves a row backwards, so a late frame cannot reorder the list', async () => {
+    const harness = await mountProvider();
+    // The structure already carries a stamp the activity payload has not caught
+    // up with — the normal case right after a turn boundary.
+    await harness.push({
+      folders: [{
+        id: 1, name: 'ws', isExpanded: true, hasMore: false, totalSessions: 1,
+        sessions: [{ id: 'a', folder_id: 1, title: 'A', updated_at: '2026-10-24T02:00:00.000Z' }],
+      }],
+      isMock: false,
+    });
+
+    await harness.push(undefined, undefined, { a: { updatedAt: '2026-10-24T01:59:00.000Z' } });
+    expect(harness.holder.api?.folders[0]?.sessions?.[0].updated_at).toBe('2026-10-24T02:00:00.000Z');
+    harness.server.stop();
+  });
+
+  test('lights the subagent chevron for a subagent seen mid-run', async () => {
+    const harness = await mountProvider();
+    await harness.push(structureBody());
+    expect(harness.holder.api?.folders[0]?.sessions?.[0].hasSubagents).toBeFalsy();
+
+    await harness.push(undefined, undefined, { a: { updatedAt: '2026-10-24T01:05:00.000Z', hasSubagents: true } });
+    expect(harness.holder.api?.folders[0]?.sessions?.[0].hasSubagents).toBe(true);
+    harness.server.stop();
+  });
+
+  test('a live read that saw no subagent does not clear a chevron the scan lit', async () => {
+    // The two sources run the SAME presence check, but the structure's answer
+    // came from a full scan and this one from a live read of one file. A
+    // `false` here is "not seen in this read", so it must not unlight a row —
+    // the merge ORs against the structure for exactly that reason.
+    const harness = await mountProvider();
+    await harness.push({
+      folders: [{
+        id: 1, name: 'ws', isExpanded: true, hasMore: false, totalSessions: 1,
+        sessions: [{ id: 'a', folder_id: 1, title: 'A', hasSubagents: true }],
+      }],
+      isMock: false,
+    });
+
+    await harness.push(undefined, undefined, { a: { updatedAt: '2026-10-24T01:05:00.000Z', hasSubagents: false } });
+    expect(harness.holder.api?.folders[0]?.sessions?.[0].hasSubagents).toBe(true);
+    harness.server.stop();
+  });
+
+  test('leaves an id the payload does not name on the structure stamp', async () => {
+    const harness = await mountProvider();
+    await harness.push({
+      folders: [{
+        id: 1, name: 'ws', isExpanded: true, hasMore: false, totalSessions: 2,
+        sessions: [
+          { id: 'a', folder_id: 1, title: 'A', updated_at: '2026-10-24T01:00:00.000Z' },
+          { id: 'b', folder_id: 1, title: 'B', updated_at: '2026-10-24T00:30:00.000Z' },
+        ],
+      }],
+      isMock: false,
+    });
+
+    await harness.push(undefined, undefined, { a: { updatedAt: '2026-10-24T01:05:00.000Z' } });
+    const sessions = harness.holder.api?.folders[0]?.sessions ?? [];
+    expect(sessions[0]?.updated_at).toBe('2026-10-24T01:05:00.000Z');
+    expect(sessions[1]?.updated_at).toBe('2026-10-24T00:30:00.000Z');
+    harness.server.stop();
+  });
+});

package/src/client/hooks/chat/omp/session-list.test-util.ts

@@ -0,0 +1,164 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shared harness for the `SidebarDataProvider` suites.
+ *
+ * Driven through a REAL server and a real socket rather than a stubbed fetch,
+ * because what the provider does is merge three topics and apply the optimistic
+ * overlays — the parts that used to be "does it re-read". A stubbed socket
+ * would only prove the fake's timing.
+ *
+ * Split out when the suites together crossed the repo's per-file ceiling: the
+ * harness is setup, and the rules under test belong in their own files.
+ */
+
+import { Window } from 'happy-dom';
+import { h, render } from 'preact';
+import { act } from 'preact/test-utils';
+
+import { SidebarDataProvider, useSidebarData } from '@/client/hooks/chat/omp/session-list';
+import type { SidebarDataHandle } from '@/client/hooks/chat/omp/session-list';
+import { resetRealtimeClient } from '@/shared/lib/realtime/client';
+import { TOPIC_SIDEBAR, TOPIC_SIDEBAR_ACTIVITY, TOPIC_SIDEBAR_STATUS } from '@/shared/lib/realtime/protocol';
+import { startRealtimeTestServer, type RealtimeTestServer } from '@/test-support/realtime-server';
+import type { TopicResolver } from '@/server/lib/realtime/hub.server';
+import { installDomGlobals, pristineWebSocket } from '@/test-support/pristine-globals';
+import type { SidebarActivityPayload, SidebarPayload, SidebarStatusPayload } from '@/client/hooks/chat/omp/session-list';
+import type { WorkspaceFolderData } from '@/shared/types';
+
+let container: HTMLElement | undefined;
+
+/**
+ * Point the DOM globals at a happy-dom window whose origin is the test
+ * listener, because the client builds its socket URL from `window.location` —
+ * a window on a different port would dial a server that is not there, and the
+ * test would be measuring a connection failure rather than the channel.
+ */
+function installDom(origin: string): void {
+  const win = new Window({ url: origin });
+  installDomGlobals(win);
+  // happy-dom's WebSocket does not reach a real listener, and the channel is
+  // what is under test, so the real implementation wins this global.
+  (globalThis as unknown as Record<string, unknown>).WebSocket = pristineWebSocket;
+}
+
+/** Unmount and drop the socket between cases. Each suite calls this in its own `afterEach`. */
+export function teardownProvider(): void {
+  if (container) render(null, container);
+  container?.remove();
+  container = undefined;
+  resetRealtimeClient();
+}
+
+export type Status = 'stream' | 'finish' | 'abort';
+
+/** A structure payload carrying one session, `a`. */
+export function structureBody(): SidebarPayload {
+  return {
+    folders: [{ id: 1, name: 'ws', isExpanded: true, hasMore: false, totalSessions: 1, sessions: [{ id: 'a', folder_id: 1, title: 'A' }] }],
+    isMock: false,
+  };
+}
+
+/** The volatile map for `a`. */
+export function statusBody(status?: Status): SidebarStatusPayload {
+  return status ? { a: { streamStatus: status } } : {};
+}
+
+/** The live-activity map: empty until a case publishes one. */
+export function activityBody(): SidebarActivityPayload {
+  return {};
+}
+
+/** One folder holding the given sessions, shaped only as far as the strip reads it. */
+export function folders(sessions: Array<{ id: string; streamStatus?: Status }>): WorkspaceFolderData[] {
+  return [{ id: 1, name: 'ws', sessions }] as unknown as WorkspaceFolderData[];
+}
+
+/** The status the provider currently renders for session `a`. */
+export function renderedStatus(api: SidebarDataHandle | null): Status | undefined {
+  return api?.folders[0]?.sessions?.[0].streamStatus;
+}
+
+/**
+ * Let Preact's queued effects run.
+ *
+ * A microtask drain, and deliberately nothing more: the socket's own progress
+ * is awaited through the harness, so this only has to flush the render a
+ * received frame queued.
+ */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 8; i += 1) await Promise.resolve();
+}
+
+export interface Harness {
+  server: RealtimeTestServer;
+  holder: { api: SidebarDataHandle | null };
+  /** Republish any of the three sidebar topics from a fresh body. */
+  push: (structure?: SidebarPayload, status?: SidebarStatusPayload, activity?: SidebarActivityPayload) => Promise<void>;
+}
+
+/** Mount the real provider against a real realtime server. */
+export async function mountProvider(): Promise<Harness> {
+  const server = await startRealtimeTestServer(new Map<string, TopicResolver>([
+    [TOPIC_SIDEBAR, async () => structureBody()],
+    [TOPIC_SIDEBAR_STATUS, async () => statusBody()],
+    [TOPIC_SIDEBAR_ACTIVITY, async () => activityBody()],
+  ]));
+  installDom(`http://127.0.0.1:${server.port}`);
+
+  const holder: { api: SidebarDataHandle | null } = { api: null };
+  function Probe() {
+    holder.api = useSidebarData();
+    return null;
+  }
+  const el = document.createElement('div');
+  document.body.appendChild(el);
+  container = el;
+  await act(async () => {
+    render(h(SidebarDataProvider, { children: h(Probe, null) }), el);
+  });
+  // The structure snapshot must have landed before the provider can report a
+  // value at all; the subscription is opened by the render above, so this
+  // awaits the client's own state rather than a duration.
+  await server.waitForTopic<SidebarPayload>(TOPIC_SIDEBAR, (value) => value !== null);
+  await act(async () => {
+    await flush();
+  });
+
+  return {
+    server,
+    holder,
+    push: async (structure, status, activity) => {
+      // Await the CLIENT's value, not just the publish: the socket round trip
+      // and the provider's merge are the things under test, so resolving on the
+      // send would assert against a state that has not happened yet.
+      if (structure) {
+        server.publish(TOPIC_SIDEBAR, structure);
+        await server.waitForTopic(TOPIC_SIDEBAR, (value) => JSON.stringify(value) === JSON.stringify(structure));
+      }
+      if (status) {
+        server.publish(TOPIC_SIDEBAR_STATUS, status);
+        await server.waitForTopic(TOPIC_SIDEBAR_STATUS, (value) => JSON.stringify(value) === JSON.stringify(status));
+      }
+      if (activity) {
+        server.publish(TOPIC_SIDEBAR_ACTIVITY, activity);
+        await server.waitForTopic(TOPIC_SIDEBAR_ACTIVITY, (value) => JSON.stringify(value) === JSON.stringify(activity));
+      }
+      await act(async () => {
+        await flush();
+      });
+    },
+  };
+}
+
+/** Run `body` with Preact's effects flushed around it. */
+export async function withAct(body: () => void | Promise<void>): Promise<void> {
+  await act(async () => {
+    await body();
+    await flush();
+  });
+}

package/src/client/hooks/chat/omp/session-list.test.ts

@@ -4,159 +4,34 @@
  */
 
 /**
- * The mounted `SidebarDataProvider` over the unified realtime channel.
+ * The mounted `SidebarDataProvider` over the unified realtime channel: the
+ * STATUS half, the seen-strip overlay, and the title hint.
  *
- * Driven through a REAL server and a real socket rather than a stubbed fetch,
- * because what the provider does now is merge two topics and apply the
- * optimistic overlays — the parts that used to be "does it re-read". A stubbed
- * socket would only prove the fake's timing.
- *
- * Kept: the two-topic merge, the authoritative status map (including a session
- * the structure has not scanned), the seen-strip on an acked terminal badge, and
- * the title hint.
+ * The activity topic's merge rules live in `session-list.activity.test.ts` —
+ * separate because the two halves answer different questions and the file was
+ * over the repo's ceiling with both.
  */
 
 import { afterAll, afterEach, describe, expect, test } from 'bun:test';
-import { Window } from 'happy-dom';
-import { h, render } from 'preact';
-import { act } from 'preact/test-utils';
 
 import { applySeenStrip, SESSION_TITLE_HINT_SIGNAL } from '@/client/hooks/chat/omp/sidebar-overlay';
 import { publishClientSignal } from '@/client/lib/signals';
-import { SidebarDataProvider, useSidebarData } from '@/client/hooks/chat/omp/session-list';
-import type { SidebarDataHandle } from '@/client/hooks/chat/omp/session-list';
-import { resetRealtimeClient } from '@/shared/lib/realtime/client';
-import { TOPIC_SIDEBAR, TOPIC_SIDEBAR_STATUS } from '@/shared/lib/realtime/protocol';
-import { startRealtimeTestServer, type RealtimeTestServer } from '@/test-support/realtime-server';
-import type { TopicResolver } from '@/server/lib/realtime/hub.server';
-import { installDomGlobals, pristineWebSocket, restoreDomGlobals } from '@/test-support/pristine-globals';
-import type { SidebarPayload, SidebarStatusPayload } from '@/client/hooks/chat/omp/session-list';
-import type { WorkspaceFolderData } from '@/shared/types';
-
-
-let container: HTMLElement | undefined;
-
-/**
- * Point the DOM globals at a happy-dom window whose origin is the test
- * listener, because the client builds its socket URL from `window.location` —
- * a window on a different port would dial a server that is not there, and the
- * test would be measuring a connection failure rather than the channel.
- */
-function installDom(origin: string): void {
-  const win = new Window({ url: origin });
-  installDomGlobals(win);
-  // happy-dom's WebSocket does not reach a real listener, and the channel is
-  // what is under test, so the real implementation wins this global.
-  (globalThis as unknown as Record<string, unknown>).WebSocket = pristineWebSocket;
-}
-
-
-
-afterEach(() => {
-  if (container) render(null, container);
-  container?.remove();
-  container = undefined;
-  resetRealtimeClient();
-});
+import { restoreDomGlobals } from '@/test-support/pristine-globals';
+import {
+  folders,
+  mountProvider,
+  renderedStatus,
+  statusBody,
+  teardownProvider,
+  withAct,
+} from '@/client/hooks/chat/omp/session-list.test-util';
+
+afterEach(teardownProvider);
 
 afterAll(() => {
   restoreDomGlobals();
 });
 
-
-
-type Status = 'stream' | 'finish' | 'abort';
-
-/** A structure payload carrying one session, `a`. */
-function structureBody(): SidebarPayload {
-  return {
-    folders: [{ id: 1, name: 'ws', isExpanded: true, hasMore: false, totalSessions: 1, sessions: [{ id: 'a', folder_id: 1, title: 'A' }] }],
-    isMock: false,
-  };
-}
-
-/** The volatile map for `a`. */
-function statusBody(status?: Status): SidebarStatusPayload {
-  return status ? { a: { streamStatus: status } } : {};
-}
-
-/** One folder holding the given sessions, shaped only as far as the strip reads it. */
-function folders(sessions: Array<{ id: string; streamStatus?: Status }>): WorkspaceFolderData[] {
-  return [{ id: 1, name: 'ws', sessions }] as unknown as WorkspaceFolderData[];
-}
-
-/** The status the provider currently renders for session `a`. */
-function renderedStatus(api: SidebarDataHandle | null): Status | undefined {
-  return api?.folders[0]?.sessions?.[0].streamStatus;
-}
-
-/**
- * Let Preact's queued effects run.
- *
- * A microtask drain, and deliberately nothing more: the socket's own progress
- * is awaited through the harness (`waitForFrames`), so this only has to flush
- * the render a received frame queued.
- */
-async function flush(): Promise<void> {
-  for (let i = 0; i < 8; i += 1) await Promise.resolve();
-}
-
-interface Harness {
-  server: RealtimeTestServer;
-  holder: { api: SidebarDataHandle | null };
-  /** Republish both topics from the current bodies. */
-  push: (structure?: SidebarPayload, status?: SidebarStatusPayload) => Promise<void>;
-}
-
-/** Mount the real provider against a real realtime server. */
-async function mountProvider(): Promise<Harness> {
-  const server = await startRealtimeTestServer(new Map<string, TopicResolver>([
-    [TOPIC_SIDEBAR, async () => structureBody()],
-    [TOPIC_SIDEBAR_STATUS, async () => statusBody()],
-  ]));
-  installDom(`http://127.0.0.1:${server.port}`);
-
-  const holder: { api: SidebarDataHandle | null } = { api: null };
-  function Probe() {
-    holder.api = useSidebarData();
-    return null;
-  }
-  const el = document.createElement('div');
-  document.body.appendChild(el);
-  container = el;
-  await act(async () => {
-    render(h(SidebarDataProvider, { children: h(Probe, null) }), el);
-  });
-  // The structure snapshot must have landed before the provider can report a
-  // value at all; the subscription is opened by the render above, so this
-  // awaits the client's own state rather than a duration.
-  await server.waitForTopic<SidebarPayload>(TOPIC_SIDEBAR, (value) => value !== null);
-  await act(async () => {
-    await flush();
-  });
-
-  return {
-    server,
-    holder,
-    push: async (structure, status) => {
-      // Await the CLIENT's value, not just the publish: the socket round trip
-      // and the provider's merge are the things under test, so resolving on the
-      // send would assert against a state that has not happened yet.
-      if (structure) {
-        server.publish(TOPIC_SIDEBAR, structure);
-        await server.waitForTopic(TOPIC_SIDEBAR, (value) => JSON.stringify(value) === JSON.stringify(structure));
-      }
-      if (status) {
-        server.publish(TOPIC_SIDEBAR_STATUS, status);
-        await server.waitForTopic(TOPIC_SIDEBAR_STATUS, (value) => JSON.stringify(value) === JSON.stringify(status));
-      }
-      await act(async () => {
-        await flush();
-      });
-    },
-  };
-}
-
 describe('SidebarDataProvider reads both sidebar topics', () => {
   test('reports a live run for a session the structure has not scanned yet', async () => {
     // A fresh spawn: omp writes the session file only when the first assistant
@@ -227,9 +102,7 @@ describe('SidebarDataProvider carries the sent text for a placeholder row', () =
     const harness = await mountProvider();
     expect(harness.holder.api?.titleHint('omp-1')).toBeUndefined();
 
-    await act(async () => {
-      hint('omp-1', 'Perbaiki tombol stop');
-    });
+    await withAct(() => hint('omp-1', 'Perbaiki tombol stop'));
 
     expect(harness.holder.api?.titleHint('omp-1')).toBe('Perbaiki tombol stop');
     expect(harness.holder.api?.titleHint('omp-2')).toBeUndefined();
@@ -239,14 +112,10 @@ describe('SidebarDataProvider carries the sent text for a placeholder row', () =
 
   test('ignores a blank hint and drops one once the session is listed', async () => {
     const harness = await mountProvider();
-    await act(async () => {
-      hint('a', '   ');
-    });
+    await withAct(() => hint('a', '   '));
     expect(harness.holder.api?.titleHint('a')).toBeUndefined();
 
-    await act(async () => {
-      hint('a', 'sent text');
-    });
+    await withAct(() => hint('a', 'sent text'));
     expect(harness.holder.api?.titleHint('a')).toBe('sent text');
 
     // The session is in the structure, so the placeholder is not drawn and the
@@ -257,3 +126,14 @@ describe('SidebarDataProvider carries the sent text for a placeholder row', () =
     harness.server.stop();
   });
 });
+
+/**
+ * `sidebar:activity` is the topic a tool call republishes, and the merge rules
+ * are what make a payload that carries ONLY the running sessions sufficient.
+ *
+ * The structure is the authority for every row and is re-scanned at every turn
+ * boundary; this topic only ever moves the two fields a run advances mid-turn.
+ * Two ways that can go wrong, both pinned below: a late frame moving a row
+ * BACKWARDS (which reorders the sidebar under the reader), and the merge
+ * re-sorting 731 rows for a stamp that did not move.
+ */

package/src/client/hooks/chat/omp/session-list.tsx

@@ -31,7 +31,7 @@ import { useRealtimeTopic } from '@/client/hooks/ui/realtime';
 import { useInputRequiredAlert } from '@/client/hooks/ui/input-required-alert';
 
 import { realtimeClient } from '@/shared/lib/realtime/client';
-import { TOPIC_SIDEBAR, TOPIC_SIDEBAR_STATUS } from '@/shared/lib/realtime/protocol';
+import { TOPIC_SIDEBAR, TOPIC_SIDEBAR_ACTIVITY, TOPIC_SIDEBAR_STATUS } from '@/shared/lib/realtime/protocol';
 import {
   applySeenStrip,
   SESSION_TITLE_HINT_SIGNAL,
@@ -39,11 +39,11 @@ import {
 import { subscribeClientSignal } from '@/client/lib/signals';
 import { buildSidebarSessionStatus } from '@/client/hooks/chat/omp/session-statuses';
 import type { WorkspaceFolderData } from '@/shared/types';
-import type { SidebarPayload, SidebarStatusPayload } from '@/shared/types/realtime';
+import type { SidebarActivityPayload, SidebarPayload, SidebarStatusPayload } from '@/shared/types/realtime';
 
 /** Re-exported so a consumer (and a test) names the shape without reaching
  *  into a server module for it. */
-export type { SidebarPayload, SidebarStatusPayload };
+export type { SidebarActivityPayload, SidebarPayload, SidebarStatusPayload };
 
 export interface SidebarDataHandle {
   folders: WorkspaceFolderData[];
@@ -115,9 +115,65 @@ function mergeStatus(
   }));
 }
 
+/**
+ * Advance each row's live fields from the activity payload.
+ *
+ * `sidebar:activity` carries only the RUNNING sessions (see its doc), so an id
+ * it does not name keeps whatever the structure gave it. Three rules, each of
+ * which is a way this can go wrong:
+ *
+ *   - the `updated_at` comparison is what makes two sources safe to
+ *     interleave: the structure is re-scanned at every turn boundary and may
+ *     already carry a stamp this payload has not caught up with, and a late
+ *     activity frame must never move a row BACKWARDS (that reorders the
+ *     sidebar under the reader);
+ *   - `hasSubagents` only ever turns ON, because the payload is a live read of
+ *     what is on disk and a subagent transcript does not disappear when its run
+ *     ends — a `false` here is "not seen yet", not "none exist";
+ *   - nothing else is touched. Every other field of a row changes on a
+ *     STRUCTURAL event, and those publish the structure for their own reason.
+ */
+function mergeActivity(
+  folders: WorkspaceFolderData[],
+  activity: SidebarActivityPayload | null,
+): WorkspaceFolderData[] {
+  if (!activity) return folders;
+  let changed = false;
+  const merged = folders.map((folder) => ({
+    ...folder,
+    sessions: (folder.sessions ?? []).map((session) => {
+      const live = activity[String(session.id)];
+      if (!live) return session;
+      const updated_at = live.updatedAt && isNewerStamp(live.updatedAt, session.updated_at)
+        ? live.updatedAt
+        : session.updated_at;
+      const hasSubagents = session.hasSubagents || live.hasSubagents === true;
+      if (updated_at === session.updated_at && hasSubagents === Boolean(session.hasSubagents)) return session;
+      changed = true;
+      return { ...session, updated_at, hasSubagents };
+    }),
+  }));
+  // A stable identity matters: the sidebar's own `useMemo` chain (filter, sort,
+  // pending overlay) keys on this array, and returning a fresh one per activity
+  // frame would re-sort 731 rows for a stamp that did not move.
+  return changed ? merged : folders;
+}
+
+/** Whether `next` is a later ISO stamp than `current`. An absent current is older. */
+function isNewerStamp(next: string, current?: string): boolean {
+  if (!current) return true;
+  const nextMs = Date.parse(next);
+  const currentMs = Date.parse(current);
+  // An unparseable value on either side is not evidence of a newer stamp; the
+  // structure's own field stays authoritative.
+  if (!Number.isFinite(nextMs) || !Number.isFinite(currentMs)) return false;
+  return nextMs > currentMs;
+}
+
 export function SidebarDataProvider({ children, initialFolders = [] }: { children: ReactNode; initialFolders?: WorkspaceFolderData[] }) {
   const structure = useRealtimeTopic<SidebarPayload>(TOPIC_SIDEBAR);
   const status = useRealtimeTopic<SidebarStatusPayload>(TOPIC_SIDEBAR_STATUS);
+  const activity = useRealtimeTopic<SidebarActivityPayload>(TOPIC_SIDEBAR_ACTIVITY);
 
   // Session ids whose badge the user has already dismissed on this mount.
   // Optimistic strip: keeps the click→disappearance instant and stops the
@@ -132,8 +188,8 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
   const [overlayVersion, setOverlayVersion] = useState(0);
 
   const folders = useMemo(
-    () => mergeStatus(structure.data?.folders ?? initialFolders, status.data),
-    [structure.data, status.data, initialFolders],
+    () => mergeActivity(mergeStatus(structure.data?.folders ?? initialFolders, status.data), activity.data),
+    [structure.data, status.data, activity.data, initialFolders],
   );
   const isMock = structure.data?.isMock ?? false;
   const initializing = structure.data === null;
@@ -173,6 +229,10 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
   const refresh = useCallback(() => {
     realtimeClient.refresh(TOPIC_SIDEBAR);
     realtimeClient.refresh(TOPIC_SIDEBAR_STATUS);
+    // The activity stamps are what a tool call advances, so a manual refresh
+    // that skipped them would re-read the list and leave its labels where they
+    // were.
+    realtimeClient.refresh(TOPIC_SIDEBAR_ACTIVITY);
   }, []);
 
   // The spinner follows a user's click only: it is raised here and lowered when
@@ -188,10 +248,10 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [structure.data]);
 
-  // A background push — every tool call republishes the structure — pulses the
-  // topic's own indicator, so the toolbar button spins for it too. Without this
-  // the list moved with nothing on screen saying so.
-  const isRefreshing = refreshing || structure.refreshing;
+  // A background push — every tool call advances a live session's activity —
+  // pulses the topic's own indicator, so the toolbar button spins for it too.
+  // Without this the list moved with nothing on screen saying so.
+  const isRefreshing = refreshing || structure.refreshing || activity.refreshing;
 
   // Fires for ANY session, including one this tab never opened — the cue that an
   // agent is blocked on an answer must not depend on the open timeline.

package/src/client/hooks/chat/timeline/generating.ts

@@ -35,6 +35,14 @@ export interface GeneratingState {
   ownRun: boolean;
   /** Non-reactive mirror of `ownRun` for the session-load guard. */
   ownRunRef: { current: boolean };
+  /**
+   * The STREAM has spoken for the run in flight — an `agent_start` or a resume
+   * of a live run, both of which call `setGenerating(true)` without ownership.
+   * False for a run this page merely DISPATCHED and whose first frame has not
+   * arrived, which is what keeps a reconnect in that window from settling a
+   * turn that has not started.
+   */
+  streamRunRef: { current: boolean };
   /**
    * Set the generating state. `owned` marks a run THIS PAGE dispatched; every
    * caller but the send path omits it, so an adopted run never claims ownership
@@ -70,6 +78,7 @@ export function useGeneratingState(): GeneratingState {
   const [isGenerating, setIsGenerating] = useState(false);
   const isGeneratingRef = useRef(false);
   const ownRunRef = useRef(false);
+  const streamRunRef = useRef(false);
   const [ownRun, setOwnRun] = useState(false);
   const [generatingVerb, setGeneratingVerbState] = useState('');
   const activityRef = useRef('');
@@ -80,8 +89,15 @@ export function useGeneratingState(): GeneratingState {
   // then re-rendered again — an unbounded fetch loop.
   const setGenerating = useCallback((v: boolean, owned = false) => {
     isGeneratingRef.current = v;
-    if (!v) ownRunRef.current = false;
-    else if (owned) ownRunRef.current = true;
+    if (!v) {
+      ownRunRef.current = false;
+      streamRunRef.current = false;
+    } else {
+      if (owned) ownRunRef.current = true;
+      // Not owned: the stream itself announced this run (`agent_start`, or the
+      // mount probe resuming a live one).
+      else streamRunRef.current = true;
+    }
     // Mirror onto state: `timelineRunning` is computed during render, so a
     // ref-only ownership flag could not reach the footer's withheld guard.
     setOwnRun(ownRunRef.current);
@@ -98,6 +114,7 @@ export function useGeneratingState(): GeneratingState {
     isGeneratingRef,
     ownRun,
     ownRunRef,
+    streamRunRef,
     setGenerating,
     generatingVerb,
     activityRef,