feat(website): add agent landing overlays with Pi content

Add a Report a bug button to plugin detail pages (#6721 )
Links to a new issue on the plugin's GitHub repository, from the registry's repository URL. Monorepo folder URLs resolve to the repository; non-GitHub sources show no button. Co-authored-by: paseo-bot[bot] <paseo-bot[bot]@users.noreply.github.com>
2026-10-30 21:23:04 +00:00 · 2026-10-12 16:34:26 +02:00 · 2026-10-12 20:51:22 +07:00 · 2026-10-12 20:22:34 +07:00 · 2026-10-12 19:47:02 +07:00 · 2026-10-12 14:04:41 +02:00
144 changed files with 6230 additions and 1248 deletions
@@ -683,7 +683,7 @@ test("discarding a staged rename restores its source path", async ({ page }) =>

  const panel = page.getByTestId("working-diff-panel").filter({ visible: true });
  const renamedHeader = diffHeaderForPath(panel, "src/zz-renamed.ts");
-  await expect(renamedHeader).toHaveAccessibleName("src/zz-renamed.ts, +1, -0");
+  await expect(renamedHeader).toHaveAccessibleName("src/zz-renamed.ts, +0, -0");
  const renamedToggle = renamedHeader.getByTestId(/^diff-file-\d+-toggle$/);
  const toggleTestId = await renamedToggle.getAttribute("data-testid");
  expect(toggleTestId).not.toBeNull();
@@ -25,6 +25,12 @@ import {
  expectReadingStreamedMarkdown,
 } from "../support/helpers/chat-outline";
 import { createCreationScenario } from "../support/helpers/creation";
+import {
+  attachPromptTimelineEvidence,
+  expectPromptsDrawnByPlugin,
+  expectVirtualizedPluginPromptVisible,
+  withPromptTimelinePlugin,
+} from "../support/helpers/plugin-timeline";
 import {
  expectTimelineAtMaximumScrollWithPromptVisible,
  expectTimelinePromptNotMounted,
@@ -105,6 +111,60 @@ test.describe("desktop chat outline", () => {
    }
  });

+  test("jumps to prompts a timeline plugin draws", async ({ page }) => {
+    test.setTimeout(180_000);
+    const agent = await seedLongMockAgentTimeline({ turns: 80 });
+    try {
+      await withPromptTimelinePlugin(async () => {
+        await page.setViewportSize(WIDE_VIEWPORT);
+        await openAgentTimeline(page, agent);
+        await expectChatOutlinePrompts(page, 80);
+        await expectPromptsDrawnByPlugin(page);
+        await expectTimelinePromptNotMounted(page, agent.prompts[39]);
+
+        // Unloaded, then loaded, then near the newest edge.
+        await clickChatOutlineRowEdge(page, 40);
+        await expectTimelinePromptLandedBelowTop(page, agent.prompts[39]);
+        await attachPromptTimelineEvidence(page, test.info());
+        await clickChatOutlineRowEdge(page, 45);
+        await expectTimelinePromptLandedBelowTop(page, agent.prompts[44]);
+        await clickChatOutlineRowEdge(page, 78);
+        await expectTimelineAtMaximumScrollWithPromptVisible(page, agent.prompts[77]);
+        await expectPromptsDrawnByPlugin(page);
+      });
+    } finally {
+      await agent.cleanup();
+    }
+  });
+
+  test("jumps to a loaded virtualized prompt a timeline plugin draws without fetching", async ({
+    page,
+  }) => {
+    test.setTimeout(180_000);
+    const agent = await seedLongMockAgentTimeline({ turns: 80 });
+    const prompt = agent.prompts[29]!;
+    try {
+      await withPromptTimelinePlugin(async () => {
+        const history = await holdOlderHistoryPages(page, agent);
+        await page.setViewportSize(WIDE_VIEWPORT);
+        await openAgentTimeline(page, agent);
+        await expectChatOutlinePrompts(page, 80);
+        await scrollThroughOlderHistoryPages(page, 2, history);
+        await scrollTimelineToNewestLoadedEdge(page);
+        await expectTimelinePromptNotMounted(page, prompt);
+        const requestsBeforeJump = history.requestCount();
+
+        await clickChatOutlineRowEdge(page, 30);
+        await expectTimelinePromptLandedBelowTop(page, prompt);
+        await expectVirtualizedPluginPromptVisible(page, prompt);
+        await attachPromptTimelineEvidence(page, test.info());
+        expect(history.requestCount()).toBe(requestsBeforeJump);
+      }, [prompt]);
+    } finally {
+      await agent.cleanup();
+    }
+  });
+
  test.describe("with the whole conversation loaded", () => {
    let agent: LongTimelineAgent;

@@ -4,6 +4,10 @@ import {
  expectComposerDraft,
  expectComposerVisible,
  fillComposerDraft,
+  enterComposerFullscreen,
+  exitComposerFullscreen,
+  resizeComposerViewport,
+  selectComposerDraftRange,
 } from "../support/helpers/composer";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";

@@ -53,3 +57,48 @@ for (const email of [
    }
  });
 }
+
+test("fullscreen mention keys edit the draft while inline keys still complete files", async ({
+  page,
+}) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "composer-fullscreen-mention-",
+    title: "Fullscreen mention keys",
+  });
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    const draft = "First line\nSecond line\n@README";
+    await fillComposerDraft(page, draft);
+    await expect(fileSuggestions(page).getByText("README.md", { exact: true })).toBeVisible();
+    await enterComposerFullscreen(page);
+    await expect(fileSuggestions(page)).not.toBeVisible();
+    await selectComposerDraftRange(page, draft.length, draft.length);
+    await composerLocator(page).press("ArrowUp");
+    await expect
+      .poll(() =>
+        composerLocator(page).evaluate((element) => {
+          const input = element as HTMLTextAreaElement;
+          return input.selectionStart === input.selectionEnd && input.selectionStart < 23;
+        }),
+      )
+      .toBe(true);
+    await selectComposerDraftRange(page, draft.length, draft.length);
+    await composerLocator(page).press("Enter");
+    await expectComposerDraft(page, `${draft}\n`);
+    await exitComposerFullscreen(page);
+    await selectReadmeMention(page);
+    const commandDraft = "/cl\nSecond line\nThird line";
+    await fillComposerDraft(page, commandDraft);
+    await selectComposerDraftRange(page, 2, 2);
+    await composerLocator(page).press("ArrowRight");
+    await expect(fileSuggestions(page).getByText("/clear", { exact: true }).first()).toBeVisible();
+    await enterComposerFullscreen(page);
+    await expect(fileSuggestions(page)).not.toBeVisible();
+    await composerLocator(page).press("Enter");
+    await expectComposerDraft(page, "/cl\n\nSecond line\nThird line");
+  } finally {
+    await agent.cleanup();
+  }
+});
@@ -1,3 +1,5 @@
+import { createMockIdleAgent, openWorkspaceWithAgents } from "../support/helpers/archive-tab";
+import { seedWorkspace } from "../support/helpers/seed-client";
 import { expect, test, type Page } from "../support/fixtures";
 import {
  expectNearBottom,
@@ -5,7 +7,27 @@ import {
  waitForScrollableChat,
 } from "../support/helpers/agent-bottom-anchor";
 import { awaitAssistantMessage } from "../support/helpers/agent-stream";
-import { composerLocator, expectComposerVisible } from "../support/helpers/composer";
+import {
+  attachComposerTestImage,
+  pasteComposerTestImage,
+  enterComposerFullscreen,
+  exitComposerFullscreen,
+  resizeComposerViewport,
+  selectComposerDraftRange,
+  expectComposerDraftSelection,
+  expectComposerFullscreenControls,
+  sendComposerWithButton,
+  queueComposerWithButton,
+  configureComposerQueueSend,
+  activateRetainedComposerTab,
+  recordVisibleComposerGeometry,
+  expectNoCollapsedVisibleComposer,
+  expectAttachmentPill,
+  expectQueuedMessageButton,
+  startRunningMockAgent,
+  composerLocator,
+  expectComposerVisible,
+} from "../support/helpers/composer";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";

 async function composerHeight(page: Page): Promise<number> {
@@ -133,3 +155,300 @@ test("composer growth keeps a bottom-pinned chat at the bottom", async ({ page }
    await agent.cleanup();
  }
 });
+
+async function writeCompactDraft(page: Page, text: string): Promise<void> {
+  await composerLocator(page).fill(text);
+  await expect(composerLocator(page)).toHaveValue(text);
+}
+
+test("compact long drafts stop growing before the header", async ({ page }) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "composer-cap-",
+    title: "Composer cap",
+  });
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    await writeCompactDraft(page, "A long draft line\n".repeat(40));
+    await expect.poll(() => composerHeight(page)).toBeLessThanOrEqual(160);
+  } finally {
+    await agent.cleanup();
+  }
+});
+
+test("compact fullscreen editing preserves the live draft and selection and stays open after send", async ({
+  page,
+}) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "composer-fullscreen-",
+    title: "Fullscreen composer",
+  });
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    await attachComposerTestImage(page);
+    await expectAttachmentPill(page, "composer-image-attachment-pill");
+    await writeCompactDraft(page, "First line\nSecond line");
+    await expect(page.getByRole("button", { name: "Fullscreen", exact: true })).toHaveCount(0);
+    await writeCompactDraft(page, "First line\nSecond line\nThird line");
+    await expect(page.getByRole("button", { name: "Fullscreen", exact: true })).toBeVisible();
+    await writeCompactDraft(
+      page,
+      "A sentence with enough words to wrap across several rendered lines in a narrow input. ".repeat(
+        4,
+      ),
+    );
+    await expect(page.getByRole("button", { name: "Fullscreen", exact: true })).toBeVisible();
+    await selectComposerDraftRange(page, 4, 17);
+    await enterComposerFullscreen(page);
+    await expectComposerFullscreenControls(page);
+    await expectComposerDraftSelection(page, 4, 17);
+    await expect(page.getByTestId("composer-image-attachment-pill")).toHaveCount(0);
+    await writeCompactDraft(page, "Edited fullscreen draft\nSecond line\nThird line");
+    await selectComposerDraftRange(page, 3, 12);
+    await exitComposerFullscreen(page);
+    await expect(composerLocator(page)).toHaveValue(
+      "Edited fullscreen draft\nSecond line\nThird line",
+    );
+    await expectComposerDraftSelection(page, 3, 12);
+    await expectAttachmentPill(page, "composer-image-attachment-pill");
+    await expect(composerLocator(page)).toBeFocused();
+    await enterComposerFullscreen(page);
+    await writeCompactDraft(page, "Short draft");
+    await expectComposerFullscreenControls(page);
+    await selectComposerDraftRange(page, 0, 5);
+    await resizeComposerViewport(page, "landscape");
+    await expectComposerFullscreenControls(page);
+    await expectComposerDraftSelection(page, 0, 5);
+    await expect(composerLocator(page)).toHaveValue("Short draft");
+    await expect(composerLocator(page)).toBeFocused();
+    await resizeComposerViewport(page, "portrait");
+    await sendComposerWithButton(page);
+    await expect(composerLocator(page)).toHaveValue("");
+    await expectComposerFullscreenControls(page);
+    await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeDisabled();
+  } finally {
+    await agent.cleanup();
+  }
+});
+
+test("fullscreen submit rejection retains the editable draft and supports retry", async ({
+  page,
+}) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "composer-fullscreen-retry-",
+    title: "Fullscreen retry",
+    featureValues: { mockPromptRejections: 1 },
+  });
+  const draft = "First line\nSecond line\nThird line";
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    await writeCompactDraft(page, draft);
+    await enterComposerFullscreen(page);
+    await sendComposerWithButton(page);
+    await expect(page.getByTestId("composer-fullscreen").getByRole("alert")).toHaveText(
+      "Requested mock prompt rejection",
+    );
+    await expect(composerLocator(page)).toHaveValue(draft);
+    await expect(composerLocator(page)).toBeEditable();
+    await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeEnabled();
+    await sendComposerWithButton(page);
+    await expect(composerLocator(page)).toHaveValue("");
+    await expectComposerFullscreenControls(page);
+  } finally {
+    await agent.cleanup();
+  }
+});
+
+test("fullscreen Send keeps the configured queue behavior while an agent runs", async ({
+  page,
+}) => {
+  await configureComposerQueueSend(page);
+  await resizeComposerViewport(page, "portrait");
+  const agent = await startRunningMockAgent(page, {
+    prefix: "composer-fullscreen-queue-",
+    model: "one-minute-stream",
+    prompt: "Stay running for fullscreen queue test.",
+  });
+  try {
+    await writeCompactDraft(page, "Queued first line\nSecond line\nThird line");
+    await enterComposerFullscreen(page);
+    await expectComposerFullscreenControls(page);
+    await queueComposerWithButton(page);
+    await expect(composerLocator(page)).toHaveValue("");
+    await expectComposerFullscreenControls(page);
+    await exitComposerFullscreen(page);
+    await expectQueuedMessageButton(page);
+  } finally {
+    await agent.cleanup();
+  }
+});
+
+test("image paste stays attached to the active editor across fullscreen entry and exit", async ({
+  page,
+}) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "composer-paste-remount-",
+    title: "Composer paste",
+  });
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    await writeCompactDraft(page, "First line\nSecond line\nThird line");
+    expect(await pasteComposerTestImage(page)).toBe(true);
+    await expect(page.getByTestId("composer-image-attachment-pill")).toHaveCount(1);
+    await enterComposerFullscreen(page);
+    expect(await pasteComposerTestImage(page)).toBe(true);
+    await exitComposerFullscreen(page);
+    await expect(page.getByTestId("composer-image-attachment-pill")).toHaveCount(2);
+    expect(await pasteComposerTestImage(page)).toBe(true);
+    await expect(page.getByTestId("composer-image-attachment-pill")).toHaveCount(3);
+  } finally {
+    await agent.cleanup();
+  }
+});
+
+test("retained agent tabs preserve fullscreen editing and paste when switched away and back", async ({
+  page,
+}) => {
+  const workspace = await seedWorkspace({ repoPrefix: "composer-retained-fullscreen-" });
+  try {
+    const first = await createMockIdleAgent(workspace.client, {
+      cwd: workspace.repoPath,
+      workspaceId: workspace.workspaceId,
+      title: "First retained chat",
+    });
+    const second = await createMockIdleAgent(workspace.client, {
+      cwd: workspace.repoPath,
+      workspaceId: workspace.workspaceId,
+      title: "Second retained chat",
+    });
+    await openWorkspaceWithAgents(page, [first, second]);
+    await resizeComposerViewport(page, "portrait");
+    const draft = "Live first line\nLive second line\nLive third line";
+    await writeCompactDraft(page, draft);
+    await enterComposerFullscreen(page);
+    await selectComposerDraftRange(page, 4, 17);
+    await activateRetainedComposerTab(page, first.title);
+    await expect(page.getByRole("button", { name: "Exit fullscreen", exact: true })).toHaveCount(0);
+    await writeCompactDraft(page, "Other tab draft");
+    await shrinkVisibleViewport(page);
+    await activateRetainedComposerTab(page, second.title);
+    await expectComposerFullscreenControls(page);
+    await expect(composerLocator(page)).toHaveValue(draft);
+    await expectFullscreenInsideVisibleViewport(page);
+    await expectComposerDraftSelection(page, 4, 17);
+    await expect(composerLocator(page)).toBeFocused();
+    expect(await pasteComposerTestImage(page)).toBe(true);
+    await exitComposerFullscreen(page);
+    await expectAttachmentPill(page, "composer-image-attachment-pill");
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+test("retained inline composers keep usable capacity through hidden tab geometry", async ({
+  page,
+}) => {
+  const workspace = await seedWorkspace({ repoPrefix: "composer-retained-capacity-" });
+  try {
+    const first = await createMockIdleAgent(workspace.client, {
+      cwd: workspace.repoPath,
+      workspaceId: workspace.workspaceId,
+      title: "First capacity chat",
+    });
+    const second = await createMockIdleAgent(workspace.client, {
+      cwd: workspace.repoPath,
+      workspaceId: workspace.workspaceId,
+      title: "Second capacity chat",
+    });
+    await openWorkspaceWithAgents(page, [first, second]);
+    await resizeComposerViewport(page, "portrait");
+    const draft = "Retained long line\n".repeat(40);
+    await writeCompactDraft(page, draft);
+    await recordVisibleComposerGeometry(page);
+    await activateRetainedComposerTab(page, first.title);
+    await writeCompactDraft(page, "Other visible draft");
+    await activateRetainedComposerTab(page, second.title);
+    await expect(composerLocator(page)).toHaveValue(draft);
+    await expect.poll(() => composerHeight(page)).toBeLessThanOrEqual(160);
+    await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeVisible();
+    await expectNoCollapsedVisibleComposer(page);
+  } finally {
+    await workspace.cleanup();
+  }
+});
+
+async function shrinkVisibleViewport(page: Page): Promise<void> {
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("Emulation.setPageScaleFactor", { pageScaleFactor: 2 });
+  await expect.poll(() => page.evaluate(() => window.visualViewport!.height)).toBe(422);
+  await cdp.detach();
+}
+
+async function panVisibleViewport(page: Page): Promise<void> {
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("Input.dispatchTouchEvent", {
+    type: "touchStart",
+    touchPoints: [{ x: 4, y: 300 }],
+  });
+  for (let y = 290; y >= 100; y -= 10) {
+    await cdp.send("Input.dispatchTouchEvent", {
+      type: "touchMove",
+      touchPoints: [{ x: 4, y }],
+    });
+  }
+  await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
+  await expect.poll(() => page.evaluate(() => window.visualViewport!.offsetTop)).toBeGreaterThan(0);
+  await cdp.detach();
+}
+
+async function expectFullscreenInsideVisibleViewport(page: Page): Promise<void> {
+  await expect
+    .poll(() =>
+      page.getByTestId("composer-fullscreen").evaluate((element) => {
+        const viewport = window.visualViewport!;
+        const frame = element.getBoundingClientRect();
+        const send = element.querySelector('[aria-label="Send message"]')!.getBoundingClientRect();
+        return {
+          frameFits:
+            Math.abs(frame.top - viewport.offsetTop) < 1 &&
+            Math.abs(frame.left - viewport.offsetLeft) < 1 &&
+            Math.abs(frame.height - viewport.height) < 1 &&
+            Math.abs(frame.width - viewport.width) < 1,
+          sendFits:
+            send.top >= viewport.offsetTop &&
+            send.bottom <= viewport.offsetTop + viewport.height &&
+            send.left >= viewport.offsetLeft &&
+            send.right <= viewport.offsetLeft + viewport.width,
+        };
+      }),
+    )
+    .toEqual({ frameFits: true, sendFits: true });
+}
+
+test("fullscreen Send follows the visible viewport when it shrinks and pans", async ({ page }) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "composer-visible-viewport-",
+    title: "Visible viewport composer",
+  });
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    await writeCompactDraft(page, "First line\nSecond line\nThird line");
+    await enterComposerFullscreen(page);
+    await expectFullscreenInsideVisibleViewport(page);
+    await shrinkVisibleViewport(page);
+    await expectFullscreenInsideVisibleViewport(page);
+    await panVisibleViewport(page);
+    await expectFullscreenInsideVisibleViewport(page);
+  } finally {
+    await agent.cleanup();
+  }
+});
@@ -6,6 +6,15 @@ import {
  selectWorkspaceIsolation,
 } from "../support/helpers/new-workspace";
 import { seedWorkspace } from "../support/helpers/seed-client";
+import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
+import {
+  composerLocator,
+  expectComposerVisible,
+  fillComposerDraft,
+  enterComposerFullscreen,
+  resizeComposerViewport,
+  expectComposerFullscreenControls,
+} from "../support/helpers/composer";
 import { waitForSidebarHydration } from "../support/helpers/workspace-ui";

 type WebSocketMessage = string | Buffer;
@@ -196,3 +205,52 @@ test.describe("New Workspace dictation submit", () => {
    }
  });
 });
+
+async function startDictationWithShortcut(page: Page): Promise<void> {
+  await composerLocator(page).press("Control+d");
+}
+
+test("dictation shortcut leaves retained fullscreen and exposes recording controls", async ({
+  page,
+}) => {
+  const agent = await seedMockAgentWorkspace({
+    repoPrefix: "fullscreen-dictation-",
+    title: "Fullscreen dictation shortcut",
+  });
+  await installSyntheticMicrophone(page);
+  const harness = await installDictationFailureHarness(page);
+  const draft = "First line\nSecond line\nThird line";
+  try {
+    await resizeComposerViewport(page, "portrait");
+    await openAgentRoute(page, agent);
+    await expectComposerVisible(page);
+    await fillComposerDraft(page, draft);
+    await enterComposerFullscreen(page);
+    await resizeComposerViewport(page, "landscape");
+    await expectComposerFullscreenControls(page);
+    await startDictationWithShortcut(page);
+    await harness.waitForAudio();
+    await expect(page.getByRole("button", { name: "Exit fullscreen", exact: true })).toHaveCount(0);
+    await expect(page.getByRole("button", { name: "Cancel dictation", exact: true })).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Insert transcription", exact: true }),
+    ).toBeVisible();
+    await expect(
+      page.getByRole("button", { name: "Insert transcription and send", exact: true }),
+    ).toBeVisible();
+    await page.getByRole("button", { name: "Cancel dictation", exact: true }).click();
+    await expect(composerLocator(page)).toBeEditable();
+    await expect(composerLocator(page)).toHaveValue(draft);
+    await resizeComposerViewport(page, "portrait");
+    await enterComposerFullscreen(page);
+    await resizeComposerViewport(page, "landscape");
+    await composerLocator(page).press("Control+Shift+d");
+    await expect(page.getByRole("button", { name: "Exit fullscreen", exact: true })).toHaveCount(0);
+    await expect(
+      page.getByText("Realtime voice is disabled in this test.", { exact: true }),
+    ).toBeVisible();
+    await expect(composerLocator(page)).toHaveValue(draft);
+  } finally {
+    await agent.cleanup();
+  }
+});
@@ -9,13 +9,12 @@ import {
  expectTerminalPreviewCommand,
  expectWorkspaceOpensWithTerminalTab,
  fillTerminalPrompt,
-  seedTerminalProfiles,
+  launchTrigger,
  selectLaunchOption,
  submitTerminalLaunch,
  terminalLaunchSubmit,
  terminalPromptInput,
  type TerminalProfile,
-  type TerminalProfileSeed,
 } from "../support/helpers/new-workspace-launch";

 // Someone who wants a terminal agent instead of a chat: they pick a profile
@@ -42,17 +41,18 @@ const BARE_PROFILE: TerminalProfile = {
  args: ["-c", "echo bare-launch-static-line; exec cat"],
 };

+test.use({
+  e2eDaemonConfig: { version: 1, daemon: { terminalProfiles: [PROMPT_PROFILE, BARE_PROFILE] } },
+});
+
 test.describe("New workspace: launching a terminal", () => {
  let workspace: SeededWorkspace;
-  let profileSeed: TerminalProfileSeed;

  test.beforeEach(async () => {
    workspace = await seedWorkspace({ repoPrefix: "launch-terminal-" });
-    profileSeed = await seedTerminalProfiles([PROMPT_PROFILE, BARE_PROFILE]);
  });

  test.afterEach(async () => {
-    await profileSeed.restore();
    await workspace?.cleanup();
  });

@@ -97,4 +97,51 @@ test.describe("New workspace: launching a terminal", () => {
      await expectTerminalOutputContains(page, "bare-launch-static-line");
    });
  });
+
+  test("switching terminal profiles restores the prompt and its fullscreen affordance", async ({
+    page,
+  }) => {
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await openNewWorkspaceComposer(page, {
+      projectKey: workspace.projectKey,
+      projectDisplayName: workspace.projectDisplayName,
+    });
+    await page.setViewportSize({ width: 390, height: 844 });
+    const prompt = "First replacement line\nSecond replacement line\nThird replacement line";
+    const selectProfile = async (profile: TerminalProfile) => {
+      await launchTrigger(page).click();
+      const option = page.getByRole("menuitem").filter({ hasText: profile.name });
+      await option.click();
+      await expect(option).not.toBeVisible();
+    };
+    const fullscreen = page.getByRole("button", { name: "Fullscreen", exact: true });
+
+    await test.step("restore a multiline prompt after a read-only profile", async () => {
+      await selectProfile(PROMPT_PROFILE);
+      await fillTerminalPrompt(page, prompt);
+      await expect(fullscreen).toBeVisible();
+      await selectProfile(BARE_PROFILE);
+      await expect(terminalPromptInput(page)).toHaveCount(0);
+      await selectProfile(PROMPT_PROFILE);
+      await expect(terminalPromptInput(page)).toHaveValue(prompt);
+      await expect(fullscreen).toBeVisible();
+    });
+
+    await test.step("restore the locally edited prompt and measure subsequent typing", async () => {
+      await fillTerminalPrompt(page, "Short draft");
+      await expect(fullscreen).toHaveCount(0);
+      await selectProfile(BARE_PROFILE);
+      await selectProfile(PROMPT_PROFILE);
+      await expect(terminalPromptInput(page)).toHaveValue("Short draft");
+      await expect(fullscreen).toHaveCount(0);
+      await terminalPromptInput(page).press("End");
+      await terminalPromptInput(page).press("Shift+Enter");
+      await terminalPromptInput(page).pressSequentially("Second");
+      await terminalPromptInput(page).press("Shift+Enter");
+      await terminalPromptInput(page).pressSequentially("Third");
+      await expect(terminalPromptInput(page)).toHaveValue("Short draft\nSecond\nThird");
+      await expect(fullscreen).toBeVisible();
+    });
+  });
 });
@@ -0,0 +1,64 @@
+import { execFileSync } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { expect, test as base } from "../support/fixtures";
+import { gotoWorkspace } from "../support/helpers/launcher";
+import { openChangesTreePanel } from "../support/helpers/workspace-tabs";
+
+const test = base.extend<{ projectWithTrailingSpace: string }>({
+  projectWithTrailingSpace: async ({ e2eWorkerClient: client }, provide) => {
+    const root = await mkdtemp(path.join(tmpdir(), "paseo-project-path-spaces-"));
+    try {
+      const repoPath = path.join(root, "repo ");
+      execFileSync("git", ["init", "-b", "main", repoPath], { stdio: "pipe" });
+      execFileSync(
+        "git",
+        [
+          "-c",
+          "user.name=Paseo Test",
+          "-c",
+          "user.email=test@getpaseo.local",
+          "-c",
+          "commit.gpgsign=false",
+          "commit",
+          "--allow-empty",
+          "-m",
+          "initial",
+        ],
+        { cwd: repoPath, stdio: "pipe" },
+      );
+      await writeFile(path.join(repoPath, "visible-change.txt"), "a change\n");
+      const added = await client.addProject(repoPath);
+      expect(added.error).toBeNull();
+      const projectId = added.project!.projectId;
+      try {
+        const created = await client.createWorkspace({
+          source: { kind: "directory", path: repoPath, projectId },
+        });
+        expect(created.error).toBeNull();
+        await provide(created.workspace!.id);
+      } finally {
+        await client.removeProject(projectId);
+      }
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  },
+});
+
+test.skip(
+  process.platform === "win32",
+  "Windows does not preserve trailing spaces in folder names",
+);
+
+test("Changes shows files in a project whose folder ends in a space", async ({
+  page,
+  projectWithTrailingSpace,
+}, testInfo) => {
+  await gotoWorkspace(page, projectWithTrailingSpace);
+  await openChangesTreePanel(page);
+  await expect(page.getByText("visible-change.txt", { exact: true }).first()).toBeVisible();
+  await expect(page.getByText("Not a git repository", { exact: true })).toHaveCount(0);
+  await page.screenshot({ path: testInfo.outputPath("changes.png") });
+});
@@ -0,0 +1,62 @@
+// Open Settings > Appearance in a native Android app loaded from this checkout.
+// AGENT_DEVICE_STATE_DIR=<state-dir> node packages/app/e2e/mobile/system-bars/android.mjs <session> <adb-serial> <app-id>
+// Requires English UI and a dedicated emulator. Leaves System theme and light OS appearance.
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+
+const [, , session, serial, appId] = process.argv;
+assert(session && serial && appId, "Pass the agent-device session, adb serial, and app ID");
+
+function ad(...args) {
+  return execFileSync("agent-device", [...args, "--session", session], {
+    encoding: "utf8",
+    timeout: 60_000,
+  });
+}
+
+function windowState() {
+  const state = execFileSync("adb", ["-s", serial, "shell", "dumpsys", "window"], {
+    encoding: "utf8",
+    timeout: 10_000,
+  });
+  assert(state.match(/mCurrentFocus=.*\n/)?.[0].includes(`${appId}/`), "App must be focused");
+  const regions = state.match(/mLastStatusBarAppearanceRegions=\s*\n([^\n]+)/)?.[1];
+  assert(regions, "Android must report the status-bar appearance region");
+  return regions.includes("LIGHT_STATUS_BARS");
+}
+
+async function expectDarkIcons(expected, context) {
+  const deadline = Date.now() + 5_000;
+  do {
+    if (windowState() === expected) {
+      console.log(`PASS: ${context}`);
+      return;
+    }
+    await delay(100);
+  } while (Date.now() < deadline);
+  assert.equal(windowState(), expected, context);
+}
+
+function selectTheme(theme) {
+  const current = ad("snapshot", "-i").match(/"Theme: ([^"]+)"/)?.[1];
+  assert(current, "Start on Settings > Appearance");
+  ad("press", `label="Theme: ${current}"`, "--settle");
+  ad("press", `label="${theme}"`, "--settle");
+  ad("wait", "text", `Theme: ${theme}`, "5000");
+}
+
+ad("settings", "appearance", "light");
+selectTheme("Light");
+await expectDarkIcons(true, "Light app theme uses dark status icons");
+selectTheme("Dark");
+await expectDarkIcons(false, "Dark app theme uses light status icons");
+selectTheme("System");
+await expectDarkIcons(true, "System theme starts with dark icons on light OS appearance");
+ad("settings", "appearance", "dark");
+await expectDarkIcons(
+  false,
+  "System theme follows an OS change to dark without reopening settings",
+);
+ad("settings", "appearance", "light");
+await expectDarkIcons(true, "System theme follows an OS change back to light");
@@ -316,3 +316,133 @@ export async function openGithubWorkspace(
    },
  };
 }
+
+const COMPOSER_TEST_IMAGE_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+
+export async function attachComposerTestImage(page: Page): Promise<void> {
+  await attachImageFromMenu(page, {
+    name: "fullscreen.png",
+    mimeType: "image/png",
+    buffer: Buffer.from(COMPOSER_TEST_IMAGE_BASE64, "base64"),
+  });
+}
+
+export async function pasteComposerTestImage(page: Page): Promise<boolean> {
+  return composerInput(page).evaluate((input, base64) => {
+    const bytes = Uint8Array.from(atob(base64), (character) => character.charCodeAt(0));
+    const clipboardData = new DataTransfer();
+    clipboardData.items.add(new File([bytes], "pasted.png", { type: "image/png" }));
+    const event = new ClipboardEvent("paste", { clipboardData, bubbles: true, cancelable: true });
+    input.dispatchEvent(event);
+    return event.defaultPrevented;
+  }, COMPOSER_TEST_IMAGE_BASE64);
+}
+
+export async function enterComposerFullscreen(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Fullscreen", exact: true }).click();
+}
+export async function exitComposerFullscreen(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Exit fullscreen", exact: true }).click();
+}
+export async function resizeComposerViewport(
+  page: Page,
+  orientation: "portrait" | "landscape" | "short",
+): Promise<void> {
+  const sizes = {
+    portrait: { width: 390, height: 844 },
+    landscape: { width: 844, height: 390 },
+    short: { width: 390, height: 390 },
+  };
+  await page.setViewportSize(sizes[orientation]);
+}
+export async function selectComposerDraftRange(
+  page: Page,
+  start: number,
+  end: number,
+): Promise<void> {
+  await composerInput(page).focus();
+  await composerInput(page).evaluate(
+    (element, selection) => {
+      const input = element as HTMLTextAreaElement;
+      input.setSelectionRange(selection.start, selection.end);
+      input.dispatchEvent(new Event("select", { bubbles: true }));
+    },
+    { start, end },
+  );
+}
+export async function expectComposerDraftSelection(
+  page: Page,
+  start: number,
+  end: number,
+): Promise<void> {
+  await expect
+    .poll(() =>
+      composerInput(page).evaluate((element) => {
+        const input = element as HTMLTextAreaElement;
+        return [input.selectionStart, input.selectionEnd];
+      }),
+    )
+    .toEqual([start, end]);
+}
+export async function expectComposerFullscreenControls(page: Page): Promise<void> {
+  await expect(page.getByRole("button", { name: "Exit fullscreen", exact: true })).toBeVisible();
+  await expect(page.getByTestId("composer-fullscreen").getByRole("button")).toHaveCount(2);
+  await expect(composerInput(page)).toHaveCount(1);
+}
+export async function sendComposerWithButton(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Send message", exact: true }).click();
+}
+export async function queueComposerWithButton(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Queue message", exact: true }).click();
+}
+export async function configureComposerQueueSend(page: Page): Promise<void> {
+  await page.addInitScript(() =>
+    localStorage.setItem("@paseo:app-settings", JSON.stringify({ sendBehavior: "queue" })),
+  );
+}
+
+/** Drive the real tab chooser's commands even when fullscreen covers its pointer surface.
+ * This exercises retained activity changes, not a claim that covered chrome is clickable.
+ */
+export async function activateRetainedComposerTab(page: Page, title: string): Promise<void> {
+  await page
+    .getByTestId("workspace-tab-switcher-trigger")
+    .evaluate((element) => (element as HTMLElement).click());
+  const option = page.getByText(title, { exact: true }).filter({ visible: true }).last();
+  await expect(option).toBeVisible();
+  await option.evaluate((element) => (element as HTMLElement).click());
+}
+
+export async function recordVisibleComposerGeometry(page: Page): Promise<void> {
+  await page.evaluate(() => {
+    const frames: { input: number; root: number }[] = [];
+    Reflect.set(window, "__composerGeometryFrames", frames);
+    let running = true;
+    const tick = () => {
+      if (!running) return;
+      for (const root of document.querySelectorAll('[data-testid="message-input-root"]')) {
+        if (root.getClientRects().length === 0) continue;
+        const input = root.querySelector("textarea");
+        if (input)
+          frames.push({
+            input: input.getBoundingClientRect().height,
+            root: root.getBoundingClientRect().height,
+          });
+      }
+      requestAnimationFrame(tick);
+    };
+    requestAnimationFrame(tick);
+    Reflect.set(window, "__stopComposerGeometry", () => {
+      running = false;
+    });
+  });
+}
+export async function expectNoCollapsedVisibleComposer(page: Page): Promise<void> {
+  const frames = await page.evaluate(() => {
+    Reflect.get(window, "__stopComposerGeometry")?.();
+    return Reflect.get(window, "__composerGeometryFrames") as { input: number; root: number }[];
+  });
+  expect(frames.length).toBeGreaterThan(0);
+  expect(frames.filter((frame) => frame.root < 42 || frame.input < 42)).toEqual([]);
+}
@@ -47,6 +47,65 @@ export default function contribute(client) {
  return () => {};
 }`;

+const PROMPT_PLUGIN_ID = "timeline-prompt-e2e";
+
+function promptClientSource(prompts?: readonly string[]): string {
+  return `import React from "react";
+import { Text, View } from "react-native";
+import { z } from "zod";
+
+const selectedPrompts = ${JSON.stringify(prompts ?? null)};
+
+function PromptCard({ item }) {
+  return <View testID="plugin-prompt"><Text>{item.data.text}</Text></View>;
+}
+
+export default function contribute(client) {
+  client.addTimelineTransformer({
+    id: "prompt",
+    query: { itemType: "user_message" },
+    transform({ item }) {
+      if (selectedPrompts && !selectedPrompts.includes(item.text)) return undefined;
+      return { items: [{ type: "plugin", kind: "prompt", version: 1, data: { text: item.text } }] };
+    },
+  });
+  client.addTimelineRenderer({
+    kind: "prompt", version: 1,
+    schema: z.object({ text: z.string() }),
+    Component: PromptCard,
+  });
+  return () => {};
+}`;
+}
+
+async function withDirectoryPlugin(options: {
+  pluginId: string;
+  source: string;
+  run: () => Promise<void>;
+}): Promise<void> {
+  const { pluginId, source, run } = options;
+  const directory = await mkdtemp(path.join(tmpdir(), "paseo-timeline-plugin-"));
+  const pluginClient = await connectNewWorkspaceDaemonClient({ ownProjects: false });
+  const previous = await pluginClient.getDaemonConfig();
+  try {
+    await writeFile(
+      path.join(directory, "paseo-plugin.json"),
+      JSON.stringify({ id: pluginId, requirements: pluginRequirements }),
+    );
+    await writeFile(path.join(directory, "index.client.tsx"), source);
+    await pluginClient.patchDaemonConfig({ pluginsEnabled: true });
+    await pluginClient.installDirectoryPlugin(directory);
+    await run();
+  } finally {
+    await pluginClient.removePlugin(pluginId);
+    await pluginClient.patchDaemonConfig({
+      pluginsEnabled: previous.config.pluginsEnabled ?? false,
+    });
+    await pluginClient.close();
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
 export async function withTimelinePlugin(
  page: Page,
  info: TestInfo,
@@ -60,7 +119,6 @@ export async function withTimelinePlugin(
      JSON.stringify({ toolCallDetailLevel: "overview" }),
    );
  });
-  const directory = await mkdtemp(path.join(tmpdir(), "paseo-timeline-plugin-"));
  const agent = await seedMockAgentWorkspace({
    repoPrefix: "timeline-plugin-",
    title: "Timeline plugin regression",
@@ -73,40 +131,53 @@ export async function withTimelinePlugin(
          }
        : {},
  });
-  const pluginClient = await connectNewWorkspaceDaemonClient({ ownProjects: false });
-  const previous = await pluginClient.getDaemonConfig();
  try {
-    await writeFile(
-      path.join(directory, "paseo-plugin.json"),
-      JSON.stringify({ id: PLUGIN_ID, requirements: pluginRequirements }),
-    );
-    await writeFile(path.join(directory, "index.client.tsx"), CLIENT_SOURCE);
-    await pluginClient.patchDaemonConfig({ pluginsEnabled: true });
-    await pluginClient.installDirectoryPlugin(directory);
-    await openAgentRoute(page, agent);
-    await expect(page.getByRole("textbox", { name: "Message agent..." }).first()).toBeVisible();
-    await run(agent);
-    await info.attach("timeline-plugin", {
-      body: await page.screenshot({ path: info.outputPath("timeline-plugin.png") }),
-      contentType: "image/png",
+    await withDirectoryPlugin({
+      pluginId: PLUGIN_ID,
+      source: CLIENT_SOURCE,
+      run: async () => {
+        try {
+          await openAgentRoute(page, agent);
+          await expect(
+            page.getByRole("textbox", { name: "Message agent..." }).first(),
+          ).toBeVisible();
+          await run(agent);
+          await info.attach("timeline-plugin", {
+            body: await page.screenshot({ path: info.outputPath("timeline-plugin.png") }),
+            contentType: "image/png",
+          });
+        } catch (error) {
+          await info.attach("timeline-before-cleanup", {
+            body: await page.screenshot({ path: info.outputPath("timeline-before-cleanup.png") }),
+            contentType: "image/png",
+          });
+          throw error;
+        }
+      },
    });
-  } catch (error) {
-    await info.attach("timeline-before-cleanup", {
-      body: await page.screenshot({ path: info.outputPath("timeline-before-cleanup.png") }),
-      contentType: "image/png",
-    });
-    throw error;
  } finally {
-    await pluginClient.removePlugin(PLUGIN_ID);
-    await pluginClient.patchDaemonConfig({
-      pluginsEnabled: previous.config.pluginsEnabled ?? false,
-    });
-    await pluginClient.close();
    await agent.cleanup();
-    await rm(directory, { recursive: true, force: true });
  }
 }

+/** Draws all prompts, or only the selected prompts, as plugin cards. */
+export async function withPromptTimelinePlugin(
+  run: () => Promise<void>,
+  prompts?: readonly string[],
+): Promise<void> {
+  await withDirectoryPlugin({
+    pluginId: PROMPT_PLUGIN_ID,
+    source: promptClientSource(prompts),
+    run,
+  });
+}
+
+export async function expectPromptsDrawnByPlugin(page: Page): Promise<void> {
+  const timeline = page.locator('[data-testid="agent-chat-scroll"]:visible').first();
+  await expect(timeline.getByTestId("plugin-prompt").first()).toBeVisible({ timeout: 30_000 });
+  await expect(timeline.getByTestId("user-message")).toHaveCount(0);
+}
+
 export async function requestPluginTimeline(agent: MockAgentWorkspace): Promise<void> {
  await agent.client.sendAgentMessage(agent.agentId, "Exercise timeline transforms.");
 }
@@ -142,3 +213,21 @@ export async function expectBothConsecutiveTools(page: Page): Promise<void> {
  await grep.scrollIntoViewIfNeeded();
  await expect(grep).toBeVisible();
 }
+
+/** The row belongs to the virtualized history, not the always-mounted recent window. */
+export async function expectVirtualizedPluginPromptVisible(
+  page: Page,
+  prompt: string,
+): Promise<void> {
+  const timeline = page.locator('[data-testid="agent-chat-scroll"]:visible').first();
+  await expect(
+    timeline.locator("[data-index]").getByTestId("plugin-prompt").filter({ hasText: prompt }),
+  ).toBeVisible();
+}
+
+export async function attachPromptTimelineEvidence(page: Page, info: TestInfo): Promise<void> {
+  await info.attach("plugin-outline-jump", {
+    body: await page.screenshot({ path: info.outputPath("plugin-outline-jump.png") }),
+    contentType: "image/png",
+  });
+}
@@ -11,7 +11,7 @@ import {
  type UserMessageItem,
 } from "@/types/stream";
 import { transformTimelineItem, type TimelineItemTransform } from "@/plugins/timeline/model";
-import { createStreamPresentation } from "./presentation";
+import { createStreamPresentation, getStreamItemMessageId } from "./presentation";
 import { buildAgentStreamRenderModel } from "./model";

 const runtime = {
@@ -29,7 +29,7 @@ const runtime = {
 } as unknown as PluginClientRuntime;

 function installProbe(
-  itemType: "assistant_message" | "tool_call" | "reasoning",
+  itemType: "user_message" | "assistant_message" | "tool_call" | "reasoning",
  condition = "true",
 ): InstalledPlugin {
  const clientBundle = `(function() {
@@ -160,6 +160,23 @@ describe("stream presentation through installed plugins", () => {
    },
  );

+  it("addresses a prompt a plugin replaced by the prompt's own id", () => {
+    const harness = streamHarness(installedTransform(installProbe("user_message")));
+    const rendered = rows(
+      harness.send({
+        type: "timeline",
+        provider: "claude",
+        item: { type: "user_message", messageId: "prompt-1", text: "Earlier prompt" },
+      }),
+    );
+    const source = rows(harness.source());
+
+    expect(source).toMatchObject([{ kind: "user_message", id: "prompt-1" }]);
+    expect(rendered).toMatchObject([{ kind: "plugin", id: "probe-plugin/prompt-1/0" }]);
+    // The chat outline jumps to the source id; the row it lands on is the plugin's.
+    expect(rendered.map(getStreamItemMessageId)).toEqual(["prompt-1"]);
+  });
+
  it("finishes one message before streaming a different message ID", () => {
    const harness = streamHarness(installedTransform(installProbe("assistant_message")));
    harness.send(assistant("First\n\nBody", "first"));
@@ -26,10 +26,14 @@ function retainItems(previous: StreamItem[], next: StreamItem[]): StreamItem[] {
 /**
 * The source message a display row belongs to. Every assistant message is split into
 * Markdown blocks, so an assistant row id never equals its message id; anything that
- * addresses a message — find, scroll-to-message, history reveal — asks for this.
+ * addresses a message — find, scroll-to-message, history reveal — asks for this. A
+ * plugin row a timeline transformer projected answers for the item it replaced, whose
+ * id is what the chat outline and find hold.
 */
 export function getStreamItemMessageId(item: StreamItem): string {
-  return item.kind === "assistant_message" ? (item.blockGroupId ?? item.id) : item.id;
+  if (item.kind === "assistant_message") return item.blockGroupId ?? item.id;
+  if (item.kind === "plugin") return item.sourceId ?? item.id;
+  return item.id;
 }

 /**
@@ -1,3 +1,4 @@
+import { ComposerEditingSessionsProvider } from "@/composer/editing-session";
 import "@/styles/unistyles";
 import { BottomSheetModalProvider } from "@gorhom/bottom-sheet";
 import { PortalProvider } from "@gorhom/portal";
@@ -625,7 +626,11 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
    surface
  );

-  return <CommandCenterProvider>{content}</CommandCenterProvider>;
+  return (
+    <ComposerEditingSessionsProvider>
+      <CommandCenterProvider>{content}</CommandCenterProvider>
+    </ComposerEditingSessionsProvider>
+  );
 }

 function SidebarChrome({
@@ -21,6 +21,7 @@ import {
 } from "@/plugins/themes";
 import { PLUGIN_THEME_NAMES, PLUGIN_THEME_PREFERENCE, THEME_TO_UNISTYLES } from "@/styles/theme";
 import { applyAppearance } from "./apply";
+import { AppearanceSystemBars } from "./system-bars";

 interface ContributedThemes {
  options: PluginThemeOption[];
@@ -107,7 +108,10 @@ export function AppearanceProvider({ children }: { children: ReactNode }) {
  if (!hasAppliedAppearance) return null;

  return (
-    <ContributedThemesContext.Provider value={value}>{children}</ContributedThemesContext.Provider>
+    <ContributedThemesContext.Provider value={value}>
+      <AppearanceSystemBars />
+      {children}
+    </ContributedThemesContext.Provider>
  );
 }

@@ -0,0 +1,11 @@
+import { SystemBars } from "react-native-edge-to-edge";
+import { withUnistyles } from "react-native-unistyles";
+import type { Theme } from "@/styles/theme";
+
+function ThemeSystemBars({ colorScheme }: Pick<Theme, "colorScheme">) {
+  return <SystemBars style={colorScheme === "light" ? "dark" : "light"} />;
+}
+
+export const AppearanceSystemBars = withUnistyles(ThemeSystemBars, (theme) => ({
+  colorScheme: theme.colorScheme,
+}));
@@ -0,0 +1,3 @@
+export function AppearanceSystemBars() {
+  return null;
+}
@@ -391,6 +391,43 @@ describe("splitHtmlishMarkdown", () => {
    );
  });

+  it("keeps table rows after a comparison that only looks like a tag", () => {
+    const source = [
+      "| ID | Note | Status |",
+      "|---|---|---|",
+      "| a-1 | accepts 1<size<2 only | open |",
+      "| a-2 | second row | open |",
+      "",
+      "Later x -> y.",
+    ].join("\n");
+
+    expect(splitHtmlishMarkdown(source)).toEqual([{ kind: "markdown", text: source }]);
+  });
+
+  it.each(["See <https://example.com/docs> for more.", "Stop when a<b", "Keep </ b> and a <b"])(
+    "keeps %j literal because it is not HTML",
+    (source) => {
+      expect(normalizeHtmlishMarkdown(source)).toBe(source);
+    },
+  );
+
+  it.each([
+    "Call As<Integer>() before limits<DWORD>::max()",
+    "<Kbd Data-Key='K'>Ctrl</Kbd> then <Foo/>",
+  ])("echoes unknown tags in %j as written", (source) => {
+    expect(normalizeHtmlishMarkdown(source)).toBe(source);
+  });
+
+  it("rebuilds an unknown tag that a code span splits", () => {
+    expect(normalizeHtmlishMarkdown('<Tip title="`x`">hi</Tip>')).toBe("`x`<tip title>hi</Tip>");
+  });
+
+  it("still reads tags and comments next to literal angle brackets", () => {
+    expect(normalizeHtmlishMarkdown("1<n<2 <b>bold</b><!-- hidden --> 3<4")).toBe(
+      "1<n<2 **bold** 3<4",
+    );
+  });
+
  it("falls back to inert markdown when details are unclosed", () => {
    const source = "<details><summary>Open</summary>Still open";

@@ -29,6 +29,12 @@ const FENCE_LINE_RE = /^ {0,3}([`~]{3,})[^\n\r]*(?:\r?\n|$)/gm;
 const BACKTICK_RUN_RE = /`+/g;
 const SAFE_IMAGE_SRC_RE = /^(https?:\/\/|data:image\/(?:png|gif|jpe?g);base64,)/i;
 const SAFE_LINK_HREF_RE = /^(https?:\/\/|#(?:$|[\w-]))/i;
+// CommonMark open and closing tags (spec "Raw HTML"); comments are matched separately.
+const HTML_ATTRIBUTE = String.raw`\s+[A-Za-z_:][\w.:-]*(?:\s*=\s*(?:[^\s"'=<>\x60]+|'[^']*'|"[^"]*"))?`;
+const HTML_TAG_RE = new RegExp(
+  String.raw`<(?:[A-Za-z][A-Za-z0-9-]*(?:${HTML_ATTRIBUTE})*\s*\/?|\/[A-Za-z][A-Za-z0-9-]*\s*)>`,
+  "y",
+);
 const VOID_HTML_TAGS = new Set(["br", "img", "source"]);
 const MARKDOWN_TAG_WRAPPERS: Readonly<Record<string, readonly [string, string]>> = {
  b: ["**", "**"],
@@ -373,14 +379,16 @@ function renderInlineTokens(tokens: HtmlToken[]): string {
    }

    const children = tokens.slice(index + 1, closeIndex);
-    output += renderHtmlTag(token, children);
+    const close = tokens[closeIndex];
+    const closeRaw = isClosingTag(close, token.name) ? close.raw : `</${token.name}>`;
+    output += renderHtmlTag(token, children, closeRaw);
    index = closeIndex;
  }

  return output;
 }

-function renderHtmlTag(token: HtmlTagToken, children: HtmlToken[]): string {
+function renderHtmlTag(token: HtmlTagToken, children: HtmlToken[], closeRaw: string): string {
  if (token.name === "a") {
    return renderLinkToken(token, children);
  }
@@ -400,7 +408,7 @@ function renderHtmlTag(token: HtmlTagToken, children: HtmlToken[]): string {
  if (token.name === "p" || token.name === "div") {
    return `\n\n${renderInlineTokens(children).trim()}\n\n`;
  }
-  return `${token.raw}${renderInlineTokens(children)}</${token.name}>`;
+  return `${token.raw}${renderInlineTokens(children)}${closeRaw}`;
 }

 function renderTableTokens(tokens: HtmlToken[]): string {
@@ -606,7 +614,15 @@ function tokenizeHtmlishMarkdown(source: string): HtmlToken[] {
 function createHtmlishTokenParser(source: string, tokens: HtmlToken[]): HtmlishTokenParser {
  let stripNextLeadingLineBreak = false;
  let skippedLength = 0;
+  let writtenLength = 0;
+  let chunkStart = 0;
  let parser!: Parser;
+  // Unknown tags render as text, so keep them as written: the parser lowercases names
+  // and rewrites attributes. A tag split by a protected range has no single slice.
+  const readRawTag = (): string | null =>
+    parser.startIndex < chunkStart
+      ? null
+      : source.slice(parser.startIndex + skippedLength, parser.endIndex + 1 + skippedLength);
  parser = new Parser(
    {
      onopentag(name, attributes, isImplied) {
@@ -620,7 +636,7 @@ function createHtmlishTokenParser(source: string, tokens: HtmlToken[]): HtmlishT
          closing: false,
          selfClosing,
          attributes,
-          raw: renderStartTag(name, attributes),
+          raw: readRawTag() ?? renderStartTag(name, attributes),
        });
      },
      onclosetag(name, isImplied) {
@@ -633,7 +649,7 @@ function createHtmlishTokenParser(source: string, tokens: HtmlToken[]): HtmlishT
          closing: true,
          selfClosing: false,
          attributes: {},
-          raw: `</${name}>`,
+          raw: readRawTag() ?? `</${name}>`,
        });
      },
      ontext(value) {
@@ -660,6 +676,8 @@ function createHtmlishTokenParser(source: string, tokens: HtmlToken[]): HtmlishT
  );
  return {
    write(chunk) {
+      chunkStart = writtenLength;
+      writtenLength += chunk.length;
      parser.write(chunk);
    },
    skip(length) {
@@ -698,7 +716,58 @@ function escapeAttribute(value: string): string {

 function getProtectedMarkdownRanges(source: string): ProtectedMarkdownRange[] {
  const fencedRanges = getFencedCodeRanges(source);
-  return mergeProtectedRanges([...fencedRanges, ...getInlineCodeRanges(source, fencedRanges)]);
+  const codeRanges = mergeProtectedRanges([
+    ...fencedRanges,
+    ...getInlineCodeRanges(source, fencedRanges),
+  ]);
+  return mergeProtectedRanges([...codeRanges, ...getLiteralAngleBracketRanges(source, codeRanges)]);
+}
+
+/**
+ * htmlparser2 reads any `<` followed by a letter as a tag and keeps collecting attributes up
+ * to the next `>`, so `1<n<2` in a table cell swallows the rows after it and an autolink loses
+ * its slashes. Hand it only what CommonMark would read as raw HTML; every other `<` is text.
+ */
+function getLiteralAngleBracketRanges(
+  source: string,
+  codeRanges: ProtectedMarkdownRange[],
+): ProtectedMarkdownRange[] {
+  const ranges: ProtectedMarkdownRange[] = [];
+  let codeIndex = 0;
+  // Reused across comment openers so unclosed comments stay linear.
+  let commentClose = -1;
+  let index = source.indexOf("<");
+
+  while (index !== -1) {
+    while ((codeRanges[codeIndex]?.end ?? Infinity) <= index) {
+      codeIndex += 1;
+    }
+    const code = codeRanges[codeIndex];
+    if (code && code.start <= index) {
+      index = source.indexOf("<", code.end);
+      continue;
+    }
+
+    let htmlEnd: number | null;
+    if (source.startsWith("<!--", index)) {
+      if (commentClose !== source.length && commentClose < index + 2) {
+        const close = source.indexOf("-->", index + 2);
+        commentClose = close === -1 ? source.length : close;
+      }
+      htmlEnd = commentClose === source.length ? null : commentClose + 3;
+    } else {
+      HTML_TAG_RE.lastIndex = index;
+      htmlEnd = HTML_TAG_RE.test(source) ? HTML_TAG_RE.lastIndex : null;
+    }
+
+    if (htmlEnd === null) {
+      ranges.push({ start: index, end: index + 1 });
+      htmlEnd = index + 1;
+    }
+    index = source.indexOf("<", htmlEnd);
+  }
+
+  return ranges;
 }

 function getFencedCodeRanges(source: string): ProtectedMarkdownRange[] {
@@ -160,3 +160,16 @@ describe("combobox above-search ordering", () => {
    expect(getComboboxFallbackIndex(ordered.length, "below-search")).toBe(0);
  });
 });
+
+describe("search-only option text", () => {
+  it("finds hidden search text while keeping title matches first", () => {
+    const bodyMatch = { id: "pr:7", label: "Fix parsing", searchText: "Release notes for 2024" };
+    const titleMatch = { id: "pr:8", label: "2024 release" };
+    expect(filterAndRankComboboxOptions([bodyMatch, titleMatch], "2024")).toEqual([
+      titleMatch,
+      bodyMatch,
+    ]);
+    expect(filterAndRankComboboxOptions([bodyMatch], "unrelated")).toEqual([]);
+    expect(filterAndRankComboboxOptions([bodyMatch], "parsing 2024")).toEqual([bodyMatch]);
+  });
+});
@@ -10,18 +10,22 @@ export interface ComboboxOptionModel {
  id: string;
  label: string;
  description?: string;
+  /** Additional text to match without displaying it in the option row. */
+  searchText?: string;
  kind?: ComboboxOptionKind;
 }

-const DESCRIPTION_FALLBACK_TIER = 99;
+const SECONDARY_TEXT_FALLBACK_TIER = 99;

 function scoreOption(opt: ComboboxOptionModel, search: string): MatchScore | null {
  const best = scoreTextFields(search, [opt.label, opt.id]);
  if (best) return best;
-  if (!opt.description) return null;
-  const descriptionScore = scoreTextFields(search, [opt.description]);
-  if (!descriptionScore) return null;
-  return { ...descriptionScore, tier: descriptionScore.tier + DESCRIPTION_FALLBACK_TIER };
+  const secondaryFields = opt.searchText
+    ? [opt.label, opt.id, opt.description ?? "", opt.searchText]
+    : [opt.description ?? ""];
+  const secondaryScore = scoreTextFields(search, secondaryFields);
+  if (!secondaryScore) return null;
+  return { ...secondaryScore, tier: secondaryScore.tier + SECONDARY_TEXT_FALLBACK_TIER };
 }

 export interface BuildVisibleComboboxOptionsInput {
@@ -56,6 +56,16 @@ afterEach(() => {

 function noop() {}

+function createHandleRecorder() {
+  const handleRef = createRef<EditingTextInputHandle>();
+  const received: (EditingTextInputHandle | null)[] = [];
+  function assignHandle(handle: EditingTextInputHandle | null) {
+    received.push(handle);
+    handleRef.current = handle;
+  }
+  return { handleRef, received, assignHandle };
+}
+
 describe("EditingTextInputNative", () => {
  it("uses the bottom-sheet input only inside a bottom sheet", () => {
    act(() => {
@@ -76,6 +86,32 @@ describe("EditingTextInputNative", () => {
    expect(bottomSheetTextInputRender.mock.calls[0]?.[0]).toMatchObject({ testID: "inside" });
  });

+  it("keeps its editing handle and selection when native editing rerenders the leaf", () => {
+    const { handleRef, received, assignHandle } = createHandleRecorder();
+    act(() =>
+      root?.render(<EditingTextInput ref={assignHandle} initialValue="initial" multiline />),
+    );
+    const input = container?.querySelector("textarea");
+    if (!input) throw new Error("Expected native editing surface");
+    const handle = handleRef.current;
+    act(() => {
+      handle?.focus();
+      const setValue = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value")?.set;
+      if (!setValue) throw new Error("Expected input value setter");
+      setValue.call(input, "native edit");
+      input.setSelectionRange(2, 5);
+      input.dispatchEvent(new InputEvent("input", { bubbles: true, data: "native edit" }));
+    });
+    expect(handleRef.current).toBe(handle);
+    expect(received).toEqual([handle]);
+    expect(handle?.getText()).toBe("native edit");
+    expect([input.selectionStart, input.selectionEnd]).toEqual([2, 5]);
+    expect(document.activeElement).toBe(input);
+    act(() => root?.unmount());
+    root = null;
+    expect(received).toEqual([handle, null]);
+  });
+
  it("clears text via clear() when replaceText receives an empty string", () => {
    const handleRef = createRef<EditingTextInputHandle>();

@@ -105,12 +141,14 @@ describe("EditingTextInputNative", () => {
      );
    });
    const grownInput = container?.querySelector("input");
+    const handle = handleRef.current;

    act(() => {
      handleRef.current?.reset();
    });

    expect(container?.querySelector("input")).not.toBe(grownInput);
+    expect(handleRef.current).toBe(handle);
  });

  it("restores focus after replacing a reset native input", () => {
@@ -69,52 +69,56 @@ export const EditingTextInput = forwardRef<EditingTextInputHandle, EditingTextIn
      setReplacement((current) => ({ ...current, autoFocus }));
    }, []);

-    useImperativeHandle(ref, () => ({
-      focus: () => {
-        if (isAwaitingReplacementRef.current) {
-          setReplacementFocus(true);
-          return;
-        }
-        inputRef.current?.focus();
-      },
-      blur: () => {
-        if (isAwaitingReplacementRef.current) {
-          setReplacementFocus(false);
-          return;
-        }
-        inputRef.current?.blur();
-      },
-      isFocused: () => inputRef.current?.isFocused?.() ?? false,
-      getText: () => textRef.current,
-      replaceText: (nextText, selection) => {
-        textRef.current = nextText;
-        if (inputRef.current?.replaceText) {
-          inputRef.current.replaceText(nextText, selection);
-          return;
-        }
-        if (nextText === "") {
-          inputRef.current?.clear?.();
-          return;
-        }
-        inputRef.current?.setNativeProps?.({
-          text: nextText,
-          ...(selection ? { selection } : {}),
-        });
-        if (selection) inputRef.current?.setSelection?.(selection.start, selection.end);
-      },
-      reset: () => {
-        textRef.current = "";
-        const autoFocus = inputRef.current?.isFocused?.() ?? false;
-        if (inputRef.current?.replaceText) {
-          inputRef.current.replaceText("");
-        } else {
-          inputRef.current?.clear?.();
-        }
-        isAwaitingReplacementRef.current = true;
-        setReplacement((current) => ({ revision: current.revision + 1, autoFocus }));
-      },
-      getNativeRef: () => inputRef.current?.getNativeRef?.() ?? inputRef.current,
-    }));
+    useImperativeHandle(
+      ref,
+      () => ({
+        focus: () => {
+          if (isAwaitingReplacementRef.current) {
+            setReplacementFocus(true);
+            return;
+          }
+          inputRef.current?.focus();
+        },
+        blur: () => {
+          if (isAwaitingReplacementRef.current) {
+            setReplacementFocus(false);
+            return;
+          }
+          inputRef.current?.blur();
+        },
+        isFocused: () => inputRef.current?.isFocused?.() ?? false,
+        getText: () => textRef.current,
+        replaceText: (nextText, selection) => {
+          textRef.current = nextText;
+          if (inputRef.current?.replaceText) {
+            inputRef.current.replaceText(nextText, selection);
+            return;
+          }
+          if (nextText === "") {
+            inputRef.current?.clear?.();
+            return;
+          }
+          inputRef.current?.setNativeProps?.({
+            text: nextText,
+            ...(selection ? { selection } : {}),
+          });
+          if (selection) inputRef.current?.setSelection?.(selection.start, selection.end);
+        },
+        reset: () => {
+          textRef.current = "";
+          const autoFocus = inputRef.current?.isFocused?.() ?? false;
+          if (inputRef.current?.replaceText) {
+            inputRef.current.replaceText("");
+          } else {
+            inputRef.current?.clear?.();
+          }
+          isAwaitingReplacementRef.current = true;
+          setReplacement((current) => ({ revision: current.revision + 1, autoFocus }));
+        },
+        getNativeRef: () => inputRef.current?.getNativeRef?.() ?? inputRef.current,
+      }),
+      [setReplacementFocus],
+    );

    const handleChangeText = useCallback(
      (nextText: string) => {
@@ -57,31 +57,35 @@ export const EditingTextInput = forwardRef<EditingTextInputHandle, EditingTextIn
      onChangeTextRef.current?.(nextText);
    }, []);

-    useImperativeHandle(ref, () => ({
-      focus: () => inputRef.current?.focus(),
-      blur: () => inputRef.current?.blur(),
-      isFocused: () => document.activeElement === inputRef.current,
-      getText: () => {
-        const input = inputRef.current as WebTextInputElement | null;
-        const nextText = input?.value ?? textRef.current;
-        textRef.current = nextText;
-        return nextText;
-      },
-      replaceText: (nextText, selection) => {
-        textRef.current = nextText;
-        const input = inputRef.current as WebTextInputElement | null;
-        if (input && "value" in input) input.value = nextText;
-        if (selection && typeof input?.setSelectionRange === "function") {
-          input.setSelectionRange(selection.start, selection.end);
-        }
-      },
-      reset: () => {
-        textRef.current = "";
-        const input = inputRef.current as WebTextInputElement | null;
-        if (input && "value" in input) input.value = "";
-      },
-      getNativeRef: () => inputRef.current,
-    }));
+    useImperativeHandle(
+      ref,
+      () => ({
+        focus: () => inputRef.current?.focus(),
+        blur: () => inputRef.current?.blur(),
+        isFocused: () => document.activeElement === inputRef.current,
+        getText: () => {
+          const input = inputRef.current as WebTextInputElement | null;
+          const nextText = input?.value ?? textRef.current;
+          textRef.current = nextText;
+          return nextText;
+        },
+        replaceText: (nextText, selection) => {
+          textRef.current = nextText;
+          const input = inputRef.current as WebTextInputElement | null;
+          if (input && "value" in input) input.value = nextText;
+          if (selection && typeof input?.setSelectionRange === "function") {
+            input.setSelectionRange(selection.start, selection.end);
+          }
+        },
+        reset: () => {
+          textRef.current = "";
+          const input = inputRef.current as WebTextInputElement | null;
+          if (input && "value" in input) input.value = "";
+        },
+        getNativeRef: () => inputRef.current,
+      }),
+      [],
+    );

    return (
      <TextInput
@@ -1,6 +1,7 @@
 import type { TextInputProps } from "react-native";
 import type { NativePastedFile } from "@/composer/native-pasted-image";

+/** Stable for the mounted editor lifetime; reset() owns any inner input replacement. */
 export interface EditingTextInputHandle {
  focus(): void;
  blur(): void;
@@ -2,6 +2,7 @@ import { ComposerDockBackground } from "./internal/background";
 export { ComposerDockBackground } from "./internal/background";
 import { ScrollView } from "@/components/ui/scroll-view";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { useIsCompactFormFactor } from "@/constants/layout";
 import { HEADER_INNER_HEIGHT } from "@/constants/layout";
 import { resolveContentMaxWidth, useAppSettings } from "@/hooks/use-settings";
 import { KeyboardTranslateView } from "@/keyboard/shift";
@@ -17,6 +18,7 @@ import Animated, {
 import { useKeyboardShift } from "@/keyboard/shift";
 import {
  resolveCenteredClearance,
+  resolveInlineComposerCapacity,
  updateComposerCapacity,
  type ComposerCapacity,
 } from "./internal/capacity";
@@ -71,12 +73,13 @@ function ComposerViewport({

 /** Bound the complete composer (including its controls), not just the text input. */
 function ComposerViewportContent({ style, ...props }: ViewProps) {
+  const compact = useIsCompactFormFactor();
  const capacity = useContext(ViewportCapacity);
  if (!capacity) throw new Error("ComposerViewportContent requires ComposerViewport");
  const constraint = useAnimatedStyle(() => ({
    // Only viewport changes and keyboard start/end events trigger layout. Motion
    // stays in KeyboardTranslateView and never changes this constraint per frame.
-    maxHeight: capacity.value,
+    maxHeight: resolveInlineComposerCapacity(capacity.value, compact),
  }));

  return (
@@ -1,8 +1,10 @@
 export { ComposerDockBackground } from "./internal/background";
 import { ScrollView } from "@/components/ui/scroll-view";
-import type { ReactNode } from "react";
+import { useState, useCallback, useMemo, type ReactNode } from "react";
 import { View } from "react-native";
 import { StyleSheet } from "react-native-unistyles";
+import { resolveInlineComposerCapacity } from "./internal/capacity";
+import { useIsCompactFormFactor } from "@/constants/layout";
 import { HEADER_INNER_HEIGHT } from "@/constants/layout";

 interface ComposerDockProps {
@@ -14,23 +16,33 @@ export function ComposerDock({
  children: [content, composer, overlay],
  centered = false,
 }: ComposerDockProps) {
+  const compact = useIsCompactFormFactor();
+  const [availableHeight, setAvailableHeight] = useState<number>();
+  const constraint = useMemo(
+    () => ({ maxHeight: resolveInlineComposerCapacity(availableHeight, compact) }),
+    [availableHeight, compact],
+  );
+  const measureViewport = useCallback((event: import("react-native").LayoutChangeEvent) => {
+    const { height } = event.nativeEvent.layout;
+    if (height > 0) setAvailableHeight(height);
+  }, []);
  if (centered) {
    return (
-      <View style={styles.centered}>
+      <View style={styles.centered} onLayout={measureViewport}>
        <View style={styles.form}>
          <ScrollView style={styles.setup} keyboardShouldPersistTaps="handled">
            {content}
          </ScrollView>
-          <View style={styles.centeredComposer}>{composer}</View>
+          <View style={[styles.centeredComposer, constraint]}>{composer}</View>
          {overlay}
        </View>
      </View>
    );
  }
  return (
-    <View style={styles.surface}>
+    <View style={styles.surface} onLayout={measureViewport}>
      <View style={styles.content}>{content}</View>
-      <View style={styles.composer}>{composer}</View>
+      <View style={[styles.composer, constraint]}>{composer}</View>
      {overlay}
    </View>
  );
@@ -1,11 +1,24 @@
 import { describe, expect, it } from "vitest";
 import {
  resolveCenteredClearance,
+  resolveInlineComposerCapacity,
  resolveComposerCapacity,
  updateComposerCapacity,
 } from "./capacity";

 describe("composer viewport", () => {
+  it("caps the complete compact composer at sixty percent of keyboard-reserved space", () => {
+    const open = updateComposerCapacity(undefined, {
+      height: 582,
+      bottomInset: 24,
+      safeAreaBottom: 0,
+      centered: false,
+      keyboardShift: 308,
+    });
+    expect(resolveInlineComposerCapacity(open.capacity, true)).toBe(147);
+    expect(resolveInlineComposerCapacity(open.capacity, false)).toBe(245);
+    expect(resolveInlineComposerCapacity(undefined, true)).toBeUndefined();
+  });
  it("preserves the editing capacity when the keyboard closes", () => {
    const viewport = { height: 582, bottomInset: 24, safeAreaBottom: 0, centered: false };
    const open = updateComposerCapacity(undefined, { ...viewport, keyboardShift: 308 });
@@ -50,3 +50,13 @@ export function updateComposerCapacity(
    capacity: resolveComposerCapacity({ ...input, keyboardShift: keyboardReserve }),
  };
 }
+
+/** Compact editing leaves conversation space above the complete composer. */
+export function resolveInlineComposerCapacity(
+  capacity: number | undefined,
+  compact: boolean,
+): number | undefined {
+  "worklet";
+  if (capacity === undefined) return undefined;
+  return compact ? capacity * 0.6 : capacity;
+}
@@ -115,6 +115,7 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
  const isHydrated = hydratedDraftKey === draftKey;
  const textReplacementRevisionRef = useRef(0);
  const [textReplacement, setTextReplacement] = useState<TextReplacement>(() => ({
+    kind: "initial",
    key: `${draftKey}:0`,
    text: textSource.getSnapshot(),
  }));
@@ -123,6 +124,7 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
    (nextText: string) => {
      textReplacementRevisionRef.current += 1;
      setTextReplacement({
+        kind: "replace",
        key: `${draftKey}:${textReplacementRevisionRef.current}`,
        text: nextText,
      });
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { ComposerEditingSession } from "./index";
+
+function leaveLiveDraft(session: ComposerEditingSession) {
+  session.captureForRemount({
+    snapshot: { text: "Unpublished live draft", selection: { start: 4, end: 17 } },
+    focused: true,
+    replacementKey: "draft:applied",
+  });
+}
+
+describe("composer editing remount handoff", () => {
+  it("keeps live text and selection when remounting from an initial draft publication", () => {
+    const session = new ComposerEditingSession();
+    leaveLiveDraft(session);
+    const handoff = session.takeHandoff({ kind: "initial", key: "draft:initial", text: "stale" });
+    expect(handoff?.snapshot).toEqual({
+      text: "Unpublished live draft",
+      selection: { start: 4, end: 17 },
+    });
+    expect(handoff?.focused).toBe(true);
+  });
+
+  it("keeps local edits when the last applied replacement is still current", () => {
+    const session = new ComposerEditingSession();
+    leaveLiveDraft(session);
+    const handoff = session.takeHandoff({
+      kind: "replace",
+      key: "draft:applied",
+      text: "old replacement",
+    });
+    expect(handoff?.snapshot).toEqual({
+      text: "Unpublished live draft",
+      selection: { start: 4, end: 17 },
+    });
+  });
+
+  it.each(["New explicit draft", ""])(
+    "honors an explicit replacement made while the editor is absent: %j",
+    (text) => {
+      const session = new ComposerEditingSession();
+      leaveLiveDraft(session);
+      const handoff = session.takeHandoff({ kind: "replace", key: "draft:new", text });
+      expect(handoff?.snapshot).toEqual({
+        text,
+        selection: { start: text.length, end: text.length },
+      });
+      expect(handoff?.focused).toBe(true);
+      expect(session.takeHandoff({ kind: "replace", key: "draft:new", text })).toBeNull();
+    },
+  );
+});
@@ -0,0 +1,142 @@
+import React, {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  useSyncExternalStore,
+  type ReactNode,
+} from "react";
+import type { TextReplacement } from "@/composer/types";
+import type { ComposerInputMode } from "@/composer/input-mode";
+
+export interface ComposerEditingHandoff {
+  snapshot: { text: string; selection: { start: number; end: number } };
+  focused: boolean;
+  replacementKey: string;
+}
+
+/** Editing metadata outlives a layout's input; draft text still belongs to its draft owner. */
+export class ComposerEditingSession {
+  private fullscreen = false;
+  private handoff: ComposerEditingHandoff | null = null;
+  private listeners = new Set<() => void>();
+  getFullscreen = () => this.fullscreen;
+  subscribe = (listener: () => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  changePresentation(fullscreen: boolean, handoff: ComposerEditingHandoff) {
+    this.captureForRemount(handoff);
+    if (fullscreen === this.fullscreen) return;
+    this.fullscreen = fullscreen;
+    for (const listener of this.listeners) listener();
+  }
+  captureForRemount(handoff: ComposerEditingHandoff) {
+    this.handoff = handoff;
+  }
+  peekHandoff(replacement: TextReplacement): ComposerEditingHandoff | null {
+    const handoff = this.handoff;
+    if (!handoff || replacement.kind === "initial" || replacement.key === handoff.replacementKey)
+      return handoff;
+    // A replacement command issued since capture supersedes the old editor's live buffer.
+    return {
+      snapshot: {
+        text: replacement.text,
+        selection: { start: replacement.text.length, end: replacement.text.length },
+      },
+      focused: handoff.focused,
+      replacementKey: replacement.key,
+    };
+  }
+  takeHandoff(replacement: TextReplacement) {
+    const handoff = this.peekHandoff(replacement);
+    this.handoff = null;
+    return handoff;
+  }
+}
+
+class ComposerEditingSessions {
+  private workspaces = new Map<
+    string,
+    Map<string, { targetKey: string; sessions: Map<ComposerInputMode, ComposerEditingSession> }>
+  >();
+  get(workspaceKey: string, tabId: string, targetKey: string, purpose: ComposerInputMode) {
+    let workspace = this.workspaces.get(workspaceKey);
+    if (!workspace) {
+      workspace = new Map();
+      this.workspaces.set(workspaceKey, workspace);
+    }
+    let tab = workspace.get(tabId);
+    if (!tab || tab.targetKey !== targetKey) {
+      tab = { targetKey, sessions: new Map() };
+      workspace.set(tabId, tab);
+    }
+    let session = tab.sessions.get(purpose);
+    if (!session) {
+      session = new ComposerEditingSession();
+      tab.sessions.set(purpose, session);
+    }
+    return session;
+  }
+  retain(workspaceKey: string, tabIds: readonly string[]) {
+    const workspace = this.workspaces.get(workspaceKey);
+    if (!workspace) return;
+    const retained = new Set(tabIds);
+    for (const tabId of workspace.keys()) if (!retained.has(tabId)) workspace.delete(tabId);
+    if (workspace.size === 0) this.workspaces.delete(workspaceKey);
+  }
+}
+
+const SessionsContext = createContext<ComposerEditingSessions | null>(null);
+const WorkspaceContext = createContext<string | null>(null);
+const ScopeContext = createContext<{ tabId: string; targetKey: string } | null>(null);
+
+/** App-container ownership survives replacement of both the gesture shell and tab layout. */
+export function ComposerEditingSessionsProvider({ children }: { children: ReactNode }) {
+  const [sessions] = useState(() => new ComposerEditingSessions());
+  return <SessionsContext.Provider value={sessions}>{children}</SessionsContext.Provider>;
+}
+export function WorkspaceComposerEditingSessionsProvider({
+  workspaceKey,
+  tabIds,
+  children,
+}: {
+  workspaceKey: string;
+  tabIds: readonly string[];
+  children: ReactNode;
+}) {
+  const sessions = useContext(SessionsContext);
+  useEffect(() => sessions?.retain(workspaceKey, tabIds), [sessions, workspaceKey, tabIds]);
+  return <WorkspaceContext.Provider value={workspaceKey}>{children}</WorkspaceContext.Provider>;
+}
+export function ComposerEditingScope({
+  tabId,
+  targetKey,
+  children,
+}: {
+  tabId: string;
+  targetKey: string;
+  children: ReactNode;
+}) {
+  const scope = useMemo(() => ({ tabId, targetKey }), [tabId, targetKey]);
+  return <ScopeContext.Provider value={scope}>{children}</ScopeContext.Provider>;
+}
+export function useComposerEditingSession(
+  purpose: ComposerInputMode,
+  provided?: ComposerEditingSession,
+): ComposerEditingSession {
+  const sessions = useContext(SessionsContext);
+  const scope = useContext(ScopeContext);
+  const workspaceKey = useContext(WorkspaceContext);
+  const [local] = useState(() => provided ?? new ComposerEditingSession());
+  if (provided) return provided;
+  return sessions && scope && workspaceKey
+    ? sessions.get(workspaceKey, scope.tabId, scope.targetKey, purpose)
+    : local;
+}
+export function useComposerFullscreen(session: ComposerEditingSession): boolean {
+  return useSyncExternalStore(session.subscribe, session.getFullscreen, session.getFullscreen);
+}
@@ -1,3 +1,4 @@
+import { useComposerEditingSession, useComposerFullscreen } from "./editing-session";
 import type { ComposerTextSource } from "./text-source";
 import { createStore, type StoreApi } from "zustand/vanilla";
 import { useStore } from "zustand";
@@ -1003,8 +1004,10 @@ function ComposerAutocompleteBinding({
    cursorIndex: Math.min(cursorIndex, userInput.length),
    onAutocompleteApplied: () => inputRef.current?.focus(),
  });
-  useImperativeHandle(ref, () => ({ onKeyPress: autocomplete.onKeyPress }), [
-    autocomplete.onKeyPress,
+  const handleKeyPress = autocomplete.onKeyPress;
+  useImperativeHandle(ref, () => ({ onKeyPress: (event) => show && handleKeyPress(event) }), [
+    show,
+    handleKeyPress,
  ]);
  const selectOption = autocomplete.onSelectOption;
  const onSelect = useCallback(
@@ -1336,6 +1339,8 @@ function ComposerContentImpl({
  const nextPendingFileId = useRef(0);
  const isUploadingFile = pendingFiles.length > 0;
  const [pendingNativeImagePastes, setPendingNativeImagePastes] = useState(0);
+  const editingSession = useComposerEditingSession(inputMode);
+  const isFullscreen = useComposerFullscreen(editingSession);
  const [sendError, setSendError] = useState<string | null>(null);
  const [isMessageInputFocused, setIsMessageInputFocused] = useState(false);
  const [isGithubPickerOpen, setIsGithubPickerOpen] = useState(false);
@@ -2364,7 +2369,7 @@ function ComposerContentImpl({
        <View style={inputAreaContainerStyle}>
          <View style={styles.inputAreaContent}>
            {queueList}
-            {sendErrorNode}
+            {!isFullscreen && sendErrorNode}

            <View ref={messageInputContainerRef} style={styles.messageInputContainer}>
              <ComposerAutocompleteBinding
@@ -2372,7 +2377,7 @@ function ComposerContentImpl({
                cursor={cursor}
                inputRef={messageInputRef}
                anchorRef={messageInputContainerRef}
-                show={mode.showAutocomplete}
+                show={mode.showAutocomplete && !isFullscreen}
                ref={autocompleteRef}
                configuration={autocompleteConfiguration}
              />
@@ -2387,6 +2392,8 @@ function ComposerContentImpl({
              <RenderProfile id="MessageInput">
                <StableMessageInput
                  ref={messageInputRef}
+                  editingSession={editingSession}
+                  submissionError={sendErrorNode}
                  value={textSource.getSnapshot()}
                  onChangeText={setUserInput}
                  onSubmit={handleSubmit}
@@ -0,0 +1,57 @@
+import { useEffect, type ReactNode } from "react";
+import { Portal } from "@gorhom/portal";
+import { BackHandler, View, useWindowDimensions } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { StyleSheet } from "react-native-unistyles";
+import Animated, { useAnimatedStyle } from "react-native-reanimated";
+import { DEFAULT_FLOATING_PANEL_PORTAL_HOST } from "@/components/ui/floating-panel-portal";
+import { useKeyboardShift } from "@/keyboard/shift";
+
+/** Same-window host keeps the IME attached while escaping the dock's clipping. */
+export function ComposerFullscreenHost({
+  children,
+  onExit,
+  active,
+}: {
+  children: ReactNode;
+  onExit: () => void;
+  active: boolean;
+}) {
+  useEffect(() => {
+    if (!active) return;
+    const handler = BackHandler.addEventListener("hardwareBackPress", () => {
+      onExit();
+      return true;
+    });
+    return () => handler.remove();
+  }, [active, onExit]);
+  const insets = useSafeAreaInsets();
+  const { height } = useWindowDimensions();
+  const { layoutShift } = useKeyboardShift();
+  const frame = useAnimatedStyle(() => ({
+    height: Math.max(0, height - layoutShift.value),
+    paddingTop: insets.top,
+    paddingBottom: insets.bottom,
+    paddingLeft: insets.left,
+    paddingRight: insets.right,
+  }));
+  return (
+    <Portal hostName={DEFAULT_FLOATING_PANEL_PORTAL_HOST}>
+      <View style={[styles.background, !active && styles.hidden]}>
+        <Animated.View style={[{ width: "100%" }, frame]}>{children}</Animated.View>
+      </View>
+    </Portal>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  hidden: { display: "none" },
+  background: {
+    position: "absolute",
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0,
+    backgroundColor: theme.colors.surface1,
+  },
+}));
@@ -0,0 +1,77 @@
+import { useMemo, useLayoutEffect, useState, type ReactNode } from "react";
+import { createPortal } from "react-dom";
+import { View } from "react-native";
+import {
+  getOverlayRoot,
+  useOverlayLayer,
+  OverlayLayerProvider,
+  useWebOverlayRegistration,
+} from "@/lib/overlay-root";
+
+export function ComposerFullscreenHost({
+  children,
+  onExit,
+  active,
+}: {
+  children: ReactNode;
+  onExit: () => void;
+  active: boolean;
+}) {
+  const layer = useOverlayLayer("modal");
+  const registration = useWebOverlayRegistration({
+    active,
+    layer,
+    onKeyDown: (event) => {
+      if (event.key !== "Escape") return false;
+      event.preventDefault();
+      onExit();
+      return true;
+    },
+  });
+  const [viewport, setViewport] = useState(readVisibleViewport);
+  useLayoutEffect(() => {
+    if (!active) return;
+    const update = () => setViewport(readVisibleViewport());
+    const visualViewport = window.visualViewport;
+    update();
+    visualViewport?.addEventListener("resize", update);
+    visualViewport?.addEventListener("scroll", update);
+    window.addEventListener("resize", update);
+    return () => {
+      visualViewport?.removeEventListener("resize", update);
+      visualViewport?.removeEventListener("scroll", update);
+      window.removeEventListener("resize", update);
+    };
+  }, [active]);
+  const frameStyle = useMemo(
+    () => ({
+      display: active ? ("flex" as const) : ("none" as const),
+      position: "absolute" as const,
+      top: viewport.top,
+      left: viewport.left,
+      width: viewport.width,
+      zIndex: layer,
+      pointerEvents: "auto" as const,
+      height: viewport.height,
+    }),
+    [active, layer, viewport],
+  );
+  return createPortal(
+    <OverlayLayerProvider layer={layer}>
+      <View ref={registration} style={frameStyle}>
+        {children}
+      </View>
+    </OverlayLayerProvider>,
+    getOverlayRoot(),
+  );
+}
+
+function readVisibleViewport() {
+  const viewport = window.visualViewport;
+  return {
+    top: viewport?.offsetTop ?? 0,
+    left: viewport?.offsetLeft ?? 0,
+    width: viewport?.width ?? window.innerWidth,
+    height: viewport?.height ?? window.innerHeight,
+  };
+}
@@ -7,6 +7,8 @@ interface ComposerHeightArgs {
  textareaRef: RefObject<unknown>;
  minHeight: number;
  maxHeight: number;
+  onRenderedLinesChange?: (lines: number) => void;
+  presentationKey?: boolean;
 }

 export function useComposerHeight({
@@ -7,6 +7,8 @@ interface ComposerHeightArgs {
  textareaRef: RefObject<HTMLElement | null>;
  minHeight: number;
  maxHeight: number;
+  onRenderedLinesChange?: (lines: number) => void;
+  presentationKey?: boolean;
 }

 const COPIED_STYLES = [
@@ -36,11 +38,13 @@ export function useComposerHeight({
  textareaRef,
  minHeight,
  maxHeight,
+  onRenderedLinesChange,
+  presentationKey,
 }: ComposerHeightArgs): ComposerHeightResult {
  const [height, setHeight] = useState(minHeight);
  const heightRef = useRef(minHeight);
-  const paramsRef = useRef({ getText, minHeight, maxHeight });
-  paramsRef.current = { getText, minHeight, maxHeight };
+  const paramsRef = useRef({ getText, minHeight, maxHeight, onRenderedLinesChange });
+  paramsRef.current = { getText, minHeight, maxHeight, onRenderedLinesChange };
  const mirrorRef = useRef<HTMLTextAreaElement | null>(null);

  const setBoundedHeight = useCallback((nextHeight: number) => {
@@ -65,6 +69,13 @@ export function useComposerHeight({
      }
      mirror.style.width = `${sourceWidth}px`;
      mirror.value = text.endsWith("\n") ? `${text} ` : text;
+      const padding =
+        parseFloat(computedStyle.paddingTop) + parseFloat(computedStyle.paddingBottom);
+      const lineHeight = parseFloat(computedStyle.lineHeight);
+      if (lineHeight > 0)
+        paramsRef.current.onRenderedLinesChange?.(
+          Math.round((mirror.scrollHeight - padding) / lineHeight),
+        );
      setBoundedHeight(mirror.scrollHeight);
    },
    [setBoundedHeight, textareaRef],
@@ -101,7 +112,7 @@ export function useComposerHeight({

  useLayoutEffect(() => {
    measure(getText());
-  }, [maxHeight, minHeight, getText, measure]);
+  }, [maxHeight, minHeight, getText, measure, presentationKey]);

  useEffect(() => {
    const source = textareaRef.current;
@@ -115,7 +126,7 @@ export function useComposerHeight({
    });
    observer.observe(source);
    return () => observer.disconnect();
-  }, [measure, textareaRef]);
+  }, [measure, textareaRef, presentationKey]);

  const onTextChange = useCallback(
    (_previousText: string, nextText: string) => measure(nextText),
@@ -1,3 +1,8 @@
+import {
+  useComposerEditingSession,
+  useComposerFullscreen,
+  type ComposerEditingSession,
+} from "@/composer/editing-session";
 import { LoadingSpinner } from "@/components/ui/loading-spinner";
 import {
  View,
@@ -56,6 +61,7 @@ import { useIsCompactFormFactor } from "@/constants/layout";
 import { useComposerKeyboardScope } from "@/composer/keyboard-scope";
 import { RenderProfile } from "@/utils/render-profiler";
 import { useComposerHeight } from "./height";
+import { ComposerInputPresentation } from "./presentation";
 import { resolveComposerInputMode, type ComposerInputMode } from "@/composer/input-mode";
 import type { NativePastedFile } from "@/composer/native-pasted-image";
 import {
@@ -77,6 +83,7 @@ import {
  applyDictationTranscript,
  computeCanStartDictation,
  resolveComposerSurfacePresentation,
+  resolveComposerSurfaceText,
  runAlternateSendAction,
  runDefaultSendAction,
  runMessageInputKeyboardAction,
@@ -106,6 +113,8 @@ export interface ComposerKeyPressEvent {
 }

 export interface MessageInputProps {
+  editingSession?: ComposerEditingSession;
+  submissionError?: React.ReactNode;
  value: string;
  onChangeText: (text: string) => void;
  onSubmit: (payload: MessagePayload) => void;
@@ -206,6 +215,7 @@ type WebTextInputKeyPressEvent = NativeSyntheticEvent<
 >;

 interface TextAreaHandle {
+  value?: string;
  scrollHeight?: number;
  clientHeight?: number;
  offsetHeight?: number;
@@ -215,7 +225,7 @@ interface TextAreaHandle {
  style?: {
    height?: string;
    overflowY?: string;
-  } & Record<string, unknown>;
+  };
 }

 function AttachButtonIcon({
@@ -433,7 +443,7 @@ function getTextInputNativeElement(current: ComposerTextInputHandle | null): HTM
 }

 interface PasteImagesEffectArgs {
-  getWebTextArea: () => TextAreaHandle | null;
+  textarea: HTMLElement | null;
  isConnected: boolean;
  disabled: boolean;
  isDictating: boolean;
@@ -443,7 +453,7 @@ interface PasteImagesEffectArgs {

 function usePasteImagesEffect(args: PasteImagesEffectArgs): void {
  const {
-    getWebTextArea,
+    textarea,
    isConnected,
    disabled,
    isDictating,
@@ -454,19 +464,7 @@ function usePasteImagesEffect(args: PasteImagesEffectArgs): void {
  useEffect(() => {
    if (!isWeb || !onAddImages) return;

-    const textarea = getWebTextArea() as
-      | (TextAreaHandle & {
-          addEventListener?: (type: string, listener: (e: ClipboardEvent) => void) => void;
-          removeEventListener?: (type: string, listener: (e: ClipboardEvent) => void) => void;
-        })
-      | null;
-    if (
-      !textarea ||
-      typeof textarea.addEventListener !== "function" ||
-      typeof textarea.removeEventListener !== "function"
-    ) {
-      return;
-    }
+    if (!textarea) return;

    let disposed = false;
    const handlePaste = (event: ClipboardEvent) => {
@@ -493,14 +491,7 @@ function usePasteImagesEffect(args: PasteImagesEffectArgs): void {
      disposed = true;
      textarea.removeEventListener?.("paste", handlePaste);
    };
-  }, [
-    disabled,
-    getWebTextArea,
-    isConnected,
-    isDictating,
-    isRealtimeVoiceForCurrentAgent,
-    onAddImages,
-  ]);
+  }, [disabled, textarea, isConnected, isDictating, isRealtimeVoiceForCurrentAgent, onAddImages]);
 }

 function useAutoFocusOnWebEffect(
@@ -628,6 +619,7 @@ function FocusHint({
 interface ComposerTextSurfaceProps {
  readOnly: boolean;
  value: string;
+  textReplacementKey: string;
  textInputRef: React.Ref<ComposerTextInputHandle>;
  textInputStyle: EditingTextInputProps["style"];
  readOnlyTextStyle: React.ComponentProps<typeof Text>["style"];
@@ -643,6 +635,9 @@ interface ComposerTextSurfaceProps {
  onSelectionChange: (event: NativeSyntheticEvent<TextInputSelectionChangeEventData>) => void;
  onPasteImages: ((files: readonly NativePastedFile[]) => void) | undefined;
  onPasteError: (message: string) => void;
+  fullscreen: boolean;
+  compact: boolean;
+  onRenderedLinesChange: (lines: number) => void;
  focusHintVisible: boolean;
  focusInputKeys: ShortcutChord | null | undefined;
  focusHintLabel: string;
@@ -654,6 +649,23 @@ interface ComposerTextSurfaceProps {
 * state of this composer rather than a second one.
 */
 function ComposerTextSurface(props: ComposerTextSurfaceProps): React.ReactElement {
+  const { onChangeText, onRenderedLinesChange } = props;
+  const [measurementText, setMeasurementText] = useState(props.value);
+  useEffect(() => {
+    if (!isWeb) setMeasurementText(props.value);
+  }, [props.value, props.textReplacementKey]);
+  const handleTextChange = useCallback(
+    (text: string) => {
+      if (!isWeb) setMeasurementText(text);
+      onChangeText(text);
+    },
+    [onChangeText, setMeasurementText],
+  );
+  const measureLines = useCallback(
+    (event: import("react-native").TextLayoutEvent) =>
+      onRenderedLinesChange(event.nativeEvent.lines.length),
+    [onRenderedLinesChange],
+  );
  if (props.readOnly) {
    return (
      <View style={styles.textInputScrollWrapper}>
@@ -664,12 +676,28 @@ function ComposerTextSurface(props: ComposerTextSurfaceProps): React.ReactElemen
    );
  }
  return (
-    <View style={styles.textInputScrollWrapper}>
+    <View
+      style={[
+        styles.textInputScrollWrapper,
+        props.fullscreen && styles.fullscreenTextSurface,
+        props.compact && !props.fullscreen && styles.compactTextSurface,
+      ]}
+    >
+      {!isWeb && props.compact && !props.fullscreen ? (
+        <Text
+          accessible={false}
+          pointerEvents="none"
+          style={[props.textInputStyle, styles.lineMeasurement]}
+          onTextLayout={measureLines}
+        >
+          {`${measurementText}\u200b`}
+        </Text>
+      ) : null}
      <ComposerTextInput
        ref={props.textInputRef}
        dataSet={COMPOSER_INPUT_DATASET}
        initialValue={props.value}
-        onChangeText={props.onChangeText}
+        onChangeText={handleTextChange}
        placeholder={props.placeholder}
        accessibilityLabel={props.accessibilityLabel}
        onFocus={props.onFocus}
@@ -843,6 +871,7 @@ interface ToggleRealtimeVoiceContext {
  handleStopRealtimeVoice: () => Promise<unknown> | void;
  toast: { error: (msg: string) => void };
  interruptBeforeVoiceMessage: string;
+  exitFullscreen: () => void;
 }

 function toggleRealtimeVoiceImpl(ctx: ToggleRealtimeVoiceContext): void {
@@ -858,6 +887,7 @@ function toggleRealtimeVoiceImpl(ctx: ToggleRealtimeVoiceContext): void {
    ctx.toast.error(ctx.interruptBeforeVoiceMessage);
    return;
  }
+  ctx.exitFullscreen();
  void ctx.voice.startVoice(ctx.voiceServerId, ctx.voiceAgentId).catch((error) => {
    console.error("[MessageInput] Failed to start realtime voice", error);
    const message = extractErrorMessage(error);
@@ -872,6 +902,7 @@ interface StartDictationContext {
  canStartDictation: () => boolean;
  toast: { error: (msg: string) => void };
  startDictation: () => Promise<void>;
+  exitFullscreen: () => void;
 }

 async function startDictationIfAvailableImpl(ctx: StartDictationContext): Promise<void> {
@@ -882,6 +913,7 @@ async function startDictationIfAvailableImpl(ctx: StartDictationContext): Promis
  if (!ctx.canStartDictation()) {
    return;
  }
+  ctx.exitFullscreen();
  await ctx.startDictation();
 }

@@ -983,7 +1015,8 @@ function computeIsDictationStartEnabled(
  return (isReadyForDictation ?? isConnected) && !disabled;
 }

-function resolveMaxInputHeight(windowHeight: number): number {
+function resolveMaxInputHeight(windowHeight: number, compact: boolean): number {
+  if (compact) return DEFAULT_MAX_INPUT_HEIGHT;
  if (!Number.isFinite(windowHeight) || windowHeight <= 0) return DEFAULT_MAX_INPUT_HEIGHT;
  return Math.max(DEFAULT_MAX_INPUT_HEIGHT, Math.floor(windowHeight * MAX_INPUT_VIEWPORT_RATIO));
 }
@@ -1007,9 +1040,12 @@ function getComposerInputSnapshot(
  current: ComposerTextInputHandle | null,
  fallbackText: string,
  fallbackSelection: ComposerInputSnapshot["selection"],
+  mountedTextArea?: TextAreaHandle | null,
 ): ComposerInputSnapshot {
-  const text = current?.getText() ?? fallbackText;
-  const textArea = getWebTextAreaImpl(current);
+  // The inner DOM ref can detach before the outer editing handle. Keep the mounted
+  // element available until this owner's ref callback captures the remount handoff.
+  const textArea = mountedTextArea ?? getWebTextAreaImpl(current);
+  const text = textArea?.value ?? current?.getText() ?? fallbackText;
  const start = textArea?.selectionStart ?? fallbackSelection.start;
  const end = textArea?.selectionEnd ?? fallbackSelection.end;
  return { text, selection: { start, end } };
@@ -1139,6 +1175,28 @@ function extractErrorMessage(error: unknown): string | null {
  return null;
 }

+function resolvePresentationSendDisabled(input: {
+  fullscreen: boolean;
+  disabled: boolean;
+  hasText: boolean;
+  attachments: ComposerAttachment[];
+  hasExternalContent: boolean;
+  allowEmpty: boolean;
+}): boolean {
+  return (
+    input.disabled || (input.fullscreen && !input.allowEmpty && !hasSendableComposerContent(input))
+  );
+}
+
+function shouldShowFullscreenControl(
+  compact: boolean,
+  readOnly: boolean,
+  overlayVisible: boolean,
+  renderedLines: number,
+) {
+  return compact && !readOnly && !overlayVisible && renderedLines > 2;
+}
+
 export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
  function MessageInput(props, ref) {
    const {
@@ -1186,11 +1244,15 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
      textReplacement,
      submitLabel,
    } = resolveMessageInputProps(props);
+    const { isActiveComposer } = useComposerKeyboardScope();
    const mode = resolveComposerInputMode(inputMode);
    const { t } = useTranslation();
    const isCompact = useIsCompactFormFactor();
    const { height: windowHeight } = useWindowDimensions();
-    const maxInputHeight = resolveMaxInputHeight(windowHeight);
+    const editingSession = useComposerEditingSession(inputMode, props.editingSession);
+    const isFullscreen = useComposerFullscreen(editingSession);
+    const [renderedLines, setRenderedLines] = useState(1);
+    const maxInputHeight = resolveMaxInputHeight(windowHeight, isCompact);
    const buttonIconSize = isWeb ? ICON_SIZE.md : ICON_SIZE.lg;
    const toast = useToast();
    const voice = useVoiceOptional();
@@ -1207,27 +1269,19 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
    const inputWrapperRef = useRef<View | null>(null);
    const textInputRef = useRef<ComposerTextInputHandle | null>(null);
    const isInputFocusedRef = useRef(false);
-    const valueRef = useRef(value);
-    const selectionRef = useRef({ start: value.length, end: value.length });
-    const appliedTextReplacementKeyRef = useRef(textReplacement.key);
-    const webTextareaRef = useRef<HTMLElement | null>(null);
-    const getLiveText = useCallback(() => valueRef.current, []);
-    const composerHeight = useComposerHeight({
-      getText: getLiveText,
-      textareaRef: webTextareaRef,
-      minHeight: MIN_INPUT_HEIGHT,
-      maxHeight: maxInputHeight,
-    });
-    const { style: composerHeightStyle, scrollEnabled: isComposerScrollEnabled } = composerHeight;
-    const measuredComposerHeight = composerHeight.mode === "measured" ? composerHeight : undefined;
-    const updateComposerHeightForText = measuredComposerHeight?.onTextChange;
-    const resetComposerHeight = measuredComposerHeight?.reset;
-
-    const handleComposerLayout = useCallback(
-      (event: LayoutChangeEvent) => onHeightChange?.(event.nativeEvent.layout.height),
-      [onHeightChange],
+    const handoff = editingSession.peekHandoff(textReplacement);
+    const focusIntentRef = useRef(Boolean(handoff?.focused));
+    const valueRef = useRef(handoff?.snapshot.text ?? value);
+    const selectionRef = useRef(
+      handoff?.snapshot.selection ?? { start: value.length, end: value.length },
    );
-
+    const activeComposerRef = useRef(isActiveComposer);
+    activeComposerRef.current = isActiveComposer;
+    const [webTextArea, setWebTextArea] = useState<HTMLElement | null>(null);
+    const appliedTextReplacementKeyRef = useRef(textReplacement.key);
+    const textReplacementRef = useRef(textReplacement);
+    textReplacementRef.current = textReplacement;
+    const webTextareaRef = useRef<HTMLElement | null>(null);
    const updateLiveTextPresence = useCallback((text: string) => {
      const nextHasLiveText = text.trim().length > 0;
      if (hasLiveTextRef.current === nextHasLiveText) return;
@@ -1235,6 +1289,82 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
      setHasLiveText(nextHasLiveText);
    }, []);

+    const assignTextInput = useCallback(
+      (input: ComposerTextInputHandle | null) => {
+        const previous = textInputRef.current;
+        if (!input && previous) {
+          editingSession.captureForRemount({
+            snapshot: getComposerInputSnapshot(
+              previous,
+              valueRef.current,
+              selectionRef.current,
+              webTextareaRef.current,
+            ),
+            focused: previous.isFocused() || isInputFocusedRef.current,
+            replacementKey: appliedTextReplacementKeyRef.current,
+          });
+        }
+        textInputRef.current = input;
+        if (isWeb) {
+          const element = getWebTextAreaImpl(input) as HTMLElement | null;
+          webTextareaRef.current = element;
+          setWebTextArea(element);
+        }
+        if (!input) return;
+        const transfer = editingSession.takeHandoff(textReplacementRef.current);
+        if (transfer) {
+          appliedTextReplacementKeyRef.current = textReplacementRef.current.key;
+          valueRef.current = transfer.snapshot.text;
+          updateLiveTextPresence(transfer.snapshot.text);
+          selectionRef.current = transfer.snapshot.selection;
+          input.replaceText(transfer.snapshot.text, transfer.snapshot.selection);
+          if (transfer.focused && activeComposerRef.current) input.focus();
+        }
+      },
+      [editingSession, updateLiveTextPresence],
+    );
+    useLayoutEffect(() => {
+      if (isActiveComposer && focusIntentRef.current) textInputRef.current?.focus();
+    }, [isActiveComposer]);
+    const getLiveText = useCallback(() => valueRef.current, []);
+    const composerHeight = useComposerHeight({
+      getText: getLiveText,
+      textareaRef: webTextareaRef,
+      minHeight: MIN_INPUT_HEIGHT,
+      maxHeight: maxInputHeight,
+      onRenderedLinesChange: setRenderedLines,
+      presentationKey: isFullscreen,
+    });
+    const { style: composerHeightStyle, scrollEnabled: isComposerScrollEnabled } = composerHeight;
+    const measuredComposerHeight = composerHeight.mode === "measured" ? composerHeight : undefined;
+    const updateComposerHeightForText = measuredComposerHeight?.onTextChange;
+    const resetComposerHeight = measuredComposerHeight?.reset;
+
+    const changePresentation = useCallback(
+      (fullscreen: boolean) => {
+        if (editingSession.getFullscreen() === fullscreen) return;
+        const snapshot = getComposerInputSnapshot(
+          textInputRef.current,
+          valueRef.current,
+          selectionRef.current,
+        );
+        editingSession.changePresentation(fullscreen, {
+          snapshot,
+          focused: textInputRef.current?.isFocused() ?? isInputFocusedRef.current,
+          replacementKey: appliedTextReplacementKeyRef.current,
+        });
+        valueRef.current = snapshot.text;
+        selectionRef.current = snapshot.selection;
+      },
+      [editingSession],
+    );
+    const exitFullscreen = useCallback(() => changePresentation(false), [changePresentation]);
+
+    const handleComposerLayout = useCallback(
+      (event: LayoutChangeEvent) => onHeightChange?.(event.nativeEvent.layout.height),
+      [onHeightChange],
+    );
+
    const replaceText = useCallback(
      (nextText: string, selection?: { start: number; end: number }) => {
        updateComposerHeightForText?.(valueRef.current, nextText);
@@ -1412,8 +1542,9 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
          canStartDictation,
          toast,
          startDictation,
+          exitFullscreen,
        }),
-      [canStartDictation, dictationUnavailableMessage, startDictation, toast],
+      [canStartDictation, dictationUnavailableMessage, startDictation, toast, exitFullscreen],
    );

    const handleVoicePress = useCallback(
@@ -1485,10 +1616,12 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
        handleStopRealtimeVoice,
        toast,
        interruptBeforeVoiceMessage: t("composer.voice.interruptBeforeVoice"),
+        exitFullscreen,
      });
    }, [
      disabled,
      handleStopRealtimeVoice,
+      exitFullscreen,
      isAgentRunning,
      isConnected,
      t,
@@ -1572,10 +1705,10 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
      if (isWeb) {
        webTextareaRef.current = getWebTextArea() as HTMLElement | null;
      }
-    }, [getWebTextArea]);
+    }, [getWebTextArea, isFullscreen]);

    usePasteImagesEffect({
-      getWebTextArea,
+      textarea: webTextArea,
      isConnected,
      disabled,
      isDictating,
@@ -1596,16 +1729,30 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
    const shouldHandleWebKeyPress = isWeb;
    const shouldSubmitOnEnter = isWeb && !isCompact;

-    function handleDesktopKeyPress(event: WebTextInputKeyPressEvent) {
-      if (!shouldHandleWebKeyPress) return;
-      handleDesktopKeyPressImpl(event, {
+    const handleDesktopKeyPress = useCallback(
+      (event: WebTextInputKeyPressEvent) => {
+        if (!shouldHandleWebKeyPress) return;
+        handleDesktopKeyPressImpl(event, {
+          onKeyPressCallback,
+          input: getComposerInputSnapshot(
+            textInputRef.current,
+            valueRef.current,
+            selectionRef.current,
+          ),
+          submitOnEnter: shouldSubmitOnEnter,
+          isAgentRunning,
+          onQueue,
+          isSubmitDisabled,
+          isSubmitLoading,
+          disabled,
+          handleAlternateSendAction,
+          handleDefaultSendAction,
+        });
+      },
+      [
+        shouldHandleWebKeyPress,
        onKeyPressCallback,
-        input: getComposerInputSnapshot(
-          textInputRef.current,
-          valueRef.current,
-          selectionRef.current,
-        ),
-        submitOnEnter: shouldSubmitOnEnter,
+        shouldSubmitOnEnter,
        isAgentRunning,
        onQueue,
        isSubmitDisabled,
@@ -1613,8 +1760,8 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
        disabled,
        handleAlternateSendAction,
        handleDefaultSendAction,
-      });
-    }
+      ],
+    );

    const primaryActionKind = resolvePrimaryActionKind({
      hasSendableContent: hasSendableComposerContent({
@@ -1678,16 +1825,18 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
    );

    const handleInputFocus = useCallback(() => {
+      focusIntentRef.current = true;
      isInputFocusedRef.current = true;
      setIsInputFocused(true);
      onFocusChange?.(true);
    }, [onFocusChange]);

    const handleInputBlur = useCallback(() => {
+      if (activeComposerRef.current && !isFullscreen) focusIntentRef.current = false;
      isInputFocusedRef.current = false;
      setIsInputFocused(false);
      onFocusChange?.(false);
-    }, [onFocusChange]);
+    }, [isFullscreen, onFocusChange]);

    const handlePasteError = useCallback(
      (message: string) => {
@@ -1735,8 +1884,12 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
    // `fontFamily` here is silently dropped while every other property lands.
    // An inline style outranks both classes. See docs/unistyles.md.
    const textInputStyle = useMemo(
-      () => [styles.textInput, mode.isMonospace && styles.textInputMonospace, composerHeightStyle],
-      [composerHeightStyle, mode.isMonospace],
+      () => [
+        styles.textInput,
+        mode.isMonospace && styles.textInputMonospace,
+        isFullscreen ? styles.fullscreenTextInput : composerHeightStyle,
+      ],
+      [composerHeightStyle, mode.isMonospace, isFullscreen],
    );
    // Static content has no textarea to mirror, so it grows with its own text
    // instead of the measured input height.
@@ -1780,107 +1933,192 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
      [isDictating, isRealtimeVoiceForCurrentAgent, voice?.isMuted, buttonIconSize],
    );

-    return (
-      <View
-        ref={rootRef}
-        style={styles.container}
-        testID="message-input-root"
-        onLayout={handleComposerLayout}
-      >
-        <MessageInputAutoFocus
-          enabled={autoFocus}
-          autoFocusKey={autoFocusKey}
-          textInputRef={textInputRef}
+    const sendButton = useMemo(
+      () => (
+        <PrimaryAction
+          kind={isFullscreen ? "send" : primaryActionKind}
+          activeActionContent={activeActionContent}
+          shouldShow
+          canPressLoadingButton={canPressLoadingButton}
+          onSubmitLoadingPress={onSubmitLoadingPress}
+          onDefaultSendAction={handleDefaultSendAction}
+          isSendButtonDisabled={resolvePresentationSendDisabled({
+            fullscreen: isFullscreen,
+            disabled: isSendButtonDisabled,
+            hasText: hasLiveText,
+            attachments,
+            hasExternalContent,
+            allowEmpty: allowEmptySubmit,
+          })}
+          submitAccessibilityLabel={submitAccessibilityLabel}
+          sendButtonCombinedStyle={sendButtonCombinedStyle}
+          isSubmitLoading={isSubmitLoading}
+          submitIcon={submitIcon}
+          submitLabel={submitLabel}
+          submitButtonTestID={submitButtonTestID}
+          buttonIconSize={buttonIconSize}
+          sendKeys={DEFAULT_SEND_KEYS}
+          sendTooltipLabel={sendTooltipLabel}
        />
-        {/* Regular input */}
-        <View
-          ref={inputWrapperRef}
-          style={inputWrapperCombinedStyle}
-          pointerEvents={surfacePresentation.input.pointerEvents}
-        >
-          {attachmentSlot}
-          {/* Text input */}
-          <RenderProfile id="ComposerTextSurface">
-            <ComposerTextSurface
-              readOnly={readOnly}
-              value={value}
-              textInputRef={textInputRef}
-              textInputStyle={textInputStyle}
-              readOnlyTextStyle={readOnlyTextStyle}
-              placeholder={placeholder ?? t("composer.placeholders.fallback")}
-              accessibilityLabel={t(mode.accessibilityLabelKey)}
-              onChangeText={handleInputChange}
-              onFocus={handleInputFocus}
-              onBlur={handleInputBlur}
-              editable={!isDictating && !isRealtimeVoiceForCurrentAgent && !disabled}
-              scrollEnabled={isComposerScrollEnabled}
-              autoFocus={false}
-              onKeyPress={shouldHandleWebKeyPress ? handleDesktopKeyPress : undefined}
-              onSelectionChange={handleSelectionChange}
-              onPasteImages={onPasteImages}
-              onPasteError={handlePasteError}
-              focusHintVisible={isWeb && !isInputFocused && !value}
-              focusInputKeys={focusInputKeys}
-              focusHintLabel={t("composer.input.focusHint", {
-                shortcut: focusInputKeys ? formatShortcut(focusInputKeys[0], getShortcutOs()) : "",
-              })}
+      ),
+      [
+        isFullscreen,
+        primaryActionKind,
+        activeActionContent,
+        canPressLoadingButton,
+        onSubmitLoadingPress,
+        handleDefaultSendAction,
+        isSendButtonDisabled,
+        hasLiveText,
+        attachments,
+        hasExternalContent,
+        allowEmptySubmit,
+        submitAccessibilityLabel,
+        sendButtonCombinedStyle,
+        isSubmitLoading,
+        submitIcon,
+        submitLabel,
+        submitButtonTestID,
+        buttonIconSize,
+        sendTooltipLabel,
+      ],
+    );
+    const textSurface = useMemo(
+      () => (
+        <RenderProfile id="ComposerTextSurface">
+          <ComposerTextSurface
+            readOnly={readOnly}
+            value={
+              readOnly
+                ? value
+                : resolveComposerSurfaceText(
+                    valueRef.current,
+                    textReplacement,
+                    appliedTextReplacementKeyRef.current,
+                  )
+            }
+            textReplacementKey={textReplacement.key}
+            textInputRef={assignTextInput}
+            textInputStyle={textInputStyle}
+            readOnlyTextStyle={readOnlyTextStyle}
+            placeholder={placeholder ?? t("composer.placeholders.fallback")}
+            accessibilityLabel={t(mode.accessibilityLabelKey)}
+            onChangeText={handleInputChange}
+            onFocus={handleInputFocus}
+            onBlur={handleInputBlur}
+            editable={!isDictating && !isRealtimeVoiceForCurrentAgent && !disabled}
+            scrollEnabled={isComposerScrollEnabled}
+            autoFocus={
+              Boolean(editingSession.peekHandoff(textReplacement)?.focused) && isActiveComposer
+            }
+            onKeyPress={shouldHandleWebKeyPress ? handleDesktopKeyPress : undefined}
+            onSelectionChange={handleSelectionChange}
+            onPasteImages={onPasteImages}
+            onPasteError={handlePasteError}
+            fullscreen={isFullscreen}
+            compact={isCompact}
+            onRenderedLinesChange={setRenderedLines}
+            focusHintVisible={!isFullscreen && isWeb && !isInputFocused && !value}
+            focusInputKeys={focusInputKeys}
+            focusHintLabel={t("composer.input.focusHint", {
+              shortcut: focusInputKeys ? formatShortcut(focusInputKeys[0], getShortcutOs()) : "",
+            })}
+          />
+        </RenderProfile>
+      ),
+      [
+        readOnly,
+        textReplacement,
+        editingSession,
+        isActiveComposer,
+        assignTextInput,
+        textInputStyle,
+        readOnlyTextStyle,
+        placeholder,
+        t,
+        mode.accessibilityLabelKey,
+        handleInputChange,
+        handleInputFocus,
+        handleInputBlur,
+        isDictating,
+        isRealtimeVoiceForCurrentAgent,
+        disabled,
+        isComposerScrollEnabled,
+        shouldHandleWebKeyPress,
+        handleDesktopKeyPress,
+        handleSelectionChange,
+        onPasteImages,
+        handlePasteError,
+        isFullscreen,
+        isCompact,
+        isInputFocused,
+        value,
+        focusInputKeys,
+      ],
+    );
+    const toolbar = useMemo(
+      () => (
+        <View style={styles.buttonRow}>
+          {/* Toolbar left: attachment button + agent controls */}
+          <View style={styles.leftButtonGroup}>
+            <AttachmentDropdown
+              visible={mode.showAttachments}
+              isConnected={isConnected}
+              disabled={disabled}
+              attachButtonStyle={attachButtonStyle}
+              renderAttachButtonIcon={renderAttachButtonIcon}
+              attachmentMenuItems={attachmentMenuItems}
+              addAttachmentLabel={t("composer.input.addAttachment")}
            />
-          </RenderProfile>
+            {leftContent}
+          </View>

-          {/* Button row */}
-          <View style={styles.buttonRow}>
-            {/* Toolbar left: attachment button + agent controls */}
-            <View style={styles.leftButtonGroup}>
-              <AttachmentDropdown
-                visible={mode.showAttachments}
-                isConnected={isConnected}
-                disabled={disabled}
-                attachButtonStyle={attachButtonStyle}
-                renderAttachButtonIcon={renderAttachButtonIcon}
-                attachmentMenuItems={attachmentMenuItems}
-                addAttachmentLabel={t("composer.input.addAttachment")}
-              />
-              {leftContent}
-            </View>
-
-            {/* Right: voice button, contextual button (realtime/send/cancel) */}
-            <View style={styles.rightButtonGroup}>
-              {beforeVoiceContent}
-              <VoiceButtonTooltip
-                visible={mode.showVoice}
-                onVoicePress={handleVoicePress}
-                isDictationStartEnabled={isDictationStartEnabled}
-                voiceButtonAccessibilityLabel={voiceButtonAccessibilityLabel}
-                voiceButtonStyle={voiceButtonStyle}
-                renderVoiceButtonIcon={renderVoiceButtonIcon}
-                voiceTooltipText={voiceTooltipText}
-                isRealtimeVoiceForCurrentAgent={isRealtimeVoiceForCurrentAgent}
-                voiceMuteToggleKeys={voiceMuteToggleKeys}
-                dictationToggleKeys={dictationToggleKeys}
-              />
-              {rightContent}
-              <PrimaryAction
-                kind={primaryActionKind}
-                activeActionContent={activeActionContent}
-                shouldShow
-                canPressLoadingButton={canPressLoadingButton}
-                onSubmitLoadingPress={onSubmitLoadingPress}
-                onDefaultSendAction={handleDefaultSendAction}
-                isSendButtonDisabled={isSendButtonDisabled}
-                submitAccessibilityLabel={submitAccessibilityLabel}
-                sendButtonCombinedStyle={sendButtonCombinedStyle}
-                isSubmitLoading={isSubmitLoading}
-                submitIcon={submitIcon}
-                submitLabel={submitLabel}
-                submitButtonTestID={submitButtonTestID}
-                buttonIconSize={buttonIconSize}
-                sendKeys={DEFAULT_SEND_KEYS}
-                sendTooltipLabel={sendTooltipLabel}
-              />
-            </View>
+          {/* Right: voice button, contextual button (realtime/send/cancel) */}
+          <View style={styles.rightButtonGroup}>
+            {beforeVoiceContent}
+            <VoiceButtonTooltip
+              visible={mode.showVoice}
+              onVoicePress={handleVoicePress}
+              isDictationStartEnabled={isDictationStartEnabled}
+              voiceButtonAccessibilityLabel={voiceButtonAccessibilityLabel}
+              voiceButtonStyle={voiceButtonStyle}
+              renderVoiceButtonIcon={renderVoiceButtonIcon}
+              voiceTooltipText={voiceTooltipText}
+              isRealtimeVoiceForCurrentAgent={isRealtimeVoiceForCurrentAgent}
+              voiceMuteToggleKeys={voiceMuteToggleKeys}
+              dictationToggleKeys={dictationToggleKeys}
+            />
+            {rightContent}
+            {sendButton}
          </View>
        </View>
-
+      ),
+      [
+        mode.showAttachments,
+        isConnected,
+        disabled,
+        attachButtonStyle,
+        renderAttachButtonIcon,
+        attachmentMenuItems,
+        t,
+        leftContent,
+        beforeVoiceContent,
+        mode.showVoice,
+        handleVoicePress,
+        isDictationStartEnabled,
+        voiceButtonAccessibilityLabel,
+        voiceButtonStyle,
+        renderVoiceButtonIcon,
+        voiceTooltipText,
+        isRealtimeVoiceForCurrentAgent,
+        voiceMuteToggleKeys,
+        dictationToggleKeys,
+        rightContent,
+        sendButton,
+      ],
+    );
+    const voiceOverlay = useMemo(
+      () => (
        <View
          style={overlayContainerStyle}
          pointerEvents={surfacePresentation.overlay.pointerEvents}
@@ -1903,6 +2141,62 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
            onRealtimeVoiceStop={handleRealtimeVoiceStop}
          />
        </View>
+      ),
+      [
+        overlayContainerStyle,
+        surfacePresentation.overlay.pointerEvents,
+        showDictationOverlay,
+        showRealtimeOverlay,
+        voice,
+        dictationVolume,
+        dictationDuration,
+        isDictating,
+        isDictationProcessing,
+        dictationStatus,
+        dictationError,
+        handleCancelRecording,
+        handleAcceptRecording,
+        handleAcceptAndSendRecording,
+        handleRetryFailedRecording,
+        handleDiscardFailedRecording,
+        handleRealtimeVoiceStop,
+      ],
+    );
+    const enterFullscreen = useCallback(() => changePresentation(true), [changePresentation]);
+    return (
+      <View
+        ref={rootRef}
+        style={styles.container}
+        testID="message-input-root"
+        onLayout={handleComposerLayout}
+      >
+        <MessageInputAutoFocus
+          enabled={autoFocus}
+          autoFocusKey={autoFocusKey}
+          textInputRef={textInputRef}
+        />
+        <ComposerInputPresentation
+          fullscreen={isFullscreen}
+          iconSize={buttonIconSize}
+          active={isActiveComposer}
+          surface={textSurface}
+          toolbar={toolbar}
+          send={sendButton}
+          error={props.submissionError}
+          onExit={exitFullscreen}
+          inputWrapperRef={inputWrapperRef}
+          inputWrapperStyle={inputWrapperCombinedStyle}
+          inputPointerEvents={surfacePresentation.input.pointerEvents}
+          attachmentSlot={attachmentSlot}
+          showFullscreenButton={shouldShowFullscreenControl(
+            isCompact,
+            readOnly,
+            showOverlay,
+            renderedLines,
+          )}
+          onEnter={enterFullscreen}
+          overlay={voiceOverlay}
+        />
      </View>
    );
  },
@@ -1947,6 +2241,19 @@ const styles = StyleSheet.create((theme: Theme) => ({
  inputWrapperReadOnly: {
    borderStyle: "dotted",
  },
+  compactTextSurface: { paddingRight: 36 },
+  fullscreenTextSurface: { flex: 1, minHeight: 0 },
+  fullscreenTextInput: { flex: 1, height: "100%", textAlignVertical: "top" },
+  lineMeasurement: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 36,
+    opacity: 0,
+    maxHeight: undefined,
+    minHeight: undefined,
+    height: undefined,
+  },
  textInputScrollWrapper: {
    flexShrink: 1,
    position: "relative",
@@ -0,0 +1,146 @@
+import { useCallback, useMemo, type ReactNode, type Ref } from "react";
+import { View, type ViewProps } from "react-native";
+import { Maximize2, Minimize2 } from "lucide-react-native";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/components/ui/button";
+import { isWeb } from "@/constants/platform";
+import { StyleSheet } from "react-native-unistyles";
+import { ComposerFullscreenHost } from "./fullscreen-host";
+
+function keepEditorFocused(event: import("react-native").PointerEvent) {
+  if (isWeb) event.preventDefault();
+}
+
+/** Both presentations receive the same editing surface and send capability. */
+export function ComposerInputPresentation({
+  fullscreen,
+  iconSize,
+  active,
+  surface,
+  toolbar,
+  send,
+  error,
+  onExit,
+  inputWrapperRef,
+  inputWrapperStyle,
+  inputPointerEvents,
+  attachmentSlot,
+  showFullscreenButton,
+  onEnter,
+  overlay,
+}: {
+  fullscreen: boolean;
+  iconSize: number;
+  active: boolean;
+  surface: ReactNode;
+  toolbar: ReactNode;
+  send: ReactNode;
+  error: ReactNode;
+  onExit: () => void;
+  inputWrapperRef: Ref<View>;
+  inputWrapperStyle: ViewProps["style"];
+  inputPointerEvents: ViewProps["pointerEvents"];
+  attachmentSlot: ReactNode;
+  showFullscreenButton: boolean;
+  onEnter: () => void;
+  overlay: ReactNode;
+}) {
+  const { t } = useTranslation();
+  // ArrowUp ends at x19; the fullscreen glyphs end at x21 in Lucide's 24px viewBox.
+  // Compensate for that difference to align visible ink with Send, not just boxes.
+  const railAdjustment = iconSize / 12;
+  const maximizeIcon = useCallback(
+    (color: string) => <Maximize2 color={color} size={iconSize} />,
+    [iconSize],
+  );
+  const minimizeIcon = useCallback(
+    (color: string) => <Minimize2 color={color} size={iconSize} />,
+    [iconSize],
+  );
+  const enterStyle = useMemo(
+    () => [styles.fullscreenButton, { right: -6 + railAdjustment }],
+    [railAdjustment],
+  );
+  const exitStyle = useMemo(
+    () => [styles.iconButton, { marginRight: railAdjustment }],
+    [railAdjustment],
+  );
+  if (!fullscreen)
+    return (
+      <>
+        <View ref={inputWrapperRef} style={inputWrapperStyle} pointerEvents={inputPointerEvents}>
+          {attachmentSlot}
+          <View style={styles.inlineTextSurface}>
+            {surface}
+            {showFullscreenButton ? (
+              <Button
+                variant="ghost"
+                size="xs"
+                accessibilityLabel={t("composer.input.fullscreen")}
+                leftIcon={maximizeIcon}
+                onPointerDown={keepEditorFocused}
+                onPress={onEnter}
+                style={enterStyle}
+                hitSlop={8}
+              >
+                {null}
+              </Button>
+            ) : null}
+          </View>
+          {toolbar}
+        </View>
+        {overlay}
+      </>
+    );
+  return (
+    <ComposerFullscreenHost onExit={onExit} active={active}>
+      <View style={styles.fullscreen} testID="composer-fullscreen">
+        <View style={styles.exitRow}>
+          <Button
+            variant="ghost"
+            size="xs"
+            accessibilityLabel={t("composer.input.exitFullscreen")}
+            onPointerDown={keepEditorFocused}
+            onPress={onExit}
+            style={exitStyle}
+            leftIcon={minimizeIcon}
+            hitSlop={8}
+          >
+            {null}
+          </Button>
+        </View>
+        {surface}
+        {error}
+        <View style={styles.sendRow}>{send}</View>
+      </View>
+    </ComposerFullscreenHost>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  inlineTextSurface: { flexShrink: 1, position: "relative" },
+  iconButton: {
+    width: 28,
+    height: 28,
+    padding: 0,
+    borderWidth: 0,
+    borderRadius: theme.borderRadius.full,
+  },
+  fullscreenButton: {
+    position: "absolute",
+    top: 0,
+    width: 28,
+    height: 28,
+    padding: 0,
+    borderWidth: 0,
+    borderRadius: theme.borderRadius.full,
+  },
+  fullscreen: {
+    flex: 1,
+    backgroundColor: theme.colors.surface1,
+    padding: theme.spacing[4],
+    gap: theme.spacing[3],
+  },
+  exitRow: { alignItems: "flex-end", flexShrink: 0 },
+  sendRow: { flexShrink: 0, alignItems: "flex-end" },
+}));
@@ -4,6 +4,7 @@ import {
  computeCanStartDictation,
  resolveActiveSendBehavior,
  resolveComposerSurfacePresentation,
+  resolveComposerSurfaceText,
  runAlternateSendAction,
  runDefaultSendAction,
  runMessageInputKeyboardAction,
@@ -316,3 +317,26 @@ describe("stopRealtimeVoice", () => {
    expect(calls).toEqual(["cancel agent", "stop voice"]);
  });
 });
+
+describe("composer surface text", () => {
+  it("measures a new nonempty replacement before it reaches the editing handle", () => {
+    const replacement = { kind: "replace" as const, key: "draft:2", text: "First\nSecond\nThird" };
+    expect(resolveComposerSurfaceText("Short draft", replacement, "draft:1")).toBe(
+      replacement.text,
+    );
+  });
+
+  it("keeps live typing once the replacement is applied", () => {
+    const replacement = { kind: "replace" as const, key: "draft:2", text: "First\nSecond\nThird" };
+    expect(resolveComposerSurfaceText("Edited live draft", replacement, "draft:2")).toBe(
+      "Edited live draft",
+    );
+  });
+
+  it("uses the live handoff when its replacement has already been applied", () => {
+    const replacement = { kind: "initial" as const, key: "draft:0", text: "Stale publication" };
+    expect(resolveComposerSurfaceText("Live remount handoff", replacement, "draft:0")).toBe(
+      "Live remount handoff",
+    );
+  });
+});
@@ -1,6 +1,6 @@
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import type { ActiveTurnBehavior } from "@getpaseo/protocol/messages";
-import type { MessagePayload } from "@/composer/types";
+import type { MessagePayload, TextReplacement } from "@/composer/types";
 import type { MessageInputKeyboardActionKind } from "@/keyboard/actions";

 export type SendBehavior = ActiveTurnBehavior | "queue";
@@ -192,3 +192,11 @@ export async function stopRealtimeVoice(ctx: StopRealtimeVoiceContext): Promise<

  await ctx.voice.stopVoice();
 }
+
+export function resolveComposerSurfaceText(
+  liveText: string,
+  replacement: TextReplacement,
+  appliedReplacementKey: string,
+): string {
+  return replacement.key === appliedReplacementKey ? liveText : replacement.text;
+}
@@ -96,6 +96,35 @@ describe("ComposerTextInput web IME composition", () => {
    expect(document.activeElement).toBe(mounted.textarea);
  });

+  it("keeps its editing handle and selection across a rerender during composition", () => {
+    const recorder = createTextRecorder();
+    const mounted = mountInput(recorder.onChangeText);
+    const handle = mounted.inputRef.current;
+    act(() => {
+      handle?.focus();
+      dispatchComposition(mounted.textarea, "compositionstart");
+      typeFromIme(mounted.textarea, "你好");
+      mounted.textarea.setSelectionRange(1, 2);
+      mounted.root.render(
+        <ComposerTextInput
+          ref={mounted.inputRef}
+          initialValue="stale publication"
+          multiline
+          onChangeText={recorder.onChangeText}
+          placeholder="updated presentation"
+        />,
+      );
+    });
+    expect(mounted.inputRef.current).toBe(handle);
+    expect(handle?.getNativeRef()).toBe(mounted.textarea);
+    expect([mounted.textarea.selectionStart, mounted.textarea.selectionEnd]).toEqual([1, 2]);
+    expect(document.activeElement).toBe(mounted.textarea);
+    expect(recorder.changes).toEqual([]);
+    act(() => dispatchComposition(mounted.textarea, "compositionend"));
+    expect(recorder.changes).toEqual(["你好"]);
+    expect(handle?.getText()).toBe("你好");
+  });
+
  it("keeps locally typed text when its parent rerenders with a stale value", () => {
    const recorder = createTextRecorder();
    const mounted = mountInput(recorder.onChangeText);
@@ -10,6 +10,7 @@ export interface MessagePayload {
 }

 export interface TextReplacement {
+  kind: "initial" | "replace";
  key: string;
  text: string;
 }
@@ -124,6 +124,8 @@ export const ar: TranslationResources = {
    input: {
      accessibilityLabel: "وكيل الرسائل...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "ملء الشاشة",
+      exitFullscreen: "الخروج من ملء الشاشة",
      focusHint: "{{shortcut}}للتركيز",
      addAttachment: "إضافة مرفق",
      interruptAgent: "عامل المقاطعة",
@@ -120,6 +120,8 @@ export const en = {
    input: {
      accessibilityLabel: "Message agent...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "Fullscreen",
+      exitFullscreen: "Exit fullscreen",
      focusHint: "{{shortcut}} to focus",
      addAttachment: "Add attachment",
      interruptAgent: "Interrupt agent",
@@ -125,6 +125,8 @@ export const es: TranslationResources = {
    input: {
      accessibilityLabel: "Agente de mensajes...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "Pantalla completa",
+      exitFullscreen: "Salir de pantalla completa",
      focusHint: "{{shortcut}}para enfocar",
      addAttachment: "Agregar archivo adjunto",
      interruptAgent: "agente de interrupción",
@@ -126,6 +126,8 @@ export const fr: TranslationResources = {
    input: {
      accessibilityLabel: "Écrire à l’agent…",
      terminalAccessibilityLabel: "Prompt du terminal",
+      fullscreen: "Plein écran",
+      exitFullscreen: "Quitter le plein écran",
      focusHint: "{{shortcut}} pour saisir",
      addAttachment: "Ajouter une pièce jointe",
      interruptAgent: "Interrompre l’agent",
@@ -125,6 +125,8 @@ export const ja: TranslationResources = {
    input: {
      accessibilityLabel: "エージェントにメッセージ...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "全画面表示",
+      exitFullscreen: "全画面表示を終了",
      focusHint: "{{shortcut}}でフォーカス",
      addAttachment: "添付ファイルを追加",
      interruptAgent: "エージェントを中断",
@@ -124,6 +124,8 @@ export const ko: TranslationResources = {
    input: {
      accessibilityLabel: "에이전트에게 메시지...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "전체 화면",
+      exitFullscreen: "전체 화면 종료",
      focusHint: "{{shortcut}}로 포커스",
      addAttachment: "첨부 추가",
      interruptAgent: "에이전트 중단",
@@ -125,6 +125,8 @@ export const ptBR: TranslationResources = {
    input: {
      accessibilityLabel: "Enviar mensagem ao agente...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "Tela cheia",
+      exitFullscreen: "Sair da tela cheia",
      focusHint: "{{shortcut}} para focar",
      addAttachment: "Adicionar anexo",
      interruptAgent: "Interromper agente",
@@ -125,6 +125,8 @@ export const ru: TranslationResources = {
    input: {
      accessibilityLabel: "Написать агенту...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "Полный экран",
+      exitFullscreen: "Выйти из полноэкранного режима",
      focusHint: "{{shortcut}}, для фокуса",
      addAttachment: "Добавить вложение",
      interruptAgent: "Прервать агента",
@@ -124,6 +124,8 @@ export const zhCN: TranslationResources = {
    input: {
      accessibilityLabel: "给 Agent 发消息...",
      terminalAccessibilityLabel: "Terminal prompt",
+      fullscreen: "全屏",
+      exitFullscreen: "退出全屏",
      focusHint: "{{shortcut}} 聚焦",
      addAttachment: "添加附件",
      interruptAgent: "中断 Agent",
@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import { formatShortcut } from "@/utils/format-shortcut";
+import { keyboardEventToComboString } from "./shortcut-string";
 import {
  buildKeyboardShortcutHelpSections,
  buildEffectiveBindings,
@@ -1026,6 +1027,25 @@ describe("unassigned shortcuts", () => {
  });

  describe("matching", () => {
+    it("dispatches a captured Dvorak binding on the same logical key", () => {
+      const event = keyboardInput({ key: "b", code: "KeyN", metaKey: true });
+      const combo = keyboardEventToComboString(event as KeyboardEvent);
+      expect(combo).toBe("Cmd+B");
+      const bindings = buildEffectiveBindings({ "sidebar-toggle-left-mac-cmd-b": combo! });
+
+      expect(
+        resolveShortcut({ event, context: { isMac: true, isDesktop: true }, bindings }).match
+          ?.action,
+      ).toBe("sidebar.toggle.left");
+      expect(
+        resolveShortcut({
+          event: { key: "x", code: "KeyB", metaKey: true },
+          context: { isMac: true, isDesktop: true },
+          bindings,
+        }).match,
+      ).toBeNull();
+    });
+
    it("stops matching a shortcut the user unassigned", () => {
      const bindings = buildEffectiveBindings({ [TAB_NEW_BINDING]: UNASSIGNED_COMBO });

@@ -22,6 +22,45 @@ function keyboardEvent(overrides: Partial<KeyboardEvent>): KeyboardEvent {
 }

 describe("keyboardEventToComboString", () => {
+  it("captures the Dvorak character rather than its QWERTY position", () => {
+    expect(
+      keyboardEventToComboString(keyboardEvent({ key: "b", code: "KeyN", metaKey: true })),
+    ).toBe("Cmd+B");
+  });
+
+  it("captures shifted Dvorak letters and punctuation at other physical positions", () => {
+    expect(
+      keyboardEventToComboString(
+        keyboardEvent({ key: "T", code: "KeyK", metaKey: true, shiftKey: true }),
+      ),
+    ).toBe("Shift+Cmd+T");
+    expect(
+      keyboardEventToComboString(keyboardEvent({ key: ";", code: "KeyZ", ctrlKey: true })),
+    ).toBe("Ctrl+;");
+    expect(
+      keyboardEventToComboString(
+        keyboardEvent({ key: "?", code: "BracketLeft", ctrlKey: true, shiftKey: true }),
+      ),
+    ).toBe("Ctrl+Shift+/");
+  });
+
+  it("keeps named keys and rewritten Option characters capturable", () => {
+    expect(keyboardEventToComboString(keyboardEvent({ key: "ArrowLeft", code: "ArrowLeft" }))).toBe(
+      "ArrowLeft",
+    );
+    expect(
+      keyboardEventToComboString(keyboardEvent({ key: "†", code: "KeyT", altKey: true })),
+    ).toBe("Alt+T");
+  });
+
+  it("does not record a named key that dispatch does not support", () => {
+    expect(
+      keyboardEventToComboString(
+        keyboardEvent({ key: "Enter", code: "NumpadEnter", ctrlKey: true }),
+      ),
+    ).toBeNull();
+  });
+
  it("captures the minus key (regression: previously returned null)", () => {
    expect(keyboardEventToComboString(keyboardEvent({ key: "-", code: "Minus" }))).toBe("-");
  });
@@ -266,7 +266,16 @@ export function keyboardEventToComboString(event: KeyboardEvent): string | null
  if (event.shiftKey) parts.push("Shift");
  if (event.metaKey) parts.push("Cmd");

-  const humanKey = CODE_TO_KEY[event.code];
+  // Capture the same logical character that dispatch matches. Keep the code
+  // fallback for named keys and Option combinations whose key is rewritten.
+  const eventKey = event.key.toLowerCase();
+  const logicalKey = Object.entries(KEY_MAP).find(
+    ([, mapping]) =>
+      mapping.key?.length === 1 &&
+      (mapping.key.toLowerCase() === eventKey ||
+        (event.shiftKey && mapping.shiftedKey === event.key)),
+  )?.[0];
+  const humanKey = logicalKey ?? CODE_TO_KEY[event.code];
  if (humanKey) {
    parts.push(humanKey);
  } else {
@@ -104,6 +104,7 @@ function transformSourceItem(
    const projected: PluginTimelineStreamItem = {
      kind: "plugin",
      id: `${pluginItem.pluginId}/${pluginItem.id}`,
+      sourceId: item.id,
      timestamp: item.timestamp,
      pluginId: pluginItem.pluginId,
      pluginItemId: pluginItem.id,
@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import { buildVisibleComboboxOptions } from "@/components/ui/combobox-options";
 import type { ForgeSearchItem } from "@getpaseo/protocol/messages";
 import {
  type BranchPickerDetail,
@@ -340,3 +341,48 @@ describe("defaultBasePickerItem", () => {
    expect(defaultBasePickerItem({ currentBranch: null })).toBeNull();
  });
 });
+
+describe("starting-ref search", () => {
+  it.each(["gitlab", "github"] as const)(
+    "keeps a %s change request returned for a body-only match",
+    (forge) => {
+      const item: ForgeSearchItem = {
+        ...prItem,
+        forge,
+        number: 3896,
+        title: "fix(config): send environment credentials only to trusted hosts",
+        body: "This mirrors the fix shipped for CVE-2024-53858.",
+        headRefName: "8545-duo-test",
+      };
+      const { options } = buildPickerOptionData({
+        branchDetails: [],
+        prItems: [item],
+        baseItem: null,
+      });
+      const visible = buildVisibleComboboxOptions({
+        options,
+        searchQuery: "2024",
+        searchable: true,
+        allowCustomValue: false,
+        customValuePrefix: "Use",
+      });
+      expect(visible.map((option) => option.label)).toEqual([
+        `${forge === "gitlab" ? "!" : "#"}3896 fix(config): send environment credentials only to trusted hosts`,
+      ]);
+      const selected = buildPickerOptionData({
+        branchDetails: [],
+        prItems: [],
+        baseItem: { kind: "github-pr", item },
+      });
+      expect(
+        buildVisibleComboboxOptions({
+          options: selected.options,
+          searchQuery: "2024",
+          searchable: true,
+          allowCustomValue: false,
+          customValuePrefix: "Use",
+        }),
+      ).toEqual(visible);
+    },
+  );
+});
@@ -264,7 +264,10 @@ export function buildPickerOptionData(input: {
    itemById.set(id, { kind: "github-pr", item: pr });
    const updatedAtMs = pr.updatedAt ? Date.parse(pr.updatedAt) : 0;
    const timestamp = Number.isNaN(updatedAtMs) ? 0 : Math.floor(updatedAtMs / 1000);
-    timedOptions.push({ option: { id, label: formatPrLabel(pr) }, timestamp });
+    timedOptions.push({
+      option: { id, label: formatPrLabel(pr), searchText: pr.body ?? undefined },
+      timestamp,
+    });
  }

  const baseItem = input.baseItem;
@@ -279,7 +282,13 @@ export function buildPickerOptionData(input: {
    const labeledItem = disambiguate(baseItem, timedOptions);
    itemById.set(selectedOptionId, labeledItem);
    timedOptions.push({
-      option: { id: selectedOptionId, label: pickerItemLabel(labeledItem) },
+      option: {
+        id: selectedOptionId,
+        label: pickerItemLabel(labeledItem),
+        ...(labeledItem.kind === "github-pr"
+          ? { searchText: labeledItem.item.body ?? undefined }
+          : {}),
+      },
      // The base sorts first: it is what a workspace is created from unless you pick something.
      timestamp: Number.POSITIVE_INFINITY,
    });
@@ -1723,7 +1723,7 @@ export function NewWorkspaceScreen({
    [terminalComposerValue],
  );
  const terminalTextReplacement = useMemo(
-    () => ({ key: launchFocusKey, text: terminalComposerValue }),
+    () => ({ kind: "replace" as const, key: launchFocusKey, text: terminalComposerValue }),
    [launchFocusKey, terminalComposerValue],
  );

@@ -1,3 +1,4 @@
+import { ComposerEditingScope } from "@/composer/editing-session";
 import React, { useMemo, type ComponentType } from "react";
 import invariant from "tiny-invariant";
 import {
@@ -156,7 +157,12 @@ export function WorkspacePaneContent({
    >
      <PaneProvider value={stablePaneContextValue}>
        <PaneFocusProvider value={paneFocusValue}>
-          <Component key={key} />
+          <ComposerEditingScope
+            tabId={paneContextValue.tabId}
+            targetKey={JSON.stringify(paneContextValue.target)}
+          >
+            <Component key={key} />
+          </ComposerEditingScope>
        </PaneFocusProvider>
      </PaneProvider>
    </RenderProfile>
@@ -1,3 +1,4 @@
+import { WorkspaceComposerEditingSessionsProvider } from "@/composer/editing-session";
 import { LoadingSpinner } from "@/components/ui/loading-spinner";
 import type { JsonValue } from "@getpaseo/protocol/agent-types";
 import { getOpenAgentTabLabel } from "@getpaseo/protocol/agent-labels";
@@ -753,14 +754,20 @@ function WorkspaceContentProviders({
 function WorkspacePanelContent({
  launcher,
  content,
+  tabIds,
+  workspaceKey,
 }: {
+  workspaceKey: string;
  launcher: NewTabLauncher;
  content: ReactNode;
+  tabIds: readonly string[];
 }) {
  return (
-    <NewTabLauncherProvider value={launcher}>
-      <View style={styles.content}>{content}</View>
-    </NewTabLauncherProvider>
+    <WorkspaceComposerEditingSessionsProvider workspaceKey={workspaceKey} tabIds={tabIds}>
+      <NewTabLauncherProvider value={launcher}>
+        <View style={styles.content}>{content}</View>
+      </NewTabLauncherProvider>
+    </WorkspaceComposerEditingSessionsProvider>
  );
 }

@@ -3491,6 +3498,8 @@ function WorkspaceScreenContent({
  const workspacePanelContent = (
    <WorkspacePanelContent
      launcher={newTabLauncher}
+      workspaceKey={`${normalizedServerId}:${normalizedWorkspaceId}`}
+      tabIds={uiTabs.map((tab) => tab.tabId)}
      content={isMobile ? content : desktopContent}
    />
  );
@@ -804,6 +804,8 @@ export interface CompactionItem {
 export interface PluginTimelineStreamItem {
  kind: "plugin";
  id: string;
+  /** The id of the stream item a timeline transformer replaced; set only by projection. */
+  sourceId?: string;
  timelineCursor?: TimelinePosition;
  turnId?: string;
  timestamp: Date;
@@ -2,6 +2,10 @@ import { describe, expect, it } from "vitest";
 import { requireWorkspaceDirectory, resolveWorkspaceDirectory } from "./workspace-directory";

 describe("resolveWorkspaceDirectory", () => {
+  it("preserves significant whitespace in a workspace folder name", () => {
+    expect(resolveWorkspaceDirectory({ workspaceDirectory: "/repo " })).toBe("/repo ");
+    expect(requireWorkspaceDirectory({ workspaceDirectory: "/repo /" })).toBe("/repo ");
+  });
  it("canonicalizes a workspace directory and returns null when blank", () => {
    expect(resolveWorkspaceDirectory({ workspaceDirectory: "C:\\repo\\app\\" })).toBe(
      "C:/repo/app",
@@ -13,11 +13,10 @@ export function normalizeWorkspaceOpaqueId(value: string | null | undefined): st
 }

 export function normalizeWorkspacePath(value: string | null | undefined): string | null {
-  const trimmed = trimNonEmpty(value);
-  if (!trimmed) {
+  if (typeof value !== "string" || value.trim().length === 0) {
    return null;
  }
-  const withUnixSeparators = trimmed.replace(/\\/g, "/");
+  const withUnixSeparators = value.replace(/\\/g, "/");
  if (withUnixSeparators === "/") {
    return withUnixSeparators;
  }
@@ -0,0 +1,67 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect, it } from "vitest";
+
+const appDir = fileURLToPath(new URL(".", import.meta.url));
+const rootDir = path.resolve(appDir, "../..");
+const require = createRequire(import.meta.url);
+const vitestEntry = path.join(path.dirname(require.resolve("vitest/package.json")), "vitest.mjs");
+const tsgoEntry = path.join(
+  path.dirname(require.resolve("@typescript/native-preview/package.json")),
+  "bin/tsgo.js",
+);
+
+it("the test configuration typechecks with Expo's generated environment declaration", () => {
+  const fixtureDir = mkdtempSync(path.join(appDir, ".vitest-expo-env-"));
+  try {
+    writeFileSync(path.join(fixtureDir, "expo-env.d.ts"), '/// <reference types="expo/types" />\n');
+    writeFileSync(
+      path.join(fixtureDir, "tsconfig.json"),
+      JSON.stringify({
+        extends: "../tsconfig.json",
+        files: ["../vitest.config.ts", "expo-env.d.ts"],
+        include: [],
+      }),
+    );
+    const result = spawnSync(
+      process.execPath,
+      [tsgoEntry, "--noEmit", "--project", path.join(fixtureDir, "tsconfig.json")],
+      { cwd: appDir, encoding: "utf8", timeout: 30_000 },
+    );
+
+    expect(result.error).toBeUndefined();
+    expect(result.status, result.stdout + result.stderr).toBe(0);
+  } finally {
+    rmSync(fixtureDir, { recursive: true, force: true });
+  }
+}, 40_000);
+
+it.each([
+  {
+    name: "root",
+    cwd: rootDir,
+    args: ["packages/app/src/screens/workspace/use-mounted-tab-set.test.ts"],
+  },
+  {
+    name: "app",
+    cwd: appDir,
+    args: ["--project", "unit", "src/screens/workspace/use-mounted-tab-set.test.ts"],
+  },
+])(
+  "$name tests can render React when the shell exports NODE_ENV=production",
+  ({ cwd, args }) => {
+    const result = spawnSync(process.execPath, [vitestEntry, "run", ...args], {
+      cwd,
+      env: { ...process.env, NODE_ENV: "production" },
+      encoding: "utf8",
+      timeout: 30_000,
+    });
+
+    expect(result.error).toBeUndefined();
+    expect(result.status, result.stdout + result.stderr).toBe(0);
+  },
+  40_000,
+);
@@ -3,6 +3,9 @@ import { playwright } from "@vitest/browser-playwright";
 import path from "path";
 import fs from "fs";

+// Set this before Vite resolves dependencies and Vitest starts its workers.
+Object.assign(process.env, { NODE_ENV: "test" });
+
 const appNodeModules = path.resolve(__dirname, "node_modules");
 const rootNodeModules = path.resolve(__dirname, "../../node_modules");
 const resolvePackageEntry = (packageName: string) => {
@@ -26,6 +29,7 @@ export default defineConfig({
            "src/**/*.{test,spec}.{ts,tsx}",
            "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}"],
@@ -15,6 +15,18 @@ function collect(items: readonly AgentTimelineItem[], turnId?: string): string {
 }

 describe("createFollowTranscriptWriter", () => {
+  it("matches one-shot logs when reasoning and assistant text alternate", () => {
+    const items: AgentTimelineItem[] = [
+      { type: "reasoning", text: "Check " },
+      { type: "reasoning", text: "the commands." },
+      { type: "assistant_message", text: "I will list the commands.", messageId: "msg_1" },
+      { type: "reasoning", text: "Then summarize." },
+      { type: "assistant_message", text: "Done.", messageId: "msg_2" },
+    ];
+
+    expect(collect(items).trimEnd()).toBe(formatAgentActivityTranscript(items));
+  });
+
  it("keeps a word that arrives split across fragments intact", () => {
    const output = collect([
      { type: "assistant_message", text: "the paseo-pr", messageId: "msg_1" },
@@ -1,5 +1,8 @@
 import type { Command } from "commander";
-import type { AgentPermissionRequest } from "@getpaseo/protocol/agent-types";
+import type {
+  AgentPermissionRequest,
+  AgentPermissionResponse,
+} from "@getpaseo/protocol/agent-types";
 import { connectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, ListResult, OutputSchema, CommandError } from "../../output/index.js";

@@ -55,106 +58,136 @@ export interface PermitAllowOptions extends CommandOptions {
  host?: string;
 }

-export async function runAllowCommand(
-  agentIdOrPrefix: string,
-  reqId: string | undefined,
-  options: PermitAllowOptions,
-  _command: Command,
-): Promise<PermitAllowResult> {
-  // No validation needed - if no reqId provided, allow all by default
+export interface PermitClient {
+  fetchAgent(options: { agentId: string }): Promise<{
+    agent: { id: string; pendingPermissions?: AgentPermissionRequest[] };
+  } | null>;
+  respondToPermissionAndWait(
+    agentId: string,
+    requestId: string,
+    response: AgentPermissionResponse,
+  ): Promise<unknown>;
+  close(): Promise<void>;
+}

-  // Parse input JSON if provided
-  let updatedInput: Record<string, unknown> | undefined;
-  if (options.input) {
-    try {
-      updatedInput = JSON.parse(options.input);
-    } catch (err) {
-      const error: CommandError = {
-        code: "INVALID_JSON",
-        message: `Invalid JSON for --input: ${err instanceof Error ? err.message : String(err)}`,
-        details: 'Provide valid JSON, e.g., --input \'{"key": "value"}\'',
-      };
-      throw error;
-    }
-  }
+export type PermitClientConnector = (
+  options: Parameters<typeof connectToDaemon>[0],
+) => Promise<PermitClient>;

-  const client = await connectToDaemon({ target: options.daemonTarget });
+export function createAllowCommand(connect: PermitClientConnector = connectToDaemon) {
+  return async function runAllowCommand(
+    agentIdOrPrefix: string,
+    reqId: string | undefined,
+    options: PermitAllowOptions,
+    _command: Command,
+  ): Promise<PermitAllowResult> {
+    // No validation needed - if no reqId provided, allow all by default

-  try {
-    const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
-    if (!fetchResult) {
-      await client.close();
-      const error: CommandError = {
-        code: "AGENT_NOT_FOUND",
-        message: `Agent not found: ${agentIdOrPrefix}`,
-        details: 'Use "paseo ls" to list available agents',
-      };
-      throw error;
-    }
-    const agent = fetchResult.agent;
-    const resolvedAgentId = agent.id;
-
-    // Get pending permissions for this agent
-    const pendingPermissions = agent.pendingPermissions || [];
-    if (pendingPermissions.length === 0) {
-      await client.close();
-      const error: CommandError = {
-        code: "NO_PENDING_PERMISSIONS",
-        message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
-      };
-      throw error;
-    }
-
-    // Determine which permissions to allow
-    let permissionsToAllow: AgentPermissionRequest[];
-    if (!reqId || options.all) {
-      // Default: allow all pending permissions if no req_id specified
-      // --all flag is kept as an explicit alias for clarity
-      permissionsToAllow = pendingPermissions;
-    } else {
-      // Find permission by ID prefix
-      const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
-      if (!permission) {
-        await client.close();
+    // Parse input JSON if provided
+    let updatedInput: Record<string, unknown> | undefined;
+    if (options.input) {
+      try {
+        updatedInput = JSON.parse(options.input);
+      } catch (err) {
        const error: CommandError = {
-          code: "PERMISSION_NOT_FOUND",
-          message: `Permission request not found: ${reqId}`,
-          details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+          code: "INVALID_JSON",
+          message: `Invalid JSON for --input: ${err instanceof Error ? err.message : String(err)}`,
+          details: 'Provide valid JSON, e.g., --input \'{"key": "value"}\'',
        };
        throw error;
      }
-      permissionsToAllow = [permission];
    }

-    // Allow permissions
-    const results: PermissionResponseItem[] = await Promise.all(
-      permissionsToAllow.map(async (permission) => {
-        await client.respondToPermission(resolvedAgentId, permission.id, {
-          behavior: "allow",
-          ...(updatedInput ? { updatedInput } : {}),
-        });
-        return toPermissionResponseItem(resolvedAgentId, permission, "allowed");
-      }),
-    );
+    const client = await connect({ target: options.daemonTarget });

-    await client.close();
+    try {
+      const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+      if (!fetchResult) {
+        await client.close();
+        const error: CommandError = {
+          code: "AGENT_NOT_FOUND",
+          message: `Agent not found: ${agentIdOrPrefix}`,
+          details: 'Use "paseo ls" to list available agents',
+        };
+        throw error;
+      }
+      const agent = fetchResult.agent;
+      const resolvedAgentId = agent.id;

-    return {
-      type: "list",
-      data: results,
-      schema: permitResponseSchema,
-    };
-  } catch (err) {
-    await client.close().catch(() => {});
-    // Re-throw CommandErrors
-    if (err && typeof err === "object" && "code" in err) {
-      throw err;
+      // Get pending permissions for this agent
+      const pendingPermissions = agent.pendingPermissions || [];
+      if (pendingPermissions.length === 0) {
+        await client.close();
+        const error: CommandError = {
+          code: "NO_PENDING_PERMISSIONS",
+          message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+        };
+        throw error;
+      }
+
+      // Determine which permissions to allow
+      let permissionsToAllow: AgentPermissionRequest[];
+      if (!reqId || options.all) {
+        // Default: allow all pending permissions if no req_id specified
+        // --all flag is kept as an explicit alias for clarity
+        permissionsToAllow = pendingPermissions;
+      } else {
+        // Find permission by ID prefix
+        const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
+        if (!permission) {
+          await client.close();
+          const error: CommandError = {
+            code: "PERMISSION_NOT_FOUND",
+            message: `Permission request not found: ${reqId}`,
+            details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+          };
+          throw error;
+        }
+        permissionsToAllow = [permission];
+      }
+
+      // Allow permissions
+      const results: PermissionResponseItem[] = await Promise.all(
+        permissionsToAllow.map(async (permission) => {
+          try {
+            await client.respondToPermissionAndWait(resolvedAgentId, permission.id, {
+              behavior: "allow",
+              ...(updatedInput ? { updatedInput } : {}),
+            });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const error: CommandError = {
+              code: "PERMISSION_RESPONSE_UNCONFIRMED",
+              message: `Permission response unconfirmed for request ${permission.id}: ${message}`,
+              details: 'Use "paseo permit ls" to check whether the request is still pending',
+            };
+            throw error;
+          }
+          return toPermissionResponseItem(resolvedAgentId, permission, "allowed");
+        }),
+      );
+
+      await client.close();
+
+      return {
+        type: "list",
+        data: results,
+        schema: permitResponseSchema,
+      };
+    } catch (err) {
+      await client.close().catch(() => {});
+      // Re-throw CommandErrors
+      if (err && typeof err === "object" && "code" in err) {
+        throw err;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      const error: CommandError = {
+        code: "ALLOW_PERMISSION_FAILED",
+        message: `Failed to allow permission: ${message}`,
+      };
+      throw error;
    }
-    const message = err instanceof Error ? err.message : String(err);
-    const error: CommandError = {
-      code: "ALLOW_PERMISSION_FAILED",
-      message: `Failed to allow permission: ${message}`,
-    };
-    throw error;
-  }
+  };
 }
+
+export const runAllowCommand = createAllowCommand();
@@ -6,6 +6,7 @@ import {
  permitResponseSchema,
  toPermissionResponseItem,
  type PermissionResponseItem,
+  type PermitClientConnector,
 } from "./allow.js";

 export type PermitDenyResult = ListResult<PermissionResponseItem>;
@@ -17,98 +18,114 @@ export interface PermitDenyOptions extends CommandOptions {
  host?: string;
 }

-export async function runDenyCommand(
-  agentIdOrPrefix: string,
-  reqId: string | undefined,
-  options: PermitDenyOptions,
-  _command: Command,
-): Promise<PermitDenyResult> {
-  // Validate arguments
-  if (!options.all && !reqId) {
-    const error: CommandError = {
-      code: "MISSING_ARGUMENT",
-      message: "Request ID is required unless --all is specified",
-      details: "Usage: paseo permit deny <agent> <req_id> or paseo permit deny <agent> --all",
-    };
-    throw error;
-  }
-
-  const client = await connectToDaemon({ target: options.daemonTarget });
-
-  try {
-    const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
-    if (!fetchResult) {
-      await client.close();
+export function createDenyCommand(connect: PermitClientConnector = connectToDaemon) {
+  return async function runDenyCommand(
+    agentIdOrPrefix: string,
+    reqId: string | undefined,
+    options: PermitDenyOptions,
+    _command: Command,
+  ): Promise<PermitDenyResult> {
+    // Validate arguments
+    if (!options.all && !reqId) {
      const error: CommandError = {
-        code: "AGENT_NOT_FOUND",
-        message: `Agent not found: ${agentIdOrPrefix}`,
-        details: 'Use "paseo ls" to list available agents',
-      };
-      throw error;
-    }
-    const agent = fetchResult.agent;
-    const resolvedAgentId = agent.id;
-
-    // Get pending permissions for this agent
-    const pendingPermissions = agent.pendingPermissions || [];
-    if (pendingPermissions.length === 0) {
-      await client.close();
-      const error: CommandError = {
-        code: "NO_PENDING_PERMISSIONS",
-        message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+        code: "MISSING_ARGUMENT",
+        message: "Request ID is required unless --all is specified",
+        details: "Usage: paseo permit deny <agent> <req_id> or paseo permit deny <agent> --all",
      };
      throw error;
    }

-    // Determine which permissions to deny
-    let permissionsToDeny: AgentPermissionRequest[];
-    if (options.all) {
-      permissionsToDeny = pendingPermissions;
-    } else {
-      // Find permission by ID prefix
-      const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId!));
-      if (!permission) {
+    const client = await connect({ target: options.daemonTarget });
+
+    try {
+      const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+      if (!fetchResult) {
        await client.close();
        const error: CommandError = {
-          code: "PERMISSION_NOT_FOUND",
-          message: `Permission request not found: ${reqId}`,
-          details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+          code: "AGENT_NOT_FOUND",
+          message: `Agent not found: ${agentIdOrPrefix}`,
+          details: 'Use "paseo ls" to list available agents',
        };
        throw error;
      }
-      permissionsToDeny = [permission];
+      const agent = fetchResult.agent;
+      const resolvedAgentId = agent.id;
+
+      // Get pending permissions for this agent
+      const pendingPermissions = agent.pendingPermissions || [];
+      if (pendingPermissions.length === 0) {
+        await client.close();
+        const error: CommandError = {
+          code: "NO_PENDING_PERMISSIONS",
+          message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+        };
+        throw error;
+      }
+
+      // Determine which permissions to deny
+      let permissionsToDeny: AgentPermissionRequest[];
+      if (options.all) {
+        permissionsToDeny = pendingPermissions;
+      } else {
+        // Find permission by ID prefix
+        const permission = pendingPermissions.find(
+          (p) => p.id === reqId || p.id.startsWith(reqId!),
+        );
+        if (!permission) {
+          await client.close();
+          const error: CommandError = {
+            code: "PERMISSION_NOT_FOUND",
+            message: `Permission request not found: ${reqId}`,
+            details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+          };
+          throw error;
+        }
+        permissionsToDeny = [permission];
+      }
+
+      // Deny permissions
+      const results: PermissionResponseItem[] = await Promise.all(
+        permissionsToDeny.map(async (permission) => {
+          try {
+            await client.respondToPermissionAndWait(resolvedAgentId, permission.id, {
+              behavior: "deny",
+              ...(options.message ? { message: options.message } : {}),
+              ...(options.interrupt ? { interrupt: true } : {}),
+            });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const error: CommandError = {
+              code: "PERMISSION_RESPONSE_UNCONFIRMED",
+              message: `Permission response unconfirmed for request ${permission.id}: ${message}`,
+              details: 'Use "paseo permit ls" to check whether the request is still pending',
+            };
+            throw error;
+          }
+          return toPermissionResponseItem(resolvedAgentId, permission, "denied");
+        }),
+      );
+
+      await client.close();
+
+      return {
+        type: "list",
+        data: results,
+        schema: permitResponseSchema,
+      };
+    } catch (err) {
+      await client.close().catch(() => {});
+      // Re-throw CommandErrors
+      if (err && typeof err === "object" && "code" in err) {
+        throw err;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      const error: CommandError = {
+        code: "DENY_PERMISSION_FAILED",
+        message: `Failed to deny permission: ${message}`,
+      };
+      throw error;
    }
-
-    // Deny permissions
-    const results: PermissionResponseItem[] = await Promise.all(
-      permissionsToDeny.map(async (permission) => {
-        await client.respondToPermission(resolvedAgentId, permission.id, {
-          behavior: "deny",
-          ...(options.message ? { message: options.message } : {}),
-          ...(options.interrupt ? { interrupt: true } : {}),
-        });
-        return toPermissionResponseItem(resolvedAgentId, permission, "denied");
-      }),
-    );
-
-    await client.close();
-
-    return {
-      type: "list",
-      data: results,
-      schema: permitResponseSchema,
-    };
-  } catch (err) {
-    await client.close().catch(() => {});
-    // Re-throw CommandErrors
-    if (err && typeof err === "object" && "code" in err) {
-      throw err;
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    const error: CommandError = {
-      code: "DENY_PERMISSION_FAILED",
-      message: `Failed to deny permission: ${message}`,
-    };
-    throw error;
-  }
+  };
 }
+
+export const runDenyCommand = createDenyCommand();
@@ -0,0 +1,177 @@
+import { setImmediate as waitForCommandContinuations } from "node:timers/promises";
+import { Command } from "commander";
+import type {
+  AgentPermissionRequest,
+  AgentPermissionResponse,
+} from "@getpaseo/protocol/agent-types";
+import { describe, expect, it } from "vitest";
+import { createAllowCommand, type PermitClient } from "./allow.js";
+import { createDenyCommand } from "./deny.js";
+
+const agentId = "2d85f428-fdaf-4d98-906f-c583de2b805f";
+const requests: AgentPermissionRequest[] = [
+  {
+    id: "permission-write",
+    provider: "codex",
+    name: "CodexBash",
+    kind: "tool",
+  },
+  { id: "permission-edit", provider: "codex", name: "CodexBash", kind: "tool" },
+];
+
+class PermissionClient implements PermitClient {
+  readonly pending = [...requests];
+  readonly responses = new Map<string, AgentPermissionResponse>();
+  closed = false;
+  private notifyReceived = () => {};
+  private readonly confirmations = new Map<
+    string,
+    {
+      resolve: () => void;
+      reject: (error: Error) => void;
+    }
+  >();
+
+  async fetchAgent() {
+    return { agent: { id: agentId, pendingPermissions: this.pending } };
+  }
+
+  async respondToPermission(
+    _agentId: string,
+    requestId: string,
+    response: AgentPermissionResponse,
+  ) {
+    this.responses.set(requestId, response);
+    this.notifyReceived();
+  }
+
+  async respondToPermissionAndWait(
+    responseAgentId: string,
+    requestId: string,
+    response: AgentPermissionResponse,
+  ): Promise<void> {
+    const confirmation = new Promise<void>((resolve, reject) => {
+      this.confirmations.set(requestId, { resolve, reject });
+    });
+    await this.respondToPermission(responseAgentId, requestId, response);
+    await confirmation;
+  }
+
+  async close() {
+    this.closed = true;
+  }
+
+  async waitForResponses(count: number) {
+    while (this.responses.size < count) {
+      await new Promise<void>((resolve) => {
+        this.notifyReceived = resolve;
+      });
+    }
+  }
+
+  confirm(requestId: string) {
+    const confirmation = this.confirmations.get(requestId);
+    if (!confirmation) throw new Error(`No confirmation waiter: ${requestId}`);
+    this.pending.splice(
+      this.pending.findIndex((request) => request.id === requestId),
+      1,
+    );
+    confirmation.resolve();
+  }
+
+  fail(requestId: string, error: Error) {
+    const confirmation = this.confirmations.get(requestId);
+    if (!confirmation) throw new Error(`No confirmation waiter: ${requestId}`);
+    confirmation.reject(error);
+  }
+}
+
+const options = {
+  daemonTarget: { kind: "endpoint" as const, host: "test.invalid" },
+};
+const actions = [
+  { name: "allow", create: createAllowCommand, result: "allowed" },
+  { name: "deny", create: createDenyCommand, result: "denied" },
+];
+for (const action of actions) {
+  describe(`permit ${action.name}`, () => {
+    it("returns success and closes only after confirmation", async () => {
+      const client = new PermissionClient();
+      let completed = false;
+      const command = action.create(async () => client)(
+        agentId,
+        requests[0].id,
+        options,
+        new Command(),
+      );
+      void command.then(
+        () => (completed = true),
+        () => false,
+      );
+      await client.waitForResponses(1);
+      await waitForCommandContinuations();
+      expect(completed).toBe(false);
+      expect(client.closed).toBe(false);
+      expect(client.pending).toEqual(requests);
+      client.confirm(requests[0].id);
+      const result = await command;
+      expect(result.data).toEqual([
+        {
+          requestId: requests[0].id,
+          agentId,
+          agentShortId: agentId.slice(0, 7),
+          name: "CodexBash",
+          result: action.result,
+        },
+      ]);
+      expect(client.closed).toBe(true);
+      expect(client.pending).toEqual([requests[1]]);
+    });
+
+    it("waits for every confirmation with --all", async () => {
+      const client = new PermissionClient();
+      let completed = false;
+      const command = action.create(async () => client)(
+        agentId,
+        undefined,
+        { ...options, all: true },
+        new Command(),
+      );
+      void command.then(
+        () => (completed = true),
+        () => false,
+      );
+      await client.waitForResponses(2);
+      client.confirm(requests[0].id);
+      // Wait beyond the first reply's promise continuations while withholding the second.
+      await waitForCommandContinuations();
+      expect(completed).toBe(false);
+      expect(client.closed).toBe(false);
+      client.confirm(requests[1].id);
+      const result = await command;
+      expect(result.data.map((item) => item.result)).toEqual([action.result, action.result]);
+      expect(client.closed).toBe(true);
+      expect(client.pending).toEqual([]);
+    });
+
+    it("rejects an unconfirmed response without returning success", async () => {
+      const client = new PermissionClient();
+      const command = action.create(async () => client)(
+        agentId,
+        requests[0].id,
+        options,
+        new Command(),
+      );
+      const failure = expect(command).rejects.toMatchObject({
+        code: "PERMISSION_RESPONSE_UNCONFIRMED",
+        message: expect.stringContaining(requests[0].id),
+        details: 'Use "paseo permit ls" to check whether the request is still pending',
+      });
+      await client.waitForResponses(1);
+      client.fail(requests[0].id, new Error("Timeout waiting for message (15000ms)"));
+      await failure;
+      expect(client.closed).toBe(true);
+      expect(client.pending).toEqual(requests);
+    });
+  });
+}
@@ -364,10 +364,6 @@ try {
      ids.every((id) => id.startsWith("gpt-")),
      "all codex model IDs should be from the gpt family",
    );
-    assert(
-      ids.some((id) => id.includes("codex")),
-      "codex model list should include at least one codex-optimized model",
-    );
    assert(
      data.every((m) => m.model && m.id && m.description),
      "every codex model should have model, id, and description fields",
@@ -848,6 +848,11 @@ async function assertSandboxState({ browser, page, expectedSandbox, stdout, stde

 function assertLinuxDesktopIdentity(appPath) {
  if (process.platform === "linux") {
+    assert.deepEqual(
+      fs.readFileSync(path.join(appPath, "resources", "icon.png")),
+      fs.readFileSync(path.join(__dirname, "..", "assets", "icon.png")),
+      "Packaged Linux windows must have the Paseo icon at their runtime lookup path",
+    );
    const metadata = JSON.parse(
      extractFile(path.join(appPath, "resources", "app.asar"), "package.json").toString(),
    );
@@ -65,6 +65,8 @@ linux:
  extraResources:
    - from: bin/paseo
      to: bin/paseo
+    - from: assets/icon.png
+      to: icon.png
  target:
    - AppImage
    - deb
@@ -89,7 +89,7 @@
    "speech:transcribe:local": "tsx scripts/transcribe-local-wav.ts",
    "test": "npm run test:unit && npm run test:integration",
    "test:unit": "vitest run --fileParallelism --exclude \"**/*.e2e.test.ts\"",
-    "test:integration": "vitest run --maxWorkers=1 src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts && vitest run --maxWorkers=1 src/server/session.create-agent-worktree-autoarchive.e2e.test.ts -t \"creates a worktree and auto-archives both\" && vitest run --maxWorkers=1 src/server/agent/providers/opencode-bridge.local.e2e.test.ts -t \"versioned runtime\"",
+    "test:integration": "vitest run --maxWorkers=1 src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts && vitest run --maxWorkers=1 src/server/daemon-e2e/git-operations.e2e.test.ts -t \"merges into\" && vitest run --maxWorkers=1 src/server/session.create-agent-worktree-autoarchive.e2e.test.ts -t \"creates a worktree and auto-archives both\" && vitest run --maxWorkers=1 src/server/agent/providers/opencode-bridge.local.e2e.test.ts -t \"versioned runtime\"",
    "test:hub-cli-contract": "vitest run --maxWorkers=1 src/server/hub/hub-cli-contract.test.ts",
    "test:integration:all": "npm run test:e2e",
    "test:integration:real": "vitest run real.e2e.test.ts",
@@ -29,6 +29,7 @@ async function runSupervisorFixture(options: {
  blockLogPath?: boolean;
  /** Close the reading end of the supervisor's stdout and stderr as soon as it starts. */
  closeOutput?: boolean;
+  env?: NodeJS.ProcessEnv;
 }): Promise<{
  code: number | null;
  signal: NodeJS.Signals | null;
@@ -84,7 +85,9 @@ async function runSupervisorFixture(options: {
        ];
  const child = spawn(command, args, {
    cwd: repoRoot,
-    env: { ...process.env },
+    // A Node color-conflict warning can hit closed stderr before runSupervisor installs
+    // its pipe-error handlers. This fixture exercises the supervisor's own output.
+    env: { ...process.env, ...options.env, NO_COLOR: undefined, FORCE_COLOR: undefined },
    stdio: ["ignore", "pipe", "pipe"],
  });

@@ -205,10 +208,16 @@ describe("supervisor durable logging", () => {
    expect(result.stderr).toContain('"worker-json-stderr"');
  });

-  test("keeps supervising the worker when nobody reads its stdout or stderr", async () => {
-    const result = await runSupervisorFixture({
-      closeOutput: true,
-      workerSource: `
+  test.each([
+    { colors: "inherited", env: {} },
+    { colors: "conflicting", env: { NO_COLOR: "1", FORCE_COLOR: "1" } },
+  ])(
+    "keeps supervising the worker when nobody reads its stdout or stderr with $colors colors",
+    async ({ env }) => {
+      const result = await runSupervisorFixture({
+        closeOutput: true,
+        env,
+        workerSource: `
        process.on("message", (message) => {
          if (message?.type === "paseo:graceful-shutdown") process.exit(0);
        });
@@ -220,14 +229,15 @@ describe("supervisor durable logging", () => {
        }, 500);
        setInterval(() => {}, 1000);
      `,
-    });
+      });

-    expect(result.code).toBe(0);
-    expect(result.signal).toBeNull();
-    expect(result.log).toContain("first stderr line\n");
-    expect(result.log).toContain("later stdout line\n");
-    expect(result.log).toContain('"reason":"closed_output_probe"');
-  });
+      expect(result.code).toBe(0);
+      expect(result.signal).toBeNull();
+      expect(result.log).toContain("first stderr line\n");
+      expect(result.log).toContain("later stdout line\n");
+      expect(result.log).toContain('"reason":"closed_output_probe"');
+    },
+  );

  test("preserves raw non-JSON stdout and stderr lines", async () => {
    const result = await runSupervisorFixture({
@@ -39,6 +39,45 @@ function row(seq: number, item: AgentTimelineItem): AgentTimelineRow {
 }

 describe("curateAgentActivity", () => {
+  it("keeps reasoning before the assistant text that followed it", () => {
+    const timeline: AgentTimelineItem[] = [
+      { type: "reasoning", text: "Check the commands first." },
+      { type: "assistant_message", text: "I will list the commands." },
+      toolCallItem({
+        callId: "shell-order",
+        name: "Bash",
+        detail: {
+          type: "shell",
+          command: "ls packages/cli/src/commands/agent/",
+          output: "",
+          exitCode: 0,
+        },
+      }),
+    ];
+
+    expect(curateAgentActivity(timeline)).toBe(
+      "[Thought] Check the commands first.\nI will list the commands.\n[Shell] ls packages/cli/src/commands/agent/",
+    );
+  });
+
+  it("preserves alternating text kinds, labels, and fragment concatenation", () => {
+    const timeline: AgentTimelineItem[] = [
+      { type: "assistant_message", text: "First message." },
+      { type: "reasoning", text: "First " },
+      { type: "reasoning", text: "thought." },
+      { type: "assistant_message", text: "Second " },
+      { type: "assistant_message", text: "message." },
+      { type: "reasoning", text: "Second thought." },
+    ];
+
+    expect(curateAgentActivity(timeline, { labelAssistantMessages: true })).toBe(
+      "[Assistant] First message.\n[Thought] First thought.\n[Assistant] Second message.\n[Thought] Second thought.",
+    );
+    expect(curateAgentActivity(timeline, { maxItems: 2 })).toBe(
+      "Second message.\n[Thought] Second thought.",
+    );
+  });
+
  it("renders user/assistant/reasoning entries", () => {
    const timeline: AgentTimelineItem[] = [
      { type: "user_message", text: "Hello" },
@@ -25,36 +25,20 @@ interface ActivityEntry {

 type TextAgentAttachment = Extract<AgentAttachment, { type: "text" }>;

-function appendText(buffer: string, text: string): string {
-  const normalized = text.trim();
-  if (!normalized) {
-    return buffer;
-  }
-  if (!buffer) {
-    return normalized;
-  }
-  return `${buffer}\n${normalized}`;
-}
-
 function activityEntry(text: string): ActivityEntry {
  return { text };
 }

-function flushBuffers(
+function appendTextEntry(
  entries: ActivityEntry[],
-  buffers: { message: string; thought: string },
+  item: Extract<AgentTimelineItem, { type: "assistant_message" | "reasoning" }>,
  options?: ActivityCuratorOptions,
 ) {
-  if (buffers.message.trim()) {
-    const text = buffers.message.trim();
-    entries.push(activityEntry(options?.labelAssistantMessages ? `[Assistant] ${text}` : text));
-  }
-  if (buffers.thought.trim()) {
-    const text = buffers.thought.trim();
-    entries.push(activityEntry(`[Thought] ${text}`));
-  }
-  buffers.message = "";
-  buffers.thought = "";
+  const text = item.text.trim();
+  if (!text) return;
+  let prefix = options?.labelAssistantMessages ? "[Assistant] " : "";
+  if (item.type === "reasoning") prefix = "[Thought] ";
+  entries.push(activityEntry(`${prefix}${text}`));
 }

 function formatToolInputJson(input: unknown): string | null {
@@ -147,7 +131,6 @@ function curateProjectedActivityEntries(
  const recentItems = maxItems > 0 && items.length > maxItems ? items.slice(-maxItems) : items;

  const entries: ActivityEntry[] = [];
-  const buffers = { message: "", thought: "" };

  for (const item of recentItems) {
    if (!shouldIncludeItem(item, options)) {
@@ -156,17 +139,13 @@ function curateProjectedActivityEntries(

    switch (item.type) {
      case "user_message":
-        flushBuffers(entries, buffers, options);
        entries.push(activityEntry(`[User] ${item.text.trim()}`));
        break;
      case "assistant_message":
-        buffers.message = appendText(buffers.message, item.text);
-        break;
      case "reasoning":
-        buffers.thought = appendText(buffers.thought, item.text);
+        appendTextEntry(entries, item, options);
        break;
      case "tool_call": {
-        flushBuffers(entries, buffers, options);
        entries.push(formatToolCallEntry(item, options));
        if (item.detail.type === "sub_agent" && item.detail.log.trim()) {
          entries.push(activityEntry(item.detail.log.trim()));
@@ -174,7 +153,6 @@ function curateProjectedActivityEntries(
        break;
      }
      case "todo":
-        flushBuffers(entries, buffers, options);
        entries.push(activityEntry("[Tasks]"));
        for (const entry of item.items) {
          const checkbox = entry.completed ? "[x]" : "[ ]";
@@ -183,18 +161,14 @@ function curateProjectedActivityEntries(
        }
        break;
      case "error":
-        flushBuffers(entries, buffers, options);
        entries.push(activityEntry(`[Error] ${item.message}`));
        break;
      case "compaction":
-        flushBuffers(entries, buffers, options);
        entries.push(activityEntry("[Compacted]"));
        break;
    }
  }

-  flushBuffers(entries, buffers, options);
-
  return entries;
 }

@@ -222,6 +222,11 @@ function createFinishNotificationScenario(
        type: "agent_state",
        agent: childAgent,
      });
+      subscriber?.({
+        type: "agent_stream",
+        agentId: "child-agent",
+        event: { type: "turn_completed", provider: "codex" },
+      });
    },
    async finishChildAndReadParentPrompt() {
      const parentPrompt = new Promise<string>((resolve) => {
@@ -540,6 +545,11 @@ it("does not notify archived callers", async () => {
    type: "agent_state",
    agent: childAgent,
  });
+  subscriber?.({
+    type: "agent_stream",
+    agentId: "child-agent",
+    event: { type: "turn_completed", provider: "codex" },
+  });

  await vi.waitFor(() => {
    expect(agentStorageGetSpy).toHaveBeenCalledWith("caller-agent");
@@ -407,13 +407,20 @@ export interface SetupFinishNotificationParams {
  logger: Logger;
 }

-type FinishNotificationReason = "finished" | "errored" | "needs permission" | "was closed";
+type FinishNotificationReason =
+  | "finished"
+  | "errored"
+  | "needs permission"
+  | "was closed"
+  | "was canceled";

 const finishNotificationEvents = {
  finished: "finished",
  errored: "errored",
  "needs permission": "permission-required",
  "was closed": "closed",
+  // Use the existing failure event so older clients still parse agent-message metadata.
+  "was canceled": "errored",
 } as const;

 const FINISH_NOTIFICATION_MESSAGE_LIMIT = 4000;
@@ -568,10 +575,8 @@ export function setupFinishNotification(params: SetupFinishNotificationParams):
      notifySafely("errored");
      return;
    }
-    if (agent.lifecycle === "idle" && hasSeenRunning) {
-      notifySafely("finished");
-      return;
-    }
+    // Idle is published before the terminal stream event for both completion
+    // and cancellation. Let that event identify the outcome instead.
    if (agent.lifecycle === "closed") {
      notifySafely("was closed");
      return;
@@ -600,6 +605,18 @@ export function setupFinishNotification(params: SetupFinishNotificationParams):
        return;
      }

+      if (event.event.type === "turn_completed" || event.event.type === "turn_canceled") {
+        // Replacing a turn keeps the child running through the displaced turn's
+        // cancellation. The task settles only when the child becomes idle.
+        if (agentManager.getAgent(childAgentId)?.lifecycle !== "idle") return;
+        if (event.event.type === "turn_completed" && hasSeenRunning) {
+          notifySafely("finished");
+        } else if (event.event.type === "turn_canceled" && hasSeenTurn) {
+          notifySafely("was canceled");
+        }
+        return;
+      }
+
      if (event.event.type === "permission_requested") {
        // A permission pause is an intermediate checkpoint. Forget the run
        // observed before it so an idle state during follow-up startup cannot
@@ -12,6 +12,8 @@ import { createTestPaseoDaemon, type TestPaseoDaemon } from "../test-utils/paseo
 import { createTestAgentClients } from "../test-utils/fake-agent-client.js";
 import type { AgentClient, AgentProvider, AgentSessionConfig } from "./agent-sdk-types.js";
 import { PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
+import { DaemonClient } from "../test-utils/daemon-client.js";
+import { parseAgentMessage } from "./agent-messages/index.js";

 interface StructuredContent {
  [key: string]: unknown;
@@ -311,6 +313,167 @@ afterAll(async () => {
 });

 describe("Suite A: Core Fixes", () => {
+  test.each([
+    ["Stop", "cancelAgent"],
+    ["Reload", "refreshAgent"],
+  ] as const)(
+    "%s tells the parent that a watched child was canceled",
+    async (_action, method) => {
+      let releaseChild!: () => void;
+      let childReachedGate!: () => void;
+      const heldTurn = new Promise<void>((resolve) => {
+        releaseChild = resolve;
+      });
+      const childAtGate = new Promise<void>((resolve) => {
+        childReachedGate = resolve;
+      });
+      const parentPrompts: string[] = [];
+      const daemon = await createTestPaseoDaemon({
+        agentClients: createTestAgentClients({
+          onStartTurn(prompt, config) {
+            if (config.title === "Watching parent" && typeof prompt === "string")
+              parentPrompts.push(prompt);
+          },
+          async beforeTurnComplete(prompt) {
+            if (
+              typeof prompt === "string" &&
+              parseAgentMessage(prompt).text === "Hold this child turn"
+            ) {
+              childReachedGate();
+              await heldTurn;
+            }
+          },
+        }),
+      });
+      const client = new DaemonClient({
+        url: `ws://127.0.0.1:${daemon.port}/ws`,
+        appVersion: "0.11.2",
+      });
+      let mcp: McpClient | undefined;
+      let unsubscribe: (() => void) | undefined;
+      try {
+        await client.connect();
+        await client.fetchAgents({ subscribe: {} });
+        const parent = await client.createAgent({
+          provider: "claude",
+          cwd: daemon.paseoHome,
+          title: "Watching parent",
+          modeId: "bypassPermissions",
+        });
+        mcp = await createMcpClient(
+          buildExpectedAgentMcpUrl({ host: "127.0.0.1", port: daemon.port, agentId: parent.id }),
+        );
+        const created = await callToolStructured(mcp, "create_agent", {
+          relationship: { kind: "subagent" },
+          workspace: { kind: "current" },
+          title: "Watched child",
+          provider: "codex/gpt-5.4",
+          initialPrompt: "Hold this child turn",
+          notifyOnFinish: true,
+          settings: { modeId: "full-access" },
+        });
+        const childId = str(created.agentId);
+        await childAtGate;
+        expect(daemon.daemon.agentManager.getAgent(childId)?.lifecycle).toBe("running");
+        const terminalEvents: string[] = [];
+        unsubscribe = daemon.daemon.agentManager.subscribe(
+          (event) => {
+            if (
+              event.type === "agent_stream" &&
+              event.agentId === childId &&
+              (event.event.type === "turn_completed" || event.event.type === "turn_canceled")
+            )
+              terminalEvents.push(event.event.type);
+          },
+          { agentId: childId, replayState: false },
+        );
+
+        await client[method](childId);
+        await waitFor({
+          timeoutMs: 10000,
+          label: "parent cancellation notification",
+          check: () => (parentPrompts.length === 1 ? true : null),
+        });
+        const notification = parseAgentMessage(parentPrompts[0]);
+        expect(terminalEvents).toEqual(["turn_canceled"]);
+        expect(notification.source).toEqual({
+          kind: "agent-notification",
+          agentId: childId,
+          title: "Watched child",
+          event: "errored",
+        });
+        expect(notification.text).toContain(`Agent ${childId} (Watched child) was canceled.`);
+        expect(notification.text).not.toContain("finished.");
+        await waitFor({
+          timeoutMs: 10000,
+          label: "parent notification turn drained",
+          check: () =>
+            daemon.daemon.agentManager.getAgent(parent.id)?.lifecycle === "idle" ? true : null,
+        });
+        expect(parentPrompts).toHaveLength(1);
+      } finally {
+        releaseChild();
+        unsubscribe?.();
+        await mcp?.close();
+        await client.close();
+        await daemon.close();
+      }
+    },
+    30000,
+  );
+
+  test.each([
+    { outcome: "finished", prompt: "say done and stop", status: "idle" },
+    { outcome: "errored", prompt: "Emit a turn failure", status: "error" },
+  ])(
+    "a watched child still reports $outcome after send_agent_prompt",
+    async ({ outcome, prompt, status }) => {
+      const childId = await createChildAgent({
+        title: "Follow-up child",
+        settings: { modeId: "bypassPermissions" },
+      });
+      try {
+        await waitFor({
+          timeoutMs: 10000,
+          label: "initial child turn completed",
+          check: () =>
+            daemonHandle.daemon.agentManager.getAgent(childId)?.lifecycle === "idle" ? true : null,
+        });
+        await callToolStructured(agentScopedClient, "send_agent_prompt", {
+          agentId: childId,
+          prompt,
+          notifyOnFinish: true,
+        });
+        const notifications = await waitFor({
+          timeoutMs: 10000,
+          label: `${outcome} notification`,
+          check: () => {
+            const items = daemonHandle.daemon.agentManager
+              .getTimeline(parentAgentId)
+              .filter(
+                (item) => item.type === "tool_call" && item.agentMessage?.sender.id === childId,
+              );
+            return items.length > 0 ? items : null;
+          },
+        });
+        expect(notifications).toEqual([
+          expect.objectContaining({
+            type: "tool_call",
+            agentMessage: {
+              event: outcome,
+              sender: { id: childId, title: "Follow-up child" },
+              text: expect.stringContaining(`(Follow-up child) ${outcome}.`),
+            },
+          }),
+        ]);
+        expect(daemonHandle.daemon.agentManager.getAgent(childId)?.lifecycle).toBe(status);
+      } finally {
+        await archiveAgentIfPresent(childId);
+      }
+    },
+    30000,
+  );
+
  test("AGENT_WAIT_TIMEOUT_MS is 30000", () => {
    expect(AGENT_WAIT_TIMEOUT_MS).toBe(30_000);
  });
@@ -4359,6 +4359,10 @@ describe("send_agent_prompt MCP tool", () => {
      await vi.waitFor(() => expect(finishNotifications()).not.toHaveLength(0));
      await new Promise((resolve) => setTimeout(resolve, 100));
      expect(finishNotifications()).toHaveLength(1);
+      expect(parentClient.sessions[0]!.prompts).toHaveLength(1);
+      expect(parseAgentMessage(parentClient.sessions[0]!.prompts[0])).toMatchObject({
+        source: { kind: "agent-notification", agentId: childId, event: "finished" },
+      });
    } finally {
      await removeAgentStateDir(agentManager, storage, workdir);
    }
@@ -0,0 +1,133 @@
+import { createServer } from "node:http";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import path from "node:path";
+import pino from "pino";
+import { expect, test } from "vitest";
+import { collectSessionTurnEvents } from "../test-utils/session-stream-adapter.js";
+import { ClaudeAgentClient } from "./agent.js";
+
+// Exercise the real Claude Code process against a local Messages API fixture.
+// The input counter's location is the only difference between the two backends.
+test.each([
+  { placement: "start", cacheTokens: 0 },
+  { placement: "delta", cacheTokens: 0 },
+  { placement: "start", cacheTokens: 1_000 },
+  { placement: "delta", cacheTokens: 1_000 },
+])(
+  "counts $placement input and $cacheTokens cached tokens through Claude Code",
+  async ({ placement, cacheTokens }) => {
+    const cwd = await mkdtemp(path.resolve(".claude-context-usage-"));
+    const configDir = path.join(cwd, "config");
+    await mkdir(configDir);
+    let requestCount = 0;
+    const server = createServer(async (request, response) => {
+      for await (const chunk of request) {
+        void chunk;
+      }
+      if (!request.url?.startsWith("/v1/messages")) {
+        response.writeHead(200, { "content-type": "application/json" });
+        response.end("{}");
+        return;
+      }
+      if (request.url.includes("count_tokens")) {
+        response.writeHead(200, { "content-type": "application/json" });
+        response.end(JSON.stringify({ input_tokens: 20_236 }));
+        return;
+      }
+      const inputTokens = 20_236 + requestCount++;
+      response.writeHead(200, { "content-type": "text/event-stream" });
+      const emit = (data: { type: string; [key: string]: unknown }) => {
+        response.write(`event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`);
+      };
+      emit({
+        type: "message_start",
+        message: {
+          id: `msg_context_usage_${requestCount}`,
+          type: "message",
+          role: "assistant",
+          model: "claude-sonnet-4-6",
+          content: [],
+          stop_reason: null,
+          stop_sequence: null,
+          usage: {
+            input_tokens: placement === "start" ? inputTokens : 0,
+            output_tokens: 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: cacheTokens,
+          },
+        },
+      });
+      emit({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } });
+      emit({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "hello" } });
+      emit({ type: "content_block_stop", index: 0 });
+      emit({
+        type: "message_delta",
+        delta: { stop_reason: "end_turn", stop_sequence: null },
+        usage: {
+          output_tokens: 64,
+          ...(placement === "delta" ? { input_tokens: inputTokens } : {}),
+        },
+      });
+      emit({ type: "message_stop" });
+      response.end();
+    });
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("Fixture has no TCP address");
+    const client = new ClaudeAgentClient({
+      logger: pino({ level: "silent" }),
+      runtimeSettings: {
+        env: {
+          ANTHROPIC_BASE_URL: `http://127.0.0.1:${address.port}`,
+          ANTHROPIC_AUTH_TOKEN: "fixture-token",
+          ANTHROPIC_API_KEY: "",
+          CLAUDE_CONFIG_DIR: configDir,
+          CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+        },
+      },
+    });
+    const session = await client.createSession(
+      { provider: "claude", cwd, model: "claude-sonnet-4-6" },
+      undefined,
+      { persistSession: false },
+    );
+    try {
+      for (let turn = 0; turn < 2; turn++) {
+        const events = await collectSessionTurnEvents(session, "say hello", {
+          signal: AbortSignal.timeout(20_000),
+        });
+        const expectedTokens = 20_236 + turn + cacheTokens + 64;
+        expect(events).toContainEqual(
+          expect.objectContaining({
+            type: "turn_completed",
+            usage: expect.objectContaining({
+              inputTokens: 20_236 + turn,
+              outputTokens: 64,
+              cachedInputTokens: cacheTokens,
+              contextWindowUsedTokens: expectedTokens,
+            }),
+          }),
+        );
+        expect(events).toContainEqual(
+          expect.objectContaining({
+            type: "usage_updated",
+            usage: expect.objectContaining({ contextWindowUsedTokens: expectedTokens }),
+          }),
+        );
+      }
+      expect(requestCount).toBe(2);
+    } finally {
+      try {
+        await session.close();
+      } finally {
+        try {
+          server.closeAllConnections();
+          await new Promise<void>((resolve) => server.close(() => resolve()));
+        } finally {
+          await rm(cwd, { recursive: true, force: true });
+        }
+      }
+    }
+  },
+  60_000,
+);
@@ -2135,13 +2135,15 @@ describe("ClaudeAgentSession context window usage", () => {
  }

  function createMessageDeltaEvent(outputTokens: number): Record<string, unknown> {
+    return createMessageDeltaUsageEvent({ output_tokens: outputTokens });
+  }
+
+  function createMessageDeltaUsageEvent(usage: Record<string, unknown>): Record<string, unknown> {
    return {
      type: "stream_event",
      event: {
        type: "message_delta",
-        usage: {
-          output_tokens: outputTokens,
-        },
+        usage,
      },
      session_id: "session-1",
    };
@@ -2887,6 +2889,119 @@ describe("ClaudeAgentSession context window usage", () => {
    }
  });

+  test("message_delta input usage replaces an empty message_start count", async () => {
+    // Translating gateways (LiteLLM in front of an OpenAI-compatible backend) do not know the
+    // prompt size when message_start is emitted, so they report input_tokens: 0 there and send
+    // the cumulative counts on message_delta, as the Anthropic Messages API allows.
+    const session = await createSessionForTurns([
+      [
+        createInitMessage(),
+        createMessageStartEvent({
+          input_tokens: 0,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+        }),
+        createMessageDeltaUsageEvent({ input_tokens: 20_236, output_tokens: 64 }),
+        createSuccessResult({
+          usage: {
+            input_tokens: 20_236,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: 0,
+            output_tokens: 64,
+            iterations: [],
+          },
+        }),
+      ],
+    ]);
+
+    try {
+      const events = await collectStreamEvents(session);
+
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          type: "usage_updated",
+          provider: "claude",
+          usage: {
+            contextWindowUsedTokens: 20_300,
+          },
+        }),
+      );
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          type: "turn_completed",
+          usage: expect.objectContaining({
+            inputTokens: 20_236,
+            outputTokens: 64,
+            contextWindowUsedTokens: 20_300,
+          }),
+        }),
+      );
+    } finally {
+      await session.close();
+    }
+  });
+
+  test("message_delta without cache counters keeps the message_start cache usage", async () => {
+    const session = await createSessionForTurns([
+      [
+        createInitMessage(),
+        createMessageStartEvent({
+          input_tokens: 5,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 1_000,
+        }),
+        createMessageDeltaUsageEvent({ input_tokens: 5, output_tokens: 64 }),
+        createSuccessResult(),
+      ],
+    ]);
+
+    try {
+      const events = await collectStreamEvents(session);
+
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          type: "usage_updated",
+          provider: "claude",
+          usage: {
+            contextWindowUsedTokens: 1_069,
+          },
+        }),
+      );
+    } finally {
+      await session.close();
+    }
+  });
+
+  test("message_delta before this request's message_start does not seed usage", async () => {
+    // A canceled request can leave its terminal message_delta queued behind the next turn.
+    // Nothing is known about the new request until its message_start, so that straggler
+    // must not produce a usage_updated event or leak into the next request's counters.
+    const session = await createSessionForTurns([
+      [
+        createInitMessage(),
+        createMessageDeltaUsageEvent({ input_tokens: 20_236, output_tokens: 64 }),
+        createMessageStartEvent({
+          input_tokens: 40,
+          cache_creation_input_tokens: 5,
+          cache_read_input_tokens: 10,
+        }),
+        createMessageDeltaEvent(7),
+        createSuccessResult(),
+      ],
+    ]);
+
+    try {
+      const events = await collectStreamEvents(session);
+
+      const usedTokens = events
+        .filter((event) => event.type === "usage_updated")
+        .map((event) => event.usage.contextWindowUsedTokens);
+      expect(usedTokens).toEqual([55, 62]);
+    } finally {
+      await session.close();
+    }
+  });
+
  test("per-request stream usage is not cumulative across API calls in a turn", async () => {
    const session = await createSessionForTurns([
      [
@@ -1855,30 +1855,59 @@ function extractContextWindowSize(modelUsage: unknown): number | undefined {
  return maxContextWindow;
 }

-function readStreamRequestInputTokens(event: Record<string, unknown>): number | undefined {
-  const messageUsage = toObjectRecord(toObjectRecord(event.message)?.usage);
-  if (!messageUsage) {
+interface StreamRequestInputUsage {
+  inputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+}
+
+function readUsageCount(usage: Record<string, unknown>, key: string): number | undefined {
+  const value = usage[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
    return undefined;
  }
-  const usage = messageUsage;
-  const inputTokens =
-    typeof usage.input_tokens === "number" && Number.isFinite(usage.input_tokens)
-      ? usage.input_tokens
-      : undefined;
-  const cacheCreationInputTokens =
-    typeof usage.cache_creation_input_tokens === "number" &&
-    Number.isFinite(usage.cache_creation_input_tokens)
-      ? usage.cache_creation_input_tokens
-      : 0;
-  const cacheReadInputTokens =
-    typeof usage.cache_read_input_tokens === "number" &&
-    Number.isFinite(usage.cache_read_input_tokens)
-      ? usage.cache_read_input_tokens
-      : 0;
-  if (typeof inputTokens !== "number" || inputTokens < 0) {
+  return value;
+}
+
+function readStreamRequestInputUsage(
+  event: Record<string, unknown>,
+): StreamRequestInputUsage | undefined {
+  const usage = toObjectRecord(toObjectRecord(event.message)?.usage);
+  if (!usage) {
    return undefined;
  }
-  return inputTokens + cacheCreationInputTokens + cacheReadInputTokens;
+  const inputTokens = readUsageCount(usage, "input_tokens");
+  if (inputTokens === undefined) {
+    return undefined;
+  }
+  return {
+    inputTokens,
+    cacheCreationInputTokens: readUsageCount(usage, "cache_creation_input_tokens") ?? 0,
+    cacheReadInputTokens: readUsageCount(usage, "cache_read_input_tokens") ?? 0,
+  };
+}
+
+/**
+ * The input counters on `message_delta.usage` are cumulative whole-request totals and are
+ * optional. Mirror the Anthropic SDK's MessageStream: a counter present on the delta replaces
+ * the `message_start` value, a missing counter keeps it. Translating gateways report
+ * `input_tokens: 0` on `message_start` and only know the real count by `message_delta`.
+ */
+function mergeStreamDeltaInputUsage(
+  current: StreamRequestInputUsage,
+  event: Record<string, unknown>,
+): StreamRequestInputUsage {
+  const usage = toObjectRecord(event.usage);
+  if (!usage) {
+    return current;
+  }
+  return {
+    inputTokens: readUsageCount(usage, "input_tokens") ?? current.inputTokens,
+    cacheCreationInputTokens:
+      readUsageCount(usage, "cache_creation_input_tokens") ?? current.cacheCreationInputTokens,
+    cacheReadInputTokens:
+      readUsageCount(usage, "cache_read_input_tokens") ?? current.cacheReadInputTokens,
+  };
 }

 function readStreamRequestOutputTokens(event: Record<string, unknown>): number | undefined {
@@ -1958,7 +1987,7 @@ function readClaudeParentToolUseId(message: SDKMessage): string | null {

 class ClaudeContextUsageState {
  private contextWindowMaxTokens: number | undefined;
-  private streamRequestInputTokens: number | undefined;
+  private streamRequestInputUsage: StreamRequestInputUsage | undefined;
  private streamRequestOutputTokens: number | undefined;
  private compactedContextWindowUsedTokens: number | undefined;
  private completedResultTurns = 0;
@@ -1968,7 +1997,7 @@ class ClaudeContextUsageState {
  }

  beginTurn(): void {
-    this.streamRequestInputTokens = undefined;
+    this.streamRequestInputUsage = undefined;
    this.streamRequestOutputTokens = undefined;
    this.compactedContextWindowUsedTokens = undefined;
  }
@@ -1992,11 +2021,11 @@ class ClaudeContextUsageState {
    }
    const eventType = readTrimmedString(streamEvent.type);
    if (eventType === "message_start") {
-      const inputTokens = readStreamRequestInputTokens(streamEvent);
-      if (typeof inputTokens !== "number") {
+      const inputUsage = readStreamRequestInputUsage(streamEvent);
+      if (!inputUsage) {
        return null;
      }
-      this.streamRequestInputTokens = inputTokens;
+      this.streamRequestInputUsage = inputUsage;
      this.streamRequestOutputTokens = 0;
    } else if (eventType === "message_delta") {
      const outputTokens = readStreamRequestOutputTokens(streamEvent);
@@ -2004,6 +2033,12 @@ class ClaudeContextUsageState {
        return null;
      }
      this.streamRequestOutputTokens = outputTokens;
+      if (this.streamRequestInputUsage) {
+        this.streamRequestInputUsage = mergeStreamDeltaInputUsage(
+          this.streamRequestInputUsage,
+          streamEvent,
+        );
+      }
    } else {
      return null;
    }
@@ -2050,13 +2085,15 @@ class ClaudeContextUsageState {
  }

  private streamUsedTokens(): number | undefined {
-    if (
-      typeof this.streamRequestInputTokens !== "number" ||
-      typeof this.streamRequestOutputTokens !== "number"
-    ) {
+    const inputUsage = this.streamRequestInputUsage;
+    if (!inputUsage || typeof this.streamRequestOutputTokens !== "number") {
      return undefined;
    }
-    const usedTokens = this.streamRequestInputTokens + this.streamRequestOutputTokens;
+    const usedTokens =
+      inputUsage.inputTokens +
+      inputUsage.cacheCreationInputTokens +
+      inputUsage.cacheReadInputTokens +
+      this.streamRequestOutputTokens;
    return usedTokens > 0 ? usedTokens : undefined;
  }

@@ -2075,7 +2112,7 @@ class ClaudeContextUsageState {
  }

  buildCompactionUsageEvent(postTokens: number | undefined): AgentStreamEvent {
-    this.streamRequestInputTokens = undefined;
+    this.streamRequestInputUsage = undefined;
    this.streamRequestOutputTokens = undefined;
    this.compactedContextWindowUsedTokens = postTokens;
    const usage: AgentUsage = {};
@@ -112,7 +112,7 @@ export interface PaseoToolHostDependencies {
  github?: ForgeService;
  workspaceGitService?: Pick<
    WorkspaceGitService,
-    "getSnapshot" | "listWorktrees" | "resolveRepoRoot"
+    "getSnapshot" | "listWorktrees" | "resolveRepoRoot" | "invalidateWorktrees"
  >;
  findWorkspaceIdForCwd?: ArchiveDependencies["findWorkspaceIdForCwd"];
  listActiveWorkspaces?: ArchiveDependencies["listActiveWorkspaces"];
@@ -134,6 +134,44 @@ describe("daemon web UI bootstrap", () => {
    });
  });

+  test("spells out the scheme default port when the Host header omits it", async () => {
+    const distDir = await createWebUiDist();
+
+    daemonHandle = await createTestPaseoDaemon({
+      mcpEnabled: false,
+      webUi: {
+        enabled: true,
+        distDir,
+      },
+    });
+
+    // A browser reaching a proxy that terminates TLS on 443 sends a Host header
+    // with no port at all. The app rejects a portless `listen`, so the daemon
+    // has to supply the default itself.
+    const httpsHint = readInjectedConnectionHint(
+      await fetchDaemonWebUi({
+        port: daemonHandle.port,
+        headers: { host: "paseo.example.test", "x-forwarded-proto": "https" },
+      }),
+    );
+    const httpHint = readInjectedConnectionHint(
+      await fetchDaemonWebUi({
+        port: daemonHandle.port,
+        headers: { host: "paseo.example.test" },
+      }),
+    );
+    const ipv6Hint = readInjectedConnectionHint(
+      await fetchDaemonWebUi({
+        port: daemonHandle.port,
+        headers: { host: "[::1]", "x-forwarded-proto": "https" },
+      }),
+    );
+
+    expect(httpsHint.listen).toBe("paseo.example.test:443");
+    expect(httpHint.listen).toBe("paseo.example.test:80");
+    expect(ipv6Hint.listen).toBe("[::1]:443");
+  });
+
  test("ignores forwarded HTTPS when proxy trust is disabled", async () => {
    const distDir = await createWebUiDist();

@@ -832,6 +832,9 @@ export async function createPaseoDaemon(
    try {
      fileHandle = await open(entry.absolutePath, DOWNLOAD_OPEN_FLAGS);
      const fileStats = await fileHandle.stat();
+      if (res.destroyed) {
+        return;
+      }
      if (!fileStats.isFile()) {
        res.status(404).json({ error: "File not found" });
        return;
@@ -843,6 +846,7 @@ export async function createPaseoDaemon(

      const stream = fileHandle.createReadStream();
      fileHandle = null;
+      res.once("close", () => stream.destroy());
      stream.on("error", (err) => {
        logger.error({ err }, "Failed to stream download");
        if (!res.headersSent) {
@@ -0,0 +1,87 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { createDaemonTestContext } from "../test-utils/index.js";
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, { cwd, encoding: "utf8" });
+}
+
+test.each(["uncommitted", "base", "commit"] as const)(
+  "%s diff preserves removed SQL comments and their deletion counts",
+  async (mode) => {
+    const ctx = await createDaemonTestContext();
+    const cwd = mkdtempSync(join(tmpdir(), "checkout-diff-content-"));
+
+    try {
+      git(cwd, "init", "-b", "main");
+      git(cwd, "config", "user.name", "Test");
+      git(cwd, "config", "user.email", "test@example.com");
+      writeFileSync(join(cwd, "query.sql"), "-- old comment\nSELECT 1;\n");
+      writeFileSync(join(cwd, "control.sql"), "SELECT 1;\n");
+      git(cwd, "add", ".");
+      git(cwd, "-c", "commit.gpgsign=false", "commit", "-m", "initial");
+      writeFileSync(join(cwd, "query.sql"), "-- new comment\nSELECT 1;\n");
+      writeFileSync(join(cwd, "control.sql"), "SELECT 2;\n");
+
+      expect(git(cwd, "diff", "--numstat", "HEAD", "--", "query.sql").trim()).toBe(
+        "1\t1\tquery.sql",
+      );
+
+      if (mode !== "uncommitted") {
+        git(cwd, "checkout", "-b", "feature");
+        git(cwd, "add", ".");
+        git(cwd, "-c", "commit.gpgsign=false", "commit", "-m", "edit");
+      }
+
+      const files =
+        mode === "commit"
+          ? [
+              (
+                await ctx.client.getCommitFileDiff(
+                  cwd,
+                  git(cwd, "rev-parse", "HEAD").trim(),
+                  "query.sql",
+                )
+              ).file,
+              (
+                await ctx.client.getCommitFileDiff(
+                  cwd,
+                  git(cwd, "rev-parse", "HEAD").trim(),
+                  "control.sql",
+                )
+              ).file,
+            ]
+          : (await ctx.client.getCheckoutDiff(cwd, { mode, baseRef: "main" })).files;
+
+      const control = files.find((file) => file?.path === "control.sql");
+      expect(control).toMatchObject({ additions: 1, deletions: 1 });
+      expect(control?.hunks.flatMap((hunk) => hunk.lines)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ type: "remove", content: "SELECT 1;" }),
+          expect.objectContaining({ type: "add", content: "SELECT 2;" }),
+        ]),
+      );
+
+      const query = files.find((file) => file?.path === "query.sql");
+      expect
+        .soft(query)
+        .toMatchObject({ additions: 1, deletions: 1, isNew: false, isDeleted: false });
+      expect
+        .soft(query?.hunks.flatMap((hunk) => hunk.lines))
+        .toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({ type: "remove", content: "-- old comment" }),
+            expect.objectContaining({ type: "add", content: "-- new comment" }),
+            expect.objectContaining({ type: "context", content: "SELECT 1;" }),
+          ]),
+        );
+    } finally {
+      await ctx.cleanup();
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  },
+  60_000,
+);
@@ -1,5 +1,15 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync } from "fs";
+import {
+  mkdtempSync,
+  writeFileSync,
+  rmSync,
+  readdirSync,
+  readlinkSync,
+  realpathSync,
+  symlinkSync,
+} from "fs";
+import { once } from "node:events";
+import { get } from "node:http";
 import { tmpdir } from "os";
 import path from "path";
 import { createDaemonTestContext, type DaemonTestContext } from "../test-utils/index.js";
@@ -8,6 +18,41 @@ function tmpCwd(): string {
  return mkdtempSync(path.join(tmpdir(), "daemon-e2e-"));
 }

+// Linux exposes the real open descriptors without replacing file or HTTP methods.
+function openDownloadDescriptors(filePath: string): string[] {
+  const realFilePath = realpathSync(filePath);
+  return readdirSync("/proc/self/fd").filter((fd) => {
+    try {
+      return readlinkSync(`/proc/self/fd/${fd}`) === realFilePath;
+    } catch (error) {
+      // A descriptor can close between listing it and reading its link.
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+      throw error;
+    }
+  });
+}
+
+async function expectDownloadClosed(filePath: string): Promise<void> {
+  await expect.poll(() => openDownloadDescriptors(filePath)).toEqual([]);
+}
+
+async function cancelDownloadAfterFirstChunk(url: string): Promise<void> {
+  const request = get(url);
+  try {
+    const [response] = await once(request, "response");
+    expect(response.statusCode).toBe(200);
+    const [chunk] = await once(response, "data");
+    expect(chunk.length).toBeGreaterThan(0);
+    expect(chunk.length).toBeLessThan(64 * 1024 * 1024);
+    const closed = once(response, "close");
+    response.destroy();
+    request.destroy();
+    await closed;
+  } finally {
+    request.destroy();
+  }
+}
+
 // Use gpt-5.4-mini with low thinking preset for faster test execution
 const CODEX_TEST_MODEL = "gpt-5.4-mini";
 const CODEX_TEST_THINKING_OPTION_ID = "low";
@@ -24,6 +69,39 @@ describe("daemon E2E", () => {
  }, 60000);

  describe("file download tokens", () => {
+    test.skipIf(process.platform !== "linux")(
+      "releases file descriptors after repeated HTTP download cancellations",
+      async () => {
+        const directory = tmpCwd();
+        const cwd = path.join(directory, "linked-files");
+        symlinkSync(mkdtempSync(path.join(directory, "files-")), cwd, "dir");
+        const filePath = path.join(cwd, "large.bin");
+        const fileSize = 64 * 1024 * 1024;
+        writeFileSync(filePath, Buffer.alloc(fileSize));
+        try {
+          const completedToken = await ctx.client.requestDownloadToken(cwd, "large.bin");
+          expect(completedToken.error).toBeNull();
+          const completed = await fetch(
+            `http://127.0.0.1:${ctx.daemon.port}/api/files/download?token=${completedToken.token}`,
+          );
+          expect(completed.status).toBe(200);
+          expect((await completed.arrayBuffer()).byteLength).toBe(fileSize);
+          await expectDownloadClosed(filePath);
+
+          for (let attempt = 0; attempt < 3; attempt++) {
+            const token = await ctx.client.requestDownloadToken(cwd, "large.bin");
+            expect(token.error).toBeNull();
+            await cancelDownloadAfterFirstChunk(
+              `http://127.0.0.1:${ctx.daemon.port}/api/files/download?token=${token.token}`,
+            );
+            await expectDownloadClosed(filePath);
+          }
+        } finally {
+          rmSync(directory, { recursive: true, force: true });
+        }
+      },
+    );
+
    test.each([
      { fileName: "download.txt", disposition: 'attachment; filename="download.txt"' },
      {
@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "fs";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, symlinkSync, readdirSync } from "fs";
 import { tmpdir } from "os";
 import path from "path";
 import { createDaemonTestContext, type DaemonTestContext } from "../test-utils/index.js";
@@ -23,6 +23,287 @@ afterEach(async () => {
 }, 60000);

 describe("file explorer", () => {
+  test.each([
+    { description: "a long ASCII name", fileName: `${"a".repeat(236)}.txt` },
+    { description: "an ordinary name", fileName: "notes.txt" },
+    { description: "a long Unicode name", fileName: `${"文".repeat(76)}.txt` },
+  ])("saves text files with $description", async ({ fileName }) => {
+    const cwd = tmpCwd();
+    try {
+      const created = await ctx.client.createFileEntry({
+        cwd,
+        parentPath: ".",
+        name: fileName,
+        kind: "file",
+      });
+      expect(created).toMatchObject({ path: fileName, success: true, error: null });
+      writeFileSync(path.join(cwd, fileName), "original payload\n");
+      const initial = await ctx.client.readFile(cwd, fileName);
+
+      const saved = await ctx.client.writeFile({
+        cwd,
+        path: fileName,
+        content: "saved payload\n",
+        expectedModifiedAt: initial.modifiedAt,
+        expectedRevision: initial.revision,
+      });
+      expect(saved).toMatchObject({ status: "written", size: 14 });
+      const after = await ctx.client.readFile(cwd, fileName);
+      expect(after.path).toBe(fileName);
+      expect(new TextDecoder().decode(after.bytes)).toBe("saved payload\n");
+
+      const staleSave = await ctx.client.writeFile({
+        cwd,
+        path: fileName,
+        content: "stale payload\n",
+        expectedModifiedAt: initial.modifiedAt,
+        expectedRevision: initial.revision,
+      });
+      expect(staleSave).toMatchObject({
+        status: "conflict",
+        version: {
+          status: "ready",
+          path: fileName,
+          size: after.size,
+          modifiedAt: after.modifiedAt,
+          revision: after.revision,
+        },
+      });
+      const afterConflict = await ctx.client.readFile(cwd, fileName);
+      expect(new TextDecoder().decode(afterConflict.bytes)).toBe("saved payload\n");
+
+      const secondSave = await ctx.client.writeFile({
+        cwd,
+        path: fileName,
+        content: "second payload\n",
+        expectedModifiedAt: afterConflict.modifiedAt,
+        expectedRevision: afterConflict.revision,
+      });
+      expect(secondSave).toMatchObject({ status: "written", size: 15 });
+      const final = await ctx.client.readFile(cwd, fileName);
+      expect(new TextDecoder().decode(final.bytes)).toBe("second payload\n");
+      expect(readdirSync(cwd)).toEqual([fileName]);
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  test.each([
+    {
+      query: "implementation",
+      expectedPaths: [
+        ".cursor/plans/implementation-plan.md",
+        ".codex/plans/implementation-plan.md",
+        ".claude/plans/implementation-plan.md",
+      ],
+    },
+    {
+      query: ".cursor/plans/implementation",
+      expectedPaths: [".cursor/plans/implementation-plan.md"],
+    },
+  ])(
+    "workspace suggestions find hidden agent plans for '$query'",
+    async ({ query, expectedPaths }) => {
+      const cwd = tmpCwd();
+      try {
+        for (const directory of [".cursor", ".codex", ".claude", ".hidden"]) {
+          mkdirSync(path.join(cwd, directory, "plans"), { recursive: true });
+          writeFileSync(path.join(cwd, directory, "plans", "implementation-plan.md"), "plan\n");
+        }
+
+        const response = await ctx.client.getDirectorySuggestions({
+          cwd,
+          query,
+          limit: 50,
+          includeFiles: true,
+          includeDirectories: true,
+        });
+        expect(response.error).toBeNull();
+        expect(response.entries).toHaveLength(expectedPaths.length);
+        expect(response.entries).toEqual(
+          expect.arrayContaining(
+            expectedPaths.map((entryPath) => ({ path: entryPath, kind: "file" })),
+          ),
+        );
+      } finally {
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+  );
+
+  test.each(["..", "..."])("supports file operations on names starting with %s", async (prefix) => {
+    const cwd = tmpCwd();
+    const fileName = `${prefix}notes.txt`;
+    const directoryName = `${prefix}drafts`;
+    try {
+      const createdFile = await ctx.client.createFileEntry({
+        cwd,
+        parentPath: ".",
+        name: fileName,
+        kind: "file",
+      });
+      expect(createdFile).toMatchObject({ path: fileName, success: true, error: null });
+      writeFileSync(path.join(cwd, fileName), "notes payload\n");
+      writeFileSync(path.join(cwd, ".notes.txt"), "dotfile control\n");
+      writeFileSync(path.join(cwd, "notes.txt"), "ordinary control\n");
+
+      const createdDirectory = await ctx.client.createFileEntry({
+        cwd,
+        parentPath: ".",
+        name: directoryName,
+        kind: "directory",
+      });
+      expect(createdDirectory).toMatchObject({ path: directoryName, success: true, error: null });
+      const createdChild = await ctx.client.createFileEntry({
+        cwd,
+        parentPath: directoryName,
+        name: "inside.txt",
+        kind: "file",
+      });
+      expect(createdChild).toMatchObject({
+        path: `${directoryName}/inside.txt`,
+        success: true,
+        error: null,
+      });
+      writeFileSync(path.join(cwd, directoryName, "inside.txt"), "nested payload\n");
+
+      const directory = await ctx.client.listDirectory(cwd, ".");
+      expect(
+        Object.fromEntries(directory.entries.map((entry) => [entry.path, entry.kind])),
+      ).toEqual({
+        [directoryName]: "directory",
+        [fileName]: "file",
+        ".notes.txt": "file",
+        "notes.txt": "file",
+      });
+      const children = await ctx.client.listDirectory(cwd, directoryName);
+      expect(children.entries.map((entry) => entry.path)).toEqual([`${directoryName}/inside.txt`]);
+      const file = await ctx.client.readFile(cwd, fileName);
+      expect(file.path).toBe(fileName);
+      expect(new TextDecoder().decode(file.bytes)).toBe("notes payload\n");
+      const nestedFile = await ctx.client.readFile(cwd, `${directoryName}/inside.txt`);
+      expect(nestedFile.path).toBe(`${directoryName}/inside.txt`);
+      expect(new TextDecoder().decode(nestedFile.bytes)).toBe("nested payload\n");
+
+      const dotfile = await ctx.client.readFile(cwd, ".notes.txt");
+      expect(new TextDecoder().decode(dotfile.bytes)).toBe("dotfile control\n");
+      const ordinaryFile = await ctx.client.readFile(cwd, "notes.txt");
+      expect(new TextDecoder().decode(ordinaryFile.bytes)).toBe("ordinary control\n");
+
+      const download = await ctx.client.requestDownloadToken(cwd, fileName);
+      expect(download.error).toBeNull();
+      expect(download.fileName).toBe(fileName);
+      const response = await fetch(
+        `http://127.0.0.1:${ctx.daemon.port}/api/files/download?token=${download.token}`,
+      );
+      expect(response.status).toBe(200);
+      expect(await response.text()).toBe("notes payload\n");
+
+      const renamedFileName = `${prefix}renamed.txt`;
+      const renamed = await ctx.client.renameFileEntry({
+        cwd,
+        path: fileName,
+        name: renamedFileName,
+      });
+      expect(renamed).toMatchObject({ renamedPath: renamedFileName, success: true, error: null });
+      const renamedFile = await ctx.client.readFile(cwd, renamedFileName);
+      expect(new TextDecoder().decode(renamedFile.bytes)).toBe("notes payload\n");
+
+      const copiedDirectoryName = `${directoryName} copy`;
+      const duplicated = await ctx.client.duplicateFileEntry({ cwd, path: directoryName });
+      expect(duplicated).toMatchObject({
+        duplicatedPath: copiedDirectoryName,
+        success: true,
+        error: null,
+      });
+      const copiedFile = await ctx.client.readFile(cwd, `${copiedDirectoryName}/inside.txt`);
+      expect(new TextDecoder().decode(copiedFile.bytes)).toBe("nested payload\n");
+
+      const deletedDirectory = await ctx.client.deleteFileEntry({ cwd, path: directoryName });
+      expect(deletedDirectory).toMatchObject({ success: true, error: null });
+      const deletedFile = await ctx.client.deleteFileEntry({ cwd, path: renamedFileName });
+      expect(deletedFile).toMatchObject({ success: true, error: null });
+      const remaining = await ctx.client.listDirectory(cwd, ".");
+      expect(remaining.entries.map((entry) => entry.path).sort()).toEqual(
+        [".notes.txt", "notes.txt", copiedDirectoryName].sort(),
+      );
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  test("rejects parent traversal and absolute paths to a sibling workspace", async () => {
+    const directory = tmpCwd();
+    const cwd = path.join(directory, "workspace");
+    const outside = path.join(directory, "workspace-sibling");
+    try {
+      mkdirSync(cwd);
+      mkdirSync(outside);
+      writeFileSync(path.join(outside, "secret.txt"), "outside payload\n");
+      for (const requestedPath of ["..", "../workspace-sibling", outside]) {
+        await expect(ctx.client.listDirectory(cwd, requestedPath)).rejects.toThrow(
+          "Access outside of workspace is not allowed",
+        );
+      }
+      for (const requestedPath of [
+        "../workspace-sibling/secret.txt",
+        path.join(outside, "secret.txt"),
+      ]) {
+        await expect(ctx.client.readFile(cwd, requestedPath)).rejects.toThrow(
+          "Access outside of workspace is not allowed",
+        );
+        const download = await ctx.client.requestDownloadToken(cwd, requestedPath);
+        expect(download).toMatchObject({
+          token: null,
+          error: "Access outside of workspace is not allowed",
+        });
+        const deleted = await ctx.client.deleteFileEntry({ cwd, path: requestedPath });
+        expect(deleted).toMatchObject({
+          success: false,
+          error: "Access outside of workspace is not allowed",
+        });
+      }
+      expect(readdirSync(outside)).toEqual(["secret.txt"]);
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  test("accepts symlinks to double-dot names inside the workspace and rejects outside targets", async () => {
+    const directory = tmpCwd();
+    const cwd = path.join(directory, "workspace");
+    const outside = path.join(directory, "workspace-sibling");
+    try {
+      mkdirSync(path.join(cwd, "..drafts"), { recursive: true });
+      mkdirSync(outside);
+      writeFileSync(path.join(cwd, "..drafts", "notes.txt"), "inside payload\n");
+      writeFileSync(path.join(outside, "secret.txt"), "outside payload\n");
+      // Junctions also work on Windows without requiring symlink privileges.
+      symlinkSync(path.join(cwd, "..drafts"), path.join(cwd, "inside-link"), "junction");
+      symlinkSync(outside, path.join(cwd, "outside-link"), "junction");
+
+      const listing = await ctx.client.listDirectory(cwd, ".");
+      expect(listing.entries.map((entry) => entry.path).sort()).toEqual([
+        "..drafts",
+        "inside-link",
+      ]);
+      const file = await ctx.client.readFile(cwd, "inside-link/notes.txt");
+      expect(file.path).toBe("inside-link/notes.txt");
+      expect(new TextDecoder().decode(file.bytes)).toBe("inside payload\n");
+      await expect(ctx.client.readFile(cwd, "outside-link/secret.txt")).rejects.toThrow(
+        "Access outside of workspace is not allowed",
+      );
+      const download = await ctx.client.requestDownloadToken(cwd, "outside-link/secret.txt");
+      expect(download).toMatchObject({
+        token: null,
+        error: "Access outside of workspace is not allowed",
+      });
+      expect(readdirSync(outside)).toEqual(["secret.txt"]);
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
  test("lists directory contents", async () => {
    const cwd = tmpCwd();

@@ -1,5 +1,14 @@
 import { test, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, existsSync, rmSync, readFileSync, realpathSync } from "fs";
+import {
+  mkdtempSync,
+  writeFileSync,
+  existsSync,
+  rmSync,
+  readFileSync,
+  realpathSync,
+  mkdirSync,
+} from "fs";
+import { execFileSync } from "node:child_process";
 import { tmpdir } from "os";
 import path from "path";
 import { createDaemonTestContext, type DaemonTestContext } from "../test-utils/index.js";
@@ -152,6 +161,78 @@ afterEach(async () => {
  await ctx.cleanup();
 }, 60000);

+interface GitCommandOptions {
+  cwd: string;
+  args: string[];
+}
+
+async function mergeFeatureIntoBaseWorktree(baseName: string): Promise<void> {
+  const directory = realpathSync(tmpCwd());
+  const base = path.join(directory, baseName);
+  const feature = path.join(directory, "feature");
+  function git({ cwd, args }: GitCommandOptions): string {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
+  }
+  try {
+    mkdirSync(base);
+    git({ cwd: base, args: ["init", "-b", "main"] });
+    git({ cwd: base, args: ["config", "user.name", "Paseo Test"] });
+    git({ cwd: base, args: ["config", "user.email", "test@paseo.local"] });
+    git({ cwd: base, args: ["config", "commit.gpgsign", "false"] });
+    git({ cwd: base, args: ["config", "core.autocrlf", "false"] });
+    git({ cwd: base, args: ["commit", "--allow-empty", "-m", "base"] });
+    git({ cwd: base, args: ["worktree", "add", "-b", "feature", feature] });
+    writeFileSync(path.join(feature, "feature.txt"), "feature payload\n");
+    git({ cwd: feature, args: ["add", "feature.txt"] });
+    git({ cwd: feature, args: ["commit", "-m", "feature"] });
+    const featureCommit = git({ cwd: feature, args: ["rev-parse", "HEAD"] }).trim();
+
+    const merged = await ctx.client.checkoutMerge(feature, { baseRef: "main" });
+    expect(merged).toMatchObject({ success: true, error: null });
+    expect(git({ cwd: base, args: ["rev-parse", "HEAD"] }).trim()).toBe(featureCommit);
+    expect(readFileSync(path.join(base, "feature.txt"), "utf8")).toBe("feature payload\n");
+    expect(git({ cwd: feature, args: ["symbolic-ref", "--short", "HEAD"] }).trim()).toBe("feature");
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+test.skipIf(isPlatform("win32")).each(["base\ncheckout", "base "])(
+  "merges into a base worktree whose path preserves %j",
+  mergeFeatureIntoBaseWorktree,
+);
+
+test.each(["base checkout", "中文 checkout"])(
+  "merges into a base worktree named %j",
+  mergeFeatureIntoBaseWorktree,
+);
+
+test("merges into a local base branch without another worktree", async () => {
+  const cwd = realpathSync(tmpCwd());
+  function git(args: string[]): string {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
+  }
+  try {
+    git(["init", "-b", "main"]);
+    git(["config", "user.name", "Paseo Test"]);
+    git(["config", "user.email", "test@paseo.local"]);
+    git(["config", "commit.gpgsign", "false"]);
+    git(["commit", "--allow-empty", "-m", "base"]);
+    git(["checkout", "-b", "feature"]);
+    writeFileSync(path.join(cwd, "feature.txt"), "feature payload\n");
+    git(["add", "feature.txt"]);
+    git(["commit", "-m", "feature"]);
+    const featureCommit = git(["rev-parse", "HEAD"]).trim();
+
+    const merged = await ctx.client.checkoutMerge(cwd, { baseRef: "main" });
+    expect(merged).toMatchObject({ success: true, error: null });
+    expect(git(["rev-parse", "main"]).trim()).toBe(featureCommit);
+    expect(git(["symbolic-ref", "--short", "HEAD"]).trim()).toBe("feature");
+  } finally {
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
 test("returns diff for modified file in git repo", async () => {
  const cwd = tmpCwd();

@@ -0,0 +1,73 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, expect, onTestFinished, test } from "vitest";
+import { DaemonClient } from "../test-utils/daemon-client.js";
+import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
+
+// Windows does not preserve trailing spaces in folder names.
+const testOnPosix = test.skipIf(process.platform === "win32");
+
+let client: DaemonClient;
+let repoDir: string;
+let projectId: string;
+
+beforeEach(async () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "paseo-project-path-spaces-")));
+  onTestFinished(() => rmSync(root, { recursive: true, force: true }));
+  repoDir = join(root, "repo ");
+  execFileSync("git", ["init", "-b", "main", repoDir], { stdio: "pipe" });
+  execFileSync(
+    "git",
+    [
+      "-c",
+      "user.name=Paseo Test",
+      "-c",
+      "user.email=test@getpaseo.local",
+      "-c",
+      "commit.gpgsign=false",
+      "commit",
+      "--allow-empty",
+      "-m",
+      "initial",
+    ],
+    { cwd: repoDir, stdio: "pipe" },
+  );
+  const daemon = await createTestPaseoDaemon();
+  onTestFinished(() => daemon.close());
+  client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+  const testClient = client;
+  onTestFinished(() => testClient.close());
+  await client.connect();
+  const added = await client.addProject(repoDir);
+  expect(added.error).toBeNull();
+  expect(added.project?.projectRootPath).toBe(repoDir);
+  projectId = added.project!.projectId;
+});
+
+testOnPosix("a project folder ending in a space keeps its Git status", async () => {
+  const opened = await client.createWorkspace({
+    source: { kind: "directory", path: repoDir, projectId },
+  });
+  expect(opened.error).toBeNull();
+  expect(opened.workspace?.workspaceDirectory).toBe(repoDir);
+  const status = await client.getCheckoutStatus(repoDir);
+  expect(status.isGit).toBe(true);
+  expect(status.repoRoot).toBe(repoDir);
+  expect(status.currentBranch).toBe("main");
+});
+
+testOnPosix("a project folder ending in a space can create a worktree", async () => {
+  const created = await client.createWorkspace({
+    source: {
+      kind: "worktree",
+      projectId,
+      action: "branch-off",
+      branchName: "feature/spaces",
+      baseBranch: "main",
+    },
+  });
+  expect(created.error).toBeNull();
+  expect(created.workspace?.gitRuntime?.currentBranch).toBe("feature/spaces");
+});
@@ -12,8 +12,8 @@ import {
 } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { runGitCommand } from "../../utils/run-git-command.js";
+import { describe, expect, it, vi } from "vitest";
+import { runGitCommand, snapshotGitCommandRuntimeMetrics } from "../../utils/run-git-command.js";
 import {
  createExplorerEntry,
  deleteExplorerEntry,
@@ -517,6 +517,129 @@ describe("file explorer service", () => {
    }
  });

+  it("renames an untracked bracketed filename without matching a tracked sibling", async () => {
+    const root = await createTempDir("paseo-entry-literal-rename-");
+    try {
+      await runGitCommand(["init"], { cwd: root });
+      await writeFile(path.join(root, "i.tsx"), "tracked\n", "utf8");
+      await runGitCommand(["add", "i.tsx"], { cwd: root });
+      await writeFile(path.join(root, "[id].tsx"), "untracked\n", "utf8");
+
+      snapshotGitCommandRuntimeMetrics();
+      const result = await renameExplorerEntry({
+        root,
+        relativePath: "[id].tsx",
+        name: "renamed.tsx",
+      });
+
+      expect(result).toEqual({ status: "ok", path: "renamed.tsx" });
+      expect(snapshotGitCommandRuntimeMetrics().operationsTop).toEqual([
+        ["ls-files", 1],
+        ["rev-parse", 1],
+      ]);
+      expect(await readFile(path.join(root, "renamed.tsx"), "utf8")).toBe("untracked\n");
+      await expect(stat(path.join(root, "[id].tsx"))).rejects.toMatchObject({ code: "ENOENT" });
+      expect(await readFile(path.join(root, "i.tsx"), "utf8")).toBe("tracked\n");
+      expect((await runGitCommand(["ls-files", "-z"], { cwd: root })).stdout).toBe("i.tsx\0");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("renames an untracked bracketed folder without matching a tracked sibling", async () => {
+    const root = await createTempDir("paseo-folder-literal-rename-");
+    try {
+      await runGitCommand(["init"], { cwd: root });
+      await mkdir(path.join(root, "i"));
+      await writeFile(path.join(root, "i", "route.tsx"), "tracked\n", "utf8");
+      await runGitCommand(["add", "i"], { cwd: root });
+      await mkdir(path.join(root, "[id]"));
+      await writeFile(path.join(root, "[id]", "route.tsx"), "untracked\n", "utf8");
+
+      const result = await renameExplorerEntry({ root, relativePath: "[id]", name: "route" });
+
+      expect(result).toEqual({ status: "ok", path: "route" });
+      expect(await readFile(path.join(root, "route", "route.tsx"), "utf8")).toBe("untracked\n");
+      await expect(stat(path.join(root, "[id]"))).rejects.toMatchObject({ code: "ENOENT" });
+      expect(await readFile(path.join(root, "i", "route.tsx"), "utf8")).toBe("tracked\n");
+      expect((await runGitCommand(["ls-files", "-z"], { cwd: root })).stdout).toBe("i/route.tsx\0");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("uses Git to rename a tracked bracketed filename and preserves its tracked sibling", async () => {
+    const root = await createTempDir("paseo-tracked-literal-rename-");
+    try {
+      await runGitCommand(["init"], { cwd: root });
+      await writeFile(path.join(root, "[id].tsx"), "tracked route\n", "utf8");
+      await writeFile(path.join(root, "i.tsx"), "tracked sibling\n", "utf8");
+      await runGitCommand(["add", "--", "[id].tsx", "i.tsx"], { cwd: root });
+
+      const result = await renameExplorerEntry({
+        root,
+        relativePath: "[id].tsx",
+        name: "renamed.tsx",
+      });
+
+      expect(result).toEqual({ status: "ok", path: "renamed.tsx" });
+      expect(await readFile(path.join(root, "renamed.tsx"), "utf8")).toBe("tracked route\n");
+      await expect(stat(path.join(root, "[id].tsx"))).rejects.toMatchObject({ code: "ENOENT" });
+      expect(await readFile(path.join(root, "i.tsx"), "utf8")).toBe("tracked sibling\n");
+      expect((await runGitCommand(["ls-files", "-z"], { cwd: root })).stdout).toBe(
+        "i.tsx\0renamed.tsx\0",
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it.each([
+    {
+      sourcePath: "[id].tsx",
+      sourceFile: "[id].tsx",
+      targetName: "renamed.tsx",
+      targetFile: "renamed.tsx",
+    },
+    {
+      sourcePath: "[id]",
+      sourceFile: "[id]/route.tsx",
+      targetName: "route",
+      targetFile: "route/route.tsx",
+    },
+  ])(
+    "keeps tracked renames in the index with inherited literal pathspecs ($sourcePath)",
+    async ({ sourcePath, sourceFile, targetName, targetFile }) => {
+      const root = await createTempDir("paseo-inherited-literal-rename-");
+      try {
+        vi.stubEnv("GIT_LITERAL_PATHSPECS", "1");
+        await runGitCommand(["init"], { cwd: root });
+        await mkdir(path.dirname(path.join(root, sourceFile)), { recursive: true });
+        await writeFile(path.join(root, sourceFile), "tracked route\n", "utf8");
+        await writeFile(path.join(root, "i.tsx"), "tracked sibling\n", "utf8");
+        await runGitCommand(["add", "."], { cwd: root });
+
+        const result = await renameExplorerEntry({
+          root,
+          relativePath: sourcePath,
+          name: targetName,
+        });
+
+        expect(result).toEqual({ status: "ok", path: targetName });
+        expect(await readFile(path.join(root, targetFile), "utf8")).toBe("tracked route\n");
+        await expect(stat(path.join(root, sourcePath))).rejects.toMatchObject({ code: "ENOENT" });
+        expect(await readFile(path.join(root, "i.tsx"), "utf8")).toBe("tracked sibling\n");
+        expect((await runGitCommand(["ls-files", "-z"], { cwd: root })).stdout).toBe(
+          `i.tsx\0${targetFile}\0`,
+        );
+        expect(process.env.GIT_LITERAL_PATHSPECS).toBe("1");
+      } finally {
+        vi.unstubAllEnvs();
+        await rm(root, { recursive: true, force: true });
+      }
+    },
+  );
+
  it("supports case-only renames for tracked and untracked files", async () => {
    const root = await createTempDir("paseo-entry-case-rename-");
    try {
@@ -489,7 +489,7 @@ export async function writeExplorerFile({

  const temporaryPath = path.join(
    path.dirname(filePath.resolvedPath),
-    `.${path.basename(filePath.resolvedPath)}.paseo-${randomUUID()}.tmp`,
+    `.paseo-${randomUUID()}.tmp`,
  );
  let temporaryHandle: FileHandle | null = null;
  try {
@@ -724,7 +724,11 @@ export async function renameExplorerEntry({
    });
    const tracked =
      repository.exitCode === 0
-        ? await runGitCommand(["ls-files", "-z", "--", sourcePath], { cwd: realRoot })
+        ? await runGitCommand(["ls-files", "-z", "--", `:(literal)${sourcePath}`], {
+            cwd: realRoot,
+            // Inherited literal mode disables the :(literal) pathspec magic.
+            envOverlay: { GIT_LITERAL_PATHSPECS: undefined },
+          })
        : null;
    if (tracked?.stdout) {
      await runGitCommand(["mv", "--", sourcePath, renamedPath], { cwd: realRoot });
@@ -820,8 +824,9 @@ async function resolveScopedPath({

 function assertWithinWorkspace(root: string, candidate: string): void {
  const relative = path.relative(root, candidate);
-  if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) return;
-  throw new Error(ACCESS_OUTSIDE_WORKSPACE_MESSAGE);
+  const isOutsideWorkspace =
+    relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+  if (isOutsideWorkspace) throw new Error(ACCESS_OUTSIDE_WORKSPACE_MESSAGE);
 }

 async function openFileForRead(filePath: string): Promise<FileHandle> {
@@ -0,0 +1,78 @@
+import { readFileSync } from "node:fs";
+import Ajv from "ajv";
+import { expect, test } from "vitest";
+import { z } from "zod";
+
+import { PersistedConfigSchema } from "./persisted-config.js";
+
+const publishedSchema = JSON.parse(
+  readFileSync(
+    new URL("../../../website/public/schemas/paseo.config.v1.json", import.meta.url),
+    "utf8",
+  ),
+);
+
+test("editors accept the daemon's browser, profile, plugin and metadata configuration", () => {
+  const config = {
+    $schema: "https://paseo.sh/schemas/paseo.config.v1.json",
+    version: 1,
+    daemon: {
+      browserTools: { enabled: true },
+      terminalProfiles: [],
+      agentProfiles: [],
+    },
+    pluginsEnabled: true,
+    plugins: {},
+    agents: {
+      metadataGeneration: { providers: [{ provider: "claude", model: "claude-opus-5" }] },
+    },
+  };
+  expect(PersistedConfigSchema.parse(config)).toEqual(config);
+  const validate = new Ajv({ allErrors: true, strict: false }).compile(publishedSchema);
+  const valid = validate(config);
+  expect(validate.errors).toBeNull();
+  expect(valid).toBe(true);
+});
+
+test("the published schema stays current with the daemon's configuration schema", () => {
+  const generated = z.toJSONSchema(PersistedConfigSchema, {
+    target: "draft-07",
+    unrepresentable: "any",
+    io: "input",
+  });
+  generated.title = "PaseoConfigV1";
+  expect(
+    publishedSchema,
+    "Run npm run generate:config-schema --workspace=@getpaseo/server",
+  ).toEqual(generated);
+});
+
+test("editors retain the existing proxy configuration help", () => {
+  const daemon = publishedSchema.properties.daemon.properties;
+  expect(daemon.trustedProxies.description).toBe(
+    'Express trusted proxy setting for X-Forwarded-* headers. Defaults to ["loopback"]. Use true only when the final trusted proxy overwrites client-supplied forwarded headers.',
+  );
+  expect(daemon.serviceProxy.properties.enabled.description).toBe(
+    "Compatibility shim. false suppresses optional service proxy listen/public layers only; localhost proxying remains enabled.",
+  );
+  expect(daemon.serviceProxy.properties.listen.description).toBe(
+    "Optional service-only listener address. Presence enables the standalone service proxy listener.",
+  );
+  expect(daemon.serviceProxy.properties.publicBaseUrl.description).toBe(
+    "Optional public base URL for service host aliases.",
+  );
+});
+
+test.each([
+  { daemon: { browserTools: { enabled: "yes" } } },
+  { daemon: { terminalProfiles: "default" } },
+  { daemon: { agentProfiles: "default" } },
+  { pluginsEnabled: "yes" },
+  { plugins: [] },
+  { agents: { metadataGeneration: { providers: [{ provider: "" }] } } },
+  { unknownSetting: true },
+])("editors still reject invalid configuration: %j", (config) => {
+  expect(PersistedConfigSchema.safeParse(config).success).toBe(false);
+  const validate = new Ajv({ allErrors: true, strict: false }).compile(publishedSchema);
+  expect(validate(config)).toBe(false);
+});
@@ -237,7 +237,12 @@ export const PersistedConfigSchema = z
        listen: z.string().optional(),
        hostnames: z.union([z.literal(true), z.array(z.string())]).optional(),
        allowedHosts: z.union([z.literal(true), z.array(z.string())]).optional(),
-        trustedProxies: z.union([z.literal(true), z.array(z.string())]).optional(),
+        trustedProxies: z
+          .union([z.literal(true), z.array(z.string())])
+          .optional()
+          .describe(
+            'Express trusted proxy setting for X-Forwarded-* headers. Defaults to ["loopback"]. Use true only when the final trusted proxy overwrites client-supplied forwarded headers.',
+          ),
        mcp: z
          .object({
            enabled: z.boolean().optional(),
@@ -284,9 +289,22 @@ export const PersistedConfigSchema = z
            // COMPAT(serviceProxyEnabled): added 2026-06-02, remove after 2026-12-02.
            // Parsed only to suppress optional public/listen layers for old configs;
            // localhost service proxying remains always enabled.
-            enabled: z.boolean().optional(),
-            listen: z.string().optional(),
-            publicBaseUrl: z.url().optional(),
+            enabled: z
+              .boolean()
+              .optional()
+              .describe(
+                "Compatibility shim. false suppresses optional service proxy listen/public layers only; localhost proxying remains enabled.",
+              ),
+            listen: z
+              .string()
+              .optional()
+              .describe(
+                "Optional service-only listener address. Presence enables the standalone service proxy listener.",
+              ),
+            publicBaseUrl: z
+              .url()
+              .optional()
+              .describe("Optional public base URL for service host aliases."),
          })
          .strict()
          .optional(),
@@ -55,6 +55,7 @@ export function createNoopWorkspaceGitService(
    suggestBranchesForCwd: async () => [],
    listStashes: async () => [],
    listWorktrees: async () => [],
+    invalidateWorktrees: () => {},
    getProjectSlug: async (cwd: string) => {
      const snapshot = createNoGitWorkspaceRuntimeSnapshot(cwd);
      return deriveProjectSlug(cwd, snapshot.git.isGit ? snapshot.git.remoteUrl : null);
@@ -190,6 +190,34 @@ index 1234567..abcdefg 100644
 `;

 describe("parseDiff", () => {
+  it.each(["-- comment", "++ marker"])(
+    "preserves hunk content resembling patch headers: %s",
+    (content) => {
+      const files = parseDiff(`diff --git a/example.txt b/example.txt
+index 1234567..abcdefg 100644
+--- a/example.txt
+++ b/example.txt
+@@ -1 +1 @@
+-${content} before
+${content} after
+`);
+
+      expect(files).toHaveLength(1);
+      expect(files[0]).toMatchObject({
+        path: "example.txt",
+        isNew: false,
+        isDeleted: false,
+        additions: 1,
+        deletions: 1,
+      });
+      expect(files[0].hunks[0].lines).toEqual([
+        { type: "header", content: "@@ -1 +1 @@" },
+        { type: "remove", content: `${content} before` },
+        { type: "add", content: `${content} after` },
+      ]);
+    },
+  );
+
  it("parses a simple diff with one hunk", () => {
    const files = parseDiff(SIMPLE_DIFF);

@@ -79,16 +79,6 @@ function extractPathFromDiffHeader(lines: string[]): string {
  return "unknown";
 }

-function isMetadataLine(line: string): boolean {
-  return (
-    line.startsWith("index ") ||
-    line.startsWith("--- ") ||
-    line.startsWith("+++ ") ||
-    line.startsWith("new file mode") ||
-    line.startsWith("deleted file mode")
-  );
-}
-
 function parseHunkHeader(line: string): DiffHunk | null {
  const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
  if (!hunkMatch) return null;
@@ -116,8 +106,6 @@ function parseSectionBody(lines: string[]): ParsedSectionBody {
  for (let i = 1; i < lines.length; i++) {
    const line = lines[i];

-    if (isMetadataLine(line)) continue;
-
    const newHunk = parseHunkHeader(line);
    if (newHunk) {
      if (currentHunk) hunks.push(currentHunk);
@@ -250,6 +250,22 @@ function serializeInlineScriptJson(value: unknown): string {
    .replace(/&/g, "\\u0026");
 }

+/**
+ * A Host header carries no port when the client used the scheme's default one,
+ * which is what every browser sends to a proxy terminating TLS on 443. The app
+ * parses `listen` with parseHostPort, which requires an explicit port and
+ * rejects the value outright, so the hint has to spell the port out.
+ */
+function hasExplicitPort(host: string): boolean {
+  if (host.startsWith("[")) {
+    // IPv6 literals are bracketed: [::1] has no port, [::1]:443 does.
+    const end = host.indexOf("]");
+    return end !== -1 && /^:\d{1,5}$/.test(host.slice(end + 1));
+  }
+  const colon = host.indexOf(":");
+  return colon !== -1 && colon === host.lastIndexOf(":") && /^\d{1,5}$/.test(host.slice(colon + 1));
+}
+
 function injectConnectionHint(
  html: string,
  req: Parameters<RequestHandler>[0],
@@ -257,8 +273,16 @@ function injectConnectionHint(
 ): string {
  const host = typeof req.headers.host === "string" ? req.headers.host : "";
  const useTls = req.protocol === "https";
+  let listen = host;
+  if (host && !hasExplicitPort(host)) {
+    let defaultPort = 80;
+    if (useTls) {
+      defaultPort = 443;
+    }
+    listen = `${host}:${defaultPort}`;
+  }
  const hint = {
-    listen: host,
+    listen,
    useTls,
    label,
  };
@@ -246,6 +246,7 @@ function createFallbackWorkspaceGitService(): WorkspaceGitService {
    suggestBranchesForCwd: async () => [],
    listStashes: async () => [],
    listWorktrees: async () => [],
+    invalidateWorktrees: () => {},
    getProjectSlug: async (cwd: string) => {
      const snapshot = createFallbackWorkspaceGitSnapshot(cwd);
      return deriveProjectSlug(cwd, snapshot.git.isGit ? snapshot.git.remoteUrl : null);
--- a/Show More
+++ b/Show More