Resume cached timelines without replaying their tail (#3329)

* perf(timeline): resume cached history from its exact range

Warm launches were repainting cached history and then downloading the same bounded tail to rediscover that nothing changed. Persist synchronization authority only when the complete current canonical window can be encoded losslessly; otherwise retain the existing display-only fallback.

* test(timeline): hide replica setup behind E2E helper

* fix(timeline): bound persisted resume overflow

* test(timeline): cover workspace eviction catch-up order

* test(timeline): read persisted range from IndexedDB

packages/app/e2e/browser/agent-message-submission.spec.ts

@@ -30,6 +30,12 @@ import { buildHostWorkspaceRoute } from "@/utils/host-routes";
 import { delayBrowserAgentCreatedStatus } from "../support/helpers/new-workspace";
 import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
 import { selectModel } from "../support/helpers/app";
+import { observeTimelineSubscriptions } from "../support/helpers/timeline-delivery";
+import {
+  expectResumeOverflowFallsBackToOneTail,
+  rememberTimelineRequestCounts,
+} from "../support/helpers/timeline-resume";
+import { workspaceDeckEntryLocator } from "../support/helpers/workspace-ui";
 import {
   scrollTimelineToNewestLoadedEdge,
   scrollTimelineUntilOlderHistoryIsReachable,
@@ -336,6 +342,64 @@ async function expectInterruptedTurnOrderAfterReconnect(
   }
 }
 
+async function expectHiddenStreamingSubmissionOrderAfterWorkspaceEviction(
+  page: Page,
+  testInfo: { workerIndex: number },
+): Promise<void> {
+  const subscriptions = observeTimelineSubscriptions(page);
+  const gate = await installDaemonWebSocketGate(page);
+  const target = await seedMockAgentWorkspace({
+    repoPrefix: `submission-hidden-stream-${testInfo.workerIndex}-`,
+    title: "Hidden streaming submission",
+    model: "ten-second-stream",
+  });
+  const evictionAgents = await Promise.all(
+    Array.from({ length: 3 }, (_unused, index) =>
+      seedMockAgentWorkspace({
+        repoPrefix: `submission-workspace-eviction-${testInfo.workerIndex}-${index}-`,
+        title: `Workspace eviction ${index + 1}`,
+      }),
+    ),
+  );
+  const prompt = "Keep this hidden image prompt before its streaming output.";
+  const targetDeckEntry = workspaceDeckEntryLocator(page, getServerId(), target.workspaceId);
+
+  try {
+    await openAgentRoute(page, target);
+    await expectComposerVisible(page);
+    await subscriptions.waitForSubscribedAgents([target.agentId]);
+
+    const userMessageCount = gate.getAgentStreamItemCount("user_message");
+    gate.setAgentStreamSuppressed(true);
+    const promptRow = await submitMessageWithImage(page, prompt);
+    await gate.waitForAgentStreamItem("user_message", userMessageCount + 1);
+
+    for (const evictionAgent of evictionAgents) {
+      await openAgentRoute(page, evictionAgent);
+      await expectComposerVisible(page);
+    }
+    await expect(targetDeckEntry).toHaveCount(0);
+    await subscriptions.waitForSubscribedAgents([evictionAgents[2]!.agentId]);
+    gate.setAgentStreamSuppressed(false);
+
+    await target.client.waitForFinish(target.agentId, 30_000);
+    const requestsBeforeReturn = rememberTimelineRequestCounts(gate);
+    await openAgentRoute(page, target);
+    await expectComposerVisible(page);
+    await subscriptions.waitForSubscribedAgents([target.agentId]);
+
+    const response = page.getByText("(end of synthetic stream)", { exact: true }).last();
+    await expect(promptRow).toBeVisible();
+    await expect(response).toBeVisible();
+    await expectRenderedBefore(promptRow, response);
+    expectResumeOverflowFallsBackToOneTail(gate, requestsBeforeReturn);
+  } finally {
+    gate.setAgentStreamSuppressed(false);
+    gate.restore();
+    await Promise.all([...evictionAgents.map((agent) => agent.cleanup()), target.cleanup()]);
+  }
+}
+
 async function expectCompletedSubmissionClearsAfterMissedRunningTransition(
   page: Page,
   testInfo: { workerIndex: number },
@@ -1013,6 +1077,13 @@ test.describe("Agent message submission", () => {
     await expectInterruptedTurnOrderAfterReconnect(page, testInfo);
   });
 
+  test("keeps a streaming hidden submission before its output after workspace eviction", async ({
+    page,
+  }, testInfo) => {
+    test.setTimeout(120_000);
+    await expectHiddenStreamingSubmissionOrderAfterWorkspaceEviction(page, testInfo);
+  });
+
   test("clears an attachment-only submission when canonical history arrives after a missed running transition", async ({
     page,
   }, testInfo) => {

packages/app/e2e/browser/agent-timeline-pagination.spec.ts

@@ -26,9 +26,41 @@ import {
   expectTimelineViewportAnchoredAfterPrepend,
   userNavigatesTimelineToHistoryStartWithKeyboard,
   userScrollsTimelineToHistoryStart,
+  waitForPersistedCanonicalTimelineRange,
 } from "../support/helpers/timeline-pagination";
+import { trackAgentTimelineRequests } from "../support/helpers/agent-timeline-gate";
+import { seedMockAgentWorkspace } from "../support/helpers/mock-agent";
 
 test.describe("Agent timeline pagination", () => {
+  test("resumes a persisted canonical timeline after its exact end", async ({ page }) => {
+    const prompt = "timeline persisted range resumes without tail replay";
+    const agent = await seedMockAgentWorkspace({
+      repoPrefix: "timeline-persisted-range-",
+      title: "Persisted timeline range",
+      initialPrompt: prompt,
+    });
+    try {
+      await agent.client.waitForFinish(agent.agentId, 15_000);
+      await openAgentTimeline(page, agent);
+      await expectTimelinePromptVisible(page, prompt);
+      const range = await waitForPersistedCanonicalTimelineRange(page, agent.agentId);
+
+      const tracker = await trackAgentTimelineRequests(page, agent.agentId);
+      await page.reload();
+      await expectTimelinePromptVisible(page, prompt);
+
+      const request = await tracker.nextRequest();
+      expect(request).toEqual({
+        direction: "after",
+        cursor: { epoch: range.epoch, seq: range.endSeq },
+      });
+      await tracker.waitForResponse();
+      expect(tracker.requests().some((entry) => entry.direction === "tail")).toBe(false);
+    } finally {
+      await agent.cleanup();
+    }
+  });
+
   test("keeps a fixed history-start gutter before, during, and after pagination", async ({
     page,
   }) => {

packages/app/e2e/browser/agent-timeline-resume.spec.ts

@@ -13,9 +13,10 @@ import {
 import {
   commitTimelineTurnsWhileDisconnected,
   disconnectViewedTimeline,
-  expectOneTailCheckWithoutCatchUpPages,
+  expectOneResumeCheckWithoutTail,
+  expectResumeOverflowFallsBackToOneTail,
   rememberTimelineRequestCounts,
-  restoreViewedTimelineWithHeldTail,
+  restoreViewedTimelineWithHeldResponse,
 } from "../support/helpers/timeline-resume";
 
 test.describe("Agent timeline resume", () => {
@@ -29,11 +30,11 @@ test.describe("Agent timeline resume", () => {
       const requests = rememberTimelineRequestCounts(gate);
       await disconnectViewedTimeline(page, gate);
       const background = await commitTimelineTurnsWhileDisconnected(agent, 24);
-      await restoreViewedTimelineWithHeldTail(page, gate);
+      await restoreViewedTimelineWithHeldResponse(page, gate);
 
       await expectTimelinePromptVisible(page, background.newestPrompt);
       await expectTimelinePromptNotMounted(page, background.firstPrompt);
-      expectOneTailCheckWithoutCatchUpPages(gate, requests);
+      expectResumeOverflowFallsBackToOneTail(gate, requests);
       await scrollTimelineUntilOlderHistoryIsReachable(page, background.firstPrompt);
     } finally {
       gate.restore();
@@ -53,10 +54,10 @@ test.describe("Agent timeline resume", () => {
       const requests = rememberTimelineRequestCounts(gate);
 
       await disconnectViewedTimeline(page, gate);
-      await restoreViewedTimelineWithHeldTail(page, gate);
+      await restoreViewedTimelineWithHeldResponse(page, gate);
 
       await expectTimelinePresentationUnchanged(page, presentation);
-      expectOneTailCheckWithoutCatchUpPages(gate, requests);
+      expectOneResumeCheckWithoutTail(gate, requests);
     } finally {
       gate.restore();
       await agent.cleanup();

packages/app/e2e/support/helpers/agent-timeline-gate.ts

@@ -31,6 +31,82 @@ export interface PromptJumpRequestTracker {
   requests(): Array<{ cursorSeq: number | null; limit: number | null; mergeWindow: boolean }>;
 }
 
+export interface TimelineRequestTracker {
+  nextRequest(): Promise<{
+    direction: string | null;
+    cursor: { epoch: string; seq: number } | null;
+  }>;
+  requests(): Array<{
+    direction: string | null;
+    cursor: { epoch: string; seq: number } | null;
+  }>;
+  waitForResponse(): Promise<void>;
+}
+
+export async function trackAgentTimelineRequests(
+  page: Page,
+  agentId: string,
+): Promise<TimelineRequestTracker> {
+  type Request = ReturnType<TimelineRequestTracker["requests"]>[number];
+  const seen: Request[] = [];
+  const waiters: Array<(request: Request) => void> = [];
+  let responseSeen = false;
+  let resolveResponse: (() => void) | null = null;
+  const response = new Promise<void>((resolve) => {
+    resolveResponse = resolve;
+  });
+  await page.routeWebSocket(daemonWsRoutePattern(), (ws) => {
+    const server = ws.connectToServer();
+    ws.onMessage((message) => {
+      const sessionMessage = getSessionMessage(message);
+      if (
+        sessionMessage?.type === "fetch_agent_timeline_request" &&
+        sessionMessage.agentId === agentId
+      ) {
+        const rawCursor = sessionMessage.cursor;
+        const cursor =
+          rawCursor &&
+          typeof rawCursor === "object" &&
+          typeof (rawCursor as { epoch?: unknown }).epoch === "string" &&
+          typeof (rawCursor as { seq?: unknown }).seq === "number"
+            ? {
+                epoch: (rawCursor as { epoch: string }).epoch,
+                seq: (rawCursor as { seq: number }).seq,
+              }
+            : null;
+        const request = {
+          direction: typeof sessionMessage.direction === "string" ? sessionMessage.direction : null,
+          cursor,
+        };
+        seen.push(request);
+        waiters.shift()?.(request);
+      }
+      server.send(message);
+    });
+    server.onMessage((message) => {
+      const sessionMessage = getSessionMessage(message);
+      const payload = sessionMessage ? getPayload(sessionMessage) : null;
+      if (
+        sessionMessage?.type === "fetch_agent_timeline_response" &&
+        payload?.agentId === agentId
+      ) {
+        responseSeen = true;
+        resolveResponse?.();
+      }
+      ws.send(message);
+    });
+  });
+  return {
+    nextRequest() {
+      const request = seen[0];
+      if (request) return Promise.resolve(request);
+      return new Promise((resolve) => waiters.push(resolve));
+    },
+    requests: () => [...seen],
+    waitForResponse: () => (responseSeen ? Promise.resolve() : response),
+  };
+}
+
 export async function trackPromptJumpRequests(
   page: Page,
   agentId: string,

packages/app/e2e/support/helpers/replica-cache-storage.ts

@@ -5,10 +5,16 @@ const STORE_NAME = "key-value";
 const STORAGE_KEY = "@paseo:replica-cache";
 
 export interface ReplicaCacheRecord {
+  version?: number;
   hosts?: Array<{
     timeline?: {
       agentId?: string;
       items?: Array<Record<string, unknown>>;
+      range?: {
+        endSeq?: number;
+        epoch?: string;
+        startSeq?: number;
+      } | null;
     } | null;
   }>;
 }

packages/app/e2e/support/helpers/timeline-pagination.ts

@@ -40,6 +40,12 @@ interface TimelineViewportSnapshot {
   scrollTop: number;
 }
 
+interface PersistedCanonicalTimelineRange {
+  epoch: string;
+  startSeq: number;
+  endSeq: number;
+}
+
 export interface TimelinePresentationSnapshot {
   marker: string;
   position: TimelinePromptPositionSnapshot;
@@ -298,6 +304,32 @@ export async function reloadAgentTimelineFromPersistedReplica(
   await expectTimelinePromptVisible(page, agent.newestPrompt);
 }
 
+export async function waitForPersistedCanonicalTimelineRange(
+  page: Page,
+  agentId: string,
+): Promise<PersistedCanonicalTimelineRange> {
+  const readRange = async () => {
+    const cache = await readReplicaCache(page);
+    if (cache?.version !== 6) return null;
+    const range = cache.hosts?.find((host) => host.timeline?.agentId === agentId)?.timeline?.range;
+    if (
+      typeof range?.epoch !== "string" ||
+      typeof range.startSeq !== "number" ||
+      typeof range.endSeq !== "number"
+    ) {
+      return null;
+    }
+    return { epoch: range.epoch, startSeq: range.startSeq, endSeq: range.endSeq };
+  };
+
+  await expect.poll(readRange).not.toBeNull();
+  const range = await readRange();
+  if (!range) {
+    throw new Error(`Persisted canonical timeline range is missing for ${agentId}`);
+  }
+  return range;
+}
+
 export async function holdNextOlderTimelinePage(
   page: Page,
   agent: LongTimelineAgent,

packages/app/e2e/support/helpers/timeline-resume.ts

@@ -40,12 +40,20 @@ export function rememberTimelineRequestCounts(gate: DaemonWebSocketGate): Timeli
   };
 }
 
-export function expectOneTailCheckWithoutCatchUpPages(
+export function expectOneResumeCheckWithoutTail(
   gate: DaemonWebSocketGate,
   before: TimelineRequestCounts,
 ): void {
+  expect(gate.getTimelineRequestCount("after") - before.after).toBe(1);
+  expect(gate.getTimelineRequestCount("tail") - before.tail).toBe(0);
+}
+
+export function expectResumeOverflowFallsBackToOneTail(
+  gate: DaemonWebSocketGate,
+  before: TimelineRequestCounts,
+): void {
+  expect(gate.getTimelineRequestCount("after") - before.after).toBe(1);
   expect(gate.getTimelineRequestCount("tail") - before.tail).toBe(1);
-  expect(gate.getTimelineRequestCount("after") - before.after).toBe(0);
 }
 
 export async function disconnectViewedTimeline(
@@ -56,7 +64,7 @@ export async function disconnectViewedTimeline(
   await expectReconnectingToastVisible(page);
 }
 
-export async function restoreViewedTimelineWithHeldTail(
+export async function restoreViewedTimelineWithHeldResponse(
   page: Page,
   gate: DaemonWebSocketGate,
 ): Promise<void> {