fix(app): keep rewound history in its own chat

A restored fork snapshot belongs to the rewound agent. Give it an agent attachment scope so switching chats cannot send or consume that context elsewhere in the workspace.

docs/agent-lifecycle.md

@@ -136,6 +136,12 @@ the marker. Closing a tab sets that client's label to `false`. Any `true` client
 open. Detach clears the parent and every open-tab label. The surviving child therefore becomes a
 normal root agent immediately, and closing its still-open tab archives it.
 
+Agent-scoped workspace creation records the caller's workspace as `parentWorkspaceId`.
+This is informational ancestry for future workspace grouping. It does not change placement,
+visibility, status, or archive behavior. Archiving a parent workspace preserves its children's
+records and parentage. Unscoped creation and existing workspaces have no parent; ancestry is
+never inferred from directories, projects, or Git branches.
+
 Runtime ownership is resolved from explicit workspace ID and caller context, never from `cwd`. Workspace creation is a separate operation with `local | worktree` isolation; agent creation reuses that workspace unless a new workspace is explicitly requested.
 
 Setup belongs to the workspace, including combined workspace-plus-agent creation and the supported agent `worktree` request. Run setup through the workspace workflow before launching configured terminals or scripts. Setup output is read in the Setup panel from per-command snapshots; never produce setup chat timeline rows or concatenate command logs. Legacy agent `git`/`worktreeName` inputs and hidden MCP worktree placement are rejected with workspace-creation guidance. Existing wire schemas retain an empty combined-log string for parsing compatibility.

docs/design.md

@@ -68,7 +68,7 @@ the sidebar. Apply it as `backgroundColor`; setting `opacity` on the control als
 
 `destructive` is filled with `destructive`. It only appears inside a confirm. The button on the page is `outline`; the destructive button is the confirm button inside the dialog.
 
-Controls come in two sizes, defined once in `control-geometry.ts`. The default is the right size almost everywhere — pages, dialogs, forms, settings rows, the setup flow — so don't pass a size. It is 32px tall where a pointer drives it and 44px where controls are touch-sized, so every touch control meets the iOS HIG's 44pt hit region. `sm` is 28px pointer and 32px touch, with `fontSize.sm` labels, and is for tight chrome only: toolbars, nested settings rows, dense inline row actions. A `size="sm"` on an ordinary page or dialog is wrong, and so is choosing a size from `useIsCompactFormFactor()`.
+Controls come in two sizes, defined once in `control-geometry.ts`. The default is the right size almost everywhere — pages, dialogs, forms, settings rows, the setup flow — so don't pass a size. It is 32px tall where a pointer drives it and 44px where controls are touch-sized, so every touch control meets the iOS HIG's 44pt hit region. The hit region is not the painted area: a filled toolbar control such as the composer's send or stop keeps the 44pt frame and paints a 36pt disc inside it (`TOOLBAR_DISC_SIZE`), so it does not outweigh its unpainted neighbours. `sm` is 28px pointer and 32px touch, with `fontSize.sm` labels, and is for tight chrome only: toolbars, nested settings rows, dense inline row actions. A `size="sm"` on an ordinary page or dialog is wrong, and so is choosing a size from `useIsCompactFormFactor()`.
 
 One gate, `resolveControlSizing`, picks touch or pointer sizing: touch when the layout is compact or the device has a touch screen. An iPad with the sidebar docked is wide and touch-sized; a desktop is pointer-sized; a phone is both compact and touch. The touch-screen fact is read once at startup (`hasTouchScreen` in `hooks/use-fine-pointer.ts`), so attaching a mouse or keyboard to a tablet never shrinks its controls. Stylesheets take sizes from `bySizing({ touch, pointer })`, which resolves to a breakpoint value, so a caller never sees which sizing it got. Rows, icon buttons and icon slots take theirs from `styles/density.ts`, which uses the same gate. An `{ xs, md }` literal for a hit target or glyph is wrong: on an iPad it yields the pointer size.
 

docs/menus.md

@@ -226,7 +226,8 @@ its own.
   inactive. An async action can navigate before its menu closes; a hidden panel must not leave a
   portal backdrop blocking the destination. On web the chat suspends one commit after it goes
   inactive, and that inactive commit is where the surface unmounts.
-- Anchoring, flipping, and edge clamping live in `components/ui/anchor.ts`, shared with the hover
-  card, and are unit-tested. Fix positioning bugs there, not at a call site.
+- Anchoring, flipping, edge clamping, and capping a surface's width to the display live in
+  `components/ui/anchor.ts`, shared with the hover card, and are unit-tested. Clamping moves a
+  surface but cannot shrink it, so the width cap is what keeps a wide menu on a narrow screen. Fix positioning bugs there, not at a call site.
 - Everything else about floating surfaces on Android — Portal/Modal escape, lifecycle gates,
   status-bar offset, the open flash — is in [floating-panels.md](floating-panels.md).

packages/app/e2e/browser/assistant-fork-menu.spec.ts

@@ -1,6 +1,18 @@
+import {
+  captureChatHistory,
+  expectRewoundHistoryIsPrivate,
+  rewindForkPrompt,
+  closeChatHistory,
+  followChatHistorySource,
+  openChatHistory,
+  sendChatHistoryFromAnotherClient,
+  setChatHistoryViewport,
+} from "../support/helpers/chat-history";
 import { expect, test as base } from "../support/fixtures";
 import { awaitAssistantMessage } from "../support/helpers/agent-stream";
 import {
+  getActiveForkAgentId,
+  expectActiveForkAgent,
   expectChatHistoryAttachment,
   expectInFlightForkAvailable,
   expectLiveAssistantText,
@@ -38,6 +50,97 @@ const test = base.extend<{
 test.describe("Assistant fork menu", () => {
   test.describe.configure({ timeout: 180_000 });
 
+  test("reads fork history before and after sending and opens its source after reload", async ({
+    page,
+    seedForkWorkspace,
+  }, testInfo) => {
+    const initialPrompt = "emit 1 coalesced agent stream updates for readable fork history.";
+    const session = await seedForkWorkspace({
+      repoPrefix: "assistant-fork-readable-",
+      title: "Original conversation",
+      initialPrompt,
+      model: "ten-second-stream",
+    });
+    await openAgentRoute(page, session);
+    await expectComposerVisible(page);
+    await awaitAssistantMessage(page);
+    await session.client.waitForFinish(session.agentId, 45_000);
+    await forkMostRecentAssistantTurnToNewTab(page);
+    await openChatHistory(page, "draft", [initialPrompt]);
+    await captureChatHistory(page, testInfo, "history-wide.png");
+    await closeChatHistory(page);
+    await submitMessage(page, "emit 1 coalesced agent stream updates for the fork.");
+    const forkAgentId = await getActiveForkAgentId(page);
+    await session.client.waitForFinish(forkAgentId, 45_000);
+
+    await openAgentRoute(page, { workspaceId: session.workspaceId, agentId: forkAgentId });
+    await page.reload();
+    await setChatHistoryViewport(page, "compact");
+    await openChatHistory(page, "sent", [initialPrompt]);
+    await captureChatHistory(page, testInfo, "history-compact.png");
+    await followChatHistorySource(page);
+    await setChatHistoryViewport(page, "wide");
+    await expectActiveForkAgent(page, session.agentId);
+
+    await openAgentRoute(page, { workspaceId: session.workspaceId, agentId: forkAgentId });
+    await expectActiveForkAgent(page, forkAgentId);
+    await forkMostRecentAssistantTurnToNewTab(page);
+    await openChatHistory(page, "draft", [initialPrompt, "updates for the fork."]);
+    await followChatHistorySource(page);
+    await expectActiveForkAgent(page, forkAgentId);
+  });
+
+  for (const prompt of ["", "Continue the fork"]) {
+    test(`retains inherited context when rewinding the first fork prompt (${prompt || "history only"})`, async ({
+      page,
+      seedForkWorkspace,
+    }) => {
+      const initialPrompt = "emit 1 coalesced agent stream updates for rewindable fork history.";
+      const session = await seedForkWorkspace({
+        repoPrefix: "fork-rewind-",
+        title: "Rewind source",
+        initialPrompt,
+        model: "ten-second-stream",
+      });
+      await openAgentRoute(page, session);
+      await expectComposerVisible(page);
+      await awaitAssistantMessage(page);
+      await session.client.waitForFinish(session.agentId, 45_000);
+      await forkMostRecentAssistantTurnToNewTab(page);
+      await submitMessage(page, prompt);
+      const forkId = await getActiveForkAgentId(page);
+      await session.client.waitForFinish(forkId, 45_000);
+      await page.reload();
+      await openChatHistory(page, "sent", [initialPrompt]);
+      await closeChatHistory(page);
+      await rewindForkPrompt(page);
+      await expectRewoundHistoryIsPrivate(page, session.agentId, forkId);
+      await openChatHistory(page, "draft", [initialPrompt]);
+      await closeChatHistory(page);
+      await submitMessage(page, prompt);
+      await session.client.waitForFinish(forkId, 45_000);
+      await page.reload();
+      await openChatHistory(page, "sent", [initialPrompt]);
+    });
+  }
+
+  test("shows history sent from another connected client without reloading", async ({
+    page,
+    seedForkWorkspace,
+  }) => {
+    const session = await seedForkWorkspace({
+      repoPrefix: "assistant-fork-live-history-",
+      title: "Live history recipient",
+      model: "ten-second-stream",
+    });
+    await openAgentRoute(page, session);
+    await expectComposerVisible(page);
+    const history = "[User] Context inherited on another device.";
+    await sendChatHistoryFromAnotherClient(session, history);
+    await openChatHistory(page, "sent", [history]);
+    await session.client.waitForFinish(session.agentId, 45_000);
+  });
+
   test("forks a failed assistant turn that has no provider message id", async ({
     page,
     seedForkWorkspace,

packages/app/e2e/browser/sidebar-footer-overflow.spec.ts

@@ -0,0 +1,127 @@
+import { expect, test } from "../support/fixtures";
+import { addProjectFlow } from "../support/helpers/add-project-flow";
+import { gotoAppShell } from "../support/helpers/app";
+import {
+  chooseFooterOverflowAction,
+  expectFooterLine,
+  expectFooterMenusInsideViewport,
+  expectFooterNeverClipped,
+  expectFooterOverflowActions,
+  footerOverflowMenu,
+  openFooterOverflow,
+  seedDockedSidebarWidth,
+  watchFooterClipping,
+} from "../support/helpers/sidebar-footer-overflow";
+import { addOfflineHostsAndReload } from "../support/helpers/hosts";
+import { openCompactSidebar } from "../support/helpers/usage-sidebar-item";
+
+const TOUCH_CONTROL = 44;
+const MIN_SIDEBAR_WIDTH = 200;
+const ALL_INLINE = [
+  "sidebar-add-project",
+  "sidebar-usage-icon",
+  "sidebar-hosts-trigger",
+  "sidebar-help",
+  "sidebar-settings",
+];
+// Five 44pt buttons and the row's padding need 236pt; 200pt holds three and the caret.
+const NARROW_TOUCH_LINE = [
+  "sidebar-add-project",
+  "sidebar-hosts-trigger",
+  "sidebar-footer-overflow",
+  "sidebar-settings",
+];
+
+test.describe("Sidebar footer on a touch screen", () => {
+  test.use({ viewport: { width: 1280, height: 800 }, hasTouch: true });
+
+  test("a narrow docked sidebar moves the actions it can't fit behind a caret", async ({
+    page,
+  }) => {
+    await seedDockedSidebarWidth(page, MIN_SIDEBAR_WIDTH);
+    await watchFooterClipping(page);
+    await gotoAppShell(page);
+    await expectFooterLine(page, { testIDs: NARROW_TOUCH_LINE, controlSize: TOUCH_CONTROL });
+    await expectFooterNeverClipped(page);
+
+    await test.step("Help opens as a page of the overflow menu", async () => {
+      await openFooterOverflow(page);
+      await expectFooterOverflowActions(page, ["Usage", "Help and support"]);
+      await chooseFooterOverflowAction(page, "Help and support");
+      await expect(page.getByRole("menuitem", { name: "What's new" })).toBeVisible();
+      await expect(page.getByTestId("sidebar-help-menu")).toHaveCount(0);
+      await page.keyboard.press("Escape");
+      await expect(footerOverflowMenu(page)).toBeHidden();
+    });
+
+    await test.step("Usage opens from the overflow menu", async () => {
+      await openFooterOverflow(page);
+      await chooseFooterOverflowAction(page, "Usage");
+      await expect(footerOverflowMenu(page)).toBeHidden();
+      await expect(page.getByTestId("usage-modal")).toBeVisible();
+      await page.keyboard.press("Escape");
+      await expect(page.getByTestId("usage-modal")).toBeHidden();
+    });
+
+    await test.step("Add project and Settings shortcuts still work", async () => {
+      await page.keyboard.press("Control+o");
+      await expect(addProjectFlow(page)).toBeVisible();
+      await page.keyboard.press("Escape");
+      await expect(addProjectFlow(page)).toBeHidden();
+      await page.keyboard.press("Control+,");
+      await expect(page).toHaveURL(/\/settings\/general$/);
+    });
+  });
+
+  test("the default sidebar width keeps all five actions inline", async ({ page }) => {
+    await gotoAppShell(page);
+    await expectFooterLine(page, { testIDs: ALL_INLINE, controlSize: TOUCH_CONTROL });
+  });
+});
+
+test.describe("Sidebar footer in a compact overlay narrower than the footer", () => {
+  test.use({ viewport: { width: 220, height: 800 }, hasTouch: true });
+
+  test("the overflow menu reaches the hidden actions", async ({ page }) => {
+    await watchFooterClipping(page);
+    await gotoAppShell(page);
+    await openCompactSidebar(page);
+    await expectFooterLine(page, { testIDs: NARROW_TOUCH_LINE, controlSize: TOUCH_CONTROL });
+    await expectFooterNeverClipped(page);
+    await openFooterOverflow(page);
+    await expectFooterOverflowActions(page, ["Usage", "Help and support"]);
+    await expectFooterMenusInsideViewport(page);
+  });
+});
+
+test.describe("Sidebar footer on a short, narrow phone", () => {
+  // 164pt for buttons holds Settings, Add project and the caret, so Hosts moves behind it.
+  test.use({ viewport: { width: 180, height: 360 }, hasTouch: true });
+
+  test("the overflow Hosts page scrolls to its last host and Add host", async ({ page }) => {
+    await gotoAppShell(page);
+    await addOfflineHostsAndReload(
+      page,
+      Array.from({ length: 10 }, (_, index) => ({
+        serverId: `overflow-host-${index}`,
+        label: `Overflow host ${index}`,
+      })),
+    );
+    await openCompactSidebar(page);
+    await expectFooterLine(page, {
+      testIDs: ["sidebar-add-project", "sidebar-footer-overflow", "sidebar-settings"],
+      controlSize: TOUCH_CONTROL,
+    });
+    await openFooterOverflow(page);
+    await expectFooterOverflowActions(page, ["Usage", "Hosts", "Help and support"]);
+    await expectFooterMenusInsideViewport(page);
+    await chooseFooterOverflowAction(page, "Hosts");
+    await expectFooterMenusInsideViewport(page);
+    const addHost = page.getByRole("menuitem", { name: "Add host" });
+    await addHost.scrollIntoViewIfNeeded();
+    await expect(page.getByRole("menuitem", { name: "Overflow host 9" })).toBeVisible();
+    await expect(addHost).toBeInViewport();
+    await addHost.click();
+    await expect(page.getByText("Add connection", { exact: true })).toBeVisible();
+  });
+});

packages/app/e2e/browser/usage-sidebar-item.spec.ts

@@ -8,7 +8,7 @@ import {
   openProjectViaDaemon,
 } from "../support/helpers/new-workspace";
 import { getServerId } from "../support/helpers/server-id";
-import { openSettingsHostSection } from "../support/helpers/settings";
+import { openCompactSettings, openSettingsHostSection } from "../support/helpers/settings";
 import {
   expectFooterItemSetting,
   expectFooterSeparator,
@@ -42,6 +42,7 @@ import {
 import { seedSidebarFooterPreferences } from "../support/helpers/sidebar-nav-settings";
 import { waitForSettledPosition } from "../support/helpers/sheet-layout";
 import { createTempGitRepo } from "../support/helpers/workspace";
+import { buildOpenProjectRoute } from "@/utils/host-routes";
 
 const WIDE = { width: 1440, height: 900 };
 const COMPACT = { width: 390, height: 844 };
@@ -70,7 +71,112 @@ async function footerClip(page: Page) {
   return (await page.locator('[data-testid="sidebar-footer"]:visible').boundingBox())!;
 }
 
+async function setPageVisibility(page: Page, visibility: DocumentVisibilityState): Promise<void> {
+  await page.evaluate((state) => {
+    Object.defineProperty(document, "visibilityState", { configurable: true, get: () => state });
+    Object.defineProperty(document, "hidden", {
+      configurable: true,
+      get: () => state === "hidden",
+    });
+    document.dispatchEvent(new Event("visibilitychange"));
+  }, visibility);
+}
+
 test.describe("Usage item", () => {
+  test("visible summary refreshes every five minutes without opening Usage", async ({ page }) => {
+    let usedPct = 31;
+    const usage = await installUsageReportsFixture(page, {
+      lists: [
+        () => [
+          {
+            ...claudeAndCodexReports()[0]!,
+            report: {
+              status: "available",
+              windows: [
+                { id: "five_hour", label: "Session", shortLabel: "5h", summary: true, usedPct },
+              ],
+            },
+          },
+        ],
+      ],
+    });
+    await page.clock.install();
+    await page.setViewportSize(WIDE);
+    await seedSidebarFooterPreferences(page, [{ key: "usage", visible: true }]);
+    await gotoAppShell(page);
+    await expectPinnedUsage(page, ["31% 5h"]);
+    const startingUrl = page.url();
+    await qaScreenshot(page, "usage-auto-refresh-initial", { kind: "footer" });
+    const requestsBeforeRefresh = usage.listRequests();
+
+    usedPct = 42;
+    await page.clock.fastForward(5 * 60_000);
+    await qaScreenshot(page, "usage-auto-refresh-after-interval", { kind: "footer" });
+    await expectPinnedUsage(page, ["42% 5h"]);
+    await expect(usageModal(page)).toHaveCount(0);
+    await expect(page).toHaveURL(startingUrl);
+    expect(usage.listRequests()).toEqual([
+      ...requestsBeforeRefresh,
+      { forceRefresh: false, reportIds: undefined, agentId: undefined },
+    ]);
+
+    await setPageVisibility(page, "hidden");
+    const requestsBeforeBackgrounding = usage.listRequests();
+    usedPct = 47;
+    await page.clock.fastForward(5 * 60_000);
+    expect(usage.listRequests()).toEqual(requestsBeforeBackgrounding);
+    await expectPinnedUsage(page, ["42% 5h"]);
+    await setPageVisibility(page, "visible");
+    await page.clock.fastForward(5 * 60_000);
+    await expectPinnedUsage(page, ["47% 5h"]);
+    expect(usage.listRequests()).toEqual([
+      ...requestsBeforeBackgrounding,
+      { forceRefresh: false, reportIds: undefined, agentId: undefined },
+    ]);
+
+    await page.setViewportSize(COMPACT);
+    await expect(usageItem(page)).toHaveCount(0);
+    const requestsBeforeHiding = usage.listRequests();
+    await page.clock.fastForward(5 * 60_000);
+    expect(usage.listRequests()).toEqual(requestsBeforeHiding);
+
+    await openCompactSidebar(page);
+    await expectPinnedUsage(page, ["47% 5h"]);
+    await expect(page.getByTestId("agent-list-backdrop")).toBeVisible();
+    usedPct = 53;
+    await page.clock.fastForward(5 * 60_000);
+    await expectPinnedUsage(page, ["53% 5h"]);
+    await expect(usageModal(page)).toHaveCount(0);
+
+    await page.setViewportSize(WIDE);
+    await openSidebarNavSettings(page);
+    await setFooterItemVisible(page, "usage", false);
+    await leaveSettings(page);
+    await expectNoUsageItem(page);
+    const requestsBeforeDisabling = usage.listRequests();
+    await page.clock.fastForward(5 * 60_000);
+    expect(usage.listRequests()).toEqual(requestsBeforeDisabling);
+  });
+
+  test("Usage settings do not poll reports while the sidebar is inactive", async ({ page }) => {
+    const usage = await installUsageReportsFixture(page, {
+      lists: [() => claudeAndCodexReports()],
+    });
+    await page.clock.install();
+    await page.setViewportSize(COMPACT);
+    await seedSidebarFooterPreferences(page, [{ key: "usage", visible: true }]);
+    await gotoAppShell(page);
+    await openCompactSettings(page, buildOpenProjectRoute());
+    await openSettingsHostSection(page, getServerId(), "usage");
+    await expect(page.getByTestId("usage-card").getByText("31% used")).toBeVisible();
+    await expect(usageItem(page)).toHaveCount(0);
+    const requestsBeforeWaiting = usage.listRequests();
+
+    await page.clock.fastForward(5 * 60_000);
+    expect(usage.listRequests()).toEqual(requestsBeforeWaiting);
+    await expect(page.getByTestId("usage-card").getByText("31% used")).toBeVisible();
+  });
+
   test("both compact footer entry points open Usage as a sheet", async ({ page }) => {
     await page.setViewportSize(COMPACT);
     await installUsageReportsFixture(page, { lists: [() => claudeAndCodexReports()] });

packages/app/e2e/support/helpers/assistant-fork.ts

@@ -112,3 +112,21 @@ export async function expectLiveAssistantText(page: Page, text: string): Promise
     timeout: 60_000,
   });
 }
+
+export async function getActiveForkAgentId(page: Page): Promise<string> {
+  const selectedTab = page
+    .getByTestId("workspace-tabs-row")
+    .getByRole("button")
+    .and(page.locator('[aria-selected="true"]'));
+  await expect(selectedTab).toHaveAttribute("data-testid", /^workspace-tab-agent_/);
+  const tabId = await selectedTab.getAttribute("data-testid");
+  if (!tabId) throw new Error("Expected a selected agent tab");
+  return tabId.replace("workspace-tab-agent_", "");
+}
+
+export async function expectActiveForkAgent(page: Page, agentId: string) {
+  await expect(page.getByTestId(`workspace-tab-agent_${agentId}`)).toHaveAttribute(
+    "aria-selected",
+    "true",
+  );
+}

packages/app/e2e/support/helpers/chat-history.ts

@@ -0,0 +1,82 @@
+import { expect, type Page, type TestInfo } from "@playwright/test";
+import type { MockAgentWorkspace } from "./mock-agent";
+import { getServerId } from "./server-id";
+
+export function setChatHistoryViewport(page: Page, layout: "wide" | "compact") {
+  return page.setViewportSize(
+    layout === "wide" ? { width: 1280, height: 720 } : { width: 390, height: 844 },
+  );
+}
+
+export async function openChatHistory(page: Page, location: "draft" | "sent", contents: string[]) {
+  const testId =
+    location === "draft"
+      ? "composer-chat-history-attachment-pill"
+      : "message-chat-history-attachment";
+  const attachment = page.getByTestId(testId).filter({ visible: true }).last();
+  await expect(attachment).toBeVisible({ timeout: 10_000 });
+  await attachment.click();
+  for (const text of contents) {
+    await expect(page.getByTestId("chat-history-content")).toContainText(text);
+  }
+  await expect(page.getByRole("button", { name: "Open source chat" })).toBeVisible();
+}
+
+export async function closeChatHistory(page: Page) {
+  await page
+    .getByTestId("chat-history-preview")
+    .getByRole("button", { name: "Close", exact: true })
+    .click();
+}
+
+export async function followChatHistorySource(page: Page) {
+  await page.getByRole("button", { name: "Open source chat" }).click();
+  await expect(page.getByTestId("chat-history-preview")).not.toBeVisible();
+}
+
+export async function captureChatHistory(page: Page, testInfo: TestInfo, name: string) {
+  // Follow the existing QA helpers: settle spring animations and hide Expo-only chrome.
+  await page.waitForTimeout(600);
+  await page.addStyleTag({ content: ".__expo_fast_refresh { display: none !important; }" });
+  await page.screenshot({ path: testInfo.outputPath(name), animations: "disabled" });
+}
+
+export async function sendChatHistoryFromAnotherClient(
+  session: MockAgentWorkspace,
+  history: string,
+) {
+  const serverId = getServerId();
+  await session.client.sendAgentMessage(session.agentId, "", {
+    attachments: [
+      {
+        type: "text",
+        mimeType: "text/plain",
+        contextKind: "chat_history",
+        text: history,
+        chatHistorySource: { serverId, agentId: "source-agent", title: "Original conversation" },
+      },
+    ],
+  });
+}
+
+export async function rewindForkPrompt(page: Page) {
+  const prompt = page.getByTestId("user-message").filter({ visible: true }).last();
+  await prompt.hover();
+  const trigger = prompt.getByRole("button", { name: "Rewind to this message", exact: true });
+  await expect(trigger).toBeVisible({ timeout: 10_000 });
+  await trigger.click();
+  const option = page.getByRole("menuitem", { name: "Rewind conversation", exact: true });
+  await expect(option).toBeInViewport({ ratio: 1 });
+  await option.click();
+  await expect(option).not.toBeVisible();
+}
+
+export async function expectRewoundHistoryIsPrivate(page: Page, sourceId: string, forkId: string) {
+  await page.getByTestId(`workspace-tab-agent_${sourceId}`).click();
+  const history = page
+    .getByTestId("composer-chat-history-attachment-pill")
+    .filter({ visible: true });
+  await expect(history).toHaveCount(0);
+  await page.getByTestId(`workspace-tab-agent_${forkId}`).click();
+  await expect(history).toBeVisible();
+}

packages/app/e2e/support/helpers/hosts.ts

@@ -22,15 +22,27 @@ export async function addOfflineHostAndReload(
   page: Page,
   input: { serverId: string; label: string; primaryLabel?: string },
 ): Promise<void> {
-  const offlineHost = buildSeededHost({
-    serverId: input.serverId,
-    label: input.label,
-    endpoint: "127.0.0.1:59999",
-    nowIso: new Date().toISOString(),
-  });
+  await addOfflineHostsAndReload(page, [input], { primaryLabel: input.primaryLabel });
+}
+
+/** Adds several unreachable hosts with one reload. See `addOfflineHostAndReload`. */
+export async function addOfflineHostsAndReload(
+  page: Page,
+  hosts: Array<{ serverId: string; label: string }>,
+  options: { primaryLabel?: string } = {},
+): Promise<void> {
+  const nowIso = new Date().toISOString();
+  const offlineHosts = hosts.map((host) =>
+    buildSeededHost({
+      serverId: host.serverId,
+      label: host.label,
+      endpoint: "127.0.0.1:59999",
+      nowIso,
+    }),
+  );
 
   await page.evaluate(
-    ({ host, keys, primaryLabel }) => {
+    ({ hosts: added, keys, primaryLabel }) => {
       const nonce = localStorage.getItem(keys.nonce);
       if (!nonce) {
         throw new Error("Expected the e2e seed nonce before overriding the host registry.");
@@ -40,20 +52,22 @@ export async function addOfflineHostAndReload(
       if (primaryLabel && registry[0]) {
         registry[0].label = primaryLabel;
       }
-      if (!registry.some((entry) => entry.serverId === host.serverId)) {
-        registry.push(host);
+      for (const host of added) {
+        if (!registry.some((entry) => entry.serverId === host.serverId)) {
+          registry.push(host);
+        }
       }
       localStorage.setItem(keys.registry, JSON.stringify(registry));
       localStorage.setItem(keys.disableSeedOnce, nonce);
     },
     {
-      host: offlineHost,
+      hosts: offlineHosts,
       keys: {
         registry: REGISTRY_KEY,
         nonce: SEED_NONCE_KEY,
         disableSeedOnce: DISABLE_DEFAULT_SEED_ONCE_KEY,
       },
-      primaryLabel: input.primaryLabel,
+      primaryLabel: options.primaryLabel,
     },
   );
 

packages/app/e2e/support/helpers/seed-client.ts

@@ -157,7 +157,10 @@ export interface SeedDaemonClient {
   sendAgentMessage(
     agentId: string,
     text: string,
-    options?: { sourceAgentId?: string },
+    options?: {
+      sourceAgentId?: string;
+      attachments?: import("@getpaseo/protocol/messages").AgentAttachment[];
+    },
   ): Promise<void>;
   waitForFinish(
     agentId: string,

packages/app/e2e/support/helpers/sidebar-footer-overflow.ts

@@ -0,0 +1,127 @@
+import { expect, type Locator, type Page } from "@playwright/test";
+
+/** Every footer control that can sit in the icon line, caret included. */
+const FOOTER_LINE_TEST_IDS = [
+  "sidebar-add-project",
+  "sidebar-usage-icon",
+  "sidebar-hosts-trigger",
+  "sidebar-help",
+  "sidebar-footer-overflow",
+  "sidebar-settings",
+];
+
+// Browser layout boxes include floating-point rounding, even for whole-pixel styles.
+const GEOMETRY_TOLERANCE = 0.01;
+
+/** Open the app with the docked sidebar at `width`, as if the user had dragged it there. */
+export async function seedDockedSidebarWidth(page: Page, width: number): Promise<void> {
+  await page.addInitScript((sidebarWidth) => {
+    localStorage.setItem("panel-state", JSON.stringify({ version: 17, state: { sidebarWidth } }));
+  }, width);
+}
+
+/**
+ * From the first frame, record any frame in which a footer button reaches past its row, so a row
+ * laid out before it measured shows up even if it lasted one frame.
+ */
+export async function watchFooterClipping(page: Page): Promise<void> {
+  await page.addInitScript((testIDs) => {
+    const clippedFrames: string[] = [];
+    Object.assign(window, { __footerClippedFrames: clippedFrames });
+    const sample = () => {
+      for (const row of document.querySelectorAll('[data-testid="sidebar-footer-bottom-line"]')) {
+        const rowRect = row.getBoundingClientRect();
+        if (rowRect.width === 0) continue;
+        for (const testID of testIDs) {
+          const button = row.querySelector(`[data-testid="${testID}"]`);
+          if (button && button.getBoundingClientRect().right > rowRect.right + 0.5) {
+            clippedFrames.push(testID);
+          }
+        }
+      }
+      requestAnimationFrame(sample);
+    };
+    requestAnimationFrame(sample);
+  }, FOOTER_LINE_TEST_IDS);
+}
+
+export async function expectFooterNeverClipped(page: Page): Promise<void> {
+  const clipped = await page.evaluate(
+    () => (window as unknown as { __footerClippedFrames: string[] }).__footerClippedFrames,
+  );
+  expect(clipped).toEqual([]);
+}
+
+function footerLine(page: Page): Locator {
+  return page.locator('[data-testid="sidebar-footer-bottom-line"]:visible');
+}
+
+export function footerOverflowMenu(page: Page): Locator {
+  return page.getByTestId("sidebar-footer-overflow-menu");
+}
+
+/**
+ * The icon line shows exactly `testIDs`, in order, each `controlSize` square and wholly inside the
+ * line's box, so no button is cut off by the sidebar's edge.
+ */
+export async function expectFooterLine(
+  page: Page,
+  input: { testIDs: string[]; controlSize: number },
+): Promise<void> {
+  const line = footerLine(page);
+  await expect(line).toHaveCount(1);
+  await expect
+    .poll(async () =>
+      line
+        .locator(FOOTER_LINE_TEST_IDS.map((testID) => `[data-testid="${testID}"]`).join(","))
+        .evaluateAll((elements) => elements.map((element) => element.getAttribute("data-testid"))),
+    )
+    .toEqual(input.testIDs);
+  const { row, buttons } = await line.evaluate((element, testIDs) => {
+    const rect = (node: Element) => {
+      const { x, width, height } = node.getBoundingClientRect();
+      return { x, width, height };
+    };
+    return {
+      row: rect(element),
+      buttons: testIDs.map((testID) => rect(element.querySelector(`[data-testid="${testID}"]`)!)),
+    };
+  }, input.testIDs);
+  for (const button of buttons) {
+    expect(Math.abs(button.width - input.controlSize)).toBeLessThan(GEOMETRY_TOLERANCE);
+    expect(Math.abs(button.height - input.controlSize)).toBeLessThan(GEOMETRY_TOLERANCE);
+    expect(button.x).toBeGreaterThanOrEqual(row.x - GEOMETRY_TOLERANCE);
+    expect(button.x + button.width).toBeLessThanOrEqual(row.x + row.width + GEOMETRY_TOLERANCE);
+  }
+}
+
+export async function openFooterOverflow(page: Page): Promise<void> {
+  await footerLine(page).getByTestId("sidebar-footer-overflow").click();
+  await expect(footerOverflowMenu(page)).toBeVisible();
+}
+
+/** The overflow menu lists exactly these actions, in row order. */
+export async function expectFooterOverflowActions(page: Page, names: string[]): Promise<void> {
+  await expect(footerOverflowMenu(page).getByRole("menuitem")).toHaveText(names);
+}
+
+export async function chooseFooterOverflowAction(page: Page, name: string): Promise<void> {
+  await footerOverflowMenu(page).getByRole("menuitem", { name }).click();
+}
+
+/** Every row of the open overflow menu, and of the page it opened, is inside the viewport's width. */
+export async function expectFooterMenusInsideViewport(page: Page): Promise<void> {
+  const viewport = page.viewportSize()!;
+  const rows = page.getByRole("menuitem");
+  await expect(rows.first()).toBeVisible();
+  const boxes = await rows.evaluateAll((elements) =>
+    elements.map((element) => {
+      const { x, width } = element.getBoundingClientRect();
+      return { x, width };
+    }),
+  );
+  for (const box of boxes) {
+    expect(box.x).toBeGreaterThanOrEqual(0);
+    expect(box.x + box.width).toBeLessThanOrEqual(viewport.width);
+  }
+}

packages/app/src/attachments/attachment-pill-content.tsx

@@ -49,7 +49,7 @@ function getTextAttachmentSubtitle(
   t: TFunction,
 ): string {
   if (attachment.contextKind === "chat_history") {
-    return "Previous conversation";
+    return attachment.chatHistorySource?.title ?? t("message.chatHistory.previousConversation");
   }
   return t("message.attachments.text");
 }
@@ -87,6 +87,13 @@ export function getAgentAttachmentPillContent(
         subtitle: `Issue #${attachment.number}`,
       };
     case "text":
+      if (attachment.contextKind === "chat_history") {
+        return {
+          icon: attachmentFileIcon,
+          title: t("message.chatHistory.title"),
+          subtitle: getTextAttachmentSubtitle(attachment, t),
+        };
+      }
       if (attachment.externalResource) {
         return {
           icon: attachmentGithubIssueIcon,

packages/app/src/attachments/chat-history/index.tsx

@@ -0,0 +1,125 @@
+import { generateMessageId } from "@/types/stream";
+import { useWorkspaceAttachmentsStore } from "@/attachments/workspace-attachments-store";
+import type { ChatHistoryAttachment as HistoryAttachment } from "@getpaseo/protocol/messages";
+import { extractChatHistoryBody } from "@getpaseo/protocol/chat-history";
+import { useCallback, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Text } from "react-native";
+import { StyleSheet } from "react-native-unistyles";
+import { ArrowUpRight } from "lucide-react-native";
+import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import { getAgentAttachmentPillContent } from "@/attachments/attachment-pill-content";
+import { AttachmentFrame, AttachmentLabel, AttachmentPill } from "@/components/attachment-pill";
+import { AdaptiveModalSheet, FULL_SHEET_SNAP_POINTS } from "@/components/adaptive-modal-sheet";
+import { Button } from "@/components/ui/button";
+import { navigateToAgent } from "@/utils/navigate-to-agent";
+
+interface ChatHistoryAttachmentProps {
+  attachment: Extract<AgentAttachment, { type: "text" }>;
+  onRemove?: () => void;
+  disabled?: boolean;
+  testID?: string;
+}
+
+export function ChatHistoryAttachment({
+  attachment,
+  onRemove,
+  disabled = false,
+  testID,
+}: ChatHistoryAttachmentProps) {
+  const { t } = useTranslation();
+  const [visible, setVisible] = useState(false);
+  const open = useCallback(() => setVisible(true), []);
+  const close = useCallback(() => setVisible(false), []);
+  const source = attachment.chatHistorySource;
+  const openSource = useCallback(() => {
+    if (!source) return;
+    close();
+    navigateToAgent({ serverId: source.serverId, agentId: source.agentId });
+  }, [close, source]);
+  const header = useMemo(
+    () => ({
+      title: t("message.chatHistory.title"),
+      subtitle: source?.title ? (
+        <Text style={styles.description} numberOfLines={1}>
+          {source.title}
+        </Text>
+      ) : undefined,
+    }),
+    [source?.title, t],
+  );
+  const footer = useMemo(
+    () =>
+      source ? (
+        <Button variant="outline" size="sm" leftIcon={ArrowUpRight} onPress={openSource}>
+          {t("message.chatHistory.openSource")}
+        </Button>
+      ) : undefined,
+    [source, openSource, t],
+  );
+  const history = useMemo(() => extractChatHistoryBody(attachment.text), [attachment.text]);
+  const content = getAgentAttachmentPillContent(attachment, t);
+  const label = (
+    <AttachmentLabel icon={content.icon} title={content.title} subtitle={content.subtitle} />
+  );
+  const openLabel = t("message.chatHistory.open");
+
+  return (
+    <>
+      {onRemove ? (
+        <AttachmentPill
+          testID={testID}
+          onOpen={open}
+          onRemove={onRemove}
+          disabled={disabled}
+          openAccessibilityLabel={openLabel}
+          removeAccessibilityLabel={t("message.chatHistory.remove")}
+        >
+          {label}
+        </AttachmentPill>
+      ) : (
+        <AttachmentFrame testID={testID} onPress={open} accessibilityLabel={openLabel}>
+          {label}
+        </AttachmentFrame>
+      )}
+      <AdaptiveModalSheet
+        visible={visible}
+        onClose={close}
+        header={header}
+        snapPoints={FULL_SHEET_SNAP_POINTS}
+        desktopMaxWidth={720}
+        desktopHeight="75%"
+        testID="chat-history-preview"
+        contentStyle={styles.content}
+        footer={footer}
+      >
+        <Text style={styles.description}>{t("message.chatHistory.description")}</Text>
+        <Text selectable testID="chat-history-content" style={styles.history}>
+          {history}
+        </Text>
+      </AdaptiveModalSheet>
+    </>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  content: { gap: theme.spacing[4] },
+  description: { fontSize: theme.fontSize.sm, color: theme.colors.foregroundMuted },
+  history: {
+    fontSize: theme.fontSize.content,
+    lineHeight: theme.fontSize.content * 1.6,
+    color: theme.colors.foreground,
+  },
+}));
+
+export function restoreChatHistoryAttachment(scopeKey: string, attachment: HistoryAttachment) {
+  useWorkspaceAttachmentsStore.getState().addWorkspaceAttachment({
+    scopeKey,
+    attachment: {
+      kind: "chat_history",
+      id: generateMessageId(),
+      attachment,
+      source: attachment.chatHistorySource,
+    },
+  });
+}

packages/app/src/attachments/types.ts

@@ -1,5 +1,6 @@
 import type {
   AgentAttachment,
+  ChatHistorySource,
   ForgeSearchItem,
   UploadedFileAttachment,
 } from "@getpaseo/protocol/messages";
@@ -82,9 +83,7 @@ export interface ChatHistoryContextAttachment {
   kind: "chat_history";
   id: string;
   attachment: Extract<AgentAttachment, { type: "text" }>;
-  source: {
-    serverId: string;
-    agentId: string;
+  source?: ChatHistorySource & {
     boundaryMessageId?: string | null;
     boundaryCursor?: { epoch: string; seq: number } | null;
     itemCount?: number;

packages/app/src/attachments/workspace-attachment-utils.test.ts

@@ -21,6 +21,29 @@ function contextAttachment(
 }
 
 describe("workspace attachment utilities", () => {
+  it("submits chat history with its source host and agent", () => {
+    const source = { serverId: "original-host", agentId: "original-agent", title: "Original" };
+    expect(
+      workspaceAttachmentToSubmitAttachment({
+        kind: "chat_history",
+        id: "history-draft",
+        attachment: {
+          type: "text",
+          mimeType: "text/plain",
+          contextKind: "chat_history",
+          text: "Earlier context",
+        },
+        source,
+      }),
+    ).toEqual({
+      type: "text",
+      mimeType: "text/plain",
+      contextKind: "chat_history",
+      text: "Earlier context",
+      chatHistorySource: source,
+    });
+  });
+
   it("treats pull request context as a workspace attachment", () => {
     expect(isWorkspaceAttachment(contextAttachment())).toBe(true);
   });

packages/app/src/attachments/workspace-attachment-utils.ts

@@ -62,7 +62,12 @@ export function workspaceAttachmentToSubmitAttachment(
     };
   }
   if (attachment.kind === "chat_history") {
-    return attachment.attachment;
+    if (!attachment.source) return attachment.attachment;
+    const { serverId, agentId, title } = attachment.source;
+    return {
+      ...attachment.attachment,
+      chatHistorySource: { serverId, agentId, ...(title ? { title } : {}) },
+    };
   }
   return attachment.kind === "review" ? attachment.attachment : null;
 }

packages/app/src/attachments/workspace-attachments-store.ts

@@ -178,6 +178,19 @@ export function useWorkspaceAttachmentScopeKey(input: WorkspaceAttachmentScope):
   }, [cwd, draftId, isDraftScope, serverId, workspaceId]);
 }
 
+export function useAgentAttachmentScopeKey(input: { serverId: string; agentId: string }): string {
+  const { serverId, agentId } = input;
+  return useMemo(
+    () =>
+      [
+        "agent-attachments",
+        `server=${encodeScopePart(serverId)}`,
+        `agent=${encodeScopePart(agentId)}`,
+      ].join(":"),
+    [serverId, agentId],
+  );
+}
+
 export function useDraftWorkspaceAttachmentScopeKey(draftId: string | null | undefined): string {
   const normalizedDraftId = useMemo(() => draftId?.trim() ?? "", [draftId]);
   return useMemo(

packages/app/src/components/left-sidebar.tsx

@@ -17,6 +17,7 @@ import {
   Text,
   useWindowDimensions,
   View,
+  type LayoutChangeEvent,
 } from "react-native";
 import { Gesture, ScrollView as GHScrollView } from "react-native-gesture-handler";
 import Animated, { runOnJS, useAnimatedStyle, useSharedValue } from "react-native-reanimated";
@@ -40,6 +41,17 @@ import { SidebarSeparator } from "@/components/sidebar/sidebar-separator";
 import { SidebarNavRows } from "@/components/sidebar/sidebar-nav-rows";
 import { SidebarFooterIconHighlight } from "@/components/sidebar/sidebar-footer-icon-highlight";
 import { SidebarHelpMenu } from "@/components/sidebar/sidebar-help-menu";
+import { SidebarFooterOverflowMenu } from "@/components/sidebar/sidebar-footer-overflow-menu";
+import {
+  resolveSidebarFooterLayout,
+  SIDEBAR_FOOTER_ACTIONS,
+  type SidebarFooterAction,
+} from "@/components/sidebar-footer-layout";
+import {
+  controlSizingForLayout,
+  mapLayout,
+  TOOLBAR_CONTROL_SIZES,
+} from "@/components/ui/control-geometry";
 import { SidebarResizeHandle } from "@/components/sidebar-resize-handle";
 import { DensityIcon } from "@/components/ui/density-icon";
 import { SidebarSectionHeader } from "@/components/sidebar/sidebar-section-header";
@@ -55,6 +67,7 @@ import {
   type SidebarWorkspaceEntry,
 } from "@/hooks/use-sidebar-workspaces-list";
 import { density } from "@/styles/density";
+import { SPACING } from "@/styles/theme";
 import { useSidebarModel } from "@/components/sidebar/sidebar-model";
 import type { PinnedSidebarGroups } from "@/hooks/use-sidebar-pins";
 import { RetainedPanelActivity } from "@/components/retained-panel";
@@ -79,6 +92,9 @@ import { SidebarWorkspaceList } from "./sidebar-workspace-list";
 
 type SidebarTheme = ReturnType<typeof useUnistyles>["theme"];
 
+/** The footer icon line's inset; the overflow layout counts it as space the buttons can't use. */
+const FOOTER_ROW_PADDING = SPACING[2];
+
 const DEV_BUILD_LABEL = process.env.EXPO_PUBLIC_PASEO_DEV_BUILD_LABEL?.trim() || null;
 
 interface SidebarSharedProps {
@@ -410,35 +426,72 @@ function SidebarFooter({
 }) {
   const newAgentKeys = useShortcutKeys("new-agent");
   const settingsKeys = useShortcutKeys("toggle-settings");
+  const isCompactLayout = useIsCompactFormFactor();
+  const [rowWidth, setRowWidth] = useState(0);
+  const handleRowLayout = useCallback((event: LayoutChangeEvent) => {
+    setRowWidth(event.nativeEvent.layout.width);
+  }, []);
+  const { inline, overflow } = useMemo(
+    () =>
+      resolveSidebarFooterLayout({
+        rowWidth,
+        controlSize: TOOLBAR_CONTROL_SIZES[controlSizingForLayout(isCompactLayout)],
+        rowPadding: FOOTER_ROW_PADDING,
+        actions: SIDEBAR_FOOTER_ACTIONS,
+      }),
+    [rowWidth, isCompactLayout],
+  );
+  const isInline = (action: SidebarFooterAction) => inline.includes(action);
 
-  // One line of icons: Add project, Usage, Hosts, then Help and Settings at the end.
+  // One line of icons: Add project, Usage, Hosts, then Help and Settings at the end. Actions that
+  // don't fit move behind a caret before Settings.
   return (
     <UsageSidebarRoot>
       <View style={styles.footerContainer} testID="sidebar-footer">
         <SidebarFooterRows onBeforeNavigate={onBeforeNavigate} />
-        <View style={styles.sidebarFooter} testID="sidebar-footer-bottom-line">
-          <FooterIconButton
-            onPress={handleOpenProject}
-            testID="sidebar-add-project"
-            label={labels.addProject}
-            icon={FolderPlus}
-            shortcutKeys={newAgentKeys}
-          />
-          <SidebarUsageIcon label={labels.usage} />
-          <SidebarHostPicker
-            label={labels.hosts}
-            onAddHost={handleAddHost}
-            onOpenHostSettings={handleOpenHostSettings}
-          />
+        <View
+          style={styles.sidebarFooter}
+          onLayout={handleRowLayout}
+          testID="sidebar-footer-bottom-line"
+        >
+          {isInline("add-project") ? (
+            <FooterIconButton
+              onPress={handleOpenProject}
+              testID="sidebar-add-project"
+              label={labels.addProject}
+              icon={FolderPlus}
+              shortcutKeys={newAgentKeys}
+            />
+          ) : null}
+          {isInline("usage") ? <SidebarUsageIcon label={labels.usage} /> : null}
+          {isInline("hosts") ? (
+            <SidebarHostPicker
+              label={labels.hosts}
+              onAddHost={handleAddHost}
+              onOpenHostSettings={handleOpenHostSettings}
+            />
+          ) : null}
           <View style={styles.footerSpacer} />
-          <SidebarHelpMenu />
-          <FooterIconButton
-            onPress={handleSettings}
-            testID="sidebar-settings"
-            label={labels.settings}
-            icon={Settings}
-            shortcutKeys={settingsKeys}
-          />
+          {isInline("help") ? <SidebarHelpMenu /> : null}
+          {overflow.length > 0 ? (
+            <SidebarFooterOverflowMenu
+              actions={overflow}
+              labels={labels}
+              onAddProject={handleOpenProject}
+              onSettings={handleSettings}
+              onAddHost={handleAddHost}
+              onOpenHostSettings={handleOpenHostSettings}
+            />
+          ) : null}
+          {isInline("settings") ? (
+            <FooterIconButton
+              onPress={handleSettings}
+              testID="sidebar-settings"
+              label={labels.settings}
+              icon={Settings}
+              shortcutKeys={settingsKeys}
+            />
+          ) : null}
         </View>
       </View>
     </UsageSidebarRoot>
@@ -937,10 +990,12 @@ const styles = StyleSheet.create((theme) => ({
     borderTopColor: theme.colors.border,
   },
   // Buttons sit edge to edge; their own inset spaces the glyphs.
+  // As tall as its buttons from the first frame, which places none until the row has measured.
   sidebarFooter: {
     flexDirection: "row",
     alignItems: "center",
-    paddingHorizontal: theme.spacing[2],
+    minHeight: mapLayout(density.iconButton, (height) => height + theme.spacing[1.5] * 2),
+    paddingHorizontal: FOOTER_ROW_PADDING,
     paddingVertical: theme.spacing[1.5],
   },
   // Pushes Help and Settings to the end of the icon line.

packages/app/src/components/message.tsx

@@ -1,3 +1,4 @@
+import { ChatHistoryAttachment } from "@/attachments/chat-history";
 import { useDisclosureHold } from "@/agent-stream/disclosure";
 import { MessagePreview, MessageSender } from "@/components/user-message";
 import { useStableEvent } from "@/hooks/use-stable-event";
@@ -33,7 +34,10 @@ import { useTargetAgentTitle } from "@/tool-calls/use-target-agent-title";
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import type { AgentMessage } from "@getpaseo/protocol/agent-message";
 import type { AgentCapabilityFlags, ToolCallDetail } from "@getpaseo/protocol/agent-types";
-import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import type {
+  AgentAttachment,
+  ChatHistoryAttachment as ChatHistorySnapshot,
+} from "@getpaseo/protocol/messages";
 import MaskedView from "@react-native-masked-view/masked-view";
 import {
   Check,
@@ -419,7 +423,12 @@ export const UserMessage = memo(function UserMessage({
   const hasText = message.trim().length > 0;
   const hasImages = images.length > 0;
   const hasAttachments = attachments.length > 0;
-  const showTrailingRow = !isPending && hasText && (isCompact || isNative || isHovered);
+  const chatHistory = attachments.find(
+    (attachment): attachment is ChatHistorySnapshot =>
+      attachment.type === "text" && attachment.contextKind === "chat_history",
+  );
+  const showTrailingRow =
+    !isPending && (hasText || Boolean(chatHistory)) && (isCompact || isNative || isHovered);
   const formattedTimestamp = useMemo(
     () => formatMessageTimestamp(new Date(timestamp)),
     [timestamp],
@@ -428,9 +437,12 @@ export const UserMessage = memo(function UserMessage({
 
   const handlePointerEnter = useCallback(() => setIsHovered(true), []);
   const handlePointerLeave = useCallback(() => setIsHovered(false), []);
-  const getMessageContent = useCallback(() => message, [message]);
+  const getMessageContent = useCallback(
+    () => message || chatHistory?.text || "",
+    [message, chatHistory],
+  );
   const handleRewind = useCallback(
-    (input: { mode: RewindMode; rewoundText: string }) => {
+    (input: { mode: RewindMode; rewoundText: string; chatHistory?: ChatHistorySnapshot }) => {
       return rewindMutation.rewindAgent(input);
     },
     [rewindMutation],
@@ -496,11 +508,19 @@ export const UserMessage = memo(function UserMessage({
             {hasAttachments ? (
               <View style={attachmentPreviewContainerStyle}>
                 {attachments.map((attachment, index) => {
+                  const key = `${attachment.type}:${"number" in attachment ? attachment.number : index}`;
+                  if (attachment.type === "text" && attachment.contextKind === "chat_history") {
+                    return (
+                      <ChatHistoryAttachment
+                        key={key}
+                        attachment={attachment}
+                        testID="message-chat-history-attachment"
+                      />
+                    );
+                  }
                   const content = getAgentAttachmentPillContent(attachment, t);
                   return (
-                    <AttachmentFrame
-                      key={`${attachment.type}:${"number" in attachment ? attachment.number : index}`}
-                    >
+                    <AttachmentFrame key={key}>
                       <AttachmentLabel
                         icon={content.icon}
                         title={content.title}
@@ -518,7 +538,7 @@ export const UserMessage = memo(function UserMessage({
             ) : null}
           </MessagePreview>
         </View>
-        {hasText ? (
+        {hasText || chatHistory ? (
           <View
             style={trailingRowStyle}
             pointerEvents={showTrailingRow ? "auto" : "none"}
@@ -532,6 +552,7 @@ export const UserMessage = memo(function UserMessage({
                 capabilities={capabilities}
                 isPending={rewindMutation.isPending}
                 rewoundText={message}
+                chatHistory={chatHistory}
                 onRewind={handleRewind}
               />
             ) : null}

packages/app/src/components/rewind/composer-restore.test.ts

@@ -1,27 +1,45 @@
 import { describe, expect, test } from "vitest";
-import { restoreComposerTextIfEmpty } from "./composer-restore";
+import { restoreComposerPromptIfEmpty } from "./composer-restore";
 import { shouldRestoreComposerForRewindMode } from "./rewind-mode";
 
-describe("restoreComposerTextIfEmpty", () => {
+describe("restoreComposerPromptIfEmpty", () => {
   test("restores the rewound message when the composer is empty", () => {
     expect(
-      restoreComposerTextIfEmpty({
+      restoreComposerPromptIfEmpty({
         currentText: "",
-        rewoundText: "message before rewind",
+        rewoundPrompt: { text: "message before rewind" },
       }),
-    ).toBe("message before rewind");
+    ).toEqual({ text: "message before rewind" });
   });
 
   test("preserves an existing composer draft", () => {
     expect(
-      restoreComposerTextIfEmpty({
+      restoreComposerPromptIfEmpty({
         currentText: "keep this draft",
-        rewoundText: "message before rewind",
+        rewoundPrompt: { text: "message before rewind" },
       }),
-    ).toBe("keep this draft");
+    ).toEqual({ text: "keep this draft" });
   });
 });
 
+test.each(["", "Continue here"])("restores inherited history with rewound prompt %s", (text) => {
+  const chatHistory = {
+    type: "text",
+    mimeType: "text/plain",
+    contextKind: "chat_history",
+    text: "Earlier context",
+  } as const;
+  expect(
+    restoreComposerPromptIfEmpty({ currentText: "", rewoundPrompt: { text, chatHistory } }),
+  ).toEqual({ text, chatHistory });
+  expect(
+    restoreComposerPromptIfEmpty({
+      currentText: "Existing draft",
+      rewoundPrompt: { text, chatHistory },
+    }),
+  ).toEqual({ text: "Existing draft" });
+});
+
 describe("shouldRestoreComposerForRewindMode", () => {
   test("restores only conversation-mutating rewind modes", () => {
     expect(shouldRestoreComposerForRewindMode("conversation")).toBe(true);

packages/app/src/components/rewind/composer-restore.tsx

@@ -1,11 +1,14 @@
+import type { ChatHistoryAttachment } from "@getpaseo/protocol/messages";
+import { restoreChatHistoryAttachment } from "@/attachments/chat-history";
 import type { ComposerTextSource } from "@/composer/text-source";
 import { createContext, useCallback, useContext, useMemo, type ReactNode } from "react";
 
 interface RewindComposerRestoreContextValue {
-  completeRewind: (text: string) => void;
+  completeRewind: (prompt: { text: string; chatHistory?: ChatHistoryAttachment }) => void;
 }
 
 interface RewindComposerRestoreProviderProps {
+  attachmentScopeKey: string;
   textSource: ComposerTextSource;
   setText: (text: string) => void;
   onRewindComplete: () => void;
@@ -14,35 +17,34 @@ interface RewindComposerRestoreProviderProps {
 
 const RewindComposerRestoreContext = createContext<RewindComposerRestoreContextValue | null>(null);
 
-export function restoreComposerTextIfEmpty(input: {
+export function restoreComposerPromptIfEmpty(input: {
   currentText: string;
-  rewoundText: string;
-}): string {
-  if (input.currentText.length > 0) {
-    return input.currentText;
-  }
-  return input.rewoundText;
+  rewoundPrompt: { text: string; chatHistory?: ChatHistoryAttachment };
+}): { text: string; chatHistory?: ChatHistoryAttachment } {
+  if (input.currentText.length > 0) return { text: input.currentText };
+  return input.rewoundPrompt;
 }
 
 export function RewindComposerRestoreProvider({
+  attachmentScopeKey,
   textSource,
   setText,
   onRewindComplete,
   children,
 }: RewindComposerRestoreProviderProps) {
   const completeRewind = useCallback(
-    (rewoundText: string) => {
+    (prompt: { text: string; chatHistory?: ChatHistoryAttachment }) => {
       const currentText = textSource.getSnapshot();
-      const nextText = restoreComposerTextIfEmpty({
-        currentText: currentText,
-        rewoundText,
-      });
-      if (nextText !== currentText) {
-        setText(nextText);
+      const restored = restoreComposerPromptIfEmpty({ currentText, rewoundPrompt: prompt });
+      if (restored.chatHistory) {
+        restoreChatHistoryAttachment(attachmentScopeKey, restored.chatHistory);
+      }
+      if (restored.text !== currentText) {
+        setText(restored.text);
       }
       onRewindComplete();
     },
-    [onRewindComplete, setText, textSource],
+    [attachmentScopeKey, onRewindComplete, setText, textSource],
   );
 
   const value = useMemo(() => ({ completeRewind }), [completeRewind]);

packages/app/src/components/rewind/rewind-menu.tsx

@@ -1,3 +1,4 @@
+import type { ChatHistoryAttachment } from "@getpaseo/protocol/messages";
 import { memo, useCallback, useMemo, useState, type ReactElement } from "react";
 import { useTranslation } from "react-i18next";
 import { Text, View } from "react-native";
@@ -19,7 +20,12 @@ export type { RewindMode };
 interface RewindMenuProps {
   capabilities: AgentCapabilityFlags;
   rewoundText: string;
-  onRewind: (input: { mode: RewindMode; rewoundText: string }) => Promise<void> | void;
+  chatHistory?: ChatHistoryAttachment;
+  onRewind: (input: {
+    mode: RewindMode;
+    rewoundText: string;
+    chatHistory?: ChatHistoryAttachment;
+  }) => Promise<void> | void;
   isPending?: boolean;
   testID?: string;
 }
@@ -38,6 +44,7 @@ function getIcon(mode: RewindMode, color: string): ReactElement {
 export const RewindMenu = memo(function RewindMenu({
   capabilities,
   rewoundText,
+  chatHistory,
   onRewind,
   isPending: isPendingProp = false,
   testID = "rewind-menu",
@@ -70,7 +77,7 @@ export const RewindMenu = memo(function RewindMenu({
       if (isLocked) return;
       setPendingMode(mode);
       try {
-        await onRewind({ mode, rewoundText });
+        await onRewind({ mode, rewoundText, chatHistory });
       } catch {
         // useRewindAgentMutation owns the toast; the menu only owns flow state.
       } finally {
@@ -78,7 +85,7 @@ export const RewindMenu = memo(function RewindMenu({
         setIsOpen(false);
       }
     },
-    [isLocked, onRewind, rewoundText],
+    [isLocked, onRewind, rewoundText, chatHistory],
   );
 
   const triggerStyle = useCallback(

packages/app/src/components/rewind/use-rewind-agent-mutation.ts

@@ -1,3 +1,4 @@
+import type { ChatHistoryAttachment } from "@getpaseo/protocol/messages";
 import { planTimelineTailFetch } from "@/timeline/timeline-sync-plan";
 import { useCallback } from "react";
 import { useTranslation } from "react-i18next";
@@ -20,6 +21,7 @@ interface UseRewindAgentMutationInput {
 interface RewindAgentInput {
   mode: RewindMode;
   rewoundText: string;
+  chatHistory?: ChatHistoryAttachment;
 }
 
 export function useRewindAgentMutation(input: UseRewindAgentMutationInput): {
@@ -52,7 +54,10 @@ export function useRewindAgentMutation(input: UseRewindAgentMutationInput): {
       if (!shouldRestoreComposerForRewindMode(variables.mode)) {
         return;
       }
-      composerRestore?.completeRewind(variables.rewoundText);
+      composerRestore?.completeRewind({
+        text: variables.rewoundText,
+        chatHistory: variables.chatHistory,
+      });
     },
     onError: (error) => {
       toast.error(error instanceof Error ? error.message : t("rewind.errors.failed"));

packages/app/src/components/sidebar-footer-layout.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import {
+  resolveSidebarFooterLayout,
+  SIDEBAR_FOOTER_ACTIONS,
+} from "@/components/sidebar-footer-layout";
+import { DEFAULT_SIDEBAR_WIDTH, MIN_SIDEBAR_WIDTH } from "@/stores/panel-store";
+
+const TOUCH = 44;
+const POINTER = 28;
+const ROW_PADDING = 8;
+
+function layout(rowWidth: number, controlSize: number) {
+  return resolveSidebarFooterLayout({
+    rowWidth,
+    controlSize,
+    rowPadding: ROW_PADDING,
+    actions: SIDEBAR_FOOTER_ACTIONS,
+  });
+}
+
+describe("sidebar footer layout", () => {
+  it("keeps every action inline at the default width with either sizing", () => {
+    for (const controlSize of [TOUCH, POINTER]) {
+      expect(layout(DEFAULT_SIDEBAR_WIDTH, controlSize)).toEqual({
+        inline: ["add-project", "usage", "hosts", "help", "settings"],
+        overflow: [],
+      });
+    }
+  });
+
+  it("keeps every action inline at the minimum width with pointer sizing", () => {
+    expect(layout(MIN_SIDEBAR_WIDTH, POINTER).overflow).toEqual([]);
+  });
+
+  // The iPhone Duo report: the folded sidebar column is about the minimum width, and touch
+  // sizing makes five 44pt buttons plus padding 236pt wide.
+  it("moves Help and Usage behind the caret at the minimum width with touch sizing", () => {
+    expect(layout(MIN_SIDEBAR_WIDTH, TOUCH)).toEqual({
+      inline: ["add-project", "hosts", "settings"],
+      overflow: ["usage", "help"],
+    });
+  });
+
+  it("keeps Settings and Add project inline longest", () => {
+    // Three slots: two actions and the caret.
+    expect(layout(3 * TOUCH + 2 * ROW_PADDING, TOUCH)).toEqual({
+      inline: ["add-project", "settings"],
+      overflow: ["usage", "hosts", "help"],
+    });
+    // Two slots: Settings and the caret.
+    expect(layout(2 * TOUCH + 2 * ROW_PADDING, TOUCH)).toEqual({
+      inline: ["settings"],
+      overflow: ["add-project", "usage", "hosts", "help"],
+    });
+  });
+
+  it("puts everything behind the caret when only the caret fits", () => {
+    expect(layout(TOUCH + 2 * ROW_PADDING - 10, TOUCH)).toEqual({
+      inline: [],
+      overflow: ["add-project", "usage", "hosts", "help", "settings"],
+    });
+  });
+
+  it("fits all five actions exactly at their combined width", () => {
+    const exact = 5 * TOUCH + 2 * ROW_PADDING;
+    expect(layout(exact, TOUCH).overflow).toEqual([]);
+    // Browser layout rounds a little below the exact width.
+    expect(layout(exact - 0.4, TOUCH).overflow).toEqual([]);
+    expect(layout(exact - 1, TOUCH).overflow).toEqual(["usage", "help"]);
+  });
+
+  it("only places the actions it is given", () => {
+    expect(
+      resolveSidebarFooterLayout({
+        rowWidth: 3 * TOUCH + 2 * ROW_PADDING,
+        controlSize: TOUCH,
+        rowPadding: ROW_PADDING,
+        actions: ["add-project", "hosts", "settings"],
+      }),
+    ).toEqual({ inline: ["add-project", "hosts", "settings"], overflow: [] });
+  });
+
+  // Laying out against a guessed width would paint a clipped row for a frame on narrow sidebars.
+  it("places nothing before the row has been measured", () => {
+    for (const controlSize of [TOUCH, POINTER]) {
+      expect(layout(0, controlSize)).toEqual({ inline: [], overflow: [] });
+    }
+  });
+});

packages/app/src/components/sidebar-footer-layout.ts

@@ -0,0 +1,62 @@
+/** The sidebar footer's icon line, in row order. */
+export const SIDEBAR_FOOTER_ACTIONS = [
+  "add-project",
+  "usage",
+  "hosts",
+  "help",
+  "settings",
+] as const;
+
+export type SidebarFooterAction = (typeof SIDEBAR_FOOTER_ACTIONS)[number];
+
+/** The order actions keep their place in a row too narrow for all of them. */
+const KEEP_ORDER: readonly SidebarFooterAction[] = [
+  "settings",
+  "add-project",
+  "hosts",
+  "usage",
+  "help",
+];
+
+/** Measured widths land a hair under the exact sum of their parts. */
+const MEASUREMENT_TOLERANCE = 0.5;
+
+export interface SidebarFooterLayout {
+  /** Actions drawn in the row, in row order. */
+  inline: SidebarFooterAction[];
+  /** Actions behind the overflow caret, in row order. Empty when everything fits. */
+  overflow: SidebarFooterAction[];
+}
+
+/**
+ * Splits the footer's actions between the row and the overflow menu. Buttons keep their full size;
+ * when they don't all fit, the caret takes one slot and the actions that lose their place move
+ * behind it, Help first and Settings last. Nothing is placed until the row has a measured width.
+ */
+export function resolveSidebarFooterLayout(input: {
+  rowWidth: number;
+  controlSize: number;
+  rowPadding: number;
+  actions: readonly SidebarFooterAction[];
+}): SidebarFooterLayout {
+  const { rowWidth, controlSize, rowPadding, actions } = input;
+  // An unmeasured row stays empty: any guess would paint a clipped row for a frame on a narrow
+  // sidebar before the real width arrives.
+  if (rowWidth <= 0) {
+    return { inline: [], overflow: [] };
+  }
+  const slots = Math.floor(
+    (rowWidth - rowPadding * 2 + MEASUREMENT_TOLERANCE) / Math.max(controlSize, 1),
+  );
+  if (slots >= actions.length) {
+    return { inline: [...actions], overflow: [] };
+  }
+  const inlineCount = Math.max(slots - 1, 0);
+  const kept = new Set(
+    KEEP_ORDER.filter((action) => actions.includes(action)).slice(0, inlineCount),
+  );
+  return {
+    inline: actions.filter((action) => kept.has(action)),
+    overflow: actions.filter((action) => !kept.has(action)),
+  };
+}

packages/app/src/components/sidebar/sidebar-footer-menu-trigger.tsx

@@ -0,0 +1,69 @@
+import type { ReactElement } from "react";
+import { Text, View } from "react-native";
+import type { LucideIcon } from "lucide-react-native";
+import { StyleSheet } from "react-native-unistyles";
+import { DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { DensityIcon } from "@/components/ui/density-icon";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { density } from "@/styles/density";
+import { SidebarFooterIconHighlight } from "./sidebar-footer-icon-highlight";
+
+/**
+ * A footer icon that opens a menu. Sized and drawn like the footer's other icon buttons; the
+ * tooltip stays out of the way while the menu is open.
+ */
+export function SidebarFooterMenuTrigger({
+  icon,
+  label,
+  menuOpen,
+  testID,
+}: {
+  icon: LucideIcon;
+  label: string;
+  menuOpen: boolean;
+  testID: string;
+}): ReactElement {
+  return (
+    <Tooltip delayDuration={300} enabledOnDesktop={!menuOpen}>
+      <TooltipTrigger asChild>
+        <View>
+          <DropdownMenuTrigger
+            style={styles.trigger}
+            testID={testID}
+            accessibilityRole="button"
+            accessibilityLabel={label}
+          >
+            {({ hovered, pressed, open }) => (
+              <>
+                <SidebarFooterIconHighlight visible={pressed || open} />
+                <DensityIcon
+                  icon={icon}
+                  size="md"
+                  color={hovered ? "foreground" : "foregroundMuted"}
+                />
+              </>
+            )}
+          </DropdownMenuTrigger>
+        </View>
+      </TooltipTrigger>
+      <TooltipContent side="top" align="center" offset={8}>
+        <Text style={styles.tooltipText}>{label}</Text>
+      </TooltipContent>
+    </Tooltip>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  trigger: {
+    width: density.iconButton,
+    height: density.iconButton,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingVertical: theme.spacing[1],
+    paddingHorizontal: theme.spacing[1],
+  },
+  tooltipText: {
+    fontSize: theme.fontSize.base,
+    color: theme.colors.popoverForeground,
+  },
+}));

packages/app/src/components/sidebar/sidebar-footer-overflow-menu.tsx

@@ -0,0 +1,245 @@
+import { useCallback, useMemo, useState, type ReactElement } from "react";
+import { useTranslation } from "react-i18next";
+import {
+  ChevronUp,
+  CircleGauge,
+  CircleHelp,
+  FolderPlus,
+  Plus,
+  Server,
+  Settings,
+} from "lucide-react-native";
+import { withUnistyles } from "react-native-unistyles";
+import { HostStatusDotSlot } from "@/components/hosts/host-picker";
+import type { SidebarFooterAction } from "@/components/sidebar-footer-layout";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuSubTrigger,
+  type MenuPageDefinition,
+} from "@/components/ui/dropdown-menu";
+import { Shortcut } from "@/components/ui/shortcut";
+import { useLocalDaemonServerId } from "@/hooks/use-is-local-daemon";
+import { useShortcutKeys } from "@/hooks/use-shortcut-keys";
+import { useHosts } from "@/runtime/host-runtime";
+import { ICON_SIZE, type Theme } from "@/styles/theme";
+import { orderHostsLocalFirst } from "@/types/host-connection";
+import { useOpenSidebarUsage } from "@/usage";
+import { SidebarFooterMenuTrigger } from "./sidebar-footer-menu-trigger";
+import { SidebarHelpMenuItems } from "./sidebar-help-menu";
+
+const mutedIconMapping = (theme: Theme) => ({ color: theme.colors.foregroundMuted });
+const ThemedFolderPlus = withUnistyles(FolderPlus);
+const ThemedCircleGauge = withUnistyles(CircleGauge);
+const ThemedServer = withUnistyles(Server);
+const ThemedCircleHelp = withUnistyles(CircleHelp);
+const ThemedSettings = withUnistyles(Settings);
+const ThemedPlus = withUnistyles(Plus);
+const addProjectLeading = <ThemedFolderPlus size={ICON_SIZE.sm} uniProps={mutedIconMapping} />;
+const usageLeading = <ThemedCircleGauge size={ICON_SIZE.sm} uniProps={mutedIconMapping} />;
+const hostsLeading = <ThemedServer size={ICON_SIZE.sm} uniProps={mutedIconMapping} />;
+const helpLeading = <ThemedCircleHelp size={ICON_SIZE.sm} uniProps={mutedIconMapping} />;
+const settingsLeading = <ThemedSettings size={ICON_SIZE.sm} uniProps={mutedIconMapping} />;
+const addHostLeading = <ThemedPlus size={ICON_SIZE.sm} uniProps={mutedIconMapping} />;
+
+const HOSTS_PAGE_ID = "hosts";
+const HELP_PAGE_ID = "help";
+
+export interface SidebarFooterOverflowMenuProps {
+  /** The footer actions that did not fit in the row, in row order. */
+  actions: readonly SidebarFooterAction[];
+  labels: { addProject: string; hosts: string; settings: string; usage: string };
+  onAddProject: () => void;
+  onSettings: () => void;
+  onAddHost: () => void;
+  onOpenHostSettings: (serverId: string) => void;
+}
+
+/**
+ * The caret at the end of a footer row too narrow for every action. It lists the actions that
+ * lost their place, with the same test IDs they carry in the row; Hosts and Help, menus of their
+ * own in the row, open as pages of this menu.
+ */
+export function SidebarFooterOverflowMenu({
+  actions,
+  labels,
+  onAddProject,
+  onSettings,
+  onAddHost,
+  onOpenHostSettings,
+}: SidebarFooterOverflowMenuProps): ReactElement {
+  const { t } = useTranslation();
+  const [open, setOpen] = useState(false);
+  const openUsage = useOpenSidebarUsage();
+  const newAgentKeys = useShortcutKeys("new-agent");
+  const settingsKeys = useShortcutKeys("toggle-settings");
+  const helpLabel = t("sidebar.help.trigger");
+  const addProjectTrailing = useMemo(
+    () => (newAgentKeys ? <Shortcut chord={newAgentKeys} /> : null),
+    [newAgentKeys],
+  );
+  const settingsTrailing = useMemo(
+    () => (settingsKeys ? <Shortcut chord={settingsKeys} /> : null),
+    [settingsKeys],
+  );
+
+  const pages = useMemo((): MenuPageDefinition[] => {
+    const result: MenuPageDefinition[] = [];
+    if (actions.includes("hosts")) {
+      result.push({
+        id: HOSTS_PAGE_ID,
+        title: labels.hosts,
+        content: <HostsPage onAddHost={onAddHost} onOpenHostSettings={onOpenHostSettings} />,
+      });
+    }
+    if (actions.includes("help")) {
+      result.push({ id: HELP_PAGE_ID, title: helpLabel, content: <SidebarHelpMenuItems /> });
+    }
+    return result;
+  }, [actions, helpLabel, labels.hosts, onAddHost, onOpenHostSettings]);
+
+  function renderAction(action: SidebarFooterAction): ReactElement {
+    switch (action) {
+      case "add-project":
+        return (
+          <DropdownMenuItem
+            key={action}
+            testID="sidebar-add-project"
+            leading={addProjectLeading}
+            trailing={addProjectTrailing}
+            onSelect={onAddProject}
+          >
+            {labels.addProject}
+          </DropdownMenuItem>
+        );
+      case "usage":
+        return (
+          <DropdownMenuItem
+            key={action}
+            testID="sidebar-usage-icon"
+            leading={usageLeading}
+            onSelect={openUsage}
+          >
+            {labels.usage}
+          </DropdownMenuItem>
+        );
+      case "hosts":
+        return (
+          <DropdownMenuSubTrigger
+            key={action}
+            id={HOSTS_PAGE_ID}
+            testID="sidebar-hosts-trigger"
+            leading={hostsLeading}
+          >
+            {labels.hosts}
+          </DropdownMenuSubTrigger>
+        );
+      case "help":
+        return (
+          <DropdownMenuSubTrigger
+            key={action}
+            id={HELP_PAGE_ID}
+            testID="sidebar-help"
+            leading={helpLeading}
+          >
+            {helpLabel}
+          </DropdownMenuSubTrigger>
+        );
+      case "settings":
+        return (
+          <DropdownMenuItem
+            key={action}
+            testID="sidebar-settings"
+            leading={settingsLeading}
+            trailing={settingsTrailing}
+            onSelect={onSettings}
+          >
+            {labels.settings}
+          </DropdownMenuItem>
+        );
+    }
+  }
+
+  return (
+    <DropdownMenu open={open} onOpenChange={setOpen}>
+      <SidebarFooterMenuTrigger
+        icon={ChevronUp}
+        label={t("sidebar.actions.moreActions")}
+        menuOpen={open}
+        testID="sidebar-footer-overflow"
+      />
+      <DropdownMenuContent
+        side="top"
+        align="end"
+        offset={8}
+        width={240}
+        pages={pages}
+        scrollable
+        testID="sidebar-footer-overflow-menu"
+      >
+        {actions.map(renderAction)}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+/** The host picker's choices as a menu page: each host opens its settings, then Add host. */
+function HostsPage({
+  onAddHost,
+  onOpenHostSettings,
+}: {
+  onAddHost: () => void;
+  onOpenHostSettings: (serverId: string) => void;
+}): ReactElement {
+  const { t } = useTranslation();
+  const hosts = useHosts();
+  const localServerId = useLocalDaemonServerId();
+  const orderedHosts = useMemo(
+    () => orderHostsLocalFirst(hosts, localServerId),
+    [hosts, localServerId],
+  );
+
+  return (
+    <>
+      {orderedHosts.map((host) => (
+        <HostRow
+          key={host.serverId}
+          serverId={host.serverId}
+          label={host.label}
+          onOpenHostSettings={onOpenHostSettings}
+        />
+      ))}
+      {orderedHosts.length > 0 ? <DropdownMenuSeparator /> : null}
+      <DropdownMenuItem testID="sidebar-host-add" leading={addHostLeading} onSelect={onAddHost}>
+        {t("settings.addHost")}
+      </DropdownMenuItem>
+    </>
+  );
+}
+
+function HostRow({
+  serverId,
+  label,
+  onOpenHostSettings,
+}: {
+  serverId: string;
+  label: string;
+  onOpenHostSettings: (serverId: string) => void;
+}): ReactElement {
+  const handleSelect = useCallback(
+    () => onOpenHostSettings(serverId),
+    [onOpenHostSettings, serverId],
+  );
+  const leading = useMemo(() => <HostStatusDotSlot serverId={serverId} />, [serverId]);
+  return (
+    <DropdownMenuItem
+      testID={`sidebar-host-row-${serverId}`}
+      leading={leading}
+      onSelect={handleSelect}
+    >
+      {label}
+    </DropdownMenuItem>
+  );
+}

packages/app/src/components/sidebar/sidebar-help-menu.tsx

@@ -1,5 +1,5 @@
 import { useCallback, useState } from "react";
-import { Text, View } from "react-native";
+import { View } from "react-native";
 import { Activity, CircleHelp, Gift, Keyboard } from "lucide-react-native";
 import { useTranslation } from "react-i18next";
 import { StyleSheet, withUnistyles } from "react-native-unistyles";
@@ -12,17 +12,13 @@ import {
   DropdownMenuItem,
   DropdownMenuLabel,
   DropdownMenuSeparator,
-  DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
-import { DensityIcon } from "@/components/ui/density-icon";
-import { SidebarFooterIconHighlight } from "./sidebar-footer-icon-highlight";
-import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { SidebarFooterMenuTrigger } from "./sidebar-footer-menu-trigger";
 import { useAppDiagnosticStore } from "@/diagnostics/store";
 import { useHardwareKeyboardPresent } from "@/keyboard";
 import { useHostRuntimeIsConnected, useHosts } from "@/runtime/host-runtime";
 import { useKeyboardShortcutsStore } from "@/stores/keyboard-shortcuts-store";
 import { useSessionStore } from "@/stores/session-store";
-import { density } from "@/styles/density";
 import { ICON_SIZE, type Theme } from "@/styles/theme";
 import type { HostProfile } from "@/types/host-connection";
 import { formatVersionWithPrefix } from "@/desktop/updates/desktop-updates";
@@ -77,12 +73,32 @@ function HostVersionHint({ host }: { host: HostProfile }) {
   );
 }
 
+/** The Help menu's trigger, and the menu it opens. */
 export function SidebarHelpMenu() {
+  const { t } = useTranslation();
+  const [open, setOpen] = useState(false);
+
+  return (
+    <DropdownMenu open={open} onOpenChange={setOpen}>
+      <SidebarFooterMenuTrigger
+        icon={CircleHelp}
+        label={t("sidebar.help.trigger")}
+        menuOpen={open}
+        testID="sidebar-help"
+      />
+      <DropdownMenuContent side="top" align="end" offset={8} width={280} testID="sidebar-help-menu">
+        <SidebarHelpMenuItems />
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+/** The Help menu's rows, shared by the Help menu and the footer's overflow page for it. */
+export function SidebarHelpMenuItems() {
   const { t } = useTranslation();
   const shortcutsAvailable = useHardwareKeyboardPresent();
   const openAppDiagnostic = useAppDiagnosticStore((state) => state.open);
   const setShortcutsDialogOpen = useKeyboardShortcutsStore((state) => state.setShortcutsDialogOpen);
-  const [open, setOpen] = useState(false);
   const version = formatVersionWithPrefix(resolveAppVersion());
   const hosts = useHosts();
 
@@ -99,105 +115,65 @@ export function SidebarHelpMenu() {
   }, []);
 
   return (
-    <DropdownMenu open={open} onOpenChange={setOpen}>
-      <Tooltip delayDuration={300} enabledOnDesktop={!open}>
-        <TooltipTrigger asChild>
-          <View>
-            <DropdownMenuTrigger
-              style={styles.trigger}
-              testID="sidebar-help"
-              accessibilityRole="button"
-              accessibilityLabel={t("sidebar.help.trigger")}
-            >
-              {({ hovered, pressed, open: menuOpen }) => (
-                <>
-                  <SidebarFooterIconHighlight visible={pressed || menuOpen} />
-                  <DensityIcon
-                    icon={CircleHelp}
-                    size="md"
-                    color={hovered ? "foreground" : "foregroundMuted"}
-                  />
-                </>
-              )}
-            </DropdownMenuTrigger>
-          </View>
-        </TooltipTrigger>
-        <TooltipContent side="top" align="center" offset={8}>
-          <Text style={styles.tooltipText}>{t("sidebar.help.trigger")}</Text>
-        </TooltipContent>
-      </Tooltip>
-      <DropdownMenuContent side="top" align="end" offset={8} width={280} testID="sidebar-help-menu">
-        <DropdownMenuLabel>{t("sidebar.help.sectionHelp")}</DropdownMenuLabel>
-        {shortcutsAvailable ? (
-          <DropdownMenuItem
-            testID="sidebar-help-shortcuts"
-            leading={shortcutsLeadingIcon}
-            onSelect={openKeyboardShortcuts}
-          >
-            {t("sidebar.help.shortcuts")}
-          </DropdownMenuItem>
-        ) : null}
+    <>
+      <DropdownMenuLabel>{t("sidebar.help.sectionHelp")}</DropdownMenuLabel>
+      {shortcutsAvailable ? (
         <DropdownMenuItem
-          testID="sidebar-help-changelog"
-          leading={changelogLeadingIcon}
-          onSelect={openChangelog}
+          testID="sidebar-help-shortcuts"
+          leading={shortcutsLeadingIcon}
+          onSelect={openKeyboardShortcuts}
         >
-          {t("sidebar.help.whatsNew")}
+          {t("sidebar.help.shortcuts")}
         </DropdownMenuItem>
-        <DropdownMenuItem
-          testID="sidebar-help-diagnostics"
-          leading={diagnosticLeadingIcon}
-          onSelect={openAppDiagnostic}
+      ) : null}
+      <DropdownMenuItem
+        testID="sidebar-help-changelog"
+        leading={changelogLeadingIcon}
+        onSelect={openChangelog}
+      >
+        {t("sidebar.help.whatsNew")}
+      </DropdownMenuItem>
+      <DropdownMenuItem
+        testID="sidebar-help-diagnostics"
+        leading={diagnosticLeadingIcon}
+        onSelect={openAppDiagnostic}
+      >
+        {t("sidebar.help.diagnostics")}
+      </DropdownMenuItem>
+      <DropdownMenuSeparator />
+      <DropdownMenuLabel>{t("sidebar.help.reportIssue")}</DropdownMenuLabel>
+      <DropdownMenuItem
+        testID="sidebar-help-discord"
+        leading={discordLeadingIcon}
+        onSelect={openDiscord}
+      >
+        {t("sidebar.help.discord")}
+      </DropdownMenuItem>
+      <DropdownMenuItem
+        testID="sidebar-help-github"
+        leading={githubLeadingIcon}
+        onSelect={openGitHubIssue}
+      >
+        {t("sidebar.help.github")}
+      </DropdownMenuItem>
+      <DropdownMenuSeparator />
+      <View style={styles.versionList}>
+        <DropdownMenuHint
+          style={styles.versionHint}
+          trailing={version}
+          testID="sidebar-help-version"
         >
-          {t("sidebar.help.diagnostics")}
-        </DropdownMenuItem>
-        <DropdownMenuSeparator />
-        <DropdownMenuLabel>{t("sidebar.help.reportIssue")}</DropdownMenuLabel>
-        <DropdownMenuItem
-          testID="sidebar-help-discord"
-          leading={discordLeadingIcon}
-          onSelect={openDiscord}
-        >
-          {t("sidebar.help.discord")}
-        </DropdownMenuItem>
-        <DropdownMenuItem
-          testID="sidebar-help-github"
-          leading={githubLeadingIcon}
-          onSelect={openGitHubIssue}
-        >
-          {t("sidebar.help.github")}
-        </DropdownMenuItem>
-        <DropdownMenuSeparator />
-        <View style={styles.versionList}>
-          <DropdownMenuHint
-            style={styles.versionHint}
-            trailing={version}
-            testID="sidebar-help-version"
-          >
-            {t("sidebar.help.appName")}
-          </DropdownMenuHint>
-          {hosts.map((host) => (
-            <HostVersionHint key={host.serverId} host={host} />
-          ))}
-        </View>
-      </DropdownMenuContent>
-    </DropdownMenu>
+          {t("sidebar.help.appName")}
+        </DropdownMenuHint>
+        {hosts.map((host) => (
+          <HostVersionHint key={host.serverId} host={host} />
+        ))}
+      </View>
+    </>
   );
 }
 
 const styles = StyleSheet.create((theme) => ({
-  trigger: {
-    width: density.iconButton,
-    height: density.iconButton,
-    alignItems: "center",
-    justifyContent: "center",
-    paddingVertical: theme.spacing[1],
-    paddingHorizontal: theme.spacing[1],
-  },
-  tooltipText: {
-    fontSize: theme.fontSize.base,
-    color: theme.colors.popoverForeground,
-  },
   versionList: {
     gap: theme.spacing[1],
     paddingVertical: theme.spacing[2],

packages/app/src/components/ui/anchor.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { computePosition, getTransformOrigin, type Rect } from "./anchor";
+import { computePosition, fitSurfaceWidth, getTransformOrigin, type Rect } from "./anchor";
 
 const DISPLAY: Rect = { x: 0, y: 0, width: 1000, height: 800 };
 const TRIGGER: Rect = { x: 100, y: 100, width: 40, height: 20 };
@@ -97,3 +97,26 @@ describe("getTransformOrigin", () => {
     expect(getTransformOrigin(placement, alignment)).toEqual(expected);
   });
 });
+
+describe("fitSurfaceWidth", () => {
+  it("leaves a surface that fits the display alone, capped at the display", () => {
+    expect(fitSurfaceWidth({ width: 240, minWidth: 180 }, 1000)).toEqual({
+      width: 240,
+      minWidth: 180,
+      maxWidth: 984,
+    });
+  });
+
+  it("shrinks a surface wider than a narrow display to the space inside its edge padding", () => {
+    expect(fitSurfaceWidth({ width: 240, minWidth: 180, maxWidth: 320 }, 220)).toEqual({
+      width: 204,
+      minWidth: 180,
+      maxWidth: 204,
+    });
+    expect(fitSurfaceWidth({ minWidth: 180 }, 150)).toEqual({
+      width: undefined,
+      minWidth: 134,
+      maxWidth: 134,
+    });
+  });
+});

packages/app/src/components/ui/anchor.ts

@@ -120,6 +120,27 @@ function clampToDisplayArea(input: {
   };
 }
 
+export interface SurfaceWidth {
+  width?: number;
+  minWidth?: number;
+  maxWidth?: number;
+}
+
+/**
+ * Caps a surface's requested width to the display. Position clamping can move a surface but not
+ * shrink it, so a menu wider than a narrow screen would otherwise hang off the far edge.
+ */
+export function fitSurfaceWidth(requested: SurfaceWidth, displayWidth: number): SurfaceWidth {
+  const available = Math.max(displayWidth - EDGE_PADDING * 2, 0);
+  const cap = (value: number | undefined) =>
+    typeof value === "number" ? Math.min(value, available) : undefined;
+  return {
+    width: cap(requested.width),
+    minWidth: cap(requested.minWidth),
+    maxWidth: cap(requested.maxWidth) ?? available,
+  };
+}
+
 export function computePosition({
   triggerRect,
   contentSize,

packages/app/src/components/ui/control-geometry.test.ts

@@ -14,6 +14,8 @@ import {
   getControlInteractionPhase,
   TOOLBAR_CONTROL_HEIGHT,
   TOOLBAR_CONTROL_SIZES,
+  TOOLBAR_DISC_SIZE,
+  TOOLBAR_DISC_SIZES,
   TOUCH_TARGET,
 } from "@/components/ui/control-geometry";
 import type { Theme } from "@/styles/theme";
@@ -90,6 +92,11 @@ describe("control sizing gate", () => {
     // Composer toolbar controls: a full target on touch, unchanged 28 on pointer.
     expect(TOOLBAR_CONTROL_SIZES).toEqual({ touch: TOUCH_TARGET, pointer: 28 });
     expect(TOOLBAR_CONTROL_HEIGHT).toEqual({ xs: TOUCH_TARGET, md: 28 });
+    // A filled toolbar control paints a 36pt disc inside its 44pt touch frame, and fills its
+    // 28pt pointer frame exactly, so desktop is unchanged. Its glyph is the `md` glyph.
+    expect(TOOLBAR_DISC_SIZES).toEqual({ touch: 36, pointer: TOOLBAR_CONTROL_SIZES.pointer });
+    expect(TOOLBAR_DISC_SIZE).toEqual({ xs: 36, md: 28 });
+    expect(iconSizeFor("md")).toEqual({ touch: 20, pointer: 16 });
     for (const size of ["sm", "md"] as const) {
       expect(controlHeightForLayout(size, true)).toBeGreaterThan(
         controlHeightForLayout(size, false),

packages/app/src/components/ui/control-geometry.ts

@@ -93,6 +93,14 @@ export const ICON_BUTTON_SIZES = {
 export const TOOLBAR_CONTROL_SIZES = { touch: TOUCH_TARGET, pointer: 28 } satisfies SizingValue;
 export const TOOLBAR_CONTROL_HEIGHT = bySizing(TOOLBAR_CONTROL_SIZES);
 
+/**
+ * The painted disc of a filled toolbar control, such as the composer's send and stop. The
+ * control keeps the full toolbar hit frame and paints this smaller disc centered inside it, so
+ * touch-sized it does not outweigh its unpainted neighbours. Pointer-sized it fills the frame.
+ */
+export const TOOLBAR_DISC_SIZES = { touch: 36, pointer: 28 } satisfies SizingValue;
+export const TOOLBAR_DISC_SIZE = bySizing(TOOLBAR_DISC_SIZES);
+
 /**
  * Glyph sizes. Pointer glyphs sit beside 13-14pt text; touch glyphs sit beside iOS's 17pt body
  * text, so each step is larger.

packages/app/src/components/ui/menu/menu-overlay.tsx

@@ -29,6 +29,7 @@ import type { KeyboardFocusScope } from "@/keyboard/actions";
 import { getOverlayRoot, OverlayLayerProvider, useOverlayLayer } from "@/lib/overlay-root";
 import {
   computePosition,
+  fitSurfaceWidth,
   getTransformOrigin,
   measureElement,
   type Alignment,
@@ -283,11 +284,7 @@ export function AnchoredSurface({
     const { width: screenWidth } = Dimensions.get("window");
     const resolvedWidthStyle: ViewStyle = fullWidth
       ? { width: screenWidth - horizontalPadding * 2 }
-      : {
-          ...(typeof width === "number" ? { width } : null),
-          ...(typeof minWidth === "number" ? { minWidth } : null),
-          ...(typeof maxWidth === "number" ? { maxWidth } : null),
-        };
+      : fitSurfaceWidth({ width, minWidth, maxWidth }, screenWidth);
     return [
       resolvedWidthStyle,
       {

packages/app/src/composer/attachments/workspace.tsx

@@ -1,3 +1,4 @@
+import { ChatHistoryAttachment } from "@/attachments/chat-history";
 import { useCallback, useEffect, useMemo, useState, type ReactElement } from "react";
 import { useTranslation } from "react-i18next";
 import type {
@@ -255,12 +256,28 @@ function WorkspaceAttachmentPill({
 }: WorkspaceAttachmentPillProps) {
   const { t } = useTranslation();
   const content = getWorkspaceAttachmentPillContent(attachment, t);
+  const chatHistory = useMemo(() => {
+    if (attachment.kind !== "chat_history") return null;
+    if (!attachment.source) return attachment.attachment;
+    const { serverId, agentId, title } = attachment.source;
+    return { ...attachment.attachment, chatHistorySource: { serverId, agentId, title } };
+  }, [attachment]);
   const handleOpen = useCallback(() => {
     onOpen(attachment);
   }, [onOpen, attachment]);
   const handleRemove = useCallback(() => {
     onRemove(index);
   }, [onRemove, index]);
+  if (chatHistory) {
+    return (
+      <ChatHistoryAttachment
+        attachment={chatHistory}
+        onRemove={handleRemove}
+        disabled={disabled}
+        testID={getPillTestID(attachment)}
+      />
+    );
+  }
   return (
     <AttachmentPill
       testID={getPillTestID(attachment)}

packages/app/src/composer/draft/create-flow.test.ts

@@ -242,10 +242,10 @@ describe("useDraftAgentCreateFlow", () => {
     expect(createRequest).toHaveBeenCalledWith({
       attempt: expect.objectContaining({
         text: "",
-        attachments: [attachment.attachment],
+        attachments: [{ ...attachment.attachment, chatHistorySource: attachment.source }],
       }),
       text: "",
-      attachments: [attachment.attachment],
+      attachments: [{ ...attachment.attachment, chatHistorySource: attachment.source }],
       cwd: "/repo",
     });
     expect(onCreateSuccess).toHaveBeenCalledTimes(1);

packages/app/src/composer/index.tsx

@@ -35,6 +35,7 @@ import {
   controlSizingForLayout,
   iconSizeFor,
   TOOLBAR_CONTROL_HEIGHT,
+  TOOLBAR_DISC_SIZE,
 } from "@/components/ui/control-geometry";
 import { usePanelStore } from "@/stores/panel-store";
 import { usePointerCapabilities } from "@/hooks/pointer-capabilities";
@@ -1117,7 +1118,7 @@ function ComposerCancelButton({
         accessibilityRole="button"
         style={cancelButtonStyle}
       >
-        {icon}
+        <View style={styles.cancelButtonDisc}>{icon}</View>
       </TooltipTrigger>
       <TooltipContent side="top" align="center" offset={8}>
         <View style={styles.tooltipRow}>
@@ -2595,14 +2596,21 @@ const styles = StyleSheet.create((theme: Theme) => ({
     width: "100%",
     gap: theme.spacing[3],
   },
+  // The trigger is the hit frame and stays unpainted; the disc inside it carries the fill.
   cancelButton: {
     width: TOOLBAR_CONTROL_HEIGHT,
     height: TOOLBAR_CONTROL_HEIGHT,
+    alignItems: "center",
+    justifyContent: "center",
+    marginLeft: theme.spacing[1],
+  },
+  cancelButtonDisc: {
+    width: TOOLBAR_DISC_SIZE,
+    height: TOOLBAR_DISC_SIZE,
     borderRadius: theme.borderRadius.full,
     backgroundColor: theme.colors.palette.red[600],
     alignItems: "center",
     justifyContent: "center",
-    marginLeft: theme.spacing[1],
   },
   rightControls: {
     flexDirection: "row",

packages/app/src/composer/input/input.tsx

@@ -33,6 +33,7 @@ import {
   controlSizingForLayout,
   iconSizeFor,
   TOOLBAR_CONTROL_HEIGHT,
+  TOOLBAR_DISC_SIZE,
 } from "@/components/ui/control-geometry";
 import { ArrowUp, Mic, MicOff, CornerDownLeft, Plus, Square } from "lucide-react-native";
 import * as Haptics from "expo-haptics";
@@ -349,7 +350,11 @@ function VoiceButtonIcon({
   buttonIconSize: number;
 }) {
   if (isDictating) {
-    return <Square size={buttonIconSize} color="white" fill="white" />;
+    return (
+      <View style={styles.voiceButtonRecordingDisc}>
+        <Square size={buttonIconSize} color="white" fill="white" />
+      </View>
+    );
   }
   const colorMapping = hovered ? iconForegroundMapping : iconForegroundMutedMapping;
   if (isMutedRealtime) {
@@ -837,12 +842,14 @@ function SendButtonTooltip({
         testID={submitButtonTestID}
         style={sendButtonCombinedStyle}
       >
-        <SendButtonContent
-          isSubmitLoading={isSubmitLoading}
-          submitIcon={submitIcon}
-          submitLabel={submitLabel}
-          buttonIconSize={buttonIconSize}
-        />
+        <View style={submitLabel ? styles.sendButtonDiscLabeled : styles.sendButtonDisc}>
+          <SendButtonContent
+            isSubmitLoading={isSubmitLoading}
+            submitIcon={submitIcon}
+            submitLabel={submitLabel}
+            buttonIconSize={buttonIconSize}
+          />
+        </View>
       </TooltipTrigger>
       <TooltipContent side="top" align="center" offset={8}>
         <SendTooltipBody label={sendTooltipLabel} sendKeys={sendKeys} />
@@ -1925,7 +1932,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
         styles.voiceButton,
         Boolean(hovered) && !isDictating && styles.iconButtonHovered,
         !isDictationStartEnabled && styles.buttonDisabled,
-        isDictating && styles.voiceButtonRecording,
       ],
       [isDictating, isDictationStartEnabled],
     );
@@ -1974,12 +1980,8 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       allowEmpty: allowEmptySubmit,
     });
     const sendButtonCombinedStyle = useMemo(
-      () => [
-        styles.sendButton,
-        submitLabel ? styles.sendButtonLabeled : undefined,
-        isPresentedSendDisabled && styles.buttonDisabled,
-      ],
-      [isPresentedSendDisabled, submitLabel],
+      () => [styles.sendButton, isPresentedSendDisabled && styles.buttonDisabled],
+      [isPresentedSendDisabled],
     );
     const overlayContainerStyle = useMemo(
       () => [styles.overlayContainer, { opacity: surfacePresentation.overlay.opacity }],
@@ -2416,23 +2418,38 @@ const styles = StyleSheet.create((theme: Theme) => ({
     alignItems: "center",
     justifyContent: "center",
   },
-  voiceButtonRecording: {
-    backgroundColor: theme.colors.destructive,
-  },
-  sendButton: {
-    width: TOOLBAR_CONTROL_HEIGHT,
-    height: TOOLBAR_CONTROL_HEIGHT,
+  voiceButtonRecordingDisc: {
+    width: TOOLBAR_DISC_SIZE,
+    height: TOOLBAR_DISC_SIZE,
     borderRadius: theme.borderRadius.full,
-    backgroundColor: theme.colors.accent,
+    backgroundColor: theme.colors.destructive,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  // The trigger is the hit frame and stays unpainted; the disc inside it carries the fill.
+  sendButton: {
+    minWidth: TOOLBAR_CONTROL_HEIGHT,
+    height: TOOLBAR_CONTROL_HEIGHT,
     alignItems: "center",
     justifyContent: "center",
     marginLeft: theme.spacing[1],
   },
-  sendButtonLabeled: {
-    width: "auto",
-    minWidth: TOOLBAR_CONTROL_HEIGHT,
+  sendButtonDisc: {
+    width: TOOLBAR_DISC_SIZE,
+    height: TOOLBAR_DISC_SIZE,
+    borderRadius: theme.borderRadius.full,
+    backgroundColor: theme.colors.accent,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  sendButtonDiscLabeled: {
+    minWidth: TOOLBAR_DISC_SIZE,
+    height: TOOLBAR_DISC_SIZE,
     paddingHorizontal: theme.spacing[3],
     borderRadius: theme.borderRadius.full,
+    backgroundColor: theme.colors.accent,
+    alignItems: "center",
+    justifyContent: "center",
   },
   sendButtonLabel: {
     fontSize: theme.fontSize.base,

packages/app/src/hooks/use-fork-agent.ts

@@ -68,6 +68,7 @@ export interface UseForkAgentInput {
 
 function buildChatHistoryAttachment(input: {
   draftId: string;
+  title: string | null;
   serverId: string;
   agentId: string;
   payload: Awaited<ReturnType<DaemonClient["buildAgentForkContext"]>>;
@@ -83,6 +84,7 @@ function buildChatHistoryAttachment(input: {
     source: {
       serverId: input.serverId,
       agentId: input.agentId,
+      ...(input.title ? { title: input.title } : {}),
       boundaryMessageId: input.payload.boundaryMessageId,
       boundaryCursor: input.payload.boundaryCursor,
       itemCount: input.payload.itemCount,
@@ -147,6 +149,7 @@ export function useForkAgent(
         const payload = await client.buildAgentForkContext(agentId, boundary);
         const attachment = buildChatHistoryAttachment({
           draftId,
+          title: useSessionStore.getState().sessions[serverId]?.agents.get(agentId)?.title ?? null,
           serverId,
           agentId,
           payload,

packages/app/src/i18n/resources/ar.ts

@@ -342,6 +342,14 @@ export const ar: TranslationResources = {
       openFile: "افتح الملف",
       copied: "منقول",
     },
+    chatHistory: {
+      title: "سجل المحادثة",
+      previousConversation: "المحادثة السابقة",
+      open: "فتح مرفق سجل المحادثة",
+      remove: "إزالة مرفق سجل المحادثة",
+      openSource: "فتح المحادثة الأصلية",
+      description: "السياق المنسوخ عند تفريع هذه المحادثة.",
+    },
     attachments: {
       dismissImage: "تجاهل الصورة",
       closeImage: "إغلاق الصورة",
@@ -1236,6 +1244,7 @@ export const ar: TranslationResources = {
       hosts: "المضيفون",
       settings: "إعدادات",
       closeSidebar: "إغلاق الشريط الجانبي",
+      moreActions: "المزيد من الإجراءات",
     },
     footer: {
       usage: "الاستخدام",

packages/app/src/i18n/resources/en.ts

@@ -339,6 +339,14 @@ export const en = {
       openFile: "Open file",
       copied: "Copied",
     },
+    chatHistory: {
+      title: "Chat history",
+      previousConversation: "Previous conversation",
+      open: "Open chat history attachment",
+      remove: "Remove chat history attachment",
+      openSource: "Open source chat",
+      description: "Context copied when this chat was forked.",
+    },
     attachments: {
       dismissImage: "Dismiss image",
       closeImage: "Close image",
@@ -1244,6 +1252,7 @@ export const en = {
       hosts: "Hosts",
       settings: "Settings",
       closeSidebar: "Close sidebar",
+      moreActions: "More actions",
     },
     footer: {
       usage: "Usage",

packages/app/src/i18n/resources/es.ts

@@ -347,6 +347,14 @@ export const es: TranslationResources = {
       openFile: "Abrir archivo",
       copied: "Copiado",
     },
+    chatHistory: {
+      title: "Historial del chat",
+      previousConversation: "Conversación anterior",
+      open: "Abrir el historial adjunto",
+      remove: "Quitar el historial adjunto",
+      openSource: "Abrir el chat de origen",
+      description: "Contexto copiado al bifurcar este chat.",
+    },
     attachments: {
       dismissImage: "Descartar imagen",
       closeImage: "Cerrar imagen",
@@ -1272,6 +1280,7 @@ export const es: TranslationResources = {
       hosts: "Hosts",
       settings: "Ajustes",
       closeSidebar: "Cerrar barra lateral",
+      moreActions: "Más acciones",
     },
     footer: {
       usage: "Uso",

packages/app/src/i18n/resources/fr.ts

@@ -347,6 +347,14 @@ export const fr: TranslationResources = {
       openFile: "Ouvrir le fichier",
       copied: "Copié",
     },
+    chatHistory: {
+      title: "Historique du chat",
+      previousConversation: "Conversation précédente",
+      open: "Ouvrir l’historique joint",
+      remove: "Retirer l’historique joint",
+      openSource: "Ouvrir le chat d’origine",
+      description: "Contexte copié lors de la bifurcation de ce chat.",
+    },
     attachments: {
       dismissImage: "Ignorer l’image",
       closeImage: "Fermer l’image",
@@ -1266,6 +1274,7 @@ export const fr: TranslationResources = {
       hosts: "Hôtes",
       settings: "Paramètres",
       closeSidebar: "Fermer la barre latérale",
+      moreActions: "Plus d’actions",
     },
     footer: {
       usage: "Utilisation",

packages/app/src/i18n/resources/ja.ts

@@ -347,6 +347,14 @@ export const ja: TranslationResources = {
       openFile: "ファイルを開く",
       copied: "コピーしました",
     },
+    chatHistory: {
+      title: "チャット履歴",
+      previousConversation: "以前の会話",
+      open: "チャット履歴の添付を開く",
+      remove: "チャット履歴の添付を削除",
+      openSource: "元のチャットを開く",
+      description: "このチャットを分岐した時点でコピーされたコンテキストです。",
+    },
     attachments: {
       dismissImage: "画像を閉じる",
       closeImage: "画像を閉じる",
@@ -1250,6 +1258,7 @@ export const ja: TranslationResources = {
       hosts: "ホスト",
       settings: "設定",
       closeSidebar: "サイドバーを閉じる",
+      moreActions: "その他のアクション",
     },
     footer: {
       usage: "使用状況",

packages/app/src/i18n/resources/ko.ts

@@ -343,6 +343,14 @@ export const ko: TranslationResources = {
       openFile: "파일 열기",
       copied: "복사됨",
     },
+    chatHistory: {
+      title: "채팅 기록",
+      previousConversation: "이전 대화",
+      open: "채팅 기록 첨부 열기",
+      remove: "채팅 기록 첨부 제거",
+      openSource: "원본 채팅 열기",
+      description: "이 채팅을 분기할 때 복사된 컨텍스트입니다.",
+    },
     attachments: {
       dismissImage: "이미지 닫기",
       closeImage: "이미지 닫기",
@@ -1243,6 +1251,7 @@ export const ko: TranslationResources = {
       hosts: "호스트",
       settings: "설정",
       closeSidebar: "사이드바 닫기",
+      moreActions: "추가 작업",
     },
     footer: {
       usage: "사용량",

packages/app/src/i18n/resources/pt-BR.ts

@@ -346,6 +346,14 @@ export const ptBR: TranslationResources = {
       openFile: "Abrir arquivo",
       copied: "Copiado",
     },
+    chatHistory: {
+      title: "Histórico do chat",
+      previousConversation: "Conversa anterior",
+      open: "Abrir histórico anexado",
+      remove: "Remover histórico anexado",
+      openSource: "Abrir chat de origem",
+      description: "Contexto copiado ao ramificar este chat.",
+    },
     attachments: {
       dismissImage: "Dispensar imagem",
       closeImage: "Fechar imagem",
@@ -1262,6 +1270,7 @@ export const ptBR: TranslationResources = {
       hosts: "Hosts",
       settings: "Configurações",
       closeSidebar: "Fechar barra lateral",
+      moreActions: "Mais ações",
     },
     footer: {
       usage: "Uso",

packages/app/src/i18n/resources/ru.ts

@@ -346,6 +346,14 @@ export const ru: TranslationResources = {
       openFile: "Открыть файл",
       copied: "Скопировано",
     },
+    chatHistory: {
+      title: "История чата",
+      previousConversation: "Предыдущий разговор",
+      open: "Открыть вложенную историю чата",
+      remove: "Удалить вложенную историю чата",
+      openSource: "Открыть исходный чат",
+      description: "Контекст, скопированный при создании этой ветки чата.",
+    },
     attachments: {
       dismissImage: "Закрыть изображение",
       closeImage: "Закрыть изображение",
@@ -1254,6 +1262,7 @@ export const ru: TranslationResources = {
       hosts: "Хосты",
       settings: "Настройки",
       closeSidebar: "Закрыть боковую панель",
+      moreActions: "Дополнительные действия",
     },
     footer: {
       usage: "Использование",

packages/app/src/i18n/resources/zh-CN.ts

@@ -342,6 +342,14 @@ export const zhCN: TranslationResources = {
       openFile: "打开文件",
       copied: "已复制",
     },
+    chatHistory: {
+      title: "聊天历史",
+      previousConversation: "之前的对话",
+      open: "打开聊天历史附件",
+      remove: "移除聊天历史附件",
+      openSource: "打开来源对话",
+      description: "创建此分叉时复制的上下文。",
+    },
     attachments: {
       dismissImage: "关闭图片",
       closeImage: "关闭图片",
@@ -1228,6 +1236,7 @@ export const zhCN: TranslationResources = {
       hosts: "Hosts",
       settings: "设置",
       closeSidebar: "关闭侧边栏",
+      moreActions: "更多操作",
     },
     footer: {
       usage: "使用情况",

packages/app/src/panels/agent-panel.tsx

@@ -43,7 +43,10 @@ import { RewindComposerRestoreProvider } from "@/components/rewind/composer-rest
 import { useAgentDescriptor } from "@/agent-presentation";
 import { useToastHost, type ToastApi, type ToastState } from "@/components/toast-host";
 import type { WorkspaceComposerAttachment } from "@/attachments/types";
-import { useWorkspaceAttachmentScopeKey } from "@/attachments/workspace-attachments-store";
+import {
+  useWorkspaceAttachmentScopeKey,
+  useAgentAttachmentScopeKey,
+} from "@/attachments/workspace-attachments-store";
 import { COMPACT_CONTENT_WIDTH, useIsCompactFormFactor } from "@/constants/layout";
 import { isNative, isWeb } from "@/constants/platform";
 import { useAgentAttentionClear } from "@/hooks/use-agent-attention-clear";
@@ -1112,6 +1115,7 @@ const ChatAgentReadyContent = memo(function ChatAgentReadyContent({
   const parentAgentId = useParentAgentId(serverId, agentId);
   // With a composer the parent is a pill above it; without one, the box takes the composer's place.
   const parentPillAgentId = showsComposer ? parentAgentId : null;
+  const rewindAttachmentScopeKey = useAgentAttachmentScopeKey({ serverId, agentId });
   const rawAgentInputDraft = useAgentInputDraft({
     draftKey: buildDraftStoreKey({
       serverId,
@@ -1245,6 +1249,7 @@ const ChatAgentReadyContent = memo(function ChatAgentReadyContent({
 
   const content = (
     <RewindComposerRestoreProvider
+      attachmentScopeKey={rewindAttachmentScopeKey}
       textSource={agentInputDraft.textSource}
       setText={agentInputDraft.replaceText}
       onRewindComplete={handleRewindComplete}
@@ -1541,9 +1546,10 @@ function ActiveAgentComposer({
     cwd,
     workspaceId,
   });
+  const agentAttachmentScopeKey = useAgentAttachmentScopeKey({ serverId, agentId });
   const attachmentScopeKeys = useMemo(
-    () => [workspaceAttachmentScopeKey],
-    [workspaceAttachmentScopeKey],
+    () => [workspaceAttachmentScopeKey, agentAttachmentScopeKey],
+    [workspaceAttachmentScopeKey, agentAttachmentScopeKey],
   );
   const handleOpenWorkspaceAttachment = useCallback(
     (attachment: WorkspaceComposerAttachment) => {

packages/app/src/runtime/replica-cache/index.test.ts

@@ -321,6 +321,26 @@ describe("ReplicaCache", () => {
     expect(restored?.range).toBeNull();
   });
 
+  it("preserves workspace parentage and its checkpoint across cache reopen", async () => {
+    const storage = new MemoryStorage();
+    const writer = createCache(storage);
+    const baseline = directory({ workspaces: { generation: "g", afterSeq: 8 } });
+    const workspace = normalizeWorkspaceDescriptor({
+      ...workspacePayload(),
+      parentWorkspaceId: "parent",
+    });
+    baseline.workspaces.set(workspace.id, workspace);
+    commitDirectory(writer, SERVER_ID, baseline);
+    await writer.flush();
+    const reader = createCache(storage);
+    const restored = await reader.readDirectory(SERVER_ID);
+    expect(restored.checkpoint).toEqual(baseline.checkpoint);
+    expect(restored.workspaces.get(workspace.id)?.parentWorkspaceId).toBe("parent");
+    expect((await reader.readWorkspace(SERVER_ID, workspace.id))?.workspace.parentWorkspaceId).toBe(
+      "parent",
+    );
+  });
+
   it("preserves workspace sorting timestamps across cache reopen", async () => {
     const storage = new MemoryStorage();
     const writer = createCache(storage);

packages/app/src/runtime/replica-cache/index.ts

@@ -299,6 +299,7 @@ const WorkspaceGitRuntimeSchema = z
   .optional();
 
 const StoredWorkspaceSchema = z.strictObject({
+  parentWorkspaceId: z.string().optional(),
   // Require both keys: a cursor without these values would preserve the wrong sort on reconnect.
   createdAt: IsoDateSchema.nullable(),
   lastUserMessageAt: IsoDateSchema.nullable(),
@@ -707,6 +708,7 @@ function restoreWorkspace(stored: StoredWorkspace): WorkspaceDescriptor {
 
 function serializeWorkspace(workspace: WorkspaceDescriptor): StoredWorkspace {
   return {
+    parentWorkspaceId: workspace.parentWorkspaceId,
     createdAt: workspace.createdAt?.toISOString() ?? null,
     lastUserMessageAt: workspace.lastUserMessageAt?.toISOString() ?? null,
     id: workspace.id,

packages/app/src/stores/session-store.test.ts

@@ -557,6 +557,33 @@ describe("normalizeWorkspaceDescriptor", () => {
     expect(blank.workspaceDirectory).toBe("");
   });
 
+  it("preserves informational workspace parentage", () => {
+    const payload = {
+      id: "child",
+      parentWorkspaceId: "parent",
+      projectId: "1",
+      projectDisplayName: "Project 1",
+      projectRootPath: "/repo",
+      workspaceDirectory: "/repo",
+      projectKind: "git",
+      workspaceKind: "checkout",
+      name: "main",
+      archivingAt: null,
+      status: "done",
+      statusEnteredAt: null,
+      activityAt: null,
+      diffStat: null,
+      scripts: [],
+    } as WorkspaceDescriptorPayload;
+
+    const workspace = normalizeWorkspaceDescriptor(payload);
+
+    expect(workspace.parentWorkspaceId).toBe("parent");
+    expect(
+      normalizeWorkspaceDescriptor({ ...payload, parentWorkspaceId: undefined }).parentWorkspaceId,
+    ).toBeUndefined();
+  });
+
   it("defaults missing scripts to an empty array", () => {
     const payload = {
       id: "1",

packages/app/src/stores/session-store.ts

@@ -105,6 +105,7 @@ export interface Agent {
 }
 
 export interface WorkspaceDescriptor {
+  parentWorkspaceId?: string;
   createdAt: Date | null;
   lastUserMessageAt: Date | null;
   id: string;
@@ -162,6 +163,7 @@ export function normalizeWorkspaceDescriptor(
     projectKind: payload.projectKind,
     workspaceKind: payload.workspaceKind,
     background: payload.background ?? false,
+    parentWorkspaceId: payload.parentWorkspaceId,
     name: payload.name,
     title: payload.title ?? null,
     pinnedAt: payload.pinnedAt ?? null,

packages/app/src/types/stream.test.ts

@@ -9,6 +9,7 @@ import {
   hydrateStreamState,
   mergeToolCallDetail,
   reduceStreamUpdate,
+  replaceWithCanonicalStream,
   streamTimelineItemIdentity,
   type AgentToolCallItem,
   type StreamItem,
@@ -158,6 +159,104 @@ describe("plugin timeline rows", () => {
 });
 
 describe("user message identity", () => {
+  it.each(["", "Continue here"])(
+    "restores fork history onto a cached user message (%s)",
+    (text) => {
+      const cached = createUserMessage({
+        clientMessageId: "fork-client",
+        messageId: "fork-provider",
+        text,
+        timestamp: new Date(0),
+        timelineCursor: { epoch: "timeline", seq: 1 },
+      });
+      const history = {
+        type: "text",
+        mimeType: "text/plain",
+        contextKind: "chat_history",
+        text: "[User] Earlier question\n[Assistant] Earlier answer",
+      } as const;
+      const canonical = createUserMessage({
+        ...cached,
+        attachments: [history],
+      });
+      const result = replaceWithCanonicalStream({
+        canonical: [canonical],
+        previousTail: [cached],
+        previousHead: [],
+        sendingClientMessageIds: [],
+        preserveContinuity: true,
+        canonicalCoverage: { epoch: "timeline", endSeq: 1 },
+      });
+      expect(result.tail).toHaveLength(1);
+      expect(result.tail[0]).toMatchObject({ text, attachments: [history] });
+    },
+  );
+
+  it.each(["", "Continue from here"])(
+    "hydrates fork history without optimistic state: %s",
+    (text) => {
+      const chatHistory = {
+        type: "text",
+        mimeType: "text/plain",
+        contextKind: "chat_history",
+        text: "[User] Earlier question\n[Assistant] Earlier answer",
+        chatHistorySource: { serverId: "source-host", agentId: "source-agent", title: "Original" },
+      } as const;
+      const result = reduceStreamUpdate(
+        [],
+        {
+          type: "timeline",
+          provider: "codex",
+          item: { type: "user_message", text, messageId: "fork-prompt", chatHistory },
+        },
+        new Date(0),
+      );
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({ kind: "user_message", text, attachments: [chatHistory] });
+    },
+  );
+
+  it.each([
+    { text: "", insert: "tail" },
+    { text: "Continue", insert: "tail" },
+    { text: "", insert: "head" },
+    { text: "Continue", insert: "head" },
+  ] as const)("delivers fork history to a live viewer ($insert, $text)", ({ text, insert }) => {
+    const chatHistory = {
+      type: "text",
+      mimeType: "text/plain",
+      contextKind: "chat_history",
+      text: "[User] Original question",
+      chatHistorySource: { serverId: "source-host", agentId: "source-agent" },
+    } as const;
+    const event = {
+      type: "timeline",
+      provider: "codex",
+      item: { type: "user_message", text, messageId: "fork-message", chatHistory },
+    } as const;
+    const first = applyStreamEvent({
+      tail: [],
+      head: [],
+      event,
+      timestamp: new Date(0),
+      unmatchedUserMessageInsert: insert,
+    });
+    expect(first[insert]).toHaveLength(1);
+    expect(first[insert][0]).toMatchObject({
+      kind: "user_message",
+      text,
+      attachments: [chatHistory],
+    });
+    const repeated = applyStreamEvent({
+      ...first,
+      event,
+      timestamp: new Date(0),
+      unmatchedUserMessageInsert: insert,
+    });
+    expect([...repeated.tail, ...repeated.head]).toHaveLength(1);
+    expect([...repeated.tail, ...repeated.head][0]).toMatchObject({ attachments: [chatHistory] });
+  });
+
   it("replaces provisional optimistic turn membership with canonical membership", () => {
     const optimistic = createUserMessage({
       clientMessageId: "hello-client",

packages/app/src/types/stream.ts

@@ -263,6 +263,7 @@ function produceUserMessage(
     clientMessageId: incoming.clientMessageId ?? existing.clientMessageId,
     messageId: incoming.messageId ?? existing.messageId,
     timelineCursor: incoming.timelineCursor ?? existing.timelineCursor,
+    attachments: presentation.attachments ?? incoming.attachments,
   });
   if (
     existing.id === merged.id &&
@@ -891,6 +892,18 @@ export function handoffCreatedAgentUserMessageToStream(params: {
   });
 }
 
+function normalizeUserMessageContent(
+  text: string,
+  chatHistory?: Extract<AgentTimelineItem, { type: "user_message" }>["chatHistory"],
+) {
+  const normalized = normalizeChunk(text);
+  return {
+    ...normalized,
+    hasContent: normalized.hasContent || chatHistory !== undefined,
+    attachments: chatHistory ? [chatHistory] : undefined,
+  };
+}
+
 function appendUserMessage(
   state: StreamItem[],
   text: string,
@@ -900,8 +913,9 @@ function appendUserMessage(
   clientMessageId?: string,
   timelineCursor?: TimelinePosition,
   turnId?: string,
+  chatHistory?: Extract<AgentTimelineItem, { type: "user_message" }>["chatHistory"],
 ): StreamItem[] {
-  const { chunk, hasContent } = normalizeChunk(text);
+  const { chunk, hasContent, attachments } = normalizeUserMessageContent(text, chatHistory);
   if (!hasContent) {
     return state;
   }
@@ -914,6 +928,7 @@ function appendUserMessage(
     timelineCursor,
     turnId,
     text: chunk,
+    attachments,
     timestamp,
   });
   return upsertUserMessage(state, nextItem);
@@ -1523,6 +1538,7 @@ function reduceTimelineEvent(
         item.clientMessageId,
         timelineCursor,
         event.turnId,
+        item.chatHistory,
       );
     case "assistant_message":
       return appendAssistantMessage(
@@ -1874,7 +1890,7 @@ function applyCanonicalUserMessageEvent(params: {
 }): ApplyStreamEventResult | null {
   const { tail, head, event, timestamp, timelineCursor, unmatchedInsert = "tail" } = params;
   if (event.type !== "timeline" || event.item.type !== "user_message") return null;
-  const normalized = normalizeChunk(event.item.text);
+  const normalized = normalizeUserMessageContent(event.item.text, event.item.chatHistory);
 
   const flushedTail = head.length > 0 ? flushHeadToTail(tail, head) : tail;
   const flushedHead = head.length > 0 ? [] : head;
@@ -1887,6 +1903,7 @@ function applyCanonicalUserMessageEvent(params: {
     turnId: event.turnId,
     timelineCursor,
     text: normalized.chunk,
+    attachments: normalized.attachments,
     timestamp,
   });
   if (unmatchedInsert === "head") {

packages/app/src/usage/queries.ts

@@ -33,9 +33,10 @@ import {
 } from "./model";
 import type { UsageReportEntry, UsageView } from "./types";
 
-// The daemon caches each report for five minutes, so re-reading it is cheap. Only
-// an explicit refresh passes `forceRefresh` and reaches the source's API.
+// The daemon caches each report for five minutes, so re-reading it is cheap.
+// An explicit refresh passes `forceRefresh` to bypass that cache.
 const REPORTS_STALE_TIME_MS = 60_000;
+const REPORTS_REFETCH_INTERVAL_MS = 5 * 60_000;
 
 /** Every report list of a host: its own and each agent's. */
 function hostUsageQueryKey(serverId: string) {
@@ -164,11 +165,16 @@ export function useHostUsage(serverId: string): { view: UsageView; refresh: () =
 
 const NO_REPORTS: UsageReportEntry[] = [];
 
-/**
- * The reports of the sidebar's usage host, which is connected and reports usage; none until they
- * load, or without a host.
- */
-export function useUsageHostReports(serverId: string | null): UsageReportEntry[] {
+interface UsageHostReportsInput {
+  serverId: string | null;
+  shouldPoll?: boolean;
+}
+
+/** A host's reports, with periodic refresh enabled only by the visible sidebar summary. */
+export function useUsageHostReports({
+  serverId,
+  shouldPoll = false,
+}: UsageHostReportsInput): UsageReportEntry[] {
   const setting = useUsageSetting(serverId);
   const queryClient = useQueryClient();
   const query = useFetchQuery({
@@ -177,6 +183,7 @@ export function useUsageHostReports(serverId: string | null): UsageReportEntry[]
     queryFn: serverId ? () => listReports(queryClient, serverId) : skipToken,
     dataShape: "list",
     staleTimeMs: REPORTS_STALE_TIME_MS,
+    refetchInterval: shouldPoll ? REPORTS_REFETCH_INTERVAL_MS : false,
   });
   return setting.enabled ? (query.data ?? NO_REPORTS) : NO_REPORTS;
 }

packages/app/src/usage/sidebar-item.tsx

@@ -16,6 +16,8 @@ import {
   type PressableStateCallbackType,
 } from "react-native";
 import { StyleSheet } from "react-native-unistyles";
+import { useRetainedPanelActive } from "@/components/retained-panel";
+import { useAppVisible } from "@/hooks/use-app-visible";
 import { builtinSidebarNavLabelKey } from "@/sidebar-nav/model";
 import { useUsageDisplay } from "./display";
 import { useUsageInSidebar } from "./in-sidebar";
@@ -36,9 +38,14 @@ import { UsageModal } from "./usage-modal";
 /** Each summary window with data on the usage host, under its source; empty while none has. */
 export function useUsageSummary(): readonly PinnedUsageSource[] {
   const { t } = useTranslation();
+  const active = useRetainedPanelActive();
+  const isAppVisible = useAppVisible();
   const { inSidebar } = useUsageInSidebar();
   const serverId = useUsageHostId();
-  const reports = useUsageHostReports(inSidebar ? serverId : null);
+  const reports = useUsageHostReports({
+    serverId: inSidebar ? serverId : null,
+    shouldPoll: active && inSidebar && isAppVisible,
+  });
   const { preferences } = useUsageDisplay(reports);
   return useMemo(() => resolvePinnedUsage(reports, preferences, t), [preferences, reports, t]);
 }

packages/protocol/src/agent-types.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage } from "./agent-message.js";
-import type { AgentAttachment } from "./messages.js";
+import type { AgentAttachment, ChatHistoryAttachment } from "./messages.js";
 
 export type AgentProvider = string;
 
@@ -373,7 +373,13 @@ export interface AgentTaskItem {
 }
 
 export type AgentTimelineItem =
-  | { type: "user_message"; text: string; messageId?: string; clientMessageId?: string }
+  | {
+      type: "user_message";
+      text: string;
+      messageId?: string;
+      clientMessageId?: string;
+      chatHistory?: ChatHistoryAttachment;
+    }
   | { type: "assistant_message"; text: string; messageId?: string }
   | { type: "reasoning"; text: string }
   | ToolCallTimelineItem

packages/protocol/src/chat-history.ts

@@ -0,0 +1,9 @@
+/** Remove the fork prompt envelope while preserving the snapshot body verbatim. */
+export function extractChatHistoryBody(text: string): string {
+  const bodyStart = text.indexOf("\n\n");
+  return text.startsWith("<chat-history-summary>\n") &&
+    text.endsWith("\n</chat-history-summary>") &&
+    bodyStart !== -1
+    ? text.slice(bodyStart + 2, -"\n</chat-history-summary>".length)
+    : text;
+}

packages/protocol/src/messages.attachments.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 
 import {
+  AgentTimelineItemPayloadSchema,
   AgentForkContextRequestMessageSchema,
   AgentForkContextResponseMessageSchema,
   CreateAgentRequestMessageSchema,
@@ -9,6 +10,24 @@ import {
 } from "./messages.js";
 
 describe("shared messages attachments", () => {
+  it("round-trips fork history on a timeline row and accepts rows without it", () => {
+    const row = {
+      type: "user_message",
+      text: "",
+      messageId: "fork-prompt",
+      chatHistory: {
+        type: "text",
+        mimeType: "text/plain",
+        contextKind: "chat_history",
+        text: "Earlier context",
+        chatHistorySource: { serverId: "source-host", agentId: "source-agent", title: "Original" },
+      },
+    };
+    expect(AgentTimelineItemPayloadSchema.parse(row)).toEqual(row);
+    const legacy = { type: "user_message", text: "Earlier message" };
+    expect(AgentTimelineItemPayloadSchema.parse(legacy)).toEqual(legacy);
+  });
+
   it("preserves an optional timeline cursor on fork-context messages", () => {
     const boundaryCursor = { epoch: "timeline-1", seq: 42 };
     const request = AgentForkContextRequestMessageSchema.parse({
@@ -269,6 +288,29 @@ describe("shared messages attachments", () => {
     ]);
   });
 
+  it("preserves the source of a fork across message submission", () => {
+    const attachment = {
+      type: "text",
+      mimeType: "text/plain",
+      contextKind: "chat_history",
+      title: "Chat history",
+      text: "Earlier context",
+      chatHistorySource: {
+        serverId: "source-host",
+        agentId: "source-agent",
+        title: "Original conversation",
+      },
+    };
+    const parsed = SendAgentMessageRequestSchema.parse({
+      type: "send_agent_message_request",
+      requestId: "req-fork-source",
+      agentId: "fork-agent",
+      text: "Continue",
+      attachments: [attachment],
+    });
+    expect(parsed.attachments).toEqual([attachment]);
+  });
+
   it("keeps known text attachment context kinds and ignores future ones", () => {
     const parsed = SendAgentMessageRequestSchema.parse({
       type: "send_agent_message_request",

packages/protocol/src/messages.ts

@@ -712,6 +712,25 @@ const ToolCallTimelineItemPayloadSchema: z.ZodType<ToolCallTimelineItem, unknown
     ToolCallCanceledPayloadSchema,
   ]);
 
+export const ChatHistorySourceSchema = z.object({
+  serverId: z.string(),
+  agentId: z.string(),
+  title: z.string().optional(),
+});
+
+export type ChatHistorySource = z.infer<typeof ChatHistorySourceSchema>;
+
+export const ChatHistoryAttachmentSchema = z.object({
+  type: z.literal("text"),
+  mimeType: z.literal("text/plain"),
+  contextKind: z.literal("chat_history"),
+  title: z.string().nullable().optional(),
+  text: z.string(),
+  chatHistorySource: ChatHistorySourceSchema.optional(),
+});
+
+export type ChatHistoryAttachment = z.infer<typeof ChatHistoryAttachmentSchema>;
+
 // zod-aot 0.20.4 miscompiles this as a nested discriminated union by omitting
 // the inner tool_call branch from the generated outer dispatch.
 export const AgentTimelineItemPayloadSchema: z.ZodType<AgentTimelineItem, unknown> = z.union([
@@ -720,6 +739,7 @@ export const AgentTimelineItemPayloadSchema: z.ZodType<AgentTimelineItem, unknow
     text: z.string(),
     messageId: z.string().optional(),
     clientMessageId: z.string().optional(),
+    chatHistory: ChatHistoryAttachmentSchema.optional(),
   }),
   z.object({
     type: z.literal("assistant_message"),
@@ -1180,6 +1200,7 @@ export const TextAttachmentSchema = z
     title: z.string().nullable().optional(),
     text: z.string(),
     externalResource: ExternalResourceAttachmentMetadataSchema.optional(),
+    chatHistorySource: ChatHistorySourceSchema.optional(),
   })
   .transform(({ contextKind, ...attachment }) => ({
     ...attachment,
@@ -4189,6 +4210,8 @@ export const WorkspaceGitHubRuntimePayloadSchema = z
 
 export const WorkspaceDescriptorPayloadSchema = z
   .object({
+    // Informational creation ancestry; independent of placement and lifecycle.
+    parentWorkspaceId: z.string().optional(),
     id: z.string(),
     projectId: z.string(),
     projectDisplayName: z.string(),

packages/protocol/src/messages.workspaces.test.ts

@@ -634,6 +634,26 @@ describe("workspace message schemas", () => {
     ]);
   });
 
+  test("preserves informational workspace parentage in directory updates", () => {
+    const workspace = {
+      id: "child",
+      parentWorkspaceId: "parent",
+      projectId: "project",
+      projectDisplayName: "repo",
+      projectRootPath: "/repo",
+      projectKind: "git",
+      workspaceKind: "worktree",
+      name: "child",
+      status: "done",
+      activityAt: null,
+    };
+    expect(WorkspaceDescriptorPayloadSchema.parse(workspace).parentWorkspaceId).toBe("parent");
+    expect(
+      WorkspaceDescriptorPayloadSchema.parse({ ...workspace, parentWorkspaceId: undefined })
+        .parentWorkspaceId,
+    ).toBeUndefined();
+  });
+
   test("parses legacy workspace descriptors without workspaceDirectory", () => {
     const parsed = SessionOutboundMessageSchema.parse({
       type: "workspace_update",

packages/server/scripts/dictation-generate-baseline.ts

@@ -33,9 +33,9 @@ async function main(): Promise<void> {
 
   const apiKey = requireEnv("OPENAI_API_KEY");
   const transcriptionModel = process.env.STT_MODEL ?? "gpt-4o-transcribe";
-  // Mirrors the daemon: no built-in prompt, only an explicit override. Whisper
-  // treats `prompt` as preceding transcript, so a default would bias the baseline.
-  const prompt = process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT?.trim() || undefined;
+  const prompt =
+    process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT ??
+    "Transcribe only what the speaker says. Do not add words. Preserve punctuation and casing. If the audio is silence or non-speech noise, return an empty transcript.";
 
   const openai = new OpenAI({ apiKey });
 
@@ -43,7 +43,7 @@ async function main(): Promise<void> {
     file: await import("node:fs").then((fs) => fs.createReadStream(audioPath)),
     language: "en",
     model: transcriptionModel,
-    ...(prompt ? { prompt } : {}),
+    prompt,
     response_format: "json",
     // Aim for determinism.
     temperature: 0,

packages/server/src/server/agent/activity-curator.test.ts

@@ -572,3 +572,57 @@ it("preserves every message in fork history below the character budget", () => {
     `<chat-history-summary>\nChat history from a previous Paseo agent.\n\n[User] ${text}\n</chat-history-summary>`,
   );
 });
+
+it.each(["", "Continue in B"])("carries inherited history through repeated forks (%s)", (text) => {
+  const original = buildAgentForkContextAttachment({
+    rows: [
+      row(1, { type: "user_message", text: "Question in A" }),
+      row(2, { type: "assistant_message", text: "Answer in A" }),
+    ],
+  });
+  const child = buildAgentForkContextAttachment({
+    rows: [
+      row(1, {
+        type: "user_message",
+        text,
+        chatHistory: { ...original.attachment, contextKind: "chat_history" },
+      }),
+      row(2, { type: "assistant_message", text: "Answer in B" }),
+    ],
+  });
+  const grandchild = buildAgentForkContextAttachment({
+    rows: [
+      row(1, {
+        type: "user_message",
+        text: "Continue in C",
+        chatHistory: { ...child.attachment, contextKind: "chat_history" },
+      }),
+      row(2, { type: "assistant_message", text: "Answer in C" }),
+    ],
+  });
+  expect(grandchild.attachment.text).toContain("[User] Question in A\n[Assistant] Answer in A");
+  expect(grandchild.attachment.text).toContain("[Assistant] Answer in B");
+  expect(grandchild.attachment.text).toContain("[User] Continue in C\n[Assistant] Answer in C");
+  expect(grandchild.attachment.text.match(/<chat-history-summary>/g)).toHaveLength(1);
+});
+
+it("keeps the fork budget when inherited history exceeds the remaining space", () => {
+  const result = buildAgentForkContextAttachment({
+    rows: [
+      row(1, {
+        type: "user_message",
+        text: "Current question",
+        chatHistory: {
+          type: "text",
+          mimeType: "text/plain",
+          contextKind: "chat_history",
+          text: "Old ".repeat(30_000),
+        },
+      }),
+      row(2, { type: "assistant_message", text: "Latest answer" }),
+    ],
+  });
+  expect(result.attachment.text.length).toBeLessThanOrEqual(100_000);
+  expect(result.attachment.text).toContain("[Earlier chat history omitted]");
+  expect(result.attachment.text).toContain("[User] Current question\n[Assistant] Latest answer");
+});

packages/server/src/server/agent/activity-curator.ts

@@ -1,3 +1,4 @@
+import { extractChatHistoryBody } from "@getpaseo/protocol/chat-history";
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
 import type { AgentMessage } from "@getpaseo/protocol/agent-message";
 import type { AgentAttachment } from "@getpaseo/protocol/messages";
@@ -21,6 +22,7 @@ const FORK_CONTEXT_KINDS: readonly AgentTimelineItem["type"][] = [
 ];
 
 interface ActivityCuratorOptions {
+  includeChatHistory?: boolean;
   maxItems?: number;
   labelAssistantMessages?: boolean;
   includeKinds?: readonly AgentTimelineItem["type"][];
@@ -37,6 +39,17 @@ function activityEntry(text: string): ActivityEntry {
   return { text };
 }
 
+function appendUserEntry(
+  entries: ActivityEntry[],
+  item: Extract<AgentTimelineItem, { type: "user_message" }>,
+  options?: ActivityCuratorOptions,
+) {
+  if (options?.includeChatHistory && item.chatHistory) {
+    entries.push(activityEntry(extractChatHistoryBody(item.chatHistory.text)));
+  }
+  entries.push(activityEntry(`[User] ${item.text.trim()}`));
+}
+
 function appendTextEntry(
   entries: ActivityEntry[],
   item: Extract<AgentTimelineItem, { type: "assistant_message" | "reasoning" }>,
@@ -158,7 +171,7 @@ function curateProjectedActivityEntries(
 
     switch (item.type) {
       case "user_message":
-        entries.push(activityEntry(`[User] ${item.text.trim()}`));
+        appendUserEntry(entries, item, options);
         break;
       case "assistant_message":
       case "reasoning":
@@ -361,6 +374,7 @@ export function buildAgentForkContextAttachment(input: {
   });
   const entries = curateProjectedActivityEntries(selected.items, {
     maxItems: 0,
+    includeChatHistory: true,
     labelAssistantMessages: true,
     includeKinds: FORK_CONTEXT_KINDS,
     includeExternalToolInput: false,

packages/server/src/server/agent/agent-manager.test.ts

@@ -729,6 +729,159 @@ test("uses an injected timeline store without making it a production requirement
   }
 });
 
+test.each([true, false])(
+  "fork history survives storage-backed replay (provider echo: %s)",
+  async (echo) => {
+    const workdir = mkdtempSync(join(tmpdir(), "agent-manager-fork-history-"));
+    const storagePath = join(workdir, "agents");
+    const attachment = {
+      type: "text",
+      mimeType: "text/plain",
+      contextKind: "chat_history",
+      text: "<chat-history-summary>\nChat history from a previous Paseo agent.\n\n[User] Original question\n[Assistant] Original answer\n</chat-history-summary>",
+      chatHistorySource: { serverId: "source-host", agentId: "source-agent", title: "Original" },
+    } as const;
+    const clientMessageId = "fork-prompt";
+    let hasHistory = false;
+    let includeFork = true;
+    class HistorySession extends TestAgentSession {
+      override async startTurn(): Promise<{ turnId: string }> {
+        hasHistory = true;
+        if (echo)
+          this.pushEvent({
+            type: "timeline",
+            provider: "codex",
+            item: {
+              type: "user_message",
+              text: attachment.text,
+              messageId: "native-fork",
+              clientMessageId,
+            },
+          });
+        return super.startTurn();
+      }
+      override async *streamHistory(): AsyncGenerator<AgentStreamEvent> {
+        if (!hasHistory) return;
+        if (includeFork)
+          yield {
+            type: "timeline",
+            provider: "codex",
+            item: { type: "user_message", text: attachment.text, messageId: "native-fork" },
+          };
+        yield {
+          type: "timeline",
+          provider: "codex",
+          item: { type: "user_message", text: attachment.text, messageId: "native-later" },
+        };
+      }
+    }
+    class HistoryClient extends TestAgentClient {
+      override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
+        return new HistorySession(config);
+      }
+      override async resumeSession(): Promise<AgentSession> {
+        return new HistorySession({ provider: "codex", cwd: workdir });
+      }
+    }
+    const client = new HistoryClient();
+    let storage = new AgentStorage(storagePath, logger);
+    let manager = new AgentManager({ clients: { codex: client }, registry: storage, logger });
+    const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
+      workspaceId: undefined,
+    });
+    onTestFinished(async () => {
+      await manager.closeAgent(agent.id);
+      await manager.flush();
+      rmSync(workdir, { recursive: true, force: true });
+    });
+    await drainAsyncGenerator(manager.streamAgent(agent.id, [attachment], { clientMessageId }));
+    expect((await manager.getTimelineRows(agent.id))[0]?.item).toMatchObject({
+      type: "user_message",
+      text: "",
+      chatHistory: attachment,
+    });
+    await manager.closeAgent(agent.id);
+    await manager.flush();
+
+    storage = new AgentStorage(storagePath, logger);
+    manager = new AgentManager({ clients: { codex: client }, registry: storage, logger });
+    await ensureAgentLoaded(agent.id, { agentManager: manager, agentStorage: storage, logger });
+    await manager.hydrateTimelineFromProvider(agent.id);
+    expect((await manager.getTimelineRows(agent.id)).map((row) => row.item)).toEqual([
+      { type: "user_message", text: "", messageId: "native-fork", chatHistory: attachment },
+      { type: "user_message", text: attachment.text, messageId: "native-later" },
+    ]);
+    // A provider rewind must not recreate a removed fork prompt.
+    includeFork = false;
+    await manager.hydrateTimelineFromProvider(agent.id, { force: true });
+    expect((await manager.getTimelineRows(agent.id)).map((row) => row.item)).toEqual([
+      { type: "user_message", text: attachment.text, messageId: "native-later" },
+    ]);
+  },
+);
+
+test.each([undefined, "native-replay-id"])(
+  "restores fork history after a local submission echo and replay ID %s",
+  async (replayId) => {
+    const workdir = mkdtempSync(join(tmpdir(), "fork-local-echo-"));
+    const clientMessageId = "local-fork-prompt";
+    const attachment = {
+      type: "text",
+      mimeType: "text/plain",
+      contextKind: "chat_history",
+      text: "[User] Original question",
+    } as const;
+    class LocalEchoSession extends TestAgentSession {
+      override async startTurn(): Promise<{ turnId: string }> {
+        this.pushEvent({
+          type: "timeline",
+          provider: "codex",
+          item: {
+            type: "user_message",
+            text: attachment.text,
+            messageId: clientMessageId,
+            clientMessageId,
+          },
+        });
+        return super.startTurn();
+      }
+      override async *streamHistory(): AsyncGenerator<AgentStreamEvent> {
+        yield {
+          type: "timeline",
+          provider: "codex",
+          item: {
+            type: "user_message",
+            text: attachment.text,
+            ...(replayId ? { messageId: replayId } : {}),
+          },
+        };
+      }
+    }
+    class LocalEchoClient extends TestAgentClient {
+      override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
+        return new LocalEchoSession(config);
+      }
+    }
+    const manager = new AgentManager({ clients: { codex: new LocalEchoClient() }, logger });
+    const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
+      workspaceId: undefined,
+    });
+    try {
+      await drainAsyncGenerator(manager.streamAgent(agent.id, [attachment], { clientMessageId }));
+      await manager.hydrateTimelineFromProvider(agent.id, { force: true });
+      expect((await manager.getTimelineRows(agent.id))[0]?.item).toMatchObject({
+        type: "user_message",
+        text: "",
+        chatHistory: attachment,
+      });
+    } finally {
+      await manager.closeAgent(agent.id);
+      await manager.flush();
+      rmSync(workdir, { recursive: true, force: true });
+    }
+  },
+);
+
 test("refreshing an agent replaces the injected timeline store instead of appending a second copy", async () => {
   const workdir = mkdtempSync(join(tmpdir(), "agent-manager-timeline-rehydrate-"));
   const store = new RecordingTimelineStore();

packages/server/src/server/agent/agent-manager.ts

@@ -441,6 +441,7 @@ interface HandleStreamEventOptions {
 }
 
 interface ManagedAgentBase {
+  forkContext?: StoredAgentRecord["forkContext"];
   id: string;
   provider: AgentProvider;
   cwd: string;
@@ -2701,11 +2702,15 @@ export class AgentManager {
       if (event.type === "timeline") {
         this.touchUpdatedAt(agent);
         const row = this.recordTimeline(agent.id, event.item);
-        this.dispatchStream(agent.id, event, {
-          seq: row.seq,
-          epoch: this.timelineStore.getEpoch(agent.id),
-          timestamp: row.timestamp,
-        });
+        this.dispatchStream(
+          agent.id,
+          { ...event, item: row.item },
+          {
+            seq: row.seq,
+            epoch: this.timelineStore.getEpoch(agent.id),
+            timestamp: row.timestamp,
+          },
+        );
         return;
       }
       this.dispatchStream(agent.id, event, { timestamp: new Date().toISOString() });
@@ -3919,6 +3924,8 @@ export class AgentManager {
         options,
       });
 
+      await this.restoreForkContext(managed);
+
       // Read history before publishing the agent: a provider failure must leave the
       // session unregistered so the registration catch closes it.
       const startupHistory: AgentStreamEvent[] = [];
@@ -4491,11 +4498,15 @@ export class AgentManager {
         event.timestamp ? { timestamp: event.timestamp } : undefined,
       );
       if (broadcastTimeline) {
-        this.dispatchStream(agent.id, event, {
-          seq: row.seq,
-          epoch: this.timelineStore.getEpoch(agent.id),
-          timestamp: row.timestamp,
-        });
+        this.dispatchStream(
+          agent.id,
+          { ...event, item: row.item },
+          {
+            seq: row.seq,
+            epoch: this.timelineStore.getEpoch(agent.id),
+            timestamp: row.timestamp,
+          },
+        );
       }
     }
     this.touchUpdatedAt(agent);
@@ -4560,13 +4571,17 @@ export class AgentManager {
         event.timestamp ? { timestamp: event.timestamp } : undefined,
       );
       if (deferredBroadcast) {
-        timelineEvents.push({ event, row });
+        timelineEvents.push({ event: { ...event, item: row.item }, row });
       } else if (broadcast) {
-        this.dispatchStream(agent.id, event, {
-          seq: row.seq,
-          epoch: this.timelineStore.getEpoch(agent.id),
-          timestamp: row.timestamp,
-        });
+        this.dispatchStream(
+          agent.id,
+          { ...event, item: row.item },
+          {
+            seq: row.seq,
+            epoch: this.timelineStore.getEpoch(agent.id),
+            timestamp: row.timestamp,
+          },
+        );
       }
     }
     agent.historyPrimed = true;
@@ -5101,7 +5116,7 @@ export class AgentManager {
     const row = this.recordTimeline(agentId, item, { ...options, turnId });
     const event: AgentStreamEvent = {
       type: "timeline",
-      item,
+      item: row.item,
       provider,
       ...(turnId !== undefined ? { turnId } : {}),
     };
@@ -5133,9 +5148,25 @@ export class AgentManager {
     outcome: "accepted" | "rejected",
     options?: { messageId?: string; providerMessageId?: string; turnId?: string },
   ): void {
+    const text = submittedPromptText(prompt);
+    if (typeof prompt !== "string") {
+      const attachment = prompt.find(
+        (block) =>
+          block.type === "text" && "contextKind" in block && block.contextKind === "chat_history",
+      );
+      if (attachment?.type === "text" && "mimeType" in attachment) {
+        agent.forkContext = {
+          clientMessageId,
+          providerMessageId:
+            options?.providerMessageId !== clientMessageId ? options?.providerMessageId : undefined,
+          text,
+          attachment: { ...attachment, contextKind: "chat_history" },
+        };
+      }
+    }
     const items = projectAgentMessages({
       type: "user_message",
-      text: submittedPromptText(prompt),
+      text,
       clientMessageId,
       ...(options?.messageId ? { messageId: options.messageId } : {}),
     });
@@ -5183,6 +5214,10 @@ export class AgentManager {
     }
     if (!existing || existing.item.type !== "user_message") return null;
     if (messageId) {
+      if (agent.forkContext?.clientMessageId === clientMessageId && messageId !== clientMessageId) {
+        agent.forkContext.providerMessageId = messageId;
+        this.enqueueBackgroundPersist(agent);
+      }
       const enriched = this.timelineStore.enrichSubmittedUserMessage(
         agent.id,
         clientMessageId,
@@ -5247,6 +5282,10 @@ export class AgentManager {
     return parts.join("\n\n");
   }
 
+  private async restoreForkContext(agent: ManagedAgent): Promise<void> {
+    agent.forkContext = (await this.registry?.get(agent.id))?.forkContext;
+  }
+
   private recordTimeline(
     agentId: string,
     item: AgentTimelineItem,
@@ -5256,6 +5295,29 @@ export class AgentManager {
       turnId?: string;
     },
   ): AgentTimelineRow {
+    const agent = this.agents.get(agentId);
+    const context = agent?.forkContext;
+    if (
+      context &&
+      item.type === "user_message" &&
+      (item.clientMessageId === context.clientMessageId ||
+        (context.providerMessageId
+          ? item.messageId === context.providerMessageId
+          : context.attachment.text.length > 0 && item.text.includes(context.attachment.text)))
+    ) {
+      // Providers without client IDs can be matched once by the exact snapshot.
+      // Remember their native ID so a later quotation is not mistaken for the fork.
+      if (
+        agent &&
+        !context.providerMessageId &&
+        item.messageId &&
+        item.messageId !== context.clientMessageId
+      ) {
+        context.providerMessageId = item.messageId;
+        this.enqueueBackgroundPersist(agent);
+      }
+      item = { ...item, text: context.text, chatHistory: context.attachment };
+    }
     item = limitAgentTimelineItemContent(item);
     const row = this.timelineStore.append(agentId, item, options);
     this.enqueueDurableTimelineAppend(agentId, row);

packages/server/src/server/agent/agent-projections.ts

@@ -92,6 +92,7 @@ export function toStoredAgentRecord(
     lastUserMessageAt: agent.lastUserMessageAt ? agent.lastUserMessageAt.toISOString() : null,
     title: options?.title ?? null,
     labels: agent.labels,
+    forkContext: agent.forkContext,
     lastStatus: agent.lifecycle,
     lastModeId: agent.currentModeId ?? config?.modeId ?? null,
     config: config ?? null,

packages/server/src/server/agent/agent-sdk-types.ts

@@ -9,7 +9,7 @@ import type {
   ToolPolicy,
 } from "@getpaseo/protocol/agent-types";
 import type { AgentMessage } from "@getpaseo/protocol/agent-message";
-import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import type { AgentAttachment, ChatHistoryAttachment } from "@getpaseo/protocol/messages";
 import type { PaseoToolCatalog } from "./tools/types.js";
 
 export type {
@@ -398,7 +398,13 @@ export interface PluginTimelineItem {
 }
 
 export type AgentTimelineItem =
-  | { type: "user_message"; text: string; messageId?: string; clientMessageId?: string }
+  | {
+      type: "user_message";
+      text: string;
+      messageId?: string;
+      clientMessageId?: string;
+      chatHistory?: ChatHistoryAttachment;
+    }
   | { type: "assistant_message"; text: string; messageId?: string }
   | { type: "reasoning"; text: string }
   | ToolCallTimelineItem

packages/server/src/server/agent/agent-storage.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import type { Logger } from "pino";
 
 import { writeJsonFileAtomic } from "../atomic-file.js";
-import { AgentFeatureSchema, AgentStatusSchema } from "../messages.js";
+import { AgentFeatureSchema, AgentStatusSchema, ChatHistoryAttachmentSchema } from "../messages.js";
 import { toStoredAgentRecord } from "./agent-projections.js";
 import type { ManagedAgent } from "./agent-manager.js";
 import type { AgentSessionConfig } from "./agent-sdk-types.js";
@@ -53,6 +53,15 @@ const STORED_AGENT_SCHEMA = z.object({
   lastUserMessageAt: z.string().nullable().optional(),
   title: z.string().nullable().optional(),
   labels: z.record(z.string(), z.string()).default({}),
+  // Provider transcripts retain the rendered prompt, not attachment metadata.
+  forkContext: z
+    .object({
+      clientMessageId: z.string(),
+      providerMessageId: z.string().optional(),
+      text: z.string(),
+      attachment: ChatHistoryAttachmentSchema,
+    })
+    .optional(),
   lastStatus: AgentStatusSchema.default("closed"),
   resumeOnStartup: z.boolean().optional(),
   lastModeId: z.string().nullable().optional(),

packages/server/src/server/agent/mcp-parity.e2e.test.ts

@@ -1171,7 +1171,7 @@ describe("Suite E: Workspace Tools", () => {
         .callTool({ name: "archive_workspace", args: { workspaceId } })
         .catch(() => undefined);
     }
-  });
+  }, 30_000);
 
   test("agent-scoped workspace creation inherits visibility and permits an explicit false override", async () => {
     const parentWorkspace = await callToolStructured(topLevelClient, "create_workspace", {
@@ -1197,12 +1197,43 @@ describe("Suite E: Workspace Tools", () => {
       });
       ownedWorkspaces.push(str(inherited.workspaceId));
       expect(inherited.background).toBe(true);
+      expect(inherited.parentWorkspaceId).toBe(parentWorkspaceId);
       const visible = await callToolStructured(scoped, "create_workspace", {
         isolation: "local",
         background: false,
       });
       ownedWorkspaces.push(str(visible.workspaceId));
       expect(visible.background).toBe(false);
+      expect(visible.parentWorkspaceId).toBe(parentWorkspaceId);
+      const worktree = await callToolStructured(scoped, "create_workspace", {
+        isolation: "worktree",
+        branchName: "parentage-child",
+        baseBranch: "main",
+        background: false,
+      });
+      ownedWorkspaces.push(str(worktree.workspaceId));
+      expect(worktree.parentWorkspaceId).toBe(parentWorkspaceId);
+      const client = new DaemonClient({ url: `ws://127.0.0.1:${daemonHandle.port}/ws` });
+      try {
+        await client.connect();
+        const created = await client.createWorkspace({
+          source: { kind: "directory", path: worktreeRepoCwd },
+          callerAgentId: str(parent.agentId),
+          background: false,
+        });
+        const workspaceId = str(created.workspace?.id);
+        ownedWorkspaces.push(workspaceId);
+        expect(created.workspace?.parentWorkspaceId).toBe(parentWorkspaceId);
+        const listed = await client.fetchWorkspaces();
+        expect(listed.entries).toContainEqual(
+          expect.objectContaining({
+            id: workspaceId,
+            parentWorkspaceId: parentWorkspaceId,
+          }),
+        );
+      } finally {
+        await client.close();
+      }
     } finally {
       await scoped?.close();
       for (const workspaceId of ownedWorkspaces.toReversed())
@@ -1210,7 +1241,7 @@ describe("Suite E: Workspace Tools", () => {
           .callTool({ name: "archive_workspace", args: { workspaceId } })
           .catch(() => undefined);
     }
-  });
+  }, 30_000);
 
   test("a background agent's children and workspaces are background unless it overrides", async () => {
     const visibleAgentId = await createTopLevelAgent();

packages/server/src/server/agent/tools/paseo-tools.ts

@@ -188,6 +188,7 @@ interface ProviderSummary {
 }
 
 const WorkspaceAutomationSummarySchema = z.object({
+  parentWorkspaceId: z.string().optional(),
   workspaceId: z.string(),
   projectId: z.string(),
   cwd: z.string(),
@@ -206,6 +207,7 @@ function toWorkspaceAutomationSummary(workspace: PersistedWorkspaceRecord) {
     kind: workspace.kind,
     title: workspace.title,
     background: workspace.background,
+    parentWorkspaceId: workspace.parentWorkspaceId,
   };
 }
 

packages/server/src/server/dictation/dictation-stream-manager.test.ts

@@ -57,13 +57,11 @@ class FakeRealtimeSession extends EventEmitter implements StreamingTranscription
 class FakeSttProvider implements SpeechToTextProvider {
   public readonly id = "fake";
   public lastLanguage?: string;
-  public lastPrompt?: string;
   constructor(private readonly session: FakeRealtimeSession) {}
   createSession(
     params: Parameters<SpeechToTextProvider["createSession"]>[0],
   ): StreamingTranscriptionSession {
     this.lastLanguage = params.language;
-    this.lastPrompt = params.prompt;
     return this.session;
   }
 }
@@ -596,58 +594,3 @@ it("closes every dictation stream when one provider cleanup fails", async () =>
   expect(second.closed).toBe(true);
   expect(manager.hasDemand).toBe(false);
 });
-
-describe("DictationStreamManager (transcription prompt)", () => {
-  const originalPromptEnv = process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT;
-
-  afterEach(() => {
-    if (originalPromptEnv === undefined) {
-      delete process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT;
-    } else {
-      process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT = originalPromptEnv;
-    }
-  });
-
-  const startDictation = async (
-    options: { language?: string } = {},
-  ): Promise<{ provider: FakeSttProvider; manager: DictationStreamManager }> => {
-    const session = new FakeRealtimeSession();
-    const provider = new FakeSttProvider(session);
-    const manager = new DictationStreamManager({
-      logger: pino({ level: "silent" }),
-      emit: () => {},
-      sessionId: "prompt",
-      stt: provider,
-      ...(options.language ? { language: options.language } : {}),
-    });
-    await manager.handleStart("d1", "audio/pcm;rate=24000;bits=16");
-    manager.cleanupAll();
-    return { provider, manager };
-  };
-
-  it("sends no prompt by default", async () => {
-    delete process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT;
-    const { provider } = await startDictation();
-    expect(provider.lastPrompt).toBeUndefined();
-  });
-
-  it("sends no prompt for non-English dictation by default", async () => {
-    delete process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT;
-    const { provider } = await startDictation({ language: "zh" });
-    expect(provider.lastLanguage).toBe("zh");
-    expect(provider.lastPrompt).toBeUndefined();
-  });
-
-  it("passes an explicit prompt override through", async () => {
-    process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT =
-      "  Vocabulary: Paseo, Dokploy, Kubernetes.  ";
-    const { provider } = await startDictation();
-    expect(provider.lastPrompt).toBe("Vocabulary: Paseo, Dokploy, Kubernetes.");
-  });
-
-  it.each(["", "   "])("treats a blank override (%j) as no prompt", async (value) => {
-    process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT = value;
-    const { provider } = await startDictation();
-    expect(provider.lastPrompt).toBeUndefined();
-  });
-});

packages/server/src/server/dictation/dictation-stream-manager.ts

@@ -38,12 +38,6 @@ function parseNonNegativeNumber(value: string | undefined): number | null {
   return parsed;
 }
 
-/** Unset, empty, and whitespace-only overrides all mean "send no prompt". */
-function readTranscriptionPromptOverride(env: NodeJS.ProcessEnv): string | undefined {
-  const value = env.PASEO_DICTATION_TRANSCRIPTION_PROMPT?.trim();
-  return value ? value : undefined;
-}
-
 function convertPCMToWavBuffer(
   pcmBuffer: Buffer,
   sampleRate: number,
@@ -191,16 +185,16 @@ export class DictationStreamManager {
       return;
     }
 
-    // Whisper uses the prompt as transcript context, not silence instructions.
-    // Keep context opt-in so it does not bias speech or introduce unspoken text.
-    const transcriptionPrompt = readTranscriptionPromptOverride(process.env);
+    const transcriptionPrompt =
+      process.env.PASEO_DICTATION_TRANSCRIPTION_PROMPT ??
+      "Transcribe only what the speaker says. Do not add words. Preserve punctuation and casing. If the audio is silence or non-speech noise, return an empty transcript.";
 
     let stt: ReturnType<SpeechToTextProvider["createSession"]>;
     try {
       stt = sttProvider.createSession({
         logger: this.logger.child({ dictationId }),
         language: this.language,
-        ...(transcriptionPrompt ? { prompt: transcriptionPrompt } : {}),
+        prompt: transcriptionPrompt,
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);

packages/server/src/server/session.ts

@@ -5900,6 +5900,7 @@ export class Session {
       pinnedAt: workspace.pinnedAt,
       ...(workspace.labels && workspace.labels.length > 0 ? { labels: workspace.labels } : {}),
       background: workspace.background,
+      parentWorkspaceId: workspace.parentWorkspaceId,
       archivingAt: null,
       status: "done",
       statusEnteredAt: null,
@@ -5988,6 +5989,7 @@ export class Session {
       projectKind: projectRecord?.kind ?? "git",
       workspaceKind: result.workspace.kind,
       background: result.workspace.background,
+      parentWorkspaceId: result.workspace.parentWorkspaceId,
       name: resolveWorkspaceName({
         title: result.workspace.title,
         derivedDisplayName: result.worktree.branchName || result.workspace.displayName,

packages/server/src/server/session/workspace-provisioning/workspace-provisioning-service.test.ts

@@ -205,6 +205,82 @@ test("fresh non-git directory creates a directory workspace at the exact path",
   expect(workspace.cwd).toBe(dir);
 });
 
+test("workspace parentage survives reload and parent archive without changing placement", async () => {
+  const cwd = path.join(tmpDir, "plain");
+  const parent = await provisioning.createWorkspaceForDirectory(cwd);
+  const child = await provisioning.createWorkspaceForDirectory(cwd, null, undefined, {
+    callerWorkspaceId: parent.workspaceId,
+    background: false,
+  });
+  const grandchild = await provisioning.createWorkspaceForDirectory(
+    path.join(tmpDir, "other"),
+    null,
+    undefined,
+    {
+      callerWorkspaceId: child.workspaceId,
+    },
+  );
+  expect(parent.parentWorkspaceId).toBeUndefined();
+  expect(child).toMatchObject({ parentWorkspaceId: parent.workspaceId, cwd });
+  expect(grandchild).toMatchObject({ parentWorkspaceId: child.workspaceId });
+  await workspaceRegistry.archive(parent.workspaceId, ARCHIVED_AT);
+  const reloaded = new FileBackedWorkspaceRegistry(
+    path.join(tmpDir, "projects", "workspaces.json"),
+    logger,
+  );
+  await reloaded.initialize();
+  expect(await reloaded.get(child.workspaceId)).toMatchObject({
+    parentWorkspaceId: parent.workspaceId,
+    archivedAt: null,
+  });
+  expect(await reloaded.get(grandchild.workspaceId)).toMatchObject({
+    parentWorkspaceId: child.workspaceId,
+    archivedAt: null,
+  });
+});
+
+test("worktree workspace creation records its caller independently of its source project", async () => {
+  const sourceCwd = path.join(tmpDir, "repo");
+  gitRoots.add(sourceCwd);
+  const parent = await provisioning.createWorkspaceForDirectory(path.join(tmpDir, "other"));
+  const child = await provisioning.createWorkspaceForWorktree({
+    sourceCwd,
+    repoRoot: sourceCwd,
+    cwd: path.join(tmpDir, "worktree"),
+    worktreeRoot: path.join(tmpDir, "worktree"),
+    branch: "child",
+    baseBranch: "main",
+    title: null,
+    callerWorkspaceId: parent.workspaceId,
+  });
+  expect(child.parentWorkspaceId).toBe(parent.workspaceId);
+  expect(child.projectId).not.toBe(parent.projectId);
+  expect(await workspaceRegistry.get(child.workspaceId)).toMatchObject({
+    parentWorkspaceId: parent.workspaceId,
+  });
+});
+
+test("workspace creation rejects an unknown caller even with explicit visibility", async () => {
+  await expect(
+    provisioning.createWorkspaceForDirectory(path.join(tmpDir, "plain"), null, undefined, {
+      callerWorkspaceId: "missing",
+      background: false,
+    }),
+  ).rejects.toThrow("Caller workspace missing not found");
+});
+
+test("workspace creation cannot overwrite its caller with a self relationship", async () => {
+  const cwd = path.join(tmpDir, "plain");
+  const parent = await provisioning.createWorkspaceForDirectory(cwd);
+  await expect(
+    provisioning.createWorkspaceForDirectory(cwd, null, undefined, {
+      callerWorkspaceId: parent.workspaceId,
+      workspaceId: parent.workspaceId,
+    }),
+  ).rejects.toThrow("A workspace cannot be its own parent");
+  expect(await workspaceRegistry.get(parent.workspaceId)).toEqual(parent);
+});
+
 test("background workspace creation preserves hooks, inheritance and durable visibility", async () => {
   const dir = path.join(tmpDir, "plain");
   const events: string[] = [];

packages/server/src/server/session/workspace-provisioning/workspace-provisioning-service.ts

@@ -227,15 +227,21 @@ export function createWorkspaceProvisioningService(deps: {
     return project;
   }
 
-  async function resolveBackground(input?: {
+  async function resolveCreationMetadata(input?: {
+    workspaceId?: string;
     background?: boolean;
     callerWorkspaceId?: string;
-  }): Promise<boolean> {
-    if (input?.background !== undefined) return input.background;
-    if (!input?.callerWorkspaceId) return false;
+  }): Promise<{ background: boolean; parentWorkspaceId?: string }> {
+    if (!input?.callerWorkspaceId) return { background: input?.background ?? false };
+    if (input.workspaceId === input.callerWorkspaceId) {
+      throw new Error("A workspace cannot be its own parent");
+    }
     const callerWorkspace = await workspaceRegistry.get(input.callerWorkspaceId);
     if (!callerWorkspace) throw new Error(`Caller workspace ${input.callerWorkspaceId} not found`);
-    return callerWorkspace.background;
+    return {
+      background: input.background ?? callerWorkspace.background,
+      parentWorkspaceId: callerWorkspace.workspaceId,
+    };
   }
 
   async function createWorkspaceForDirectory(
@@ -269,7 +275,7 @@ export function createWorkspaceProvisioningService(deps: {
         title: title?.trim() || null,
         createdAt: timestamp,
         updatedAt: timestamp,
-        background: await resolveBackground(context),
+        ...(await resolveCreationMetadata(context)),
       });
       await workspaceRegistry.upsert(workspace, {
         expectsInitialAgent: context?.expectsInitialAgent,
@@ -310,7 +316,7 @@ export function createWorkspaceProvisioningService(deps: {
       createdAt: timestamp,
       updatedAt: timestamp,
       ...(input.untrustedSource ? { untrustedSource: input.untrustedSource } : {}),
-      background: await resolveBackground(input),
+      ...(await resolveCreationMetadata(input)),
     });
     await workspaceRegistry.upsert(workspace, {
       expectsInitialAgent: input.expectsInitialAgent,

packages/server/src/server/workspace-registry.ts

@@ -49,6 +49,7 @@ const PersistedProjectRecordSchema = z.object({
 });
 
 const PersistedWorkspaceRecordSchema = z.object({
+  parentWorkspaceId: z.string().optional(),
   workspaceId: z.string(),
   projectId: z.string(),
   cwd: z.string(),
@@ -679,6 +680,7 @@ export function resolveProjectDisplayName(record: PersistedProjectRecord): strin
 }
 
 export function createPersistedWorkspaceRecord(input: {
+  parentWorkspaceId?: string;
   workspaceId: string;
   projectId: string;
   cwd: string;

public-docs/voice.md

@@ -142,19 +142,8 @@ Keys and base URLs follow the fallback rule above.
 - `PASEO_VOICE_LOCAL_STT_MODEL`, `PASEO_VOICE_LOCAL_TTS_MODEL`, local voice STT/TTS model IDs
 - `PASEO_DICTATION_LANGUAGE`, dictation STT language
 - `PASEO_VOICE_LANGUAGE`, voice mode STT language; falls back to `PASEO_DICTATION_LANGUAGE` when unset
-- `PASEO_DICTATION_TRANSCRIPTION_PROMPT`, optional OpenAI dictation transcription prompt (including compatible servers). Unset by default; empty or whitespace-only is treated as unset
 - `PASEO_VOICE_LOCAL_TTS_SPEAKER_ID`, `PASEO_VOICE_LOCAL_TTS_SPEED`, optional local voice TTS tuning
 
-## Transcription Prompt
-
-With the OpenAI provider, including compatible servers, Paseo sends no transcription prompt by default. Whisper-family models use `prompt` as transcript context, so instruction text can distort the transcript or bias its language. Omitting it does not prevent every hallucination on silence or noise.
-
-For OpenAI dictation, set `PASEO_DICTATION_TRANSCRIPTION_PROMPT` to send a prompt explicitly, for example to bias toward project vocabulary. An empty or whitespace-only value means no prompt. Local providers ignore this setting, and voice mode never sends a prompt.
-
-```bash
-PASEO_DICTATION_TRANSCRIPTION_PROMPT="Vocabulary: Paseo, TypeScript."
-```
-
 ## Operational Notes
 
 Voice mode can launch and control agents. Treat voice prompts with the same care as direct agent instructions, especially when specifying working directories or destructive operations.

public-docs/voice.zh-CN.md

@@ -120,19 +120,8 @@ Paseo 在配置的 OpenAI base URL 下使用以下路径：
 - `PASEO_VOICE_LOCAL_STT_MODEL`、`PASEO_VOICE_LOCAL_TTS_MODEL`：本地语音 STT/TTS 模型 ID
 - `PASEO_DICTATION_LANGUAGE`：口述 STT 语言（仅限 OpenAI STT；本地 Parakeet 会忽略）
 - `PASEO_VOICE_LANGUAGE`：语音模式 STT 语言；未设置时退回到 `PASEO_DICTATION_LANGUAGE`（仅限 OpenAI STT；本地 Parakeet 会忽略）
-- `PASEO_DICTATION_TRANSCRIPTION_PROMPT`：可选的 OpenAI 口述转录提示词（包括兼容服务器）。默认不设置；空值或仅含空白字符的值视为未设置
 - `PASEO_VOICE_LOCAL_TTS_SPEAKER_ID`、`PASEO_VOICE_LOCAL_TTS_SPEED`：可选的本地语音 TTS 调优
 
-## 转录提示词 {#transcription-prompt}
-
-使用 OpenAI Provider（包括兼容服务器）进行口述时，Paseo 默认不发送转录提示词。Whisper 系列模型把 `prompt` 当作转录上下文，因此指令文本可能使转录失真或影响输出语言。不发送提示词也无法消除静音或噪声中的所有幻觉。
-
-对于 OpenAI 口述，可以设置 `PASEO_DICTATION_TRANSCRIPTION_PROMPT` 来显式发送提示词，例如提示项目术语。空值或仅含空白字符的值表示不发送提示词。本地 Provider 会忽略此设置，语音模式也不会发送提示词。
-
-```bash
-PASEO_DICTATION_TRANSCRIPTION_PROMPT="Vocabulary: Paseo, TypeScript."
-```
-
 ## 使用须知 {#operational-notes}
 
 语音模式可以启动和控制 Agent。请像对待直接的 Agent 指令一样谨慎对待语音提示词，尤其是在指定工作目录或执行破坏性操作时。