fix: make session resume atomic across restarts

frontend/src/stream/useSessionStream.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook } from "@testing-library/react";
-import { act } from "react";
+import { act, useLayoutEffect } from "react";
 import { FakeEventSource } from "../test/fakeEventSource";
 import { useSessionStream } from "./useSessionStream";
 import { useSessionStore } from "../store/sessionStore";
@@ -100,6 +100,58 @@ test("a same-session generation reconnect includes the last consumed SSE id", ()
     .toEqual([{ kind: "assistant", phase: null, text: "hello world" }]);
 });
 
+test("a same-session reset epoch drops a high cursor and accepts fresh low-id events", () => {
+  const { rerender } = renderHook(
+    ({ resetEpoch }) => useSessionStream("s1", 0, resetEpoch),
+    { initialProps: { resetEpoch: 0 } },
+  );
+  const first = FakeEventSource.instances[0];
+  act(() => first.emitNamed("info", { type: "info", text: "old runtime" }, "900"));
+
+  rerender({ resetEpoch: 1 });
+
+  expect(first.closed).toBe(true);
+  expect(FakeEventSource.instances).toHaveLength(2);
+  expect(FakeEventSource.instances[1].url).toBe(
+    "http://localhost:8787/sessions/s1/events",
+  );
+
+  act(() =>
+    FakeEventSource.instances[1].emitNamed(
+      "ui_request",
+      { type: "ui_request", ui_request: { id: "fresh-gate", widget: "select" } },
+      "1",
+    ),
+  );
+  expect(useSessionStore.getState().pendingWidget?.id).toBe("fresh-gate");
+});
+
+test("a reset epoch also accepts an in-process preserved high id and resumes from it", () => {
+  const { rerender } = renderHook(
+    ({ generation, resetEpoch }) => useSessionStream("s1", generation, resetEpoch),
+    { initialProps: { generation: 0, resetEpoch: 0 } },
+  );
+  const first = FakeEventSource.instances[0];
+  act(() => first.emitNamed("info", { type: "info", text: "old runtime" }, "900"));
+
+  rerender({ generation: 0, resetEpoch: 1 });
+  const replacement = FakeEventSource.instances[1];
+  expect(replacement.url).toBe("http://localhost:8787/sessions/s1/events");
+  act(() =>
+    replacement.emitNamed(
+      "ui_request",
+      { type: "ui_request", ui_request: { id: "preserved-high-gate", widget: "select" } },
+      "902",
+    ),
+  );
+
+  expect(useSessionStore.getState().pendingWidget?.id).toBe("preserved-high-gate");
+  rerender({ generation: 1, resetEpoch: 1 });
+  expect(FakeEventSource.instances[2].url).toBe(
+    "http://localhost:8787/sessions/s1/events?lastEventId=902",
+  );
+});
+
 test("changing the session resets the manual reconnect cursor", () => {
   const { rerender } = renderHook(
     ({ sessionId }) => useSessionStream(sessionId),
@@ -113,3 +165,55 @@ test("changing the session resets the manual reconnect cursor", () => {
   expect(first.closed).toBe(true);
   expect(FakeEventSource.instances[1].url).toBe("http://localhost:8787/sessions/s2/events");
 });
+
+test("a queued event from a replaced source cannot mutate the new session or its cursor", () => {
+  const { rerender } = renderHook(
+    ({ sessionId, generation }) => useSessionStream(sessionId, generation, 0),
+    { initialProps: { sessionId: "s1" as string | null, generation: 0 } },
+  );
+  const first = FakeEventSource.instances[0];
+  act(() => first.emitNamed("info", { type: "info", text: "session one" }, "12"));
+
+  rerender({ sessionId: "s2", generation: 0 });
+  expect(first.closed).toBe(true);
+  expect(FakeEventSource.instances[1].url).toBe("http://localhost:8787/sessions/s2/events");
+  useSessionStore.getState().resetSession();
+
+  act(() =>
+    first.emitQueuedNamed(
+      "text_delta",
+      { type: "text_delta", text: "stale session one" },
+      "999",
+    ),
+  );
+  expect(useSessionStore.getState().transcript).toEqual([]);
+
+  rerender({ sessionId: "s2", generation: 1 });
+  expect(FakeEventSource.instances[2].url).toBe("http://localhost:8787/sessions/s2/events");
+});
+
+test("the old source is invalid before later layout effects can deliver a queued event", () => {
+  let first: FakeEventSource;
+  const { rerender } = renderHook(
+    ({ sessionId, emitDuringLayout }) => {
+      useSessionStream(sessionId);
+      useLayoutEffect(() => {
+        if (emitDuringLayout) {
+          first.emitQueuedNamed(
+            "text_delta",
+            { type: "text_delta", text: "commit-window stale text" },
+            "777",
+          );
+        }
+      }, [emitDuringLayout, sessionId]);
+    },
+    { initialProps: { sessionId: "s1" as string | null, emitDuringLayout: false } },
+  );
+  first = FakeEventSource.instances[0];
+  useSessionStore.getState().resetSession();
+
+  rerender({ sessionId: "s2", emitDuringLayout: true });
+
+  expect(first.closed).toBe(true);
+  expect(useSessionStore.getState().transcript).toEqual([]);
+});

frontend/src/stream/useSessionStream.ts

@@ -1,29 +1,51 @@
-import { useEffect, useRef, useState } from "react";
+import { useLayoutEffect, useRef, useState } from "react";
 import { BASE } from "../api/client";
 import { joinBackendPath } from "../api/runtime-config";
 import { useSessionStore } from "../store/sessionStore";
 import type { StreamEvent } from "../api/types";
 
-export function useSessionStream(sessionId: string | null, generation = 0) {
+export function useSessionStream(
+  sessionId: string | null,
+  generation = 0,
+  cursorResetEpoch = 0,
+) {
   const [connected, setConnected] = useState(false);
   const applyEvent = useSessionStore((s) => s.applyEvent);
-  const cursor = useRef({ sessionId: null as string | null, lastEventId: "" });
+  const cursor = useRef({
+    sessionId: null as string | null,
+    cursorResetEpoch,
+    lastEventId: "",
+  });
+  const activeSource = useRef<object | null>(null);
 
-  if (cursor.current.sessionId !== sessionId) {
-    cursor.current = { sessionId, lastEventId: "" };
-  }
-
-  useEffect(() => {
-    if (!sessionId) return;
+  useLayoutEffect(() => {
+    if (
+      cursor.current.sessionId !== sessionId
+      || cursor.current.cursorResetEpoch !== cursorResetEpoch
+    ) {
+      cursor.current = { sessionId, cursorResetEpoch, lastEventId: "" };
+    }
+    if (!sessionId) {
+      activeSource.current = null;
+      setConnected(false);
+      return;
+    }
 
     const query = cursor.current.lastEventId
       ? `?lastEventId=${encodeURIComponent(cursor.current.lastEventId)}`
       : "";
     const es = new EventSource(joinBackendPath(BASE, `/sessions/${sessionId}/events${query}`));
-    es.onopen = () => setConnected(true);
-    es.onerror = () => setConnected(false);
+    const identity = { source: es, sessionId, cursorResetEpoch };
+    activeSource.current = identity;
+    es.onopen = () => {
+      if (activeSource.current === identity) setConnected(true);
+    };
+    es.onerror = () => {
+      if (activeSource.current === identity) setConnected(false);
+    };
 
     const handle = (ev: MessageEvent) => {
+      if (activeSource.current !== identity) return;
       if (ev.lastEventId) cursor.current.lastEventId = ev.lastEventId;
       try {
         applyEvent(JSON.parse(ev.data) as StreamEvent);
@@ -47,10 +69,14 @@ export function useSessionStream(sessionId: string | null, generation = 0) {
 
     return () => {
       for (const name of namedEvents) es.removeEventListener(name, handle);
+      es.onmessage = null;
       es.close();
-      setConnected(false);
+      if (activeSource.current === identity) {
+        activeSource.current = null;
+        setConnected(false);
+      }
     };
-  }, [sessionId, generation, applyEvent]);
+  }, [sessionId, generation, cursorResetEpoch, applyEvent]);
 
   return { connected };
 }