test(app): retain separate initial theme journeys

test(app): consolidate browser setup and rebalance CI shards
test(app): control hidden turn completion explicitly
2026-10-21 00:32:45 +00:00 · 2026-10-17 21:20:46 +02:00 · 2026-10-17 21:12:13 +02:00 · 2026-10-17 18:54:16 +02:00 · 2026-10-17 18:37:38 +02:00
37 changed files with 1646 additions and 2028 deletions
@@ -405,9 +405,9 @@ jobs:
        run: npm run test:e2e --workspace=@getpaseo/app -- --shard=${{ env.PLAYWRIGHT_SHARD }}
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          # Weight file groups by observed duration; raw test counts overload
-          # early agent/Changes specs. Required check names remain unchanged.
-          PWTEST_SHARD_WEIGHTS: "111:172:137:160"
+          # Balance contiguous file groups using CI durations and the trimmed
+          # inventory. Required check names and worker counts stay unchanged.
+          PWTEST_SHARD_WEIGHTS: "187:183:184:201"

      - name: Upload test artifacts
        uses: actions/upload-artifact@v4
@@ -154,6 +154,8 @@ npm run test:e2e:browser-tabs --workspace=@getpaseo/desktop
 - Extract complex setup into reusable helpers
 - Test bodies should read like plain English
 - Build a vocabulary of test helpers that make complex flows simple
+- Use one browser test per causal user journey, with named `test.step()` blocks for behaviors reached along the way. Reuse the open form, workspace, and browser state. Start another test for a distinct initial state, failure injection, race ordering, viewport, or destructive branch.
+- Keep pure test-helper checks in `packages/app/e2e/support/helpers/*.test.ts`; the app unit job runs them without Metro, a daemon, or a browser.

 ### File naming

@@ -460,7 +460,7 @@ async function expectHiddenStreamingSubmissionOrderAfterWorkspaceEviction(
  const target = await seedMockAgentWorkspace({
    repoPrefix: `submission-hidden-stream-${testInfo.workerIndex}-`,
    title: "Hidden streaming submission",
-    model: "ten-second-stream",
+    model: "e2e-fast-stream",
  });
  const evictionAgents = await Promise.all(
    Array.from({ length: WORKSPACE_DECK_MAX_MOUNTED_WORKSPACES }, (_unused, index) =>
@@ -549,7 +549,7 @@ async function expectCompletedSubmissionClearsAfterMissedRunningTransition(
  const agent = await seedMockAgentWorkspace({
    repoPrefix: `submission-missed-running-${testInfo.workerIndex}-`,
    title: "Submission missed running transition",
-    model: "ten-second-stream",
+    model: "e2e-fast-stream",
  });
  try {
    await openAgentRoute(page, { workspaceId: agent.workspaceId, agentId: agent.agentId });
@@ -700,7 +700,7 @@ async function expectCanonicalOrderWinsAcrossOverlappingClients(
  const agent = await seedMockAgentWorkspace({
    repoPrefix: `submission-cross-client-order-${testInfo.workerIndex}-`,
    title: "Cross-client submission order",
-    model: "ten-second-stream",
+    model: "e2e-fast-stream",
  });
  const localPrompt = "Send this after the other client turn.";
  const remotePrompt = "Commit this other client turn first.";
@@ -36,15 +36,25 @@ test.describe("Host agent skills", () => {
    page,
    skills,
  }) => {
+    await page.setViewportSize({ width: 1280, height: 900 });
    const custom = skills.available.slice(0, 2);
    const cancelledAddition = skills.available[2]!;
    await openAgentSkillsSettings(page, skills);

    await openSkillSelection(page);
+    await test.step("the desktop sheet gives the bundled label its intended inset", async () => {
+      await expectBundledSkillsInset(page);
+    });
    await chooseCustomSkills(page, custom);
    await saveSkillSelection(page);
    await expectInstalledSkills(skills, custom);
    await expectSavedSelection(skills, { mode: "custom", skills: custom });
+    await test.step("installation ignores agent config environment overrides", async () => {
+      await expect(access(`${skills.home}/../ignored-claude-config/skills`)).rejects.toThrow(
+        "ENOENT",
+      );
+      await expect(access(`${skills.home}/../ignored-codex-home/skills`)).rejects.toThrow("ENOENT");
+    });

    await openSkillSelection(page);
    await toggleSkill(page, cancelledAddition);
@@ -150,23 +160,6 @@ test.describe("Host agent skills", () => {
    await expectInstalledSkills(skills, secondSelection.skills);
    await expectSavedSelection(skills, secondSelection);
  });
-
-  test("ignores agent config environment overrides", async ({ skills }) => {
-    await skills.install({ mode: "custom", skills: [skills.available[0]!] });
-
-    await expect(
-      access(`${skills.home}/../ignored-claude-config/skills`).then(
-        () => true,
-        () => false,
-      ),
-    ).resolves.toBe(false);
-    await expect(
-      access(`${skills.home}/../ignored-codex-home/skills`).then(
-        () => true,
-        () => false,
-      ),
-    ).resolves.toBe(false);
-  });
 });

 function allSkillsCard(page: Parameters<typeof openSkillSelection>[0]) {
@@ -192,24 +185,14 @@ test.describe("Agent skills sheet inset", () => {
      await openSkillSelection(page);
      await waitForSettledPosition(page.getByTestId("skill-selection-sheet"));

-      expect({
-        aboveLabel: await readVerticalGap(allSkillsCard(page), bundledSkillsLabel(page)),
-        belowLabel: await readVerticalGap(bundledSkillsLabel(page), skillListCard(page)),
-      }).toEqual({ aboveLabel: 16, belowLabel: 12 });
-    });
-  });
-
-  test.describe("desktop", () => {
-    test.use({ viewport: { width: 1280, height: 900 } });
-
-    test("keeps more space above the bundled skills label than below", async ({ page, skills }) => {
-      await openAgentSkillsSettings(page, skills);
-      await openSkillSelection(page);
-
-      expect({
-        aboveLabel: await readVerticalGap(allSkillsCard(page), bundledSkillsLabel(page)),
-        belowLabel: await readVerticalGap(bundledSkillsLabel(page), skillListCard(page)),
-      }).toEqual({ aboveLabel: 16, belowLabel: 12 });
+      await expectBundledSkillsInset(page);
    });
  });
 });
+
+async function expectBundledSkillsInset(page: Parameters<typeof openSkillSelection>[0]) {
+  expect({
+    aboveLabel: await readVerticalGap(allSkillsCard(page), bundledSkillsLabel(page)),
+    belowLabel: await readVerticalGap(bundledSkillsLabel(page), skillListCard(page)),
+  }).toEqual({ aboveLabel: 16, belowLabel: 12 });
+}
@@ -1,9 +1,7 @@
 import { test } from "../support/fixtures";
 import { expect } from "@playwright/test";
 import {
-  findScrollJumps,
  expectImageSpaceReserved,
-  type ScrollFrame,
  observeTimelinePages,
  openOnlyTimelineTail,
  recordUpwardTraversal,
@@ -14,179 +12,6 @@ import {
  holdParagraphThroughCompletion,
 } from "../support/helpers/timeline-scroll-smoothness";

-test("scroll detector distinguishes entered image growth from a simultaneous viewport jump", () => {
-  const before: ScrollFrame = {
-    at: 1000,
-    scrollTop: 1000,
-    scrollHeight: 5000,
-    viewportHeight: 800,
-    virtualized: true,
-    loading: false,
-    rows: [
-      { id: "image", top: -150, height: 150 },
-      { id: "reading", top: 0, height: 100 },
-    ],
-    anchor: "reading",
-    wheelTotal: 0,
-    lastWheelAt: 0,
-    inputFinishedAt: null,
-    imageLoads: 0,
-    mounted: 0,
-    unmounted: 0,
-  };
-  const after: ScrollFrame = {
-    ...before,
-    at: 1400,
-    scrollTop: 900,
-    wheelTotal: 100,
-    lastWheelAt: 1050,
-    rows: [
-      { id: "image", top: -50, height: 1150 },
-      { id: "reading", top: 1100, height: 100 },
-    ],
-  };
-  expect(findScrollJumps([before, after])).toEqual([]);
-  expect(
-    findScrollJumps([
-      { ...before, scrollTop: 200 },
-      {
-        ...after,
-        wheelTotal: 1000,
-        scrollTop: 0,
-        rows: after.rows.map((row) => ({ ...row, top: row.top + 100 })),
-      },
-    ]),
-  ).toEqual([]);
-  expect(
-    findScrollJumps([
-      before,
-      { ...after, rows: after.rows.map((row) => ({ ...row, top: row.top - 500 })) },
-    ]),
-  ).toHaveLength(1);
-  expect(
-    findScrollJumps([
-      { ...before, anchor: "image", rows: [{ id: "image", top: 0, height: 150 }] },
-      { ...after, rows: [{ id: "image", top: 600, height: 1150 }] },
-    ]),
-  ).toHaveLength(1);
-});
-
-test("scroll detector accounts for delayed wheel input and growth below the new reader", () => {
-  const before: ScrollFrame = {
-    at: 1000,
-    scrollTop: 2000,
-    scrollHeight: 5000,
-    viewportHeight: 800,
-    virtualized: true,
-    loading: false,
-    rows: [
-      { id: "new-reader", top: -520, height: 278 },
-      { id: "image", top: -242, height: 184 },
-      { id: "old-reader", top: -58, height: 130 },
-    ],
-    anchor: "old-reader",
-    wheelTotal: 0,
-    lastWheelAt: 0,
-    inputFinishedAt: null,
-    imageLoads: 0,
-    mounted: 0,
-    unmounted: 0,
-  };
-  const wheel = { ...before, at: 1100, wheelTotal: 480, lastWheelAt: 1099 };
-  const after: ScrollFrame = {
-    ...wheel,
-    at: 1220,
-    scrollTop: 1520,
-    scrollHeight: 5041,
-    anchor: "new-reader",
-    rows: [
-      { id: "new-reader", top: -40, height: 278 },
-      { id: "image", top: 238, height: 225 },
-      { id: "old-reader", top: 463, height: 130 },
-    ],
-  };
-  expect(findScrollJumps([before, wheel, after])).toEqual([]);
-  // The previous 480 px input has already moved the viewport; the recent
-  // budget includes it, but only the next 480 px belongs to this frame.
-  const steadyBefore = { ...before, at: 1050, wheelTotal: 480, lastWheelAt: 1049 };
-  const steadyAfter = {
-    ...after,
-    at: 1100,
-    wheelTotal: 960,
-    lastWheelAt: 1099,
-    scrollHeight: 6000,
-    rows: [
-      { id: "new-reader", top: -40, height: 278 },
-      { id: "image", top: 238, height: 1184 },
-      { id: "old-reader", top: 1422, height: 130 },
-    ],
-  };
-  expect(findScrollJumps([steadyBefore, steadyAfter])).toEqual([]);
-
-  expect(
-    findScrollJumps([
-      before,
-      wheel,
-      {
-        ...after,
-        rows: after.rows.map((row) => ({ id: row.id, height: row.height, top: row.top + 100 })),
-      },
-    ]),
-  ).toHaveLength(1);
-});
-
-test("scroll detector follows the entered image through resize and virtual offset correction", () => {
-  for (const height of [225, 1632]) {
-    const before: ScrollFrame = {
-      at: 1000,
-      scrollTop: 2208,
-      scrollHeight: 5000,
-      viewportHeight: 516,
-      virtualized: true,
-      loading: false,
-      rows: [
-        { id: "image", top: -704, height: 560 },
-        { id: "caption", top: -144, height: 100 },
-        { id: "old-reader", top: -44, height: 127 },
-      ],
-      anchor: "old-reader",
-      wheelTotal: 0,
-      lastWheelAt: 0,
-      inputFinishedAt: null,
-      imageLoads: 0,
-      mounted: 3,
-      unmounted: 0,
-    };
-    const resize = height - 560;
-    const after: ScrollFrame = {
-      ...before,
-      at: 1060,
-      // The virtualizer corrects 110px of estimates while the wheel moves 160px.
-      scrollTop: 1938,
-      scrollHeight: 5000 + resize - 110,
-      wheelTotal: 160,
-      lastWheelAt: 1020,
-      imageLoads: 1,
-      rows: [
-        { id: "image", top: -544, height },
-        { id: "caption", top: 16 + resize, height: 100 },
-        { id: "old-reader", top: 116 + resize, height: 127 },
-      ],
-    };
-    expect(findScrollJumps([before, after])).toEqual([]);
-    // Resizing must not excuse additional viewport movement.
-    expect(
-      findScrollJumps([
-        before,
-        {
-          ...after,
-          rows: after.rows.map((row) => ({ id: row.id, height: row.height, top: row.top + 100 })),
-        },
-      ]),
-    ).toHaveLength(1);
-  }
-});
-
 for (const cadence of scrollCadences) {
  test(`varied timeline preserves reading position during ${cadence.name} upward scrolling`, async ({
    page,
@@ -51,7 +51,9 @@ test.describe("Archive tab reconciliation", () => {
    await tempRepo?.cleanup();
  });

-  test("non-UI archive prunes the archived tab across open pages and reload", async ({ page }) => {
+  test("non-UI archive prunes open tabs and keeps the session archived when reopened", async ({
+    page,
+  }) => {
    const archived = await createIdleAgent(client, {
      cwd: tempRepo.path,
      workspaceId,
@@ -65,28 +67,51 @@ test.describe("Archive tab reconciliation", () => {
    const passivePage = await page.context().newPage();

    try {
-      await primeAdditionalPage(passivePage);
-      await resetSeededPageState(page);
-      await resetSeededPageState(passivePage);
-      await openSessions(page);
-      await expectSessionRowVisible(page, archived.title);
-      await expectSessionRowVisible(page, surviving.title);
-      await openSessions(passivePage);
-      await expectSessionRowVisible(passivePage, archived.title);
-      await expectSessionRowVisible(passivePage, surviving.title);
-      await openWorkspaceWithAgents(page, [archived, surviving]);
-      await openWorkspaceWithAgents(passivePage, [archived, surviving]);
+      await test.step("open both sessions in two pages", async () => {
+        await primeAdditionalPage(passivePage);
+        await resetSeededPageState(page);
+        await resetSeededPageState(passivePage);
+        await openSessions(page);
+        await expectSessionRowVisible(page, archived.title);
+        await expectSessionRowVisible(page, surviving.title);
+        await openSessions(passivePage);
+        await expectSessionRowVisible(passivePage, archived.title);
+        await expectSessionRowVisible(passivePage, surviving.title);
+        await openWorkspaceWithAgents(page, [archived, surviving]);
+        await openWorkspaceWithAgents(passivePage, [archived, surviving]);
+      });
+
      await archiveAgentFromDaemon(client, archived.id);
-      await expectWorkspaceArchiveOutcome(page, {
-        archivedAgentId: archived.id,
-        survivingAgentId: surviving.id,
+      const archivedAt = await fetchAgentArchivedAt(client, archived.id);
+      expect(archivedAt).not.toBeNull();
+
+      await test.step("prune the archived tab across both pages and reload", async () => {
+        await expectWorkspaceArchiveOutcome(page, {
+          archivedAgentId: archived.id,
+          survivingAgentId: surviving.id,
+        });
+        await expectWorkspaceArchiveOutcome(passivePage, {
+          archivedAgentId: archived.id,
+          survivingAgentId: surviving.id,
+        });
+        await reloadWorkspace(passivePage, surviving.workspaceId);
+        await expectWorkspaceTabHidden(passivePage, archived.id);
      });
-      await expectWorkspaceArchiveOutcome(passivePage, {
-        archivedAgentId: archived.id,
-        survivingAgentId: surviving.id,
+
+      await test.step("reopen the archived session without unarchiving it", async () => {
+        await openSessions(page);
+        await expectSessionRowArchived(page, archived.title);
+
+        await clickSessionRow(page, archived.title);
+
+        await expectArchivedAgentFocused(page, archived.id);
+        await expectAgentTabActive(page, archived.id);
+        expect(await fetchAgentArchivedAt(client, archived.id)).toBe(archivedAt);
+
+        await expect(page).toHaveURL(buildHostWorkspaceRoute(getServerId(), archived.workspaceId), {
+          timeout: 30_000,
+        });
      });
-      await reloadWorkspace(passivePage, surviving.workspaceId);
-      await expectWorkspaceTabHidden(passivePage, archived.id);
    } finally {
      await passivePage.close();
    }
@@ -123,35 +148,4 @@ test.describe("Archive tab reconciliation", () => {
      await passivePage.close();
    }
  });
-
-  test("clicking an archived session navigates without unarchiving it", async ({ page }) => {
-    const archived = await createIdleAgent(client, {
-      cwd: tempRepo.path,
-      workspaceId,
-      title: `unarchive-archived-${randomUUID().slice(0, 8)}`,
-    });
-    const surviving = await createIdleAgent(client, {
-      cwd: tempRepo.path,
-      workspaceId,
-      title: `unarchive-control-${randomUUID().slice(0, 8)}`,
-    });
-
-    await resetSeededPageState(page);
-    await openWorkspaceWithAgents(page, [archived, surviving]);
-    await archiveAgentFromDaemon(client, archived.id);
-    const archivedAt = await fetchAgentArchivedAt(client, archived.id);
-    expect(archivedAt).not.toBeNull();
-    await openSessions(page);
-    await expectSessionRowArchived(page, archived.title);
-
-    await clickSessionRow(page, archived.title);
-
-    await expectArchivedAgentFocused(page, archived.id);
-    await expectAgentTabActive(page, archived.id);
-    expect(await fetchAgentArchivedAt(client, archived.id)).toBe(archivedAt);
-
-    await expect(page).toHaveURL(buildHostWorkspaceRoute(getServerId(), archived.workspaceId), {
-      timeout: 30_000,
-    });
-  });
 });
@@ -90,7 +90,7 @@ test.describe("Assistant fork menu", () => {
    await expectLiveAssistantText(page, visibleAfterFork);
  });

-  test("focuses a forked assistant turn in a new workspace draft tab", async ({
+  test("focuses an existing-workspace fork draft and keeps its attachment after submission", async ({
    page,
    seedForkWorkspace,
  }) => {
@@ -101,55 +101,44 @@ test.describe("Assistant fork menu", () => {
      model: "ten-second-stream",
    });

-    await openAgentRoute(page, session);
-    await expectComposerVisible(page);
-    await awaitAssistantMessage(page);
-    await session.client.waitForFinish(session.agentId, 45_000);
+    await test.step("complete a second assistant turn in the visible source tab", async () => {
+      await openAgentRoute(page, session);
+      await expectComposerVisible(page);
+      await awaitAssistantMessage(page);
+      await session.client.waitForFinish(session.agentId, 45_000);

-    await submitMessage(page, "emit 1 coalesced agent stream updates while this tab is visible.");
-    await session.client.waitForFinish(session.agentId, 45_000);
-    await awaitAssistantMessage(page);
-
-    const agentTab = page.getByTestId(`workspace-tab-agent_${session.agentId}`);
-    await expect(agentTab).toHaveAttribute("aria-selected", "true");
-
-    await forkMostRecentAssistantTurnToNewTab(page);
-
-    const selectedTab = page
-      .getByTestId("workspace-tabs-row")
-      .getByRole("button")
-      .and(page.locator('[aria-selected="true"]'));
-    await expect(selectedTab).toHaveAttribute("data-testid", /^workspace-tab-draft_/, {
-      timeout: 30_000,
-    });
-    await expect(agentTab).toHaveAttribute("aria-selected", "false");
-    await expectChatHistoryAttachment(page);
-  });
-
-  test("keeps the fork attachment after submitting an existing-workspace draft tab", async ({
-    page,
-    seedForkWorkspace,
-  }) => {
-    const session = await seedForkWorkspace({
-      repoPrefix: "assistant-fork-tab-submit-",
-      title: "Assistant fork tab submit",
-      initialPrompt: "emit 1 coalesced agent stream updates for assistant fork tab submit.",
-      model: "ten-second-stream",
+      await submitMessage(page, "emit 1 coalesced agent stream updates while this tab is visible.");
+      await session.client.waitForFinish(session.agentId, 45_000);
+      await awaitAssistantMessage(page);
    });

-    await openAgentRoute(page, session);
-    await expectComposerVisible(page);
-    await awaitAssistantMessage(page);
-    await session.client.waitForFinish(session.agentId, 45_000);
+    await test.step("fork the latest turn into the selected draft tab", async () => {
+      const agentTab = page.getByTestId(`workspace-tab-agent_${session.agentId}`);
+      await expect(agentTab).toHaveAttribute("aria-selected", "true");

-    await forkMostRecentAssistantTurnToNewTab(page);
-    await expectChatHistoryAttachment(page);
+      await forkMostRecentAssistantTurnToNewTab(page);

-    await submitMessage(page, "");
+      const selectedTab = page
+        .getByTestId("workspace-tabs-row")
+        .getByRole("button")
+        .and(page.locator('[aria-selected="true"]'));
+      await expect(selectedTab).toHaveAttribute("data-testid", /^workspace-tab-draft_/, {
+        timeout: 30_000,
+      });
+      await expect(agentTab).toHaveAttribute("aria-selected", "false");
+      await expectChatHistoryAttachment(page);
+    });

-    const userMessage = page.getByTestId("user-message").filter({ hasText: "Chat history" }).last();
-    await expect(userMessage).toBeVisible({ timeout: 30_000 });
-    await expect(userMessage).not.toContainText("Source agent:");
+    await test.step("submit that draft with its chat-history attachment", async () => {
+      await submitMessage(page, "");
+
+      const userMessage = page
+        .getByTestId("user-message")
+        .filter({ hasText: "Chat history" })
+        .last();
+      await expect(userMessage).toBeVisible({ timeout: 30_000 });
+      await expect(userMessage).not.toContainText("Source agent:");
+    });
  });

  test("forks an assistant turn into New Workspace and keeps the attachment across host changes", async ({
@@ -262,15 +262,54 @@ test.afterEach(async () => {
  }
 });

-test("Changes opens the populated committed comparison for a clean checkout", async ({ page }) => {
+test("clean Changes opens committed changes and navigates an empty comparison", async ({
+  page,
+}) => {
  const workspace = await createWorkspaceWithCommittedDiff();
-
  await openWorkspaceChangesSurface(page, workspace, 90_000);

-  const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
-  const tree = page.getByTestId("changes-tree-panel").filter({ visible: true });
-  await expect(tree.getByTestId("changes-diff-status-trigger")).toContainText("Committed");
-  await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName("committed-only.ts, +1, -0");
+  await test.step("Changes opens the populated committed comparison for a clean checkout", async () => {
+    const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
+    const tree = page.getByTestId("changes-tree-panel").filter({ visible: true });
+    await expect(tree.getByTestId("changes-diff-status-trigger")).toContainText("Committed");
+    await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName(
+      "committed-only.ts, +1, -0",
+    );
+  });
+
+  await test.step("an empty Changes comparison links to the populated comparison", async () => {
+    const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
+    const tree = page.getByTestId("changes-tree-panel").filter({ visible: true });
+    const mode = tree.getByTestId("changes-diff-status-trigger");
+    await mode.click();
+    await page.getByTestId("changes-diff-mode-committed").click();
+    await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName(
+      "committed-only.ts, +1, -0",
+    );
+
+    await mode.click();
+    await page.getByTestId("changes-diff-mode-uncommitted").click();
+
+    await expect(tree.getByText("No changes to display", { exact: true })).toBeVisible();
+    await expect(panel.getByText("No changes to display", { exact: true })).toBeVisible();
+    const seeCommitted = tree.getByRole("button", { name: "See committed changes" });
+    await expect(seeCommitted).toBeVisible();
+    await seeCommitted.click();
+    await expect(mode).toContainText("Committed");
+    await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName(
+      "committed-only.ts, +1, -0",
+    );
+  });
+
+  await test.step("Jump to file stays out of the desktop diff and of an empty comparison", async () => {
+    await expect(page.getByRole("button", { name: "Jump to file" })).toHaveCount(0);
+
+    const explorer = await openCompactChanges(page, workspace);
+    await expect(explorer.getByRole("button", { name: "Jump to file" })).toBeVisible();
+
+    await selectEmptyUncommittedComparison(page, explorer);
+    await expect(page.getByRole("button", { name: "Jump to file" })).toHaveCount(0);
+  });
 });

 test("Changes expires a manual comparison when checkout dirtiness changes", async ({ page }) => {
@@ -297,29 +336,6 @@ test("Changes expires a manual comparison when checkout dirtiness changes", asyn
  await expect(mode).toContainText("Uncommitted", { timeout: 30_000 });
 });

-test("an empty Changes comparison links to the populated comparison", async ({ page }) => {
-  const workspace = await createWorkspaceWithCommittedDiff();
-  await openWorkspaceChangesSurface(page, workspace);
-
-  const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
-  const tree = page.getByTestId("changes-tree-panel").filter({ visible: true });
-  const mode = tree.getByTestId("changes-diff-status-trigger");
-  await mode.click();
-  await page.getByTestId("changes-diff-mode-committed").click();
-  await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName("committed-only.ts, +1, -0");
-
-  await mode.click();
-  await page.getByTestId("changes-diff-mode-uncommitted").click();
-
-  await expect(tree.getByText("No changes to display", { exact: true })).toBeVisible();
-  await expect(panel.getByText("No changes to display", { exact: true })).toBeVisible();
-  const seeCommitted = tree.getByRole("button", { name: "See committed changes" });
-  await expect(seeCommitted).toBeVisible();
-  await seeCommitted.click();
-  await expect(mode).toContainText("Committed");
-  await expect(panel.getByTestId("diff-file-0")).toHaveAccessibleName("committed-only.ts, +1, -0");
-});
-
 test("Changes comparison controls the working diff and tree selection focuses its file", async ({
  page,
 }) => {
@@ -335,223 +351,109 @@ test("Changes comparison controls the working diff and tree selection focuses it
  await selectChangedFileAndExpectFocused(page, "uncommitted/50-target.ts");
 });

-test("changes file actions open below the right-click without a reserved kebab", async ({
+test("horizontal diff scrolling preserves its header and offset across collapse", async ({
  page,
 }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff({ includeDeletedFile: true });
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-
-  const deletedFileName = page.getByTestId("diff-file-1");
-  await expect(deletedFileName).toHaveAccessibleName(/zz-deleted\.ts/);
-  await deletedFileName.dblclick();
-  expect(await page.evaluate(() => window.getSelection()?.toString() ?? "")).toBe("");
-  await expect(page.getByTestId(/diff-file-\d+-actions/)).toHaveCount(0);
-  await page.getByTestId("diff-file-1-toggle").click({ button: "right" });
-  await expect(page.getByText("Copy path")).toBeVisible();
-  await page.getByText("Copy path", { exact: true }).click({ button: "right" });
-  await expect(page.getByText("Copy path")).toBeVisible();
-  await expect(page.getByTestId("diff-file-1-open-file")).toHaveCount(0);
-  await page.keyboard.press("Escape");
-
-  const fileRow = page.getByTestId("diff-file-0-toggle");
-  const fileRowBounds = await fileRow.boundingBox();
-  expect(fileRowBounds).not.toBeNull();
-  await fileRow.click({ button: "right", position: { x: 80, y: 10 } });
-  await expect(page.getByTestId("diff-file-0-open-file")).toBeVisible();
-  const menuBounds = await page.getByTestId("diff-file-0-context-menu").boundingBox();
-  expect(menuBounds).not.toBeNull();
-  expect(Math.abs(menuBounds!.x - (fileRowBounds!.x + 80))).toBeLessThanOrEqual(1);
-  expect(menuBounds!.y).toBeGreaterThan(fileRowBounds!.y + 10);
-  await page.getByTestId("diff-file-0-open-file").click();
-
-  await expect(page.getByTestId("workspace-file-pane")).toBeVisible();
-  await expect(page.getByTestId("workspace-tab-file_src/use-mounted-tab-set.ts")).toBeVisible();
-});
-
-test("canvas file headers select without toggling for context menu and long press", async ({
-  page,
-}) => {
-  const workspace = await createWorkspaceWithMountedTabDiff({ includeDeletedFile: true });
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-
-  const firstFile = page.getByTestId("diff-file-0-toggle");
-  const deletedFile = page.getByTestId("diff-file-1-toggle");
-  await deletedFile.click({ button: "right" });
-  await expect(deletedFile).toHaveAttribute("aria-selected", "true");
-  await expect(deletedFile).toHaveAttribute("aria-expanded", "true");
-  await expect(page.getByText("Copy path")).toBeVisible();
-  await page.keyboard.press("Escape");
-
-  await longPressFileHeader(page, firstFile);
-  await expect(firstFile).toHaveAttribute("aria-selected", "true");
-  await expect(deletedFile).toHaveAttribute("aria-selected", "false");
-  await expect(firstFile).toHaveAttribute("aria-expanded", "true");
-});
-
-test("every interactive file header has the same hover feedback", async ({ page }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff({ includeDeletedFile: true });
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-
-  const first = page.getByTestId("diff-file-0-toggle");
-  const second = page.getByTestId("diff-file-1-toggle");
-  const firstCanvas = page.getByTestId("git-diff-sticky-header-0");
-  const secondCanvas = page.getByTestId("git-diff-sticky-header-1");
-  const normalBackground = await headerCanvasPixel(firstCanvas, first, 10);
-
-  await first.hover();
-  await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).not.toBe(normalBackground);
-  const hoverBackground = await headerCanvasPixel(firstCanvas, first, 10);
-
-  await first.click();
-  await page.mouse.move(0, 0);
-  await expect(first).toHaveAttribute("aria-expanded", "false");
-  await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).toBe(normalBackground);
-
-  await first.hover();
-  await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).toBe(hoverBackground);
-  await second.hover();
-  await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).toBe(normalBackground);
-  await expect.poll(() => headerCanvasPixel(secondCanvas, second, 10)).toBe(hoverBackground);
-});
-
-test("horizontal body scrolling never moves or repaints the canvas header", async ({ page }) => {
  const wideLine = `export const wide = "${"wide".repeat(160)}";`;
  const workspace = await createWorkspaceWithExactSelectionDiff(wideLine);
  await useUnwrappedDiffLines(page);
  await openSelectionWorkspaceChanges(page, workspace);

-  const headerCanvas = page.getByTestId("git-diff-canvas");
-  const header = page.getByTestId("diff-file-0-toggle");
-  const beforePixel = await headerCanvasPixel(headerCanvas, header, 10);
-  const beforeBounds = await header.boundingBox();
+  await test.step("horizontal body scrolling never moves or repaints the canvas header", async () => {
+    const headerCanvas = page.getByTestId("git-diff-canvas");
+    const header = page.getByTestId("diff-file-0-toggle");
+    const beforePixel = await headerCanvasPixel(headerCanvas, header, 10);
+    const beforeBounds = await header.boundingBox();

-  await horizontallyScrollFirstFile(page, 320);
-  await page.waitForTimeout(50);
+    await horizontallyScrollFirstFile(page, 320);
+    await page.waitForTimeout(50);

-  expect(await headerCanvasPixel(headerCanvas, header, 10)).toBe(beforePixel);
-  expect(await header.boundingBox()).toEqual(beforeBounds);
+    expect(await headerCanvasPixel(headerCanvas, header, 10)).toBe(beforePixel);
+    expect(await header.boundingBox()).toEqual(beforeBounds);
+  });
+
+  await test.step("collapsing and expanding restores the real horizontal scroll offset", async () => {
+    const retainedOffset = await horizontallyScrollFirstFile(page, 320);
+    await page.getByTestId("diff-file-0-toggle").click();
+    await expect(page.getByTestId("diff-file-0-horizontal-scroll")).toHaveCount(0);
+    await page.getByTestId("diff-file-0-toggle").click();
+
+    await expect.poll(() => readHorizontalDiffOffset(page)).toBe(retainedOffset);
+  });
 });

-test("in-flow file headers move with the diff document", async ({ page }) => {
-  const workspace = await createWorkspaceWithStickyTransitionDiff();
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChangesSurface(page, workspace);
-
-  const motion = await measureInFlowHeaderMotion(page);
-
-  expect(motion).toEqual({ headerSurface: -120, shell: -120 });
-});
-
-test("the outgoing sticky header hands off without a gap or overlap", async ({
+test("file headers scroll with the document and hand off without gaps", async ({
  page,
 }, testInfo) => {
  const workspace = await createWorkspaceWithStickyTransitionDiff();
  await useUnwrappedDiffLines(page);
  await openWorkspaceChangesSurface(page, workspace);

-  const scroller = page.getByTestId("git-diff-scroll");
-  const first = page.getByTestId("diff-file-0-toggle");
-  const second = page.getByTestId("diff-file-1-toggle");
-  const secondTop = await second.evaluate((element) => {
-    const scrollElement = element.closest<HTMLElement>('[data-testid="git-diff-scroll"]');
-    if (!scrollElement) return Number.NaN;
-    return (
-      scrollElement.scrollTop +
-      element.getBoundingClientRect().top -
-      scrollElement.getBoundingClientRect().top
-    );
-  });
-  expect(secondTop).toBeGreaterThan(30);
-  await scroller.evaluate((element, scrollTop) => {
-    element.scrollTop = scrollTop;
-    element.dispatchEvent(new Event("scroll", { bubbles: false }));
-  }, secondTop - 15);
-  await expect(first).toBeAttached();
-  await expect(second).toBeAttached();
+  await test.step("in-flow file headers move with the diff document", async () => {
+    const motion = await measureInFlowHeaderMotion(page);

-  const [scrollBounds, firstBounds, secondBounds] = await Promise.all([
-    scroller.boundingBox(),
-    first.boundingBox(),
-    second.boundingBox(),
-  ]);
-  if (!scrollBounds || !firstBounds || !secondBounds) {
-    throw new Error("Sticky transition geometry is unavailable");
-  }
-  expect(firstBounds.y - scrollBounds.y).toBeCloseTo(-15, 0);
-  expect(secondBounds.y - scrollBounds.y).toBeCloseTo(15, 0);
-  const transitionHits = await scroller.evaluate((element) => {
-    const bounds = element.getBoundingClientRect();
-    return [14, 16].map(
-      (y) =>
+    expect(motion).toEqual({ headerSurface: -120, shell: -120 });
+  });
+
+  await test.step("the outgoing sticky header hands off without a gap or overlap", async () => {
+    const scroller = page.getByTestId("git-diff-scroll");
+    const first = page.getByTestId("diff-file-0-toggle");
+    const second = page.getByTestId("diff-file-1-toggle");
+    const secondTop = await second.evaluate((element) => {
+      const scrollElement = element.closest<HTMLElement>('[data-testid="git-diff-scroll"]');
+      if (!scrollElement) return Number.NaN;
+      return (
+        scrollElement.scrollTop +
+        element.getBoundingClientRect().top -
+        scrollElement.getBoundingClientRect().top
+      );
+    });
+    expect(secondTop).toBeGreaterThan(30);
+    await scroller.evaluate((element, scrollTop) => {
+      element.scrollTop = scrollTop;
+      element.dispatchEvent(new Event("scroll", { bubbles: false }));
+    }, secondTop - 15);
+    await expect(first).toBeAttached();
+    await expect(second).toBeAttached();
+
+    const [scrollBounds, firstBounds, secondBounds] = await Promise.all([
+      scroller.boundingBox(),
+      first.boundingBox(),
+      second.boundingBox(),
+    ]);
+    if (!scrollBounds || !firstBounds || !secondBounds) {
+      throw new Error("Sticky transition geometry is unavailable");
+    }
+    expect(firstBounds.y - scrollBounds.y).toBeCloseTo(-15, 0);
+    expect(secondBounds.y - scrollBounds.y).toBeCloseTo(15, 0);
+    const transitionHits = await scroller.evaluate((element) => {
+      const bounds = element.getBoundingClientRect();
+      const headerAt = (y: number) =>
        document
          .elementFromPoint(bounds.left + bounds.width / 2, bounds.top + y)
-          ?.closest<HTMLElement>("[data-diff-header]")?.dataset.diffHeaderPath ?? null,
-    );
-  });
-  expect(transitionHits).toEqual(["src/first.ts", "src/second.ts"]);
-  await testInfo.attach("canvas-header-sticky-handoff", {
-    body: await page.getByTestId("git-diff-canvas-root").screenshot(),
-    contentType: "image/png",
-  });
+          ?.closest<HTMLElement>("[data-diff-header]")?.dataset.diffHeaderPath ?? null;
+      return [headerAt(14), headerAt(16)];
+    });
+    expect(transitionHits).toEqual(["src/first.ts", "src/second.ts"]);
+    await testInfo.attach("canvas-header-sticky-handoff", {
+      body: await page.getByTestId("git-diff-canvas-root").screenshot(),
+      contentType: "image/png",
+    });

-  await scroller.evaluate((element, scrollTop) => {
-    element.scrollTop = scrollTop;
-    element.dispatchEvent(new Event("scroll", { bubbles: false }));
-  }, secondTop);
-  await expect
-    .poll(async () => {
-      const bounds = await second.boundingBox();
-      return bounds ? bounds.y - scrollBounds.y : Number.NaN;
-    })
-    .toBeCloseTo(0, 0);
+    await scroller.evaluate((element, scrollTop) => {
+      element.scrollTop = scrollTop;
+      element.dispatchEvent(new Event("scroll", { bubbles: false }));
+    }, secondTop);
+    await expect
+      .poll(async () => {
+        const bounds = await second.boundingBox();
+        return bounds ? bounds.y - scrollBounds.y : Number.NaN;
+      })
+      .toBeCloseTo(0, 0);
+  });
 });

-test("changes context menus duplicate files and folders", async ({ page }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff();
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-
-  await page.getByTestId("diff-file-0-toggle").click({ button: "right" });
-  await page.getByTestId("diff-file-0-duplicate").click();
-  await expect
-    .poll(() => readFileIfPresent(path.join(workspace.repoPath, "src/use-mounted-tab-set copy.ts")))
-    .toBe(AFTER);
-
-  await changesTree(page).getByTestId("diff-folder-src-toggle").click({ button: "right" });
-  await page.getByTestId("diff-folder-src-duplicate").click();
-  await expect
-    .poll(() => readFileIfPresent(path.join(workspace.repoPath, "src copy/use-mounted-tab-set.ts")))
-    .toBe(AFTER);
-});
-
-test("changes tree aligns every file status after its diff stat", async ({ page }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff({
-    includeDeletedFile: true,
-    includeUntrackedFile: true,
-  });
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-  const tree = changesTree(page);
-  const modifiedRow = tree.getByTestId("diff-tree-file-0");
-  const deletedRow = tree.getByTestId("diff-tree-file-1");
-  const addedRow = tree.getByTestId("diff-tree-file-2");
-  const modifiedStatus = modifiedRow.getByRole("img", { name: "Modified" });
-  await expect(modifiedStatus).toBeVisible();
-  await expect(deletedRow.getByRole("img", { name: "Deleted" })).toBeVisible();
-  await expect(addedRow.getByRole("img", { name: "New" })).toBeVisible();
-
-  const [statBounds, statusBounds] = await Promise.all([
-    modifiedRow.getByTestId("diff-tree-file-0-stat").boundingBox(),
-    modifiedStatus.boundingBox(),
-  ]);
-  if (!statBounds || !statusBounds) throw new Error("Changes tree trailing status has no bounds");
-  expect(statusBounds.x - (statBounds.x + statBounds.width)).toBeGreaterThanOrEqual(8);
-});
-
-test("the scrolling diff lists files in changes tree order", async ({ page }) => {
+test("browse the ordered changes tree and recursively collapse its folders", async ({ page }) => {
  const workspace = await createWorkspaceWithMountedTabDiff({
    includeNestedFolders: true,
    includeRootFileSortingFirst: true,
@@ -559,72 +461,70 @@ test("the scrolling diff lists files in changes tree order", async ({ page }) =>
  await useUnwrappedDiffLines(page);
  await openWorkspaceChanges(page, workspace);

-  const tree = changesTree(page);
-  const treeNames = tree.locator('[data-testid^="diff-tree-file-"][data-testid$="-name"]');
-  const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
-  const diffHeaders = panel.getByTestId(/^diff-file-\d+$/);
+  await test.step("the scrolling diff lists files in changes tree order", async () => {
+    const tree = changesTree(page);
+    const treeNames = tree.locator('[data-testid^="diff-tree-file-"][data-testid$="-name"]');
+    const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
+    const diffHeaders = panel.getByTestId(/^diff-file-\d+$/);

-  // Directories sort before files at every level, so the root note lands last
-  // even though "a-root-note.txt" compares below "src/..." as a whole string.
-  const expected = ["changed.ts", "root.ts", "use-mounted-tab-set.ts", "a-root-note.txt"];
+    // Directories sort before files at every level, so the root note lands last
+    // even though "a-root-note.txt" compares below "src/..." as a whole string.
+    const expected = ["changed.ts", "root.ts", "use-mounted-tab-set.ts", "a-root-note.txt"];

-  // Equal counts also prove no folder is collapsed: flattenDiffTree drops the
-  // descendants of a collapsed folder, which would make the tree a subsequence
-  // of the diff rather than a match, and mask a real ordering difference.
-  await expect(treeNames).toHaveCount(expected.length);
-  await expect(diffHeaders).toHaveCount(expected.length);
-  await expect(treeNames).toHaveText(expected);
-  const expectedHeaderNames = [
-    "src/zz-folder/nested/changed.ts, +1, -1",
-    "src/zz-folder/root.ts, +1, -1",
-    "src/use-mounted-tab-set.ts, +37, -1",
-    "a-root-note.txt, +1, -0",
-  ];
-  for (const [index, accessibleName] of expectedHeaderNames.entries()) {
-    await expect(diffHeaders.nth(index)).toHaveAccessibleName(accessibleName);
-  }
-});
+    // Equal counts also prove no folder is collapsed: flattenDiffTree drops the
+    // descendants of a collapsed folder, which would make the tree a subsequence
+    // of the diff rather than a match, and mask a real ordering difference.
+    await expect(treeNames).toHaveCount(expected.length);
+    await expect(diffHeaders).toHaveCount(expected.length);
+    await expect(treeNames).toHaveText(expected);
+    const expectedHeaderNames = [
+      "src/zz-folder/nested/changed.ts, +1, -1",
+      "src/zz-folder/root.ts, +1, -1",
+      "src/use-mounted-tab-set.ts, +37, -1",
+      "a-root-note.txt, +1, -0",
+    ];
+    for (const [index, accessibleName] of expectedHeaderNames.entries()) {
+      await expect(diffHeaders.nth(index)).toHaveAccessibleName(accessibleName);
+    }
+  });

-test("changes context menu recursively collapses descendant folders", async ({ page }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff({ includeNestedFolders: true });
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
+  await test.step("changes context menu recursively collapses descendant folders", async () => {
+    const tree = changesTree(page);
+    await expect(tree.getByTestId("diff-folder-src/zz-folder")).toBeVisible();
+    await expect(tree.getByTestId("diff-folder-src/zz-folder/nested")).toBeVisible();
+    const rootRow = tree.getByTestId("diff-folder-src-toggle");
+    const rootLabel = tree.getByTestId("diff-folder-src-toggle").getByText("src", { exact: true });
+    await expect(rootRow).toHaveCSS("opacity", "1");
+    await expect(rootLabel).toHaveCSS("opacity", "0.76");
+    await rootRow.hover();
+    await expect(rootLabel).toHaveCSS("opacity", "1");
+    await page.mouse.move(0, 0);
+    const nestedLabel = tree
+      .getByTestId("diff-folder-src/zz-folder-toggle")
+      .getByText("zz-folder", { exact: true });
+    const [rootBounds, nestedBounds] = await Promise.all([
+      rootLabel.boundingBox(),
+      nestedLabel.boundingBox(),
+    ]);
+    if (!rootBounds || !nestedBounds) throw new Error("Changes tree rows have no bounds");
+    expect(nestedBounds.x - rootBounds.x).toBe(12);

-  const tree = changesTree(page);
-  await expect(tree.getByTestId("diff-folder-src/zz-folder")).toBeVisible();
-  await expect(tree.getByTestId("diff-folder-src/zz-folder/nested")).toBeVisible();
-  const rootRow = tree.getByTestId("diff-folder-src-toggle");
-  const rootLabel = tree.getByTestId("diff-folder-src-toggle").getByText("src", { exact: true });
-  await expect(rootRow).toHaveCSS("opacity", "1");
-  await expect(rootLabel).toHaveCSS("opacity", "0.76");
-  await rootRow.hover();
-  await expect(rootLabel).toHaveCSS("opacity", "1");
-  await page.mouse.move(0, 0);
-  const nestedLabel = tree
-    .getByTestId("diff-folder-src/zz-folder-toggle")
-    .getByText("zz-folder", { exact: true });
-  const [rootBounds, nestedBounds] = await Promise.all([
-    rootLabel.boundingBox(),
-    nestedLabel.boundingBox(),
-  ]);
-  if (!rootBounds || !nestedBounds) throw new Error("Changes tree rows have no bounds");
-  expect(nestedBounds.x - rootBounds.x).toBe(12);
+    await tree.getByTestId("diff-folder-src-toggle").click({ button: "right" });
+    await page.getByTestId("diff-folder-src-collapse-folder").click();
+    await expect(tree.getByTestId("diff-folder-src/zz-folder")).toHaveCount(0);

-  await tree.getByTestId("diff-folder-src-toggle").click({ button: "right" });
-  await page.getByTestId("diff-folder-src-collapse-folder").click();
-  await expect(tree.getByTestId("diff-folder-src/zz-folder")).toHaveCount(0);
+    await tree.getByTestId("diff-folder-src-toggle").click();
+    await expect(tree.getByTestId("diff-folder-src/zz-folder")).toBeVisible();
+    await expect(tree.getByText("root.ts", { exact: true })).toHaveCount(0);

-  await tree.getByTestId("diff-folder-src-toggle").click();
-  await expect(tree.getByTestId("diff-folder-src/zz-folder")).toBeVisible();
-  await expect(tree.getByText("root.ts", { exact: true })).toHaveCount(0);
+    await tree.getByTestId("diff-folder-src/zz-folder-toggle").click();
+    await expect(tree.getByText("root.ts", { exact: true })).toBeVisible();
+    await expect(tree.getByTestId("diff-folder-src/zz-folder/nested")).toBeVisible();
+    await expect(tree.getByText("changed.ts", { exact: true })).toHaveCount(0);

-  await tree.getByTestId("diff-folder-src/zz-folder-toggle").click();
-  await expect(tree.getByText("root.ts", { exact: true })).toBeVisible();
-  await expect(tree.getByTestId("diff-folder-src/zz-folder/nested")).toBeVisible();
-  await expect(tree.getByText("changed.ts", { exact: true })).toHaveCount(0);
-
-  await tree.getByTestId("diff-folder-src/zz-folder/nested-toggle").click();
-  await expect(tree.getByText("changed.ts", { exact: true })).toBeVisible();
+    await tree.getByTestId("diff-folder-src/zz-folder/nested-toggle").click();
+    await expect(tree.getByText("changed.ts", { exact: true })).toBeVisible();
+  });
 });

 test("changes context menus expose folder revert and restore a file after confirmation", async ({
@@ -761,70 +661,25 @@ test("shows a revert error returned by the daemon", async ({ page }) => {
    .toBe(AFTER);
 });

-test("Changes keeps review navigation and controls inside its workspace tab", async ({ page }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff({ includeDeletedFile: true });
+test("inspect, review, open, and duplicate changed files in the workspace", async ({ page }) => {
+  const workspace = await createWorkspaceWithMountedTabDiff({
+    includeDeletedFile: true,
+    includeUntrackedFile: true,
+  });
  await useUnwrappedDiffLines(page);
  await openWorkspaceChanges(page, workspace);
-
-  const visiblePanel = page.getByTestId("working-diff-panel").filter({ visible: true });
-  await expect(visiblePanel).toBeVisible();
-  await expect(visiblePanel.getByTestId("changes-repository-header")).toHaveCount(0);
-  await expect(visiblePanel.getByTestId("changes-branch-switcher")).toHaveCount(0);
-  await expect(visiblePanel.getByTestId("changes-diff-status-trigger")).toHaveCount(0);
-  await expect(visiblePanel.getByTestId("changes-selected-diff-stat")).toHaveCount(0);
-  await expect(visiblePanel.getByTestId("changes-header")).toHaveCount(1);
-  await expect(diffHeaderForPath(visiblePanel, "src/use-mounted-tab-set.ts")).toHaveAccessibleName(
-    "src/use-mounted-tab-set.ts, +37, -1",
-  );
-  await expect(diffHeaderForPath(visiblePanel, "src/zz-deleted.ts")).toHaveAccessibleName(
-    "src/zz-deleted.ts, +0, -1",
-  );
-  await expect(visiblePanel.getByTestId("changes-primary-cta")).toHaveCount(0);
-  await expect(page.getByTestId("changes-primary-cta")).toHaveCount(1);
-  await expect(page.getByTestId("changes-primary-cta")).toContainText("Commit");
-  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
-  await visiblePanel.getByTestId("diff-file-0-toggle").click();
-  await expect(visiblePanel.getByTestId("diff-file-0-body")).not.toBeVisible();
-
-  await expect(visiblePanel.getByRole("button", { name: "Diff options" })).toHaveCount(0);
-  await expect(page.getByTestId("changes-open-tab")).toHaveCount(0);
-  const collapseFiles = visiblePanel.getByTestId("changes-toggle-collapse-all");
-  await expect(collapseFiles).toHaveAttribute("aria-label", "Collapse all files");
-  await collapseFiles.click();
-  await expect(collapseFiles).toHaveAttribute("aria-label", "Expand all files");
-  await collapseFiles.click();
-  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
-
-  const layout = visiblePanel.getByTestId("changes-toggle-layout");
-  await expect(layout).toHaveAttribute("aria-label", "Switch to side-by-side diff");
-  await layout.click();
-  await expect(layout).toHaveAttribute("aria-label", "Switch to unified diff");
-
-  const whitespace = visiblePanel.getByTestId("changes-toggle-whitespace");
-  await expect(whitespace).toHaveAttribute("aria-label", "Hide whitespace");
-  const wrapLines = visiblePanel.getByTestId("changes-toggle-wrap-lines");
-  await expect(wrapLines).toHaveAttribute("aria-label", "Wrap long lines");
-  await expect(visiblePanel.getByTestId("changes-refresh")).toHaveAttribute(
-    "aria-label",
-    "Refresh",
-  );
-  await wrapLines.click();
-  await expect(wrapLines).toHaveAttribute("aria-label", "Scroll long lines");
-  await expect(page.getByTestId(/^workspace-working-diff-close-/)).toHaveCount(1);
-
-  await writeFile(path.join(workspace.repoPath, "src/use-mounted-tab-set.ts"), BEFORE);
-  await expect(
-    visiblePanel.locator('[data-diff-header-path="src/use-mounted-tab-set.ts"]'),
-  ).toHaveCount(0, { timeout: 30_000 });
-  await expect(visiblePanel.locator('[data-diff-header-path="src/zz-deleted.ts"]')).toBeVisible();
-  await writeFile(path.join(workspace.repoPath, "src/use-mounted-tab-set.ts"), AFTER);
-  await expect(diffHeaderForPath(visiblePanel, "src/use-mounted-tab-set.ts")).toHaveAccessibleName(
-    "src/use-mounted-tab-set.ts, +37, -1",
-    { timeout: 30_000 },
-  );
-  await expect(diffHeaderForPath(visiblePanel, "src/zz-deleted.ts")).toHaveAccessibleName(
-    "src/zz-deleted.ts, +0, -1",
-  );
+  await test.step("workspace controls update the comparison and presentation", async () => {
+    await inspectChangesWorkspaceControls(page, workspace);
+  });
+  await setOpenChangesPresentation(page, { layout: "unified", wrapLines: false });
+  await scrollDiffToTop(page);
+  await reviewChangedLine(page);
+  await scrollDiffToTop(page);
+  await inspectChangedFileHeaders(page);
+  await test.step("duplicate the file and its folder from Changes", async () => {
+    await page.getByTestId("workspace-tab-working_diff").filter({ visible: true }).click();
+    await duplicateChangedFiles(page, workspace);
+  });
 });

 test("compact Changes keeps its actions compact and menu-only", async ({ page }) => {
@@ -890,18 +745,6 @@ test("compact Changes jumps to a file from the changed-files sheet", async ({ pa
  });
 });

-test("Jump to file stays out of the desktop diff and of an empty comparison", async ({ page }) => {
-  const committed = await createWorkspaceWithCommittedDiff();
-  await openWorkspaceChangesSurface(page, committed, 90_000);
-  await expect(page.getByRole("button", { name: "Jump to file" })).toHaveCount(0);
-
-  const explorer = await openCompactChanges(page, committed);
-  await expect(explorer.getByRole("button", { name: "Jump to file" })).toBeVisible();
-
-  await selectEmptyUncommittedComparison(page, explorer);
-  await expect(page.getByRole("button", { name: "Jump to file" })).toHaveCount(0);
-});
-
 test("canvas diff stays sharp while its workspace pane is resized", async ({ page }) => {
  const workspace = await createWorkspaceWithMountedTabDiff();
  await useUnwrappedDiffLines(page);
@@ -1013,33 +856,6 @@ test("changes diff waits for configured fonts, then applies code typography chan
  expect(after.canvasPixels).not.toEqual(before.canvasPixels);
 });

-test("creates, cancels, edits, and deletes a review while keeping Changes focused", async ({
-  page,
-}) => {
-  const workspace = await createWorkspaceWithMountedTabDiff();
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-  const changesTab = page.getByTestId("workspace-tab-working_diff").filter({ visible: true });
-  const focusedBackground = await changesTab.evaluate(
-    (element) => getComputedStyle(element).backgroundColor,
-  );
-
-  await test.step("start a focused review with the browser text menu", async () => {
-    await startReviewOnFirstChangedLine(page);
-    await expect(page.getByTestId("inline-review-editor-input")).toBeFocused();
-    await expect(changesTab).toHaveCSS("background-color", focusedBackground);
-    await page.getByTestId("inline-review-editor-input").click({ button: "right" });
-    await expect(page.getByTestId("diff-source-context-menu")).toHaveCount(0);
-    await cancelInlineReview(page);
-  });
-  await test.step("save, edit, and delete the review", async () => {
-    await startReviewOnFirstChangedLine(page);
-    await saveInlineReview(page, "Please keep this branch explicit");
-    await editInlineReview(page, "Please keep this branch named explicitly");
-    await deleteInlineReview(page);
-  });
-});
-
 test("split canvas creates a review on the changed side and keeps it in that column", async ({
  page,
 }) => {
@@ -1058,21 +874,6 @@ test("split canvas creates a review on the changed side and keeps it in that col
  await cancelInlineReview(page);
 });

-test("scrolling clears the hovered review affordance", async ({ page }) => {
-  const workspace = await createWorkspaceWithMountedTabDiff();
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-
-  await hoverFirstChangedGutter(page);
-  await expect(page.getByRole("button", { name: "Add review comment" })).toBeVisible();
-  await page.getByTestId("git-diff-scroll").evaluate((element) => {
-    element.scrollTop += 80;
-    element.dispatchEvent(new Event("scroll", { bubbles: false }));
-  });
-
-  await expect(page.getByRole("button", { name: "Add review comment" })).toHaveCount(0);
-});
-
 test("canvas diff uses the overlay scrollbar and its thumb controls vertical scrolling", async ({
  page,
 }) => {
@@ -1120,33 +921,6 @@ test("canvas headers keep a many-file diff bounded while scrolling end to end",
  await expect(root.locator('[data-testid^="git-diff-sticky-header-"]')).toHaveCount(2);
 });

-test("the whole reviewable row reveals the gutter affordance and uses a text cursor", async ({
-  page,
-}) => {
-  const workspace = await createWorkspaceWithMountedTabDiff();
-  await useUnwrappedDiffLines(page);
-  await openWorkspaceChanges(page, workspace);
-
-  const body = page.getByTestId("diff-file-0-body");
-  const canvas = page.getByTestId("git-diff-canvas");
-  const [bodyBounds, fontSize] = await Promise.all([
-    body.boundingBox(),
-    canvas.evaluate((element) => Number.parseFloat(getComputedStyle(element).fontSize)),
-  ]);
-  if (!bodyBounds) throw new Error("Expanded diff body has no bounds");
-  const lineHeight = Math.round(fontSize * 1.5);
-  await page.mouse.move(bodyBounds.x + bodyBounds.width - 32, bodyBounds.y + lineHeight * 1.5);
-
-  const affordance = page.getByRole("button", { name: "Add review comment" });
-  await expect(affordance).toBeVisible();
-  await expect(affordance.locator("svg")).toBeVisible();
-  const affordanceBounds = await affordance.boundingBox();
-  expect(affordanceBounds?.width).toBeCloseTo(22, 0);
-  expect(affordanceBounds?.height).toBeCloseTo(22, 0);
-  await expect(affordance).not.toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
-  await expect(page.getByTestId("git-diff-scroll")).toHaveCSS("cursor", "text");
-});
-
 test("selects, preserves, copies, and dismisses diff text without opening a review", async ({
  page,
 }) => {
@@ -1297,23 +1071,6 @@ test("dragging within one wide grapheme or outside its cell never opens a review
  await expect(page.getByTestId("inline-review-editor")).toHaveCount(0);
 });

-test("collapsing and expanding restores the real horizontal scroll offset", async ({ page }) => {
-  const workspace = await createWorkspaceWithExactSelectionDiff("x".repeat(400));
-  await useUnwrappedDiffLines(page);
-  await openSelectionWorkspaceChanges(page, workspace);
-
-  const retainedOffset = await horizontallyScrollFirstFile(page, 320);
-  await page.getByTestId("diff-file-0-toggle").click();
-  await expect(page.getByTestId("diff-file-0-horizontal-scroll")).toHaveCount(0);
-  await page.getByTestId("diff-file-0-toggle").click();
-
-  await expect
-    .poll(() =>
-      page.getByTestId("diff-file-0-horizontal-scroll").evaluate((element) => element.scrollLeft),
-    )
-    .toBe(retainedOffset);
-});
-
 async function useCodeFont(page: Page, codeFontSize: number): Promise<void> {
  await page.addInitScript(
    ({ settingsKey, fontSize }) => {
@@ -2218,3 +1975,242 @@ async function scrollToLowerUnwrappedDiffRows(page: Page): Promise<void> {
  });
  await expect(page.getByTestId("git-diff-canvas")).toBeVisible();
 }
+
+async function readHorizontalDiffOffset(page: Page): Promise<number> {
+  return page
+    .getByTestId("diff-file-0-horizontal-scroll")
+    .evaluate((element) => element.scrollLeft);
+}
+
+async function inspectChangesWorkspaceControls(
+  page: Page,
+  workspace: DirtyWorkspace,
+): Promise<void> {
+  const visiblePanel = page.getByTestId("working-diff-panel").filter({ visible: true });
+  await expect(visiblePanel).toBeVisible();
+  await expect(visiblePanel.getByTestId("changes-repository-header")).toHaveCount(0);
+  await expect(visiblePanel.getByTestId("changes-branch-switcher")).toHaveCount(0);
+  await expect(visiblePanel.getByTestId("changes-diff-status-trigger")).toHaveCount(0);
+  await expect(visiblePanel.getByTestId("changes-selected-diff-stat")).toHaveCount(0);
+  await expect(visiblePanel.getByTestId("changes-header")).toHaveCount(1);
+  await expect(diffHeaderForPath(visiblePanel, "src/use-mounted-tab-set.ts")).toHaveAccessibleName(
+    "src/use-mounted-tab-set.ts, +37, -1",
+  );
+  await expect(diffHeaderForPath(visiblePanel, "src/zz-deleted.ts")).toHaveAccessibleName(
+    "src/zz-deleted.ts, +0, -1",
+  );
+  await expect(visiblePanel.getByTestId("changes-primary-cta")).toHaveCount(0);
+  await expect(page.getByTestId("changes-primary-cta")).toHaveCount(1);
+  await expect(page.getByTestId("changes-primary-cta")).toContainText("Commit");
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
+  await visiblePanel.getByTestId("diff-file-0-toggle").click();
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).not.toBeVisible();
+
+  await expect(visiblePanel.getByRole("button", { name: "Diff options" })).toHaveCount(0);
+  await expect(page.getByTestId("changes-open-tab")).toHaveCount(0);
+  const collapseFiles = visiblePanel.getByTestId("changes-toggle-collapse-all");
+  await expect(collapseFiles).toHaveAttribute("aria-label", "Collapse all files");
+  await collapseFiles.click();
+  await expect(collapseFiles).toHaveAttribute("aria-label", "Expand all files");
+  await collapseFiles.click();
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
+
+  const layout = visiblePanel.getByTestId("changes-toggle-layout");
+  await expect(layout).toHaveAttribute("aria-label", "Switch to side-by-side diff");
+  await layout.click();
+  await expect(layout).toHaveAttribute("aria-label", "Switch to unified diff");
+
+  const whitespace = visiblePanel.getByTestId("changes-toggle-whitespace");
+  await expect(whitespace).toHaveAttribute("aria-label", "Hide whitespace");
+  const wrapLines = visiblePanel.getByTestId("changes-toggle-wrap-lines");
+  await expect(wrapLines).toHaveAttribute("aria-label", "Wrap long lines");
+  await expect(visiblePanel.getByTestId("changes-refresh")).toHaveAttribute(
+    "aria-label",
+    "Refresh",
+  );
+  await wrapLines.click();
+  await expect(wrapLines).toHaveAttribute("aria-label", "Scroll long lines");
+  await expect(page.getByTestId(/^workspace-working-diff-close-/)).toHaveCount(1);
+
+  await writeFile(path.join(workspace.repoPath, "src/use-mounted-tab-set.ts"), BEFORE);
+  await expect(
+    visiblePanel.locator('[data-diff-header-path="src/use-mounted-tab-set.ts"]'),
+  ).toHaveCount(0, { timeout: 30_000 });
+  await expect(visiblePanel.locator('[data-diff-header-path="src/zz-deleted.ts"]')).toBeVisible();
+  await writeFile(path.join(workspace.repoPath, "src/use-mounted-tab-set.ts"), AFTER);
+  await expect(diffHeaderForPath(visiblePanel, "src/use-mounted-tab-set.ts")).toHaveAccessibleName(
+    "src/use-mounted-tab-set.ts, +37, -1",
+    { timeout: 30_000 },
+  );
+  await expect(diffHeaderForPath(visiblePanel, "src/zz-deleted.ts")).toHaveAccessibleName(
+    "src/zz-deleted.ts, +0, -1",
+  );
+}
+
+async function reviewChangedLine(page: Page): Promise<void> {
+  await test.step("the whole reviewable row reveals the gutter affordance and uses a text cursor", async () => {
+    const body = page.getByTestId("diff-file-0-body");
+    const canvas = page.getByTestId("git-diff-canvas");
+    const [bodyBounds, fontSize] = await Promise.all([
+      body.boundingBox(),
+      canvas.evaluate((element) => Number.parseFloat(getComputedStyle(element).fontSize)),
+    ]);
+    if (!bodyBounds) throw new Error("Expanded diff body has no bounds");
+    const lineHeight = Math.round(fontSize * 1.5);
+    await page.mouse.move(bodyBounds.x + bodyBounds.width - 32, bodyBounds.y + lineHeight * 1.5);
+
+    const affordance = page.getByRole("button", { name: "Add review comment" });
+    await expect(affordance).toBeVisible();
+    await expect(affordance.locator("svg")).toBeVisible();
+    const affordanceBounds = await affordance.boundingBox();
+    expect(affordanceBounds?.width).toBeCloseTo(22, 0);
+    expect(affordanceBounds?.height).toBeCloseTo(22, 0);
+    await expect(affordance).not.toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
+    await expect(page.getByTestId("git-diff-scroll")).toHaveCSS("cursor", "text");
+  });
+
+  await test.step("creates, cancels, edits, and deletes a review while keeping Changes focused", async () => {
+    const changesTab = page.getByTestId("workspace-tab-working_diff").filter({ visible: true });
+    const focusedBackground = await changesTab.evaluate(
+      (element) => getComputedStyle(element).backgroundColor,
+    );
+
+    await test.step("start a focused review with the browser text menu", async () => {
+      await startReviewOnFirstChangedLine(page);
+      await expect(page.getByTestId("inline-review-editor-input")).toBeFocused();
+      await expect(changesTab).toHaveCSS("background-color", focusedBackground);
+      await page.getByTestId("inline-review-editor-input").click({ button: "right" });
+      await expect(page.getByTestId("diff-source-context-menu")).toHaveCount(0);
+      await cancelInlineReview(page);
+    });
+    await test.step("save, edit, and delete the review", async () => {
+      await startReviewOnFirstChangedLine(page);
+      await saveInlineReview(page, "Please keep this branch explicit");
+      await editInlineReview(page, "Please keep this branch named explicitly");
+      await deleteInlineReview(page);
+    });
+  });
+
+  await test.step("scrolling clears the hovered review affordance", async () => {
+    await hoverFirstChangedGutter(page);
+    await expect(page.getByRole("button", { name: "Add review comment" })).toBeVisible();
+    await page.getByTestId("git-diff-scroll").evaluate((element) => {
+      element.scrollTop += 80;
+      element.dispatchEvent(new Event("scroll", { bubbles: false }));
+    });
+
+    await expect(page.getByRole("button", { name: "Add review comment" })).toHaveCount(0);
+  });
+}
+
+async function inspectChangedFileHeaders(page: Page): Promise<void> {
+  await test.step("file statuses follow their diff stats", async () => {
+    const tree = changesTree(page);
+    const modifiedRow = tree.getByTestId("diff-tree-file-0");
+    const deletedRow = tree.getByTestId("diff-tree-file-1");
+    const addedRow = tree.getByTestId("diff-tree-file-2");
+    const modifiedStatus = modifiedRow.getByRole("img", { name: "Modified" });
+    await expect(modifiedStatus).toBeVisible();
+    await expect(deletedRow.getByRole("img", { name: "Deleted" })).toBeVisible();
+    await expect(addedRow.getByRole("img", { name: "New" })).toBeVisible();
+
+    const [statBounds, statusBounds] = await Promise.all([
+      modifiedRow.getByTestId("diff-tree-file-0-stat").boundingBox(),
+      modifiedStatus.boundingBox(),
+    ]);
+    if (!statBounds || !statusBounds) throw new Error("Changes tree trailing status has no bounds");
+    expect(statusBounds.x - (statBounds.x + statBounds.width)).toBeGreaterThanOrEqual(8);
+  });
+
+  await test.step("every interactive file header has the same hover feedback", async () => {
+    const first = page.getByTestId("diff-file-0-toggle");
+    const second = page.getByTestId("diff-file-1-toggle");
+    const firstCanvas = page.getByTestId("git-diff-sticky-header-0");
+    const secondCanvas = page.getByTestId("git-diff-sticky-header-1");
+    const normalBackground = await headerCanvasPixel(firstCanvas, first, 10);
+
+    await first.hover();
+    await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).not.toBe(normalBackground);
+    const hoverBackground = await headerCanvasPixel(firstCanvas, first, 10);
+
+    await first.click();
+    await page.mouse.move(0, 0);
+    await expect(first).toHaveAttribute("aria-expanded", "false");
+    await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).toBe(normalBackground);
+
+    await first.hover();
+    await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).toBe(hoverBackground);
+    await second.hover();
+    await expect.poll(() => headerCanvasPixel(firstCanvas, first, 10)).toBe(normalBackground);
+    await expect.poll(() => headerCanvasPixel(secondCanvas, second, 10)).toBe(hoverBackground);
+    await first.click();
+    await page.mouse.move(0, 0);
+    await expect(first).toHaveAttribute("aria-expanded", "true");
+  });
+
+  await test.step("canvas file headers select without toggling for context menu and long press", async () => {
+    const firstFile = page.getByTestId("diff-file-0-toggle");
+    const deletedFile = page.getByTestId("diff-file-1-toggle");
+    await deletedFile.click({ button: "right" });
+    await expect(deletedFile).toHaveAttribute("aria-selected", "true");
+    await expect(deletedFile).toHaveAttribute("aria-expanded", "true");
+    await expect(page.getByText("Copy path")).toBeVisible();
+    await page.keyboard.press("Escape");
+
+    await longPressFileHeader(page, firstFile);
+    await expect(firstFile).toHaveAttribute("aria-selected", "true");
+    await expect(deletedFile).toHaveAttribute("aria-selected", "false");
+    await expect(firstFile).toHaveAttribute("aria-expanded", "true");
+  });
+
+  await test.step("changes file actions open below the right-click without a reserved kebab", async () => {
+    const deletedFileName = page.getByTestId("diff-file-1");
+    await expect(deletedFileName).toHaveAccessibleName(/zz-deleted\.ts/);
+    await deletedFileName.dblclick();
+    expect(await page.evaluate(() => window.getSelection()?.toString() ?? "")).toBe("");
+    await expect(page.getByTestId(/diff-file-\d+-actions/)).toHaveCount(0);
+    await page.getByTestId("diff-file-1-toggle").click({ button: "right" });
+    await expect(page.getByText("Copy path")).toBeVisible();
+    await page.getByText("Copy path", { exact: true }).click({ button: "right" });
+    await expect(page.getByText("Copy path")).toBeVisible();
+    await expect(page.getByTestId("diff-file-1-open-file")).toHaveCount(0);
+    await page.keyboard.press("Escape");
+
+    const fileRow = page.getByTestId("diff-file-0-toggle");
+    const fileRowBounds = await fileRow.boundingBox();
+    expect(fileRowBounds).not.toBeNull();
+    await fileRow.click({ button: "right", position: { x: 80, y: 10 } });
+    await expect(page.getByTestId("diff-file-0-open-file")).toBeVisible();
+    const menuBounds = await page.getByTestId("diff-file-0-context-menu").boundingBox();
+    expect(menuBounds).not.toBeNull();
+    expect(Math.abs(menuBounds!.x - (fileRowBounds!.x + 80))).toBeLessThanOrEqual(1);
+    expect(menuBounds!.y).toBeGreaterThan(fileRowBounds!.y + 10);
+    await page.getByTestId("diff-file-0-open-file").click();
+
+    await expect(page.getByTestId("workspace-file-pane")).toBeVisible();
+    await expect(page.getByTestId("workspace-tab-file_src/use-mounted-tab-set.ts")).toBeVisible();
+  });
+}
+
+async function duplicateChangedFiles(page: Page, workspace: DirtyWorkspace): Promise<void> {
+  await page.getByTestId("diff-file-0-toggle").click({ button: "right" });
+  await page.getByTestId("diff-file-0-duplicate").click();
+  await expect
+    .poll(() => readFileIfPresent(path.join(workspace.repoPath, "src/use-mounted-tab-set copy.ts")))
+    .toBe(AFTER);
+
+  await changesTree(page).getByTestId("diff-folder-src-toggle").click({ button: "right" });
+  await page.getByTestId("diff-folder-src-duplicate").click();
+  await expect
+    .poll(() => readFileIfPresent(path.join(workspace.repoPath, "src copy/use-mounted-tab-set.ts")))
+    .toBe(AFTER);
+}
+
+async function scrollDiffToTop(page: Page): Promise<void> {
+  const scroll = page.getByTestId("git-diff-scroll");
+  await scroll.evaluate((element) => {
+    element.scrollTop = 0;
+    element.dispatchEvent(new Event("scroll", { bubbles: false }));
+  });
+  await expect.poll(() => scroll.evaluate((element) => element.scrollTop)).toBe(0);
+}
@@ -11,6 +11,8 @@ import {
  expectReconnectingToastVisible,
 } from "../support/helpers/workspace-ui";
 import { trackPromptJumpRequests } from "../support/helpers/agent-timeline-gate";
+import { seedWorkspace } from "../support/helpers/seed-client";
+import { createControlledStream } from "../support/helpers/controlled-stream";
 import {
  composerLocator,
  fillComposerDraft,
@@ -24,11 +26,13 @@ const MAC_USER_AGENT =
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";

 const FILLER = Array.from({ length: 400 }, (_, index) => `filler${index}`).join(" ");
-const STREAMED_RESPONSE = [
+const STREAMED_TAIL = "STREAMED-REPLY-FINAL-TAIL";
+const HYDRATED_PARTIAL = "Hydrated partial continuation";
+const STREAMED_PREFIX = [
  "First paragraph with alpha-needle and pair-needle inside.",
  "Second paragraph with beta-needle and pair-needle inside.",
  `Third paragraph ${FILLER}`,
-].join("\n\n");
+].map((paragraph) => `${paragraph}\n\n`);

 const RESPONSE =
  'İ😀hello **world**; hello *world*.\n\n[hello &amp; world](https://example.com/hidden-destination)\n\n```ts\nconst a = "a.b";\n```\n\n- first cell\n- second cell';
@@ -282,50 +286,90 @@ test("shows a disconnected search failure and recovers with Retry", async ({ pag
  }
 });

-interface StreamedReplyChat extends MockAgentWorkspace {
-  /** Resolves once the streamed reply has finished arriving. */
+interface StreamedReplyChat {
+  cleanup(): Promise<void>;
+  advancePastVisiblePrefix(): Promise<void>;
+  expectHydratedPartial(): Promise<void>;
  replyFinished(): Promise<void>;
 }

-/**
- * Opens the chat first, then streams a multi-block reply into it and waits for a
- * later block, so the block holding the early needles is no longer the growing row.
- */
+/** The provider owns the pause, so both search and hydration see incomplete output. */
 async function openChatStreamingMultiBlockReply(page: Page): Promise<StreamedReplyChat> {
-  const agent = await seedMockAgentWorkspace({
-    repoPrefix: "chat-find-live-blocks-",
-    title: "Chat Find live blocks",
-    featureValues: {
-      mockStreamingAssistantResponse: STREAMED_RESPONSE,
-      mockStreamingAssistantIntervalMs: 60,
+  const stream = await createControlledStream();
+  const workspace = await seedWorkspace({ repoPrefix: "chat-find-live-blocks-" }).catch(
+    async (error) => {
+      await stream.cleanup();
+      throw error;
    },
-  });
+  );
+  const gate = await installDaemonWebSocketGate(page);
+  const cleanup = async () => {
+    try {
+      await stream.cleanup();
+    } finally {
+      await workspace.cleanup();
+    }
+  };
  try {
-    await openAgentRoute(page, agent);
-    await agent.client.sendAgentMessage(agent.agentId, "Stream a multi block answer");
-    await expect(page.getByText("beta-needle", { exact: false }).last()).toBeVisible({
-      timeout: 30_000,
+    const agent = await workspace.client.createAgent({
+      provider: stream.provider,
+      cwd: workspace.repoPath,
+      workspaceId: workspace.workspaceId,
+      title: "Chat Find live blocks",
    });
+    await openAgentRoute(page, { workspaceId: workspace.workspaceId, agentId: agent.id });
+    await workspace.client.sendAgentMessage(agent.id, "Stream a multi block answer");
+    await stream.append(STREAMED_PREFIX);
+    await expect(page.getByText("beta-needle", { exact: false }).last()).toBeVisible();
    return {
-      ...agent,
+      cleanup,
+      advancePastVisiblePrefix: async () => {
+        const count = gate.getAgentStreamItemCount("assistant_message");
+        gate.setAgentStreamSuppressed(true);
+        await stream.append([HYDRATED_PARTIAL]);
+        await gate.waitForAgentStreamItem("assistant_message", count + 1);
+        await expect(page.getByTestId("assistant-message").last()).not.toContainText(
+          HYDRATED_PARTIAL,
+        );
+      },
+      expectHydratedPartial: async () => {
+        // A newer daemon row forces Find to fetch the real timeline instead of
+        // matching only the browser's streamed prefix.
+        await expect(page.getByTestId("assistant-message").last()).toContainText(HYDRATED_PARTIAL);
+        expect(gate.getTimelineRequestCount("before", agent.id)).toBeGreaterThan(0);
+      },
      replyFinished: async () => {
-        await agent.client.waitForFinish(agent.agentId, 60_000);
+        gate.setAgentStreamSuppressed(false);
+        await stream.finish([`\n\n${STREAMED_TAIL}`]);
+        await workspace.client.waitForFinish(agent.id, 15_000);
      },
    };
  } catch (error) {
-    await agent.cleanup();
+    await cleanup();
    throw error;
  }
 }

+async function expectIncompleteStreamedReply(page: Page): Promise<void> {
+  await expect(page.getByTestId("assistant-message").last()).toContainText("beta-needle");
+  await expect(page.getByTestId("assistant-message").last()).toContainText("filler399");
+  await expect(page.getByTestId("assistant-message").last()).not.toContainText(STREAMED_TAIL);
+  await expect(page.getByRole("button", { name: "Stop agent", exact: true })).toBeVisible();
+}
+
 test("finds a hit in a message that streamed while the chat was open", async ({ page }) => {
  test.setTimeout(120_000);
  const chat = await openChatStreamingMultiBlockReply(page);
  try {
+    await expectIncompleteStreamedReply(page);
+    await chat.advancePastVisiblePrefix();
    await openChatFind(page);
    // The first-paragraph hit must remain searchable while the same message grows.
    await expectFindStatus(page, "alpha-needle", "1 of 1");
+    await chat.expectHydratedPartial();
+    await expectIncompleteStreamedReply(page);
    await chat.replyFinished();
+    await expect(page.getByTestId("assistant-message").last()).toContainText(STREAMED_TAIL);
    await expectFindStatus(page, "beta-needle", "1 of 1");
    // One message, two paragraphs, one count across both.
    await expectFindStatus(page, "pair-needle", "1 of 2");
@@ -1,4 +1,4 @@
-import { expect, test } from "../support/fixtures";
+import { expect, test, type Page } from "../support/fixtures";
 import { trackPromptJumpRequests } from "../support/helpers/agent-timeline-gate";
 import {
  clickChatOutlineRowEdge,
@@ -50,6 +50,43 @@ import {
 const WIDE_VIEWPORT = { width: 1440, height: 900 };
 const LOADED_TURNS = 16;

+async function navigateLoadedOutline(page: Page, agent: LongTimelineAgent): Promise<void> {
+  await test.step("preview across the row", async () => {
+    await expectOneActiveChatOutlinePrompt(page);
+    await hoverChatOutlinePrompt(page, 2);
+    await expectChatOutlinePreview(page, agent.prompts[1]);
+
+    await pointAtChatOutlineRowEdge(page, 7);
+    await expectChatOutlinePreview(page, agent.prompts[6]);
+
+    await movePointerOffChatOutline(page);
+    await expectNoChatOutlinePreview(page);
+  });
+  await test.step("jump, dismiss preview, and retain bare selection", async () => {
+    await clickChatOutlineRowEdge(page, 4);
+    await expectChatOutlinePromptToRemainBare(page, 4);
+    await expectTimelinePromptLandedBelowTop(page, agent.prompts[3]);
+    await expectActiveChatOutlinePrompt(page, 4);
+    await movePointerOffChatOutline(page);
+    await expectNoChatOutlinePreview(page);
+  });
+  await test.step("track the active prompt while jumping and scrolling", async () => {
+    await expectOneActiveChatOutlinePrompt(page);
+    await scrollTimelineToNewestLoadedEdge(page);
+    await expectTimelinePromptVisible(page, agent.newestPrompt);
+    await expectActiveChatOutlinePromptMovedFrom(page, 4);
+  });
+  await test.step("clamp the newest prompt at maximum scroll", async () => {
+    await clickChatOutlineRowEdge(page, LOADED_TURNS);
+    await expectTimelineAtMaximumScrollWithPromptVisible(page, agent.newestPrompt);
+  });
+}
+
+async function jumpToNewerLoadedPrompt(page: Page, agent: LongTimelineAgent): Promise<void> {
+  await clickChatOutlineRowEdge(page, 60);
+  await expectTimelinePromptLandedBelowTop(page, agent.prompts[59]);
+}
+
 test.describe("desktop chat outline", () => {
  test("keeps the prompt marked while reading split Markdown blocks and after completion", async ({
    page,
@@ -183,28 +220,14 @@ test.describe("desktop chat outline", () => {
      await expectChatOutlinePrompts(page, LOADED_TURNS);
    });

-    test("previews the prompt under the pointer, anywhere across its row", async ({ page }) => {
-      await hoverChatOutlinePrompt(page, 2);
-      await expectChatOutlinePreview(page, agent.prompts[1]);
-
-      await pointAtChatOutlineRowEdge(page, 7);
-      await expectChatOutlinePreview(page, agent.prompts[6]);
-
-      await movePointerOffChatOutline(page);
-      await expectNoChatOutlinePreview(page);
+    test("previews, jumps, and tracks the reader through loaded prompts", async ({ page }) => {
+      await navigateLoadedOutline(page, agent);
    });

    test("does not preview while crossing the rail toward the sidebar", async ({ page }) => {
      await expectNoChatOutlinePreviewWhileCrossingToSidebar(page);
    });

-    test("closes the preview when the pointer leaves after a jump", async ({ page }) => {
-      await clickChatOutlineRowEdge(page, 4);
-      await movePointerOffChatOutline(page);
-
-      await expectNoChatOutlinePreview(page);
-    });
-
    test("previews and jumps to the focused prompt from the keyboard", async ({ page }) => {
      await focusChatOutlinePrompt(page, 1);
      await expectChatOutlinePreview(page, agent.prompts[0]);
@@ -215,32 +238,6 @@ test.describe("desktop chat outline", () => {
      await expectActiveChatOutlinePrompt(page, 1);
    });

-    test("moves the active mark as the reader jumps and scrolls", async ({ page }) => {
-      await expectOneActiveChatOutlinePrompt(page);
-
-      await clickChatOutlineRowEdge(page, 4);
-      await expectTimelinePromptLandedBelowTop(page, agent.prompts[3]);
-      await expectActiveChatOutlinePrompt(page, 4);
-
-      await scrollTimelineToNewestLoadedEdge(page);
-      await expectTimelinePromptVisible(page, agent.newestPrompt);
-      await expectActiveChatOutlinePromptMovedFrom(page, 4);
-    });
-
-    test("keeps a clicked prompt free of persistent selection chrome", async ({ page }) => {
-      await clickChatOutlineRowEdge(page, 4);
-
-      await expectChatOutlinePromptToRemainBare(page, 4);
-    });
-
-    test("clamps the newest prompt at maximum scroll while keeping it visible", async ({
-      page,
-    }) => {
-      await clickChatOutlineRowEdge(page, LOADED_TURNS);
-
-      await expectTimelineAtMaximumScrollWithPromptVisible(page, agent.newestPrompt);
-    });
-
    test("keeps the current prompt active throughout a long live assistant turn", async ({
      page,
    }) => {
@@ -282,21 +279,11 @@ test.describe("desktop chat outline", () => {
      await expectTimelinePromptLandedBelowTop(page, agent.prompts[29]);

      expect(history.requestCount()).toBe(requestsBeforeJump);
-    });

-    test("pins a newer loaded prompt when jumping downward from old history", async ({ page }) => {
-      const history = await holdOlderHistoryPages(page, agent);
-      await openAgentTimeline(page, agent);
-      await expectChatOutlinePrompts(page, 80);
-      await scrollThroughOlderHistoryPages(page, 2, history);
-      await scrollTimelineToNewestLoadedEdge(page);
-
-      await clickChatOutlineRowEdge(page, 30);
-      await expectTimelinePromptLandedBelowTop(page, agent.prompts[29]);
-
-      await clickChatOutlineRowEdge(page, 60);
-
-      await expectTimelinePromptLandedBelowTop(page, agent.prompts[59]);
+      await test.step(
+        "jump downward from old history to a newer loaded prompt",
+        jumpToNewerLoadedPrompt.bind(null, page, agent),
+      );
    });
  });

@@ -4,7 +4,6 @@ import { closeCommandCenter, openCommandCenter } from "../support/helpers/comman
 import {
  applyCommandCenterAgentControls,
  chooseCommandCenterAgentControl,
-  openCommandCenterForAgent,
  expectCommandCenterAgentControlSelected,
  expectFocusedAgentControls,
  expectWorkspaceAgentConfiguration,
@@ -42,37 +41,93 @@ async function seedMockDraftPreferences(page: import("@playwright/test").Page):
 test.describe("Command Center agent controls", () => {
  test.describe.configure({ timeout: 180_000 });

-  test("changes a running agent setting and preserves its selected row", async ({ page }) => {
+  test("search, select, and re-rank live agent controls before navigating to an action", async ({
+    page,
+  }) => {
    const workspace = await seedMockAgentWorkspace({
      repoPrefix: "command-center-live-controls-",
      title: "Command Center live controls",
      model: "five-minute-stream",
    });
    try {
-      // A stale runtime mode makes selecting the provider's supported mode
-      // exercise the live setting RPC instead of the selected-row no-op.
      await workspace.client.setAgentMode(workspace.agentId, "legacy-mode");
-      await openAgentRoute(page, {
-        workspaceId: workspace.workspaceId,
-        agentId: workspace.agentId,
+      await openAgentRoute(page, workspace);
+      await test.step("changes a running agent setting and preserves its selected row", async () => {
+        await openCommandCenter(page);
+        await chooseCommandCenterAgentControl({
+          page,
+          query: "load test",
+          choice: "Mode › Load test",
+        });
+        await expectWorkspaceAgentConfiguration(workspace, {
+          id: workspace.agentId,
+          provider: "mock",
+          model: "five-minute-stream",
+          modeId: "load-test",
+        });
+        await openCommandCenter(page);
+        await expectCommandCenterAgentControlSelected({
+          page,
+          query: "load test",
+          choice: "Mode › Load test",
+        });
+
+        await closeCommandCenter(page);
      });
-      await openCommandCenter(page);
-      await chooseCommandCenterAgentControl({
-        page,
-        query: "load test",
-        choice: "Mode › Load test",
+      await test.step("matches query tokens in any order", async () => {
+        await workspace.client.setAgentMode(workspace.agentId, "legacy-mode");
+        await openCommandCenter(page);
+        await chooseCommandCenterAgentControl({
+          page,
+          query: "test load",
+          choice: "Mode › Load test",
+        });
+
+        await expectWorkspaceAgentConfiguration(workspace, {
+          id: workspace.agentId,
+          provider: "mock",
+          model: "five-minute-stream",
+          modeId: "load-test",
+        });
      });
-      await expectWorkspaceAgentConfiguration(workspace, {
-        id: workspace.agentId,
-        provider: "mock",
-        model: "five-minute-stream",
-        modeId: "load-test",
+      await test.step("activates the best-matching row, not the highest-ranked group", async () => {
+        await workspace.client.setAgentMode(workspace.agentId, "approval-test");
+        const panel = await openCommandCenter(page);
+        const input = panel.getByTestId("command-center-input");
+        await input.fill("load");
+        await page.keyboard.press("Enter");
+
+        await expectWorkspaceAgentConfiguration(workspace, {
+          id: workspace.agentId,
+          provider: "mock",
+          model: "five-minute-stream",
+          modeId: "load-test",
+        });
      });
-      await openCommandCenter(page);
-      await expectCommandCenterAgentControlSelected({
-        page,
-        query: "load test",
-        choice: "Mode › Load test",
+      await test.step("drops an arrow-key selection once the query changes", async () => {
+        await workspace.client.setAgentMode(workspace.agentId, "approval-test");
+        const panel = await openCommandCenter(page);
+        const input = panel.getByTestId("command-center-input");
+        await input.fill("loa");
+        // Moves the highlight onto a model row, which still matches after the next keystroke.
+        await page.keyboard.press("ArrowDown");
+        await input.fill("load");
+        await page.keyboard.press("Enter");
+
+        await expectWorkspaceAgentConfiguration(workspace, {
+          id: workspace.agentId,
+          provider: "mock",
+          model: "five-minute-stream",
+          modeId: "load-test",
+        });
+      });
+      await test.step("keeps an action first when the action is the best match", async () => {
+        const panel = await openCommandCenter(page);
+        const input = panel.getByTestId("command-center-input");
+        await input.fill("sched");
+        await page.keyboard.press("Enter");
+
+        await expectAppRoute(page, buildSchedulesRoute(), { timeout: 30_000 });
      });
    } finally {
      await workspace.cleanup();
@@ -100,107 +155,6 @@ test.describe("Command Center agent controls", () => {
    }
  });

-  test("activates the best-matching row, not the highest-ranked group", async ({ page }) => {
-    // "Mode › Load Test" matches "load" at offset 0; every "Model › Mock Load Test › …" row
-    // matches at offset 5. Models used to outrank modes by fixed group rank, so Enter picked a
-    // model. Asserting both model and mode catches either row winning.
-    const workspace = await seedMockAgentWorkspace({
-      repoPrefix: "command-center-relevance-",
-      title: "Command Center relevance",
-      model: "five-minute-stream",
-    });
-    try {
-      await workspace.client.setAgentMode(workspace.agentId, "approval-test");
-      const input = await openCommandCenterForAgent(page, workspace);
-      await input.fill("load");
-      await page.keyboard.press("Enter");
-
-      await expectWorkspaceAgentConfiguration(workspace, {
-        id: workspace.agentId,
-        provider: "mock",
-        model: "five-minute-stream",
-        modeId: "load-test",
-      });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("matches query tokens in any order", async ({ page }) => {
-    // "Mode › Load test" flattens to "mode load test", so the reversed query "test load" is never
-    // a substring of it. Only per-token matching finds this row.
-    const workspace = await seedMockAgentWorkspace({
-      repoPrefix: "command-center-tokenized-",
-      title: "Command Center tokenized search",
-      model: "five-minute-stream",
-    });
-    try {
-      await workspace.client.setAgentMode(workspace.agentId, "legacy-mode");
-      await openAgentRoute(page, {
-        workspaceId: workspace.workspaceId,
-        agentId: workspace.agentId,
-      });
-      await openCommandCenter(page);
-      await chooseCommandCenterAgentControl({
-        page,
-        query: "test load",
-        choice: "Mode › Load test",
-      });
-
-      await expectWorkspaceAgentConfiguration(workspace, {
-        id: workspace.agentId,
-        provider: "mock",
-        model: "five-minute-stream",
-        modeId: "load-test",
-      });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("keeps an action first when the action is the best match", async ({ page }) => {
-    const workspace = await seedMockAgentWorkspace({
-      repoPrefix: "command-center-action-priority-",
-      title: "Command Center action priority",
-      model: "five-minute-stream",
-    });
-    try {
-      const input = await openCommandCenterForAgent(page, workspace);
-      await input.fill("sched");
-      await page.keyboard.press("Enter");
-
-      await expectAppRoute(page, buildSchedulesRoute(), { timeout: 30_000 });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("drops an arrow-key selection once the query changes", async ({ page }) => {
-    const workspace = await seedMockAgentWorkspace({
-      repoPrefix: "command-center-active-reset-",
-      title: "Command Center active reset",
-      model: "five-minute-stream",
-    });
-    try {
-      await workspace.client.setAgentMode(workspace.agentId, "approval-test");
-      const input = await openCommandCenterForAgent(page, workspace);
-      await input.fill("loa");
-      // Moves the highlight onto a model row, which still matches after the next keystroke.
-      await page.keyboard.press("ArrowDown");
-      await input.fill("load");
-      await page.keyboard.press("Enter");
-
-      await expectWorkspaceAgentConfiguration(workspace, {
-        id: workspace.agentId,
-        provider: "mock",
-        model: "five-minute-stream",
-        modeId: "load-test",
-      });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
  test("applies draft model and setting choices to the created agent", async ({ page }) => {
    const workspace = await seedWorkspace({ repoPrefix: "command-center-draft-controls-" });
    await seedMockDraftPreferences(page);
@@ -82,31 +82,20 @@ test("workspace file search stays geometrically stable through delayed loading a

    await row.click();
    await expectFileTabOpen(page, FILE_PATH);
-  } finally {
-    await seeded.cleanup();
-  }
-});
+    await test.step("dropping the files scope leaves the search row the same height", async () => {
+      await page.keyboard.press("Meta+P");

-test("dropping the files scope leaves the search row the same height", async ({ page }) => {
-  const seeded = await seedWorkspace({
-    repoPrefix: "command-center-file-search-scope-",
-    title: "Scope chip height",
-  });
+      const reopenedPanel = page.getByTestId("command-center-panel");
+      await expect(reopenedPanel).toBeVisible({ timeout: 30_000 });
+      const header = reopenedPanel.getByTestId("command-center-header");
+      const scoped = await header.boundingBox();

-  try {
-    await gotoWorkspace(page, seeded.workspaceId);
-    await page.keyboard.press("Meta+P");
+      await page.getByTestId("command-center-files-scope").click();
+      await expect(page.getByTestId("command-center-files-scope")).toHaveCount(0);
+      const unscoped = await header.boundingBox();

-    const panel = page.getByTestId("command-center-panel");
-    await expect(panel).toBeVisible({ timeout: 30_000 });
-    const header = panel.getByTestId("command-center-header");
-    const scoped = await header.boundingBox();
-
-    await page.getByTestId("command-center-files-scope").click();
-    await expect(page.getByTestId("command-center-files-scope")).toHaveCount(0);
-    const unscoped = await header.boundingBox();
-
-    expect(scoped?.height).toBe(unscoped?.height);
+      expect(scoped?.height).toBe(unscoped?.height);
+    });
  } finally {
    await seeded.cleanup();
  }
@@ -1,58 +0,0 @@
-import { expect, test, type Page } from "../support/fixtures";
-import { gotoAppShell } from "../support/helpers/app";
-import { openCommandCenter } from "../support/helpers/command-center";
-import { seedWorkspace } from "../support/helpers/seed-client";
-
-const GROUP_BY_STATUS = "Group by status";
-const GROUP_BY_PROJECT = "Group by project";
-
-// Result rows carry no testID of their own, so the entries are addressed by their visible label.
-async function runGroupingEntry(page: Page, label: string, absent: string): Promise<void> {
-  const panel = await openCommandCenter(page);
-  await panel.getByTestId("command-center-input").fill("group");
-
-  const entry = panel.getByText(label, { exact: true });
-  await expect(entry).toBeVisible({ timeout: 30_000 });
-  // The entry always names the mode you are not in, so its opposite must never be listed.
-  await expect(panel.getByText(absent, { exact: true })).toHaveCount(0);
-
-  await entry.click();
-  await expect(page.getByTestId("command-center-panel")).not.toBeVisible({ timeout: 30_000 });
-}
-
-test.describe("Command center sidebar grouping", () => {
-  test.describe.configure({ timeout: 120_000 });
-
-  test("flips sidebar grouping and persists the choice across a reload", async ({ page }) => {
-    const seeded = await seedWorkspace({ repoPrefix: "command-center-grouping-" });
-
-    try {
-      await gotoAppShell(page);
-      const projectList = page.getByTestId("sidebar-project-workspace-list-scroll");
-      const statusList = page.getByTestId("sidebar-status-list-scroll");
-      await expect(projectList).toBeVisible({ timeout: 30_000 });
-
-      // Query-only: the grouping entry stays out of the default empty-query list.
-      const panel = await openCommandCenter(page);
-      await expect(panel.getByText(GROUP_BY_STATUS, { exact: true })).toHaveCount(0);
-      await expect(panel.getByText(GROUP_BY_PROJECT, { exact: true })).toHaveCount(0);
-      await page.keyboard.press("Escape");
-      await expect(panel).not.toBeVisible({ timeout: 30_000 });
-
-      await runGroupingEntry(page, GROUP_BY_STATUS, GROUP_BY_PROJECT);
-      await expect(statusList).toBeVisible({ timeout: 30_000 });
-      await expect(projectList).toHaveCount(0);
-
-      // The only assertion that catches a flip which never reached persisted storage.
-      await page.reload();
-      await expect(statusList).toBeVisible({ timeout: 30_000 });
-
-      // Grouping persists, so the run must leave the sidebar back in project mode.
-      await runGroupingEntry(page, GROUP_BY_PROJECT, GROUP_BY_STATUS);
-      await expect(projectList).toBeVisible({ timeout: 30_000 });
-      await expect(statusList).toHaveCount(0);
-    } finally {
-      await seeded.cleanup().catch(() => undefined);
-    }
-  });
-});
@@ -107,73 +107,122 @@ async function rejectNextLabelAssignment(page: Page): Promise<void> {
  });
 }

+const GROUP_BY_STATUS = "Group by status";
+const GROUP_BY_PROJECT = "Group by project";
+
+// Result rows carry no testID of their own, so the entries are addressed by their visible label.
+async function runGroupingEntry(page: Page, label: string, absent: string): Promise<void> {
+  const panel = await openCommandCenter(page);
+  await panel.getByTestId("command-center-input").fill("group");
+
+  const entry = panel.getByText(label, { exact: true });
+  await expect(entry).toBeVisible({ timeout: 30_000 });
+  // The entry always names the mode you are not in, so its opposite must never be listed.
+  await expect(panel.getByText(absent, { exact: true })).toHaveCount(0);
+
+  await entry.click();
+  await expect(page.getByTestId("command-center-panel")).not.toBeVisible({ timeout: 30_000 });
+}
+
 test.describe("Command center workspace management", () => {
-  test("renames the active workspace while its sidebar row is unmounted", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "cc-rename-" });
-
+  test("manage the active workspace and scope its commands when leaving the route", async ({
+    page,
+  }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "cc-manage-" });
    try {
      await gotoAppShell(page);
      await openWorkspace(page, workspace.workspaceId);
-      await collapseProjectSection(page, workspace);
+      await test.step("renames the active workspace while its sidebar row is unmounted", async () => {
+        await collapseProjectSection(page, workspace);

-      await runCommand(page, "rename", "Rename workspace");
+        await runCommand(page, "rename", "Rename workspace");

-      // Focused, not merely visible. A modal that mounts behind the closing palette, or loses the
-      // focus race with its focus-restore, still renders — you just cannot type into it.
-      const input = page.getByTestId("workspace-rename-modal-global-input");
-      await expect(input).toBeFocused({ timeout: 15_000 });
-      await expect(input).toHaveValue(workspace.workspaceName);
+        // Focused, not merely visible. A modal that mounts behind the closing palette, or loses the
+        // focus race with its focus-restore, still renders — you just cannot type into it.
+        const input = page.getByTestId("workspace-rename-modal-global-input");
+        await expect(input).toBeFocused({ timeout: 15_000 });
+        await expect(input).toHaveValue(workspace.workspaceName);

-      const customTitle = "Renamed From Palette";
-      await input.fill(customTitle);
-      await page.getByTestId("workspace-rename-modal-global-submit").click();
-      await expect(input).toHaveCount(0, { timeout: 15_000 });
+        const customTitle = "Renamed From Palette";
+        await input.fill(customTitle);
+        await page.getByTestId("workspace-rename-modal-global-submit").click();
+        await expect(input).toHaveCount(0, { timeout: 15_000 });

-      // Re-expand the section to read the row back.
-      const header = page
-        .locator('[data-testid^="sidebar-project-row-"]')
-        .filter({ hasText: workspace.projectDisplayName });
-      await header.click();
-      await expect(workspaceRow(page, workspace.workspaceId)).toContainText(customTitle, {
-        timeout: 15_000,
+        // Re-expand the section to read the row back.
+        const header = page
+          .locator('[data-testid^="sidebar-project-row-"]')
+          .filter({ hasText: workspace.projectDisplayName });
+        await header.click();
+        await expect(workspaceRow(page, workspace.workspaceId)).toContainText(customTitle, {
+          timeout: 15_000,
+        });
      });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
+      await test.step("copies the workspace path and confirms with a toast", async () => {
+        await runCommand(page, "copy path", "Copy workspace path");

-  test("copies the workspace path and confirms with a toast", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "cc-copy-path-" });
-
-    try {
-      await gotoAppShell(page);
-      await openWorkspace(page, workspace.workspaceId);
-
-      await runCommand(page, "copy path", "Copy workspace path");
-
-      // toast.copied wraps its label: "Copied {{label}}" with label "Path copied".
-      await expect(page.getByText("Copied Path copied", { exact: true })).toBeVisible({
-        timeout: 15_000,
+        // toast.copied wraps its label: "Copied {{label}}" with label "Path copied".
+        await expect(page.getByText("Copied Path copied", { exact: true })).toBeVisible({
+          timeout: 15_000,
+        });
      });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
+      await test.step("flips the pin entry to Unpin after pinning from the palette", async () => {
+        await runCommand(page, "pin", "Pin to top");
+        await expect(page.getByTestId("sidebar-pinned-section")).toBeVisible({ timeout: 15_000 });

-  test("flips the pin entry to Unpin after pinning from the palette", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "cc-pin-" });
+        const panel = await openCommandCenter(page);
+        await panel.getByTestId("command-center-input").fill("pin");
+        await expect(action(panel, "Unpin")).toBeVisible({ timeout: 15_000 });
+        await expect(action(panel, "Pin to top")).toHaveCount(0);

-    try {
-      await gotoAppShell(page);
-      await openWorkspace(page, workspace.workspaceId);
+        await action(panel, "Unpin").click();
+        await expect(page.getByTestId("sidebar-pinned-section")).toHaveCount(0);
+      });
+      await test.step("grouping commands persist across reload and switch back", async () => {
+        const projectList = page.getByTestId("sidebar-project-workspace-list-scroll");
+        const statusList = page.getByTestId("sidebar-status-list-scroll");
+        await expect(projectList).toBeVisible({ timeout: 30_000 });
+        // Query-only: the grouping entry stays out of the default empty-query list.
+        const panel = await openCommandCenter(page);
+        await expect(panel.getByText(GROUP_BY_STATUS, { exact: true })).toHaveCount(0);
+        await expect(panel.getByText(GROUP_BY_PROJECT, { exact: true })).toHaveCount(0);
+        await page.keyboard.press("Escape");
+        await expect(panel).not.toBeVisible({ timeout: 30_000 });

-      await runCommand(page, "pin", "Pin to top");
-      await expect(page.getByTestId("sidebar-pinned-section")).toBeVisible({ timeout: 15_000 });
+        await runGroupingEntry(page, GROUP_BY_STATUS, GROUP_BY_PROJECT);
+        await expect(statusList).toBeVisible({ timeout: 30_000 });
+        await expect(projectList).toHaveCount(0);

-      const panel = await openCommandCenter(page);
-      await panel.getByTestId("command-center-input").fill("pin");
-      await expect(action(panel, "Unpin")).toBeVisible({ timeout: 15_000 });
-      await expect(action(panel, "Pin to top")).toHaveCount(0);
+        // The only assertion that catches a flip which never reached persisted storage.
+        await page.reload();
+        await expect(statusList).toBeVisible({ timeout: 30_000 });
+
+        // Grouping persists, so the run must leave the sidebar back in project mode.
+        await runGroupingEntry(page, GROUP_BY_PROJECT, GROUP_BY_STATUS);
+        await expect(projectList).toBeVisible({ timeout: 30_000 });
+        await expect(statusList).toHaveCount(0);
+      });
+      await test.step("lists only the globally-handled toggle off a workspace route", async () => {
+        // All three are listed while a workspace route owns the handlers.
+        const workspacePanel = await openCommandCenter(page);
+        await workspacePanel.getByTestId("command-center-input").fill("toggle");
+        await expect(action(workspacePanel, "Toggle left sidebar")).toBeVisible({
+          timeout: 15_000,
+        });
+        await expect(action(workspacePanel, "Toggle Explorer sidebar")).toBeVisible();
+        await expect(action(workspacePanel, "Toggle focus mode")).toBeVisible();
+        await page.keyboard.press("Escape");
+        await expect(page.getByTestId("command-center-panel")).toHaveCount(0);
+
+        await page.locator('[data-testid="sidebar-settings"]:visible').first().click();
+        await expect(page.getByTestId("settings-sidebar")).toBeVisible({ timeout: 30_000 });
+
+        const panel = await openCommandCenter(page);
+        await panel.getByTestId("command-center-input").fill("toggle");
+
+        await expect(action(panel, "Toggle left sidebar")).toBeVisible({ timeout: 15_000 });
+        await expect(action(panel, "Toggle Explorer sidebar")).toHaveCount(0);
+        await expect(action(panel, "Toggle focus mode")).toHaveCount(0);
+      });
    } finally {
      await workspace.cleanup();
    }
@@ -183,35 +232,6 @@ test.describe("Command center workspace management", () => {
  // handled only by workspace-screen.tsx behind `enabled: isRouteFocused && ...`, so listing them
  // off a workspace route would give the user two entries that close the palette and do nothing.
  // Toggle left sidebar calls the panel store directly and works everywhere, so it stays listed.
-  test("lists only the globally-handled toggle off a workspace route", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "cc-toggle-scope-" });
-
-    try {
-      await gotoAppShell(page);
-      await openWorkspace(page, workspace.workspaceId);
-
-      // All three are listed while a workspace route owns the handlers.
-      const workspacePanel = await openCommandCenter(page);
-      await workspacePanel.getByTestId("command-center-input").fill("toggle");
-      await expect(action(workspacePanel, "Toggle left sidebar")).toBeVisible({ timeout: 15_000 });
-      await expect(action(workspacePanel, "Toggle Explorer sidebar")).toBeVisible();
-      await expect(action(workspacePanel, "Toggle focus mode")).toBeVisible();
-      await page.keyboard.press("Escape");
-      await expect(page.getByTestId("command-center-panel")).toHaveCount(0);
-
-      await page.locator('[data-testid="sidebar-settings"]:visible').first().click();
-      await expect(page.getByTestId("settings-sidebar")).toBeVisible({ timeout: 30_000 });
-
-      const panel = await openCommandCenter(page);
-      await panel.getByTestId("command-center-input").fill("toggle");
-
-      await expect(action(panel, "Toggle left sidebar")).toBeVisible({ timeout: 15_000 });
-      await expect(action(panel, "Toggle Explorer sidebar")).toHaveCount(0);
-      await expect(action(panel, "Toggle focus mode")).toHaveCount(0);
-    } finally {
-      await workspace.cleanup();
-    }
-  });

  test("toggles a label on the active workspace from the palette", async ({ page }) => {
    const workspace = await seedWorkspace({ repoPrefix: "cc-label-" });
@@ -44,6 +44,16 @@ test.describe("Command center workspaces", () => {
      });

      await gotoAppShell(page);
+      await test.step("single-host results show project and branch without a host label", async () => {
+        const singleHostPanel = await openCommandCenter(page);
+        const singleHostRow = singleHostPanel.getByTestId(
+          `command-center-workspace-${getServerId()}:${seeded.workspaceId}`,
+        );
+        await expect(singleHostRow.getByTestId("command-center-workspace-subtitle")).toHaveText(
+          `${seeded.projectDisplayName} · ${WORKSPACE_BRANCH}`,
+        );
+        await page.keyboard.press("Escape");
+      });
      await addOfflineHostAndReload(page, {
        serverId: SECONDARY_HOST_ID,
        label: "Secondary Host",
@@ -121,38 +131,4 @@ test.describe("Command center workspaces", () => {
      await seeded.cleanup();
    }
  });
-
-  test("single-host workspace subtitle omits the host and shows project · branch", async ({
-    page,
-  }) => {
-    const seeded = await seedWorkspace({
-      repoPrefix: "command-center-workspace-single-",
-      title: WORKSPACE_TITLE,
-    });
-
-    try {
-      execFileSync("git", ["checkout", "-b", WORKSPACE_BRANCH], {
-        cwd: seeded.repoPath,
-        stdio: "ignore",
-      });
-      const refreshed = await seeded.client.checkoutRefresh(seeded.repoPath);
-      if (!refreshed.success) {
-        throw new Error(`Failed to refresh checkout: ${JSON.stringify(refreshed.error)}`);
-      }
-
-      // No secondary host: with a single host, the host label is gated away.
-      await gotoAppShell(page);
-
-      const panel = await openCommandCenter(page);
-      const row = panel.getByTestId(
-        `command-center-workspace-${getServerId()}:${seeded.workspaceId}`,
-      );
-      await expect(row).toBeVisible({ timeout: 30_000 });
-
-      const subtitle = row.getByTestId("command-center-workspace-subtitle");
-      await expect(subtitle).toHaveText(`${seeded.projectDisplayName} · ${WORKSPACE_BRANCH}`);
-    } finally {
-      await seeded.cleanup();
-    }
-  });
 });
@@ -420,36 +420,38 @@ test("context details support keyboard entry and dismiss when the viewport moves
  await expect(details).toHaveCount(0);
 });

-test("pointer hovering context details preserves composer focus", async ({ page, agent }) => {
+test("context details preserve composer focus on hover and leave Find available after keyboard dismissal", async ({
+  page,
+  agent,
+}) => {
  const usage = await scriptAgentUsage(page);
  await page.setViewportSize(DESKTOP);
  await openAgent(page, agent);
  const [claude] = claudeAndCodexReports();
-  usage.answerNext([onPersonalLogin(claude!)]);
-  const input = composerLocator(page);
-  await input.focus();
-  await hoverContextWindowMeter(page);
-  await expect(input).toBeFocused();
-  await leaveContextWindowMeter(page);
-  await expect(input).toBeFocused();
-});

-test("Find remains available after dismissing context details", async ({ page, agent }) => {
-  const usage = await scriptAgentUsage(page);
-  await page.setViewportSize(DESKTOP);
-  await openAgent(page, agent);
-  const [claude] = claudeAndCodexReports();
-  usage.answerNext([onPersonalLogin(claude!)]);
-  const meter = page.getByTestId("context-window-meter");
-  const trigger = page.getByRole("button", {
-    name: (await meter.getAttribute("aria-label"))!,
-    exact: true,
+  await test.step("pointer entry and dismissal preserve composer focus", async () => {
+    usage.answerNext([onPersonalLogin(claude!)]);
+    const input = composerLocator(page);
+    await input.focus();
+    await hoverContextWindowMeter(page);
+    await expect(input).toBeFocused();
+    await leaveContextWindowMeter(page);
+    await expect(input).toBeFocused();
+  });
+
+  await test.step("keyboard dismissal restores trigger focus and Find remains available", async () => {
+    usage.answerNext([onPersonalLogin(claude!)]);
+    const meter = page.getByTestId("context-window-meter");
+    const trigger = page.getByRole("button", {
+      name: (await meter.getAttribute("aria-label"))!,
+      exact: true,
+    });
+    await trigger.focus();
+    await expect(contextWindowDetails(page)).toBeVisible();
+    await page.keyboard.press("Escape");
+    await expect(contextWindowDetails(page)).toHaveCount(0);
+    await expect(trigger).toBeFocused();
+    await page.keyboard.press("ControlOrMeta+f");
+    await expect(page.getByRole("textbox", { name: "Find in pane", exact: true })).toBeFocused();
  });
-  await trigger.focus();
-  await expect(contextWindowDetails(page)).toBeVisible();
-  await page.keyboard.press("Escape");
-  await expect(contextWindowDetails(page)).toHaveCount(0);
-  await expect(trigger).toBeFocused();
-  await page.keyboard.press("ControlOrMeta+f");
-  await expect(page.getByRole("textbox", { name: "Find in pane", exact: true })).toBeFocused();
 });
@@ -105,25 +105,41 @@ async function seedAgentWithFileLink(input: LinkedFile) {
 }

 test.describe("CodeMirror workspace file editing", () => {
-  test("opens explicit screenshot links and explains missing files", async ({ page }) => {
+  test("opens screenshot and non-ASCII Markdown links and explains missing files", async ({
+    page,
+  }) => {
    const session = await seedMockAgentWorkspace({
      repoPrefix: "screenshot-markdown-link-",
      title: "Screenshot file links",
      initialPrompt: "Show screenshots",
      featureValues: {
        mockAssistantResponse:
-          "[Capture](.dev/tablet-review/capture.png) [Missing capture](.dev/tablet-review/missing.png)",
+          "[Capture](.dev/tablet-review/capture.png) [报告](docs/reports/开户赠金.md) [Missing capture](.dev/tablet-review/missing.png)",
      },
    });
    try {
      await mkdir(path.join(session.cwd, ".dev/tablet-review"), { recursive: true });
      await writeFile(path.join(session.cwd, ".dev/tablet-review/capture.png"), RED_PIXEL);
+      await mkdir(path.join(session.cwd, "docs/reports"), { recursive: true });
+      await writeFile(path.join(session.cwd, "docs/reports/开户赠金.md"), "# Report opened\n");
      await openAgentRoute(page, session);
      await test.step("Open the linked screenshot", async () => {
        await openAssistantMarkdownLink(page, "Capture");
        await expectFileTabOpen(page, ".dev/tablet-review/capture.png");
        await expect(page.getByTestId("image-file-preview-canvas")).toBeVisible();
      });
+      await test.step("Open the non-ASCII report named by its Markdown link", async () => {
+        await returnToAssistant(page, session.agentId);
+        await openAssistantMarkdownLink(page, "报告");
+        await expectFileTabOpen(page, "docs/reports/开户赠金.md");
+        await expect(
+          page
+            .getByTestId("workspace-file-pane")
+            .filter({ visible: true })
+            .getByText("Report opened", { exact: true }),
+        ).toBeVisible();
+        await page.screenshot({ path: test.info().outputPath("non-ascii-file-opened.png") });
+      });
      await test.step("Explain why the missing screenshot cannot open", async () => {
        await returnToAssistant(page, session.agentId);
        await openAssistantMarkdownLink(page, "Missing capture");
@@ -136,31 +152,6 @@ test.describe("CodeMirror workspace file editing", () => {
    }
  });

-  test("opens the non-ASCII file named by an assistant markdown link", async ({ page }) => {
-    const session = await seedMockAgentWorkspace({
-      repoPrefix: "encoded-markdown-link-",
-      title: "Non-ASCII file link",
-      initialPrompt: "Show the report link",
-      featureValues: { mockAssistantResponse: "[报告](docs/reports/开户赠金.md)" },
-    });
-    try {
-      await mkdir(path.join(session.cwd, "docs/reports"), { recursive: true });
-      await writeFile(path.join(session.cwd, "docs/reports/开户赠金.md"), "# Report opened\n");
-      await openAgentRoute(page, session);
-      await openAssistantMarkdownLink(page, "报告");
-      await expectFileTabOpen(page, "docs/reports/开户赠金.md");
-      await expect(
-        page
-          .getByTestId("workspace-file-pane")
-          .filter({ visible: true })
-          .getByText("Report opened", { exact: true }),
-      ).toBeVisible();
-      await page.screenshot({ path: test.info().outputPath("non-ascii-file-opened.png") });
-    } finally {
-      await session.cleanup();
-    }
-  });
-
  for (const order of ["raw-first", "href-first"] as const) {
    test(`opens literal and encoded percent filenames independently ${order}`, async ({ page }) => {
      const session = await seedMockAgentWorkspace({
@@ -690,7 +681,37 @@ test.describe("CodeMirror workspace file editing", () => {
    const imagePath = path.join(workspace.repoPath, "pixel.png");
    await writeFile(markdownPath, "# First heading\n", "utf8");
    await writeFile(imagePath, RED_PIXEL);
+    await mkdir(path.join(workspace.repoPath, "docs"), { recursive: true });
+    await mkdir(path.join(workspace.repoPath, "data", "cache"), { recursive: true });
+    await writeFile(path.join(workspace.repoPath, "docs", "sibling.png"), RED_PIXEL);
+    await writeFile(path.join(workspace.repoPath, "data", "cache", "hero.png"), RED_PIXEL);
+    await writeFile(
+      path.join(workspace.repoPath, "docs", "guide.md"),
+      [
+        "# Guide",
+        "",
+        "![sibling](./sibling.png)",
+        "",
+        "![hero](../data/cache/hero.png?v=2#preview)",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
    await workspace.navigateTo();
+    await test.step("render sibling and parent-relative images in Markdown preview", async () => {
+      await openFileExplorer(page);
+      await expandFolder(page, "docs");
+      await openFileFromExplorer(page, "guide.md");
+      await expectFileTabOpen(page, "docs/guide.md");
+
+      const guidePane = page.getByTestId("workspace-file-pane").filter({ visible: true });
+      await expect(guidePane.getByText("Guide", { exact: true })).toBeVisible();
+      await expectMarkdownImageLoaded(page, "sibling");
+      await expectMarkdownImageLoaded(page, "hero");
+      await guidePane.screenshot({
+        path: test.info().outputPath("markdown-relative-images.png"),
+      });
+    });
    await openWorkspaceFile(page, "notes.md");

    const visibleFilePane = page.getByTestId("workspace-file-pane").filter({ visible: true });
@@ -724,84 +745,30 @@ test.describe("CodeMirror workspace file editing", () => {
    await expect.poll(() => image.getAttribute("src")).not.toBe(initialSource);
  });

-  test("renders local relative images inside Markdown preview", async ({ page, withWorkspace }) => {
-    test.setTimeout(90_000);
-    const workspace = await withWorkspace({ prefix: "file-md-relative-image-" });
-    await mkdir(path.join(workspace.repoPath, "docs"), { recursive: true });
-    await mkdir(path.join(workspace.repoPath, "data", "cache"), { recursive: true });
-    await writeFile(path.join(workspace.repoPath, "docs", "sibling.png"), RED_PIXEL);
-    await writeFile(path.join(workspace.repoPath, "data", "cache", "hero.png"), RED_PIXEL);
-    await writeFile(
-      path.join(workspace.repoPath, "docs", "guide.md"),
-      [
-        "# Guide",
-        "",
-        "![sibling](./sibling.png)",
-        "",
-        "![hero](../data/cache/hero.png?v=2#preview)",
-        "",
-      ].join("\n"),
-      "utf8",
-    );
-    await workspace.navigateTo();
-    await openFileExplorer(page);
-    await expandFolder(page, "docs");
-    await openFileFromExplorer(page, "guide.md");
-    await expectFileTabOpen(page, "docs/guide.md");
-
-    const visibleFilePane = page.getByTestId("workspace-file-pane").filter({ visible: true });
-    await expect(visibleFilePane.getByText("Guide", { exact: true })).toBeVisible();
-    await expectMarkdownImageLoaded(page, "sibling");
-    await expectMarkdownImageLoaded(page, "hero");
-    await visibleFilePane.screenshot({
-      path: test.info().outputPath("markdown-relative-images.png"),
-    });
-  });
-
-  test("previews and refreshes an HTML plan while preserving source access", async ({
+  test("isolates an HTML preview, blocks fetch egress, and refreshes while retaining source access", async ({
    page,
    withWorkspace,
  }) => {
-    test.setTimeout(90_000);
-    const workspace = await withWorkspace({ prefix: "file-editing-html-preview-" });
-    const htmlPath = path.join(workspace.repoPath, "plan.html");
-    await writeFile(
-      htmlPath,
-      "<!doctype html><html><body><h1>Visual plan</h1></body></html>",
-      "utf8",
-    );
-    await workspace.navigateTo();
-    await openWorkspaceFile(page, "plan.html");
-
-    const preview = htmlPreview(page);
-    await expect(preview.host).toBeVisible();
-    await expect(preview.host).toHaveAttribute("sandbox", /allow-scripts/);
-    await expect(preview.host).not.toHaveAttribute("sandbox", /allow-same-origin/);
-    await expect(preview.document.getByRole("heading", { name: "Visual plan" })).toBeVisible();
-
-    await writeFile(
-      htmlPath,
-      "<!doctype html><html><body><h1>Updated plan</h1></body></html>",
-      "utf8",
-    );
-    await expect(preview.document.getByRole("heading", { name: "Updated plan" })).toBeVisible();
-
-    await selectFileView(page, "Source");
-    await expect(page.getByTestId("file-source-editor")).toBeVisible();
-    await expect(preview.host).toHaveCount(0);
-    await selectFileView(page, "Preview");
-    await expect(preview.host).toBeVisible();
-  });
-
-  test("runs inline scripts without allowing fetch egress", async ({ page, withWorkspace }) => {
    test.setTimeout(90_000);
    const workspace = await withWorkspace({ prefix: "file-editing-html-csp-" });
    await writeFile(
      path.join(workspace.repoPath, "probe.html"),
      `<!doctype html><html><head><title>probe</title></head><body>
+<h1>Visual plan</h1>
 <h1 id="script-result">Inline script did not run</h1>
 <p id="network-result">Network request not attempted</p>
 <p id="document-mode">Standards mode not detected</p>
+<p id="parent">?</p><p id="storage">?</p><p id="cookie">?</p>
+<script>
+  function report(id, label, probe) {
+    try { probe(); document.getElementById(id).textContent = label + " reachable"; }
+    catch (error) { document.getElementById(id).textContent = label + " blocked"; }
+  }
+  report("parent", "Parent DOM", function () { return parent.document.body; });
+  report("storage", "Storage", function () { return localStorage.length; });
+  report("cookie", "Cookies", function () { return document.cookie; });
+</script>
+
 <script>
  document.getElementById("script-result").textContent = "Inline script ran";
  if (document.compatMode === "CSS1Compat") {
@@ -822,6 +789,8 @@ test.describe("CodeMirror workspace file editing", () => {
    await openWorkspaceFile(page, "probe.html");

    const preview = htmlPreview(page);
+    await expect(preview.host).toBeVisible();
+    await expect(preview.document.getByRole("heading", { name: "Visual plan" })).toBeVisible();
    await expect(
      preview.document.getByRole("heading", { name: "Inline script ran" }),
    ).toBeVisible();
@@ -832,34 +801,26 @@ test.describe("CodeMirror workspace file editing", () => {
      preview.document.getByText("Network request blocked", { exact: true }),
    ).toBeVisible();
    expect(blockedRequests).toEqual([]);
-  });
-
-  test("isolates HTML plans from the app origin and storage", async ({ page, withWorkspace }) => {
-    test.setTimeout(90_000);
-    const workspace = await withWorkspace({ prefix: "file-editing-html-origin-" });
-    await writeFile(
-      path.join(workspace.repoPath, "origin.html"),
-      `<!doctype html><html><body>
-<p id="parent">?</p><p id="storage">?</p><p id="cookie">?</p>
-<script>
-  function report(id, label, probe) {
-    try { probe(); document.getElementById(id).textContent = label + " reachable"; }
-    catch (error) { document.getElementById(id).textContent = label + " blocked"; }
-  }
-  report("parent", "Parent DOM", function () { return parent.document.body; });
-  report("storage", "Storage", function () { return localStorage.length; });
-  report("cookie", "Cookies", function () { return document.cookie; });
-</script>
-</body></html>`,
-      "utf8",
-    );
-    await workspace.navigateTo();
-    await openWorkspaceFile(page, "origin.html");
-
-    const preview = htmlPreview(page);
-    await expect(preview.document.getByText("Parent DOM blocked", { exact: true })).toBeVisible();
-    await expect(preview.document.getByText("Storage blocked", { exact: true })).toBeVisible();
-    await expect(preview.document.getByText("Cookies blocked", { exact: true })).toBeVisible();
+    await test.step("isolate the preview from app origin and storage", async () => {
+      await expect(preview.host).toHaveAttribute("sandbox", /allow-scripts/);
+      await expect(preview.host).not.toHaveAttribute("sandbox", /allow-same-origin/);
+      await expect(preview.document.getByText("Parent DOM blocked", { exact: true })).toBeVisible();
+      await expect(preview.document.getByText("Storage blocked", { exact: true })).toBeVisible();
+      await expect(preview.document.getByText("Cookies blocked", { exact: true })).toBeVisible();
+    });
+    await test.step("refresh a changed HTML plan and switch to source and back", async () => {
+      await writeFile(
+        path.join(workspace.repoPath, "probe.html"),
+        "<!doctype html><html><body><h1>Updated plan</h1></body></html>",
+        "utf8",
+      );
+      await expect(preview.document.getByRole("heading", { name: "Updated plan" })).toBeVisible();
+      await selectFileView(page, "Source");
+      await expect(page.getByTestId("file-source-editor")).toBeVisible();
+      await expect(preview.host).toHaveCount(0);
+      await selectFileView(page, "Preview");
+      await expect(preview.host).toBeVisible();
+    });
  });

  test("persists Vim keybindings and reports Vim mode with cursor position", async ({
@@ -6,20 +6,14 @@ import {
 } from "../support/helpers/composer";
 import { expect, test } from "../support/fixtures";
 import { gotoAppShell } from "../support/helpers/app";
-import { getE2EDaemonPort } from "../support/helpers/daemon-port";
 import {
  delayBrowserWorkspaceCreatedResponse,
  expectNewWorkspaceDraft,
-  expectNewWorkspaceProjectSelected,
  fillNewWorkspaceDraft,
  openGlobalNewWorkspaceComposer,
  openNewWorkspaceComposer,
-  selectNewWorkspaceHost,
-  selectNewWorkspaceProject,
 } from "../support/helpers/new-workspace";
-import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
-import { getServerId } from "../support/helpers/server-id";
-import { seedSavedSettingsHosts } from "../support/helpers/settings";
+import { seedWorkspace } from "../support/helpers/seed-client";
 import { waitForSidebarHydration } from "../support/helpers/workspace-ui";

 const DRAFT = `Please investigate the workspace startup failure.
@@ -29,70 +23,6 @@ Trace the request from the app through the daemon, preserve the existing behavio
 test.describe("New workspace composer draft", () => {
  test.describe.configure({ timeout: 240_000 });

-  test("keeps the draft when the project changes", async ({ page }) => {
-    const firstProject: SeededWorkspace = await seedWorkspace({
-      repoPrefix: "new-workspace-draft-project-a-",
-    });
-    const secondProject: SeededWorkspace = await seedWorkspace({
-      repoPrefix: "new-workspace-draft-project-b-",
-    });
-
-    try {
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-      await openNewWorkspaceComposer(page, {
-        projectKey: firstProject.projectKey,
-        projectDisplayName: firstProject.projectDisplayName,
-      });
-      await expectNewWorkspaceProjectSelected(page, firstProject.projectDisplayName);
-
-      await fillNewWorkspaceDraft(page, DRAFT);
-
-      await selectNewWorkspaceProject(page, {
-        projectKey: secondProject.projectKey,
-        projectDisplayName: secondProject.projectDisplayName,
-      });
-
-      await expectNewWorkspaceDraft(page, DRAFT);
-    } finally {
-      await secondProject.cleanup();
-      await firstProject.cleanup();
-    }
-  });
-
-  test("keeps the draft when the host changes", async ({ page }) => {
-    const project: SeededWorkspace = await seedWorkspace({
-      repoPrefix: "new-workspace-draft-host-",
-    });
-    const secondaryServerId = "new-workspace-draft-secondary-host";
-
-    try {
-      await seedSavedSettingsHosts(page, [
-        {
-          serverId: getServerId(),
-          label: "Primary host",
-          endpoint: `127.0.0.1:${getE2EDaemonPort()}`,
-        },
-        {
-          serverId: secondaryServerId,
-          label: "Secondary host",
-          endpoint: "127.0.0.1:9",
-        },
-      ]);
-
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-      await openGlobalNewWorkspaceComposer(page);
-
-      await fillNewWorkspaceDraft(page, DRAFT);
-      await selectNewWorkspaceHost(page, "Secondary host");
-
-      await expectNewWorkspaceDraft(page, DRAFT);
-    } finally {
-      await project.cleanup();
-    }
-  });
-
  test("does not restore a submitted draft after deferred publication", async ({ page }) => {
    const project = await seedWorkspace({ repoPrefix: "new-workspace-submitted-draft-" });

@@ -3,6 +3,9 @@ import { gotoAppShell } from "../support/helpers/app";
 import {
  connectNewWorkspaceDaemonClient,
  expectNewWorkspaceControlsEnabled,
+  expectNewWorkspaceDraft,
+  fillNewWorkspaceDraft,
+  selectNewWorkspaceHost,
  expectNewWorkspaceProjectSelected,
  expectNewWorkspaceTriggerLabelsAligned,
  openGlobalNewWorkspaceComposer,
@@ -90,6 +93,11 @@ test.describe("New workspace entry points", () => {
        projectLabel: seeded.projectDisplayName,
        hostLabel: "localhost",
      });
+      await test.step("changing hosts preserves the draft", async () => {
+        await fillNewWorkspaceDraft(page, "Keep this draft while choosing a host");
+        await selectNewWorkspaceHost(page, "Secondary host");
+        await expectNewWorkspaceDraft(page, "Keep this draft while choosing a host");
+      });
    } finally {
      await seeded.cleanup();
    }
@@ -121,6 +129,9 @@ test.describe("New workspace entry points", () => {
        timeout: 30_000,
      });
      await expect(page.getByTestId("host-picker-trigger")).toHaveCount(0);
+      await test.step("Ctrl+P opens the project picker with search focused", async () => {
+        await openNewWorkspaceProjectPickerWithShortcut(page);
+      });
    } finally {
      await seeded.cleanup();
    }
@@ -137,20 +148,6 @@ test.describe("New workspace entry points", () => {
    await expectNewWorkspaceControlsEnabled(page);
  });

-  test("Ctrl+P opens the project picker with search focused", async ({ page }) => {
-    const seeded: SeededWorkspace = await seedWorkspace({ repoPrefix: "entry-shortcut-" });
-
-    try {
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-      await openGlobalNewWorkspaceComposer(page);
-
-      await openNewWorkspaceProjectPickerWithShortcut(page);
-    } finally {
-      await seeded.cleanup();
-    }
-  });
-
  test("keeps the in-progress form when the remembered workspace is archived elsewhere", async ({
    page,
  }) => {
@@ -220,6 +217,8 @@ test.describe("New workspace entry points", () => {
      });
      await expectNewWorkspaceProjectSelected(page, projectA.projectDisplayName);

+      await fillNewWorkspaceDraft(page, "Keep this draft while choosing a project");
+
      // Manually override the selection to C from inside A's screen. This stale
      // manualProjectKey is what the reused 'new' screen must reset when the next
      // route-driven navigation targets a different project.
@@ -230,6 +229,9 @@ test.describe("New workspace entry points", () => {
      await expect(optionC).toBeVisible({ timeout: 30_000 });
      await optionC.click();
      await expectNewWorkspaceProjectSelected(page, projectC.projectDisplayName);
+      await test.step("changing projects preserves the draft", async () => {
+        await expectNewWorkspaceDraft(page, "Keep this draft while choosing a project");
+      });

      // Navigate via B's row icon. B must be preselected — the route project wins
      // because the stale manual choice (C) was reset on the route change. If the
@@ -88,11 +88,23 @@ async function openNewWorkspaceFromContextProject(
  await expectNewWorkspaceProjectSelected(page, "Context project");
 }

-const test = base.extend<{ crossHostProject: CrossHostProjectScenario }>({
-  crossHostProject: async ({ page: _page }, provide) => {
-    const secondaryDaemon: IsolatedHostDaemon = await startIsolatedHostDaemon(
-      "new-workspace-project-preservation-secondary",
-    );
+const test = base.extend<
+  { crossHostProject: CrossHostProjectScenario },
+  { secondaryDaemon: IsolatedHostDaemon }
+>({
+  secondaryDaemon: [
+    async ({ e2eWorker }, provide) => {
+      void e2eWorker;
+      const daemon = await startIsolatedHostDaemon("new-workspace-project-preservation-secondary");
+      try {
+        await provide(daemon);
+      } finally {
+        await daemon.close();
+      }
+    },
+    { scope: "worker" },
+  ],
+  crossHostProject: async ({ page: _page, secondaryDaemon }, provide) => {
    const contextRepo = await createTempGitRepo("new-workspace-context-");
    const primarySharedRepo = await createTempGitRepo("new-workspace-paseo-primary-", {
      originUrl: SHARED_REMOTE_URL,
@@ -177,7 +189,6 @@ const test = base.extend<{ crossHostProject: CrossHostProjectScenario }>({
      await primaryDuplicateRepo.cleanup().catch(() => undefined);
      await secondaryFallbackRepo.cleanup().catch(() => undefined);
      await secondarySharedRepo.cleanup().catch(() => undefined);
-      await secondaryDaemon.close().catch(() => undefined);
    }
  },
 });
@@ -1,100 +0,0 @@
-import { expect, test } from "../support/fixtures";
-import { gotoAppShell } from "../support/helpers/app";
-import {
-  archiveLocalWorkspaceFromDaemon,
-  archiveWorkspaceFromDaemon,
-  assertNewWorkspaceSidebarAndHeader,
-  connectNewWorkspaceDaemonClient,
-  expectWorkspaceIsolationSelected,
-  openNewWorkspaceComposer,
-  openProjectViaDaemon,
-  openStartingRefPicker,
-  selectBranchInPicker,
-} from "../support/helpers/new-workspace";
-import { expectNoTruncation } from "../support/helpers/no-truncation";
-import { createTempGitRepo } from "../support/helpers/workspace";
-import { getServerId } from "../support/helpers/server-id";
-import { waitForSidebarHydration } from "../support/helpers/workspace-ui";
-
-// Regression for "the local / worktree selection in the new workspace is not
-// remembered." The isolation choice persists in the create-form preferences
-// (FormPreferences.isolation), so it must survive the create→reopen remount:
-// creating a worktree workspace navigates away from /new and unmounts it, and
-// reopening New Workspace has to still show "New worktree".
-test.describe("New workspace isolation memory", () => {
-  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
-  const localWorkspaceIds = new Set<string>();
-  const createdWorktreeDirectories = new Set<string>();
-
-  test.describe.configure({ timeout: 240_000 });
-
-  test.beforeEach(async () => {
-    client = await connectNewWorkspaceDaemonClient();
-  });
-
-  test.afterEach(async () => {
-    if (client) {
-      for (const workspaceDirectory of createdWorktreeDirectories) {
-        await archiveWorkspaceFromDaemon(client, workspaceDirectory).catch(() => undefined);
-      }
-      for (const workspaceId of localWorkspaceIds) {
-        await archiveLocalWorkspaceFromDaemon(client, workspaceId).catch(() => undefined);
-      }
-    }
-    createdWorktreeDirectories.clear();
-    localWorkspaceIds.clear();
-    await client?.close().catch(() => undefined);
-  });
-
-  test("remembers the worktree isolation choice after creating a workspace", async ({ page }) => {
-    const serverId = getServerId();
-    const tempRepo = await createTempGitRepo("isolation-memory-", { branches: ["main", "dev"] });
-
-    try {
-      const openedProject = await openProjectViaDaemon(client, tempRepo.path);
-      localWorkspaceIds.add(openedProject.workspaceId);
-
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-
-      // First visit: the screen opens on Local, switch it to New worktree and create.
-      await openNewWorkspaceComposer(page, {
-        projectKey: openedProject.projectKey,
-        projectDisplayName: openedProject.projectDisplayName,
-      });
-      await expectWorkspaceIsolationSelected(page, "local");
-      await page.getByTestId("workspace-create-isolation-trigger").click();
-      const isolationPopup = page.getByTestId("combobox-desktop-container").last();
-      await expect(isolationPopup).toBeVisible({ timeout: 30_000 });
-      await expectNoTruncation(isolationPopup);
-      await page.getByTestId("workspace-create-isolation-worktree").click();
-      await expectWorkspaceIsolationSelected(page, "worktree");
-
-      await openStartingRefPicker(page);
-      await selectBranchInPicker(page, "dev");
-
-      const createButton = page
-        .getByTestId("message-input-root")
-        .getByRole("button", { name: "Create" });
-      await expect(createButton).toBeVisible({ timeout: 30_000 });
-      await createButton.click();
-
-      const createdWorkspace = await assertNewWorkspaceSidebarAndHeader(page, {
-        serverId,
-        client,
-        previousWorkspaceId: openedProject.workspaceId,
-        projectDisplayName: openedProject.projectDisplayName,
-      });
-      createdWorktreeDirectories.add(createdWorkspace.workspaceDirectory);
-
-      // Second visit (fresh mount of /new): the worktree choice must stick.
-      await openNewWorkspaceComposer(page, {
-        projectKey: openedProject.projectKey,
-        projectDisplayName: openedProject.projectDisplayName,
-      });
-      await expectWorkspaceIsolationSelected(page, "worktree");
-    } finally {
-      await tempRepo.cleanup();
-    }
-  });
-});
@@ -1,86 +0,0 @@
-import { expect, test } from "../support/fixtures";
-import { gotoAppShell } from "../support/helpers/app";
-import { waitForSidebarHydration } from "../support/helpers/workspace-ui";
-import {
-  expectNewWorkspaceDraft,
-  fillNewWorkspaceDraft,
-  openNewWorkspaceComposer,
-} from "../support/helpers/new-workspace";
-import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
-import {
-  attachButton,
-  expectChatComposerActive,
-  expectTerminalComposerActive,
-  fillTerminalPrompt,
-  seedTerminalProfiles,
-  selectChatLaunch,
-  selectLaunchOption,
-  terminalPromptInput,
-  type TerminalProfile,
-  type TerminalProfileSeed,
-} from "../support/helpers/new-workspace-launch";
-
-const PROFILE: TerminalProfile = {
-  id: "e2e-composer-profile",
-  name: "Composer Profile",
-  command: "/bin/echo",
-  args: ["{{{prompt}}}"],
-};
-
-test.describe("New workspace: the composer is one control in two modes", () => {
-  let workspace: SeededWorkspace;
-  let profileSeed: TerminalProfileSeed;
-
-  test.beforeEach(async () => {
-    workspace = await seedWorkspace({ repoPrefix: "launch-composer-" });
-    profileSeed = await seedTerminalProfiles([PROFILE]);
-  });
-
-  test.afterEach(async () => {
-    await profileSeed.restore();
-    await workspace?.cleanup();
-  });
-
-  test("switching launch target does not leak draft text between chat and terminal, and drops the chat-only controls", async ({
-    page,
-  }) => {
-    test.setTimeout(60_000);
-    await gotoAppShell(page);
-    await waitForSidebarHydration(page);
-
-    await openNewWorkspaceComposer(page, {
-      projectKey: workspace.projectKey,
-      projectDisplayName: workspace.projectDisplayName,
-    });
-
-    await test.step("a chat draft does not leak into the terminal prompt", async () => {
-      await fillNewWorkspaceDraft(page, "a chat-only draft");
-      await selectLaunchOption(page, PROFILE.id);
-      await expectTerminalComposerActive(page);
-      await expect(terminalPromptInput(page)).toHaveValue("");
-    });
-
-    await test.step("the attachment button and mic are absent in terminal mode, and the submit button is inside the same surface", async () => {
-      await expect(attachButton(page)).toHaveCount(0);
-      await expect(page.getByRole("button", { name: "Start dictation" })).toHaveCount(0);
-      await expect(
-        page.locator('[data-testid="message-input-root"]:visible').getByRole("button", {
-          name: "Launch",
-        }),
-      ).toBeVisible();
-    });
-
-    await test.step("a terminal draft does not leak back into chat, which keeps its own draft", async () => {
-      await fillTerminalPrompt(page, "a terminal-only draft");
-      await selectChatLaunch(page);
-      await expectChatComposerActive(page);
-      await expectNewWorkspaceDraft(page, "a chat-only draft");
-    });
-
-    await test.step("each side keeps its own draft across toggles, without either leaking into the other", async () => {
-      await selectLaunchOption(page, PROFILE.id);
-      await expectTerminalComposerActive(page);
-      await expect(terminalPromptInput(page)).toHaveValue("a terminal-only draft");
-    });
-  });
-});
@@ -1,103 +0,0 @@
-import { test } from "../support/fixtures";
-import { gotoAppShell } from "../support/helpers/app";
-import { waitForSidebarHydration } from "../support/helpers/workspace-ui";
-import {
-  openNewWorkspaceComposer,
-  submitNewWorkspacePrompt,
-} from "../support/helpers/new-workspace";
-import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
-import {
-  expectChatLaunchSelected,
-  expectTerminalLaunchSelected,
-  expectTerminalOutputContains,
-  expectWorkspaceOpensWithTerminalTab,
-  fillTerminalPrompt,
-  patchTerminalProfiles,
-  seedTerminalProfiles,
-  selectChatLaunch,
-  selectLaunchOption,
-  submitTerminalLaunch,
-  type TerminalProfile,
-  type TerminalProfileSeed,
-} from "../support/helpers/new-workspace-launch";
-
-// Wait for input until project cleanup kills the terminal. A fixed lifetime
-// can expire before a busy browser attaches or finishes revisiting the composer.
-const PROMPT_PROFILE: TerminalProfile = {
-  id: "e2e-memory-profile",
-  name: "Memory Profile",
-  command: "/bin/sh",
-  args: ["-c", 'echo remembered: "$0"; exec cat', "{{{prompt}}}"],
-};
-
-function hasLeftNewWorkspaceRoute(url: URL): boolean {
-  return !/\/new(?:\?.*)?$/.test(`${url.pathname}${url.search}`);
-}
-
-test.describe("New workspace: launch target memory", () => {
-  let workspace: SeededWorkspace;
-  let profileSeed: TerminalProfileSeed;
-
-  test.beforeEach(async () => {
-    workspace = await seedWorkspace({ repoPrefix: "launch-memory-" });
-    profileSeed = await seedTerminalProfiles([PROMPT_PROFILE]);
-  });
-
-  test.afterEach(async () => {
-    await profileSeed.restore();
-    await workspace?.cleanup();
-  });
-
-  test("remembers the launch target across visits, and a removed profile falls back to chat instead of a dead entry", async ({
-    page,
-  }) => {
-    test.setTimeout(90_000);
-    await gotoAppShell(page);
-    await waitForSidebarHydration(page);
-
-    const openNewWorkspace = () =>
-      openNewWorkspaceComposer(page, {
-        projectKey: workspace.projectKey,
-        projectDisplayName: workspace.projectDisplayName,
-      });
-
-    await test.step("launching a terminal profile preselects it the next time New workspace opens", async () => {
-      await openNewWorkspace();
-      await selectLaunchOption(page, PROMPT_PROFILE.id);
-      await expectTerminalLaunchSelected(page, PROMPT_PROFILE.name);
-      await fillTerminalPrompt(page, "remember me");
-      await submitTerminalLaunch(page);
-      await expectWorkspaceOpensWithTerminalTab(page);
-      await expectTerminalOutputContains(page, "remembered: remember me");
-
-      await openNewWorkspace();
-      await expectTerminalLaunchSelected(page, PROMPT_PROFILE.name);
-    });
-
-    await test.step("switching to Chat and submitting preselects Chat the next time", async () => {
-      await selectChatLaunch(page);
-      await expectChatLaunchSelected(page);
-      await submitNewWorkspacePrompt(page, "hello from chat");
-      // The chat handoff navigates asynchronously (draft -> created agent). Let
-      // it fully settle before moving on, so it can't fire a late redirect
-      // that races the next step's navigation.
-      await page.waitForURL(hasLeftNewWorkspaceRoute, { timeout: 30_000 });
-
-      await openNewWorkspace();
-      await expectChatLaunchSelected(page);
-    });
-
-    await test.step("re-selecting the terminal profile, then removing it daemon-side, falls back to Chat rather than a dead entry", async () => {
-      await selectLaunchOption(page, PROMPT_PROFILE.id);
-      await expectTerminalLaunchSelected(page, PROMPT_PROFILE.name);
-      await fillTerminalPrompt(page, "second run");
-      await submitTerminalLaunch(page);
-      await expectWorkspaceOpensWithTerminalTab(page);
-
-      await patchTerminalProfiles([]);
-
-      await openNewWorkspace();
-      await expectChatLaunchSelected(page);
-    });
-  });
-});
@@ -5,6 +5,7 @@ import {
  expectNewWorkspaceDraft,
  fillNewWorkspaceDraft,
  openNewWorkspaceComposer,
+  submitNewWorkspacePrompt,
 } from "../support/helpers/new-workspace";
 import {
  composerLocator,
@@ -15,6 +16,12 @@ import {
 } from "../support/helpers/composer";
 import { seedWorkspace, type SeededWorkspace } from "../support/helpers/seed-client";
 import {
+  attachButton,
+  expectChatComposerActive,
+  expectTerminalComposerActive,
+  expectChatLaunchSelected,
+  patchTerminalProfiles,
+  selectChatLaunch,
  expectTerminalLaunchSelected,
  expectTerminalOutputContains,
  expectTerminalPreviewCommand,
@@ -67,21 +74,50 @@ test.describe("New workspace: launching a terminal", () => {
    await workspace?.cleanup();
  });

-  test("a profile that takes a prompt launches with it as its trailing argument; a profile without the sentinel launches bare from Launch", async ({
+  test("switch launch modes, run prompt and bare profiles, and remember successful targets", async ({
    page,
  }) => {
    test.setTimeout(90_000);
    await gotoAppShell(page);
    await waitForSidebarHydration(page);

-    await test.step("pick a profile that takes a prompt, type one, and submit", async () => {
+    await test.step("open New workspace to choose a launch target", async () => {
      await openNewWorkspaceComposer(page, {
        projectKey: workspace.projectKey,
        projectDisplayName: workspace.projectDisplayName,
      });
+    });
+    await test.step("a chat draft does not leak into the terminal prompt", async () => {
+      await fillNewWorkspaceDraft(page, "a chat-only draft");
      await selectLaunchOption(page, PROMPT_PROFILE.id);
-      await expectTerminalLaunchSelected(page, PROMPT_PROFILE.name);
+      await expectTerminalComposerActive(page);
+      await expect(terminalPromptInput(page)).toHaveValue("");
+    });

+    await test.step("the attachment button and mic are absent in terminal mode, and the submit button is inside the same surface", async () => {
+      await expect(attachButton(page)).toHaveCount(0);
+      await expect(page.getByRole("button", { name: "Start dictation" })).toHaveCount(0);
+      await expect(
+        page.locator('[data-testid="message-input-root"]:visible').getByRole("button", {
+          name: "Launch",
+        }),
+      ).toBeVisible();
+    });
+
+    await test.step("a terminal draft does not leak back into chat, which keeps its own draft", async () => {
+      await fillTerminalPrompt(page, "a terminal-only draft");
+      await selectChatLaunch(page);
+      await expectChatComposerActive(page);
+      await expectNewWorkspaceDraft(page, "a chat-only draft");
+    });
+
+    await test.step("each side keeps its own draft across toggles, without either leaking into the other", async () => {
+      await selectLaunchOption(page, PROMPT_PROFILE.id);
+      await expectTerminalComposerActive(page);
+      await expect(terminalPromptInput(page)).toHaveValue("a terminal-only draft");
+    });
+    await test.step("submit the prompt profile", async () => {
+      await expectTerminalLaunchSelected(page, PROMPT_PROFILE.name);
      await fillTerminalPrompt(page, "fix the flaky test");
      await submitTerminalLaunch(page);
    });
@@ -96,6 +132,7 @@ test.describe("New workspace: launching a terminal", () => {
        projectKey: workspace.projectKey,
        projectDisplayName: workspace.projectDisplayName,
      });
+      await expectTerminalLaunchSelected(page, PROMPT_PROFILE.name);
      await selectLaunchOption(page, BARE_PROFILE.id);
      await expect(terminalPromptInput(page)).toHaveCount(0);
      await expectTerminalPreviewCommand(page, "/bin/sh -c echo bare-launch-static-line; exec cat");
@@ -107,6 +144,31 @@ test.describe("New workspace: launching a terminal", () => {
      await expectWorkspaceOpensWithTerminalTab(page);
      await expectTerminalOutputContains(page, "bare-launch-static-line");
    });
+    await test.step("successful launches remember their target across visits", async () => {
+      await openNewWorkspaceComposer(page, workspace);
+      await expectTerminalLaunchSelected(page, BARE_PROFILE.name);
+      await selectChatLaunch(page);
+      await expectChatLaunchSelected(page);
+      await submitNewWorkspacePrompt(page, "hello from chat");
+      await page.waitForURL(hasLeftNewWorkspaceRoute, {
+        timeout: 30_000,
+      });
+      await openNewWorkspaceComposer(page, workspace);
+      await expectChatLaunchSelected(page);
+    });
+    await test.step("a removed remembered terminal profile falls back to Chat", async () => {
+      await selectLaunchOption(page, PROMPT_PROFILE.id);
+      await fillTerminalPrompt(page, "second run");
+      await submitTerminalLaunch(page);
+      await expectWorkspaceOpensWithTerminalTab(page);
+      try {
+        await patchTerminalProfiles([]);
+        await openNewWorkspaceComposer(page, workspace);
+        await expectChatLaunchSelected(page);
+      } finally {
+        await patchTerminalProfiles([PROMPT_PROFILE, BARE_PROFILE]);
+      }
+    });
  });

  test("switching terminal profiles restores the prompt and its fullscreen affordance", async ({
@@ -157,6 +219,10 @@ test.describe("New workspace: launching a terminal", () => {
  });
 });

+function hasLeftNewWorkspaceRoute(url: URL): boolean {
+  return !/\/new(?:\?.*)?$/.test(`${url.pathname}${url.search}`);
+}
+
 async function expectNewWorkspaceHeaderHidden(page: Page): Promise<void> {
  await expect(page.getByTestId("menu-button").filter({ visible: true })).toHaveCount(0);
 }
@@ -172,7 +172,9 @@ test.describe("New workspace preselects the open workspace's project", () => {
    await projectB?.cleanup();
  });

-  test("Cmd+N preselects the project you are looking at", async ({ page }) => {
+  test("workspace button and shortcut follow the active project across visits", async ({
+    page,
+  }) => {
    await gotoAppShell(page);
    await waitForSidebarHydration(page);

@@ -183,6 +185,15 @@ test.describe("New workspace preselects the open workspace's project", () => {
    });
    await pressNewWorkspaceShortcut(page);
    await expectNewWorkspaceProjectSelected(page, projectB.projectDisplayName);
+    await switchWorkspaceViaSidebar({
+      page,
+      serverId: getServerId(),
+      workspaceId: projectB.workspaceId,
+    });
+    await test.step("global button follows project B", async () => {
+      await openGlobalNewWorkspaceComposer(page);
+      await expectNewWorkspaceProjectSelected(page, projectB.projectDisplayName);
+    });

    await switchWorkspaceViaSidebar({
      page,
@@ -191,27 +202,15 @@ test.describe("New workspace preselects the open workspace's project", () => {
    });
    await pressNewWorkspaceShortcut(page);
    await expectNewWorkspaceProjectSelected(page, projectA.projectDisplayName);
-  });
-
-  test("New workspace button preselects the project you are looking at", async ({ page }) => {
-    await gotoAppShell(page);
-    await waitForSidebarHydration(page);
-
-    await switchWorkspaceViaSidebar({
-      page,
-      serverId: getServerId(),
-      workspaceId: projectB.workspaceId,
-    });
-    await openGlobalNewWorkspaceComposer(page);
-    await expectNewWorkspaceProjectSelected(page, projectB.projectDisplayName);
-
    await switchWorkspaceViaSidebar({
      page,
      serverId: getServerId(),
      workspaceId: projectA.workspaceId,
    });
-    await openGlobalNewWorkspaceComposer(page);
-    await expectNewWorkspaceProjectSelected(page, projectA.projectDisplayName);
+    await test.step("global button follows project A", async () => {
+      await openGlobalNewWorkspaceComposer(page);
+      await expectNewWorkspaceProjectSelected(page, projectA.projectDisplayName);
+    });
  });

  test("Cmd+N preselects the connected host project when an offline saved host is first", async ({
@@ -1,3 +1,4 @@
+import { expectNoTruncation } from "../support/helpers/no-truncation";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { buildHostWorkspaceRoute } from "@/utils/host-routes";
@@ -33,6 +34,7 @@ import {
  selectGitHubPrInPicker,
  selectPickerOptionByKeyboard,
  selectWorkspaceIsolation,
+  expectWorkspaceIsolationSelected,
  submitNewWorkspacePrompt,
 } from "../support/helpers/new-workspace";
 import {
@@ -723,9 +725,26 @@ test.describe("New workspace flow", () => {
        projectKey: openedProject.projectKey,
        projectDisplayName: openedProject.projectDisplayName,
      });
-      await selectWorkspaceIsolation(page, "worktree");
-      await openStartingRefPicker(page);
-      await selectBranchInPicker(page, "dev");
+      await expectWorkspaceIsolationSelected(page, "local");
+      await page.getByTestId("workspace-create-isolation-trigger").click();
+      const isolationPopup = page.getByTestId("combobox-desktop-container").last();
+      await expect(isolationPopup).toBeVisible({ timeout: 30_000 });
+      await expectNoTruncation(isolationPopup);
+      await page.getByTestId("workspace-create-isolation-worktree").click();
+      await expectWorkspaceIsolationSelected(page, "worktree");
+      await test.step("cancel the branch picker without changing the selection", async () => {
+        await openBranchPicker(page);
+        await expectPickerOpen(page);
+        await closeBranchPicker(page);
+        await expectPickerClosed(page);
+      });
+      await test.step("select the filtered starting branch with the keyboard", async () => {
+        await openBranchPicker(page);
+        await expectPickerOpen(page);
+        await selectPickerOptionByKeyboard(page, "dev");
+        await expectPickerSelected(page, "dev");
+        await expectPickerClosed(page);
+      });

      const createButton = page
        .getByTestId("message-input-root")
@@ -749,6 +768,10 @@ test.describe("New workspace flow", () => {
      expect(branchInfo.currentBranch).toBe(path.basename(createdWorkspace.workspaceDirectory));
      expect(branchInfo.hasAncestor(tempRepo.branchHeads.main)).toBe(true);
      expect(branchInfo.hasAncestor(tempRepo.branchHeads.dev)).toBe(true);
+      await test.step("the worktree choice survives creating and reopening New workspace", async () => {
+        await openNewWorkspaceComposer(page, openedProject);
+        await expectWorkspaceIsolationSelected(page, "worktree");
+      });
    } finally {
      await tempRepo.cleanup();
    }
@@ -890,57 +913,6 @@ test.describe("New workspace flow", () => {
    });
  });

-  test("branch picker opens via keyboard and selects the filtered option on Enter", async ({
-    page,
-  }) => {
-    const tempRepo = await createTempGitRepo("picker-keyboard-", { branches: ["main", "dev"] });
-
-    try {
-      const openedProject = await openProjectViaDaemon(client, tempRepo.path);
-      localWorkspaceIds.add(openedProject.workspaceId);
-
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-      await openNewWorkspaceComposer(page, {
-        projectKey: openedProject.projectKey,
-        projectDisplayName: openedProject.projectDisplayName,
-      });
-      await selectWorkspaceIsolation(page, "worktree");
-
-      await openBranchPicker(page);
-      await expectPickerOpen(page);
-      await selectPickerOptionByKeyboard(page, "dev");
-      await expectPickerSelected(page, "dev");
-      await expectPickerClosed(page);
-    } finally {
-      await tempRepo.cleanup();
-    }
-  });
-
-  test("branch picker closes on Escape without selecting an option", async ({ page }) => {
-    const tempRepo = await createTempGitRepo("picker-escape-");
-
-    try {
-      const openedProject = await openProjectViaDaemon(client, tempRepo.path);
-      localWorkspaceIds.add(openedProject.workspaceId);
-
-      await gotoAppShell(page);
-      await waitForSidebarHydration(page);
-      await openNewWorkspaceComposer(page, {
-        projectKey: openedProject.projectKey,
-        projectDisplayName: openedProject.projectDisplayName,
-      });
-      await selectWorkspaceIsolation(page, "worktree");
-
-      await openBranchPicker(page);
-      await expectPickerOpen(page);
-      await closeBranchPicker(page);
-      await expectPickerClosed(page);
-    } finally {
-      await tempRepo.cleanup();
-    }
-  });
-
  test("selected GitHub PR shows PR context in the trigger and composer", async ({ page }) => {
    test.skip(!hasGithubAuth(), "Requires GitHub authentication (gh auth login)");

@@ -226,10 +226,19 @@ test.describe("narrow touch browser", () => {
    await source(page).press("ControlOrMeta+f");
    await expect(query(page)).toBeFocused();
    await query(page).fill("needle");
-    await page.getByRole("button", { name: "Next match" }).tap();
-    await expect(status(page)).toHaveText("2 of 2");
-    await expectFindInsidePane(page);
-    await page.screenshot({ path: testInfo.outputPath("touch-find.png") });
+    await test.step("reveal the first match below the floating Find widget", async () => {
+      await expect(status(page)).toHaveText("1 of 2");
+      await expectActiveMatchUncovered(page);
+    });
+    await test.step("tap the next uncovered match while controls stay inside the pane", async () => {
+      await page.getByRole("button", { name: "Next match" }).tap();
+      await expect(status(page)).toHaveText("2 of 2");
+      await expectActiveMatchUncovered(page);
+      await expectFindInsidePane(page);
+      await page.screenshot({ path: testInfo.outputPath("touch-find.png") });
+      await page.screenshot({ path: testInfo.outputPath("touch-match-uncovered.png") });
+      await expect(query(page)).toHaveValue("needle");
+    });
    await page.getByRole("button", { name: "Close Find" }).tap();
    await expect(source(page)).toBeFocused();
  });
@@ -332,33 +341,6 @@ for (const startingField of ["Find in pane", "Replace with"] as const) {
 }

 test.describe("the active match stays visible under the floating widget", () => {
-  test.describe("narrow touch browser", () => {
-    test.use({ hasTouch: true });
-    test("reveals a short file's match that the widget would cover", async ({
-      page,
-      withWorkspace,
-    }, testInfo) => {
-      const workspace = await withWorkspace({ prefix: "pane-find-cover-touch-" });
-      await writeFile(path.join(workspace.repoPath, "touch.txt"), "touch needle\nnext needle\n");
-      await workspace.navigateTo();
-      await openSource(page, "touch.txt");
-      await page.setViewportSize({ width: 390, height: 844 });
-      await source(page).focus();
-      await source(page).press("ControlOrMeta+f");
-      await expect(query(page)).toBeFocused();
-      await query(page).fill("needle");
-      await expect(status(page)).toHaveText("1 of 2");
-      await expectActiveMatchUncovered(page);
-      await page.getByRole("button", { name: "Next match" }).tap();
-      await expect(status(page)).toHaveText("2 of 2");
-      await expectActiveMatchUncovered(page);
-      await page.screenshot({ path: testInfo.outputPath("touch-match-uncovered.png") });
-      await expect(query(page)).toHaveValue("needle");
-      await page.getByRole("button", { name: "Close Find" }).tap();
-      await expect(source(page)).toBeFocused();
-    });
-  });
-
  test("reveals a match beneath the top-right widget in a narrow desktop pane", async ({
    page,
    withWorkspace,
@@ -749,7 +749,6 @@ function observePluginReload(page: Page) {
  return {
    waitForRequest: () => expect.poll(() => requests.length, { timeout: 30_000 }).toBe(1),
    waitForResponse: () => expect.poll(() => responses.length, { timeout: 120_000 }).toBe(1),
-    requestedAt: () => requests[0]!,
    requestCount: () => requests.length,
  };
 }
@@ -814,12 +813,6 @@ async function capturePluginSurface(page: Page, testInfo: TestInfo, name: string
  });
 }

-/** The wait under test is the daemon's lifecycle queue, so the scenario has to spend real time. */
-async function waitPastFormerReloadDeadline(page: Page, requestedAt: number): Promise<void> {
-  const remaining = 66_000 - (Date.now() - requestedAt);
-  if (remaining > 0) await page.waitForTimeout(remaining);
-}
-
 test("keeps Reload pending past a minute while the plugin queue is busy", async ({
  page,
  pluginEnvironment,
@@ -833,6 +826,9 @@ test("keeps Reload pending past a minute while the plugin queue is busy", async
    "Plugin v1",
  );

+  // Advance the real browser client's RPC timers while the daemon's build gate
+  // remains held on its own clock.
+  await page.clock.install();
  // Observe before the app loads: its daemon socket comes up with the page.
  const reload = observePluginReload(page);
  await gotoAppShell(page);
@@ -851,7 +847,7 @@ test("keeps Reload pending past a minute while the plugin queue is busy", async
    await expectPluginRowPending(page, "e2e-plugin");
    await capturePluginSurface(page, testInfo, "plugin-reload-pending.png");

-    await waitPastFormerReloadDeadline(page, reload.requestedAt());
+    await page.clock.fastForward(66_000);

    // Past the former deadline the reload is still pending, the row shows its previous state, and
    // no timeout error reached the surface.
@@ -316,7 +316,9 @@ test.describe("Sidebar workspace list", () => {
    }
  });

-  test("project with GitHub remote shows its selected folder name in sidebar", async ({ page }) => {
+  test("opens a GitHub-backed workspace with folder metadata and pointer and keyboard hover cards", async ({
+    page,
+  }) => {
    const workspace = await seedWorkspace({
      repoPrefix: "sidebar-remote-",
      repo: { withRemote: true, originUrl: GITHUB_REMOTE_URL },
@@ -335,6 +337,46 @@ test.describe("Sidebar workspace list", () => {

      await expect(projectRow).toBeVisible({ timeout: 30_000 });
      await expect(projectRow).not.toContainText("test-owner/test-repo");
+      expect(workspace.workspaceName).toBe("main");
+      const row = await waitForSidebarWorkspace(page, workspace.workspaceId);
+      await expect(row).toContainText("main");
+
+      await test.step("inspect host metadata before opening the workspace", async () => {
+        const hoverCard = await openWorkspaceHoverCard(page, workspace.workspaceId);
+        await expect(page.getByTestId("hover-card-workspace-host")).toHaveText("localhost");
+        await expect(hoverCard).not.toContainText(/\b(Online|Connecting|Offline|Error|Idle)\b/);
+      });
+
+      await test.step("open the workspace and inspect its selected folder header", async () => {
+        await openWorkspaceFromSidebar(page, workspace.workspaceId);
+        await expectWorkspaceHeader(page, {
+          title: workspace.workspaceName,
+          subtitle: projectName,
+        });
+        await movePointerAwayFromWorkspaceHoverCard(page);
+        await expectWorkspaceHoverCardClosed(page);
+      });
+
+      await test.step("dismiss a clicked row's hover card when the pointer leaves", async () => {
+        await row.click();
+        await expect(row).toBeFocused();
+        await expectWorkspaceHoverCardOpen(page);
+        await movePointerAwayFromWorkspaceHoverCard(page);
+        await expectWorkspaceHoverCardClosed(page);
+      });
+
+      await test.step("retain keyboard preview until Escape or focus leaves the row", async () => {
+        await focusWorkspaceRowWithKeyboard(page, workspace.workspaceId);
+        await expectWorkspaceHoverCardOpen(page);
+        await movePointerAwayFromWorkspaceHoverCard(page);
+        await expectWorkspaceHoverCardStaysOpen(page);
+        await page.keyboard.press("Escape");
+        await expectWorkspaceHoverCardClosed(page);
+        await focusWorkspaceRowWithKeyboard(page, workspace.workspaceId);
+        await expectWorkspaceHoverCardOpen(page);
+        await page.keyboard.press("Tab");
+        await expectWorkspaceHoverCardClosed(page);
+      });
    } finally {
      await workspace.cleanup();
    }
@@ -354,107 +396,6 @@ test.describe("Sidebar workspace list", () => {
    }
  });

-  test("workspace header uses the selected folder name instead of its GitHub remote", async ({
-    page,
-  }) => {
-    const workspace = await seedWorkspace({
-      repoPrefix: "sidebar-header-",
-      repo: { withRemote: true, originUrl: GITHUB_REMOTE_URL },
-    });
-
-    try {
-      const projectName = path.basename(workspace.repoPath);
-      await gotoAppShell(page);
-      await waitForSidebarProject(page, projectName);
-      await waitForSidebarWorkspace(page, workspace.workspaceId);
-      await openWorkspaceFromSidebar(page, workspace.workspaceId);
-
-      await expectWorkspaceHeader(page, {
-        title: workspace.workspaceName,
-        subtitle: projectName,
-      });
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("git project shows branch name in workspace row", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "sidebar-branch-" });
-
-    try {
-      await gotoAppShell(page);
-      await waitForSidebarProject(page, path.basename(workspace.repoPath));
-
-      expect(workspace.workspaceName).toBe("main");
-      await expect(await waitForSidebarWorkspace(page, workspace.workspaceId)).toContainText(
-        "main",
-      );
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("workspace hover card shows host as metadata", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "sidebar-hover-host-" });
-
-    try {
-      await gotoAppShell(page);
-      await waitForSidebarProject(page, path.basename(workspace.repoPath));
-
-      const hoverCard = await openWorkspaceHoverCard(page, workspace.workspaceId);
-      await expect(page.getByTestId("hover-card-workspace-host")).toHaveText("localhost");
-      await expect(hoverCard).not.toContainText(/\b(Online|Connecting|Offline|Error|Idle)\b/);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("workspace hover card closes when the pointer leaves a clicked row", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "sidebar-hover-click-leave-" });
-
-    try {
-      await gotoAppShell(page);
-      await waitForSidebarProject(page, path.basename(workspace.repoPath));
-      const row = await openWorkspaceFromSidebar(page, workspace.workspaceId);
-      await movePointerAwayFromWorkspaceHoverCard(page);
-      await expectWorkspaceHoverCardClosed(page);
-
-      await row.click();
-      await expect(row).toBeFocused();
-      await expectWorkspaceHoverCardOpen(page);
-      await movePointerAwayFromWorkspaceHoverCard(page);
-      await expectWorkspaceHoverCardClosed(page);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("workspace hover card follows keyboard focus on a row", async ({ page }) => {
-    const workspace = await seedWorkspace({ repoPrefix: "sidebar-hover-keyboard-" });
-
-    try {
-      await gotoAppShell(page);
-      await waitForSidebarProject(page, path.basename(workspace.repoPath));
-      await openWorkspaceFromSidebar(page, workspace.workspaceId);
-      await movePointerAwayFromWorkspaceHoverCard(page);
-      await expectWorkspaceHoverCardClosed(page);
-
-      await focusWorkspaceRowWithKeyboard(page, workspace.workspaceId);
-      await expectWorkspaceHoverCardOpen(page);
-      await movePointerAwayFromWorkspaceHoverCard(page);
-      await expectWorkspaceHoverCardStaysOpen(page);
-      await page.keyboard.press("Escape");
-      await expectWorkspaceHoverCardClosed(page);
-
-      await focusWorkspaceRowWithKeyboard(page, workspace.workspaceId);
-      await expectWorkspaceHoverCardOpen(page);
-      await page.keyboard.press("Tab");
-      await expectWorkspaceHoverCardClosed(page);
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
  test("marks a finished workspace unread until it is opened again", async ({ page }) => {
    const workspace = await seedMockAgentWorkspace({
      repoPrefix: "sidebar-mark-unread-",
@@ -495,26 +436,21 @@ test.describe("Sidebar workspace list", () => {
 test.describe("Mobile sidebar panelState transition", () => {
  test.use({ viewport: { width: 390, height: 844 } });

-  test("showMobileAgent open and close transition", async ({ page }) => {
+  test("opens mobile navigation beside the close button and closes it again", async ({ page }) => {
    await gotoAppShell(page);
    await expectMobileAgentSidebarHidden(page);
    await openMobileAgentSidebar(page);
    await expectMobileAgentSidebarVisible(page);
+    await test.step("place the close button beside the first navigation row", async () => {
+      const firstRow = await page.getByTestId("sidebar-global-new-workspace").boundingBox();
+      const closeButton = await page.getByTestId("sidebar-close").boundingBox();
+      if (!firstRow || !closeButton) throw new Error("first nav row and close button must render");
+      expect(closeButton.x).toBeGreaterThanOrEqual(firstRow.x + firstRow.width);
+    });
    await closeMobileAgentSidebar(page);
    await expectMobileAgentSidebarHidden(page);
  });

-  test("places the close button beside the first nav row instead of over it", async ({ page }) => {
-    await gotoAppShell(page);
-    await openMobileAgentSidebar(page);
-    await expectMobileAgentSidebarVisible(page);
-
-    const firstRow = await page.getByTestId("sidebar-global-new-workspace").boundingBox();
-    const closeButton = await page.getByTestId("sidebar-close").boundingBox();
-    if (!firstRow || !closeButton) throw new Error("first nav row and close button must render");
-    expect(closeButton.x).toBeGreaterThanOrEqual(firstRow.x + firstRow.width);
-  });
-
  test("keeps a pinned workspace rendered while the retained sidebar is closed", async ({
    page,
  }) => {
@@ -587,15 +523,14 @@ test.describe("Half-screen desktop layout", () => {
    }
  });

-  test("keeps the pinned sidebar at half of a 14-inch Mac display", async ({ page }) => {
-    await gotoAppShell(page);
-    await expect(page.getByTestId("sidebar-global-new-workspace")).toBeVisible();
-    await expect(page.getByTestId("agent-list-backdrop")).not.toBeVisible();
-  });
-
  test("keeps the left toggle center-owned without left window controls", async ({ page }) => {
    await gotoAppShell(page);

+    await test.step("start with pinned navigation at half of a 14-inch Mac display", async () => {
+      await expect(page.getByTestId("sidebar-global-new-workspace")).toBeVisible();
+      await expect(page.getByTestId("agent-list-backdrop")).not.toBeVisible();
+    });
+
    const openToggle = page.getByTestId("menu-button");
    const openIcon = openToggle.locator("svg").first();
    await expect(openIcon).toBeVisible();
@@ -1,6 +1,7 @@
 import { expect, type Page } from "@playwright/test";
 import { buildHostAgentDetailRoute } from "@/utils/host-routes";
 import { test } from "../support/fixtures";
+import { createControlledStream } from "../support/helpers/controlled-stream";
 import { seedWorkspace, type SeedDaemonClient } from "../support/helpers/seed-client";
 import { getServerId } from "../support/helpers/server-id";
 import { observeTimelineSubscriptions } from "../support/helpers/timeline-delivery";
@@ -27,31 +28,46 @@ interface ViewedTimelineScenario {
  cleanup(): Promise<void>;
 }

+type ViewedAgentConfig = Pick<
+  Parameters<SeedDaemonClient["createAgent"]>[0],
+  "provider" | "modeId" | "model"
+>;
+
 async function seedViewedTimelineScenario(
-  options: { firstAgentModel?: string } = {},
+  options: { firstAgent?: ViewedAgentConfig } = {},
 ): Promise<ViewedTimelineScenario> {
  const workspace = await seedWorkspace({ repoPrefix: "viewed-timelines-" });
-  const createAgent = (title: string, model = "ten-second-stream") =>
-    workspace.client.createAgent({
+  const createAgent = (
+    title: string,
+    config: ViewedAgentConfig = {
      provider: "mock",
+      modeId: "load-test",
+      model: "e2e-fast-stream",
+    },
+  ) =>
+    workspace.client.createAgent({
+      ...config,
      cwd: workspace.repoPath,
      workspaceId: workspace.workspaceId,
      title,
-      modeId: "load-test",
-      model,
    });
-  const [firstAgent, secondAgent] = await Promise.all([
-    createAgent("First viewed chat", options.firstAgentModel),
-    createAgent("Second viewed chat"),
-  ]);
-  return {
-    client: workspace.client,
-    workspaceId: workspace.workspaceId,
-    repoPath: workspace.repoPath,
-    firstAgentId: firstAgent.id,
-    secondAgentId: secondAgent.id,
-    cleanup: workspace.cleanup,
-  };
+  try {
+    const [firstAgent, secondAgent] = await Promise.all([
+      createAgent("First viewed chat", options.firstAgent),
+      createAgent("Second viewed chat"),
+    ]);
+    return {
+      client: workspace.client,
+      workspaceId: workspace.workspaceId,
+      repoPath: workspace.repoPath,
+      firstAgentId: firstAgent.id,
+      secondAgentId: secondAgent.id,
+      cleanup: workspace.cleanup,
+    };
+  } catch (error) {
+    await workspace.cleanup();
+    throw error;
+  }
 }

 interface RestoredLayoutChat {
@@ -306,19 +322,39 @@ test.describe("Viewed agent timelines", () => {
  }) => {
    test.setTimeout(150_000);
    const subscriptions = observeTimelineSubscriptions(page);
-    const scenario = await seedViewedTimelineScenario({ firstAgentModel: "one-minute-stream" });
+    const stream = await createControlledStream();
+    const scenario = await seedViewedTimelineScenario({
+      firstAgent: { provider: stream.provider },
+    }).catch(async (error) => {
+      await stream.cleanup();
+      throw error;
+    });
    try {
      await openAgent(page, scenario, scenario.firstAgentId);
      await startVisibleTurn(page, scenario, "Finish after this chat becomes hidden.");
+      await stream.append(["The first chat is still producing output."]);
+      await expect(
+        page.getByText("The first chat is still producing output.", { exact: true }),
+      ).toBeVisible();
      await selectAgent(page, "Second viewed chat");
      await subscriptions.waitForSubscribedAgents([scenario.firstAgentId, scenario.secondAgentId]);
-      const finish = await scenario.client.waitForFinish(scenario.firstAgentId, 90_000);
+      const agents = await scenario.client.fetchAgents();
+      expect(
+        agents.entries.find((entry) => entry.agent.id === scenario.firstAgentId)?.agent.status,
+      ).toBe("running");
+      await stream.finish([" Completed while hidden."]);
+      const finish = await scenario.client.waitForFinish(scenario.firstAgentId, 30_000);
      expect(finish.status).toBe("idle");

      await selectAgent(page, "First viewed chat");
      await expectAgentConsistentlyIdle(page, "First viewed chat");
+      await expect(page.getByText("Completed while hidden.", { exact: false })).toBeVisible();
    } finally {
-      await scenario.cleanup();
+      try {
+        await stream.cleanup();
+      } finally {
+        await scenario.cleanup();
+      }
    }
  });

@@ -0,0 +1,79 @@
+import { defineRpc } from "@getpaseo/plugin";
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { runAcpProvider, type AcpStreamMessage } from "@getpaseo/plugin/server/acp";
+import { z } from "zod";
+
+/** A single-turn producer controlled through the daemon, before timeline persistence. */
+export default function contribute(server: PluginServerContext) {
+  let startTurn!: (append: (chunks: string[], finish: boolean) => void) => void;
+  const turn = new Promise<(chunks: string[], finish: boolean) => void>((resolve) => {
+    startTurn = resolve;
+  });
+  server.handle(
+    defineRpc({
+      name: "append",
+      input: z.object({ chunks: z.array(z.string()), finish: z.boolean() }),
+      output: z.null(),
+    }),
+    async ({ chunks, finish }) => {
+      const append = await turn;
+      append(chunks, finish);
+      return null;
+    },
+  );
+  server.registerProvider(
+    runAcpProvider({ id: "controlled-stream", label: "Controlled stream", connector: connect }),
+  );
+  return () => {};
+
+  function connect() {
+    let controller: ReadableStreamDefaultController<AcpStreamMessage>;
+    return {
+      readable: new ReadableStream<AcpStreamMessage>({
+        start(value) {
+          controller = value;
+        },
+      }),
+      writable: new WritableStream<AcpStreamMessage>({
+        write(message) {
+          if (!("method" in message) || !("id" in message)) return;
+          if (message.method === "session/prompt") {
+            let finished = false;
+            startTurn((chunks, finish) => {
+              if (finished) return;
+              for (const text of chunks) {
+                controller.enqueue({
+                  jsonrpc: "2.0",
+                  method: "session/update",
+                  params: {
+                    sessionId: "controlled",
+                    update: {
+                      sessionUpdate: "agent_message_chunk",
+                      content: { type: "text", text },
+                    },
+                  },
+                });
+              }
+              if (finish) {
+                finished = true;
+                controller.enqueue({
+                  jsonrpc: "2.0",
+                  id: message.id,
+                  result: { stopReason: "end_turn" },
+                });
+              }
+            });
+            return;
+          }
+          let result: unknown = {};
+          if (message.method === "initialize") {
+            result = { protocolVersion: 1, agentCapabilities: {} };
+          } else if (message.method === "session/new") {
+            result = { sessionId: "controlled" };
+          }
+          controller.enqueue({ jsonrpc: "2.0", id: message.id, result });
+        },
+      }),
+    };
+  }
+}
@@ -0,0 +1 @@
+{ "id": "controlled-stream-test", "requirements": { "paseo": ">=0.8.0" } }
@@ -0,0 +1,57 @@
+import path from "node:path";
+import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
+import { connectDaemonClient } from "./daemon-client-loader";
+
+type ControlledStreamClient = Pick<
+  DaemonClient,
+  | "connect"
+  | "close"
+  | "getDaemonConfig"
+  | "patchDaemonConfig"
+  | "installDirectoryPlugin"
+  | "removePlugin"
+  | "invokePluginRpc"
+>;
+
+/** Owns one real provider turn whose completion the test explicitly releases. */
+export async function createControlledStream() {
+  const client = await connectDaemonClient<ControlledStreamClient>({
+    clientIdPrefix: "controlled-stream",
+  });
+  const previous = await client.getDaemonConfig();
+  let appended = false;
+  const emit = (chunks: string[], finish: boolean) =>
+    client.invokePluginRpc("controlled-stream-test", "append", { chunks, finish });
+  const cleanup = async () => {
+    try {
+      if (appended) await emit([], true);
+      await client.removePlugin("controlled-stream-test");
+    } finally {
+      try {
+        await client.patchDaemonConfig({ pluginsEnabled: previous.config.pluginsEnabled });
+      } finally {
+        await client.close();
+      }
+    }
+  };
+  try {
+    await client.patchDaemonConfig({ pluginsEnabled: true });
+    await client.installDirectoryPlugin(
+      path.resolve(__dirname, "../fixtures/controlled-stream-plugin"),
+    );
+    return {
+      provider: "controlled-stream",
+      append: async (chunks: string[]) => {
+        await emit(chunks, false);
+        appended = true;
+      },
+      finish: async (chunks: string[] = []) => {
+        await emit(chunks, true);
+      },
+      cleanup,
+    };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
@@ -0,0 +1,175 @@
+import { expect, test } from "vitest";
+import { findScrollJumps, type ScrollFrame } from "./scroll-jumps";
+
+test("scroll detector distinguishes entered image growth from a simultaneous viewport jump", () => {
+  const before: ScrollFrame = {
+    at: 1000,
+    scrollTop: 1000,
+    scrollHeight: 5000,
+    viewportHeight: 800,
+    virtualized: true,
+    loading: false,
+    rows: [
+      { id: "image", top: -150, height: 150 },
+      { id: "reading", top: 0, height: 100 },
+    ],
+    anchor: "reading",
+    wheelTotal: 0,
+    lastWheelAt: 0,
+    inputFinishedAt: null,
+    imageLoads: 0,
+    mounted: 0,
+    unmounted: 0,
+  };
+  const after: ScrollFrame = {
+    ...before,
+    at: 1400,
+    scrollTop: 900,
+    wheelTotal: 100,
+    lastWheelAt: 1050,
+    rows: [
+      { id: "image", top: -50, height: 1150 },
+      { id: "reading", top: 1100, height: 100 },
+    ],
+  };
+  expect(findScrollJumps([before, after])).toEqual([]);
+  expect(
+    findScrollJumps([
+      { ...before, scrollTop: 200 },
+      {
+        ...after,
+        wheelTotal: 1000,
+        scrollTop: 0,
+        rows: after.rows.map((row) => ({ ...row, top: row.top + 100 })),
+      },
+    ]),
+  ).toEqual([]);
+  expect(
+    findScrollJumps([
+      before,
+      { ...after, rows: after.rows.map((row) => ({ ...row, top: row.top - 500 })) },
+    ]),
+  ).toHaveLength(1);
+  expect(
+    findScrollJumps([
+      { ...before, anchor: "image", rows: [{ id: "image", top: 0, height: 150 }] },
+      { ...after, rows: [{ id: "image", top: 600, height: 1150 }] },
+    ]),
+  ).toHaveLength(1);
+});
+
+test("scroll detector accounts for delayed wheel input and growth below the new reader", () => {
+  const before: ScrollFrame = {
+    at: 1000,
+    scrollTop: 2000,
+    scrollHeight: 5000,
+    viewportHeight: 800,
+    virtualized: true,
+    loading: false,
+    rows: [
+      { id: "new-reader", top: -520, height: 278 },
+      { id: "image", top: -242, height: 184 },
+      { id: "old-reader", top: -58, height: 130 },
+    ],
+    anchor: "old-reader",
+    wheelTotal: 0,
+    lastWheelAt: 0,
+    inputFinishedAt: null,
+    imageLoads: 0,
+    mounted: 0,
+    unmounted: 0,
+  };
+  const wheel = { ...before, at: 1100, wheelTotal: 480, lastWheelAt: 1099 };
+  const after: ScrollFrame = {
+    ...wheel,
+    at: 1220,
+    scrollTop: 1520,
+    scrollHeight: 5041,
+    anchor: "new-reader",
+    rows: [
+      { id: "new-reader", top: -40, height: 278 },
+      { id: "image", top: 238, height: 225 },
+      { id: "old-reader", top: 463, height: 130 },
+    ],
+  };
+  expect(findScrollJumps([before, wheel, after])).toEqual([]);
+  // The previous 480 px input has already moved the viewport; the recent
+  // budget includes it, but only the next 480 px belongs to this frame.
+  const steadyBefore = { ...before, at: 1050, wheelTotal: 480, lastWheelAt: 1049 };
+  const steadyAfter = {
+    ...after,
+    at: 1100,
+    wheelTotal: 960,
+    lastWheelAt: 1099,
+    scrollHeight: 6000,
+    rows: [
+      { id: "new-reader", top: -40, height: 278 },
+      { id: "image", top: 238, height: 1184 },
+      { id: "old-reader", top: 1422, height: 130 },
+    ],
+  };
+  expect(findScrollJumps([steadyBefore, steadyAfter])).toEqual([]);
+
+  expect(
+    findScrollJumps([
+      before,
+      wheel,
+      {
+        ...after,
+        rows: after.rows.map((row) => ({ id: row.id, height: row.height, top: row.top + 100 })),
+      },
+    ]),
+  ).toHaveLength(1);
+});
+
+test("scroll detector follows the entered image through resize and virtual offset correction", () => {
+  for (const height of [225, 1632]) {
+    const before: ScrollFrame = {
+      at: 1000,
+      scrollTop: 2208,
+      scrollHeight: 5000,
+      viewportHeight: 516,
+      virtualized: true,
+      loading: false,
+      rows: [
+        { id: "image", top: -704, height: 560 },
+        { id: "caption", top: -144, height: 100 },
+        { id: "old-reader", top: -44, height: 127 },
+      ],
+      anchor: "old-reader",
+      wheelTotal: 0,
+      lastWheelAt: 0,
+      inputFinishedAt: null,
+      imageLoads: 0,
+      mounted: 3,
+      unmounted: 0,
+    };
+    const resize = height - 560;
+    const after: ScrollFrame = {
+      ...before,
+      at: 1060,
+      // The virtualizer corrects 110px of estimates while the wheel moves 160px.
+      scrollTop: 1938,
+      scrollHeight: 5000 + resize - 110,
+      wheelTotal: 160,
+      lastWheelAt: 1020,
+      imageLoads: 1,
+      rows: [
+        { id: "image", top: -544, height },
+        { id: "caption", top: 16 + resize, height: 100 },
+        { id: "old-reader", top: 116 + resize, height: 127 },
+      ],
+    };
+    expect(findScrollJumps([before, after])).toEqual([]);
+    // Resizing must not excuse additional viewport movement.
+    expect(
+      findScrollJumps([
+        before,
+        {
+          ...after,
+          rows: after.rows.map((row) => ({ id: row.id, height: row.height, top: row.top + 100 })),
+        },
+      ]),
+    ).toHaveLength(1);
+  }
+});
@@ -0,0 +1,95 @@
+interface RowFrame {
+  id: string;
+  top: number;
+  height: number;
+}
+export interface ScrollFrame {
+  at: number;
+  scrollTop: number;
+  scrollHeight: number;
+  viewportHeight: number;
+  virtualized: boolean;
+  loading: boolean;
+  rows: RowFrame[];
+  anchor: string | null;
+  wheelTotal: number;
+  lastWheelAt: number;
+  inputFinishedAt: number | null;
+  imageLoads: number;
+  mounted: number;
+  unmounted: number;
+}
+
+export function findScrollJumps(frames: ScrollFrame[]) {
+  return frames.flatMap((current, index) => {
+    const previous = frames[index - 1];
+    if (!previous?.anchor) return [];
+    // Wheel input can move the reading line onto an image before it expands.
+    // Follow that intended row, not text now below the image.
+    const recent = frames.findLast((frame) => frame.at <= previous.at - 100);
+    const wheelBudget = current.wheelTotal - (recent?.wheelTotal ?? 0);
+    const currentRows = new Map(current.rows.map((row) => [row.id, row]));
+    const anchor = previous.anchor;
+    const before = currentRows.has(anchor)
+      ? previous.rows.find((row) => row.id === anchor)!
+      : previous.rows
+          .filter((row) => currentRows.has(row.id))
+          .sort((left, right) => Math.abs(left.top - 8) - Math.abs(right.top - 8))[0];
+    if (!before) {
+      throw new Error(`No shared reading geometry between frames ${index - 1} and ${index}`);
+    }
+    const after = currentRows.get(before.id)!;
+    const movement = after.top - before.top;
+    // A busy main thread can deliver wheel movement hundreds of milliseconds
+    // after its event. Only assert idle stability after the driver stops input.
+    const idle = current.inputFinishedAt !== null && previous.at - current.inputFinishedAt > 250;
+    // scrollTop also includes virtualizer estimate corrections. Locate the row
+    // entered by wheel input from its viewport movement instead. Its old height
+    // identifies the reader before a simultaneous image resize takes effect.
+    const intendedRow = previous.rows.find((row) => {
+      const next = currentRows.get(row.id);
+      if (!next || idle || wheelBudget <= 0) return false;
+      const travel = next.top - row.top;
+      return (
+        travel >= -8 &&
+        travel <= Math.min(wheelBudget, previous.scrollTop) + 32 &&
+        (next.top <= 8 || current.scrollTop === 0) &&
+        next.top + row.height > 8
+      );
+    });
+    const enteredRowResize = intendedRow
+      ? previous.rows.reduce((growth, row) => {
+          if (row.top < intendedRow.top || row.top >= before.top) return growth;
+          const height = currentRows.get(row.id)?.height ?? row.height;
+          return growth + height - row.height;
+        }, 0)
+      : 0;
+    const readingMovement = movement - enteredRowResize;
+    const excessForward = readingMovement > wheelBudget + 32;
+    // Upward wheel input moves the same text DOWN the viewport. A negative move
+    // is a reversal, independent of legitimate scrollTop compensation on prepend.
+    if (readingMovement >= -8 && (!idle || Math.abs(readingMovement) <= 8) && !excessForward)
+      return [];
+    return [
+      {
+        frame: index,
+        at: current.at,
+        row: before.id,
+        movement,
+        idle,
+        excessForward,
+        resizedRows: current.rows.flatMap((row) => {
+          const old = previous.rows.find((candidate) => candidate.id === row.id);
+          return old && old.height !== row.height
+            ? [{ id: row.id, before: old.height, after: row.height }]
+            : [];
+        }),
+        loading: current.loading || previous.loading,
+        virtualized: current.virtualized,
+        heightChange: current.scrollHeight - previous.scrollHeight,
+        imageLoads: current.imageLoads - previous.imageLoads,
+        frameGapMs: current.at - previous.at,
+      },
+    ];
+  });
+}
@@ -1,3 +1,4 @@
+import { findScrollJumps, type ScrollFrame } from "./scroll-jumps";
 import { writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { expect, type Page, type TestInfo } from "@playwright/test";
@@ -12,27 +13,6 @@ export const scrollCadences = [
 ] as const;

 type Cadence = (typeof scrollCadences)[number];
-interface RowFrame {
-  id: string;
-  top: number;
-  height: number;
-}
-export interface ScrollFrame {
-  at: number;
-  scrollTop: number;
-  scrollHeight: number;
-  viewportHeight: number;
-  virtualized: boolean;
-  loading: boolean;
-  rows: RowFrame[];
-  anchor: string | null;
-  wheelTotal: number;
-  lastWheelAt: number;
-  inputFinishedAt: number | null;
-  imageLoads: number;
-  mounted: number;
-  unmounted: number;
-}
 interface Recording {
  frames: ScrollFrame[];
  finishInput(): void;
@@ -404,80 +384,6 @@ export async function recordUpwardTraversal(
  });
 }

-export function findScrollJumps(frames: ScrollFrame[]) {
-  return frames.flatMap((current, index) => {
-    const previous = frames[index - 1];
-    if (!previous?.anchor) return [];
-    // Wheel input can move the reading line onto an image before it expands.
-    // Follow that intended row, not text now below the image.
-    const recent = frames.findLast((frame) => frame.at <= previous.at - 100);
-    const wheelBudget = current.wheelTotal - (recent?.wheelTotal ?? 0);
-    const currentRows = new Map(current.rows.map((row) => [row.id, row]));
-    const anchor = previous.anchor;
-    const before = currentRows.has(anchor)
-      ? previous.rows.find((row) => row.id === anchor)!
-      : previous.rows
-          .filter((row) => currentRows.has(row.id))
-          .sort((left, right) => Math.abs(left.top - 8) - Math.abs(right.top - 8))[0];
-    if (!before) {
-      throw new Error(`No shared reading geometry between frames ${index - 1} and ${index}`);
-    }
-    const after = currentRows.get(before.id)!;
-    const movement = after.top - before.top;
-    // A busy main thread can deliver wheel movement hundreds of milliseconds
-    // after its event. Only assert idle stability after the driver stops input.
-    const idle = current.inputFinishedAt !== null && previous.at - current.inputFinishedAt > 250;
-    // scrollTop also includes virtualizer estimate corrections. Locate the row
-    // entered by wheel input from its viewport movement instead. Its old height
-    // identifies the reader before a simultaneous image resize takes effect.
-    const intendedRow = previous.rows.find((row) => {
-      const next = currentRows.get(row.id);
-      if (!next || idle || wheelBudget <= 0) return false;
-      const travel = next.top - row.top;
-      return (
-        travel >= -8 &&
-        travel <= Math.min(wheelBudget, previous.scrollTop) + 32 &&
-        (next.top <= 8 || current.scrollTop === 0) &&
-        next.top + row.height > 8
-      );
-    });
-    const enteredRowResize = intendedRow
-      ? previous.rows.reduce((growth, row) => {
-          if (row.top < intendedRow.top || row.top >= before.top) return growth;
-          const height = currentRows.get(row.id)?.height ?? row.height;
-          return growth + height - row.height;
-        }, 0)
-      : 0;
-    const readingMovement = movement - enteredRowResize;
-    const excessForward = readingMovement > wheelBudget + 32;
-    // Upward wheel input moves the same text DOWN the viewport. A negative move
-    // is a reversal, independent of legitimate scrollTop compensation on prepend.
-    if (readingMovement >= -8 && (!idle || Math.abs(readingMovement) <= 8) && !excessForward)
-      return [];
-    return [
-      {
-        frame: index,
-        at: current.at,
-        row: before.id,
-        movement,
-        idle,
-        excessForward,
-        resizedRows: current.rows.flatMap((row) => {
-          const old = previous.rows.find((candidate) => candidate.id === row.id);
-          return old && old.height !== row.height
-            ? [{ id: row.id, before: old.height, after: row.height }]
-            : [];
-        }),
-        loading: current.loading || previous.loading,
-        virtualized: current.virtualized,
-        heightChange: current.scrollHeight - previous.scrollHeight,
-        imageLoads: current.imageLoads - previous.imageLoads,
-        frameGapMs: current.at - previous.at,
-      },
-    ];
-  });
-}
-
 export async function reportScrollJumps(
  page: Page,
  testInfo: TestInfo,
@@ -18,7 +18,7 @@ const resolvePackageEntry = (packageName: string) => {
 export default defineConfig({
  test: {
    environment: "node",
-    exclude: [...configDefaults.exclude, "e2e/**"],
+    exclude: configDefaults.exclude,
    projects: [
      {
        extends: true,
@@ -27,12 +27,13 @@ export default defineConfig({
          environment: "node",
          include: [
            "src/**/*.{test,spec}.{ts,tsx}",
+            "e2e/support/helpers/*.test.ts",
            "native-release-version.test.ts",
            "app.config.test.ts",
            "vitest-environment.test.ts",
          ],
          setupFiles: [path.resolve(__dirname, "vitest.setup.ts")],
-          exclude: [...configDefaults.exclude, "e2e/**", "src/**/*.browser.{test,spec}.{ts,tsx}"],
+          exclude: [...configDefaults.exclude, "src/**/*.browser.{test,spec}.{ts,tsx}"],
        },
      },
      {
Author	SHA1	Message	Date
Mohamed Boudra	79de2540fd	test(app): retain separate initial theme journeys	2026-10-17 21:20:46 +02:00
Mohamed Boudra	213c78e819	test(app): consolidate browser setup and rebalance CI shards	2026-10-17 21:12:13 +02:00
Mohamed Boudra	941c890744	test(app): control hidden turn completion explicitly	2026-10-17 18:54:16 +02:00
Mohamed Boudra	e109b866ab	test(app): trim repeated browser journeys and scripted waits	2026-10-17 18:37:38 +02:00
				`@@ -0,0 +1 @@`
				`{ "id": "controlled-stream-test", "requirements": { "paseo": ">=0.8.0" } }`