refactor(desktop): load the transcript whole and virtualize it in the renderer

apps/desktop/e2e-budget.json

@@ -19,7 +19,7 @@
     },
     "partial-history-notice.spec.ts": {
       "tests": 1,
-      "electron": "bounded paging crosses renderer, preload and Host transcript storage; the return-to-tail assertion also uses a real pointer hit-test"
+      "electron": "bounded paging crosses renderer, preload and Host transcript storage: each page comes from the Host only when the reader asks, and the Host Turn index lists the whole Session before it is loaded; the return-to-tail assertion also uses a real pointer hit-test. Where the arriving rows leave the reader is renderer-owned and lives in the PrependedHistoryKeepsMeasuredHeights story."
     },
     "proxy-password-editing.spec.ts": {
       "tests": 1,
@@ -69,10 +69,6 @@
       "tests": 4,
       "electron": "observation seeding, reconnect and settle are Host subscriptions surviving a renderer remount"
     },
-    "transcript-scroll-cost.spec.ts": {
-      "tests": 1,
-      "electron": "One traversal exercises real Host transcript paging through preload/IPC, bounded retained ranges, reader displacement when pages install, and a return-to-tail Host read. Fixture motion runs in the TranscriptRenderCost story."
-    },
     "workhub-layout.spec.ts": {
       "tests": 3,
       "electron": "WorkHub model configuration and attachment sending cross the Host boundary; the Project New task action must dismiss the native dock owned by a separate WebContentsView; the native Workbar menu must coexist with the live sibling WebContentsView without hiding its compositor; the compact native window grows only with the inline composer wheel and keeps its bottom anchor; opening context details routes to Main’s Workbar without resizing or docking the floating conversation, while the thinking menu stays within the compact bounds, and pointer dragging scrolls the no-drag wheel instead of moving the frameless window; native floating preserves macOS Dock visibility; a held-open Host Turn verifies immediate prompt visibility, durable transcript handoff and persistence after renderer reload"

apps/desktop/e2e/fixtures.ts

@@ -394,6 +394,7 @@ export async function withE2eWindow(
   {
     seed,
     readinessSelector,
+    readinessTimeoutMs = 20_000,
     e2eFixtureScenario,
     locale,
     platform,
@@ -407,6 +408,8 @@ export async function withE2eWindow(
   }: {
     seed: boolean;
     readinessSelector: string;
+    /** Raise only for a scenario whose seeding is itself heavy enough to delay the first paint. */
+    readinessTimeoutMs?: number;
     e2eFixtureScenario?: string;
     locale?: 'zh-CN' | 'zh-TW' | 'en';
     /** #1312: force app:info's platform so the window boots natively into that platform's `data-os` cascade. */
@@ -486,7 +489,7 @@ export async function withE2eWindow(
     }
     // Centralize the cold-start wait so test bodies are flake-free under retries:0.
     try {
-      await page.waitForSelector(readinessSelector, { timeout: 20_000 });
+      await page.waitForSelector(readinessSelector, { timeout: readinessTimeoutMs });
       if (invocableSkills) {
         await waitForInvocableSkills(page, ['project-only', 'workspace-only']);
       }
@@ -504,7 +507,7 @@ export async function withE2eWindow(
         env: buildFixtureEnv(userDataDir, homeDir, { scenario: e2eFixtureScenario, locale, platform, showWindow: visibleWindow }),
       });
       const restored = await app.firstWindow();
-      await restored.waitForSelector(readinessSelector, { timeout: 20_000 });
+      await restored.waitForSelector(readinessSelector, { timeout: readinessTimeoutMs });
       return restored;
     } });
   } finally {
@@ -531,8 +534,8 @@ type E2eTestFixtures = {
   renameFocusWindow: { page: Page; app: ElectronApplication };
   parentRemovalWindow: Page;
   railRenderWindow: Page;
-  promptRailWindow: Page;
   partialHistoryWindow: Page;
+  largeHistoryWindow: { page: Page; app: ElectronApplication };
   newTaskTargetWindow: Page;
   directoryReferenceWindow: { page: Page; folder: string };
   accessibilityNarrativeWindow: Page;
@@ -647,27 +650,8 @@ export const test = base.extend<E2eTestFixtures>({
       use,
     );
   },
-  // A multi-prompt transcript. Each cost assertion gets an isolated Host and
-  // renderer so observation state cannot bleed between tests. The window is
-  // shown because these cases drive the real compositor through CDP.
-  promptRailWindow: async ({}, use) => {
-    await withE2eWindow({
-      seed: false,
-      // A rendered turn, deliberately not the rail: Playwright treats a
-      // zero-area element as hidden, so gating readiness on a tick would turn
-      // every rail regression into a 20s cold-start timeout instead of the
-      // assertion that names it.
-      readinessSelector: '[data-turn-id]',
-      e2eFixtureScenario: 'chat-prompt-rail',
-      // Every other fixture window names its locale; without one the renderer
-      // takes the host's, so any test that reaches a control by its label
-      // passes on a Chinese desktop and cannot find it on an English CI runner.
-      locale: 'zh-CN',
-      showWindow: true,
-    }, use);
-  },
-  // A transcript larger than the bounded Desktop range. Clicking an unloaded
-  // prompt exercises the real load-around path and its partial-history UI.
+  // A transcript larger than the Desktop history budget, so earlier Turns load
+  // only through the load-earlier control.
   partialHistoryWindow: async ({}, use) => {
     await withE2eWindow({
       seed: false,
@@ -677,6 +661,22 @@ export const test = base.extend<E2eTestFixtures>({
       showWindow: true,
     }, use);
   },
+  // Three transcripts past the real 64 MiB history budget, for weighing what
+  // holding the loaded history costs the renderer. Writing them is hundreds of
+  // MiB of durable transcript, which is why the cold-start wait is raised.
+  largeHistoryWindow: async ({}, use) => {
+    await withE2eWindow(
+      {
+        seed: false,
+        readinessSelector: '[data-turn-id]',
+        readinessTimeoutMs: 300_000,
+        e2eFixtureScenario: 'chat-large-history',
+        locale: 'zh-CN',
+        showWindow: true,
+      },
+      async (page, { app }) => use({ page, app }),
+    );
+  },
   // A data-backed conversation with settled tool evidence and the workbar open
   // beside it. Shown because the accessibility journey follows real native
   // focus order through the transcript into the composer controls.

apps/desktop/e2e/partial-history-notice.spec.ts

@@ -17,53 +17,80 @@
  * under the License.
  */
 
+/**
+ * A Session too large for one read: what the Host hands over is a tail, and
+ * the rest comes only when the reader asks, one bounded page at a time.
+ *
+ * Where the arriving rows leave the reader is renderer-owned and lives in the
+ * `PrependedHistoryKeepsMeasuredHeights` browser story over real layout.
+ */
+
+import type { Page } from '@playwright/test';
 import { expect, test } from './fixtures';
 
-const TURN = '.maka-transcript-turn';
+const SCROLLER = '[data-chat-scroll-container="true"]';
+const TICK = '.maka-prompt-rail-tick';
 /** Turns the partial-history fixture seeds. */
 const PARTIAL_HISTORY_TURN_COUNT = 18;
 
-test('a bounded transcript range reaches its whole history without a control to ask', async ({
+async function frames(page: Page, count = 2): Promise<void> {
+  await page.evaluate((remaining) => new Promise<void>((resolve) => {
+    const step = (left: number): void => {
+      if (left === 0) resolve();
+      else requestAnimationFrame(() => step(left - 1));
+    };
+    step(remaining);
+  }), count);
+}
+
+/** Wheel to the top as a reader would; a programmatic scroll does not release the tail pin. */
+async function wheelToTop(page: Page): Promise<void> {
+  const scroller = page.locator(SCROLLER);
+  await expect(async () => {
+    // Re-read each attempt: the window may still be resizing.
+    const box = await scroller.boundingBox();
+    if (!box) throw new Error('the chat scroll container has no box');
+    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 4);
+    await page.mouse.wheel(0, -4_000);
+    await frames(page, 4);
+    expect(await scroller.evaluate((element) => element.scrollTop)).toBe(0);
+  }).toPass({ timeout: 30_000 });
+  await frames(page, 4);
+}
+
+test('a transcript over the history budget loads earlier Turns only on request', async ({
   partialHistoryWindow: page,
 }) => {
+  test.setTimeout(90_000);
   await page.setViewportSize({ width: 1_400, height: 800 });
+  const loadEarlier = page.getByRole('button', { name: '载入更早的记录' });
+  const pendingLoad = page.locator('button:disabled', { hasText: '载入更早的记录' });
+  const ticks = page.locator(TICK);
 
-  await expect(page.locator(TURN).first()).toBeVisible();
-  expect(await page.locator(TURN).count()).toBeLessThan(PARTIAL_HISTORY_TURN_COUNT);
+  await expect(page.locator(`[data-turn-id="turn-partial-history-${PARTIAL_HISTORY_TURN_COUNT}"]`)).toBeVisible();
+  // The Host Turn index lists the whole Session before its history is loaded.
+  await expect(ticks).toHaveCount(PARTIAL_HISTORY_TURN_COUNT);
+  await expect(loadEarlier).toHaveCount(1);
 
-  const oldestPrompt = page.locator(
-    '.maka-prompt-rail-tick[data-prompt-turn-id="turn-partial-history-1"]',
-  );
-  await expect(oldestPrompt).toBeVisible();
-  await oldestPrompt.click();
+  let loads = 0;
+  while ((await loadEarlier.count()) > 0) {
+    await wheelToTop(page);
+    await loadEarlier.click();
+    await expect(pendingLoad).toHaveCount(0, { timeout: 30_000 });
+    loads += 1;
+    expect(loads).toBeLessThan(PARTIAL_HISTORY_TURN_COUNT);
+  }
 
+  expect(loads).toBeGreaterThan(0);
+  await expect(ticks).toHaveCount(PARTIAL_HISTORY_TURN_COUNT);
+  await wheelToTop(page);
   await expect(page.locator('[data-turn-id="turn-partial-history-1"]')).toBeVisible();
-  // Where the jump landed, read from the reading position rather than from
-  // `data-search-highlight`: that highlight clears itself 2.2s after the
-  // command lands, so waiting for the Turn to mount and then asserting it
-  // fails whenever loading the page around it takes longer than the flash —
-  // measured here as a 3s pass turning into an 18s timeout under load.
-  await expect(oldestPrompt).toHaveAttribute('data-active', 'true');
-  // A jump lands on its own page, not on the whole history.
-  expect(await page.locator(TURN).count()).toBeLessThan(PARTIAL_HISTORY_TURN_COUNT);
-
-  // The newer side of the jump fills on its own as the reader moves into it.
-  await page.mouse.move(700, 400);
-  await expect(async () => {
-    await page.mouse.wheel(0, 400);
-    await expect(page.locator('[data-turn-id="turn-partial-history-3"]')).toBeVisible();
-  }).toPass({ timeout: 30_000 });
 
   const returnToLatest = page.getByRole('button', {
     name: /^(?:滚动主对话到底部|Scroll main conversation to bottom)$/,
   });
   await expect(returnToLatest).toBeVisible();
   await returnToLatest.click();
-
-  // Reading the tail page and rebuilding the window around it is slower than
-  // the paging above, and measured past the suite's 10s expect timeout here.
-  await expect(page.locator(`[data-turn-id="turn-partial-history-${PARTIAL_HISTORY_TURN_COUNT}"]`))
-    .toBeVisible({ timeout: 30_000 });
-  await expect(oldestPrompt).toBeVisible();
-  expect(await page.locator(TURN).count()).toBeLessThan(PARTIAL_HISTORY_TURN_COUNT);
+  await expect(page.locator(`[data-turn-id="turn-partial-history-${PARTIAL_HISTORY_TURN_COUNT}"]`)).toBeVisible();
+  await expect(ticks).toHaveCount(PARTIAL_HISTORY_TURN_COUNT);
 });