fix(desktop): stop per-event nested commits that crashed the Live Session View

apps/desktop/src/entities/session/session-projections-store.test.tsx

@@ -1,4 +1,5 @@
 import { act, render } from "@testing-library/react";
+import { Profiler } from "react";
 import { describe, expect, it } from "vitest";
 import type {
   AgentRuntimeEventEntry,
@@ -13,11 +14,15 @@ import {
   createSessionProjection,
   type SessionProjection,
 } from "@/entities/session/session-projection";
-import { createSessionProjectionsStore } from "@/entities/session/session-projections-store";
+import {
+  createSessionProjectionsStore,
+  type SessionProjectionsStore,
+} from "@/entities/session/session-projections-store";
 import {
   SessionProjectionsProvider,
   useLiveSession,
   useSessionProjections,
+  useViewedSession,
 } from "@/entities/session/use-session-projections";
 
 type Listener<T extends unknown[]> = (...args: T) => void;
@@ -553,3 +558,140 @@ describe("Session Projections store", () => {
     });
   });
 });
+
+function assistantMessage(id: string, piSessionId: string, seq: number): PiRuntimeEvent {
+  return {
+    id,
+    piSessionId,
+    kind: "message",
+    role: "assistant",
+    body: `Reply ${seq}`,
+    timestamp: `2026-09-24T10:00:0${seq}.000Z`,
+  };
+}
+
+describe("viewed Sessions", () => {
+  it("reads results as they land on a viewed Session and keeps them unread once it is released", () => {
+    const fake = createFakeBridge();
+    const store = createStore(fake);
+    store.insert(createSessionProjection({
+      id: "viewed",
+      projectId: "pig",
+      initialPrompt: "Prompt",
+      createdAt: "2026-09-24T09:00:00.000Z",
+    }));
+    store.apply("viewed", {
+      type: "runtime-bound",
+      stage: "starting runtime",
+      runtimeId: "runtime:viewed",
+      piSessionId: "pi:viewed",
+      occurredAt: "2026-09-24T09:00:01.000Z",
+    });
+
+    const notifies: string[] = [];
+    store.subscribe(() => notifies.push("notify"));
+    const release = store.view("viewed");
+
+    fake.emitLegacy(assistantMessage("m1", "pi:viewed", 1));
+
+    // The unread write lands inside the event's own commit, not after it.
+    expect(store.get("viewed")?.unreadResult).toBe(false);
+    expect(notifies).toHaveLength(1);
+
+    release();
+    fake.emitLegacy(assistantMessage("m2", "pi:viewed", 2));
+
+    expect(store.get("viewed")?.unreadResult).toBe(true);
+    expect(notifies).toHaveLength(2);
+  });
+
+  it("viewing an unread Session reads it once", () => {
+    const fake = createFakeBridge();
+    const store = createStore(fake);
+    store.insert({ ...boundSession("unread"), unreadResult: true });
+
+    const notifies: string[] = [];
+    store.subscribe(() => notifies.push("notify"));
+    store.view("unread");
+
+    expect(store.get("unread")?.unreadResult).toBe(false);
+    expect(notifies).toHaveLength(1);
+  });
+
+  it("reads a Session that arrives after its view started", () => {
+    const store = createStore();
+    const release = store.view("late");
+
+    // Insert bypasses apply(): the read marker has to come from commit itself.
+    store.insert({ ...boundSession("late"), unreadResult: true });
+
+    expect(store.get("late")?.unreadResult).toBe(false);
+    release();
+  });
+
+  it("reads a viewed Session that rehydrate brings in unread", async () => {
+    const fake = createFakeBridge();
+    const store = createStore(fake, async () => [
+      coldSession("hydrated", { unreadResult: true }),
+    ]);
+    const release = store.view("hydrated");
+
+    await store.rehydrate();
+
+    expect(store.get("hydrated")?.unreadResult).toBe(false);
+    release();
+  });
+
+  it("commits once per assistant event while the Session is on screen", () => {
+    const fake = createFakeBridge();
+    let store!: SessionProjectionsStore;
+    let commits = 0;
+
+    function LiveView() {
+      const { projection } = useLiveSession("onscreen");
+      useViewedSession("onscreen");
+      return <span data-testid="unread">{String(projection?.unreadResult)}</span>;
+    }
+    function StoreProbe() {
+      store = useSessionProjections().store;
+      return null;
+    }
+
+    render(
+      <SessionProjectionsProvider bridge={fake.bridge}>
+        <StoreProbe />
+        <Profiler id="live" onRender={() => { commits += 1; }}>
+          <LiveView />
+        </Profiler>
+      </SessionProjectionsProvider>,
+    );
+
+    act(() => {
+      store.insert(createSessionProjection({
+        id: "onscreen",
+        projectId: "pig",
+        initialPrompt: "Prompt",
+        createdAt: "2026-09-24T09:00:00.000Z",
+      }));
+      store.apply("onscreen", {
+        type: "runtime-bound",
+        stage: "starting runtime",
+        runtimeId: "runtime:onscreen",
+        piSessionId: "pi:onscreen",
+        occurredAt: "2026-09-24T09:00:01.000Z",
+      });
+    });
+    commits = 0;
+
+    for (let seq = 1; seq <= 5; seq += 1) {
+      act(() => {
+        fake.emitLegacy(assistantMessage(`m${seq}`, "pi:onscreen", seq));
+      });
+    }
+
+    // One commit per event: the old pattern added a second commit per event
+    // from a passive effect writing "read" back after each render.
+    expect(commits).toBe(5);
+    expect(store.get("onscreen")?.unreadResult).toBe(false);
+  });
+});

apps/desktop/src/entities/session/session-projections-store.ts

@@ -34,6 +34,12 @@ export type SessionProjectionsStore = {
   remove(sessionId: string): void;
   rehydrate(): Promise<void>;
   subscribe(listener: () => void): () => void;
+  /**
+   * Marks a Session as on screen until the returned release runs. Its results
+   * are read as they land, in the same store commit, so a view never writes
+   * "read" back after rendering (which cost one extra commit per event).
+   */
+  view(sessionId: string): () => void;
 };
 
 // A projection this process has advanced past its persisted record. Replacing
@@ -63,16 +69,30 @@ export function createSessionProjectionsStore(options: {
   let projections: SessionProjection[] = [];
   const listeners = new Set<() => void>();
   const subscriptions = new Map<string, { piSessionId: string; release: () => void }>();
+  // Sessions currently on screen, ref-counted per `view()` caller. Their
+  // results are already consumed by definition, so `seen` folds the read
+  // marker into the same projection write instead of a second apply later.
+  const viewed = new Map<string, number>();
   const history = new Map<
     string,
     { key: string; piSessionId: string; state: Exclude<SessionHistoryState, "idle"> }
   >();
 
+  const seen = (projection: SessionProjection) =>
+    viewed.has(projection.id) && projection.unreadResult
+      ? applySessionProjectionEvent(projection, {
+          type: "latest-message-rendered",
+          occurredAt: new Date().toISOString(),
+        })
+      : projection;
+
   const notify = () => {
     for (const listener of listeners) listener();
   };
   const commit = (next: SessionProjection[]) => {
-    projections = next;
+    // Every write passes here, so a viewed Session is read however its
+    // projection arrives (event, history read, insert, rehydrate).
+    projections = viewed.size > 0 ? next.map(seen) : next;
     notify();
   };
   const get = (sessionId: string) =>
@@ -119,7 +139,7 @@ export function createSessionProjectionsStore(options: {
 
     // The reducer throws on events it cannot place (an unknown queued id);
     // that propagates before anything is stored.
-    const next = applySessionProjectionEvent(current, event);
+    const next = seen(applySessionProjectionEvent(current, event));
     replace(next);
 
     if (event.type === "runtime-bound") {
@@ -247,5 +267,30 @@ export function createSessionProjectionsStore(options: {
         listeners.delete(listener);
       };
     },
+    view(sessionId) {
+      viewed.set(sessionId, (viewed.get(sessionId) ?? 0) + 1);
+      // An already-unread Session is caught up now: one notify, only on view
+      // start — nothing writes "read" back while events land afterwards.
+      const current = get(sessionId);
+      if (current) {
+        const next = seen(current);
+        if (next !== current) {
+          replace(next);
+        }
+      }
+      let released = false;
+      return () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        const count = (viewed.get(sessionId) ?? 0) - 1;
+        if (count <= 0) {
+          viewed.delete(sessionId);
+        } else {
+          viewed.set(sessionId, count);
+        }
+      };
+    },
   };
 }

apps/desktop/src/entities/session/use-session-projections.tsx

@@ -304,3 +304,18 @@ export function useLiveSession(sessionId: string | null) {
 
   return { projection, history, apply, retryHistory };
 }
+
+/** Keeps a Session read while it is on screen (SessionProjectionsStore.view). */
+export function useViewedSession(sessionId: string | null) {
+  const context = useContext(SessionProjectionsStoreContext);
+
+  if (!context) {
+    throw new Error("useViewedSession requires SessionProjectionsProvider");
+  }
+
+  const { store } = context;
+  useEffect(
+    () => (sessionId ? store.view(sessionId) : undefined),
+    [sessionId, store],
+  );
+}

apps/desktop/src/shared/ui/astryx-text-ref.test.tsx

@@ -0,0 +1,54 @@
+import { render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { Heading, Text } from "@astryxdesign/core/Text";
+
+/**
+ * Guard for the @astryxdesign/core patch: Text/Heading merge their forwarded
+ * ref, useTruncation's callback ref, and an internal object ref into one
+ * callback built fresh on every render. A new callback identity makes React
+ * detach+reattach the ref on every commit — and useTruncation's attach calls
+ * setState inside the commit, which is what let nested updates accumulate
+ * into React #185 under dense Session events.
+ */
+describe("Astryx ref stability", () => {
+  it("Text keeps the forwarded callback ref attached across re-renders", () => {
+    const spy = vi.fn();
+    function Parent({ label }: { label: string }) {
+      return <Text ref={spy}>{label}</Text>;
+    }
+
+    const { rerender } = render(<Parent label="a" />);
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenLastCalledWith(expect.any(HTMLElement));
+
+    rerender(<Parent label="b" />);
+    rerender(<Parent label="c" />);
+    rerender(<Parent label="d" />);
+
+    // No detach (spy(null)) and no re-attach: identity must be stable.
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).not.toHaveBeenCalledWith(null);
+  });
+
+  it("Heading keeps the forwarded callback ref attached across re-renders", () => {
+    const spy = vi.fn();
+    function Parent({ label }: { label: string }) {
+      return (
+        <Heading level={2} ref={spy}>
+          {label}
+        </Heading>
+      );
+    }
+
+    const { rerender } = render(<Parent label="a" />);
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenLastCalledWith(expect.any(HTMLElement));
+
+    rerender(<Parent label="b" />);
+    rerender(<Parent label="c" />);
+    rerender(<Parent label="d" />);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).not.toHaveBeenCalledWith(null);
+  });
+});

apps/desktop/src/shared/ui/chat/chat-inline-pager.test.tsx

@@ -1,3 +1,4 @@
+import { Profiler } from "react";
 import { act, render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { ChatInlinePager } from "@/shared/ui/chat/chat-inline-pager";
@@ -104,6 +105,30 @@ describe("ChatInlinePager", () => {
     expect(screen.getByText("Running bash script…")).toBeInTheDocument();
   });
 
+  // A parent re-render with the same page key used to cost a second commit
+  // from the pager's passive effect — under dense Session events that extra
+  // commit per event is what let React's nested-update counter overflow (React error #185).
+  it("lands same-page content without an extra commit", () => {
+    let commits = 0;
+    const { rerender } = render(
+      <Profiler id="pager" onRender={() => { commits += 1; }}>
+        <ChatInlinePager pageKey="running:1">Running bash…</ChatInlinePager>
+      </Profiler>,
+    );
+
+    commits = 0;
+    for (const label of ["Running bash script…", "Running bash -lc…", "Running test…"]) {
+      rerender(
+        <Profiler id="pager" onRender={() => { commits += 1; }}>
+          <ChatInlinePager pageKey="running:1">{label}</ChatInlinePager>
+        </Profiler>,
+      );
+    }
+
+    expect(commits).toBe(3);
+    expect(screen.getByText("Running test…")).toBeInTheDocument();
+  });
+
   it("swaps pages without motion when reduced motion is preferred", () => {
     vi.useFakeTimers();
     useReducedMotion();

apps/desktop/src/shared/ui/chat/chat-inline-pager.tsx

@@ -53,10 +53,10 @@ export function ChatInlinePager({
     latestRef.current = { key: pageKey, node: children };
 
     // Same page, new content (streaming args, a ticking duration): land it in
-    // place rather than turning the page on itself.
+    // place rather than turning the page on itself. Rendered straight from
+    // children below, so a parent re-render costs no extra commit.
     if (pageKey === shownRef.current.key) {
       shownRef.current = latestRef.current;
-      setShown(latestRef.current);
       return;
     }
 
@@ -122,7 +122,7 @@ export function ChatInlinePager({
             }
           }}
         >
-          {shown.node}
+          {pageKey === shown.key ? children : shown.node}
         </span>
       </span>
     </span>