fix(app): keep autonomous turns distinct and readable

Hidden system prompts merged autonomous work into the previous response and reopened completed turns. Preserve canonical turn boundaries and expose their triggers, while making received messages attributable and expanded turn details readable in one step.

docs/plugins.md

@@ -432,9 +432,6 @@ Server entries register lifecycle observers with `server.on()` and request trans
 `server.before()`. The [public reference](../public-docs/plugins/reference.md#lifecycle-hooks)
 owns callback shapes, ordering, and failure behavior. `plugin-examples/lifecycle-logger` registers all
 eleven hooks; `plugin-examples/lifecycle-actions` demonstrates common automation callbacks.
-Session-open hooks also [attach tools to individual agents](../public-docs/plugins/reference.md#attach-tools-to-agents),
-as shown in `plugin-examples/agent-tools`. The agent manager stamps their metadata per session;
-executable definitions stay in the plugin process.
 
 Emit from the operation owner, not a client subscription. Provider history replay must not trigger
 live hooks. Observers must not be awaited inside agent mutations: a callback can send a prompt or

packages/app/e2e/browser/settings-toggle-tab-regression.spec.ts

@@ -1,4 +1,3 @@
-import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
 import { buildHostAgentDetailRoute, buildHostWorkspaceRoute } from "@/utils/host-routes";
 import { expect, test } from "../support/fixtures";
 import { createMockIdleAgent, openWorkspaceWithAgents } from "../support/helpers/archive-tab";
@@ -275,123 +274,3 @@ test.describe("Settings toggle tab regression", () => {
     }
   });
 });
-
-async function selectSendingOption(
-  page: import("@playwright/test").Page,
-  setting: string,
-  option: string,
-) {
-  await page.getByRole("button", { name: new RegExp(`^${setting}:`) }).click();
-  await page.getByRole("menuitem", { name: option, exact: true }).click();
-  await expect(
-    page.getByRole("button", { name: `${setting}: ${option}`, exact: true }),
-  ).toBeVisible();
-}
-
-async function sendDraftWithShortcut(
-  page: import("@playwright/test").Page,
-  draft: string,
-  shortcut: string,
-) {
-  const composer = page.getByRole("textbox", { name: "Message agent..." });
-  await composer.fill(draft);
-  await composer.press(shortcut);
-  await expect(composer).toHaveValue("");
-  await expect(page.getByText(draft, { exact: true })).toBeVisible();
-}
-
-test("send shortcut selection persists and controls the composer", async ({ page }, testInfo) => {
-  test.setTimeout(180_000);
-  const workspace = await seedWorkspace({ repoPrefix: "send-shortcut-" });
-  const modifierLabel = process.platform === "darwin" ? "⌘" : "Ctrl";
-  try {
-    const agent = await createMockIdleAgent(workspace.client, {
-      cwd: workspace.repoPath,
-      workspaceId: workspace.workspaceId,
-      title: "Send shortcut",
-    });
-    await openAgentRouteAndExpectFocused({
-      page,
-      serverId: getServerId(),
-      workspaceId: workspace.workspaceId,
-      agentId: agent.id,
-    });
-    await openComposerTab(page, agent.id);
-    const composer = page.getByRole("textbox", { name: "Message agent..." });
-
-    await test.step("Enter sends by default", async () => {
-      await sendDraftWithShortcut(page, "Default Enter submission", "Enter");
-    });
-    await test.step("choose the explicit modifier shortcut and retain it after reload", async () => {
-      await pressSettingsToggleShortcut(page);
-      await expect(
-        page.getByRole("button", { name: "Send shortcut: Enter", exact: true }),
-      ).toBeVisible();
-      await page.getByRole("button", { name: "Send shortcut: Enter", exact: true }).click();
-      await expect(page.getByRole("menuitem")).toHaveText(["Enter", `${modifierLabel}+Enter`]);
-      // Let the menu opening animation settle for visual QA.
-      await page.waitForTimeout(300);
-      await page.screenshot({ path: testInfo.outputPath("send-shortcut-selector.png") });
-      await page.getByRole("menuitem", { name: `${modifierLabel}+Enter`, exact: true }).click();
-      await page.reload();
-      await expect(
-        page.getByRole("button", { name: `Send shortcut: ${modifierLabel}+Enter`, exact: true }),
-      ).toBeVisible();
-      await pressSettingsToggleShortcut(page);
-      await expect(composer).toBeVisible();
-    });
-    await test.step("Enter and Shift+Enter keep editing; modifier Enter sends", async () => {
-      await composer.fill("First line");
-      await composer.press("Enter");
-      await expect(composer).toHaveValue("First line\n");
-      await composer.press("Shift+Enter");
-      await expect(composer).toHaveValue("First line\n\n");
-      await sendDraftWithShortcut(page, "Sent with Control", "Control+Enter");
-      await sendDraftWithShortcut(page, "Sent with Command", "Meta+Enter");
-    });
-    await test.step("switch back to Enter without changing the default send behavior", async () => {
-      await pressSettingsToggleShortcut(page);
-      await selectSendingOption(page, "Send shortcut", "Enter");
-      await pressSettingsToggleShortcut(page);
-      await composer.fill("Shift still edits");
-      await composer.press("Shift+Enter");
-      await expect(composer).toHaveValue("Shift still edits\n");
-      await sendDraftWithShortcut(page, "Restored Enter submission", "Enter");
-    });
-  } finally {
-    await workspace.cleanup();
-  }
-});
-
-for (const behavior of ["Steer", "Interrupt", "Queue"] as const) {
-  test(`modifier send shortcut follows ${behavior} while an agent runs`, async ({ page }) => {
-    const agent = await seedMockAgentWorkspace({
-      repoPrefix: "running-send-shortcut-",
-      title: "Running send shortcut",
-      model: "one-minute-stream",
-    });
-    const modifierLabel = process.platform === "darwin" ? "⌘" : "Ctrl";
-    try {
-      await openAgentRoute(page, agent);
-      await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeVisible();
-      await pressSettingsToggleShortcut(page);
-      await selectSendingOption(page, "Send shortcut", `${modifierLabel}+Enter`);
-      await selectSendingOption(page, "Default send", behavior);
-      await pressSettingsToggleShortcut(page);
-      await sendDraftWithShortcut(page, "Stay running while I write a follow-up", "Control+Enter");
-      await expect(page.getByRole("button", { name: "Stop agent", exact: true })).toBeVisible();
-      const composer = page.getByRole("textbox", { name: "Message agent..." });
-      await composer.fill("Follow-up");
-      await composer.press("Enter");
-      await expect(composer).toHaveValue("Follow-up\n");
-      await composer.press("Control+Enter");
-      await expect(composer).toHaveValue("");
-      await expect(page.getByText("Follow-up", { exact: true })).toBeVisible();
-      await expect(page.getByRole("button", { name: "Send queued message" })).toHaveCount(
-        behavior === "Queue" ? 1 : 0,
-      );
-    } finally {
-      await agent.cleanup();
-    }
-  });
-}

packages/app/e2e/browser/turn-collapse.spec.ts

@@ -1,3 +1,4 @@
+import { getActiveTabTestId } from "../support/helpers/launcher";
 import type { Page } from "@playwright/test";
 import { test, expect } from "../support/fixtures";
 import { expectComposerVisible } from "../support/helpers/composer";
@@ -19,7 +20,10 @@ async function seedAnsweredAgent(title: string) {
     initialPrompt: "Why does the chat stop following new output?",
   });
   await agent.client.waitForFinish(agent.agentId, 30_000);
-  await agent.client.sendAgentMessage(agent.agentId, "Make the fix and run the burst script.");
+  await agent.client.sendAgentMessage(
+    agent.agentId,
+    "Make the fix and run the burst script.\n" + "Keep the previous response visible.\n".repeat(40),
+  );
   await agent.client.waitForFinish(agent.agentId, 30_000);
   return agent;
 }
@@ -36,17 +40,67 @@ async function rowsBetweenLatestSummaryAndReply(page: Page): Promise<number> {
   });
 }
 
+async function groupedToolsInsideLatestTurn(page: Page): Promise<string[]> {
+  return page.evaluate(() => {
+    const rows = [...document.querySelectorAll("[data-message-id]")];
+    const start = rows.findLastIndex((row) => row.querySelector("[data-testid=turn-summary]"));
+    const end = rows.findLastIndex((row) => row.querySelector("[data-testid=assistant-message]"));
+    return rows
+      .slice(start + 1, end)
+      .flatMap((row) =>
+        [...row.querySelectorAll("[data-testid=tool-call-group]")].map(
+          (group) => group.textContent ?? "",
+        ),
+      );
+  });
+}
+
+async function expandAndCollapseLongPrompt(page: Page) {
+  const prompt = page.getByTestId("user-message").last();
+  const before = await prompt.boundingBox();
+  const text = prompt.locator('[data-message-text="true"]');
+  const messageLeft = (await text.boundingBox())!.x;
+  await expect
+    .poll(async () => (await prompt.getByText("Show more", { exact: true }).boundingBox())!.x)
+    .toBe(messageLeft);
+  await prompt.getByRole("button", { name: "Show more", exact: true }).click();
+  await expect(prompt.getByRole("button", { name: "Show less", exact: true })).toBeVisible();
+  await expect
+    .poll(async () => (await prompt.getByText("Show less", { exact: true }).boundingBox())!.x)
+    .toBe(messageLeft);
+  await expect
+    .poll(async () => (await prompt.boundingBox())?.height ?? 0)
+    .toBeGreaterThan(before!.height);
+  await prompt.getByRole("button", { name: "Show less", exact: true }).click();
+  await expect.poll(async () => (await prompt.boundingBox())?.height ?? 0).toBe(before!.height);
+  await prompt.scrollIntoViewIfNeeded();
+  const bounds = (await prompt.boundingBox())!;
+  const body = (await text.boundingBox())!;
+  await page.screenshot({
+    path: "/tmp/message-toggle-aligned.png",
+    clip: {
+      x: body.x - 16,
+      y: bounds.y,
+      width: bounds.x + bounds.width - body.x + 16,
+      height: bounds.height,
+    },
+  });
+}
+
 test.describe("Turn collapse", () => {
   test("folds each answered turn behind a summary line that opens it", async ({ page }) => {
     test.setTimeout(120_000);
+    await page.setViewportSize({ width: 1280, height: 1000 });
     await useChatDisplay(page, "collapseTurns");
     const agent = await seedAnsweredAgent("Turn collapse");
     try {
       await openAgentRoute(page, agent);
       await expectComposerVisible(page);
 
+      await expandAndCollapseLongPrompt(page);
+
       const summary = page.getByTestId("turn-summary").last().getByRole("button");
-      await expect(summary).toHaveText(/^Wrote \d+ messages?, edited 1 file/);
+      await expect(summary).toHaveText(/^Edited 1 file/);
       // Text chunks that stream back to back merge into one message, so the reply holds
       // at least the stream's last chunk.
       await expect(page.getByTestId("assistant-message").last()).toHaveText(
@@ -57,6 +111,9 @@ test.describe("Turn collapse", () => {
       await summary.click();
       await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBeGreaterThan(0);
       await expect(summary).toBeInViewport();
+      await summary.evaluate((element) => element.scrollIntoView({ block: "start" }));
+      await page.screenshot({ path: "/tmp/turn-rail-aligned.png" });
+      await expect.poll(() => groupedToolsInsideLatestTurn(page)).toEqual([]);
 
       await summary.click();
       await expect.poll(() => rowsBetweenLatestSummaryAndReply(page)).toBe(0);
@@ -65,3 +122,38 @@ test.describe("Turn collapse", () => {
     }
   });
 });
+
+test("received messages show their sender and open that agent", async ({ page }) => {
+  const recipient = await seedMockAgentWorkspace({
+    repoPrefix: "sender-attribution-",
+    title: "Implementation",
+  });
+  try {
+    const sender = await recipient.client.createAgent({
+      provider: "mock",
+      cwd: recipient.cwd,
+      workspaceId: recipient.workspaceId,
+      title: "Reviewer",
+      model: "e2e-fast-stream",
+      modeId: "load-test",
+    });
+    await recipient.client.sendAgentMessage(
+      recipient.agentId,
+      "I reviewed the turn-grouping changes. Heartbeats now keep their own timing footer, and the previous response stays visible.",
+      { sourceAgentId: sender.id },
+    );
+    await openAgentRoute(page, recipient);
+    await expectComposerVisible(page);
+    const attribution = page.getByRole("button", { name: "Sent by Reviewer", exact: true });
+    await expect(attribution).toBeVisible();
+    await expect(page.getByTestId("user-message").filter({ has: attribution })).toContainText(
+      "I reviewed the turn-grouping changes.",
+    );
+    await attribution.scrollIntoViewIfNeeded();
+    await page.screenshot({ path: "/tmp/sender-attribution.png" });
+    await attribution.click();
+    await expect.poll(() => getActiveTabTestId(page)).toContain(sender.id);
+  } finally {
+    await recipient.cleanup();
+  }
+});

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

@@ -149,7 +149,11 @@ export interface SeedDaemonClient {
     timeout?: number,
   ): Promise<{ status: string }>;
   cancelAgent(agentId: string): Promise<void>;
-  sendAgentMessage(agentId: string, text: string): Promise<void>;
+  sendAgentMessage(
+    agentId: string,
+    text: string,
+    options?: { sourceAgentId?: string },
+  ): Promise<void>;
   waitForFinish(
     agentId: string,
     timeout?: number,

packages/app/src/agent-stream/footer-spacing.test.ts

@@ -71,7 +71,7 @@ function layoutFor(input: { platform: "web" | "native"; isTurnActive: boolean })
       isTurnActive: input.isTurnActive,
       history: strategy.orderTail([userMessage("user"), assistant]),
       liveHead: [],
-      timingByAssistantId: timingFor(assistant.id),
+      timingByItemId: timingFor(assistant.id),
     }),
   };
 }

packages/app/src/agent-stream/layout.test.ts

@@ -104,7 +104,7 @@ function layoutFor(input: {
       strategy,
       streamHead: input.head ?? [],
     }),
-    timingByAssistantId: timingFor(...(input.timingIds ?? [])),
+    timingByItemId: timingFor(...(input.timingIds ?? [])),
   });
 }
 
@@ -148,7 +148,7 @@ function findLayoutItem(layout: StreamLayout, id: string): StreamLayoutItem {
 }
 
 describe("layoutStream", () => {
-  it("places one response footer after an adjacent tagged tool-only turn", () => {
+  it("keeps separate footers for an assistant turn and an adjacent tool-only turn", () => {
     const priorAssistant = assistantMessage("prior", 1, undefined, "turn-1");
     const nextTool = toolCall("next-tool", 2, "turn-2");
     const layout = layoutFor({
@@ -157,8 +157,8 @@ describe("layoutStream", () => {
       timingIds: [priorAssistant.id],
     });
 
-    expect(layout.auxiliaryTurnFooter?.itemId).toBe(priorAssistant.id);
-    expect(footerOwners(layout)).toEqual([priorAssistant.id]);
+    expect(layout.auxiliaryTurnFooter?.itemId).toBe(nextTool.id);
+    expect(footerOwners(layout)).toEqual([priorAssistant.id, nextTool.id]);
   });
 
   it("recomputes cached history layout when only the live boundary turn changes", () => {
@@ -171,7 +171,7 @@ describe("layoutStream", () => {
       isTurnActive: true,
       history,
       liveHead,
-      timingByAssistantId: timingFor(priorAssistant.id),
+      timingByItemId: timingFor(priorAssistant.id),
     });
 
     liveHead[0] = { ...liveHead[0]!, turnId: "turn-2" };
@@ -180,7 +180,7 @@ describe("layoutStream", () => {
       isTurnActive: true,
       history,
       liveHead,
-      timingByAssistantId: timingFor(priorAssistant.id),
+      timingByItemId: timingFor(priorAssistant.id),
     });
 
     expect(footerOwners(first)).toEqual([]);

packages/app/src/agent-stream/layout.ts

@@ -39,13 +39,13 @@ export interface StreamLayoutInput {
   isTurnActive: boolean;
   history: StreamItem[];
   liveHead: StreamItem[];
-  timingByAssistantId: Map<string, TurnTiming>;
+  timingByItemId: Map<string, TurnTiming>;
 }
 
 interface LayoutSegmentInput {
   strategy: StreamStrategy;
   items: StreamItem[];
-  timingByAssistantId: Map<string, TurnTiming>;
+  timingByItemId: Map<string, TurnTiming>;
   auxiliaryTurnFooter: TurnFooterHost | null;
   hasAuxiliaryFooter: boolean;
   frameOrder: StreamFrameChildOrder;
@@ -57,8 +57,8 @@ interface LayoutSegmentInput {
   phase: "streaming" | "complete";
 }
 
-interface AssistantFooterSource {
-  item: Extract<StreamItem, { kind: "assistant_message" }>;
+interface TurnFooterSource {
+  item: StreamItem;
   items: StreamItem[];
   index: number;
 }
@@ -67,23 +67,26 @@ function createTurnFooterHost(input: {
   item: StreamItem;
   items: StreamItem[];
   index: number;
-  timingByAssistantId: Map<string, TurnTiming>;
+  timingByItemId: Map<string, TurnTiming>;
 }): TurnFooterHost {
   return {
     itemId: input.item.id,
     items: input.items,
-    timing: input.timingByAssistantId.get(input.item.id),
+    timing: input.timingByItemId.get(input.item.id),
     startIndex: input.index,
   };
 }
 
-function findLatestAssistantInResponse(input: {
+function findTurnFooterSource(input: {
   strategy: StreamStrategy;
   items: StreamItem[];
   startIndex: number;
   boundaryAboveItems?: StreamItem[] | null;
   boundaryAboveIndex?: number | null;
-}): AssistantFooterSource | null {
+}): TurnFooterSource | null {
+  const last = input.items[input.startIndex];
+  const toolFallback: TurnFooterSource | null =
+    last?.kind === "tool_call" ? { item: last, items: input.items, index: input.startIndex } : null;
   let items = input.items;
   let index = input.startIndex;
   let canCrossBoundary = true;
@@ -97,7 +100,7 @@ function findLatestAssistantInResponse(input: {
     ) {
       const item = items[index];
       if (!item || (laterItem && !continuesResponse(item, laterItem))) {
-        return null;
+        return toolFallback;
       }
       if (item.kind === "assistant_message") {
         return { item, items, index };
@@ -111,7 +114,7 @@ function findLatestAssistantInResponse(input: {
       input.boundaryAboveIndex === null ||
       input.boundaryAboveIndex === undefined
     ) {
-      return null;
+      return toolFallback;
     }
 
     items = input.boundaryAboveItems;
@@ -131,20 +134,20 @@ function resolveAuxiliaryTurnFooter(input: StreamLayoutInput): TurnFooterHost |
     return null;
   }
 
-  const assistant = findLatestAssistantInResponse({
+  const source = findTurnFooterSource({
     strategy: input.strategy,
     items: footerItems,
     startIndex: latestIndex,
   });
-  if (!assistant) {
+  if (!source) {
     return null;
   }
 
   return createTurnFooterHost({
-    item: assistant.item,
-    items: assistant.items,
-    index: assistant.index,
-    timingByAssistantId: input.timingByAssistantId,
+    item: source.item,
+    items: source.items,
+    index: source.index,
+    timingByItemId: input.timingByItemId,
   });
 }
 
@@ -154,7 +157,7 @@ function resolveCompletedFooter(input: {
   index: number;
   item: StreamItem;
   belowItem: StreamItem | null;
-  timingByAssistantId: Map<string, TurnTiming>;
+  timingByItemId: Map<string, TurnTiming>;
   auxiliaryTurnFooter: TurnFooterHost | null;
   boundaryAboveItems: StreamItem[] | null;
   boundaryAboveIndex: number | null;
@@ -163,21 +166,21 @@ function resolveCompletedFooter(input: {
     return null;
   }
 
-  const assistant = findLatestAssistantInResponse({
+  const source = findTurnFooterSource({
     strategy: input.strategy,
     items: input.items,
     startIndex: input.index,
     boundaryAboveItems: input.boundaryAboveItems,
     boundaryAboveIndex: input.boundaryAboveIndex,
   });
-  if (!assistant || input.auxiliaryTurnFooter?.itemId === assistant.item.id) {
+  if (!source || input.auxiliaryTurnFooter?.itemId === source.item.id) {
     return null;
   }
   return createTurnFooterHost({
-    item: assistant.item,
-    items: assistant.items,
-    index: assistant.index,
-    timingByAssistantId: input.timingByAssistantId,
+    item: source.item,
+    items: source.items,
+    index: source.index,
+    timingByItemId: input.timingByItemId,
   });
 }
 
@@ -306,7 +309,7 @@ function layoutSegmentItem(
     index,
     item,
     belowItem,
-    timingByAssistantId: input.timingByAssistantId,
+    timingByItemId: input.timingByItemId,
     auxiliaryTurnFooter: input.auxiliaryTurnFooter,
     boundaryAboveItems: input.boundaryAboveItems,
     boundaryAboveIndex: input.boundaryAboveIndex,
@@ -375,7 +378,7 @@ export function layoutStream(input: StreamLayoutInput): StreamLayout {
       history = layoutSegment({
         strategy: input.strategy,
         items: input.history,
-        timingByAssistantId: input.timingByAssistantId,
+        timingByItemId: input.timingByItemId,
         auxiliaryTurnFooter,
         hasAuxiliaryFooter,
         frameOrder,
@@ -395,7 +398,7 @@ export function layoutStream(input: StreamLayoutInput): StreamLayout {
   const liveHead = layoutSegment({
     strategy: input.strategy,
     items: input.liveHead,
-    timingByAssistantId: input.timingByAssistantId,
+    timingByItemId: input.timingByItemId,
     auxiliaryTurnFooter,
     hasAuxiliaryFooter,
     frameOrder,

packages/app/src/agent-stream/model.test.ts

@@ -69,8 +69,8 @@ describe("buildAgentStreamRenderModel", () => {
       historyStart: 2,
     });
 
-    expect(model.turnTiming.byAssistantId.has("hidden-a")).toBe(false);
-    expect(model.turnTiming.byAssistantId.get("visible-a")).toEqual({
+    expect(model.turnTiming.byItemId.has("hidden-a")).toBe(false);
+    expect(model.turnTiming.byItemId.get("visible-a")).toEqual({
       completedAt: tail[3]?.timestamp,
       durationMs: 1000,
     });
@@ -184,7 +184,7 @@ describe("buildAgentStreamRenderModel", () => {
     });
 
     expect(model.turnTiming.runningStartedAt).toBe(tail[0]?.timestamp);
-    expect(model.turnTiming.byAssistantId.has("live-a")).toBe(false);
+    expect(model.turnTiming.byItemId.has("live-a")).toBe(false);
   });
 
   it("maps completed turn timing to assistant ids across committed history and live head", () => {
@@ -201,7 +201,7 @@ describe("buildAgentStreamRenderModel", () => {
     });
 
     expect(model.turnTiming.runningStartedAt).toBe(null);
-    expect(model.turnTiming.byAssistantId.get("live-a")).toEqual({
+    expect(model.turnTiming.byItemId.get("live-a")).toEqual({
       completedAt: head[0]?.timestamp,
       durationMs: 3000,
     });
@@ -220,7 +220,7 @@ describe("buildAgentStreamRenderModel", () => {
     });
 
     expect(model.segments.historyMounted.map((item) => item.id)).toEqual(["a1", "u1"]);
-    expect(model.turnTiming.byAssistantId.get("a1")).toEqual({
+    expect(model.turnTiming.byItemId.get("a1")).toEqual({
       completedAt: tail[1]?.timestamp,
       durationMs: 3000,
     });
@@ -238,7 +238,7 @@ describe("buildAgentStreamRenderModel", () => {
       isMobileBreakpoint: false,
     });
 
-    expect(model.turnTiming.byAssistantId.size).toBe(0);
+    expect(model.turnTiming.byItemId.size).toBe(0);
   });
 
   it.each(["web", "native"] as const)(
@@ -274,10 +274,10 @@ describe("buildAgentStreamRenderModel", () => {
 
       expect(second.history).toBe(first.history);
       expect(second.segments.historyMounted).toBe(first.segments.historyMounted);
-      expect(second.turnTiming.byAssistantId).toBe(first.turnTiming.byAssistantId);
+      expect(second.turnTiming.byItemId).toBe(first.turnTiming.byItemId);
       expect(first.history).toHaveLength(20);
-      expect(first.turnTiming.byAssistantId.has("a29")).toBe(false);
-      expect(first.turnTiming.byAssistantId.get("a38")).toEqual({
+      expect(first.turnTiming.byItemId.has("a29")).toBe(false);
+      expect(first.turnTiming.byItemId.get("a38")).toEqual({
         completedAt: tail[77]?.timestamp,
         durationMs: 1000,
       });

packages/app/src/agent-stream/presentation.test.ts

@@ -588,3 +588,69 @@ describe("timeline presentation", () => {
     expect(projectTimelineItems([source], () => [])).toEqual([]);
   });
 });
+
+it("opening a turn reveals individual calls rather than another tool group", () => {
+  const present = createStreamPresentation();
+  const timestamp = new Date();
+  const tail: StreamItem[] = [
+    { kind: "user_message", id: "prompt", text: "Work", timestamp },
+    toolCall("one", "Bash"),
+    toolCall("two", "Bash"),
+    { kind: "assistant_message", id: "reply", text: "Done", timestamp },
+  ];
+  const result = present({
+    ...presentationOptions,
+    transform: undefined,
+    tail,
+    head: [],
+    display: "collapseTurns",
+    isTurnActive: false,
+    expandedTurnHostIds: new Set(["prompt"]),
+  });
+  expect(result.tail.map((item) => item.id)).toEqual(tail.map((item) => item.id));
+  expect(result.groupsByHostId.size).toBe(0);
+});
+
+it("presents received agent messages as attributed bubbles with the original turn identity", () => {
+  const call = toolCall("received", "agent_message");
+  if (call.payload.source !== "agent") throw new Error("Expected agent tool");
+  call.turnId = "turn";
+  call.payload.data.agentMessage = {
+    event: "message",
+    sender: { id: "sender", title: "Reviewer" },
+    text: "Ready",
+  };
+  const result = createStreamPresentation()({
+    ...presentationOptions,
+    transform: undefined,
+    tail: [call],
+    head: [],
+  });
+  expect(result.tail[0]).toMatchObject({
+    kind: "user_message",
+    id: call.id,
+    turnId: "turn",
+    text: "Ready",
+    sender: { id: "sender", title: "Reviewer" },
+  });
+});
+
+it("does not reopen the previous turn while a new run waits for its first row", () => {
+  const timestamp = new Date();
+  const tail: StreamItem[] = [
+    { kind: "user_message", id: "prompt", text: "Work", timestamp },
+    toolCall("one", "Bash"),
+    { kind: "assistant_message", id: "reply", text: "Done", timestamp },
+  ];
+  for (const item of tail) item.turnId = "completed";
+  const result = createStreamPresentation()({
+    ...presentationOptions,
+    transform: undefined,
+    tail,
+    head: [],
+    display: "collapseTurns",
+    isTurnActive: true,
+    activeTurnId: "new",
+  });
+  expect(result.tail.map((item) => item.id)).toEqual(["prompt", "reply"]);
+});

packages/app/src/agent-stream/presentation.ts

@@ -1,3 +1,4 @@
+import { isTurnBoundary } from "./turn-membership";
 import type { ChatDisplay } from "@/hooks/use-settings";
 import type { TimelineItemTransform } from "@/plugins/timeline/model";
 import { projectPluginTimelineItems } from "@/plugins/timeline/projection";
@@ -19,6 +20,7 @@ interface PresentationInput {
   /** User messages whose collapsed turn the reader opened. */
   expandedTurnHostIds: ReadonlySet<string>;
   isTurnActive: boolean;
+  activeTurnId?: string | null;
 }
 
 export interface StreamPresentation extends ToolCallDetailProjection {
@@ -63,6 +65,22 @@ export function createStreamPresentation() {
   let collapsed: TurnCollapse | undefined;
 
   function presentRows(item: StreamItem): StreamItem[] {
+    if (item.kind === "tool_call" && item.payload.source === "agent") {
+      const message = item.payload.data.agentMessage;
+      if (message?.event === "message") {
+        return [
+          {
+            kind: "user_message",
+            id: item.id,
+            turnId: item.turnId,
+            timelineCursor: item.timelineCursor,
+            timestamp: item.timestamp,
+            text: message.text,
+            sender: message.sender,
+          },
+        ];
+      }
+    }
     return [item.kind === "user_message" ? presentUserMessage(item) : item];
   }
 
@@ -75,7 +93,14 @@ export function createStreamPresentation() {
     }
     // Live text updates reach the head only, so the folded history is reused until the
     // retained rows, the latest turn's liveness, or the reader's expanded turns change.
-    const isLatestTurnOpen = input.isTurnActive || projection.head.length > 0;
+    const isLatestTurnOpen =
+      (input.isTurnActive || projection.head.length > 0) &&
+      !isTurnBoundary(projection.tail.at(-1) ?? null, projection.head[0] ?? null) &&
+      !(
+        input.activeTurnId &&
+        projection.tail.at(-1)?.turnId &&
+        input.activeTurnId !== projection.tail.at(-1)?.turnId
+      );
     if (
       !collapsed ||
       collapsedSource !== projection.tail ||
@@ -93,7 +118,20 @@ export function createStreamPresentation() {
       collapsedExpandedHostIds = input.expandedTurnHostIds;
     }
     const { tail, ...turns } = collapsed;
-    return { ...projection, tail, turns };
+    if (turns.nestedItemIds.size === 0) return { ...projection, tail, turns };
+    // Opening a turn reveals its raw calls; those rows must not become group hosts again.
+    const withoutExpandedRows = (groups: StreamPresentation["groupsByHostId"]) => ({
+      size: groups.size - [...turns.nestedItemIds].filter((id) => groups.has(id)).length,
+      get: (id: string) => (turns.nestedItemIds.has(id) ? undefined : groups.get(id)),
+      has: (id: string) => !turns.nestedItemIds.has(id) && groups.has(id),
+    });
+    return {
+      ...projection,
+      tail,
+      turns,
+      groupsByHostId: withoutExpandedRows(projection.groupsByHostId),
+      historyGroupUpdatesByHostId: withoutExpandedRows(projection.historyGroupUpdatesByHostId),
+    };
   }
 
   return (input: PresentationInput): StreamPresentation => {

packages/app/src/agent-stream/stream-tick.bench.ts

@@ -110,7 +110,7 @@ function runTicks(input: { tail: StreamItem[]; historyStart: number; heads: Stre
       isTurnActive: true,
       history: model.history,
       liveHead: model.segments.liveHead,
-      timingByAssistantId: model.turnTiming.byAssistantId,
+      timingByItemId: model.turnTiming.byItemId,
     });
   }
 }

packages/app/src/agent-stream/turn-collapse/model.test.ts

@@ -63,7 +63,6 @@ describe("collapseTurns", () => {
       hostId: "u1",
       expanded: false,
       summary: {
-        messageCount: 1,
         tools: expect.objectContaining({ commandCount: 2 }),
       },
     });
@@ -121,6 +120,34 @@ describe("collapseTurns", () => {
     expect(result.turnsByHostId.size).toBe(0);
   });
 
+  it("keeps a completed response folded when a promptless canonical turn starts", () => {
+    const first = [user("u1"), shell("c1"), reply("r1")].map((item) =>
+      Object.assign(item, { turnId: "first" }),
+    );
+    const next = { ...shell("heartbeat"), turnId: "second" };
+    const result = collapse([...first, next], { isLatestTurnOpen: true });
+    expect(ids(result.tail)).toEqual(["u1", "r1", "heartbeat"]);
+    expect(result.turnsByHostId.has("u1")).toBe(true);
+  });
+
+  it("keeps mid-turn messages visible when work is folded", () => {
+    const tail = [user("prompt"), shell("work"), user("steer"), shell("more"), reply("done")];
+    for (const item of tail) item.turnId = "same-turn";
+    const result = collapse(tail);
+    expect(ids(result.tail)).toEqual(["prompt", "steer", "done"]);
+    expect(result.hostIdByFoldedMessageId.has("steer")).toBe(false);
+  });
+
+  it("reveals every raw call inside an expanded turn", () => {
+    const calls = [shell("one"), shell("two")];
+    const result = collapse([user("prompt"), calls[0]!, reply("done")], {
+      expandedHostIds: new Set(["prompt"]),
+      getGroupedCalls: (id) => (id === "one" ? calls : undefined),
+    });
+    expect(ids(result.tail)).toEqual(["prompt", "one", "two", "done"]);
+    expect([...result.nestedItemIds]).toEqual(["one", "two"]);
+  });
+
   it("counts every call a tool-call group row stands for", () => {
     const group = [shell("c1"), shell("c2"), shell("c3")];
     const result = collapse([user("u1"), group[0]!, reply("final")], {

packages/app/src/agent-stream/turn-collapse/model.ts

@@ -1,13 +1,13 @@
+import { isTurnBoundary, isTurnTrigger } from "../turn-membership";
 import { getStreamItemMessageId, type StreamItem, type ToolCallItem } from "@/types/stream";
 import { summarizeToolCalls, type OverviewSummary } from "@/tool-calls/detail-level/overview/model";
 
 export interface TurnSummary {
-  messageCount: number;
   tools: OverviewSummary;
 }
 
 export interface CollapsedTurn {
-  /** The user message the turn answers. Its row carries the turn's summary line. */
+  /** The input or first loaded row that carries the turn's summary line. */
   hostId: string;
   expanded: boolean;
   summary: TurnSummary;
@@ -40,16 +40,15 @@ function summarizeTurn(
   getGroupedCalls: CollapseTurnsInput["getGroupedCalls"],
 ): TurnSummary {
   const calls: ToolCallItem[] = [];
-  let messageCount = 0;
   for (const item of items) {
-    if (item.kind === "assistant_message") messageCount += 1;
-    else if (item.kind === "tool_call") calls.push(...(getGroupedCalls(item.id) ?? [item]));
+    if (item.kind === "tool_call" && !isTurnTrigger(item))
+      calls.push(...(getGroupedCalls(item.id) ?? [item]));
   }
-  return { messageCount, tools: summarizeToolCalls(calls) };
+  return { tools: summarizeToolCalls(calls) };
 }
 
 function hasWork(summary: TurnSummary): boolean {
-  return summary.messageCount > 0 || Object.values(summary.tools).some((count) => count > 0);
+  return Object.values(summary.tools).some((count) => count > 0);
 }
 
 function findLastAssistantIndex(tail: StreamItem[], start: number, end: number): number {
@@ -77,28 +76,43 @@ export function collapseTurns(input: CollapseTurnsInput): TurnCollapse {
     const host = tail[runStart - 1];
     const isClosed = runEnd < tail.length || !input.isLatestTurnOpen;
     const replyIndex = findLastAssistantIndex(tail, runStart, runEnd);
-    if (host?.kind !== "user_message" || !isClosed || replyIndex <= runStart) {
+    if (
+      !host ||
+      (host.kind !== "user_message" && host.kind !== "tool_call") ||
+      !isClosed ||
+      replyIndex <= runStart
+    ) {
       output.push(...tail.slice(runStart, runEnd));
       return;
     }
     const folded = tail.slice(runStart, replyIndex);
     const summary = summarizeTurn(folded, input.getGroupedCalls);
-    if (!hasWork(summary)) {
+    if (!hasWork(summary) && !folded.some((item) => item.kind === "assistant_message")) {
       output.push(...tail.slice(runStart, runEnd));
       return;
     }
     const expanded = input.expandedHostIds.has(host.id);
     turnsByHostId.set(host.id, { hostId: host.id, expanded, summary });
-    for (const item of folded) {
+    const revealed = expanded
+      ? folded.flatMap<StreamItem>((item) =>
+          item.kind === "tool_call" ? [...(input.getGroupedCalls(item.id) ?? [item])] : [item],
+        )
+      : folded;
+    for (const item of revealed) {
+      if (isTurnTrigger(item)) continue;
       hostIdByFoldedMessageId.set(getStreamItemMessageId(item), host.id);
       if (expanded) nestedItemIds.add(item.id);
     }
-    if (expanded) output.push(...folded);
+    output.push(...(expanded ? revealed : folded.filter(isTurnTrigger)));
     output.push(...tail.slice(replyIndex, runEnd));
   };
 
   for (let index = 0; index < tail.length; index += 1) {
-    if (tail[index]?.kind !== "user_message") continue;
+    if (
+      !(index === 0 && isTurnTrigger(tail[index]!)) &&
+      !isTurnBoundary(tail[index - 1] ?? null, tail[index] ?? null)
+    )
+      continue;
     flushRun(index);
     output.push(tail[index]!);
     runStart = index + 1;
@@ -114,7 +128,10 @@ export function collapseTurns(input: CollapseTurnsInput): TurnCollapse {
     };
   }
   return {
-    tail: output.length === tail.length ? tail : output,
+    tail:
+      output.length === tail.length && output.every((item, index) => item === tail[index])
+        ? tail
+        : output,
     turnsByHostId,
     nestedItemIds,
     hostIdByFoldedMessageId,

packages/app/src/agent-stream/turn-collapse/summary-line.tsx

@@ -1,4 +1,4 @@
-import { memo, useCallback, useMemo } from "react";
+import { memo, useCallback } from "react";
 import { useTranslation } from "react-i18next";
 import { Summary } from "lucide-react-native";
 import { ExpandableBadge } from "@/components/message";
@@ -17,19 +17,7 @@ export const TurnSummaryLine = memo(function TurnSummaryLine({
   onExpandedChange: (hostId: string, expanded: boolean) => void;
 }) {
   const { t } = useTranslation();
-  const { messageCount, tools } = turn.summary;
-  const messageParts = useMemo(
-    () =>
-      messageCount > 0
-        ? [
-            t(`turnSummary.messages.${messageCount === 1 ? "one" : "other"}`, {
-              count: messageCount,
-            }),
-          ]
-        : [],
-    [messageCount, t],
-  );
-  const label = useOverviewSummaryLabel(tools, messageParts);
+  const label = useOverviewSummaryLabel(turn.summary.tools) || t("turnSummary.details");
   const toggle = useCallback(
     () => onExpandedChange(turn.hostId, !turn.expanded),
     [onExpandedChange, turn.expanded, turn.hostId],

packages/app/src/agent-stream/turn-footer.tsx

@@ -197,7 +197,7 @@ function CompletedTurnFooter({
   return (
     <View style={stylesheet.turnFooterSlot}>
       <AssistantTurnFooter
-        getContent={getContent}
+        getContent={items[startIndex]?.kind === "assistant_message" ? getContent : undefined}
         completedAt={timing?.completedAt}
         durationMs={timing?.durationMs}
         onFork={boundary && onForkAssistantTurn ? handleFork : undefined}

packages/app/src/agent-stream/turn-membership.test.ts

@@ -53,7 +53,7 @@ function layoutFor(items: StreamItem[], isTurnActive: boolean) {
       isTurnActive,
       history: model.segments.historyMounted,
       liveHead: model.segments.liveHead,
-      timingByAssistantId: model.turnTiming.byAssistantId,
+      timingByItemId: model.turnTiming.byItemId,
     }),
   };
 }
@@ -76,7 +76,7 @@ describe("canonical turn membership", () => {
     );
   });
 
-  it("renders adjacent turns without visible prompts as one response", () => {
+  it("renders a separate footer for each canonical turn without visible prompts", () => {
     const items = [
       user("prompt", 1, "turn-1"),
       assistant("first reply", 2, "turn-1"),
@@ -88,7 +88,11 @@ describe("canonical turn membership", () => {
 
     const completed = layoutFor(items, false);
 
-    expect(completedFooterIds(completed.layout)).toEqual(["heartbeat-2-reply"]);
+    expect(completedFooterIds(completed.layout)).toEqual([
+      "first reply",
+      "heartbeat-1-reply",
+      "heartbeat-2-reply",
+    ]);
     expect(completed.layout.auxiliaryTurnFooter?.timing).toEqual({
       completedAt: at(6),
       durationMs: null,
@@ -123,7 +127,7 @@ describe("canonical turn membership", () => {
     const completedItems = [...build(turnId), assistant("done", 9, turnId)];
     const completed = layoutFor(completedItems, false);
     expect(completedFooterIds(completed.layout)).toEqual(["done"]);
-    expect(completed.model.turnTiming.byAssistantId.get("done")).toMatchObject({
+    expect(completed.model.turnTiming.byItemId.get("done")).toMatchObject({
       completedAt: at(9),
       durationMs: 8000,
     });

packages/app/src/agent-stream/turn-membership.ts

@@ -9,16 +9,15 @@ export function continuesTurn(previous: StreamItem | null, next: StreamItem | nu
   if (previous.turnId !== undefined && next.turnId !== undefined) {
     return previous.turnId === next.turnId;
   }
-  return next.kind !== "user_message";
+  return !isTurnTrigger(next);
 }
 
 /**
- * A visible response can span multiple canonical turns when their prompts are
- * system-injected and therefore absent from the Paseo timeline.
+ * Every canonical turn owns its response, including system-triggered runs.
  */
 export function continuesResponse(previous: StreamItem | null, next: StreamItem | null): boolean {
   if (!previous || !next) return false;
-  return continuesTurn(previous, next) || next.kind !== "user_message";
+  return continuesTurn(previous, next);
 }
 
 export function isTurnBoundary(previous: StreamItem | null, next: StreamItem | null): boolean {
@@ -37,3 +36,13 @@ export function startsNewTurn(item: StreamItem, previous: StreamItem | null): bo
 export function belongsToTurn(item: StreamItem, turnId: string | null): boolean {
   return turnId !== null && item.turnId === turnId;
 }
+
+/** Inputs that start a turn when older history has no canonical turn IDs. */
+export function isTurnTrigger(item: StreamItem): boolean {
+  if (item.kind === "user_message") return true;
+  return (
+    item.kind === "tool_call" &&
+    item.payload.source === "agent" &&
+    (item.payload.data.agentMessage !== undefined || item.payload.data.name === "heartbeat")
+  );
+}

packages/app/src/agent-stream/view.tsx

@@ -526,6 +526,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           display: chatDisplay,
           expandedTurnHostIds,
           isTurnActive,
+          activeTurnId: effectiveTurnPresentation.turnId,
         }),
       [
         presentStream,
@@ -535,6 +536,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         chatDisplay,
         expandedTurnHostIds,
         isTurnActive,
+        effectiveTurnPresentation.turnId,
       ],
     );
     const {
@@ -576,12 +578,12 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           isTurnActive,
           history: baseRenderModel.history,
           liveHead: baseRenderModel.segments.liveHead,
-          timingByAssistantId: baseRenderModel.turnTiming.byAssistantId,
+          timingByItemId: baseRenderModel.turnTiming.byItemId,
         }),
       [
         baseRenderModel.history,
         baseRenderModel.segments.liveHead,
-        baseRenderModel.turnTiming.byAssistantId,
+        baseRenderModel.turnTiming.byItemId,
         isTurnActive,
         streamRenderStrategy,
       ],
@@ -722,6 +724,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             agentId={agentId}
             messageId={item.messageId}
             message={item.text}
+            sender={item.sender}
             images={item.images}
             attachments={item.attachments}
             timestamp={item.timestamp.getTime()}
@@ -787,6 +790,9 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [agentId, client, handleInlinePathPress, resolvedServerId, toast, workspaceRoot],
     );
 
+    const isExpandedTurnItem = useStableEvent((id: string) =>
+      presentation.turns.nestedItemIds.has(id),
+    );
     const renderThoughtItem = useCallback(
       (layoutItem: StreamLayoutItem, item: Extract<StreamItem, { kind: "thought" }>) => {
         return (
@@ -796,11 +802,11 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             text={item.text}
             status={item.status}
             isLastInSequence={layoutItem.isLastInToolSequence}
-            defaultExpanded={autoExpandReasoning}
+            defaultExpanded={autoExpandReasoning || isExpandedTurnItem(item.id)}
           />
         );
       },
-      [autoExpandReasoning, setInlineDetailsExpanded],
+      [autoExpandReasoning, setInlineDetailsExpanded, isExpandedTurnItem],
     );
 
     const renderSingleToolCallItem = useCallback(
@@ -830,6 +836,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
               itemId={item.id}
               onInlineDetailsExpandedChangeByItemId={setInlineDetailsExpanded}
               toolName={data.name}
+              defaultExpanded={isExpandedTurnItem(item.id)}
+              forceInline={isExpandedTurnItem(item.id)}
               error={data.error}
               status={data.status}
               detail={data.detail}
@@ -859,7 +867,13 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
           />
         );
       },
-      [context.cwd, resolvedServerId, setInlineDetailsExpanded, handleToolCallOpenFile],
+      [
+        context.cwd,
+        resolvedServerId,
+        setInlineDetailsExpanded,
+        handleToolCallOpenFile,
+        isExpandedTurnItem,
+      ],
     );
 
     // Read through a stable event so live group updates do not change the renderer identity
@@ -917,7 +931,17 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             return renderThoughtItem(layoutItem, item);
 
           case "tool_call":
-            return renderToolCallItem(layoutItem, item);
+            return (
+              <>
+                {renderToolCallItem(layoutItem, item)}
+                {getCollapsedTurn(item.id) ? (
+                  <TurnSummaryLine
+                    turn={getCollapsedTurn(item.id)!}
+                    onExpandedChange={setTurnExpanded}
+                  />
+                ) : null}
+              </>
+            );
 
           case "notification":
             return <Notification level={item.level} message={item.message} />;
@@ -949,6 +973,8 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         renderAssistantMessageItem,
         renderThoughtItem,
         renderToolCallItem,
+        getCollapsedTurn,
+        setTurnExpanded,
         resolvedServerId,
       ],
     );

packages/app/src/components/indent-rail.tsx

@@ -3,11 +3,10 @@ import { View, type StyleProp, type ViewStyle } from "react-native";
 import { StyleSheet } from "react-native-unistyles";
 
 /**
- * Collapsed chat rows badge their summary with an icon whose center sits 7px into the content
- * column (`ExpandableBadge` bleeds 13px left, then 1px border, 8px padding, 22px icon). The rail
- * hangs from that center so opened rows read as children of the line that opened them.
+ * Align the rail with the expanded caret's left edge. Keep the content offset fixed so
+ * expanded tool cards stay in place, with a gap between their border and the rail.
  */
-const RAIL_LEFT = 7;
+const RAIL_LEFT = 1;
 const RAIL_WIDTH = 1;
 export const INDENT_RAIL_CONTENT_OFFSET = 21;
 

packages/app/src/components/message.tsx

@@ -1,3 +1,4 @@
+import { MessagePreview, MessageSender } from "@/components/user-message";
 import { useStableEvent } from "@/hooks/use-stable-event";
 import { getAgentAttachmentPillContent } from "@/attachments/attachment-pill-content";
 import { AssistantForkMenu, type AssistantForkTarget } from "@/components/assistant-fork-menu";
@@ -89,6 +90,7 @@ export type { InlinePathTarget } from "@/assistant-file-links";
 export type { AssistantForkTarget };
 
 interface UserMessageProps {
+  sender?: AgentMessage["sender"];
   serverId?: string;
   agentId?: string;
   messageId?: string;
@@ -387,6 +389,7 @@ function UserMessageImagePill({ image, onOpen, accessibilityLabel }: UserMessage
 const MESSAGE_TEXT_DATASET = { messageText: "true" };
 
 export const UserMessage = memo(function UserMessage({
+  sender,
   serverId,
   agentId,
   messageId,
@@ -473,42 +476,45 @@ export const UserMessage = memo(function UserMessage({
         onPointerEnter={handlePointerEnter}
         onPointerLeave={handlePointerLeave}
       >
+        {sender ? <MessageSender sender={sender} serverId={serverId} /> : null}
         <View style={userMessageStylesheet.bubble}>
-          {hasImages ? (
-            <View style={imagePreviewContainerStyle}>
-              {images.map((image) => (
-                <UserMessageImagePill
-                  key={image.id}
-                  image={image}
-                  onOpen={setLightboxMetadata}
-                  accessibilityLabel={t("composer.attachments.openImage")}
-                />
-              ))}
-            </View>
-          ) : null}
-          {hasAttachments ? (
-            <View style={attachmentPreviewContainerStyle}>
-              {attachments.map((attachment, index) => {
-                const content = getAgentAttachmentPillContent(attachment, t);
-                return (
-                  <AttachmentFrame
-                    key={`${attachment.type}:${"number" in attachment ? attachment.number : index}`}
-                  >
-                    <AttachmentLabel
-                      icon={content.icon}
-                      title={content.title}
-                      subtitle={content.subtitle}
-                    />
-                  </AttachmentFrame>
-                );
-              })}
-            </View>
-          ) : null}
-          {hasText ? (
-            <Text selectable style={userMessageStylesheet.text} dataSet={MESSAGE_TEXT_DATASET}>
-              {message}
-            </Text>
-          ) : null}
+          <MessagePreview>
+            {hasImages ? (
+              <View style={imagePreviewContainerStyle}>
+                {images.map((image) => (
+                  <UserMessageImagePill
+                    key={image.id}
+                    image={image}
+                    onOpen={setLightboxMetadata}
+                    accessibilityLabel={t("composer.attachments.openImage")}
+                  />
+                ))}
+              </View>
+            ) : null}
+            {hasAttachments ? (
+              <View style={attachmentPreviewContainerStyle}>
+                {attachments.map((attachment, index) => {
+                  const content = getAgentAttachmentPillContent(attachment, t);
+                  return (
+                    <AttachmentFrame
+                      key={`${attachment.type}:${"number" in attachment ? attachment.number : index}`}
+                    >
+                      <AttachmentLabel
+                        icon={content.icon}
+                        title={content.title}
+                        subtitle={content.subtitle}
+                      />
+                    </AttachmentFrame>
+                  );
+                })}
+              </View>
+            ) : null}
+            {hasText ? (
+              <Text selectable style={userMessageStylesheet.text} dataSet={MESSAGE_TEXT_DATASET}>
+                {message}
+              </Text>
+            ) : null}
+          </MessagePreview>
         </View>
         {hasText ? (
           <View
@@ -541,7 +547,7 @@ export const UserMessage = memo(function UserMessage({
 });
 
 interface AssistantTurnFooterProps {
-  getContent: () => string;
+  getContent?: () => string;
   completedAt?: Date;
   durationMs?: number | null;
   onFork?: (target: AssistantForkTarget) => Promise<void> | void;
@@ -641,10 +647,12 @@ export const AssistantTurnFooter = memo(function AssistantTurnFooter({
 
   return (
     <View style={assistantTurnFooterStylesheet.container}>
-      <TurnCopyButton
-        getContent={getContent}
-        containerStyle={assistantTurnFooterStylesheet.copyButton}
-      />
+      {getContent ? (
+        <TurnCopyButton
+          getContent={getContent}
+          containerStyle={assistantTurnFooterStylesheet.copyButton}
+        />
+      ) : null}
       {canFork ? <AssistantForkMenu onFork={handleFork} /> : null}
       {primaryLabel ? (
         <Pressable

packages/app/src/components/ui/edge-fade.tsx

@@ -4,9 +4,10 @@ import Svg, { Defs, LinearGradient as SvgLinearGradient, Rect, Stop } from "reac
 import { withUnistyles } from "react-native-unistyles";
 import type { Theme } from "@/styles/theme";
 
-type EdgeFadeBackdrop = "surface0" | "surfaceWorkspace";
+type EdgeFadeBackdrop = "surface0" | "surfaceWorkspace" | "surface3";
 
 const backdropColorMappings: Record<EdgeFadeBackdrop, (theme: Theme) => { color: string }> = {
+  surface3: (theme) => ({ color: theme.colors.surface3 }),
   surface0: (theme) => ({ color: theme.colors.surface0 }),
   surfaceWorkspace: (theme) => ({ color: theme.colors.surfaceWorkspace }),
 };

packages/app/src/components/user-message/index.tsx

@@ -0,0 +1,79 @@
+import { useState, useCallback, useMemo, type ReactNode } from "react";
+import { View, type LayoutChangeEvent } from "react-native";
+import { StyleSheet } from "react-native-unistyles";
+import { useTranslation } from "react-i18next";
+import type { AgentMessage } from "@getpaseo/protocol/agent-message";
+import { Button } from "@/components/ui/button";
+import { EdgeFade } from "@/components/ui/edge-fade";
+import { useProviderIcon } from "@/components/provider-icons";
+import { useSessionStore } from "@/stores/session-store";
+import { navigateToAgent } from "@/utils/navigate-to-agent";
+
+const PREVIEW_HEIGHT = 240;
+
+export function MessagePreview({ children }: { children: ReactNode }) {
+  const { t } = useTranslation();
+  const [expanded, setExpanded] = useState(false);
+  const [height, setHeight] = useState(0);
+  const overflowing = height > PREVIEW_HEIGHT;
+  const measure = useCallback(
+    (event: LayoutChangeEvent) => setHeight(event.nativeEvent.layout.height),
+    [],
+  );
+  const toggle = useCallback(() => setExpanded((value) => !value), []);
+  const accessibilityState = useMemo(() => ({ expanded }), [expanded]);
+  return (
+    <>
+      <View style={!expanded && styles.preview}>
+        <View style={styles.body} onLayout={measure}>
+          {children}
+        </View>
+        {overflowing && !expanded ? (
+          <EdgeFade edge="bottom" solidFraction={0} backdrop="surface3" style={styles.fade} />
+        ) : null}
+      </View>
+      {overflowing ? (
+        <Button
+          variant="ghost"
+          size="sm"
+          style={styles.toggle}
+          accessibilityState={accessibilityState}
+          onPress={toggle}
+        >
+          {t(expanded ? "turnSummary.showLess" : "turnSummary.showMore")}
+        </Button>
+      ) : null}
+    </>
+  );
+}
+
+export function MessageSender({
+  sender,
+  serverId,
+}: {
+  sender: AgentMessage["sender"];
+  serverId?: string;
+}) {
+  const { t } = useTranslation();
+  const host = sender.serverId ?? serverId;
+  const agent = useSessionStore((state) => {
+    const session = host ? state.sessions[host] : undefined;
+    return session?.agents.get(sender.id) ?? session?.agentDetails.get(sender.id);
+  });
+  const ProviderIcon = useProviderIcon(agent?.provider ?? "", host);
+  const openSender = useCallback(() => {
+    if (host) navigateToAgent({ serverId: host, agentId: sender.id });
+  }, [host, sender.id]);
+  return (
+    <Button variant="ghost" size="sm" leftIcon={ProviderIcon} disabled={!host} onPress={openSender}>
+      {t("turnSummary.sentBy", { name: agent?.title ?? sender.title ?? sender.id })}
+    </Button>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  preview: { maxHeight: PREVIEW_HEIGHT, overflow: "hidden" },
+  body: { flexShrink: 0 },
+  toggle: { alignSelf: "flex-start", paddingHorizontal: 0, borderWidth: 0 },
+  fade: { position: "absolute", bottom: 0, left: 0, right: 0, height: theme.spacing[12] },
+}));

packages/app/src/composer/index.tsx

@@ -2495,7 +2495,6 @@ function ComposerContentImpl({
                   voiceAgentId={agentId}
                   isAgentRunning={isAgentRunning}
                   defaultSendBehavior={activeSendBehavior}
-                  sendShortcut={appSettings.sendShortcut}
                   onQueue={handleQueue}
                   onSubmitLoadingPress={submitLoadingPressHandler}
                   onKeyPress={handleCommandKeyPress}

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

@@ -1,4 +1,3 @@
-import type { SendShortcut } from "@/hooks/use-settings";
 import {
   useComposerEditingSession,
   useComposerFullscreen,
@@ -89,7 +88,6 @@ import {
   resolveAlternateSendAction,
   resolveComposerSurfacePresentation,
   resolveComposerSurfaceText,
-  resolveMessageInputEnterAction,
   resolveRetainedSelection,
   runAlternateSendAction,
   runDefaultSendAction,
@@ -98,11 +96,6 @@ import {
 } from "./state";
 
 const DEFAULT_SEND_KEYS: ShortcutKey[][] = [["Enter"]];
-const MOD_ENTER_SEND_KEYS: ShortcutKey[][] = [["mod", "Enter"]];
-
-function resolveSendKeys(sendShortcut: SendShortcut): ShortcutKey[][] {
-  return sendShortcut === "mod-enter" ? MOD_ENTER_SEND_KEYS : DEFAULT_SEND_KEYS;
-}
 const COMPOSER_INPUT_DATASET = { composerInput: "" } as const;
 
 export interface AttachmentMenuItem {
@@ -174,7 +167,6 @@ export interface MessageInputProps {
    *  running. "interrupt" and "steer" send immediately, "queue" queues. Required so the default
    *  lives only in DEFAULT_CLIENT_SETTINGS. */
   defaultSendBehavior: "interrupt" | "steer" | "queue";
-  sendShortcut: SendShortcut;
   /** Callback for queue button when agent is running */
   onQueue?: (payload: MessagePayload) => void;
   /** Optional handler used when submit button is in loading state. */
@@ -410,9 +402,6 @@ interface DesktopKeyPressContext {
   onKeyPressCallback: ((event: ComposerKeyPressEvent) => boolean) | undefined;
   input: ComposerKeyPressEvent["input"];
   submitOnEnter: boolean;
-  sendShortcut: SendShortcut;
-  isAgentRunning: boolean;
-  onQueue: ((payload: MessagePayload) => void) | undefined;
   isSubmitDisabled: boolean;
   isSubmitLoading: boolean;
   disabled: boolean;
@@ -439,21 +428,12 @@ function handleDesktopKeyPressImpl(
   }
 
   if (event.nativeEvent.key !== "Enter") return;
-
-  const action = resolveMessageInputEnterAction({
-    submitOnEnter: ctx.submitOnEnter,
-    sendShortcut: ctx.sendShortcut,
-    shiftKey: shiftKey ?? false,
-    metaKey: metaKey ?? false,
-    ctrlKey: ctrlKey ?? false,
-    isAgentRunning: ctx.isAgentRunning,
-    onQueue: ctx.onQueue,
-  });
-  if (action === null) return;
+  if (!ctx.submitOnEnter) return;
+  if (shiftKey) return;
 
   if (ctx.isSubmitDisabled || ctx.isSubmitLoading || ctx.disabled) return;
   event.preventDefault();
-  if (action === "alternate-send") {
+  if (metaKey || ctrlKey) {
     ctx.handleAlternateSendAction();
     return;
   }
@@ -1132,7 +1112,6 @@ interface ResolvedMessageInputProps {
   voiceAgentId: string | undefined;
   isAgentRunning: boolean;
   defaultSendBehavior: "interrupt" | "steer" | "queue";
-  sendShortcut: SendShortcut;
   onQueue: ((payload: MessagePayload) => void) | undefined;
   onSubmitLoadingPress: (() => void) | undefined;
   onKeyPressCallback: ((event: ComposerKeyPressEvent) => boolean) | undefined;
@@ -1180,7 +1159,6 @@ function resolveMessageInputProps(props: MessageInputProps): ResolvedMessageInpu
     voiceAgentId: props.voiceAgentId,
     isAgentRunning: props.isAgentRunning ?? false,
     defaultSendBehavior: props.defaultSendBehavior,
-    sendShortcut: props.sendShortcut,
     onQueue: props.onQueue,
     onSubmitLoadingPress: props.onSubmitLoadingPress,
     onKeyPressCallback: props.onKeyPress,
@@ -1258,7 +1236,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       voiceAgentId,
       isAgentRunning,
       defaultSendBehavior,
-      sendShortcut,
       onQueue,
       onSubmitLoadingPress,
       onKeyPressCallback,
@@ -1778,9 +1755,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
             selectionRef.current,
           ),
           submitOnEnter: shouldSubmitOnEnter,
-          sendShortcut,
-          isAgentRunning,
-          onQueue,
           isSubmitDisabled,
           isSubmitLoading,
           disabled,
@@ -1792,9 +1766,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
         shouldHandleWebKeyPress,
         onKeyPressCallback,
         shouldSubmitOnEnter,
-        sendShortcut,
-        isAgentRunning,
-        onQueue,
         isSubmitDisabled,
         isSubmitLoading,
         disabled,
@@ -2009,7 +1980,7 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
           submitLabel={submitLabel}
           submitButtonTestID={submitButtonTestID}
           buttonIconSize={buttonIconSize}
-          sendKeys={resolveSendKeys(sendShortcut)}
+          sendKeys={DEFAULT_SEND_KEYS}
           sendTooltipLabel={sendTooltipLabel}
         />
       ),
@@ -2030,7 +2001,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
         submitLabel,
         submitButtonTestID,
         buttonIconSize,
-        sendShortcut,
         sendTooltipLabel,
       ],
     );

packages/app/src/composer/input/state.test.ts

@@ -2,12 +2,10 @@ import { describe, expect, it, vi } from "vitest";
 import {
   applyDictationTranscript,
   computeCanStartDictation,
-  type MessageInputEnterContext,
   resolveActiveSendBehavior,
   resolveComposerSurfacePresentation,
   resolveComposerSurfaceText,
   resolveGlyphRailOffset,
-  resolveMessageInputEnterAction,
   resolveRetainedSelection,
   resolveAlternateSendAction,
   runAlternateSendAction,
@@ -322,212 +320,6 @@ describe("composer send behavior", () => {
   });
 });
 
-describe("resolveMessageInputEnterAction", () => {
-  function enterContext(
-    overrides: Partial<MessageInputEnterContext> = {},
-  ): MessageInputEnterContext {
-    return {
-      submitOnEnter: true,
-      sendShortcut: "enter",
-      shiftKey: false,
-      metaKey: false,
-      ctrlKey: false,
-      isAgentRunning: false,
-      onQueue: () => undefined,
-      ...overrides,
-    };
-  }
-
-  it("returns null for plain, Shift, and modifier Enter when submit on enter is disabled", () => {
-    expect(resolveMessageInputEnterAction(enterContext({ submitOnEnter: false }))).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(enterContext({ submitOnEnter: false, shiftKey: true })),
-    ).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(enterContext({ submitOnEnter: false, metaKey: true })),
-    ).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(enterContext({ submitOnEnter: false, ctrlKey: true })),
-    ).toBeNull();
-  });
-
-  it("still returns null when modifier Enter sends and submit on enter is disabled", () => {
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", submitOnEnter: false, metaKey: true }),
-      ),
-    ).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", submitOnEnter: false }),
-      ),
-    ).toBeNull();
-  });
-
-  it("sends on plain Enter when Enter sends", () => {
-    expect(resolveMessageInputEnterAction(enterContext())).toBe("default-send");
-  });
-
-  it("returns null for Shift+Enter when Enter sends", () => {
-    expect(resolveMessageInputEnterAction(enterContext({ shiftKey: true }))).toBeNull();
-  });
-
-  it("returns null for Shift+Cmd+Enter and Shift+Ctrl+Enter so Shift keeps its newline", () => {
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ shiftKey: true, metaKey: true, isAgentRunning: true }),
-      ),
-    ).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ shiftKey: true, ctrlKey: true, isAgentRunning: true }),
-      ),
-    ).toBeNull();
-  });
-
-  it("sends on Cmd+Enter and Ctrl+Enter while idle even with a queue handler", () => {
-    expect(resolveMessageInputEnterAction(enterContext({ metaKey: true }))).toBe("default-send");
-    expect(resolveMessageInputEnterAction(enterContext({ ctrlKey: true }))).toBe("default-send");
-  });
-
-  it("queues on Cmd+Enter and Ctrl+Enter while the agent is running with a queue handler", () => {
-    expect(
-      resolveMessageInputEnterAction(enterContext({ metaKey: true, isAgentRunning: true })),
-    ).toBe("alternate-send");
-    expect(
-      resolveMessageInputEnterAction(enterContext({ ctrlKey: true, isAgentRunning: true })),
-    ).toBe("alternate-send");
-  });
-
-  it("sends on Cmd+Enter and Ctrl+Enter while running when no queue handler exists", () => {
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ metaKey: true, isAgentRunning: true, onQueue: undefined }),
-      ),
-    ).toBe("default-send");
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ ctrlKey: true, isAgentRunning: true, onQueue: undefined }),
-      ),
-    ).toBe("default-send");
-  });
-
-  it("returns null for plain and Shift+Enter when modifier Enter sends", () => {
-    expect(resolveMessageInputEnterAction(enterContext({ sendShortcut: "mod-enter" }))).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(enterContext({ sendShortcut: "mod-enter", shiftKey: true })),
-    ).toBeNull();
-  });
-
-  it("returns null for Shift+Cmd+Enter and Shift+Ctrl+Enter when modifier Enter sends", () => {
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", shiftKey: true, metaKey: true }),
-      ),
-    ).toBeNull();
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", shiftKey: true, ctrlKey: true }),
-      ),
-    ).toBeNull();
-  });
-
-  it("sends on Cmd+Enter and Ctrl+Enter while idle when modifier Enter sends", () => {
-    expect(
-      resolveMessageInputEnterAction(enterContext({ sendShortcut: "mod-enter", metaKey: true })),
-    ).toBe("default-send");
-    expect(
-      resolveMessageInputEnterAction(enterContext({ sendShortcut: "mod-enter", ctrlKey: true })),
-    ).toBe("default-send");
-  });
-
-  it("uses the default action on modifier Enter while running when modifier Enter sends", () => {
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", metaKey: true, isAgentRunning: true }),
-      ),
-    ).toBe("default-send");
-    expect(
-      resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", ctrlKey: true, isAgentRunning: true }),
-      ),
-    ).toBe("default-send");
-  });
-
-  describe("composed with the send actions", () => {
-    function actions() {
-      const calls: string[] = [];
-      return {
-        calls,
-        handleSendMessage: () => calls.push("send"),
-        handleQueueMessage: () => calls.push("queue"),
-        onQueue: () => undefined,
-      };
-    }
-
-    function resolveCommandEnterToSendModifierEnter() {
-      return resolveMessageInputEnterAction(
-        enterContext({ sendShortcut: "mod-enter", metaKey: true, isAgentRunning: true }),
-      );
-    }
-
-    it("queues through the default send action when queue behavior is selected and the agent is running", () => {
-      const sendAction = actions();
-
-      expect(resolveCommandEnterToSendModifierEnter()).toBe("default-send");
-
-      runDefaultSendAction({
-        defaultSendBehavior: "queue",
-        isAgentRunning: true,
-        onQueue: sendAction.onQueue,
-        handleSendMessage: sendAction.handleSendMessage,
-        handleQueueMessage: sendAction.handleQueueMessage,
-      });
-
-      expect(sendAction.calls).toEqual(["queue"]);
-    });
-
-    it("sends through the default send action when queue behavior is selected and the agent is idle", () => {
-      const sendAction = actions();
-
-      expect(
-        resolveMessageInputEnterAction(
-          enterContext({ sendShortcut: "mod-enter", metaKey: true, isAgentRunning: false }),
-        ),
-      ).toBe("default-send");
-
-      runDefaultSendAction({
-        defaultSendBehavior: "queue",
-        isAgentRunning: false,
-        onQueue: sendAction.onQueue,
-        handleSendMessage: sendAction.handleSendMessage,
-        handleQueueMessage: sendAction.handleQueueMessage,
-      });
-
-      expect(sendAction.calls).toEqual(["send"]);
-    });
-
-    it.each([{ defaultSendBehavior: "steer" }, { defaultSendBehavior: "interrupt" }] as const)(
-      "sends through the default send action when $defaultSendBehavior behavior is selected and the agent is running",
-      ({ defaultSendBehavior }) => {
-        const sendAction = actions();
-
-        expect(resolveCommandEnterToSendModifierEnter()).toBe("default-send");
-
-        runDefaultSendAction({
-          defaultSendBehavior,
-          isAgentRunning: true,
-          onQueue: sendAction.onQueue,
-          handleSendMessage: sendAction.handleSendMessage,
-          handleQueueMessage: sendAction.handleQueueMessage,
-        });
-
-        expect(sendAction.calls).toEqual(["send"]);
-      },
-    );
-  });
-});
-
 describe("stopRealtimeVoice", () => {
   it("keeps voice mode active when the running agent refuses cancellation", async () => {
     const cancellationError = new Error("active run cancellation was not acknowledged");

packages/app/src/composer/input/state.ts

@@ -1,4 +1,3 @@
-import type { SendShortcut } from "@/hooks/use-settings";
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import type { ActiveTurnBehavior } from "@getpaseo/protocol/messages";
 import type { MessagePayload, TextReplacement } from "@/composer/types";
@@ -152,29 +151,6 @@ export function runAlternateSendAction(ctx: SendActionContext): void {
   runDefaultSendAction(ctx);
 }
 
-export type MessageInputEnterAction = "alternate-send" | "default-send";
-
-export interface MessageInputEnterContext {
-  submitOnEnter: boolean;
-  sendShortcut: SendShortcut;
-  shiftKey: boolean;
-  metaKey: boolean;
-  ctrlKey: boolean;
-  isAgentRunning: boolean;
-  onQueue: ((payload: MessagePayload) => void) | undefined;
-}
-
-export function resolveMessageInputEnterAction(
-  ctx: MessageInputEnterContext,
-): MessageInputEnterAction | null {
-  if (!ctx.submitOnEnter) return null;
-  if (ctx.shiftKey) return null;
-  const hasModifier = ctx.metaKey || ctx.ctrlKey;
-  if (ctx.sendShortcut === "mod-enter") return hasModifier ? "default-send" : null;
-  if (hasModifier && ctx.isAgentRunning && ctx.onQueue) return "alternate-send";
-  return "default-send";
-}
-
 export function runMessageInputKeyboardAction(
   action: MessageInputKeyboardActionKind,
   actions: MessageInputKeyboardActions,

packages/app/src/hooks/use-settings/index.ts

@@ -49,7 +49,6 @@ import {
   type KeyValueStorage,
   type ReleaseChannel,
   type SendBehavior,
-  type SendShortcut,
   type ServiceUrlBehavior,
   type Settings,
   type SidebarWorkspaceTrailing,
@@ -94,7 +93,6 @@ export type {
   KeyValueStorage,
   ReleaseChannel,
   SendBehavior,
-  SendShortcut,
   ServiceUrlBehavior,
   Settings,
   SettingsDeps,

packages/app/src/hooks/use-settings/storage.test.ts

@@ -227,39 +227,6 @@ describe("loadAppSettingsFromStorage", () => {
     expect(result.chatOutlineEnabled).toBe(false);
   });
 
-  it("uses Enter to send by default", async () => {
-    const deps = makeDeps();
-
-    const result = await loadAppSettingsFromStorage(deps);
-
-    expect(result.sendShortcut).toBe("enter");
-    expect(DEFAULT_CLIENT_SETTINGS.sendShortcut).toBe("enter");
-  });
-
-  it("loads the modifier Enter send preference", async () => {
-    const deps = makeDeps({
-      storage: createInMemoryKeyValueStorage({
-        [APP_SETTINGS_KEY]: JSON.stringify({ sendShortcut: "mod-enter" }),
-      }),
-    });
-
-    const result = await loadAppSettingsFromStorage(deps);
-
-    expect(result.sendShortcut).toBe("mod-enter");
-  });
-
-  it("falls back to Enter when the stored send shortcut is invalid", async () => {
-    const deps = makeDeps({
-      storage: createInMemoryKeyValueStorage({
-        [APP_SETTINGS_KEY]: JSON.stringify({ sendShortcut: "yes" }),
-      }),
-    });
-
-    const result = await loadAppSettingsFromStorage(deps);
-
-    expect(result.sendShortcut).toBe("enter");
-  });
-
   it("defaults sidebar navigation items to an empty preference list", async () => {
     const deps = makeDeps();
 

packages/app/src/hooks/use-settings/storage.ts

@@ -33,8 +33,6 @@ import { migrateAppSettings } from "./migrations";
 export { APP_SETTINGS_KEY } from "./keys";
 export const APP_SETTINGS_QUERY_KEY = ["app-settings"];
 
-export type SendShortcut = "enter" | "mod-enter";
-
 export type SendBehavior = ActiveTurnBehavior | "queue";
 export type ReleaseChannel = "stable" | "beta";
 export type ServiceUrlBehavior = "ask" | "in-app" | "external";
@@ -106,7 +104,6 @@ export interface AppSettings {
   chatDisplay: ChatDisplay;
   chatOutlineEnabled: boolean;
   vimKeybindings: boolean;
-  sendShortcut: SendShortcut;
   filePanelAssociations: Record<string, string>;
   /** Desktop-only preferences for implicit opens into the ordinary side pane. */
   openInSidePane: OpenInSidePanePreferences;
@@ -163,7 +160,6 @@ export const DEFAULT_CLIENT_SETTINGS: AppSettings = {
   chatDisplay: "collapseTurns",
   chatOutlineEnabled: true,
   vimKeybindings: false,
-  sendShortcut: "enter",
   filePanelAssociations: {},
   openInSidePane: DEFAULT_OPEN_IN_SIDE_PANE_PREFERENCES,
   pullRequestOpenLocation: "explorer",
@@ -268,7 +264,6 @@ const StoredAppSettingsSchema = z
     compactToolCalls: z.boolean().optional().catch(undefined),
     chatOutlineEnabled: z.boolean().catch(true),
     vimKeybindings: z.boolean().catch(false),
-    sendShortcut: z.enum(["enter", "mod-enter"]).catch("enter"),
     filePanelAssociations: z.record(z.string(), z.string()).catch({}),
     openInSidePane: z
       .object({

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

@@ -2018,10 +2018,10 @@ export const ar: TranslationResources = {
     output: "الإخراج",
   },
   turnSummary: {
-    messages: {
-      one: "كتب {{count}} رسالة",
-      other: "كتب {{count}} رسائل",
-    },
+    details: "عرض تفاصيل الجولة",
+    sentBy: "أرسلها {{name}}",
+    showMore: "عرض المزيد",
+    showLess: "عرض أقل",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2369,25 +2369,12 @@ export const ar: TranslationResources = {
             "عند تشغيل الوكيل، يوجّه Enter الجولة النشطة. يضيف Command/Ctrl+Enter إلى قائمة الانتظار.",
           queue: "عند تشغيل الوكيل، يضيف Enter إلى قائمة الانتظار. Command/Ctrl+Enter يرسل.",
         },
-        commandEnterDescriptions: {
-          interrupt: "عند تشغيل الوكيل، يوقف {{modifier}}+Enter التشغيل. يُدرج Enter سطرًا جديدًا.",
-          steer: "عند تشغيل الوكيل، يوجّه {{modifier}}+Enter الجولة النشطة. يُدرج Enter سطرًا جديدًا.",
-          queue:
-            "عند تشغيل الوكيل، يضيف {{modifier}}+Enter إلى قائمة الانتظار. يُدرج Enter سطرًا جديدًا.",
-        },
         options: {
           interrupt: "مقاطعة",
           steer: "توجيه",
           queue: "طابور",
         },
       },
-      sendShortcut: {
-        label: "اختصار الإرسال",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "بسأل",

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

@@ -2043,10 +2043,10 @@ export const en = {
     output: "Output",
   },
   turnSummary: {
-    messages: {
-      one: "wrote {{count}} message",
-      other: "wrote {{count}} messages",
-    },
+    details: "View turn details",
+    sentBy: "Sent by {{name}}",
+    showMore: "Show more",
+    showLess: "Show less",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2457,26 +2457,12 @@ export const en = {
             "When the agent is running, Enter steers the active turn. Command/Ctrl+Enter queues.",
           queue: "When the agent is running, Enter queues. Command/Ctrl+Enter submits.",
         },
-        commandEnterDescriptions: {
-          interrupt:
-            "When the agent is running, {{modifier}}+Enter interrupts. Enter inserts a new line.",
-          steer:
-            "When the agent is running, {{modifier}}+Enter steers the active turn. Enter inserts a new line.",
-          queue: "When the agent is running, {{modifier}}+Enter queues. Enter inserts a new line.",
-        },
         options: {
           interrupt: "Interrupt",
           steer: "Steer",
           queue: "Queue",
         },
       },
-      sendShortcut: {
-        label: "Send shortcut",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "Ask",

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

@@ -2066,10 +2066,10 @@ export const es: TranslationResources = {
     output: "Producción",
   },
   turnSummary: {
-    messages: {
-      one: "escribió {{count}} mensaje",
-      other: "escribió {{count}} mensajes",
-    },
+    details: "Ver detalles del turno",
+    sentBy: "Enviado por {{name}}",
+    showMore: "Mostrar más",
+    showLess: "Mostrar menos",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2384,27 +2384,12 @@ export const es: TranslationResources = {
           queue:
             "Cuando el agente se está ejecutando, Enter pone en cola. Command/Ctrl+Enter envía.",
         },
-        commandEnterDescriptions: {
-          interrupt:
-            "Cuando el agente se está ejecutando, {{modifier}}+Enter interrumpe. Enter inserta una línea nueva.",
-          steer:
-            "Cuando el agente se está ejecutando, {{modifier}}+Enter dirige el turno activo. Enter inserta una línea nueva.",
-          queue:
-            "Cuando el agente se está ejecutando, {{modifier}}+Enter pone en cola. Enter inserta una línea nueva.",
-        },
         options: {
           interrupt: "Interrumpir",
           steer: "Dirigir",
           queue: "Cola",
         },
       },
-      sendShortcut: {
-        label: "Atajo de envío",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "Preguntar",

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

@@ -2065,10 +2065,10 @@ export const fr: TranslationResources = {
     output: "Sortie",
   },
   turnSummary: {
-    messages: {
-      one: "{{count}} message écrit",
-      other: "{{count}} messages écrits",
-    },
+    details: "Voir les détails du tour",
+    sentBy: "Envoyé par {{name}}",
+    showMore: "Afficher plus",
+    showLess: "Afficher moins",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2383,27 +2383,12 @@ export const fr: TranslationResources = {
           queue:
             "Quand l’agent est en cours d’exécution, Entrée met en file d’attente. Cmd/Ctrl+Entrée envoie.",
         },
-        commandEnterDescriptions: {
-          interrupt:
-            "Lorsque l'agent est en cours d'exécution, {{modifier}}+Entrée interrompt. Entrée insère une nouvelle ligne.",
-          steer:
-            "Lorsque l'agent est en cours d'exécution, {{modifier}}+Entrée oriente le tour actif. Entrée insère une nouvelle ligne.",
-          queue:
-            "Lorsque l'agent est en cours d'exécution, {{modifier}}+Entrée met en file d'attente. Entrée insère une nouvelle ligne.",
-        },
         options: {
           interrupt: "Interrompre",
           steer: "Réorienter",
           queue: "File d’attente",
         },
       },
-      sendShortcut: {
-        label: "Raccourci d’envoi",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "Demander",

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

@@ -2038,10 +2038,10 @@ export const ja: TranslationResources = {
     output: "出力",
   },
   turnSummary: {
-    messages: {
-      one: "{{count}}件のメッセージを送信",
-      other: "{{count}}件のメッセージを送信",
-    },
+    details: "ターンの詳細を表示",
+    sentBy: "{{name}} から送信",
+    showMore: "もっと見る",
+    showLess: "折りたたむ",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2353,25 +2353,12 @@ export const ja: TranslationResources = {
             "エージェント実行中、Enterで現在のターンに指示を送ります。Command/Ctrl+Enterでキューに追加。",
           queue: "エージェント実行中、Enterでキューに追加します。Command/Ctrl+Enterで送信。",
         },
-        commandEnterDescriptions: {
-          interrupt: "エージェント実行中、{{modifier}}+Enterで中断します。Enterで改行します。",
-          steer:
-            "エージェント実行中、{{modifier}}+Enterで現在のターンに指示を送ります。Enterで改行します。",
-          queue: "エージェント実行中、{{modifier}}+Enterでキューに追加します。Enterで改行します。",
-        },
         options: {
           interrupt: "中断",
           steer: "指示",
           queue: "キュー",
         },
       },
-      sendShortcut: {
-        label: "送信ショートカット",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "確認する",

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

@@ -2028,10 +2028,10 @@ export const ko: TranslationResources = {
     output: "출력",
   },
   turnSummary: {
-    messages: {
-      one: "{{count}} 메시지를 작성했습니다.",
-      other: "{{count}} 메시지를 작성했습니다.",
-    },
+    details: "턴 세부 정보 보기",
+    sentBy: "{{name}}이(가) 보냄",
+    showMore: "더 보기",
+    showLess: "접기",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2344,27 +2344,12 @@ export const ko: TranslationResources = {
           queue:
             "에이전트가 실행 중일 때 Enter는 대기열에 추가합니다. Command/Ctrl+Enter는 제출합니다.",
         },
-        commandEnterDescriptions: {
-          interrupt:
-            "에이전트가 실행 중일 때 {{modifier}}+Enter는 중단합니다. Enter는 줄바꿈합니다.",
-          steer:
-            "에이전트가 실행 중일 때 {{modifier}}+Enter는 현재 턴에 지시합니다. Enter는 줄바꿈합니다.",
-          queue:
-            "에이전트가 실행 중일 때 {{modifier}}+Enter는 대기열에 추가합니다. Enter는 줄바꿈합니다.",
-        },
         options: {
           interrupt: "중단",
           steer: "지시",
           queue: "대기열",
         },
       },
-      sendShortcut: {
-        label: "전송 단축키",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "물어보기",

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

@@ -2051,10 +2051,10 @@ export const ptBR: TranslationResources = {
     output: "Saída",
   },
   turnSummary: {
-    messages: {
-      one: "escreveu {{count}} mensagem",
-      other: "escreveu {{count}} mensagens",
-    },
+    details: "Ver detalhes do turno",
+    sentBy: "Enviado por {{name}}",
+    showMore: "Mostrar mais",
+    showLess: "Mostrar menos",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2367,27 +2367,12 @@ export const ptBR: TranslationResources = {
             "Quando o agente está em execução, Enter orienta o turno ativo. Command/Ctrl+Enter enfileira.",
           queue: "Quando o agente está em execução, Enter enfileira. Command/Ctrl+Enter envia.",
         },
-        commandEnterDescriptions: {
-          interrupt:
-            "Quando o agente está em execução, {{modifier}}+Enter interrompe. Enter insere uma nova linha.",
-          steer:
-            "Quando o agente está em execução, {{modifier}}+Enter orienta o turno ativo. Enter insere uma nova linha.",
-          queue:
-            "Quando o agente está em execução, {{modifier}}+Enter enfileira. Enter insere uma nova linha.",
-        },
         options: {
           interrupt: "Interromper",
           steer: "Orientar",
           queue: "Fila",
         },
       },
-      sendShortcut: {
-        label: "Atalho de envio",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "Perguntar",

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

@@ -2051,10 +2051,10 @@ export const ru: TranslationResources = {
     output: "Выходные данные",
   },
   turnSummary: {
-    messages: {
-      one: "написано {{count}} сообщение",
-      other: "написаны сообщения ({{count}})",
-    },
+    details: "Показать подробности хода",
+    sentBy: "Отправлено агентом {{name}}",
+    showMore: "Показать больше",
+    showLess: "Свернуть",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2370,27 +2370,12 @@ export const ru: TranslationResources = {
           queue:
             "Когда агент работает, Enter ставит сообщение в очередь, а Command/Ctrl+Enter отправляет его.",
         },
-        commandEnterDescriptions: {
-          interrupt:
-            "Когда агент работает, {{modifier}}+Enter прерывает его работу, а Enter вставляет новую строку.",
-          steer:
-            "Когда агент работает, {{modifier}}+Enter дополняет текущий ответ новым указанием, а Enter вставляет новую строку.",
-          queue:
-            "Когда агент работает, {{modifier}}+Enter ставит сообщение в очередь, а Enter вставляет новую строку.",
-        },
         options: {
           interrupt: "Прерывать",
           steer: "Направить",
           queue: "Поставить в очередь",
         },
       },
-      sendShortcut: {
-        label: "Сочетание клавиш для отправки",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "Спрашивать",

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

@@ -1996,10 +1996,10 @@ export const zhCN: TranslationResources = {
     output: "输出",
   },
   turnSummary: {
-    messages: {
-      one: "写了 {{count}} 条消息",
-      other: "写了 {{count}} 条消息",
-    },
+    details: "查看轮次详情",
+    sentBy: "由 {{name}} 发送",
+    showMore: "展开",
+    showLess: "收起",
   },
   toolCallGroup: {
     editedFiles: {
@@ -2308,24 +2308,12 @@ export const zhCN: TranslationResources = {
           steer: "Agent 运行时，Enter 会引导当前回合。Command/Ctrl+Enter 会排队。",
           queue: "Agent 运行时，Enter 会排队。Command/Ctrl+Enter 会提交。",
         },
-        commandEnterDescriptions: {
-          interrupt: "Agent 运行时，{{modifier}}+Enter 会中断。Enter 会插入换行。",
-          steer: "Agent 运行时，{{modifier}}+Enter 会引导当前回合。Enter 会插入换行。",
-          queue: "Agent 运行时，{{modifier}}+Enter 会排队。Enter 会插入换行。",
-        },
         options: {
           interrupt: "中断",
           steer: "引导",
           queue: "排队",
         },
       },
-      sendShortcut: {
-        label: "发送快捷键",
-        options: {
-          enter: "Enter",
-          "mod-enter": "{{modifier}}+Enter",
-        },
-      },
       serviceUrls: {
         options: {
           ask: "询问",

packages/app/src/screens/settings/general/sending-section.tsx

@@ -1,17 +1,13 @@
 import { useCallback, useMemo } from "react";
 import { useTranslation } from "react-i18next";
 import { SettingsCard, SettingsSection, SettingsSelect } from "@/components/settings";
-import { useAppSettings, type SendShortcut, type SendBehavior } from "@/hooks/use-settings";
-import { useKeyboardShortcutsAvailable } from "@/keyboard/availability";
-import { getShortcutOs } from "@/utils/shortcut-platform";
+import { useAppSettings, type SendBehavior } from "@/hooks/use-settings";
 
 const SEND_BEHAVIORS: readonly SendBehavior[] = ["interrupt", "steer", "queue"];
 
 export function SendingSection() {
   const { t } = useTranslation();
   const { settings, updateSettings } = useAppSettings();
-  const shortcutsAvailable = useKeyboardShortcutsAvailable();
-  const modifier = getShortcutOs() === "mac" ? "⌘" : "Ctrl";
   const options = useMemo(
     () =>
       SEND_BEHAVIORS.map((value) => ({
@@ -24,37 +20,12 @@ export function SendingSection() {
     (sendBehavior: SendBehavior) => void updateSettings({ sendBehavior }),
     [updateSettings],
   );
-  const shortcutOptions = useMemo(
-    () =>
-      (["enter", "mod-enter"] as const).map((value) => ({
-        value,
-        label: t(`settings.general.sendShortcut.options.${value}`, { modifier }),
-      })),
-    [t, modifier],
-  );
-  const changeSendShortcut = useCallback(
-    (sendShortcut: SendShortcut) => void updateSettings({ sendShortcut }),
-    [updateSettings],
-  );
   return (
     <SettingsSection title={t("settings.general.sending")}>
       <SettingsCard>
-        {shortcutsAvailable ? (
-          <SettingsSelect
-            label={t("settings.general.sendShortcut.label")}
-            value={settings.sendShortcut}
-            options={shortcutOptions}
-            onValueChange={changeSendShortcut}
-          />
-        ) : null}
         <SettingsSelect
           label={t("settings.general.defaultSend.label")}
-          hint={t(
-            shortcutsAvailable && settings.sendShortcut === "mod-enter"
-              ? `settings.general.defaultSend.commandEnterDescriptions.${settings.sendBehavior}`
-              : `settings.general.defaultSend.descriptions.${settings.sendBehavior}`,
-            { modifier },
-          )}
+          hint={t(`settings.general.defaultSend.descriptions.${settings.sendBehavior}`)}
           value={settings.sendBehavior}
           options={options}
           onValueChange={change}

packages/app/src/timeline/turn-time.test.ts

@@ -51,7 +51,7 @@ describe("deriveStreamTurnTiming", () => {
     });
 
     assert.equal(timing.runningStartedAt, secondUserAt);
-    assert.equal(timing.byAssistantId.has("a2"), false);
+    assert.equal(timing.byItemId.has("a2"), false);
   });
 
   it("derives completed turn timing from user and assistant item timestamps", () => {
@@ -69,7 +69,7 @@ describe("deriveStreamTurnTiming", () => {
       head: [],
     });
 
-    assert.deepEqual(timing.byAssistantId.get("a1"), {
+    assert.deepEqual(timing.byItemId.get("a1"), {
       completedAt: assistantAt,
       durationMs: 7000,
     });
@@ -95,8 +95,8 @@ describe("deriveStreamTurnTiming", () => {
       completedAt: lastAssistantAt,
       durationMs: 7000,
     };
-    assert.deepEqual(timing.byAssistantId.get("a1"), expected);
-    assert.deepEqual(timing.byAssistantId.get("a2"), expected);
+    assert.deepEqual(timing.byItemId.get("a1"), expected);
+    assert.deepEqual(timing.byItemId.get("a2"), expected);
   });
 
   it("preserves the completion timestamp when a canonical turn has no visible prompt", () => {
@@ -120,7 +120,7 @@ describe("deriveStreamTurnTiming", () => {
       head: [],
     });
 
-    assert.deepEqual(timing.byAssistantId.get("hidden-prompt-a2"), {
+    assert.deepEqual(timing.byItemId.get("hidden-prompt-a2"), {
       completedAt: hiddenPromptTurnAt,
       durationMs: null,
     });
@@ -143,12 +143,12 @@ describe("deriveStreamTurnTiming", () => {
     const first = derive("one", "2026-05-15T00:01:04.000Z");
     const second = derive("one two", "2026-05-15T00:01:05.000Z");
 
-    assert.equal(second.byAssistantId, first.byAssistantId);
-    assert.deepEqual(first.byAssistantId.get("a1"), {
+    assert.equal(second.byItemId, first.byItemId);
+    assert.deepEqual(first.byItemId.get("a1"), {
       completedAt: tail[1]?.timestamp,
       durationMs: 7000,
     });
-    assert.equal(first.byAssistantId.has("a2"), false);
+    assert.equal(first.byItemId.has("a2"), false);
   });
 
   it("keeps the timing map identity when the head closed the tail's open turn", () => {
@@ -168,8 +168,8 @@ describe("deriveStreamTurnTiming", () => {
     const first = derive("one", "2026-05-15T00:01:04.000Z");
     const second = derive("one two", "2026-05-15T00:01:05.000Z");
 
-    assert.equal(second.byAssistantId, first.byAssistantId);
-    assert.deepEqual(first.byAssistantId.get("a1"), {
+    assert.equal(second.byItemId, first.byItemId);
+    assert.deepEqual(first.byItemId.get("a1"), {
       completedAt: lastTailAt,
       durationMs: 7000,
     });
@@ -193,9 +193,9 @@ describe("deriveStreamTurnTiming", () => {
       head,
     });
 
-    assert.notEqual(completed.byAssistantId, active.byAssistantId);
-    assert.equal(active.byAssistantId.has("a1"), false);
-    assert.deepEqual(completed.byAssistantId.get("a1"), { completedAt, durationMs: 9000 });
+    assert.notEqual(completed.byItemId, active.byItemId);
+    assert.equal(active.byItemId.has("a1"), false);
+    assert.deepEqual(completed.byItemId.get("a1"), { completedAt, durationMs: 9000 });
   });
 
   it("derives fresh timing when the tail itself changes", () => {
@@ -211,11 +211,39 @@ describe("deriveStreamTurnTiming", () => {
     const first = derive(firstTail);
     const second = derive(secondTail);
 
-    assert.notEqual(second.byAssistantId, first.byAssistantId);
-    assert.equal(first.byAssistantId.has("a2"), false);
-    assert.deepEqual(second.byAssistantId.get("a2"), {
+    assert.notEqual(second.byItemId, first.byItemId);
+    assert.equal(first.byItemId.has("a2"), false);
+    assert.deepEqual(second.byItemId.get("a2"), {
       completedAt: secondTail[3]?.timestamp,
       durationMs: 3000,
     });
   });
 });
+
+it("times a heartbeat that ends with tools and no assistant text", () => {
+  const trigger: StreamItem = {
+    kind: "tool_call",
+    id: "trigger",
+    timestamp: new Date("2026-05-15T00:00:00Z"),
+    turnId: "heartbeat",
+    payload: {
+      source: "agent",
+      data: {
+        provider: "claude",
+        callId: "trigger",
+        name: "heartbeat",
+        status: "completed",
+        error: null,
+        detail: { type: "plain_text", text: "Check progress" },
+      },
+    },
+  };
+  const tool: StreamItem = { ...trigger, id: "last", timestamp: new Date("2026-05-15T00:00:05Z") };
+  const timing = deriveStreamTurnTiming({
+    tail: [trigger, tool],
+    head: [],
+    isTurnActive: false,
+    activeTurnStartedAt: null,
+  });
+  assert.equal(timing.byItemId.get("last")?.durationMs, 5000);
+});

packages/app/src/timeline/turn-time.ts

@@ -1,5 +1,5 @@
 import type { StreamItem } from "@/types/stream";
-import { startsNewTurn } from "@/agent-stream/turn-membership";
+import { startsNewTurn, isTurnTrigger } from "@/agent-stream/turn-membership";
 
 export interface TurnTiming {
   completedAt: Date;
@@ -7,7 +7,7 @@ export interface TurnTiming {
 }
 
 export interface StreamTurnTiming {
-  byAssistantId: Map<string, TurnTiming>;
+  byItemId: Map<string, TurnTiming>;
   runningStartedAt: Date | null;
 }
 
@@ -20,7 +20,7 @@ interface OpenTurn {
 
 interface HeadTurnTiming {
   additions: Map<string, TurnTiming>;
-  byAssistantId: Map<string, TurnTiming>;
+  byItemId: Map<string, TurnTiming>;
 }
 
 interface TailTurnTiming {
@@ -37,14 +37,18 @@ const EMPTY_OPEN_TURN: OpenTurn = {
 };
 
 function closeTurn(turn: OpenTurn, into: Map<string, TurnTiming>): void {
-  if (!turn.lastItemAt || turn.assistantIds.length === 0) {
+  if (!turn.lastItemAt) {
     return;
   }
   const timing: TurnTiming = {
     completedAt: turn.lastItemAt,
     durationMs: turn.userAt ? Math.max(0, turn.lastItemAt.getTime() - turn.userAt.getTime()) : null,
   };
-  for (const id of turn.assistantIds) {
+  let footerIds = turn.assistantIds;
+  if (footerIds.length === 0 && turn.previousItem?.kind === "tool_call") {
+    footerIds = [turn.previousItem.id];
+  }
+  for (const id of footerIds) {
     into.set(id, timing);
   }
 }
@@ -61,7 +65,7 @@ function walkTurns(
   for (const item of items) {
     if (startsNewTurn(item, previousItem)) {
       closeTurn({ userAt, lastItemAt, assistantIds, previousItem }, into);
-      userAt = item.kind === "user_message" ? item.timestamp : null;
+      userAt = isTurnTrigger(item) ? item.timestamp : null;
       lastItemAt = null;
       assistantIds = [];
     }
@@ -108,7 +112,7 @@ function getTailTurnTiming(tail: StreamItem[]): TailTurnTiming {
   return timing;
 }
 
-function resolveByAssistantId(
+function resolveByItemId(
   tail: TailTurnTiming,
   additions: Map<string, TurnTiming>,
 ): Map<string, TurnTiming> {
@@ -116,14 +120,14 @@ function resolveByAssistantId(
     return tail.completed;
   }
   if (tail.lastHead && areTimingsEqual(tail.lastHead.additions, additions)) {
-    return tail.lastHead.byAssistantId;
+    return tail.lastHead.byItemId;
   }
-  const byAssistantId = new Map(tail.completed);
+  const byItemId = new Map(tail.completed);
   for (const [id, timing] of additions) {
-    byAssistantId.set(id, timing);
+    byItemId.set(id, timing);
   }
-  tail.lastHead = { additions, byAssistantId };
-  return byAssistantId;
+  tail.lastHead = { additions, byItemId };
+  return byItemId;
 }
 
 export function deriveStreamTurnTiming(params: {
@@ -139,7 +143,7 @@ export function deriveStreamTurnTiming(params: {
     closeTurn(openTurn, additions);
   }
   return {
-    byAssistantId: resolveByAssistantId(tail, additions),
+    byItemId: resolveByItemId(tail, additions),
     runningStartedAt: params.isTurnActive ? params.activeTurnStartedAt : null,
   };
 }

packages/app/src/tool-calls/detail-level/grouping.ts

@@ -1,3 +1,4 @@
+import { isTurnTrigger, isTurnBoundary } from "@/agent-stream/turn-membership";
 import type { ToolCallDetail } from "@getpaseo/protocol/agent-types";
 import type { StreamItem, ToolCallItem } from "@/types/stream";
 
@@ -63,7 +64,7 @@ export function describeToolCall(item: ToolCallItem): ToolCallDescriptor {
 }
 
 export function isGroupableToolCall(item: StreamItem): item is ToolCallItem {
-  if (item.kind !== "tool_call") {
+  if (item.kind !== "tool_call" || isTurnTrigger(item)) {
     return false;
   }
   const descriptor = describeToolCall(item);
@@ -116,7 +117,7 @@ export function prepareGroupedHistory<TGroup>(input: {
   let pending: ToolCallItem[] = [];
 
   for (const item of input.tail) {
-    if (isGroupableToolCall(item)) {
+    if (isGroupableToolCall(item) && !isTurnBoundary(pending.at(-1) ?? null, item)) {
       pending.push(item);
       continue;
     }
@@ -128,7 +129,8 @@ export function prepareGroupedHistory<TGroup>(input: {
       buildGroup: input.buildGroup,
     });
     pending = [];
-    output.push(item);
+    if (isGroupableToolCall(item)) pending.push(item);
+    else output.push(item);
   }
 
   appendRun({
@@ -175,6 +177,7 @@ export function groupLiveToolCalls<TGroup>(input: {
   };
 
   for (const item of input.head) {
+    if (isTurnBoundary(pending.at(-1) ?? null, item)) flush(true);
     if (isGroupableToolCall(item)) {
       if (pending.length === 0) {
         hostPlacement = "head";

packages/app/src/tool-calls/detail-level/projection.test.ts

@@ -480,3 +480,24 @@ describe("tool call detail-level projection", () => {
     expect(result.groupsByHostId.size).toBe(1);
   });
 });
+
+it("keeps a heartbeat trigger visible outside grouped work", () => {
+  const trigger = toolCall(
+    "1",
+    { type: "plain_text", text: "Check progress" },
+    { name: "heartbeat" },
+  );
+  const work = toolCall("2", { type: "shell", command: "pwd" });
+  const result = project({ level: "overview", tail: [trigger, work] });
+  expect(result.tail.map((item) => item.id)).toEqual(["1", "2"]);
+  expect(result.groupsByHostId.has("1")).toBe(false);
+});
+
+it("does not merge tools from different canonical turns", () => {
+  const first = toolCall("1", { type: "shell", command: "pwd" });
+  first.turnId = "first";
+  const second = toolCall("2", { type: "shell", command: "ls" });
+  second.turnId = "second";
+  const result = project({ level: "overview", tail: [first, second] });
+  expect(result.tail.map((item) => item.id)).toEqual(["1", "2"]);
+});

packages/app/src/types/stream.ts

@@ -91,6 +91,8 @@ export type StreamItem =
 export type UserMessageImageAttachment = AttachmentMetadata;
 
 export interface UserMessageItem {
+  /** Attribution added by presentation for received agent messages. */
+  sender?: AgentMessage["sender"];
   kind: "user_message";
   id: string;
   clientMessageId?: string;

packages/client/src/index.test.ts

@@ -1770,66 +1770,3 @@ test("qualified parents preserve foreign identity without resolving an equal loc
   await client.close();
   expect(localParent.address).toEqual({ serverId: "srv_sdk_test", agentId: "same-parent" });
 });
-
-test("agent reload reopens through the daemon RPC then returns the observed snapshot; refresh remains a read", async () => {
-  const { client, ws } = await connectClient();
-  try {
-    const agent = client.agents.ref("agent_sdk");
-    const snapshot = createAgent();
-    const reloaded = agent.reload({ requestId: "reload-sdk" });
-    expect(parseSentSessionMessage(ws.sent.at(-1))).toMatchObject({
-      type: "refresh_agent_request",
-      agentId: "agent_sdk",
-      requestId: "reload-sdk",
-    });
-    ws.message(
-      sessionMessage({
-        type: "status",
-        payload: {
-          status: "agent_refreshed",
-          requestId: "reload-sdk",
-          agentId: "agent_sdk",
-          timelineSize: 0,
-        },
-      }),
-    );
-    await expect
-      .poll(() => parseSentSessionMessage(ws.sent.at(-1)).type)
-      .toBe("fetch_agent_request");
-    const fetched = parseSentSessionMessage(ws.sent.at(-1));
-    ws.message(
-      sessionMessage({
-        type: "fetch_agent_response",
-        payload: {
-          requestId: fetched.requestId,
-          agentId: "agent_sdk",
-          agent: snapshot,
-          project: null,
-          error: null,
-        },
-      }),
-    );
-    expect(await reloaded).toEqual({ agent: snapshot, project: null });
-    expect(agent.current()).toEqual(snapshot);
-    const read = agent.refresh("snapshot-read");
-    expect(parseSentSessionMessage(ws.sent.at(-1))).toMatchObject({
-      type: "fetch_agent_request",
-      requestId: "snapshot-read",
-    });
-    ws.message(
-      sessionMessage({
-        type: "fetch_agent_response",
-        payload: {
-          requestId: "snapshot-read",
-          agentId: "agent_sdk",
-          agent: snapshot,
-          project: null,
-          error: null,
-        },
-      }),
-    );
-    expect(await read).toEqual({ agent: snapshot, project: null });
-  } finally {
-    await client.close();
-  }
-});

packages/client/src/index.ts

@@ -369,11 +369,6 @@ export interface PaseoAgentHandle {
   readonly timeline: PaseoAgentTimelineHandle;
   current(): PaseoAgent | null;
   refresh(requestId?: string): Promise<PaseoAgentRefetchResult | null>;
-  /**
-   * Reopens the provider session with current configuration, rerunning session-open hooks.
-   * Interrupts a running turn and returns the refreshed snapshot.
-   */
-  reload(options?: { requestId?: string }): Promise<PaseoAgentRefetchResult | null>;
   send(text: string, options?: PaseoAgentSendOptions): Promise<void>;
   respondToPermission(options: PaseoAgentRespondToPermissionOptions): Promise<void>;
   /** Sends a prompt and resolves when that turn finishes or needs attention. */
@@ -986,12 +981,6 @@ function createAgentHandleFactory(
         current = result?.agent ?? null;
         return result;
       },
-      reload: async (options) => {
-        await daemonClient.refreshAgent(id, options?.requestId);
-        const result = await daemonClient.fetchAgent({ agentId: id });
-        current = result?.agent ?? null;
-        return result;
-      },
       send: async (text, options) => {
         await daemonClient.sendAgentMessage(id, text, options);
       },

packages/highlight/src/__tests__/highlighter.test.ts

@@ -1,6 +1,4 @@
 import { describe, it, expect } from "vitest";
-import { setImmediate } from "node:timers/promises";
-import { highlightCodeWithBudget, HIGHLIGHT_MAX_SOURCE_BYTES } from "../budgeted-highlighter.js";
 import type { HighlightToken } from "../types.js";
 import { highlightCode, highlightCodeInSteps, highlightLine } from "../highlighter.js";
 
@@ -422,55 +420,3 @@ describe("highlightLine", () => {
     expect(tokens).toEqual([{ text: "hello", style: null }]);
   });
 });
-
-describe("highlightCodeWithBudget", () => {
-  it("yields to IO while producing byte-identical output below the source budget", async () => {
-    const code = "const value = Math.max(42, 7);\n".repeat(3_000);
-    const expected = JSON.stringify(highlightCode(code, "file.ts"));
-    let ticks = 0;
-    let longestGap = 0;
-    let lastTick = performance.now();
-    const timer = setInterval(() => {
-      const now = performance.now();
-      longestGap = Math.max(longestGap, now - lastTick);
-      lastTick = now;
-      ticks++;
-    }, 1);
-    try {
-      const actual = await highlightCodeWithBudget(code, "file.ts", {
-        yieldToEventLoop: setImmediate,
-      });
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      expect(ticks).toBeGreaterThan(1);
-      expect(longestGap).toBeLessThan(50);
-      expect(JSON.stringify(actual)).toBe(expected);
-    } finally {
-      clearInterval(timer);
-    }
-  });
-
-  it("budgets UTF-8 bytes before parsing, including multibyte text", async () => {
-    expect(
-      await highlightCodeWithBudget("é".repeat(HIGHLIGHT_MAX_SOURCE_BYTES / 2 + 1), "file.ts", {
-        yieldToEventLoop: setImmediate,
-      }),
-    ).toBeNull();
-    expect(
-      await highlightCodeWithBudget("a".repeat(HIGHLIGHT_MAX_SOURCE_BYTES + 1), "file.ts", {
-        yieldToEventLoop: setImmediate,
-      }),
-    ).toBeNull();
-  });
-
-  it("stops a parser that is cancelled between real event-loop turns", async () => {
-    const controller = new AbortController();
-    const pending = highlightCodeWithBudget(
-      "const value = Math.max(42, 7);\n".repeat(3_000),
-      "file.ts",
-      { yieldToEventLoop: setImmediate, signal: controller.signal },
-    );
-    await setImmediate();
-    controller.abort();
-    expect(await pending).toBeNull();
-  });
-});

packages/highlight/src/budgeted-highlighter.ts

@@ -1,49 +0,0 @@
-import { highlightCodeInSteps } from "./highlighter.js";
-import type { HighlightToken } from "./types.js";
-
-// Full source, rather than patch size, bounds parser and token allocation work.
-// Each token consumes a source code unit or an empty line: at most the byte cap + 1 records.
-export const HIGHLIGHT_MAX_SOURCE_BYTES = 768 * 1024;
-const SLICE_MS = 4;
-
-/**
- * Returns null when source exceeds the budget or the request is cancelled.
- * The host supplies a real event-loop yield (setImmediate on the daemon).
- * Existing synchronous highlighting remains available for its existing consumers.
- */
-export async function highlightCodeWithBudget(
-  code: string,
-  filename: string,
-  options: { yieldToEventLoop: () => Promise<void>; signal?: { readonly aborted: boolean } },
-): Promise<HighlightToken[][] | null> {
-  if (options.signal?.aborted || exceedsSourceBudget(code)) return null;
-  const steps = highlightCodeInSteps(code, filename);
-  let sliceStarted = Date.now();
-  try {
-    for (;;) {
-      if (options.signal?.aborted) return null;
-      const step = steps.next();
-      if (step.done) return step.value;
-      if (Date.now() - sliceStarted >= SLICE_MS) {
-        await options.yieldToEventLoop();
-        sliceStarted = Date.now();
-      }
-    }
-  } finally {
-    steps.return([]);
-  }
-}
-
-function exceedsSourceBudget(code: string): boolean {
-  if (code.length > HIGHLIGHT_MAX_SOURCE_BYTES) return true;
-  let bytes = 0;
-  for (const char of code) {
-    const point = char.codePointAt(0)!;
-    if (point < 0x80) bytes++;
-    else if (point < 0x800) bytes += 2;
-    else if (point < 0x10000) bytes += 3;
-    else bytes += 4;
-    if (bytes > HIGHLIGHT_MAX_SOURCE_BYTES) return true;
-  }
-  return false;
-}

packages/highlight/src/index.ts

@@ -15,4 +15,3 @@ export {
   isSyntaxThemeId,
   resolveSyntaxColors,
 } from "./themes.js";
-export { highlightCodeWithBudget, HIGHLIGHT_MAX_SOURCE_BYTES } from "./budgeted-highlighter.js";

packages/plugin/src/boundaries.test.ts

@@ -92,12 +92,7 @@ function typeErrors(code: string): string[] {
 }
 describe("plugin SDK import boundaries", () => {
   it("publishes process capabilities without their Windows implementation helpers", () => {
-    expect(Object.keys(server).sort()).toEqual([
-      "defineAgentTool",
-      "execCommand",
-      "spawnProcess",
-      "terminateProcess",
-    ]);
+    expect(Object.keys(server).sort()).toEqual(["execCommand", "spawnProcess", "terminateProcess"]);
   });
 
   it("classifies every published entry", () => {
@@ -214,54 +209,3 @@ describe("plugin panel SDK boundary", () => {
     ).toEqual([]);
   });
 });
-
-describe("plugin agent tools SDK boundary", () => {
-  it("lets a session hook attach typed tools without exposing their transport", () => {
-    expect(
-      typeErrors(`
-      import { z } from "zod";
-      import { defineAgentTool, type PluginServerContext, type AgentToolResult, type AgentToolContext, type AgentToolDefinition } from "@getpaseo/plugin/server";
-      const tool: AgentToolDefinition = defineAgentTool({
-        name: "create_issue",
-        description: "Create an issue",
-        input: z.object({ title: z.string(), count: z.string().transform(Number) }),
-        async execute(input, { agent, paseo, signal }) {
-          const count: number = input.count;
-          // @ts-expect-error input is inferred from the schema
-          input.missing;
-          return { text: agent.id + input.title, structuredContent: { count } };
-        },
-      });
-      export default function contribute(server: PluginServerContext) {
-        server.before("agent.session_open", ({ request }) => {
-          const title: string | null = request.title;
-          // @ts-expect-error labels are read-only
-          request.labels.x = "changed";
-          if (request.labels.x !== "y") return;
-          return { ...request, tools: [...request.tools, tool] };
-        });
-        return () => {};
-      }
-    `),
-    ).toEqual([]);
-  });
-});
-
-describe("agent session reload SDK boundary", () => {
-  it("exposes reload separately from snapshot refresh", () => {
-    expect(
-      typeErrors(`
-      import { type PluginServerContext } from "@getpaseo/plugin/server";
-      import { type PaseoAgentRefetchResult } from "@getpaseo/client";
-      async function reload(server: PluginServerContext, paseo: import("@getpaseo/client").PaseoApi) {
-        const agent = paseo.agents.ref("chosen-agent");
-        const read: PaseoAgentRefetchResult | null = await agent.refresh("read-snapshot");
-        const reopened: PaseoAgentRefetchResult | null = await agent.reload({ requestId: "reload-session" });
-        await agent.reload();
-        // @ts-expect-error reload options can grow without a positional signature change
-        await agent.reload("reload-session");
-      }
-    `),
-    ).toEqual([]);
-  });
-});

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

@@ -1,39 +0,0 @@
-import type { PaseoApi } from "@getpaseo/client";
-import type { z } from "zod";
-import type { PluginHookAgent } from "./lifecycle.js";
-
-export interface AgentToolContext {
-  agent: PluginHookAgent;
-  paseo: PaseoApi;
-  signal: AbortSignal;
-}
-
-export interface AgentToolResult {
-  text?: string;
-  structuredContent?: unknown;
-  isError?: boolean;
-}
-
-export interface AgentToolDefinition {
-  name: string;
-  title?: string;
-  description: string;
-  input: z.ZodType;
-  execute(input: unknown, context: AgentToolContext): AgentToolResult | Promise<AgentToolResult>;
-}
-
-export function defineAgentTool<Input extends z.ZodType>(tool: {
-  name: string;
-  title?: string;
-  description: string;
-  input: Input;
-  execute(
-    input: z.output<Input>,
-    context: AgentToolContext,
-  ): AgentToolResult | Promise<AgentToolResult>;
-}): AgentToolDefinition {
-  if (!/^[a-z][a-z0-9_]*$/.test(tool.name) || tool.name.length > 64) {
-    throw new Error(`Invalid agent tool name: ${tool.name}`);
-  }
-  return tool;
-}

packages/plugin/src/server/index.ts

@@ -24,6 +24,3 @@ export type {
 } from "./lifecycle.js";
 
 export { spawnProcess, execCommand, terminateProcess } from "./process.js";
-
-export { defineAgentTool } from "./agent-tools.js";
-export type { AgentToolDefinition, AgentToolResult, AgentToolContext } from "./agent-tools.js";

packages/plugin/src/server/lifecycle.ts

@@ -1,4 +1,3 @@
-import type { AgentToolDefinition } from "./agent-tools.js";
 import type {
   AgentPermissionRequest,
   AgentPermissionResponse,
@@ -37,9 +36,6 @@ export interface PluginSessionOpenRequest {
   cwd: string;
   reason: "create" | "resume" | "refresh" | "import";
   purpose: "interactive" | "history";
-  readonly title: string | null;
-  readonly labels: Readonly<Record<string, string>>;
-  tools: AgentToolDefinition[];
   env: Record<string, string>;
 }
 

packages/server/package.json

@@ -89,7 +89,7 @@
     "speech:transcribe:local": "tsx scripts/transcribe-local-wav.ts",
     "test": "npm run test:unit && npm run test:integration",
     "test:unit": "vitest run --fileParallelism --exclude \"**/*.e2e.test.ts\"",
-    "test:integration": "vitest run --maxWorkers=1 src/server/git-filename-diffs.e2e.test.ts src/server/daemon-e2e/checkout-diff-content.e2e.test.ts src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/workspace-create-worktree-source.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/daemon-e2e/oversized-message.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts src/server/connected-hosts/hosts.e2e.test.ts && vitest run --maxWorkers=1 src/server/agent/providers/omp/history.e2e.test.ts src/server/daemon-e2e/git-operations.e2e.test.ts src/server/session.create-agent-worktree-autoarchive.e2e.test.ts src/server/agent/providers/opencode-bridge.local.e2e.test.ts src/server/daemon-e2e/relay-transport.e2e.test.ts -t \"merges into|creates a worktree and auto-archives both|versioned runtime|oversized attachments|connected hosts|password-protected daemon refuses|replays selected OMP history\"",
+    "test:integration": "vitest run --maxWorkers=1 src/server/git-filename-diffs.e2e.test.ts src/server/daemon-e2e/checkout-diff-content.e2e.test.ts src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/workspace-create-worktree-source.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/daemon-e2e/oversized-message.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts src/server/connected-hosts/hosts.e2e.test.ts && vitest run --maxWorkers=1 src/server/daemon-e2e/git-operations.e2e.test.ts src/server/session.create-agent-worktree-autoarchive.e2e.test.ts src/server/agent/providers/opencode-bridge.local.e2e.test.ts src/server/daemon-e2e/relay-transport.e2e.test.ts -t \"merges into|creates a worktree and auto-archives both|versioned runtime|oversized attachments|connected hosts|password-protected daemon refuses\"",
     "test:hub-cli-contract": "vitest run --maxWorkers=1 src/server/hub/hub-cli-contract.test.ts",
     "test:integration:all": "npm run test:e2e",
     "test:integration:real": "vitest run real.e2e.test.ts",

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

@@ -11341,7 +11341,7 @@ test("listImportableSessions searches every provider result before global rankin
   ]);
 });
 
-test("user_message events wrapping a paseo-system envelope are not added to the timeline", async () => {
+test("system-injected prompts appear as trigger tools in the live timeline", async () => {
   const workdir = mkdtempSync(join(tmpdir(), "agent-manager-envelope-live-"));
   const storagePath = join(workdir, "agents");
   const storage = new AgentStorage(storagePath, logger);
@@ -11370,13 +11370,16 @@ test("user_message events wrapping a paseo-system envelope are not added to the
   await manager.runAgent(snapshot.id, { text: "do something" });
 
   const timeline = manager.getTimeline(snapshot.id);
+  expect(timeline).toContainEqual(
+    expect.objectContaining({ type: "tool_call", name: "heartbeat", status: "completed" }),
+  );
   const userMessages = timeline.filter((item) => item.type === "user_message");
 
   expect(userMessages).toHaveLength(1);
   expect(userMessages[0].text).toBe("plain user message");
 });
 
-test("user_message events wrapping a paseo-system envelope are not restored during history replay", async () => {
+test("system-injected prompts appear as trigger tools during history replay", async () => {
   const workdir = mkdtempSync(join(tmpdir(), "agent-manager-envelope-history-"));
   const storagePath = join(workdir, "agents");
   const storage = new AgentStorage(storagePath, logger);
@@ -11411,6 +11414,9 @@ test("user_message events wrapping a paseo-system envelope are not restored duri
   await manager.hydrateTimelineFromProvider(snapshot.id, { force: true });
 
   const timeline = manager.getTimeline(snapshot.id);
+  expect(timeline).toContainEqual(
+    expect.objectContaining({ type: "tool_call", name: "heartbeat", status: "completed" }),
+  );
   const userMessages = timeline.filter((item) => item.type === "user_message");
 
   expect(userMessages).toHaveLength(1);

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

@@ -1,5 +1,3 @@
-import type { AttachedAgentTool, PluginAgentToolsRuntime } from "../plugins/agent-tools.js";
-import type { AgentToolResult } from "@getpaseo/plugin/server";
 import type { RuntimeCleanupCandidate } from "./idle-runtime-cleanup/index.js";
 import { ensureAgentLoaded } from "./agent-loading.js";
 import { projectTimelineRows } from "./timeline-projection.js";
@@ -335,7 +333,6 @@ export interface AgentManagerOptions {
   terminalManager?: TerminalManager | null;
   mcpBaseUrl?: string;
   mcpAuthToken?: string;
-  pluginAgentTools?: PluginAgentToolsRuntime;
   paseoToolsEnabled?: boolean;
   paseoToolCatalogFactory?: PaseoToolCatalogFactory;
   resolvePaseoToolPolicy?: (provider: AgentProvider) => ProviderPaseoToolsPolicy | undefined;
@@ -769,10 +766,6 @@ export class AgentManager {
   private readonly agentStreamCoalescer: AgentStreamCoalescer;
   private mcpBaseUrl: string | null;
   private readonly mcpAuthToken: string | null;
-  private sessionOpenGeneration = 0;
-  private readonly sessionOpenGenerations = new Map<string, number>();
-  private readonly attachedPluginTools = new Map<string, AttachedAgentTool[]>();
-  private readonly pluginAgentTools: PluginAgentToolsRuntime | undefined;
   private paseoToolsEnabled = true;
   private paseoToolCatalogFactory: PaseoToolCatalogFactory | null = null;
   private readonly paseoToolPolicies = new Map<string, ProviderPaseoToolsPolicy | undefined>();
@@ -790,7 +783,6 @@ export class AgentManager {
 
   constructor(options: AgentManagerOptions) {
     this.pluginLifecycle = options.pluginLifecycle;
-    this.pluginAgentTools = options.pluginAgentTools;
     this.timelineStore = options.timelineStore ?? new InMemoryAgentTimelineStore();
     this.idFactory = options.idFactory ?? (() => randomUUID());
     this.registry = options?.registry;
@@ -895,62 +887,6 @@ export class AgentManager {
     this.paseoToolCatalogFactory = factory;
   }
 
-  invalidatePluginSessions(): void {
-    this.sessionOpenGeneration++;
-  }
-
-  async reloadStalePluginSession(agentId: string): Promise<void> {
-    if (!this.needsPluginSessionReload(agentId)) return;
-    await this.trackAgentRegistrationOperation(
-      this.runLifecycleMutation(agentId, async () => {
-        if (!this.needsPluginSessionReload(agentId)) return;
-        await this.reloadAgentSessionInternal(agentId);
-      }),
-    );
-  }
-
-  private needsPluginSessionReload(agentId: string): boolean {
-    const agent = this.getAgent(agentId);
-    return (
-      agent !== null &&
-      agent.lifecycle !== "closed" &&
-      this.sessionOpenGenerations.get(agentId) !== this.sessionOpenGeneration &&
-      !this.hasInFlightRun(agentId)
-    );
-  }
-
-  getPluginTools(agentId: string): readonly AttachedAgentTool[] {
-    return (this.attachedPluginTools.get(agentId) ?? []).filter((tool) =>
-      this.pluginAgentTools?.isToolPluginAvailable(tool.pluginId, tool.pluginInstanceId),
-    );
-  }
-
-  async executePluginTool(
-    tool: AttachedAgentTool,
-    agentId: string,
-    input: unknown,
-    signal?: AbortSignal,
-  ): Promise<AgentToolResult> {
-    const agent = this.getAgent(agentId);
-    if (!agent || agent.lifecycle === "closed") throw new Error(`Agent is not live: ${agentId}`);
-    if (!this.pluginAgentTools) throw new Error("Plugin tools are unavailable");
-    const record = await this.registry?.get(agentId);
-    return this.pluginAgentTools.callTool(
-      tool.pluginId,
-      tool.pluginInstanceId,
-      describeHookAgent({ ...agent, title: record?.title ?? agent.config.title }),
-      tool.name,
-      input,
-      signal,
-    );
-  }
-
-  private detachPluginTools(agentId: string): void {
-    this.attachedPluginTools.delete(agentId);
-    this.sessionOpenGenerations.delete(agentId);
-    this.pluginAgentTools?.detachTools(agentId);
-  }
-
   getPaseoToolPolicy(agentId: string): ProviderPaseoToolsPolicy | undefined {
     return this.paseoToolPolicies.get(agentId);
   }
@@ -1376,13 +1312,7 @@ export class AgentManager {
       storedConfig.cwd,
       paseoToolPolicy,
       options?.env,
-      {
-        reason: "create",
-        purpose: "interactive",
-        workspaceId: options.workspaceId ?? null,
-        title: options.initialTitle ?? storedConfig.title ?? null,
-        labels: options.labels ?? {},
-      },
+      { reason: "create", purpose: "interactive", workspaceId: options.workspaceId ?? null },
     );
     const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
     const createOptions = this.buildCreateSessionOptions(options);
@@ -1504,8 +1434,6 @@ export class AgentManager {
         reason: "resume",
         purpose,
         workspaceId: options?.workspaceId ?? null,
-        title: record?.title ?? mergedConfig.title ?? null,
-        labels: record?.labels ?? options?.labels ?? {},
       },
     );
     const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
@@ -1563,12 +1491,7 @@ export class AgentManager {
       storedConfig.cwd,
       paseoToolPolicy,
       undefined,
-      {
-        reason: "import",
-        purpose: "interactive",
-        workspaceId: input.workspaceId,
-        labels: input.labels ?? {},
-      },
+      { reason: "import", purpose: "interactive", workspaceId: input.workspaceId },
     );
     const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
     const imported = await client.importSession(
@@ -1663,13 +1586,7 @@ export class AgentManager {
       storedConfig.cwd,
       paseoToolPolicy,
       undefined,
-      {
-        reason: "refresh",
-        purpose: "interactive",
-        workspaceId: existing.workspaceId,
-        title: await this.resolveInitialPersistedTitle(agentId, existing.config, null),
-        labels: existing.labels,
-      },
+      { reason: "refresh", purpose: "interactive", workspaceId: existing.workspaceId },
     );
     const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
     if (
@@ -1733,7 +1650,6 @@ export class AgentManager {
       throw error;
     } finally {
       if (!handedToRegistration) {
-        this.detachPluginTools(agentId);
         if (hadPreviousPaseoToolPolicy) {
           this.paseoToolPolicies.set(agentId, previousPaseoToolPolicy);
         } else {
@@ -1941,7 +1857,6 @@ export class AgentManager {
     } catch (error) {
       persistError = error;
     }
-    this.detachPluginTools(agentId);
     this.emitClosedAgent(closedAgent, { persist: false });
     this.logger.trace(
       {
@@ -4025,7 +3940,6 @@ export class AgentManager {
   private discardRetainedAgentState(agentId: string): void {
     this.timelineStore.delete(agentId);
     this.paseoToolPolicies.delete(agentId);
-    this.detachPluginTools(agentId);
     for (const event of this.providerSubagents.deleteParent(agentId)) {
       this.dispatch({ type: "provider_subagent", event });
     }
@@ -5512,15 +5426,10 @@ export class AgentManager {
       reason: PluginSessionOpenRequest["reason"];
       purpose: PluginSessionOpenRequest["purpose"];
       workspaceId?: string | null;
-      title?: string | null;
-      labels?: Record<string, string>;
     },
   ): Promise<AgentLaunchContext> {
-    // A plugin changing during this open must still make the resulting session stale.
-    const generation = this.sessionOpenGeneration;
-    this.detachPluginTools(agentId);
     if (this.pluginLifecycle) {
-      const request = {
+      const request: PluginSessionOpenRequest = {
         agentId,
         provider: client.provider,
         cwd,
@@ -5528,14 +5437,9 @@ export class AgentManager {
         reason: opening?.reason ?? "resume",
         purpose: opening?.purpose ?? "interactive",
         env: { ...env },
-        title: opening?.title ?? null,
-        labels: opening?.labels ?? {},
-        tools: [],
       };
       const transformed = await this.pluginLifecycle.before("agent.session_open", request);
       env = transformed.env;
-      if (request.purpose === "interactive")
-        this.attachedPluginTools.set(agentId, transformed.tools as AttachedAgentTool[]);
     }
     const context: AgentLaunchContext = {
       agentId,
@@ -5545,26 +5449,17 @@ export class AgentManager {
         PASEO_AGENT_CWD: cwd,
       },
     };
-    const useNativeTools =
+    if (
       this.paseoToolsEnabled &&
       isPaseoToolPolicyEnabled(paseoToolPolicy) &&
-      client.capabilities.supportsNativePaseoTools;
-    if (
-      this.paseoToolCatalogFactory &&
-      (useNativeTools || this.getPluginTools(agentId).length > 0)
+      client.capabilities.supportsNativePaseoTools &&
+      this.paseoToolCatalogFactory
     ) {
-      try {
-        const catalog = await this.paseoToolCatalogFactory({
-          callerAgentId: agentId,
-          paseoToolPolicy,
-        });
-        if (useNativeTools) context.paseoTools = catalog;
-      } catch (error) {
-        this.detachPluginTools(agentId);
-        throw error;
-      }
+      context.paseoTools = await this.paseoToolCatalogFactory({
+        callerAgentId: agentId,
+        paseoToolPolicy,
+      });
     }
-    this.sessionOpenGenerations.set(agentId, generation);
     return context;
   }
 

packages/server/src/server/agent/agent-messages/envelope.ts

@@ -1,5 +1,5 @@
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
 import type {
   AgentPromptContentBlock,
@@ -175,9 +175,18 @@ function projectAgentMessage(item: AgentTimelineItem): AgentTimelineItem | null
   if (item.type !== "user_message") return item;
   const message = parseAgentMessage(item.text);
   if (!message) {
-    // COMPAT(legacySystemEnvelope): added in v0.11.1; remove after 2027-04-08 once
-    // legacy notification history is retired. Schedules still use this envelope.
-    return isSystemInjectedEnvelope(item.text) ? null : item;
+    // Schedule bodies include their run ID, keeping identity stable across acceptance
+    // and provider replay even when the provider assigns its own message ID.
+    if (!isSystemInjectedEnvelope(item.text)) return item;
+    const text = item.text.slice("<paseo-system>\n".length, -"\n</paseo-system>".length);
+    return {
+      type: "tool_call",
+      callId: `paseo-system:${createHash("sha256").update(item.text).digest("hex")}`,
+      name: "heartbeat",
+      status: "completed",
+      error: null,
+      detail: { type: "plain_text", text, icon: "sparkles" },
+    };
   }
   const { source } = message;
   if (!source) {

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

@@ -357,3 +357,21 @@ test("a human pasting an agent envelope stays a human message through provider r
     clientMessageId: "human-submission",
   });
 });
+
+test("schedule prompts remain visible as completed tool calls on replay", () => {
+  const text = formatSystemNotificationPrompt("Heartbeat: check progress");
+  expect(projectAgentMessages({ type: "user_message", messageId: "fire-1", text })).toEqual([
+    expect.objectContaining({
+      type: "tool_call",
+      status: "completed",
+      detail: { type: "plain_text", text: "Heartbeat: check progress", icon: "sparkles" },
+    }),
+  ]);
+});
+
+test("schedule trigger identity survives the provider assigning a message ID", () => {
+  const text = formatSystemNotificationPrompt("Schedule fired (id=heartbeat, run=run-1).");
+  expect(projectAgentMessages({ type: "user_message", text })).toEqual(
+    projectAgentMessages({ type: "user_message", text, messageId: "provider-message" }),
+  );
+});

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

@@ -15,7 +15,6 @@ export type AgentRunController = Pick<
   | "getAgent"
   | "tryRunOutOfBand"
   | "hasInFlightRun"
-  | "reloadStalePluginSession"
   | "replaceAgentRun"
   | "steerOrReplaceActiveTurn"
   | "streamAgent"
@@ -116,7 +115,6 @@ export async function startAgentRun(
     return { disposition: "out_of_band" };
   }
   try {
-    await agentManager.reloadStalePluginSession(agentId);
     return await startAgentRunInner(agentManager, agentId, prompt, logger, options);
   } catch (error) {
     if (!isStaleProviderSessionError(error)) throw error;

packages/server/src/server/agent/agent-timeline-store.test.ts

@@ -1,6 +1,4 @@
 import { describe, expect, it } from "vitest";
-import { selectReferenceProjectedTimelinePage } from "./test-utils/timeline-page-reference.js";
-import type { AgentTimelineItem } from "./agent-sdk-types.js";
 import { InMemoryAgentTimelineStore } from "./agent-timeline-store.js";
 
 describe("InMemoryAgentTimelineStore", () => {
@@ -179,10 +177,7 @@ describe("projected sequence ownership", () => {
     store.append("a", { type: "assistant_message", text: "Answer" });
     store.append("a", { ...tool, status: "completed" });
     store.initialize("b", { rows: store.getRows("a") });
-    expect(store.getLastItem("b")).toMatchObject({ type: "tool_call", status: "completed" });
-    expect(store.getLastAssistantMessage("b")).toBe("Answer");
     expect(store.append("b", { type: "user_message", text: "next" }).seq).toBe(4);
-    expect(store.getLastItem("b")).toEqual({ type: "user_message", text: "next" });
     expect(store.fetch("b").rows.map((row) => row.seqStart)).toEqual([1, 2, 4]);
   });
   it("returns the last projected assistant message without joining different messages", () => {
@@ -216,151 +211,3 @@ it("includes transitive tool updates in a contiguous projected tail", () => {
   expect(tail.rows.map((row) => row.seqStart)).toEqual([1, 2, 3, 5]);
   expect(tail).toMatchObject({ startSeq: 1, endSeq: 6, hasOlder: false });
 });
-
-it("serves tail 200 from 100,000 retained rows without stalling the loop", async () => {
-  const store = new InMemoryAgentTimelineStore();
-  store.initialize("large");
-  for (let index = 0; index < 100_000; index++) {
-    store.append("large", { type: "user_message", text: String(index) });
-  }
-  // Generation and its GC are outside the measured request window.
-  await new Promise<void>((resolve) => setImmediate(resolve));
-  const started = performance.now();
-  const probe = new Promise<number>((resolve) =>
-    setImmediate(() => resolve(performance.now() - started)),
-  );
-  let page = store.fetch("large", { limit: 200 });
-  for (let repeat = 1; repeat < 8; repeat++) page = store.fetch("large", { limit: 200 });
-  const duration = performance.now() - started;
-  const loopGap = await probe;
-  console.info({ duration, loopGap });
-  expect(page.rows).toHaveLength(200);
-  expect(page.startSeq).toBe(99_801);
-  expect(page.endSeq).toBe(100_000);
-  // CI runners can pause for scheduling/GC; the local per-request 2 ms gate
-  // is measured separately. Eight requests amplify the old full-history work.
-  expect(duration).toBeLessThan(50);
-  expect(loopGap).toBeLessThan(50);
-});
-
-it("matches the previous reprojecting selector on seeded randomized timelines", () => {
-  let seed = 0x76aabbcc;
-  const random = (bound: number) => {
-    seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
-    return Math.floor((seed / 0x1_0000_0000) * bound);
-  };
-  for (let scenario = 0; scenario < 100; scenario++) {
-    const store = new InMemoryAgentTimelineStore();
-    store.initialize("a", { epoch: "e" });
-    for (let seq = 1; seq <= 100; seq++) {
-      const identity = String(random(8));
-      const text = String(seq);
-      const items: AgentTimelineItem[] = [
-        { type: "user_message", text },
-        { type: "assistant_message", text },
-        { type: "assistant_message", text, messageId: identity },
-        { type: "reasoning", text },
-        {
-          type: "tool_call",
-          callId: identity,
-          name: "shell",
-          status: "running",
-          error: null,
-          detail: { type: "plain_text", label: text },
-        },
-        {
-          type: "plugin",
-          id: identity,
-          pluginId: "test",
-          kind: "state",
-          version: 1,
-          data: { text },
-        },
-      ];
-      store.append("a", items[random(items.length)], { turnId: String(random(3)) });
-    }
-    // Include rehydration of already-projected rows, with non-monotonic seqEnd.
-    store.initialize("b", { rows: store.getRows("a"), epoch: "e" });
-    for (const agentId of ["a", "b"]) {
-      assertSelectionMatchesReference(store, agentId);
-      store.append(agentId, { type: "assistant_message", text: "later" });
-      assertSelectionMatchesReference(store, agentId);
-    }
-  }
-});
-
-function assertSelectionMatchesReference(store: InMemoryAgentTimelineStore, agentId: string): void {
-  for (const direction of ["tail", "before", "after"] as const) {
-    for (const limit of [0, 1, 7, 200]) {
-      for (const cursorSeq of [0, 1, 25, 50, 99, 100, 150]) {
-        const actual = store.fetch(agentId, {
-          direction,
-          limit,
-          cursor: { epoch: "e", seq: cursorSeq },
-        });
-        const expected = selectReferenceProjectedTimelinePage({
-          rows: store.getRows(agentId),
-          bounds: actual.window,
-          direction,
-          limit,
-          cursorSeq,
-        });
-        expect({
-          ...expected,
-          entries: undefined,
-          rows: expected.entries.map((entry) => Object.assign({ seq: entry.seqEnd }, entry)),
-        }).toEqual({
-          entries: undefined,
-          rows: actual.rows,
-          startSeq: actual.startSeq,
-          endSeq: actual.endSeq,
-          hasOlder: actual.hasOlder,
-          hasNewer: actual.hasNewer,
-        });
-      }
-    }
-  }
-}
-
-it("continues a scroll across appends and lifecycle collapse without losing source coverage", () => {
-  const store = new InMemoryAgentTimelineStore();
-  store.initialize("a", { epoch: "e" });
-  const tool: AgentTimelineItem = {
-    type: "tool_call",
-    callId: "t",
-    name: "shell",
-    status: "running",
-    error: null,
-    detail: { type: "plain_text", label: "work" },
-  };
-  store.append("a", tool);
-  for (let seq = 2; seq <= 5; seq++) store.append("a", { type: "user_message", text: String(seq) });
-  const first = store.fetch("a", { direction: "after", cursor: { epoch: "e", seq: 0 }, limit: 2 });
-  expect(first.endSeq).toBe(2);
-  store.append("a", { ...tool, status: "completed" });
-  store.append("a", { type: "assistant_message", text: "Done" });
-  expect(first.rows[0].item).toMatchObject({ status: "running" });
-  const second = store.fetch("a", {
-    direction: "after",
-    cursor: { epoch: "e", seq: first.endSeq! },
-    limit: 2,
-  });
-  expect(second.rows.map((row) => row.seqStart)).toEqual([3, 4]);
-  expect(second.endSeq).toBe(4);
-  const third = store.fetch("a", {
-    direction: "after",
-    cursor: { epoch: "e", seq: second.endSeq! },
-    limit: 2,
-  });
-  expect(third.rows.map((row) => row.seqStart)).toEqual([1, 5]);
-  expect(third.rows[0].item).toMatchObject({ status: "completed" });
-  expect(third.endSeq).toBe(6);
-  const last = store.fetch("a", {
-    direction: "after",
-    cursor: { epoch: "e", seq: third.endSeq! },
-    limit: 2,
-  });
-  expect(last.rows.map((row) => row.item)).toEqual([{ type: "assistant_message", text: "Done" }]);
-  expect(last.endSeq).toBe(7);
-  expect(last.hasNewer).toBe(false);
-});

packages/server/src/server/agent/agent-timeline-store.ts

@@ -1,5 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { TimelineProjection, type ProjectedTimelineRow } from "./timeline-projection.js";
+import {
+  TimelineProjection,
+  selectProjectedTimelinePage,
+  type ProjectedTimelineRow,
+} from "./timeline-projection.js";
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
 import type {
   AgentTimelineFetchOptions,
@@ -39,7 +43,8 @@ export class InMemoryAgentTimelineStore {
       ? options.rows.map(cloneRow)
       : this.buildRowsFromItems(options?.items ?? [], options?.nextSeq ?? 1, timestamp);
     const nextSeq = rows.reduce((next, row) => Math.max(next, row.seq + 1), options?.nextSeq ?? 1);
-    const projection = new TimelineProjection(rows);
+    const projection = new TimelineProjection();
+    for (const row of rows) projection.append(row);
     this.states.set(agentId, {
       epoch: options?.epoch ?? randomUUID(),
       projection,
@@ -92,17 +97,18 @@ export class InMemoryAgentTimelineStore {
     const state = this.requireState(agentId);
     const direction = options?.direction ?? "tail";
     const cursor = options?.cursor;
-    const hasRows = state.minSeq !== 0;
+    const rows = state.projection.getRows();
     const window = { minSeq: state.minSeq, maxSeq: state.nextSeq - 1, nextSeq: state.nextSeq };
     const staleCursor = cursor !== undefined && cursor.epoch !== state.epoch;
     const gap =
       !staleCursor &&
       direction === "after" &&
       cursor !== undefined &&
-      hasRows &&
+      rows.length > 0 &&
       cursor.seq < state.minSeq - 1;
     const reset = staleCursor || gap;
-    const page = state.projection.selectPage({
+    const page = selectProjectedTimelinePage({
+      rows,
       bounds: window,
       direction: reset ? "tail" : direction,
       cursorSeq: cursor?.seq,
@@ -144,11 +150,14 @@ export class InMemoryAgentTimelineStore {
 
   getLastItem(agentId: string): AgentTimelineItem | null {
     const state = this.requireState(agentId);
-    return state.projection.getLastItem(state.nextSeq - 1);
+    return state.projection.getRows().find((row) => row.seqEnd === state.nextSeq - 1)?.item ?? null;
   }
 
   getLastAssistantMessage(agentId: string): string | null {
-    return this.requireState(agentId).projection.getLastAssistantMessage();
+    const row = this.requireState(agentId)
+      .projection.getRows()
+      .findLast((candidate) => candidate.item.type === "assistant_message");
+    return row?.item.type === "assistant_message" ? row.item.text : null;
   }
 
   private requireState(agentId: string): AgentTimelineState {

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

@@ -69,7 +69,6 @@ test("session create forwards clientMessageId to the initial prompt run options"
       getAgent: vi.fn(() => snapshot),
       tryRunOutOfBand: vi.fn(() => false),
       hasInFlightRun: vi.fn(() => false),
-      reloadStalePluginSession: async () => {},
       streamAgent,
       waitForAgentRunStart: vi.fn(async () => undefined),
     } as unknown as Parameters<typeof createAgentCommand>[0]["agentManager"],

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

@@ -270,8 +270,6 @@ function buildAgentManagerSpies() {
     hydrateTimelineFromProvider: vi.fn().mockResolvedValue(undefined),
     appendTimelineItem: vi.fn().mockResolvedValue(undefined),
     emitLiveTimelineItem: vi.fn().mockResolvedValue(undefined),
-    getPluginTools: () => [],
-    reloadStalePluginSession: async () => {},
     hasInFlightRun: vi.fn().mockReturnValue(false),
     steerOrReplaceActiveTurn: async () => ({ status: "inactive" as const }),
     tryRunOutOfBand: vi.fn().mockReturnValue(false),
@@ -619,10 +617,6 @@ class FakeBrowserToolsBroker {
 }
 
 class BoundaryAgentManagerFake {
-  public getPluginTools(): [] {
-    return [];
-  }
-
   private readonly agent = createManagedAgent({
     id: "agent-1",
     cwd: REPO_CWD,

packages/server/src/server/agent/mutable-provider-config-owner.test.ts

@@ -99,17 +99,16 @@ afterEach(() => {
 });
 
 describe("mutable provider config owner", () => {
-  test("publishes provider changes after commit and emits nothing on rollback", async () => {
+  test("publishes provider changes after commit and emits nothing on rollback", () => {
     const paseoHome = mkdtempSync(path.join(tmpdir(), "paseo-provider-config-owner-"));
     tempDirs.push(paseoHome);
     const store = new DaemonConfigStore(paseoHome, mutableConfig({ version: 1 }));
     const manager = new ProviderSnapshotManager({
       logger: createTestLogger(),
-      providerOverrides: CONTROLLED_PROVIDERS,
-      extraClients: { codex: controlledCodexClient(async () => catalog("initial")) },
+      providerOverrides: { codex: { enabled: true } },
     });
     const cwd = path.resolve("/tmp/provider-config-owner");
-    await manager.refreshSnapshotForCwd({ cwd });
+    manager.getSnapshot(cwd);
     const events: string[] = [];
     manager.on("change", ({ current }) => events.push(current.cwd));
     let agentManagerState = manager.getAgentManagerProviderState();
@@ -126,7 +125,7 @@ describe("mutable provider config owner", () => {
     });
 
     try {
-      await store.patch({ providers: { codex: { enabled: false } } });
+      store.patch({ providers: { codex: { enabled: false } } });
       expect(events).toEqual([cwd]);
       expect(agentManagerState.providerDefinitions.codex).toMatchObject({ enabled: false });
 
@@ -134,7 +133,7 @@ describe("mutable provider config owner", () => {
       const unsubscribeFailure = store.onApply(() => {
         throw new Error("later owner failed");
       });
-      await expect(store.patch({ providers: { codex: { enabled: true } } })).rejects.toThrow(
+      expect(() => store.patch({ providers: { codex: { enabled: true } } })).toThrow(
         "later owner failed",
       );
       unsubscribeFailure();
@@ -151,7 +150,7 @@ describe("mutable provider config owner", () => {
     }
   });
 
-  test("does no provider work for unrelated CORS, Git, and app URL reloads", async () => {
+  test("does no provider work for unrelated CORS, Git, and app URL reloads", () => {
     const paseoHome = mkdtempSync(path.join(tmpdir(), "paseo-provider-config-owner-"));
     tempDirs.push(paseoHome);
     const initial: PersistedConfig = {
@@ -175,10 +174,9 @@ describe("mutable provider config owner", () => {
     });
     const manager = new ProviderSnapshotManager({
       logger: createTestLogger(),
-      providerOverrides: CONTROLLED_PROVIDERS,
-      extraClients: { codex: controlledCodexClient(async () => catalog("initial")) },
+      providerOverrides: { codex: { enabled: true } },
     });
-    await manager.refreshSnapshotForCwd({ cwd: "/tmp/provider-config-owner" });
+    manager.getSnapshot("/tmp/provider-config-owner");
     const events: string[] = [];
     manager.on("change", ({ current }) => events.push(current.cwd));
     let registryUpdates = 0;
@@ -202,7 +200,7 @@ describe("mutable provider config owner", () => {
       };
       writeFileSync(configPath, `${JSON.stringify(reloaded, null, 2)}\n`, "utf-8");
 
-      expect((await store.reload()).appliedPaths).toEqual([
+      expect(store.reload().appliedPaths).toEqual([
         "app.baseUrl",
         "daemon.cors.allowedOrigins",
         "daemon.git.maxProcessConcurrency",
@@ -247,7 +245,7 @@ describe("mutable provider config owner", () => {
       await vi.waitFor(() => expect(catalogResolvers).toHaveLength(1));
       expect(events).toEqual([]);
 
-      await store.patch({ providers: { codex: { enabled: true, label: "Reloaded Codex" } } });
+      store.patch({ providers: { codex: { enabled: true, label: "Reloaded Codex" } } });
       expect(events).toEqual(["loading:none"]);
       await vi.waitFor(() => expect(catalogResolvers).toHaveLength(2));
 
@@ -313,9 +311,9 @@ describe("mutable provider config owner", () => {
       expect(events).toEqual([]);
 
       const before = manager.getSnapshot(cwd);
-      await expect(
+      expect(() =>
         store.patch({ providers: { codex: { enabled: true, label: "Rejected Codex" } } }),
-      ).rejects.toThrow("later owner failed");
+      ).toThrow("later owner failed");
       expect(events).toEqual([]);
       expect(observedDuringApply).toEqual([{ label: "Codex", snapshot: before }]);
       expect(observedDuringApply[0]!.snapshot).toBe(before);

packages/server/src/server/agent/permission-response.test.ts

@@ -40,8 +40,6 @@ class FakePermissionAgentManager {
     return undefined;
   }
 
-  async reloadStalePluginSession(): Promise<void> {}
-
   hasInFlightRun(): boolean {
     return this.hasRunInFlight;
   }

packages/server/src/server/agent/plugin-provider.test.ts

@@ -310,7 +310,7 @@ describe("PluginAgentClientRegistry", () => {
     });
     const own = { nested: { replace: "agent" } };
     const agent = await manager.createAgent(
-      { provider: "plugin-direct", cwd: tmpdir(), providerOptions: own },
+      { provider: "plugin-direct", cwd: "/tmp", providerOptions: own },
       undefined,
       { workspaceId: undefined },
     );

packages/server/src/server/agent/providers/claude/agent.env.test.ts

@@ -1,11 +1,10 @@
-import { once } from "node:events";
 import type { Query } from "@anthropic-ai/claude-agent-sdk";
 import { describe, expect, test, vi } from "vitest";
 
 import { createTestLogger } from "../../../../test-utils/test-logger.js";
 import type { AgentLaunchContext } from "../../agent-sdk-types.js";
 import { ClaudeAgentClient } from "./agent.js";
-import { claudeQuery, type ClaudeQueryInput } from "./query.js";
+import type { ClaudeQueryInput } from "./query.js";
 
 function createQueryMock(events: unknown[]): Query {
   let index = 0;
@@ -30,48 +29,6 @@ function createQueryMock(events: unknown[]): Query {
 }
 
 describe("Claude SDK env", () => {
-  test.each(["node", "bun", process.execPath])(
-    "identifies the spawned %s process as Paseo after clearing parent session env",
-    async (command) => {
-      let output = "";
-      let exited = Promise.resolve<unknown[]>([]);
-      const query = claudeQuery(
-        { prompt: "", options: {} },
-        {
-          runtimeSettings: { env: { CLAUDE_CODE_ENTRYPOINT: "sdk-ts" } },
-          launchEnv: { CLAUDE_CODE_ENTRYPOINT: "sdk-cli" },
-          queryFactory: ({ options }) => {
-            if (!options.spawnClaudeCodeProcess) {
-              throw new Error("Missing Claude process launcher");
-            }
-            const child = options.spawnClaudeCodeProcess({
-              command,
-              args: [
-                "-e",
-                "process.stdout.write(JSON.stringify({ entrypoint: process.env.CLAUDE_CODE_ENTRYPOINT, parentSession: process.env.CLAUDECODE ?? null }))",
-              ],
-              cwd: process.cwd(),
-              env: { ...process.env, CLAUDE_CODE_ENTRYPOINT: "sdk-ts", CLAUDECODE: "1" },
-              signal: new AbortController().signal,
-            });
-            child.stdout.on("data", (chunk: Buffer) => {
-              output += chunk.toString();
-            });
-            exited = once(child, "close");
-            return createQueryMock([]);
-          },
-        },
-      );
-
-      try {
-        expect(await exited).toEqual([0, null]);
-        expect(JSON.parse(output)).toEqual({ entrypoint: "Paseo", parentSession: null });
-      } finally {
-        query.close();
-      }
-    },
-  );
-
   test("forwards launch-context env through Claude process env", async () => {
     let capturedEnv: Record<string, string | undefined> | undefined;
     let capturedPerTaskStopAffordance: boolean | undefined;

packages/server/src/server/agent/providers/claude/agent.history-load.test.ts

@@ -1,13 +1,9 @@
 import fs, { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { open } from "node:fs/promises";
-import { performance } from "node:perf_hooks";
 import * as os from "node:os";
 import * as path from "node:path";
 import pino from "pino";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 
-import { createTestPaseoDaemon } from "../../../test-utils/paseo-daemon.js";
-import type { ClaudeRewindSdk } from "./rewind.js";
 import { ClaudeAgentClient } from "./agent.js";
 import { claudeProjectDirSync } from "./project-dir.js";
 import { withClaudeReplayHistory } from "./transcript-history.js";
@@ -36,10 +32,7 @@ describe("ClaudeAgentSession persisted history load", () => {
   let configDir: string;
   let records: LogRecord[];
 
-  async function resume(
-    queryFactory?: ClaudeQueryFactory,
-    rewindSdk?: ClaudeRewindSdk,
-  ): Promise<AgentSession> {
+  async function resume(queryFactory?: ClaudeQueryFactory): Promise<AgentSession> {
     const client = new ClaudeAgentClient({
       logger: pino({ level: "info" }, { write: (line: string) => records.push(JSON.parse(line)) }),
       queryFactory:
@@ -49,36 +42,10 @@ describe("ClaudeAgentSession persisted history load", () => {
         }),
       resolveBinary: async () => process.execPath,
       resolveVersion: async () => "2.1.220",
-      rewindSdk,
     });
     return client.resumeSession({ provider: "claude", sessionId: SESSION_ID }, { cwd });
   }
 
-  function replyFactory(text: string, messageId = "live-reply"): ClaudeQueryFactory {
-    return (() => {
-      const messages = [
-        { type: "assistant", uuid: messageId, message: { content: text } },
-        { type: "result", subtype: "success", total_cost_usd: 0 },
-      ];
-      return {
-        async next() {
-          const value = messages.shift();
-          return value ? { done: false, value } : { done: true, value: undefined };
-        },
-        close() {},
-        async return() {
-          return { done: true, value: undefined };
-        },
-        async supportedCommands() {
-          return [];
-        },
-        [Symbol.asyncIterator]() {
-          return this;
-        },
-      };
-    }) as ClaudeQueryFactory;
-  }
-
   function transcriptPath(): string {
     return path.join(claudeProjectDirSync(cwd, { configDir }), `${SESSION_ID}.jsonl`);
   }
@@ -98,288 +65,6 @@ describe("ClaudeAgentSession persisted history load", () => {
     rmSync(tempRoot, { recursive: true, force: true });
   });
 
-  test("serves unrelated health requests while resuming 32 MiB of ordered history", async () => {
-    const startedAt = performance.now();
-    mkdirSync(path.dirname(transcriptPath()), { recursive: true });
-    const file = await open(transcriptPath(), "w");
-    const text = "x".repeat(16 * 1024);
-    let bytes = 0;
-    let count = 0;
-    try {
-      while (bytes < 32 * 1024 * 1024) {
-        const line =
-          JSON.stringify({ type: "assistant", message: { content: `${count}:${text}` } }) + "\n";
-        bytes += Buffer.byteLength(line);
-        await file.write(line);
-        count++;
-      }
-    } finally {
-      await file.close();
-    }
-    const daemon = await createTestPaseoDaemon();
-    let lastTick = performance.now();
-    let longestGap = 0;
-    const probe = setInterval(() => {
-      const now = performance.now();
-      longestGap = Math.max(longestGap, now - lastTick);
-      lastTick = now;
-    }, 2);
-    let loading = true;
-    let answeredDuringLoad = false;
-    const health = fetch(`http://127.0.0.1:${daemon.port}/api/health`).then(async (response) => {
-      expect(response.status).toBe(200);
-      await response.text();
-      answeredDuringLoad = loading;
-      return undefined;
-    });
-    let session: AgentSession | undefined;
-    try {
-      session = await resume(replyFactory("live after large resume"));
-      let index = 0;
-      for await (const event of session.streamHistory()) {
-        expect(event).toEqual({
-          type: "timeline",
-          provider: "claude",
-          timestamp: undefined,
-          item: { type: "assistant_message", text: `${index}:${text}` },
-        });
-        index++;
-      }
-      loading = false;
-      await health;
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      console.info(
-        JSON.stringify({
-          bytes,
-          count,
-          longestGap,
-          answeredDuringLoad,
-          elapsedMs: performance.now() - startedAt,
-        }),
-      );
-      expect(index).toBe(count);
-      expect(longestGap).toBeLessThan(50);
-      expect(answeredDuringLoad).toBe(true);
-      const live = await collectSessionTurnEvents(session, "follow up");
-      expect(
-        live
-          .filter((event) => event.type === "timeline" && event.item.type === "assistant_message")
-          .map((event) => (event.type === "timeline" ? event.item : null)),
-      ).toEqual([
-        { type: "assistant_message", messageId: "live-reply", text: "live after large resume" },
-      ]);
-    } finally {
-      clearInterval(probe);
-      await session?.close();
-      await daemon.close();
-    }
-  }, 60_000);
-
-  test("rebinds ordered history before returning from rewind and accepts a live turn", async () => {
-    const entries = [
-      { type: "user", uuid: "u1", message: { content: "first" } },
-      { type: "assistant", uuid: "a1", message: { content: "first reply" } },
-      { type: "user", uuid: "u2", message: { content: "second" } },
-      { type: "assistant", uuid: "a2", message: { content: "second reply" } },
-    ];
-    mkdirSync(path.dirname(transcriptPath()), { recursive: true });
-    writeFileSync(transcriptPath(), entries.map((entry) => JSON.stringify(entry)).join("\n"));
-    const forkId = "rebound-history";
-    const forkFile = path.join(path.dirname(transcriptPath()), `${forkId}.jsonl`);
-    writeFileSync(
-      forkFile,
-      entries
-        .slice(0, 2)
-        .map((entry) => JSON.stringify(entry))
-        .join("\n"),
-    );
-    const forks: unknown[] = [];
-    const late = {
-      type: "assistant",
-      uuid: "retired-reply",
-      message: { content: "retired query" },
-    };
-    let pendingRead: ((value: unknown) => void) | undefined;
-    let releaseRetirement!: () => void;
-    const retirementGate = new Promise<void>((resolve) => {
-      releaseRetirement = resolve;
-    });
-    let retirementStarted!: () => void;
-    const retiring = new Promise<void>((resolve) => {
-      retirementStarted = resolve;
-    });
-    let firstQuery = true;
-    let retired = false;
-    const queryFactory = (() => {
-      if (!firstQuery) return replyFactory("live after rebind")({} as never);
-      firstQuery = false;
-      const messages = [
-        { type: "assistant", uuid: "before-rebind", message: { content: "before rebind" } },
-        { type: "result", subtype: "success", total_cost_usd: 0 },
-      ];
-      return {
-        async next() {
-          const value = messages.shift();
-          if (value) return { done: false, value };
-          if (retired) return { done: true, value: undefined };
-          return new Promise((resolve) => {
-            pendingRead = resolve;
-          });
-        },
-        close() {
-          retired = true;
-          pendingRead?.({ done: false, value: late });
-        },
-        async return() {
-          retirementStarted();
-          await retirementGate;
-          return { done: true, value: undefined };
-        },
-        async supportedCommands() {
-          return [];
-        },
-        [Symbol.asyncIterator]() {
-          return this;
-        },
-      };
-    }) as ClaudeQueryFactory;
-    const session = await resume(queryFactory, {
-      async forkSession(sessionId, options) {
-        forks.push({ sessionId, ...options });
-        return { sessionId: forkId };
-      },
-    });
-    try {
-      const original = await Array.fromAsync(session.streamHistory());
-      expect(original).toHaveLength(4);
-      await collectSessionTurnEvents(session, "before rewind");
-      const emitted: AgentStreamEvent[] = [];
-      const subscription = session.subscribe((event) => emitted.push(event));
-      let rewindDone = false;
-      const rewind = (async () => {
-        await session.revertConversation!({ messageId: "u2" });
-        rewindDone = true;
-      })();
-      await retiring;
-      let historyDone = false;
-      const reading = (async () => {
-        const history = await Array.fromAsync(session.streamHistory());
-        historyDone = true;
-        return history;
-      })();
-      const readingAgain = Array.fromAsync(session.streamHistory());
-      await Promise.resolve();
-      expect(rewindDone).toBe(false);
-      expect(historyDone).toBe(false);
-      releaseRetirement();
-      await rewind;
-      subscription();
-      expect(retired).toBe(true);
-      expect(
-        emitted.filter(
-          (event) => event.type === "timeline" && event.item.type === "assistant_message",
-        ),
-      ).toEqual([
-        {
-          type: "timeline",
-          provider: "claude",
-          item: {
-            type: "assistant_message",
-            text: `Claude switched to a new session: ${SESSION_ID} -> ${forkId}`,
-          },
-        },
-      ]);
-      expect(forks).toEqual([
-        { sessionId: SESSION_ID, upToMessageId: "a1", transcriptPath: transcriptPath() },
-      ]);
-      expect(session.id).toBe(forkId);
-      const [history, secondRead] = await Promise.all([reading, readingAgain]);
-      expect(history).toEqual(original.slice(0, 2));
-      expect(secondRead).toEqual([]);
-      const live = await collectSessionTurnEvents(session, "continue the fork");
-      expect(
-        live
-          .filter((event) => event.type === "timeline" && event.item.type === "assistant_message")
-          .map((event) => (event.type === "timeline" ? event.item : null)),
-      ).toEqual([
-        { type: "assistant_message", messageId: "live-reply", text: "live after rebind" },
-      ]);
-    } finally {
-      releaseRetirement();
-      await session.close();
-    }
-  });
-
-  test("reports a failed rewind without poisoning readiness when query retirement throws", async () => {
-    mkdirSync(path.dirname(transcriptPath()), { recursive: true });
-    writeFileSync(
-      transcriptPath(),
-      [
-        { type: "user", uuid: "u1", message: { content: "first" } },
-        { type: "assistant", uuid: "a1", message: { content: "reply" } },
-        { type: "user", uuid: "u2", message: { content: "second" } },
-      ]
-        .map((entry) => JSON.stringify(entry))
-        .join("\n"),
-    );
-    let firstQuery = true;
-    let finishRead: ((value: unknown) => void) | undefined;
-    const queryFactory = ((input) => {
-      const query = replyFactory(
-        firstQuery ? "before retirement" : "still available",
-        firstQuery ? "before-retirement" : "live-reply",
-      )(input);
-      if (!firstQuery) return query;
-      firstQuery = false;
-      let reads = 0;
-      return {
-        ...query,
-        async next() {
-          if (++reads <= 2) return query.next();
-          return new Promise((resolve) => {
-            finishRead = resolve;
-          });
-        },
-        close() {
-          finishRead?.({ done: true, value: undefined });
-          throw new Error("retirement failed");
-        },
-        [Symbol.asyncIterator]() {
-          return this;
-        },
-      };
-    }) as ClaudeQueryFactory;
-    const session = await resume(queryFactory, {
-      async forkSession() {
-        return { sessionId: "failed-rebind" };
-      },
-    });
-    try {
-      await Array.fromAsync(session.streamHistory());
-      await collectSessionTurnEvents(session, "before rewind");
-      await expect(session.revertConversation!({ messageId: "u2" })).rejects.toThrow(
-        "retirement failed",
-      );
-      expect(records).toContainEqual(
-        expect.objectContaining({
-          level: pino.levels.values.warn,
-          msg: "Failed to rebind Claude session",
-          sessionId: "failed-rebind",
-          err: expect.objectContaining({ message: "retirement failed" }),
-        }),
-      );
-      expect(session.id).toBe(SESSION_ID);
-      const live = await collectSessionTurnEvents(session, "after failed rebind");
-      expect(
-        live
-          .filter((event) => event.type === "timeline" && event.item.type === "assistant_message")
-          .map((event) => (event.type === "timeline" ? event.item : null)),
-      ).toEqual([{ type: "assistant_message", messageId: "live-reply", text: "still available" }]);
-    } finally {
-      await session.close();
-    }
-  });
-
   test.each(["file_path", "files"])(
     "replays %s without probing targets and preserves live existence checks",
     async (field) => {
@@ -615,21 +300,21 @@ describe("ClaudeAgentSession persisted history load", () => {
     );
   });
 
-  test("loads readable history when the temporary directory is unavailable", async () => {
+  test("loads readable history when the temporary directory is unavailable", () => {
     const file = transcriptPath();
     const entry = { type: "assistant", message: { content: [{ type: "text", text: "saved" }] } };
     mkdirSync(path.dirname(file), { recursive: true });
     writeFileSync(file, JSON.stringify(entry));
     const unavailable = path.join(tempRoot, "unavailable-tmp");
     for (const variable of ["TMPDIR", "TEMP", "TMP"]) vi.stubEnv(variable, unavailable);
-    await withClaudeReplayHistory(file, async (history) => {
-      expect(await Array.fromAsync(history.parentEntries)).toEqual([entry]);
+    withClaudeReplayHistory(file, (history) => {
+      expect([...history.parentEntries]).toEqual([entry]);
     });
   });
 
   test.each(["parent", "child", "workflow"])(
     "preserves indexed %s history when its transcript disappears between passes",
-    async (target) => {
+    (target) => {
       const parent = transcriptPath();
       const sessionDirectory = parent.slice(0, -".jsonl".length);
       const child = path.join(sessionDirectory, "subagents", "agent-child.jsonl");
@@ -649,16 +334,14 @@ describe("ClaudeAgentSession persisted history load", () => {
       writeFileSync(parent, JSON.stringify(parentEntry));
       writeFileSync(child, JSON.stringify(childEntry));
       writeFileSync(workflow, JSON.stringify(childEntry));
-      await withClaudeReplayHistory(parent, async (history) => {
+      withClaudeReplayHistory(parent, (history) => {
         rmSync({ parent, child, workflow }[target]);
         // Ownership facts and visible payloads are separate passes over the same source.
         for (let pass = 0; pass < 2; pass++) {
-          expect(await Array.fromAsync(history.parentEntries)).toEqual([parentEntry]);
+          expect([...history.parentEntries]).toEqual([parentEntry]);
           expect(history.subagents).toHaveLength(1);
-          expect(await Array.fromAsync(history.subagents[0]!.entries)).toEqual([childEntry]);
-          expect(await Array.fromAsync(history.workflowEntriesByRunId.get("wf_test")!)).toEqual([
-            childEntry,
-          ]);
+          expect([...history.subagents[0]!.entries]).toEqual([childEntry]);
+          expect([...history.workflowEntriesByRunId.get("wf_test")!]).toEqual([childEntry]);
         }
       });
     },

packages/server/src/server/agent/providers/claude/agent.ts

@@ -1,4 +1,3 @@
-import { setImmediate } from "node:timers/promises";
 import { ClaudeRuntimeSafety } from "./runtime-safety.js";
 import { validateProviderOptions } from "../../provider-options.js";
 import type { ChildProcess } from "node:child_process";
@@ -83,7 +82,7 @@ import {
   type ClaudeRewindSdk,
 } from "./rewind.js";
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
-import { claudeConfigDir, claudeProjectDirSync, claudeTranscriptPath } from "./project-dir.js";
+import { claudeConfigDir, claudeProjectDirSync, claudeTranscriptPathSync } from "./project-dir.js";
 import { THINKING_APPLIES_NEXT_TURN_NOTICE } from "../../provider-notices.js";
 import {
   isProviderImageMarkdown,
@@ -1635,7 +1634,7 @@ export class ClaudeAgentClient implements AgentClient {
       cwd: merged.cwd,
     };
     const claudeConfig = this.assertConfig(mergedConfig);
-    const session = new ClaudeAgentSession(claudeConfig, {
+    return new ClaudeAgentSession(claudeConfig, {
       defaults: this.defaults,
       runtimeSettings: this.runtimeSettings,
       handle,
@@ -1646,8 +1645,6 @@ export class ClaudeAgentClient implements AgentClient {
       resolveBinary: this.resolveBinary,
       rewindSdk: this.rewindSdk,
     });
-    await session.ensureHistoryReady();
-    return session;
   }
 
   async getCatalogCacheKey(_options: FetchCatalogOptions): Promise<string> {
@@ -2332,9 +2329,6 @@ class ClaudeAgentSession implements AgentSession {
     { type: "provider_subagent" }
   >[] = [];
   private historyPending = false;
-  // Readiness never rejects; history/rebind failures are logged at their owning boundary.
-  private historyReady: Promise<void> | null = null;
-  private historySessionId: string | null = null;
   private replayingHistory = false;
   private turnState: TurnState = "idle";
   private nextTurnOrdinal = 1;
@@ -2388,7 +2382,7 @@ class ClaudeAgentSession implements AgentSession {
       }
       this.claudeSessionId = handle.sessionId;
       this.persistence = handle;
-      this.historySessionId = handle.sessionId;
+      this.loadPersistedHistory(handle.sessionId);
     } else {
       this.claudeSessionId = null;
       this.persistence = null;
@@ -2468,7 +2462,6 @@ class ClaudeAgentSession implements AgentSession {
     prompt: AgentPromptInput,
     options?: AgentRunOptions,
   ): Promise<{ turnId: string }> {
-    await this.ensureHistoryReady();
     if (this.closed) {
       throw new Error("Claude session is closed");
     }
@@ -2639,7 +2632,6 @@ class ClaudeAgentSession implements AgentSession {
   }
 
   async *streamHistory(): AsyncGenerator<AgentStreamEvent> {
-    await this.ensureHistoryReady();
     if (
       !this.historyPending ||
       (this.persistedHistory.length === 0 && this.persistedProviderSubagentEvents.length === 0)
@@ -2651,9 +2643,7 @@ class ClaudeAgentSession implements AgentSession {
     this.persistedHistory = [];
     this.persistedProviderSubagentEvents = [];
     this.historyPending = false;
-    let replayed = 0;
     for (const entry of history) {
-      if (++replayed % 32 === 0) await setImmediate();
       yield {
         type: "timeline",
         item: entry.item,
@@ -2971,7 +2961,6 @@ class ClaudeAgentSession implements AgentSession {
       "provider.claude.session_close.start",
     );
     this.closed = true;
-    await this.ensureHistoryReady();
     this.rejectAllPendingPermissions(new Error("Claude session closed"));
     this.cancelCurrentTurn?.();
     this.subscribers.clear();
@@ -3012,7 +3001,7 @@ class ClaudeAgentSession implements AgentSession {
       // (see `claude --help`), so the SDK's persistSession=false is silently dropped
       // in stream-json mode. Sweep the transcript ourselves so ephemeral runs
       // (metadata generator, branch-name generator) don't show up as resumable.
-      const historyPath = await this.resolveHistoryPath(this.claudeSessionId);
+      const historyPath = this.resolveHistoryPath(this.claudeSessionId);
       if (historyPath) {
         try {
           await promises.rm(historyPath, { force: true });
@@ -3056,7 +3045,6 @@ class ClaudeAgentSession implements AgentSession {
   }
 
   async revertConversation(input: { messageId: string }): Promise<void> {
-    await this.ensureHistoryReady();
     const target = this.resolveConversationRewindTarget(input.messageId);
     if (target.kind === "fresh-session") {
       this.startFreshConversationSession();
@@ -3066,15 +3054,16 @@ class ClaudeAgentSession implements AgentSession {
     await revertClaudeConversation({
       sdk: this.rewindSdk,
       sessionId: currentSessionId,
-      transcriptPath: currentSessionId ? await this.resolveHistoryPath(currentSessionId) : null,
+      transcriptPath: currentSessionId ? this.resolveHistoryPath(currentSessionId) : null,
       messageId: target.messageId,
       resolveMessageId: (messageId) => this.resolveClaudeMessageId(messageId),
-      setSessionId: (sessionId) => this.rebindConversationSession(sessionId),
+      setSessionId: (sessionId) => {
+        this.rebindConversationSession(sessionId);
+      },
     });
   }
 
   async revertFiles(input: { messageId: string }): Promise<void> {
-    await this.ensureHistoryReady();
     const messageId = await this.resolveClaudeMessageId(input.messageId);
     await revertClaudeFiles({
       query: await this.ensureQuery(),
@@ -3249,52 +3238,38 @@ class ClaudeAgentSession implements AgentSession {
     return candidates;
   }
 
-  private rebindConversationSession(sessionId: string): Promise<void> {
-    const previousReady = this.ensureHistoryReady();
-    const rebind = (async () => {
-      await previousReady;
-      await this.retireQuery();
-      if (this.closed) return;
-      const oldSessionId = this.claudeSessionId;
-      this.claudeSessionId = sessionId;
-      this.pendingFreshSessionId = null;
-      this.persistence = null;
-      this.cachedRuntimeInfo = null;
-      this.queryRestartNeeded = true;
-      this.persistedHistory = [];
-      this.persistedProviderSubagentEvents = [];
-      this.historyPending = false;
-      this.userMessageIds = [];
-      this.emittedUserMessageIds.clear();
-      this.rewindTurnAnchors.length = 0;
-      this.taskState.reset();
-      this.historySessionId = sessionId;
-      await this.loadPersistedHistory(sessionId);
-      if (this.closed) return;
-      if (oldSessionId && oldSessionId !== sessionId) {
-        this.dispatchEvents([
-          {
-            type: "timeline",
-            provider: "claude",
-            item: this.createClaudeSessionChangedNotice(oldSessionId, sessionId),
-          },
-          {
-            type: "thread_started",
-            provider: "claude",
-            sessionId,
-          },
-        ]);
-      }
-    })();
-    this.historyReady = rebind.catch((error) => {
-      this.logger.warn({ err: error, sessionId }, "Failed to rebind Claude session");
-    });
-    return rebind;
+  private rebindConversationSession(sessionId: string): void {
+    const oldSessionId = this.claudeSessionId;
+    this.claudeSessionId = sessionId;
+    this.pendingFreshSessionId = null;
+    this.persistence = null;
+    this.cachedRuntimeInfo = null;
+    this.queryRestartNeeded = true;
+    this.persistedHistory = [];
+    this.persistedProviderSubagentEvents = [];
+    this.historyPending = false;
+    this.userMessageIds = [];
+    this.emittedUserMessageIds.clear();
+    this.rewindTurnAnchors.length = 0;
+    this.taskState.reset();
+    this.loadPersistedHistory(sessionId);
+    if (oldSessionId && oldSessionId !== sessionId) {
+      this.dispatchEvents([
+        {
+          type: "timeline",
+          provider: "claude",
+          item: this.createClaudeSessionChangedNotice(oldSessionId, sessionId),
+        },
+        {
+          type: "thread_started",
+          provider: "claude",
+          sessionId,
+        },
+      ]);
+    }
   }
 
   private startFreshConversationSession(): void {
-    this.historySessionId = null;
-    this.historyReady = Promise.resolve();
     const sessionId = randomUUID();
     this.claudeSessionId = sessionId;
     this.pendingFreshSessionId = sessionId;
@@ -3415,43 +3390,7 @@ class ClaudeAgentSession implements AgentSession {
     return { kind: "fresh-session" };
   }
 
-  private async retireQuery(): Promise<void> {
-    const oldQuery = this.query;
-    if (!oldQuery) return;
-    const oldInput = this.input;
-    // Null out query/input BEFORE awaiting the old iterator's return so the
-    // old pump sees this.query !== activeQuery and skips failActiveTurns.
-    this.query = null;
-    this.input = null;
-    this.queryPumpPromise = null;
-    this.queryRestartNeeded = false;
-    // Ending the input retires the process on purpose. Detach first so its
-    // exit is not reported as a crash.
-    const retiredChild = this.childProcess;
-    this.childProcess = null;
-    if (retiredChild) this.failRunningRuntimeTasks();
-    oldInput?.end();
-    oldQuery.close?.();
-    try {
-      await oldQuery.return?.();
-    } catch {
-      /* ignore */
-    }
-    // Tree-kill the old process tree now that the SDK has cleaned up.
-    // If we skip this, MCP children of the previous claude process can
-    // survive as orphans when the session spawns a replacement query.
-    if (retiredChild) {
-      await terminateWithTreeKill(retiredChild, {
-        gracefulTimeoutMs: 2_000,
-        forceTimeoutMs: 2_000,
-      }).catch(() => {
-        /* process may already be dead */
-      });
-    }
-  }
-
   private async ensureQuery(launchMode: PermissionMode = this.currentMode): Promise<Query> {
-    await this.ensureHistoryReady();
     // Controls use the running turn's query. Pending launch settings take effect
     // after that turn finishes, when its active query handle has been cleared.
     if (this.query && (!this.queryRestartNeeded || this.activeForegroundQuery === this.query)) {
@@ -3459,7 +3398,37 @@ class ClaudeAgentSession implements AgentSession {
     }
 
     if (this.queryRestartNeeded && this.query) {
-      await this.retireQuery();
+      const oldQuery = this.query;
+      const oldInput = this.input;
+      // Null out query/input BEFORE awaiting the old iterator's return so the
+      // old pump sees this.query !== activeQuery and skips failActiveTurns.
+      this.query = null;
+      this.input = null;
+      this.queryPumpPromise = null;
+      this.queryRestartNeeded = false;
+      // Ending the input retires the process on purpose. Detach first so its
+      // exit is not reported as a crash.
+      const retiredChild = this.childProcess;
+      this.childProcess = null;
+      if (retiredChild) this.failRunningRuntimeTasks();
+      oldInput?.end();
+      oldQuery.close?.();
+      try {
+        await oldQuery.return?.();
+      } catch {
+        /* ignore */
+      }
+      // Tree-kill the old process tree now that the SDK has cleaned up.
+      // If we skip this, MCP children of the previous claude process can
+      // survive as orphans when the session spawns a replacement query.
+      if (retiredChild) {
+        await terminateWithTreeKill(retiredChild, {
+          gracefulTimeoutMs: 2_000,
+          forceTimeoutMs: 2_000,
+        }).catch(() => {
+          /* process may already be dead */
+        });
+      }
     }
 
     // Preserve claudeSessionId across query recreation so buildOptions() passes
@@ -4126,15 +4095,13 @@ class ClaudeAgentSession implements AgentSession {
       );
     };
     const handlePumpedMessage = async (message: SDKMessage): Promise<boolean> => {
-      if (!this.ownsQuery(activeQuery)) return true;
       this.processingSdkMessages++;
       try {
         this.runtimeSafety.observe(message);
         logRawMessage(message);
         consecutiveInterruptAbortRecoveries = 0;
         if (await this.handleMissingResumedConversation(message, activeQuery)) return true;
-        if (!this.ownsQuery(activeQuery)) return true;
-        this.routeSdkMessageFromPump(message);
+        await this.routeSdkMessageFromPump(message);
         return false;
       } finally {
         this.processingSdkMessages--;
@@ -4254,11 +4221,7 @@ class ClaudeAgentSession implements AgentSession {
     return isClaudeTurnInit(message) && !this.activeForegroundTurnId;
   }
 
-  private ownsQuery(query: Query): boolean {
-    return !this.closed && this.query === query;
-  }
-
-  private routeSdkMessageFromPump(message: SDKMessage): void {
+  private async routeSdkMessageFromPump(message: SDKMessage): Promise<void> {
     if (this.consumeSessionStateChange(message)) {
       return;
     }
@@ -4292,7 +4255,7 @@ class ClaudeAgentSession implements AgentSession {
       "provider.claude.parsed_event",
     );
 
-    const events = this.buildPumpedMessageEvents(message, identifiers.messageId, turnId);
+    const events = await this.buildPumpedMessageEvents(message, identifiers.messageId, turnId);
 
     if (events.length === 0) {
       return;
@@ -4327,11 +4290,11 @@ class ClaudeAgentSession implements AgentSession {
     this.dispatchEvents(events);
   }
 
-  private buildPumpedMessageEvents(
+  private async buildPumpedMessageEvents(
     message: SDKMessage,
     messageIdHint: string | null,
     turnId: string | null,
-  ): AgentStreamEvent[] {
+  ): Promise<AgentStreamEvent[]> {
     const messageEvents = this.translateMessageToEvents(message, {
       suppressAssistantText: true,
       suppressReasoning: true,
@@ -5309,31 +5272,22 @@ class ClaudeAgentSession implements AgentSession {
     }
   }
 
-  ensureHistoryReady(): Promise<void> {
-    if (!this.historyReady) {
-      this.historyReady = this.historySessionId
-        ? this.loadPersistedHistory(this.historySessionId)
-        : Promise.resolve();
-    }
-    return this.historyReady;
-  }
-
-  private async loadPersistedHistory(sessionId: string): Promise<void> {
+  private loadPersistedHistory(sessionId: string): void {
     let historyPath: string | null = null;
     this.replayingHistory = true;
     try {
       this.taskState.reset();
-      historyPath = await this.resolveHistoryPath(sessionId);
-      if (!historyPath || !(await transcriptExists(historyPath))) {
+      historyPath = this.resolveHistoryPath(sessionId);
+      if (!historyPath || !fs.existsSync(historyPath)) {
         this.logger.info(
           { sessionId, cwd: this.config.cwd, historyPath },
           "No Claude transcript to load history from",
         );
         return;
       }
-      await withClaudeReplayHistory(historyPath, async (history) => {
-        const replay = await this.ingestPersistedSidechains(history);
-        await this.ingestPersistedHistory(history.parentEntries, replay);
+      withClaudeReplayHistory(historyPath, (history) => {
+        const replay = this.ingestPersistedSidechains(history);
+        this.ingestPersistedHistory(history.parentEntries, replay);
       });
     } catch (error) {
       this.logger.warn(
@@ -5345,12 +5299,12 @@ class ClaudeAgentSession implements AgentSession {
     }
   }
 
-  private async ingestPersistedHistory(
-    entries: Iterable<ClaudeHistoryEntry> | AsyncIterable<ClaudeHistoryEntry>,
+  private ingestPersistedHistory(
+    entries: Iterable<ClaudeHistoryEntry>,
     replay: ClaudeReplayOwnership,
-  ): Promise<void> {
+  ): void {
     const timeline: PersistedTimelineEntry[] = [];
-    for await (const entry of entries) {
+    for (const entry of entries) {
       this.ingestPersistedHistoryEntry(entry, timeline, replay);
     }
 
@@ -5360,33 +5314,27 @@ class ClaudeAgentSession implements AgentSession {
     }
   }
 
-  private async ingestPersistedSidechains(
-    history: ClaudeReplayHistory,
-  ): Promise<ClaudeReplayOwnership> {
-    const parentFacts = await readClaudeReplayParentFacts(history.parentEntries);
+  private ingestPersistedSidechains(history: ClaudeReplayHistory): ClaudeReplayOwnership {
+    const parentFacts = readClaudeReplayParentFacts(history.parentEntries);
 
     // Replay produces the same observations the live task protocol produces, then folds them
     // with the same function, so identity and status are derived once for both paths.
-    const subagents = [];
-    for (const subagent of history.subagents) {
-      subagents.push({
+    const subagentReplay = observeReplaySubagents({
+      subagents: history.subagents.map((subagent) => ({
         ...subagent,
-        parentFacts: await readClaudeReplayParentFacts(subagent.entries),
-      });
-    }
-    const subagentReplay = await observeReplaySubagents({
-      subagents,
+        parentFacts: readClaudeReplayParentFacts(subagent.entries),
+      })),
       parent: parentFacts,
       convertEntry: (entry) => this.convertHistoryEntry(entry),
     });
     const observations = [
       ...subagentReplay.observations,
-      ...(await observeReplayWorkflows({
+      ...observeReplayWorkflows({
         workflows: history.workflows,
         parentEntries: history.parentEntries,
         entriesByRunId: history.workflowEntriesByRunId,
         convertEntry: (entry) => this.convertHistoryEntry(entry),
-      })),
+      }),
     ];
     const restoredProviderSubagentIds = new Set(
       observations
@@ -5473,10 +5421,10 @@ class ClaudeAgentSession implements AgentSession {
     }
   }
 
-  private async resolveHistoryPath(sessionId: string): Promise<string | null> {
+  private resolveHistoryPath(sessionId: string): string | null {
     const cwd = this.config.cwd;
     if (!cwd) return null;
-    return claudeTranscriptPath({
+    return claudeTranscriptPathSync({
       cwd,
       sessionId,
       configDir: claudeConfigDir(this.harnessEnvironment),
@@ -6243,13 +6191,13 @@ function labelReplayedSubagentCard(
  * source consumes. The agentId scrape is kept only as a fallback for sessions recorded before
  * Claude Code wrote the meta sidecar.
  */
-async function readClaudeReplayParentFacts(
-  entries: Iterable<ClaudeHistoryEntry> | AsyncIterable<ClaudeHistoryEntry>,
-): Promise<ClaudeReplayParentFacts> {
+function readClaudeReplayParentFacts(
+  entries: Iterable<ClaudeHistoryEntry>,
+): ClaudeReplayParentFacts {
   const toolCalls = new Map<string, { title?: string; description?: string }>();
   const linksByAgentId = new Map<string, { toolCallId: string; failed: boolean }>();
   const outcomes = new Map<string, { failed: boolean }>();
-  for await (const entry of entries) {
+  for (const entry of entries) {
     const content = toObjectRecord(entry.message)?.content;
     if (!Array.isArray(content)) continue;
     for (const value of content) {
@@ -6781,7 +6729,7 @@ async function readClaudeRenamedSessionTitle(input: {
 }): Promise<string | null> {
   let content: string;
   try {
-    content = await fsPromises.readFile(await claudeTranscriptPath(input), "utf8");
+    content = await fsPromises.readFile(claudeTranscriptPathSync(input), "utf8");
   } catch (error) {
     // A session with no transcript on disk has no rename to carry over. Every
     // other read failure is a real fault and stays explicit.
@@ -6881,13 +6829,3 @@ function readClaudeCommandLifecycle(message: unknown): ClaudeCommandLifecycle |
     state: record.state as ClaudeCommandLifecycle["state"],
   };
 }
-
-async function transcriptExists(file: string): Promise<boolean> {
-  try {
-    await fs.promises.access(file);
-    return true;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-    throw error;
-  }
-}

packages/server/src/server/agent/providers/claude/project-dir.ts

@@ -1,5 +1,5 @@
-import { realpathSync } from "node:fs";
-import { realpath, access, readdir } from "node:fs/promises";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -35,21 +35,21 @@ export function claudeProjectDirSync(cwd: string, options?: ClaudeProjectDirOpti
 // one `cwd` encodes to when the project moved, the daemon migrated, or Claude Code sees the
 // cwd under another name (a Windows binary under WSL). Returns the expected path when no
 // transcript exists anywhere.
-export async function claudeTranscriptPath(input: {
+export function claudeTranscriptPathSync(input: {
   cwd: string;
   sessionId: string;
   configDir?: string;
-}): Promise<string> {
+}): string {
   const options = { configDir: input.configDir };
   const fileName = `${input.sessionId}.jsonl`;
-  const expected = join(await claudeProjectDir(input.cwd, options), fileName);
-  if (await exists(expected)) {
+  const expected = join(claudeProjectDirSync(input.cwd, options), fileName);
+  if (existsSync(expected)) {
     return expected;
   }
   const projectsRoot = join(resolveConfigDir(options), "projects");
   let projectDirs: string[];
   try {
-    projectDirs = await readdir(projectsRoot);
+    projectDirs = readdirSync(projectsRoot);
   } catch (error) {
     if (isMissingDirectoryError(error)) {
       return expected;
@@ -58,23 +58,13 @@ export async function claudeTranscriptPath(input: {
   }
   for (const projectDir of projectDirs) {
     const candidate = join(projectsRoot, projectDir, fileName);
-    if (await exists(candidate)) {
+    if (existsSync(candidate)) {
       return candidate;
     }
   }
   return expected;
 }
 
-async function exists(file: string): Promise<boolean> {
-  try {
-    await access(file);
-    return true;
-  } catch (error) {
-    if (isMissingDirectoryError(error)) return false;
-    throw error;
-  }
-}
-
 function isMissingDirectoryError(error: unknown): boolean {
   const code = (error as NodeJS.ErrnoException | null)?.code;
   return code === "ENOENT" || code === "ENOTDIR";

packages/server/src/server/agent/providers/claude/query.ts

@@ -2,10 +2,11 @@ import { type ChildProcess, type ChildProcessWithoutNullStreams } from "node:chi
 import { query, type Options, type Query, type SpawnOptions } from "@anthropic-ai/claude-agent-sdk";
 
 import {
+  createProviderEnv,
   createProviderEnvSpec,
   type ProviderRuntimeSettings,
 } from "../../provider-launch-config.js";
-import { buildSelfNodeCommand, createExternalProcessEnv } from "../../../paseo-env.js";
+import { buildSelfNodeCommand } from "../../../paseo-env.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 
 // Keep the raw SDK query import in this module only. Claude process launch behavior
@@ -73,9 +74,11 @@ function applyRuntimeSettingsToClaudeOptions(
         runtimeSettings,
         overlays: [launchEnv],
       });
-      // Set our identity after sanitization clears the parent session's entrypoint.
-      providerEnvSpec.envOverlay.CLAUDE_CODE_ENTRYPOINT = "Paseo";
-      const providerEnv = createExternalProcessEnv(spawnOptions.env, providerEnvSpec.envOverlay);
+      const providerEnv = createProviderEnv({
+        baseEnv: spawnOptions.env,
+        runtimeSettings,
+        overlays: [launchEnv],
+      });
       const selfNodeCommand = isDefaultRuntime
         ? buildSelfNodeCommand(resolved.args, providerEnv)
         : null;

packages/server/src/server/agent/providers/claude/rewind.ts

@@ -76,7 +76,7 @@ export async function revertClaudeConversation(input: {
   transcriptPath: string | null;
   messageId: string;
   resolveMessageId?: (messageId: string) => string | Promise<string>;
-  setSessionId: (sessionId: string) => void | Promise<void>;
+  setSessionId: (sessionId: string) => void;
 }): Promise<void> {
   if (!input.sessionId || !input.transcriptPath) {
     throw new Error("Claude session is not ready for rewind");
@@ -86,7 +86,7 @@ export async function revertClaudeConversation(input: {
     upToMessageId: messageId,
     transcriptPath: input.transcriptPath,
   });
-  await input.setSessionId(fork.sessionId);
+  input.setSessionId(fork.sessionId);
 }
 
 export async function revertClaudeFiles(input: {
@@ -108,7 +108,7 @@ export async function revertClaudeConversationAndFiles(input: {
   transcriptPath: string | null;
   messageId: string;
   resolveMessageId?: (messageId: string) => string | Promise<string>;
-  setSessionId: (sessionId: string) => void | Promise<void>;
+  setSessionId: (sessionId: string) => void;
 }): Promise<void> {
   await revertClaudeFiles({
     query: input.query,

packages/server/src/server/agent/providers/claude/subagents/replay-source.test.ts

@@ -45,7 +45,7 @@ function applyToStore(observations: SubagentObservation[]): ProviderSubagentDesc
 }
 
 describe("parseClaudeSubagentMeta", () => {
-  it("reads the real sidecar shape", async () => {
+  it("reads the real sidecar shape", () => {
     expect(
       parseClaudeSubagentMeta(
         '{"agentType":"general-purpose","description":"Reply banana","toolUseId":"toolu_013i","spawnDepth":1}',
@@ -68,7 +68,7 @@ describe("parseClaudeSubagentMeta", () => {
     expect(parseClaudeSubagentMeta(contents)).toBeNull();
   });
 
-  it("keeps the good fields when one field has the wrong type", async () => {
+  it("keeps the good fields when one field has the wrong type", () => {
     expect(parseClaudeSubagentMeta('{"agentType":"Explore","toolUseId":42}')).toEqual({
       agentType: "Explore",
       description: undefined,
@@ -79,14 +79,12 @@ describe("parseClaudeSubagentMeta", () => {
 });
 
 describe("observeReplaySubagents", () => {
-  it("links a subagent to its Task call through meta.toolUseId", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("links a subagent to its Task call through meta.toolUseId", () => {
+    const observations = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations[0]).toMatchObject({
       kind: "declared",
@@ -97,33 +95,31 @@ describe("observeReplaySubagents", () => {
     });
   });
 
-  it("replays descendants beneath the sidechain that declared their Task", async () => {
+  it("replays descendants beneath the sidechain that declared their Task", () => {
     const nestedToolUseId = "toolu_012rzYnFZA";
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID, spawnDepth: 1 },
-            entries: [],
-            parentFacts: {
-              toolCalls: new Map([
-                [nestedToolUseId, { title: "Explore", description: "Nested audit" }],
-              ]),
-              linksByAgentId: new Map(),
-              outcomesByToolCallId: new Map([[nestedToolUseId, { failed: false }]]),
-            },
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID, spawnDepth: 1 },
+          entries: [],
+          parentFacts: {
+            toolCalls: new Map([
+              [nestedToolUseId, { title: "Explore", description: "Nested audit" }],
+            ]),
+            linksByAgentId: new Map(),
+            outcomesByToolCallId: new Map([[nestedToolUseId, { failed: false }]]),
           },
-          {
-            agentId: "a6acb4b898",
-            meta: { toolUseId: nestedToolUseId, agentType: "Explore", spawnDepth: 2 },
-            entries: [],
-          },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+        },
+        {
+          agentId: "a6acb4b898",
+          meta: { toolUseId: nestedToolUseId, agentType: "Explore", spawnDepth: 2 },
+          entries: [],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations).toContainEqual(
       expect.objectContaining({
@@ -134,143 +130,89 @@ describe("observeReplaySubagents", () => {
     );
   });
 
-  it("keeps a subagent recorded before spawnDepth existed", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("keeps a subagent recorded before spawnDepth existed", () => {
+    const observations = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations[0]).toMatchObject({ kind: "declared", id: TOOL_USE_ID });
   });
 
-  it("drops a meta-linked subagent when the parent never declared its Task", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID, agentType: "Explore", description: "Find the code" },
-            entries: [],
-          },
-        ],
-        parent: emptyParent(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("drops a meta-linked subagent when the parent never declared its Task", () => {
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID, agentType: "Explore", description: "Find the code" },
+          entries: [],
+        },
+      ],
+      parent: emptyParent(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations).toEqual([]);
   });
 
-  it("falls back to the scraped link when there is no meta file", async () => {
+  it("falls back to the scraped link when there is no meta file", () => {
     const parent: ClaudeReplayParentFacts = {
       toolCalls: new Map([[TOOL_USE_ID, { title: "Explore" }]]),
       linksByAgentId: new Map([[AGENT_ID, { toolCallId: TOOL_USE_ID, failed: false }]]),
       outcomesByToolCallId: new Map(),
     };
 
-    const [declared, ...rest] = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: null, entries: [] }],
-        parent,
-        convertEntry: () => [],
-      })
-    ).observations;
+    const [declared, ...rest] = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: null, entries: [] }],
+      parent,
+      convertEntry: () => [],
+    }).observations;
 
     expect(declared).toMatchObject({ id: TOOL_USE_ID, toolCallId: TOOL_USE_ID, title: "Explore" });
     expect(rest.at(-1)).toMatchObject({ kind: "status", status: "completed" });
   });
 
-  it("drops an unlinkable subagent", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: null, entries: [] }],
-        parent: emptyParent(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("drops an unlinkable subagent", () => {
+    const observations = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: null, entries: [] }],
+      parent: emptyParent(),
+      convertEntry: () => [],
+    }).observations;
     expect(observations).toEqual([]);
   });
 
-  it("drops a terminal subagent the parent has no Task call for", async () => {
+  it("drops a terminal subagent the parent has no Task call for", () => {
     // A legacy grandchild: its toolUseId names a Task call made inside a sibling's transcript, so
     // no tool_result for it can ever reach the parent. Left running, it never stops.
     const descriptor = applyToStore(
-      (
-        await observeReplaySubagents({
-          subagents: [
-            {
-              agentId: AGENT_ID,
-              meta: { toolUseId: TOOL_USE_ID },
-              entries: [
-                {
-                  type: "assistant",
-                  timestamp: "2026-07-31T03:41:00.000Z",
-                  message: { stop_reason: "end_turn" },
-                },
-              ],
-            },
-          ],
-          parent: emptyParent(),
-          convertEntry: () => [],
-        })
-      ).observations,
+      observeReplaySubagents({
+        subagents: [
+          {
+            agentId: AGENT_ID,
+            meta: { toolUseId: TOOL_USE_ID },
+            entries: [
+              {
+                type: "assistant",
+                timestamp: "2026-07-31T03:41:00.000Z",
+                message: { stop_reason: "end_turn" },
+              },
+            ],
+          },
+        ],
+        parent: emptyParent(),
+        convertEntry: () => [],
+      }).observations,
     );
 
     expect(descriptor).toBeNull();
   });
 
-  it("drops a terminal skill-spawned subagent that has no link at all", async () => {
+  it("drops a terminal skill-spawned subagent that has no link at all", () => {
     // A /code-review run: no Task tool_use exists to name it, so its sidecar carries only
     // agentType and its id appears nowhere in the parent transcript.
     const descriptor = applyToStore(
-      (
-        await observeReplaySubagents({
-          subagents: [
-            {
-              agentId: AGENT_ID,
-              meta: { agentType: "general-purpose" },
-              entries: [
-                {
-                  type: "assistant",
-                  timestamp: "2026-07-31T03:41:00.000Z",
-                  message: { stop_reason: "end_turn" },
-                },
-              ],
-            },
-          ],
-          parent: emptyParent(),
-          convertEntry: () => [],
-        })
-      ).observations,
-    );
-
-    expect(descriptor).toBeNull();
-  });
-
-  it("reports a scraped link's failure as failed", async () => {
-    const descriptor = applyToStore(
-      (
-        await observeReplaySubagents({
-          subagents: [{ agentId: AGENT_ID, meta: null, entries: [] }],
-          parent: {
-            toolCalls: new Map([[TOOL_USE_ID, { title: "Explore" }]]),
-            linksByAgentId: new Map([[AGENT_ID, { toolCallId: TOOL_USE_ID, failed: true }]]),
-            outcomesByToolCallId: new Map(),
-          },
-          convertEntry: () => [],
-        })
-      ).observations,
-    );
-
-    expect(descriptor).toMatchObject({ id: TOOL_USE_ID, status: "failed" });
-  });
-
-  it("drops a non-terminal linkless subagent", async () => {
-    const observations = (
-      await observeReplaySubagents({
+      observeReplaySubagents({
         subagents: [
           {
             agentId: AGENT_ID,
@@ -279,81 +221,111 @@ describe("observeReplaySubagents", () => {
               {
                 type: "assistant",
                 timestamp: "2026-07-31T03:41:00.000Z",
-                message: { stop_reason: null },
+                message: { stop_reason: "end_turn" },
               },
             ],
           },
         ],
         parent: emptyParent(),
         convertEntry: () => [],
-      })
-    ).observations;
+      }).observations,
+    );
+
+    expect(descriptor).toBeNull();
+  });
+
+  it("reports a scraped link's failure as failed", () => {
+    const descriptor = applyToStore(
+      observeReplaySubagents({
+        subagents: [{ agentId: AGENT_ID, meta: null, entries: [] }],
+        parent: {
+          toolCalls: new Map([[TOOL_USE_ID, { title: "Explore" }]]),
+          linksByAgentId: new Map([[AGENT_ID, { toolCallId: TOOL_USE_ID, failed: true }]]),
+          outcomesByToolCallId: new Map(),
+        },
+        convertEntry: () => [],
+      }).observations,
+    );
+
+    expect(descriptor).toMatchObject({ id: TOOL_USE_ID, status: "failed" });
+  });
+
+  it("drops a non-terminal linkless subagent", () => {
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { agentType: "general-purpose" },
+          entries: [
+            {
+              type: "assistant",
+              timestamp: "2026-07-31T03:41:00.000Z",
+              message: { stop_reason: null },
+            },
+          ],
+        },
+      ],
+      parent: emptyParent(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations).toEqual([]);
   });
 
-  it("finishes a terminal Task child when the parent has not recorded its outcome", async () => {
+  it("finishes a terminal Task child when the parent has not recorded its outcome", () => {
     const descriptor = applyToStore(
-      (
-        await observeReplaySubagents({
-          subagents: [
-            {
-              agentId: AGENT_ID,
-              meta: { toolUseId: TOOL_USE_ID },
-              entries: [
-                {
-                  type: "assistant",
-                  timestamp: "2026-07-31T03:41:00.000Z",
-                  message: { stop_reason: "end_turn" },
-                },
-              ],
-            },
-          ],
-          parent: { ...parentWithTaskCall(), outcomesByToolCallId: new Map() },
-          convertEntry: () => [],
-        })
-      ).observations,
+      observeReplaySubagents({
+        subagents: [
+          {
+            agentId: AGENT_ID,
+            meta: { toolUseId: TOOL_USE_ID },
+            entries: [
+              {
+                type: "assistant",
+                timestamp: "2026-07-31T03:41:00.000Z",
+                message: { stop_reason: "end_turn" },
+              },
+            ],
+          },
+        ],
+        parent: { ...parentWithTaskCall(), outcomesByToolCallId: new Map() },
+        convertEntry: () => [],
+      }).observations,
     );
 
     expect(descriptor).toMatchObject({ status: "completed" });
   });
 
-  it("leaves a subagent with no recorded outcome running", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
-        parent: { ...parentWithTaskCall(), outcomesByToolCallId: new Map() },
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("leaves a subagent with no recorded outcome running", () => {
+    const observations = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
+      parent: { ...parentWithTaskCall(), outcomesByToolCallId: new Map() },
+      convertEntry: () => [],
+    }).observations;
     expect(observations.some((o) => o.kind === "status")).toBe(false);
   });
 
-  it("reports a failed outcome as failed", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
-        parent: parentWithTaskCall(true),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("reports a failed outcome as failed", () => {
+    const observations = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
+      parent: parentWithTaskCall(true),
+      convertEntry: () => [],
+    }).observations;
     expect(observations.at(-1)).toMatchObject({ kind: "status", status: "failed" });
   });
 
-  it("carries entry timestamps onto timeline observations", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID },
-            entries: [{ type: "assistant", timestamp: "2026-07-26T06:27:47.034Z" }],
-          },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [{ type: "reasoning", text: "thinking" }],
-      })
-    ).observations;
+  it("carries entry timestamps onto timeline observations", () => {
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID },
+          entries: [{ type: "assistant", timestamp: "2026-07-26T06:27:47.034Z" }],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [{ type: "reasoning", text: "thinking" }],
+    }).observations;
 
     expect(observations.find((observation) => observation.kind === "timeline")).toMatchObject({
       kind: "timeline",
@@ -364,20 +336,18 @@ describe("observeReplaySubagents", () => {
 });
 
 describe("replay runtime", () => {
-  it("reads the model and effort off the subagent's own transcript", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID },
-            entries: [{ type: "assistant", effort: "high", message: { model: "claude-opus-5" } }],
-          },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("reads the model and effort off the subagent's own transcript", () => {
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID },
+          entries: [{ type: "assistant", effort: "high", message: { model: "claude-opus-5" } }],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations.find((o) => o.kind === "subtitle")).toEqual({
       kind: "subtitle",
@@ -386,55 +356,49 @@ describe("replay runtime", () => {
     });
   });
 
-  it("takes the last observed values when the model changes mid-transcript", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID },
-            entries: [
-              { type: "assistant", effort: "high", message: { model: "claude-opus-5" } },
-              { type: "assistant", effort: "low", message: { model: "claude-sonnet-5" } },
-            ],
-          },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("takes the last observed values when the model changes mid-transcript", () => {
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID },
+          entries: [
+            { type: "assistant", effort: "high", message: { model: "claude-opus-5" } },
+            { type: "assistant", effort: "low", message: { model: "claude-sonnet-5" } },
+          ],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
 
     expect(observations.find((o) => o.kind === "subtitle")).toMatchObject({
       subtitle: "general-purpose · Sonnet 5 · Low",
     });
   });
 
-  it("reports nothing when the transcript never names a model or effort", async () => {
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+  it("reports nothing when the transcript never names a model or effort", () => {
+    const observations = observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries: [] }],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
     expect(observations.some((o) => o.kind === "subtitle")).toBe(false);
   });
 
-  it("passes through a model the manifest does not know", async () => {
+  it("passes through a model the manifest does not know", () => {
     // Claude Code is an Anthropic-compatible client; subagents legitimately report other models.
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID },
-            entries: [{ type: "assistant", message: { model: "glm-5.1" } }],
-          },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID },
+          entries: [{ type: "assistant", message: { model: "glm-5.1" } }],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
     expect(observations.find((o) => o.kind === "subtitle")).toMatchObject({
       subtitle: "general-purpose · glm-5.1",
     });
@@ -442,24 +406,20 @@ describe("replay runtime", () => {
 });
 
 describe("replay usage", () => {
-  async function subtitleOf(
-    entries: ClaudeReplayEntry[],
-  ): Promise<SubagentObservation | undefined> {
-    return (
-      await observeReplaySubagents({
-        subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries }],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations.find((observation) => observation.kind === "subtitle");
+  function subtitleOf(entries: ClaudeReplayEntry[]): SubagentObservation | undefined {
+    return observeReplaySubagents({
+      subagents: [{ agentId: AGENT_ID, meta: { toolUseId: TOOL_USE_ID }, entries }],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations.find((observation) => observation.kind === "subtitle");
   }
 
-  it("derives the counters Claude Code itself reports, from a real transcript's shape", async () => {
+  it("derives the counters Claude Code itself reports, from a real transcript's shape", () => {
     // Shape and numbers taken from an on-disk subagent transcript. Claude Code finalizes a
     // subagent from the LAST assistant entry's usage, so the earlier, smaller turn must not win
     // and must not be added in.
     expect(
-      await subtitleOf([
+      subtitleOf([
         {
           type: "assistant",
           timestamp: "2026-07-23T23:18:43.023Z",
@@ -502,9 +462,9 @@ describe("replay usage", () => {
     });
   });
 
-  it("formats tokens for a child that only answered", async () => {
+  it("formats tokens for a child that only answered", () => {
     expect(
-      await subtitleOf([
+      subtitleOf([
         {
           type: "assistant",
           timestamp: "2026-07-27T16:42:14.698Z",
@@ -519,12 +479,12 @@ describe("replay usage", () => {
     ).toMatchObject({ subtitle: "general-purpose · 16.4k tokens" });
   });
 
-  it("emits nothing for a transcript with no entries", async () => {
-    expect(await subtitleOf([])).toBeUndefined();
+  it("emits nothing for a transcript with no entries", () => {
+    expect(subtitleOf([])).toBeUndefined();
   });
 
-  it("keeps duration out of the compact subtitle", async () => {
-    const observation = await subtitleOf([
+  it("keeps duration out of the compact subtitle", () => {
+    const observation = subtitleOf([
       {
         type: "assistant",
         timestamp: "2026-07-27T16:42:14.698Z",
@@ -534,8 +494,8 @@ describe("replay usage", () => {
     expect(observation).toMatchObject({ subtitle: "general-purpose · 10 tokens" });
   });
 
-  it("omits totalTokens when no entry carries a usage block", async () => {
-    const observation = await subtitleOf([
+  it("omits totalTokens when no entry carries a usage block", () => {
+    const observation = subtitleOf([
       { type: "assistant", timestamp: "2026-07-27T16:42:14.698Z", message: { content: [] } },
       {
         type: "assistant",
@@ -546,9 +506,9 @@ describe("replay usage", () => {
     expect(observation).toBeUndefined();
   });
 
-  it("keeps the last usage-bearing entry when the final assistant entry has none", async () => {
+  it("keeps the last usage-bearing entry when the final assistant entry has none", () => {
     expect(
-      await subtitleOf([
+      subtitleOf([
         {
           type: "assistant",
           timestamp: "2026-07-27T16:42:14.698Z",
@@ -559,36 +519,34 @@ describe("replay usage", () => {
     ).toMatchObject({ subtitle: "general-purpose · 1k tokens" });
   });
 
-  it("only reports counters the transcript actually shows", async () => {
+  it("only reports counters the transcript actually shows", () => {
     // A user-only transcript says nothing about cost: no assistant turn, so no tool count either.
-    const observation = await subtitleOf([
+    const observation = subtitleOf([
       { type: "user", timestamp: "2026-07-27T16:42:14.698Z", message: { content: "prompt" } },
       { type: "user", timestamp: "2026-07-27T16:42:20.000Z", message: { content: "more" } },
     ]);
     expect(observation).toBeUndefined();
   });
 
-  it("lands the complete provider-owned subtitle on the descriptor", async () => {
+  it("lands the complete provider-owned subtitle on the descriptor", () => {
     const store = new ProviderSubagentStore();
-    const observations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: { toolUseId: TOOL_USE_ID },
-            entries: [
-              {
-                type: "assistant",
-                timestamp: "2026-07-27T16:42:14.698Z",
-                message: { content: [], usage: { input_tokens: 7 } },
-              },
-            ],
-          },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+    const observations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: { toolUseId: TOOL_USE_ID },
+          entries: [
+            {
+              type: "assistant",
+              timestamp: "2026-07-27T16:42:14.698Z",
+              message: { content: [], usage: { input_tokens: 7 } },
+            },
+          ],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
     for (const event of foldSubagentObservations(observations)) {
       store.apply("parent", "claude", event);
     }
@@ -601,7 +559,7 @@ describe("live and replay agree", () => {
   // The property the design exists to guarantee: one session, two sources, one descriptor.
   // This is inexpressible against the inference implementation, where the paths share no
   // vocabulary and each derives identity and status its own way.
-  it("produces identical descriptor state from the wire and from disk", async () => {
+  it("produces identical descriptor state from the wire and from disk", () => {
     const live = new ClaudeTaskProtocolSource();
     const liveObservations = [
       ...live.observe({
@@ -621,23 +579,21 @@ describe("live and replay agree", () => {
       } as unknown as SDKMessage),
     ];
 
-    const replayObservations = (
-      await observeReplaySubagents({
-        subagents: [
-          {
-            agentId: AGENT_ID,
-            meta: {
-              toolUseId: TOOL_USE_ID,
-              agentType: "general-purpose",
-              description: "Summarize hover and unistyles docs",
-            },
-            entries: [],
+    const replayObservations = observeReplaySubagents({
+      subagents: [
+        {
+          agentId: AGENT_ID,
+          meta: {
+            toolUseId: TOOL_USE_ID,
+            agentType: "general-purpose",
+            description: "Summarize hover and unistyles docs",
           },
-        ],
-        parent: parentWithTaskCall(),
-        convertEntry: () => [],
-      })
-    ).observations;
+          entries: [],
+        },
+      ],
+      parent: parentWithTaskCall(),
+      convertEntry: () => [],
+    }).observations;
 
     const fromWire = applyToStore(liveObservations);
     const fromDisk = applyToStore(replayObservations);

packages/server/src/server/agent/providers/claude/subagents/replay-source.ts

@@ -130,7 +130,7 @@ function readUsage(entry: ClaudeReplayEntry): ClaudeSubagentUsage | null {
 export interface ClaudeReplaySubagentInput {
   agentId: string;
   meta: ClaudeSubagentMeta | null;
-  entries: Iterable<ClaudeReplayEntry> | AsyncIterable<ClaudeReplayEntry>;
+  entries: Iterable<ClaudeReplayEntry>;
   /** Task declarations made by this subagent, used to attach its direct children. */
   parentFacts?: ClaudeReplayParentFacts;
 }
@@ -250,13 +250,13 @@ function observeSubtitle(
   };
 }
 
-async function observeSubagent(
+function observeSubagent(
   subagent: ClaudeReplaySubagentInput,
   parent: ClaudeReplayParentFacts,
   convertEntry: (entry: ClaudeReplayEntry) => AgentTimelineItem[],
   toolOwners: Map<string, string>,
   parentSubagentId?: string,
-): Promise<SubagentObservation[]> {
+): SubagentObservation[] {
   const link = resolveParentLink(subagent, parent);
   if (!link) return [];
   const toolCall = parent.toolCalls.get(link.toolCallId);
@@ -269,7 +269,7 @@ async function observeSubagent(
   let childTerminalStatus: ProviderSubagentStatus | null = null;
 
   // Consume each source once for presentation and timeline; keep no raw transcript records.
-  for await (const entry of subagent.entries) {
+  for (const entry of subagent.entries) {
     const timestamp = normalizeProviderReplayTimestamp(entry.timestamp);
     if (!seenEntry) firstTimestamp = timestamp;
     seenEntry = true;
@@ -320,11 +320,11 @@ function recordReplayToolOwners(
   }
 }
 
-export async function observeReplaySubagents(input: {
+export function observeReplaySubagents(input: {
   subagents: readonly ClaudeReplaySubagentInput[];
   parent: ClaudeReplayParentFacts;
   convertEntry: (entry: ClaudeReplayEntry) => AgentTimelineItem[];
-}): Promise<{ observations: SubagentObservation[]; toolOwners: ReadonlyMap<string, string> }> {
+}): { observations: SubagentObservation[]; toolOwners: ReadonlyMap<string, string> } {
   const observations: SubagentObservation[] = [];
   const toolOwners = new Map<string, string>();
   const unresolved = [...input.subagents].sort(
@@ -346,7 +346,7 @@ export async function observeReplaySubagents(input: {
       const { ownerId, parent, link } = resolved;
 
       // Only proven descendants may own notifications; ambient sidecars cannot claim them.
-      for (const observation of await observeSubagent(
+      for (const observation of observeSubagent(
         subagent,
         parent,
         input.convertEntry,

packages/server/src/server/agent/providers/claude/subagents/workflow-replay-source.test.ts

@@ -35,7 +35,7 @@ function parentEntries(
 }
 
 describe("Claude workflow replay", () => {
-  it("parses the persisted run summary observed from Claude Code 2.1.220", async () => {
+  it("parses the persisted run summary observed from Claude Code 2.1.220", () => {
     expect(
       parseClaudeWorkflowRun(
         JSON.stringify({
@@ -62,8 +62,8 @@ describe("Claude workflow replay", () => {
     });
   });
 
-  it("rebuilds the same generic completed descriptor through the parent Workflow call", async () => {
-    const observations = await observeReplayWorkflows({
+  it("rebuilds the same generic completed descriptor through the parent Workflow call", () => {
+    const observations = observeReplayWorkflows({
       workflows: [
         {
           runId: RUN_ID,
@@ -91,8 +91,8 @@ describe("Claude workflow replay", () => {
     });
   });
 
-  it("rebuilds a workflow when Claude persists its result as structured text blocks", async () => {
-    const observations = await observeReplayWorkflows({
+  it("rebuilds a workflow when Claude persists its result as structured text blocks", () => {
+    const observations = observeReplayWorkflows({
       workflows: [{ runId: RUN_ID, summary: "Structured result workflow", status: "completed" }],
       parentEntries: parentEntries([
         {
@@ -114,7 +114,7 @@ describe("Claude workflow replay", () => {
     });
   });
 
-  it("replays the workflow result without exposing its script or child prompt", async () => {
+  it("replays the workflow result without exposing its script or child prompt", () => {
     const workflow = parseClaudeWorkflowRun(
       JSON.stringify({
         runId: RUN_ID,
@@ -128,7 +128,7 @@ describe("Claude workflow replay", () => {
     expect(workflow).not.toBeNull();
     if (!workflow) throw new Error("expected workflow");
 
-    const observations = await observeReplayWorkflows({
+    const observations = observeReplayWorkflows({
       workflows: [workflow],
       parentEntries: parentEntries(),
     });
@@ -145,9 +145,9 @@ describe("Claude workflow replay", () => {
     expect(JSON.stringify(observations)).not.toContain("SECRET CHILD PROMPT");
   });
 
-  it("does not duplicate a result already present in the child transcript", async () => {
+  it("does not duplicate a result already present in the child transcript", () => {
     const report = "What Paseo is\nA local-first coding-agent environment.";
-    const observations = await observeReplayWorkflows({
+    const observations = observeReplayWorkflows({
       workflows: [
         { runId: RUN_ID, summary: "Inspect Paseo", status: "completed", result: { report } },
       ],
@@ -166,8 +166,8 @@ describe("Claude workflow replay", () => {
     ).toHaveLength(1);
   });
 
-  it("fails a nonterminal persisted run because its former runtime cannot update it", async () => {
-    const observations = await observeReplayWorkflows({
+  it("fails a nonterminal persisted run because its former runtime cannot update it", () => {
+    const observations = observeReplayWorkflows({
       workflows: [{ runId: RUN_ID, summary: "Interrupted workflow", status: "running" }],
       parentEntries: parentEntries(),
     });
@@ -179,9 +179,9 @@ describe("Claude workflow replay", () => {
     });
   });
 
-  it("drops a run that no parent Workflow tool call declared", async () => {
+  it("drops a run that no parent Workflow tool call declared", () => {
     expect(
-      await observeReplayWorkflows({
+      observeReplayWorkflows({
         workflows: [{ runId: RUN_ID, status: "completed" }],
         parentEntries: [],
       }),

packages/server/src/server/agent/providers/claude/subagents/workflow-replay-source.ts

@@ -45,17 +45,14 @@ export function parseClaudeWorkflowRun(contents: string): ClaudeWorkflowRun | nu
  * provider runtime was recreated, so replay terminalizes it as failed instead of resurrecting a
  * row that can never receive another update.
  */
-export async function observeReplayWorkflows(input: {
+export function observeReplayWorkflows(input: {
   workflows: readonly ClaudeWorkflowRun[];
-  parentEntries: Iterable<ClaudeWorkflowParentEntry> | AsyncIterable<ClaudeWorkflowParentEntry>;
+  parentEntries: Iterable<ClaudeWorkflowParentEntry>;
   /** Repeatable entries in chronological order, supplied by the transcript reader. */
-  entriesByRunId?: ReadonlyMap<
-    string,
-    Iterable<ClaudeReplayEntry> | AsyncIterable<ClaudeReplayEntry>
-  >;
+  entriesByRunId?: ReadonlyMap<string, Iterable<ClaudeReplayEntry>>;
   convertEntry?: (entry: ClaudeReplayEntry) => AgentTimelineItem[];
-}): Promise<SubagentObservation[]> {
-  const toolCallIdByRunId = await readWorkflowLinks(input.parentEntries);
+}): SubagentObservation[] {
+  const toolCallIdByRunId = readWorkflowLinks(input.parentEntries);
   const observations: SubagentObservation[] = [];
 
   for (const workflow of input.workflows) {
@@ -82,7 +79,7 @@ export async function observeReplayWorkflows(input: {
       });
     }
 
-    for (const observation of await observeWorkflowTimeline({
+    for (const observation of observeWorkflowTimeline({
       id,
       result: workflow.result,
       entries: input.entriesByRunId?.get(workflow.runId) ?? [],
@@ -118,17 +115,17 @@ export async function observeReplayWorkflows(input: {
   return observations;
 }
 
-async function observeWorkflowTimeline(input: {
+function observeWorkflowTimeline(input: {
   id: string;
   result: unknown;
-  entries: Iterable<ClaudeReplayEntry> | AsyncIterable<ClaudeReplayEntry>;
+  entries: Iterable<ClaudeReplayEntry>;
   convertEntry?: (entry: ClaudeReplayEntry) => AgentTimelineItem[];
   finishedAt?: string;
-}): Promise<SubagentObservation[]> {
+}): SubagentObservation[] {
   const observations: SubagentObservation[] = [];
   const replayedAssistantText = new Set<string>();
 
-  for await (const entry of input.entries) {
+  for (const entry of input.entries) {
     const timestamp = normalizeProviderReplayTimestamp(entry.timestamp);
     const items = input.convertEntry?.(entry) ?? [];
     for (const item of items) {
@@ -153,13 +150,11 @@ async function observeWorkflowTimeline(input: {
   return observations;
 }
 
-async function readWorkflowLinks(
-  entries: Iterable<ClaudeWorkflowParentEntry> | AsyncIterable<ClaudeWorkflowParentEntry>,
-): Promise<Map<string, string>> {
+function readWorkflowLinks(entries: Iterable<ClaudeWorkflowParentEntry>): Map<string, string> {
   const workflowToolCallIds = new Set<string>();
   const toolCallIdByRunId = new Map<string, string>();
 
-  for await (const entry of entries) {
+  for (const entry of entries) {
     const content = entry.message?.content;
     if (!Array.isArray(content)) continue;
     for (const value of content) {
@@ -170,7 +165,7 @@ async function readWorkflowLinks(
     }
   }
 
-  for await (const entry of entries) {
+  for (const entry of entries) {
     const content = entry.message?.content;
     if (!Array.isArray(content)) continue;
     for (const value of content) {

packages/server/src/server/agent/providers/claude/task-notification-tool-call.ts

@@ -221,11 +221,9 @@ function parseTaskNotificationFromSystemRecord(record: unknown): TaskNotificatio
 /** Normalize notification identity for one transcript traversal. Queue bookkeeping and delivery
  * are separate records of the same occurrence; each source counts repeated identical bodies
  * independently so the second event is not merged with the first. */
-export async function* assignTaskNotificationReplayIds<T>(
-  entries: AsyncIterable<T>,
-): AsyncGenerator<T> {
+export function* assignTaskNotificationReplayIds<T>(entries: Iterable<T>): Generator<T> {
   const occurrences = new Map<string, Map<string, number>>();
-  for await (const entry of entries) {
+  for (const entry of entries) {
     const record = TaskNotificationHistoryRecordSchema.safeParse(entry);
     if (!record.success) {
       yield entry;

packages/server/src/server/agent/providers/claude/transcript-history.ts

@@ -1,6 +1,5 @@
 import { assignTaskNotificationReplayIds } from "./task-notification-tool-call.js";
-import fs, { type FileHandle } from "node:fs/promises";
-import { setImmediate } from "node:timers/promises";
+import fs from "node:fs";
 import path from "node:path";
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
 import {
@@ -25,11 +24,11 @@ interface RecordLocation {
 }
 
 /** Chunk in bytes so UTF-8 and multi-chunk records are decoded once, at a line boundary. */
-async function* locatedRecords(
+function* locatedRecords(
   file: string,
-  fd: FileHandle,
-): AsyncGenerator<{ entry: TranscriptEntry; location: RecordLocation }> {
-  const stat = await fd.stat();
+  fd: number,
+): Generator<{ entry: TranscriptEntry; location: RecordLocation }> {
+  const stat = fs.fstatSync(fd);
   // Opening a directory succeeds on some platforms; it must never look like empty history.
   if (stat.isDirectory()) {
     throw Object.assign(new Error(`EISDIR: illegal operation on a directory, read '${file}'`), {
@@ -44,7 +43,7 @@ async function* locatedRecords(
   let length = 0;
   while (remaining > 0) {
     const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, remaining));
-    const { bytesRead: count } = await fd.read(buffer, 0, buffer.length, null);
+    const count = fs.readSync(fd, buffer, 0, buffer.length, null);
     if (count === 0) break;
     remaining -= count;
     let start = 0;
@@ -65,8 +64,6 @@ async function* locatedRecords(
       if (entry) yield { entry, location };
       start = end + 1;
     }
-    // Bound parsing work as well as IO; microtasks alone do not service timers or sockets.
-    await setImmediate();
     if (start < count) {
       pieces.push(buffer.subarray(start, count));
       length += count - start;
@@ -88,25 +85,20 @@ async function* locatedRecords(
 /** Indexed sources parse only their own records using descriptors owned by this replay. */
 function indexedRecords(
   locations: readonly RecordLocation[],
-  descriptors: ReadonlyMap<string, FileHandle>,
-): AsyncIterable<TranscriptEntry> {
+  descriptors: ReadonlyMap<string, number>,
+): Iterable<TranscriptEntry> {
   return {
-    async *[Symbol.asyncIterator]() {
+    *[Symbol.iterator]() {
       yield* assignTaskNotificationReplayIds(readEntries());
     },
   };
-  async function* readEntries(): AsyncGenerator<TranscriptEntry> {
+  function* readEntries(): Generator<TranscriptEntry> {
     for (const location of locations) {
       const fd = descriptors.get(location.file)!;
       const buffer = Buffer.allocUnsafe(location.length);
       let read = 0;
       while (read < buffer.length) {
-        const { bytesRead: count } = await fd.read(
-          buffer,
-          read,
-          buffer.length - read,
-          location.offset + read,
-        );
+        const count = fs.readSync(fd, buffer, read, buffer.length - read, location.offset + read);
         if (count === 0)
           throw new Error(`Claude transcript was truncated during replay: ${location.file}`);
         read += count;
@@ -135,9 +127,9 @@ function parseRecord(line: string): TranscriptEntry | null {
   }
 }
 
-async function readOptionalFile(file: string): Promise<string | null> {
+function readOptionalFile(file: string): string | null {
   try {
-    return await fs.readFile(file, "utf8");
+    return fs.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -146,40 +138,31 @@ async function readOptionalFile(file: string): Promise<string | null> {
 /** Discover sources without retaining transcript contents. Unrelated sidechains stay excluded
  * by the replay ownership resolver; workflow children retain their separate run ownership. */
 export interface ClaudeReplayHistory {
-  parentEntries: AsyncIterable<TranscriptEntry>;
+  parentEntries: Iterable<TranscriptEntry>;
   subagents: {
     agentId: string;
     meta: ClaudeSubagentMeta | null;
-    entries: AsyncIterable<TranscriptEntry>;
+    entries: Iterable<TranscriptEntry>;
   }[];
   workflows: ClaudeWorkflowRun[];
-  workflowEntriesByRunId: Map<string, AsyncIterable<TranscriptEntry>>;
+  workflowEntriesByRunId: Map<string, Iterable<TranscriptEntry>>;
 }
 
 /** Own descriptors through every pass so unlink or rename cannot invalidate discovered history.
  * Sources must be consumed before the callback returns. No transcript copies are needed. */
-export async function withClaudeReplayHistory<T>(
+export function withClaudeReplayHistory<T>(
   historyPath: string,
-  consume: (history: ClaudeReplayHistory) => Promise<T>,
-): Promise<T> {
-  const descriptors = new Map<string, FileHandle>();
+  consume: (history: ClaudeReplayHistory) => T,
+): T {
+  const descriptors = new Map<string, number>();
   try {
-    return await consume(await indexHistory(historyPath, descriptors));
+    return consume(indexHistory(historyPath, descriptors));
   } finally {
-    await closeReplaySources(descriptors.values());
+    for (const fd of descriptors.values()) fs.closeSync(fd);
   }
 }
 
-async function closeReplaySources(descriptors: Iterable<FileHandle>): Promise<void> {
-  const results = await Promise.allSettled([...descriptors].map((fd) => fd.close()));
-  const failure = results.find((result) => result.status === "rejected");
-  if (failure) throw failure.reason;
-}
-
-async function indexHistory(
-  historyPath: string,
-  descriptors: Map<string, FileHandle>,
-): Promise<ClaudeReplayHistory> {
+function indexHistory(historyPath: string, descriptors: Map<string, number>): ClaudeReplayHistory {
   const sessionDirectory = path.join(
     path.dirname(historyPath),
     path.basename(historyPath, ".jsonl"),
@@ -191,7 +174,8 @@ async function indexHistory(
   const directories = [sidechainDirectory];
   while (directories.length) {
     const directory = directories.pop()!;
-    for (const entry of await optionalDirectory(directory)) {
+    if (!fs.existsSync(directory)) continue;
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
       const file = path.join(directory, entry.name);
       if (entry.isDirectory()) {
         directories.push(file);
@@ -210,23 +194,23 @@ async function indexHistory(
       }
       const agentId = /^agent-(.+)\.meta\.json$/.exec(entry.name)?.[1];
       if (!agentId) continue;
-      const contents = await readOptionalFile(file);
+      const contents = readOptionalFile(file);
       const meta = contents === null ? null : parseClaudeSubagentMeta(contents);
       if (meta) metaByAgentId.set(agentId, meta);
     }
   }
   const parentLocations: RecordLocation[] = [];
   const locationsByAgentId = new Map<string, RecordLocation[]>();
-  async function scan(
+  function scan(
     file: string,
     visit: (entry: TranscriptEntry, location: RecordLocation) => void,
-  ): Promise<void> {
-    const fd = await fs.open(file, "r");
+  ): void {
+    const fd = fs.openSync(file, "r");
     descriptors.set(file, fd);
-    for await (const { entry, location } of locatedRecords(file, fd)) visit(entry, location);
+    for (const { entry, location } of locatedRecords(file, fd)) visit(entry, location);
   }
   for (const file of sidechainFiles) {
-    await scan(file, (entry, location) => {
+    scan(file, (entry, location) => {
       if (file === historyPath && entry.isSidechain !== true) parentLocations.push(location);
       if (entry.isSidechain !== true || typeof entry.agentId !== "string") return;
       const locations = locationsByAgentId.get(entry.agentId) ?? [];
@@ -234,11 +218,11 @@ async function indexHistory(
       locationsByAgentId.set(entry.agentId, locations);
     });
   }
-  const workflowEntriesByRunId = new Map<string, AsyncIterable<TranscriptEntry>>();
+  const workflowEntriesByRunId = new Map<string, Iterable<TranscriptEntry>>();
   for (const [runId, files] of workflowFiles) {
     const locations: RecordLocation[] = [];
     for (const file of files)
-      await scan(file, (entry, location) => {
+      scan(file, (entry, location) => {
         if (entry.type !== "user" || isToolResult(entry)) locations.push(location);
       });
     locations.sort((a, b) => {
@@ -256,28 +240,21 @@ async function indexHistory(
       meta: metaByAgentId.get(agentId) ?? null,
       entries: indexedRecords(locations, descriptors),
     })),
-    workflows: await readWorkflows(sessionDirectory),
+    workflows: readWorkflows(sessionDirectory),
     workflowEntriesByRunId,
   };
 }
 
-async function readWorkflows(sessionDirectory: string): Promise<ClaudeWorkflowRun[]> {
+function readWorkflows(sessionDirectory: string): ClaudeWorkflowRun[] {
   const workflows: ClaudeWorkflowRun[] = [];
   const workflowDirectory = path.join(sessionDirectory, "workflows");
-  for (const entry of await optionalDirectory(workflowDirectory)) {
-    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const contents = await readOptionalFile(path.join(workflowDirectory, entry.name));
-    const workflow = contents === null ? null : parseClaudeWorkflowRun(contents);
-    if (workflow) workflows.push(workflow);
+  if (fs.existsSync(workflowDirectory)) {
+    for (const entry of fs.readdirSync(workflowDirectory, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const contents = readOptionalFile(path.join(workflowDirectory, entry.name));
+      const workflow = contents === null ? null : parseClaudeWorkflowRun(contents);
+      if (workflow) workflows.push(workflow);
+    }
   }
   return workflows;
 }
-
-async function optionalDirectory(directory: string) {
-  try {
-    return await fs.readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-    throw error;
-  }
-}

packages/server/src/server/agent/providers/codex/app-server-transport.test.ts

@@ -183,29 +183,3 @@ describe("Codex app-server transport", () => {
     codex.child.stdin.end();
   });
 });
-
-describe("Codex stdout byte admission", () => {
-  test("fails pending requests and the session before joining an oversized line", async () => {
-    const child = createCodexAppServerChildProcess();
-    const client = new CodexAppServerClient(child, createTestLogger());
-    const terminations: Error[] = [];
-    client.setUnexpectedTerminationHandler((error) => terminations.push(error));
-    const request = client.request("thread/resume", {}, 1000).catch((error: Error) => error);
-    const chunk = Buffer.alloc(64 * 1024, "x");
-    child.stdout.write('{"id":1,"result":"');
-    for (let index = 0; index < 2048; index++) child.stdout.write(chunk);
-    const error = await request;
-    expect(error).toMatchObject({
-      name: "ProviderStreamLimitError",
-      code: "PROVIDER_STREAM_LINE_TOO_LARGE",
-      limitBytes: 128 * 1024 * 1024,
-    });
-    expect(terminations).toEqual([error]);
-    expect(client.hasPendingRequests()).toBe(false);
-    child.stdout.write('"}\n{"id":1,"result":"late"}\n');
-    await expect(client.request("model/list")).rejects.toThrow("closed");
-    await client.dispose();
-    child.stdout.end();
-    child.stderr.end();
-  });
-});

packages/server/src/server/agent/providers/codex/app-server-transport.ts

@@ -1,15 +1,10 @@
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 import type { Logger } from "pino";
 import { z } from "zod";
 
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 
-import { ProviderLineReader, ProviderStreamLimitError } from "../jsonl-frame-decoder.js";
-
-// A measured long-thread resume was 19.75 MB; preserve the existing 32 MiB fixture
-// with 4x margin for longer threads. This is provider stdout, not the client protocol.
-export const CODEX_PROVIDER_LINE_BYTES = 128 * 1024 * 1024;
-
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2_000;
 const APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1_000;
@@ -172,6 +167,39 @@ function readProviderTurnId(params: unknown): string | undefined {
   return isRecord(turn) && typeof turn.id === "string" ? turn.id : undefined;
 }
 
+/**
+ * Splits stdout into lines on "\n" only. `node:readline` additionally treats U+2028 and U+2029
+ * as line terminators, but Codex emits those characters raw inside JSON strings, so readline
+ * would cut a single JSON-RPC message into pieces that fail to parse.
+ */
+function createNewlineLineReader(
+  input: NodeJS.ReadableStream,
+  onLine: (line: string) => void,
+): { close(): void } {
+  const decoder = new StringDecoder("utf8");
+  // Text after the last "\n", kept as parts and joined once its line ends, so a large line
+  // arriving in many chunks is scanned and copied once instead of once per chunk.
+  let unterminated: string[] = [];
+  const onData = (chunk: Buffer | string): void => {
+    const text = typeof chunk === "string" ? chunk : decoder.write(chunk);
+    let lineStart = 0;
+    let index = text.indexOf("\n");
+    while (index !== -1) {
+      unterminated.push(text.slice(lineStart, index));
+      const line = unterminated.join("");
+      unterminated = [];
+      onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+      lineStart = index + 1;
+      index = text.indexOf("\n", lineStart);
+    }
+    if (lineStart < text.length) {
+      unterminated.push(text.slice(lineStart));
+    }
+  };
+  input.on("data", onData);
+  return { close: () => void input.off("data", onData) };
+}
+
 export class CodexAppServerClient {
   private readonly stdoutLineReader: { close(): void };
   private activeProviderRequests = 0;
@@ -188,24 +216,11 @@ export class CodexAppServerClient {
     private readonly logger: Logger,
     private readonly getTraceContext: () => CodexAppServerTraceContext = () => ({}),
   ) {
-    // Split only on LF: U+2028/U+2029 are valid raw characters inside Codex JSON.
-    const reader = new ProviderLineReader(
-      CODEX_PROVIDER_LINE_BYTES,
-      (line) => {
-        void this.handleLine(line).catch((error) => {
-          this.logger.warn({ error, line }, "Failed to handle Codex app-server stdout line");
-        });
-      },
-      (error) => this.handleStreamLimit(error),
-    );
-    const onData = (chunk: Buffer | string) => reader.write(chunk);
-    child.stdout.on("data", onData);
-    this.stdoutLineReader = {
-      close: () => {
-        reader.close();
-        child.stdout.off("data", onData);
-      },
-    };
+    this.stdoutLineReader = createNewlineLineReader(child.stdout, (line) => {
+      void this.handleLine(line).catch((error) => {
+        this.logger.warn({ error, line }, "Failed to handle Codex app-server stdout line");
+      });
+    });
 
     child.stderr.on("data", (chunk) => {
       this.stderrBuffer += chunk.toString();
@@ -303,15 +318,6 @@ export class CodexAppServerClient {
     }
   }
 
-  private handleStreamLimit(failure: ProviderStreamLimitError): void {
-    // A rejected response/notification cannot be replayed safely. Fail the session,
-    // including live turns with no pending RPC, rather than dropping a stream unit.
-    this.handleUnexpectedTermination(failure);
-    void this.dispose().catch((err) => {
-      this.logger.warn({ err }, "Failed to terminate oversized Codex stdout producer");
-    });
-  }
-
   private handleUnexpectedTermination(error: Error): void {
     if (this.disposed) {
       return;

packages/server/src/server/agent/providers/jsonl-frame-decoder.test.ts

@@ -1,5 +1,3 @@
-import { performance } from "node:perf_hooks";
-import { setTimeout as delay } from "node:timers/promises";
 import { describe, expect, it } from "vitest";
 import { JsonlFrameDecoder, type JsonlFrameProblem } from "./jsonl-frame-decoder.js";
 
@@ -38,16 +36,6 @@ describe("JsonlFrameDecoder", () => {
     expect(problems).toEqual([]);
   });
 
-  it("preserves UTF-8 characters split across raw stdout buffers", () => {
-    const { decoder, frames, problems } = decoderHarness();
-    const bytes = Buffer.from('{"type":"notice","text":"é🙂"}\n');
-    const split = bytes.indexOf(Buffer.from("🙂")) + 1;
-    decoder.write(bytes.subarray(0, split));
-    decoder.write(bytes.subarray(split));
-    expect(frames).toEqual([{ type: "notice", text: "é🙂" }]);
-    expect(problems).toEqual([]);
-  });
-
   it("reassembles a large ordered v2 frame", () => {
     const { decoder, frames, problems } = decoderHarness();
     const frame = { type: "models", value: "x".repeat(1024 * 1024) };
@@ -67,57 +55,3 @@ describe("JsonlFrameDecoder", () => {
     expect(problems).toEqual(["out-of-order-chunk"]);
   });
 });
-
-describe("provider line admission", () => {
-  it("keeps the loop responsive while accumulating a fragmented provider response", async () => {
-    const { decoder, frames, problems } = decoderHarness();
-    const part = "x".repeat(512);
-    let last = performance.now();
-    let longestGap = 0;
-    const probe = setInterval(() => {
-      const now = performance.now();
-      longestGap = Math.max(longestGap, now - last);
-      last = now;
-    }, 1);
-    try {
-      await delay(5);
-      decoder.write('{"type":"notice","text":"');
-      // 1 MiB is enough to expose the former rescan of every accumulated prefix.
-      for (let index = 0; index < 2048; index++) decoder.write(part);
-      decoder.write('"}\n');
-      await delay(5);
-      expect(frames).toEqual([{ type: "notice", text: part.repeat(2048) }]);
-      expect(problems).toEqual([]);
-      expect(longestGap).toBeLessThan(50);
-    } finally {
-      clearInterval(probe);
-    }
-  });
-
-  it("rejects an unterminated over-cap UTF-8 line and stops accepting frames", () => {
-    const frames: Record<string, unknown>[] = [];
-    const failures: Array<{ problem: string; detail: unknown }> = [];
-    const decoder = new JsonlFrameDecoder({
-      frame: (frame) => frames.push(frame),
-      problem: (problem, detail) => failures.push({ problem, detail }),
-    });
-    // 64 MiB of UTF-8, only 32 Mi UTF-16 code units. No newline or JSON parse needed.
-    const chunk = "é".repeat(32 * 1024);
-    for (let index = 0; index < 1024; index++) decoder.write(chunk);
-    expect(failures).toEqual([]);
-    decoder.write("é");
-    expect(failures).toEqual([
-      {
-        problem: "line-too-large",
-        detail: expect.objectContaining({
-          name: "ProviderStreamLimitError",
-          code: "PROVIDER_STREAM_LINE_TOO_LARGE",
-          limitBytes: 64 * 1024 * 1024,
-        }),
-      },
-    ]);
-    decoder.write('\n{"type":"ready"}\n');
-    expect(frames).toEqual([]);
-    expect(failures).toHaveLength(1);
-  });
-});

packages/server/src/server/agent/providers/jsonl-frame-decoder.ts

@@ -1,60 +1,3 @@
-// Provider-process stdout only; these are not app/daemon wire limits.
-export const JSONL_PROVIDER_LINE_BYTES = 64 * 1024 * 1024;
-
-export class ProviderStreamLimitError extends Error {
-  readonly code = "PROVIDER_STREAM_LINE_TOO_LARGE";
-
-  constructor(readonly limitBytes: number) {
-    super(
-      `Provider stdout line exceeds ${limitBytes} bytes. Start a new thread or reduce the provider response size.`,
-    );
-    this.name = "ProviderStreamLimitError";
-  }
-}
-
-/** Admits raw UTF-8 bytes before retaining, decoding or joining a complete line. */
-export class ProviderLineReader {
-  private parts: Buffer[] = [];
-  private bytes = 0;
-  private stopped = false;
-
-  constructor(
-    private readonly limitBytes: number,
-    private readonly onLine: (line: string) => void,
-    private readonly onLimit: (error: ProviderStreamLimitError) => void,
-  ) {}
-
-  write(chunk: Buffer | string): void {
-    if (this.stopped) return;
-    const buffer = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
-    let start = 0;
-    while (start < buffer.byteLength && !this.stopped) {
-      const newline = buffer.indexOf(10, start);
-      const end = newline === -1 ? buffer.byteLength : newline;
-      const length = end - start;
-      if (length > this.limitBytes - this.bytes) {
-        this.close();
-        this.onLimit(new ProviderStreamLimitError(this.limitBytes));
-        return;
-      }
-      if (length) this.parts.push(buffer.subarray(start, end));
-      this.bytes += length;
-      if (newline === -1) return;
-      const line = Buffer.concat(this.parts, this.bytes).toString("utf8");
-      this.parts = [];
-      this.bytes = 0;
-      this.onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
-      start = newline + 1;
-    }
-  }
-
-  close(): void {
-    this.stopped = true;
-    this.parts = [];
-    this.bytes = 0;
-  }
-}
-
 const V2_FRAME_BYTES = 1024 * 1024;
 const V2_REASSEMBLED_BYTES = 64 * 1024 * 1024;
 const V2_CHUNK_BYTES = 256 * 1024;
@@ -62,7 +5,6 @@ const V2_BASE64_CHARS = Math.ceil(V2_CHUNK_BYTES / 3) * 4;
 const V2_MAX_CHUNKS = Math.ceil(V2_REASSEMBLED_BYTES / V2_CHUNK_BYTES);
 
 export type JsonlFrameProblem =
-  | "line-too-large"
   | "invalid-json"
   | "invalid-chunk"
   | "invalid-base64"
@@ -136,7 +78,7 @@ function chunkBytes(data: string): Buffer | null {
 }
 
 export class JsonlFrameDecoder {
-  private readonly lines: ProviderLineReader;
+  private lineBuffer = "";
   private assembly: ChunkAssembly | null = null;
 
   constructor(
@@ -144,18 +86,17 @@ export class JsonlFrameDecoder {
       frame(message: Record<string, unknown>): void;
       problem(problem: JsonlFrameProblem, detail?: unknown): void;
     },
-  ) {
-    this.lines = new ProviderLineReader(
-      JSONL_PROVIDER_LINE_BYTES,
-      (line) => {
-        if (line.trim()) this.consumeLine(line);
-      },
-      (error) => this.drop("line-too-large", error),
-    );
-  }
+  ) {}
 
-  write(chunk: Buffer | string): void {
-    this.lines.write(chunk);
+  write(text: string): void {
+    this.lineBuffer += text;
+    let newline = this.lineBuffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = this.lineBuffer.slice(0, newline).replace(/\r$/, "");
+      this.lineBuffer = this.lineBuffer.slice(newline + 1);
+      if (line.trim()) this.consumeLine(line);
+      newline = this.lineBuffer.indexOf("\n");
+    }
   }
 
   private consumeLine(line: string): void {

packages/server/src/server/agent/providers/jsonl-rpc-process.test.ts

@@ -471,25 +471,3 @@ describe("JsonlRpcProcess", () => {
     }
   });
 });
-
-describe("JSONL stdout byte admission", () => {
-  test("fails pending requests and publishes the typed failure to live-turn consumers", async () => {
-    const child = createInMemoryChildProcess();
-    const process = startProcess({ child });
-    const exit = new Promise<JsonlRpcExit>((resolve) => process.onExit(resolve));
-    const request = process.request({ type: "hang" }, 1000).catch((error: Error) => error);
-    const chunk = Buffer.alloc(64 * 1024, "x");
-    child.stdout.write('{"type":"notice","text":"');
-    for (let index = 0; index < 1024; index++) child.stdout.write(chunk);
-    const error = await request;
-    expect(error).toMatchObject({
-      name: "ProviderStreamLimitError",
-      code: "PROVIDER_STREAM_LINE_TOO_LARGE",
-      limitBytes: 64 * 1024 * 1024,
-    });
-    expect((await exit).error).toBe(error);
-    await process.close();
-    child.stdout.end();
-    child.stderr.end();
-  });
-});

packages/server/src/server/agent/providers/jsonl-rpc-process.ts

@@ -3,7 +3,7 @@ import type { Logger } from "pino";
 
 import { spawnProcess } from "../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
-import { JsonlFrameDecoder, ProviderStreamLimitError } from "./jsonl-frame-decoder.js";
+import { JsonlFrameDecoder } from "./jsonl-frame-decoder.js";
 export { supportsJsonlRpcProtocolV2 } from "./jsonl-frame-decoder.js";
 
 /** Default wall-clock timeout for control-plane / short RPC calls. */
@@ -81,7 +81,6 @@ export class JsonlRpcProcess {
   private stderrBuffer = "";
   private nextRequestId = 1;
   private disposed = false;
-  private streamFailure: ProviderStreamLimitError | null = null;
   private exited = false;
   private closing: Promise<void> | null = null;
   private readonly frameDecoder: JsonlFrameDecoder;
@@ -91,14 +90,6 @@ export class JsonlRpcProcess {
     this.frameDecoder = new JsonlFrameDecoder({
       frame: (message) => this.dispatchFrame(message),
       problem: (problem, detail) => {
-        if (problem === "line-too-large" && detail instanceof ProviderStreamLimitError) {
-          // Stop the producer: silently skipping a response or turn event loses state.
-          this.streamFailure = detail;
-          void this.close(detail).catch((err) => {
-            this.options.logger.warn({ err }, `Failed to close ${this.diagnosticName}`);
-          });
-          return;
-        }
         this.options.logger.warn(
           { problem, detail },
           `Ignoring invalid ${this.diagnosticName} frame`,
@@ -107,7 +98,7 @@ export class JsonlRpcProcess {
     });
     this.child = (options.spawn ?? spawnJsonlRpcProcess)(options.launch);
     this.child.stdout.on("data", (chunk) => {
-      this.handleStdoutChunk(chunk);
+      this.handleStdoutChunk(chunk.toString());
     });
     this.child.stderr.on("data", (chunk) => {
       this.stderrBuffer += chunk.toString();
@@ -123,11 +114,9 @@ export class JsonlRpcProcess {
     });
     this.child.on("exit", (code, signal) => {
       this.exited = true;
-      const error =
-        this.streamFailure ??
-        new Error(
-          `${this.diagnosticName} process exited with code ${code ?? "null"} and signal ${signal ?? "null"}\n${this.stderrBuffer}`.trim(),
-        );
+      const error = new Error(
+        `${this.diagnosticName} process exited with code ${code ?? "null"} and signal ${signal ?? "null"}\n${this.stderrBuffer}`.trim(),
+      );
       const exit = { code, signal, error };
       for (const subscriber of this.exitSubscribers) {
         subscriber(exit);
@@ -265,7 +254,7 @@ export class JsonlRpcProcess {
     }
   }
 
-  private handleStdoutChunk(chunk: Buffer | string): void {
+  private handleStdoutChunk(chunk: string): void {
     this.frameDecoder.write(chunk);
   }
 

packages/server/src/server/agent/providers/omp/agent.test.ts

@@ -1133,17 +1133,6 @@ describe("OMP agent client and session", () => {
         messageId: "assistant-history",
       },
     ]);
-    await expect(
-      omp.runPrompt("continue after resume", "resumed follow-up complete"),
-    ).resolves.toMatchObject({
-      finalText: "resumed follow-up complete",
-    });
-    expect(omp.timeline()).toContainEqual(
-      expect.objectContaining({
-        type: "assistant_message",
-        text: "resumed follow-up complete",
-      }),
-    );
     expect(omp.usageSession()).toMatchObject({ provider: "omp", sessionKey: expect.any(String) });
     await omp.close();
     expect(omp.usageSession()).toBeNull();

packages/server/src/server/agent/providers/omp/history-mapper.test.ts

@@ -1,5 +1,4 @@
 import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, test } from "vitest";
@@ -9,7 +8,7 @@ import { streamOmpCoreHistory, type OmpCapturedUserMessageEntry } from "./messag
 import type { OmpAgentMessage } from "./rpc-types.js";
 import { FakeOmp } from "./test-utils/fake-omp.js";
 import { OMP_HISTORY_MAPPER_HOOKS } from "./history-hooks.js";
-import { readActiveOmpEntryChain, readOmpHistoryTodoState, streamOmpHistory } from "./history.js";
+import { readOmpHistoryTodoState, streamOmpHistory } from "./history.js";
 
 async function collectHistory(
   messages: OmpAgentMessage[],
@@ -1246,53 +1245,3 @@ describe("OMP history mapper", () => {
     );
   });
 });
-
-test("indexes out-of-order branches, duplicate IDs and cycles before selecting history", async () => {
-  const directory = await mkdtemp(join(tmpdir(), "omp-history-branches-"));
-  const sessionFile = join(directory, "session.jsonl");
-  const root = { id: "root", parentId: null };
-  const earlyLeaf = {
-    id: "early",
-    parentId: "root",
-    message: { role: "user", content: "你好🌍".repeat(15000) },
-  };
-  const branch = { id: "branch", parentId: "root" };
-  const active = { id: "active", parentId: "branch" };
-  const duplicate = {
-    id: "branch",
-    parentId: "root",
-    message: { role: "user", content: "replacement" },
-  };
-  try {
-    await writeFile(
-      sessionFile,
-      [earlyLeaf, active, root, branch, duplicate]
-        .map((entry) => JSON.stringify(entry))
-        .join("\n") + '\n{"id":',
-    );
-    // The final record is a branch ancestor, not the active leaf. Latest duplicate wins
-    // when following parents; the invalid tail contributes neither a leaf nor a parent.
-    await expect(readActiveOmpEntryChain(sessionFile)).resolves.toEqual([root, duplicate, active]);
-    await expect(readActiveOmpEntryChain(sessionFile, "early")).resolves.toEqual([root, earlyLeaf]);
-    await expect(readActiveOmpEntryChain(sessionFile, "missing")).resolves.toEqual([
-      root,
-      duplicate,
-      active,
-    ]);
-    const cycle = [
-      { id: "a", parentId: "b" },
-      { id: "b", parentId: "a" },
-    ];
-    await writeFile(sessionFile, cycle.map((entry) => JSON.stringify(entry)).join("\n"));
-    await expect(readActiveOmpEntryChain(sessionFile)).resolves.toEqual(cycle);
-    await writeFile(sessionFile, "null\n{}\ninvalid\n");
-    await expect(readActiveOmpEntryChain(sessionFile)).resolves.toEqual([]);
-    await expect(readActiveOmpEntryChain(directory)).rejects.toMatchObject({ code: "EISDIR" });
-    await expect(readActiveOmpEntryChain(join(directory, "missing"))).rejects.toMatchObject({
-      code: "ENOENT",
-    });
-    await expect(readOmpHistoryTodoState(join(directory, "missing"))).resolves.toBeNull();
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-});

packages/server/src/server/agent/providers/omp/history.e2e.test.ts

@@ -1,104 +0,0 @@
-import { BUILTIN_PROVIDER_IDS } from "@getpaseo/protocol/provider-manifest";
-import { mkdtemp, open, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { performance } from "node:perf_hooks";
-import { setTimeout as delay } from "node:timers/promises";
-import { expect, test } from "vitest";
-import { createTestPaseoDaemon } from "../../../test-utils/paseo-daemon.js";
-import { DaemonClient } from "../../../test-utils/daemon-client.js";
-import { readActiveOmpEntryChain } from "./history.js";
-
-test("replays selected OMP history without blocking the event loop", async () => {
-  const directory = await mkdtemp(join(tmpdir(), "omp-history-budget-"));
-  const sessionFile = join(directory, "session.jsonl");
-  const started = performance.now();
-  try {
-    const daemon = await createTestPaseoDaemon({
-      // This regression exercises file replay and daemon requests, not executable discovery.
-      providerOverrides: Object.fromEntries(
-        BUILTIN_PROVIDER_IDS.map((id) => [id, { enabled: false }]),
-      ),
-    });
-    const client = new DaemonClient({
-      url: `ws://127.0.0.1:${daemon.port}/ws`,
-      appVersion: "0.13.2",
-    });
-    try {
-      await client.connect();
-      await client.fetchAgents({ subscribe: {} });
-      await client.getDaemonStatus();
-      const file = await open(sessionFile, "w");
-      // Structured message blocks expose document-sized parsing at a modest byte size.
-      // Replay an earlier active entry so inactive payload retention cannot drive the probe.
-      const text = Array.from({ length: 64 }, () => ({ type: "text", text: "x" }));
-      let bytes = 0;
-      let count = 0;
-      try {
-        while (bytes < 28 * 1024 * 1024) {
-          const line =
-            JSON.stringify({
-              type: "message",
-              id: `row-${count}`,
-              parentId: count ? `row-${count - 1}` : null,
-              message: { role: "user", content: text },
-            }) + "\n";
-          bytes += Buffer.byteLength(line);
-          await file.write(line);
-          count++;
-        }
-      } finally {
-        await file.close();
-      }
-      let last = performance.now();
-      let longestGap = 0;
-      const probe = setInterval(() => {
-        const now = performance.now();
-        longestGap = Math.max(longestGap, now - last);
-        last = now;
-      }, 5);
-      try {
-        const replayState = { finished: false };
-        let repliesDuringReplay = 0;
-        const replay = readActiveOmpEntryChain(sessionFile, "row-0").finally(() => {
-          replayState.finished = true;
-        });
-        // A real WebSocket RPC served by the isolated daemon on the same event loop.
-        const requests = (async () => {
-          while (!replayState.finished) {
-            await client.getDaemonStatus();
-            if (!replayState.finished) repliesDuringReplay++;
-            await delay(10);
-          }
-        })();
-        const [entries] = await Promise.all([replay, requests]);
-        await delay(10);
-        console.log(
-          JSON.stringify({
-            bytes,
-            count,
-            longestGap,
-            repliesDuringReplay,
-            generationAndLoadMs: performance.now() - started,
-          }),
-        );
-        expect(entries).toEqual([
-          {
-            type: "message",
-            id: "row-0",
-            parentId: null,
-            message: { role: "user", content: text },
-          },
-        ]);
-        expect(longestGap).toBeLessThan(50);
-        expect(repliesDuringReplay).toBeGreaterThan(0);
-      } finally {
-        clearInterval(probe);
-      }
-    } finally {
-      await client.close().finally(() => daemon.close());
-    }
-  } finally {
-    await rm(directory, { recursive: true, force: true });
-  }
-}, 30000);

packages/server/src/server/agent/providers/omp/history.ts

@@ -1,5 +1,4 @@
-import { open, type FileHandle } from "node:fs/promises";
-import { setImmediate } from "node:timers/promises";
+import { readFile } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import type { AgentProvider, AgentStreamEvent, AgentTimelineItem } from "../../agent-sdk-types.js";
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
@@ -97,9 +96,7 @@ export async function* streamOmpHistory(input: {
   const messages: OmpAgentMessage[] = [];
   const replayEntries: OmpReplayEntry[] = [];
   const userEntries: OmpCapturedUserMessageEntry[] = [];
-  let prepared = 0;
   for (const entry of entries) {
-    if (++prepared % 32 === 0) await setImmediate();
     if (entry.type === "compaction") {
       replayEntries.push({ entry, item: mapCompactionEntry(entry) });
       continue;
@@ -118,9 +115,7 @@ export async function* streamOmpHistory(input: {
     OMP_HISTORY_MAPPER_HOOKS,
     input.bridgedTools,
   );
-  let replayed = 0;
   for (const replayEntry of replayEntries) {
-    if (++replayed % 32 === 0) await setImmediate();
     const timestamp = normalizeProviderReplayTimestamp(replayEntry.entry.timestamp);
     const events: AgentStreamEvent[] =
       "item" in replayEntry
@@ -334,139 +329,34 @@ function stripExtension(filePath: string): string {
   return extension ? filePath.slice(0, -extension.length) : filePath;
 }
 
-interface OmpEntryLocation {
-  id: string;
-  parentId?: string | null;
-  offset: number;
-}
-
-// Yield after each bounded IO chunk, including chunks containing only tiny or invalid records.
-// Keep bytes until a complete line so multi-byte UTF-8 characters survive chunk boundaries.
-async function* readOmpLines(
-  file: FileHandle,
-  size: number,
-): AsyncGenerator<{
-  line: Buffer;
-  offset: number;
-}> {
-  const chunkSize = 64 * 1024;
-  let fragments: Buffer[] = [];
-  let lineOffset = 0;
-  for (let position = 0; position < size; ) {
-    const chunk = Buffer.allocUnsafe(Math.min(chunkSize, size - position));
-    const { bytesRead } = await file.read(chunk, 0, chunk.length, position);
-    if (!bytesRead) break;
-    let start = 0;
-    for (let index = 0; index < bytesRead; index++) {
-      if (chunk[index] !== 10) continue;
-      const tail = chunk.subarray(start, index);
-      const line = fragments.length ? Buffer.concat([...fragments, tail]) : tail;
-      yield { line, offset: lineOffset };
-      fragments = [];
-      start = index + 1;
-      lineOffset = position + start;
-    }
-    if (start < bytesRead) fragments.push(chunk.subarray(start, bytesRead));
-    position += bytesRead;
-    await setImmediate();
-  }
-  if (fragments.length) yield { line: Buffer.concat(fragments), offset: lineOffset };
-}
-
-function parseOmpEntry(line: Buffer): OmpSessionEntry | null {
-  try {
-    const value: unknown = JSON.parse(line.toString("utf8"));
-    return value && typeof value === "object" && typeof Reflect.get(value, "id") === "string"
-      ? (value as OmpSessionEntry)
-      : null;
-  } catch {
-    // OMP can leave a partial last record; malformed records have always been ignored.
-    return null;
-  }
-}
-
-async function selectOmpChain(
-  locations: readonly OmpEntryLocation[],
-  byId: ReadonlyMap<string, OmpEntryLocation>,
-  parentIds: ReadonlySet<string>,
+export async function readActiveOmpEntryChain(
+  sessionFile: string,
   activeEntryId?: string,
-): Promise<OmpEntryLocation[]> {
-  let current = activeEntryId ? byId.get(activeEntryId) : undefined;
-  if (!current) {
-    for (let index = locations.length - 1; index >= 0; index--) {
-      const location = locations[index]!;
-      if (!parentIds.has(location.id)) {
-        current = location;
-        break;
-      }
-      if (index % 256 === 0) await setImmediate();
+): Promise<OmpSessionEntry[]> {
+  const content = await readFile(sessionFile, "utf8");
+  const entries = content.split("\n").flatMap((line) => {
+    if (!line.trim()) return [];
+    try {
+      const value = JSON.parse(line) as OmpSessionEntry;
+      return value && typeof value === "object" && typeof value.id === "string" ? [value] : [];
+    } catch {
+      return [];
     }
-    current ??= locations.at(-1);
-  }
-  const chain: OmpEntryLocation[] = [];
+  });
+  if (entries.length === 0) return [];
+  const byId = new Map(entries.map((entry) => [entry.id!, entry]));
+  const parentIds = new Set(entries.flatMap((entry) => (entry.parentId ? [entry.parentId] : [])));
+  const leaves = entries.filter((entry) => !parentIds.has(entry.id!));
+  let current: OmpSessionEntry | undefined =
+    (activeEntryId ? byId.get(activeEntryId) : undefined) ?? leaves.at(-1) ?? entries.at(-1);
+  const chain: OmpSessionEntry[] = [];
   const seen = new Set<string>();
   while (current?.id && !seen.has(current.id)) {
     chain.push(current);
     seen.add(current.id);
     current = current.parentId ? byId.get(current.parentId) : undefined;
-    if (chain.length % 256 === 0) await setImmediate();
-  }
-  return chain;
-}
-
-export async function readActiveOmpEntryChain(
-  sessionFile: string,
-  activeEntryId?: string,
-): Promise<OmpSessionEntry[]> {
-  const file = await open(sessionFile, "r");
-  try {
-    const stat = await file.stat();
-    if (stat.isDirectory()) {
-      throw Object.assign(
-        new Error(`EISDIR: illegal operation on a directory, read '${sessionFile}'`),
-        {
-          code: "EISDIR",
-        },
-      );
-    }
-    // One descriptor and a fixed byte boundary exclude appends made while replay is yielding.
-    // Retain graph metadata only: abandoned branches must not retain their message payloads.
-    const locations: OmpEntryLocation[] = [];
-    const byId = new Map<string, OmpEntryLocation>();
-    const parentIds = new Set<string>();
-    for await (const { line, offset } of readOmpLines(file, stat.size)) {
-      const entry = parseOmpEntry(line);
-      if (!entry) continue;
-      const location = { id: entry.id!, parentId: entry.parentId, offset };
-      locations.push(location);
-      byId.set(location.id, location);
-      if (location.parentId) parentIds.add(location.parentId);
-    }
-    const chain = await selectOmpChain(locations, byId, parentIds, activeEntryId);
-    if (chain.length === 0) return [];
-    const selected = new Map<number, number>();
-    for (let index = 0; index < chain.length; index++) {
-      selected.set(chain[index]!.offset, chain.length - index - 1);
-      if (index % 256 === 0) await setImmediate();
-    }
-    const entries: OmpSessionEntry[] = [];
-    for await (const { line, offset } of readOmpLines(file, stat.size)) {
-      const index = selected.get(offset);
-      if (index === undefined) continue;
-      const entry = parseOmpEntry(line);
-      // Truncation in place invalidates the indexed snapshot; never publish a partial chain.
-      if (!entry || entry.id !== chain[chain.length - index - 1]!.id) {
-        throw new Error(`OMP transcript changed during replay: ${sessionFile}`);
-      }
-      entries[index] = entry;
-      selected.delete(offset);
-      if (selected.size === 0) break;
-    }
-    if (selected.size) throw new Error(`OMP transcript changed during replay: ${sessionFile}`);
-    return entries;
-  } finally {
-    await file.close();
   }
+  return chain.toReversed();
 }
 
 function mapEntryMessage(entry: OmpSessionEntry): OmpAgentMessage | null {

packages/server/src/server/agent/providers/opencode/bridge-input-errors.test.ts

@@ -56,7 +56,6 @@ test("bridge preserves tool failure messages and classifies invalid requests as
     getDaemonTcpHost: null,
     serviceProxyPublicBaseUrl: null,
     resolveScriptHealth: null,
-    getGlobalServicePorts: async () => undefined,
     logger,
     emit: () => {},
     publishStatusUpdate: () => {},

packages/server/src/server/agent/test-utils/timeline-page-reference.ts

@@ -1,249 +0,0 @@
-// Frozen pre-index page selection: differential oracle for retained projection tests.
-import type { AgentTimelineRow } from "../agent-timeline-store-types.js";
-import {
-  TimelineProjection,
-  projectTimelineRows,
-  type TimelineProjectionEntry,
-  type ProjectedTimelineRow,
-  type TimelineLimitDirection,
-  type ProjectedTimelinePageSelection,
-} from "../timeline-projection.js";
-
-function makeCanonicalEntries(rows: readonly AgentTimelineRow[]): TimelineProjectionEntry[] {
-  return rows.map((row) => {
-    if ("seqStart" in row) return { ...(row as ProjectedTimelineRow) };
-    return {
-      item: row.item,
-      timestamp: row.timestamp,
-      ...(row.turnId ? { turnId: row.turnId } : {}),
-      ...(row.providerMessageId ? { providerMessageId: row.providerMessageId } : {}),
-      seqStart: row.seq,
-      seqEnd: row.seq,
-      sourceSeqRanges: [{ startSeq: row.seq, endSeq: row.seq }],
-      collapsed: [],
-    };
-  });
-}
-
-function getTimelineBounds(
-  rows: readonly AgentTimelineRow[],
-): { minSeq: number; maxSeq: number } | null {
-  const first = rows[0];
-  const last = rows[rows.length - 1];
-  if (!first || !last) {
-    return null;
-  }
-  const entries = makeCanonicalEntries(rows);
-  return {
-    minSeq: entries.reduce((min, e) => Math.min(min, e.seqStart), Infinity),
-    maxSeq: entries.reduce((max, e) => Math.max(max, e.seqEnd), 0),
-  };
-}
-
-function firstSourceSeqInRange(
-  entry: TimelineProjectionEntry,
-  startSeq: number,
-  endSeq: number,
-): number | null {
-  for (const range of entry.sourceSeqRanges) {
-    const firstSeq = Math.max(range.startSeq, startSeq);
-    if (firstSeq <= Math.min(range.endSeq, endSeq)) return firstSeq;
-  }
-  return null;
-}
-
-interface ProjectedEntryCandidate {
-  entry: TimelineProjectionEntry;
-  index: number;
-  firstSourceSeq: number;
-}
-
-function selectProjectedEntriesAfter(input: {
-  entries: readonly TimelineProjectionEntry[];
-  startSeq: number;
-  maxSeq: number;
-  limit: number;
-}): { entries: TimelineProjectionEntry[]; endSeq: number | null } {
-  const eligible = input.entries
-    .map((entry, index) => ({
-      entry,
-      index,
-      firstSourceSeq: firstSourceSeqInRange(entry, input.startSeq, input.maxSeq),
-    }))
-    .filter((candidate): candidate is ProjectedEntryCandidate => candidate.firstSourceSeq !== null)
-    .sort((left, right) => left.firstSourceSeq - right.firstSourceSeq || left.index - right.index);
-  const selected = input.limit === 0 ? eligible : eligible.slice(0, input.limit);
-  const selectedEntries = selected
-    .sort((left, right) => left.index - right.index)
-    .map((candidate) => candidate.entry);
-  if (selectedEntries.length === 0) return { entries: [], endSeq: null };
-
-  const selectedRanges = selectedEntries
-    .flatMap((entry) => entry.sourceSeqRanges)
-    .sort((left, right) => left.startSeq - right.startSeq || left.endSeq - right.endSeq);
-  // Wide projected entries can include future, discontiguous source ranges. The
-  // page cursor advances only through source rows covered without a gap.
-  let endSeq = input.startSeq - 1;
-  for (const range of selectedRanges) {
-    if (range.endSeq <= endSeq) continue;
-    if (range.startSeq > endSeq + 1) break;
-    endSeq = Math.min(range.endSeq, input.maxSeq);
-  }
-
-  return {
-    entries: selectedEntries,
-    endSeq: endSeq >= input.startSeq ? endSeq : null,
-  };
-}
-
-function selectProjectedEntriesBefore(input: {
-  entries: readonly TimelineProjectionEntry[];
-  endSeq: number;
-  limit: number;
-}): { entries: TimelineProjectionEntry[]; startSeq: number | null; hasOlder: boolean } {
-  // Older history follows projected display order. Lifecycle updates can move an
-  // entry's seqEnd without moving its display anchor, so seqStart keeps the full
-  // projected item on exactly one backward page.
-  const eligible = input.entries.filter((entry) => entry.seqStart <= input.endSeq);
-  const selected =
-    input.limit === 0 || input.limit >= eligible.length
-      ? eligible
-      : eligible.slice(eligible.length - input.limit);
-
-  return {
-    entries: selected,
-    startSeq: selected[0]?.seqStart ?? null,
-    hasOlder: selected.length < eligible.length,
-  };
-}
-
-function selectProjectedEntriesTail(
-  projectedAll: TimelineProjectionEntry[],
-  limit: number,
-  bounds: { minSeq: number; maxSeq: number },
-): ProjectedTimelinePageSelection {
-  let start = limit === 0 ? 0 : Math.max(0, projectedAll.length - limit);
-  // Include earlier display anchors with updates in the selected source window,
-  // so a tail certifies contiguous coverage even with interleaved tool updates.
-  for (let i = start - 1; i >= 0; i--) {
-    if (projectedAll[i].seqEnd >= projectedAll[start].seqStart) start = i;
-  }
-  const selected = projectedAll.slice(start);
-  return {
-    entries: selected,
-    startSeq: selected[0]?.seqStart ?? null,
-    endSeq: bounds.maxSeq,
-    hasOlder: start > 0,
-    hasNewer: false,
-  };
-}
-
-export function selectReferenceProjectedTimelinePage(input: {
-  rows: readonly AgentTimelineRow[];
-  bounds?: { minSeq: number; maxSeq: number };
-  direction: TimelineLimitDirection;
-  cursorSeq?: number;
-  limit?: number;
-}): ProjectedTimelinePageSelection {
-  const limit = input.limit === undefined ? 0 : Math.max(0, Math.floor(input.limit));
-  const bounds = input.bounds ?? getTimelineBounds(input.rows);
-  const projectedAll = projectTimelineRows({ rows: input.rows, mode: "projected" });
-  if (!bounds) {
-    return {
-      entries: [],
-      startSeq: null,
-      endSeq: null,
-      hasOlder: false,
-      hasNewer: false,
-    };
-  }
-
-  if (projectedAll.length === 0) {
-    if (input.direction === "after") {
-      const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
-      return {
-        entries: [],
-        startSeq: null,
-        endSeq: null,
-        hasOlder: cursorSeq >= bounds.minSeq,
-        hasNewer: cursorSeq < bounds.maxSeq,
-      };
-    }
-    if (input.direction === "before") {
-      const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
-      return {
-        entries: [],
-        startSeq: null,
-        endSeq: null,
-        hasOlder: cursorSeq > bounds.minSeq,
-        hasNewer: cursorSeq <= bounds.maxSeq,
-      };
-    }
-    return {
-      entries: [],
-      startSeq: null,
-      endSeq: null,
-      hasOlder: false,
-      hasNewer: false,
-    };
-  }
-
-  if (input.direction === "tail") {
-    return selectProjectedEntriesTail(projectedAll, limit, bounds);
-  }
-
-  if (input.direction === "after") {
-    const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
-    const startSeq = Math.max(bounds.minSeq, cursorSeq + 1);
-    const selected = selectProjectedEntriesAfter({
-      entries: projectedAll,
-      startSeq,
-      maxSeq: bounds.maxSeq,
-      limit,
-    });
-    return {
-      entries: selected.entries,
-      startSeq: selected.endSeq === null ? null : startSeq,
-      endSeq: selected.endSeq,
-      hasOlder: startSeq > bounds.minSeq,
-      hasNewer: selected.endSeq !== null && selected.endSeq < bounds.maxSeq,
-    };
-  }
-
-  const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
-  const endSeq = Math.min(bounds.maxSeq, cursorSeq - 1);
-  if (endSeq < bounds.minSeq) {
-    return {
-      entries: [],
-      startSeq: null,
-      endSeq: null,
-      hasOlder: false,
-      hasNewer: endSeq < bounds.maxSeq,
-    };
-  }
-
-  const selected = selectProjectedEntriesBefore({ entries: projectedAll, endSeq, limit });
-  return {
-    entries: selected.entries,
-    startSeq: selected.startSeq,
-    endSeq,
-    hasOlder: selected.hasOlder,
-    hasNewer: endSeq < bounds.maxSeq,
-  };
-}
-
-// Existing selection fixtures exercise the retained owner through its public API.
-export function selectProjectedTimelinePage(
-  input: Parameters<typeof selectReferenceProjectedTimelinePage>[0],
-) {
-  const projection = new TimelineProjection(input.rows);
-  const bounds = input.bounds ?? getTimelineBounds(input.rows) ?? { minSeq: 0, maxSeq: 0 };
-  const page = projection.selectPage({ ...input, bounds });
-  return {
-    ...page,
-    entries: page.entries.map((row) => {
-      const { seq: _seq, ...entry } = row as ProjectedTimelineRow;
-      return entry;
-    }),
-  };
-}

packages/server/src/server/agent/timeline-projection.test.ts

@@ -1,9 +1,9 @@
-import { selectProjectedTimelinePage } from "./test-utils/timeline-page-reference.js";
 import { describe, expect, test } from "vitest";
 
 import type { AgentTimelineRow } from "./agent-manager.js";
 import {
   projectTimelineRows,
+  selectProjectedTimelinePage,
   selectTimelineWindowByProjectedLimit,
 } from "./timeline-projection.js";
 

packages/server/src/server/agent/timeline-projection.ts

@@ -295,43 +295,12 @@ function mergeAssistantChunks(entries: readonly WorkingEntry[]): WorkingEntry[]
 /** A retained item. `seq` is its latest source event, not its display anchor. */
 export type ProjectedTimelineRow = AgentTimelineRow & TimelineProjectionEntry;
 
-interface ProjectedTimelinePageOptions {
-  bounds: { minSeq: number; maxSeq: number };
-  direction: TimelineLimitDirection;
-  cursorSeq?: number;
-  limit?: number;
-}
-
 /** Owns projected state; source events are consumed, never retained. */
 export class TimelineProjection {
   private readonly rows: ProjectedTimelineRow[] = [];
   private readonly identities = new Map<string, number>();
-  private lastAssistantRowIndex: number | null = null;
-  // Disjoint source-coverage spans in display order. A tail starting inside a
-  // span must include its first anchor to cover interleaved lifecycle updates.
-  private readonly spans: { start: number; endSeq: number }[] = [];
-
-  private readonly sourceRanges: { startSeq: number; endSeq: number; rowIndex: number }[] = [];
-
-  constructor(rows: readonly AgentTimelineRow[] = []) {
-    for (const row of rows) this.appendProjected(row);
-    for (const [rowIndex, row] of this.rows.entries()) {
-      for (const range of row.sourceSeqRanges) this.sourceRanges.push({ ...range, rowIndex });
-    }
-    this.sourceRanges.sort((a, b) => a.startSeq - b.startSeq);
-  }
 
   append(row: AgentTimelineRow): void {
-    const rowIndex = this.appendProjected(row);
-    const last = this.sourceRanges.at(-1);
-    if (last && last.rowIndex === rowIndex && last.endSeq + 1 === row.seq) {
-      last.endSeq = row.seq;
-    } else {
-      this.sourceRanges.push({ startSeq: row.seq, endSeq: row.seq, rowIndex });
-    }
-  }
-
-  private appendProjected(row: AgentTimelineRow): number {
     const entry = makeCanonicalEntries([row])[0];
     const identity = timelineItemIdentity(row.item);
     const index = identity === null ? undefined : this.identities.get(identity);
@@ -339,8 +308,7 @@ export class TimelineProjection {
     const merged = existing ? mergeIdentityEntries(existing, entry) : null;
     if (merged && index !== undefined) {
       this.rows[index] = { ...merged, seq: merged.seqEnd };
-      this.extendSpan(index);
-      return index;
+      return;
     }
     const previous = this.rows.at(-1);
     const adjacent = previous
@@ -349,159 +317,16 @@ export class TimelineProjection {
     if (previous && adjacent.length === 1) {
       const mergedText = adjacent[0];
       this.rows[this.rows.length - 1] = { ...mergedText, seq: mergedText.seqEnd };
-      this.extendSpan(this.rows.length - 1);
-      return this.rows.length - 1;
+      return;
     }
     if (identity !== null) this.identities.set(identity, this.rows.length);
-    if (entry.item.type === "assistant_message") this.lastAssistantRowIndex = this.rows.length;
     this.rows.push({ ...entry, seq: entry.seqEnd });
-    const last = this.spans.at(-1);
-    if (last && last.endSeq >= entry.seqStart) {
-      last.endSeq = Math.max(last.endSeq, entry.seqEnd);
-    } else {
-      this.spans.push({ start: this.rows.length - 1, endSeq: entry.seqEnd });
-    }
-    return this.rows.length - 1;
-  }
-
-  private spanIndex(rowIndex: number): number {
-    let low = 0;
-    let high = this.spans.length;
-    while (low + 1 < high) {
-      const middle = (low + high) >>> 1;
-      if (this.spans[middle].start <= rowIndex) low = middle;
-      else high = middle;
-    }
-    return low;
-  }
-
-  private extendSpan(rowIndex: number): void {
-    const index = this.spanIndex(rowIndex);
-    const span = this.spans[index];
-    span.endSeq = Math.max(span.endSeq, this.rows[rowIndex].seqEnd);
-    let end = index + 1;
-    while (end < this.spans.length && this.rows[this.spans[end].start].seqStart <= span.endSeq) {
-      span.endSeq = Math.max(span.endSeq, this.spans[end].endSeq);
-      end++;
-    }
-    this.spans.splice(index + 1, end - index - 1);
   }
 
   getRows(): ProjectedTimelineRow[] {
     return this.rows.map((row) => ({ ...row }));
   }
 
-  selectPage(input: ProjectedTimelinePageOptions): ProjectedTimelinePageSelection {
-    if (this.rows.length === 0) {
-      const cursor =
-        input.cursorSeq ??
-        (input.direction === "before" ? input.bounds.maxSeq + 1 : input.bounds.minSeq - 1);
-      return {
-        entries: [],
-        startSeq: null,
-        endSeq: null,
-        hasOlder:
-          input.direction === "after"
-            ? cursor >= input.bounds.minSeq
-            : input.direction === "before" && cursor > input.bounds.minSeq,
-        hasNewer:
-          input.direction === "after"
-            ? cursor < input.bounds.maxSeq
-            : input.direction === "before" && cursor <= input.bounds.maxSeq,
-      };
-    }
-    switch (input.direction) {
-      case "tail":
-        return this.selectTail(input);
-      case "after":
-        return this.selectAfter(input);
-      case "before":
-        return this.selectBefore(input);
-    }
-  }
-
-  private selectTail(input: ProjectedTimelinePageOptions): ProjectedTimelinePageSelection {
-    const limit = Math.max(0, Math.floor(input.limit ?? 0));
-    const requestedStart = limit === 0 ? 0 : Math.max(0, this.rows.length - limit);
-    const start = this.spans[this.spanIndex(requestedStart)].start;
-    return {
-      entries: this.rows.slice(start),
-      startSeq: this.rows[start].seqStart,
-      endSeq: input.bounds.maxSeq,
-      hasOlder: start > 0,
-      hasNewer: false,
-    };
-  }
-
-  private selectAfter(input: ProjectedTimelinePageOptions): ProjectedTimelinePageSelection {
-    const startSeq = Math.max(
-      input.bounds.minSeq,
-      (input.cursorSeq ?? input.bounds.minSeq - 1) + 1,
-    );
-    let low = 0;
-    let high = this.sourceRanges.length;
-    while (low < high) {
-      const middle = (low + high) >>> 1;
-      if (this.sourceRanges[middle].endSeq < startSeq) low = middle + 1;
-      else high = middle;
-    }
-    const indexes = new Set<number>();
-    const limit = Math.max(0, Math.floor(input.limit ?? 0));
-    for (let i = low; i < this.sourceRanges.length; i++) {
-      const range = this.sourceRanges[i];
-      if (range.startSeq > input.bounds.maxSeq) break;
-      indexes.add(range.rowIndex);
-      if (limit > 0 && indexes.size === limit) break;
-    }
-    const entries = [...indexes].sort((a, b) => a - b).map((index) => this.rows[index]);
-    const selected = selectProjectedEntriesAfter({
-      entries,
-      startSeq,
-      maxSeq: input.bounds.maxSeq,
-      limit,
-    });
-    return {
-      entries: selected.entries,
-      startSeq: selected.endSeq === null ? null : startSeq,
-      endSeq: selected.endSeq,
-      hasOlder: startSeq > input.bounds.minSeq,
-      hasNewer: selected.endSeq !== null && selected.endSeq < input.bounds.maxSeq,
-    };
-  }
-
-  private selectBefore(input: ProjectedTimelinePageOptions): ProjectedTimelinePageSelection {
-    const endSeq = Math.min(input.bounds.maxSeq, (input.cursorSeq ?? input.bounds.maxSeq + 1) - 1);
-    if (endSeq >= input.bounds.minSeq) {
-      let low = 0;
-      let high = this.rows.length;
-      while (low < high) {
-        const middle = (low + high) >>> 1;
-        if (this.rows[middle].seqStart <= endSeq) low = middle + 1;
-        else high = middle;
-      }
-      const limit = Math.max(0, Math.floor(input.limit ?? 0));
-      const start = limit === 0 ? 0 : Math.max(0, low - limit);
-      return {
-        entries: this.rows.slice(start, low),
-        startSeq: this.rows[start]?.seqStart ?? null,
-        endSeq,
-        hasOlder: start > 0,
-        hasNewer: endSeq < input.bounds.maxSeq,
-      };
-    }
-    return { entries: [], startSeq: null, endSeq: null, hasOlder: false, hasNewer: true };
-  }
-
-  getLastItem(seq: number): AgentTimelineItem | null {
-    const last = this.sourceRanges.at(-1);
-    return last?.endSeq === seq ? this.rows[last.rowIndex].item : null;
-  }
-
-  getLastAssistantMessage(): string | null {
-    const row = this.lastAssistantRowIndex === null ? null : this.rows[this.lastAssistantRowIndex];
-    return row?.item.type === "assistant_message" ? row.item.text : null;
-  }
-
   enrichSubmittedUserMessage(
     clientMessageId: string,
     providerMessageId: string,
@@ -619,6 +444,21 @@ export function selectTimelineWindowByProjectedLimit(input: {
   };
 }
 
+function getTimelineBounds(
+  rows: readonly AgentTimelineRow[],
+): { minSeq: number; maxSeq: number } | null {
+  const first = rows[0];
+  const last = rows[rows.length - 1];
+  if (!first || !last) {
+    return null;
+  }
+  const entries = makeCanonicalEntries(rows);
+  return {
+    minSeq: entries.reduce((min, e) => Math.min(min, e.seqStart), Infinity),
+    maxSeq: entries.reduce((max, e) => Math.max(max, e.seqEnd), 0),
+  };
+}
+
 function firstSourceSeqInRange(
   entry: TimelineProjectionEntry,
   startSeq: number,
@@ -675,6 +515,142 @@ function selectProjectedEntriesAfter(input: {
   };
 }
 
+function selectProjectedEntriesBefore(input: {
+  entries: readonly TimelineProjectionEntry[];
+  endSeq: number;
+  limit: number;
+}): { entries: TimelineProjectionEntry[]; startSeq: number | null; hasOlder: boolean } {
+  // Older history follows projected display order. Lifecycle updates can move an
+  // entry's seqEnd without moving its display anchor, so seqStart keeps the full
+  // projected item on exactly one backward page.
+  const eligible = input.entries.filter((entry) => entry.seqStart <= input.endSeq);
+  const selected =
+    input.limit === 0 || input.limit >= eligible.length
+      ? eligible
+      : eligible.slice(eligible.length - input.limit);
+
+  return {
+    entries: selected,
+    startSeq: selected[0]?.seqStart ?? null,
+    hasOlder: selected.length < eligible.length,
+  };
+}
+
+function selectProjectedEntriesTail(
+  projectedAll: TimelineProjectionEntry[],
+  limit: number,
+  bounds: { minSeq: number; maxSeq: number },
+): ProjectedTimelinePageSelection {
+  let start = limit === 0 ? 0 : Math.max(0, projectedAll.length - limit);
+  // Include earlier display anchors with updates in the selected source window,
+  // so a tail certifies contiguous coverage even with interleaved tool updates.
+  for (let i = start - 1; i >= 0; i--) {
+    if (projectedAll[i].seqEnd >= projectedAll[start].seqStart) start = i;
+  }
+  const selected = projectedAll.slice(start);
+  return {
+    entries: selected,
+    startSeq: selected[0]?.seqStart ?? null,
+    endSeq: bounds.maxSeq,
+    hasOlder: start > 0,
+    hasNewer: false,
+  };
+}
+
+export function selectProjectedTimelinePage(input: {
+  rows: readonly AgentTimelineRow[];
+  bounds?: { minSeq: number; maxSeq: number };
+  direction: TimelineLimitDirection;
+  cursorSeq?: number;
+  limit?: number;
+}): ProjectedTimelinePageSelection {
+  const limit = input.limit === undefined ? 0 : Math.max(0, Math.floor(input.limit));
+  const bounds = input.bounds ?? getTimelineBounds(input.rows);
+  const projectedAll = projectTimelineRows({ rows: input.rows, mode: "projected" });
+  if (!bounds) {
+    return {
+      entries: [],
+      startSeq: null,
+      endSeq: null,
+      hasOlder: false,
+      hasNewer: false,
+    };
+  }
+
+  if (projectedAll.length === 0) {
+    if (input.direction === "after") {
+      const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+      return {
+        entries: [],
+        startSeq: null,
+        endSeq: null,
+        hasOlder: cursorSeq >= bounds.minSeq,
+        hasNewer: cursorSeq < bounds.maxSeq,
+      };
+    }
+    if (input.direction === "before") {
+      const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+      return {
+        entries: [],
+        startSeq: null,
+        endSeq: null,
+        hasOlder: cursorSeq > bounds.minSeq,
+        hasNewer: cursorSeq <= bounds.maxSeq,
+      };
+    }
+    return {
+      entries: [],
+      startSeq: null,
+      endSeq: null,
+      hasOlder: false,
+      hasNewer: false,
+    };
+  }
+
+  if (input.direction === "tail") {
+    return selectProjectedEntriesTail(projectedAll, limit, bounds);
+  }
+
+  if (input.direction === "after") {
+    const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+    const startSeq = Math.max(bounds.minSeq, cursorSeq + 1);
+    const selected = selectProjectedEntriesAfter({
+      entries: projectedAll,
+      startSeq,
+      maxSeq: bounds.maxSeq,
+      limit,
+    });
+    return {
+      entries: selected.entries,
+      startSeq: selected.endSeq === null ? null : startSeq,
+      endSeq: selected.endSeq,
+      hasOlder: startSeq > bounds.minSeq,
+      hasNewer: selected.endSeq !== null && selected.endSeq < bounds.maxSeq,
+    };
+  }
+
+  const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+  const endSeq = Math.min(bounds.maxSeq, cursorSeq - 1);
+  if (endSeq < bounds.minSeq) {
+    return {
+      entries: [],
+      startSeq: null,
+      endSeq: null,
+      hasOlder: false,
+      hasNewer: endSeq < bounds.maxSeq,
+    };
+  }
+
+  const selected = selectProjectedEntriesBefore({ entries: projectedAll, endSeq, limit });
+  return {
+    entries: selected.entries,
+    startSeq: selected.startSeq,
+    endSeq,
+    hasOlder: selected.hasOlder,
+    hasNewer: endSeq < bounds.maxSeq,
+  };
+}
+
 /**
  * Apply a projected-count limit to a flat AgentTimelineItem[] without seq metadata.
  * Used by callers that only have items in hand (e.g. MCP tools reading

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

@@ -1,4 +1,3 @@
-import { registerPluginTools } from "./plugin-tools.js";
 import type { FinishSubscriptions, FinishRegistration } from "../finish-subscriptions/index.js";
 import type { AgentMessageDelivery } from "../agent-messages/index.js";
 import {
@@ -705,7 +704,6 @@ function createToolCatalog(
   }
   const localHostOperations = new Map<string, HostOperation>();
   const tools = new Map<string, PaseoToolDefinition>();
-  const builtinNames = new Set<string>();
   const hostTools = new Map([
     ["create_agent", "createAgent"],
     ["create_workspace", "createWorkspace"],
@@ -740,7 +738,6 @@ function createToolCatalog(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Tool handlers are schema-validated at registration boundaries.
     handler: (input: any, context: PaseoToolExecutionContext) => Promise<PaseoToolResult>,
   ) => {
-    builtinNames.add(name);
     if (!isPaseoToolEnabled(options.paseoToolPolicy, name)) {
       return;
     }
@@ -3275,14 +3272,6 @@ function createToolCatalog(
     },
   );
 
-  registerPluginTools({
-    agentManager,
-    callerAgentId,
-    scope,
-    tools,
-    builtinNames,
-    policy: options.paseoToolPolicy,
-  });
   return toCatalog();
 }
 

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

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import type { ProviderPaseoToolsPolicy } from "@getpaseo/protocol/provider-config";
-import type { AgentManager } from "../agent-manager.js";
-import { isPaseoToolEnabled } from "../paseo-tool-policy.js";
-import type { PaseoToolDefinition } from "./types.js";
-import { addModelVisibleStructuredContent } from "./paseo-tool-serialization.js";
-
-export function registerPluginTools(options: {
-  agentManager: AgentManager;
-  callerAgentId?: string;
-  scope: "agent" | "top-level";
-  tools: Map<string, PaseoToolDefinition>;
-  builtinNames: Set<string>;
-  policy?: ProviderPaseoToolsPolicy;
-}): void {
-  const { agentManager, callerAgentId, scope, tools, builtinNames, policy } = options;
-  if (scope !== "agent" || !callerAgentId) return;
-  for (const tool of agentManager.getPluginTools(callerAgentId)) {
-    if (builtinNames.has(tool.name)) {
-      throw new Error(
-        `Agent tool ${tool.name} from plugin ${tool.pluginId} collides with Paseo tool ${tool.name}`,
-      );
-    }
-    if (!isPaseoToolEnabled(policy, tool.name)) continue;
-    tools.set(tool.name, {
-      name: tool.name,
-      title: tool.title,
-      description: tool.description,
-      inputSchema: z.fromJSONSchema(tool.inputSchema),
-      async handler(input, { signal }) {
-        const result = await agentManager.executePluginTool(tool, callerAgentId, input, signal);
-        return addModelVisibleStructuredContent({
-          content: result.text === undefined ? [] : [{ type: "text", text: result.text }],
-          structuredContent: result.structuredContent,
-          isError: result.isError,
-        });
-      },
-    });
-  }
-}

packages/server/src/server/bootstrap.test.ts

@@ -141,11 +141,11 @@ function liveCleanupHost() {
 test("bootstrap's host toggle prevents collection live, persists, and leaves other hosts enabled", async () => {
   const host = liveCleanupHost();
   const other = liveCleanupHost();
-  await host.store.patch({ idleRuntimeCleanup: false });
+  host.store.patch({ idleRuntimeCleanup: false });
   expect(loadPersistedConfig(host.home).agents?.idleRuntimeCleanup).toBe(false);
   expect((await host.sweep()).collected).toEqual([]);
   expect((await other.sweep()).collected).toHaveLength(1);
-  await host.store.patch({ idleRuntimeCleanup: true });
+  host.store.patch({ idleRuntimeCleanup: true });
   host.protect(true);
   expect((await host.sweep()).collected).toEqual([]);
   host.protect(false);
@@ -160,7 +160,7 @@ test("bootstrap's config-file reload binding disables and enables eligible colle
       path.join(host.home, "config.json"),
       JSON.stringify({ version: 1, agents: { idleRuntimeCleanup: enabled } }),
     );
-    expect(await host.store.reload()).toEqual({
+    expect(host.store.reload()).toEqual({
       appliedPaths: ["agents.idleRuntimeCleanup"],
       restartRequiredPaths: [],
       overrideControlledPaths: [],
@@ -173,12 +173,12 @@ test.each([false, true])(
   "failed config apply restores prior idle cleanup behavior (previous: %s)",
   async (previous) => {
     const host = liveCleanupHost();
-    await host.store.patch({ idleRuntimeCleanup: previous });
+    host.store.patch({ idleRuntimeCleanup: previous });
     const persistedBefore = loadPersistedConfig(host.home);
     const refuse = host.store.onApply(() => {
       throw new Error("Another live owner refused");
     });
-    await expect(host.store.patch({ idleRuntimeCleanup: !previous })).rejects.toThrow(
+    expect(() => host.store.patch({ idleRuntimeCleanup: !previous })).toThrow(
       "Another live owner refused",
     );
     expect(host.store.get().idleRuntimeCleanup).toBe(previous);
@@ -191,6 +191,6 @@ test.each([false, true])(
 test("disposing bootstrap's binding stops configuration delivery", async () => {
   const host = liveCleanupHost();
   host.unsubscribe();
-  await host.store.patch({ idleRuntimeCleanup: false });
+  host.store.patch({ idleRuntimeCleanup: false });
   expect((await host.sweep()).collected).toHaveLength(1);
 });

packages/server/src/server/bootstrap.ts

@@ -161,11 +161,7 @@ import { CheckoutDiffManager } from "./checkout-diff-manager.js";
 import { ScheduleService } from "./schedule/service.js";
 import { DaemonConfigStore, type MutableDaemonConfig } from "./daemon-config-store.js";
 import { createOrchestrationSkills } from "./orchestration-skills/index.js";
-import {
-  resolveReloadableConfig,
-  type ResolvedDaemonSettings,
-  type CliConfigOverrides,
-} from "./config.js";
+import { resolveConfigFromPersisted, type CliConfigOverrides } from "./config.js";
 import { resolvePaseoToolPolicy } from "./agent/paseo-tool-policy.js";
 import { BrowserToolsBroker } from "./browser-tools/broker.js";
 import { DaemonConfigBrowserToolsPolicy } from "./browser-tools/policy.js";
@@ -200,7 +196,7 @@ import type {
   AgentProviderRuntimeSettingsMap,
   ProviderOverride,
 } from "./agent/provider-launch-config.js";
-import { type PersistedConfig } from "./persisted-config.js";
+import { loadPersistedConfig, type PersistedConfig } from "./persisted-config.js";
 import { createServiceProxySubsystem, type ServiceProxySubsystem } from "./service-proxy.js";
 import { releaseWorkspaceServicePortPlan } from "./workspace-service-port-registry.js";
 import { ScriptHealthMonitor } from "./script-health-monitor.js";
@@ -555,7 +551,7 @@ function resolveExpressTrustProxySetting(config: PaseoDaemonConfig): true | stri
   return config.trustedProxies ?? ["loopback"];
 }
 
-function createInitialRelayConfig(config: ResolvedDaemonSettings): MutableDaemonConfig["relay"] {
+function createInitialRelayConfig(config: PaseoDaemonConfig): MutableDaemonConfig["relay"] {
   return {
     enabled: config.relayEnabled ?? true,
     requireProtectedSecurity: config.relayRequireProtectedSecurity ?? false,
@@ -566,7 +562,7 @@ function resolveReloadEnv(config: PaseoDaemonConfig): NodeJS.ProcessEnv {
   return config.configReload?.env ?? process.env;
 }
 
-function createInitialMutableDaemonConfig(config: ResolvedDaemonSettings): MutableDaemonConfig {
+function createInitialMutableDaemonConfig(config: PaseoDaemonConfig): MutableDaemonConfig {
   const providers = config.providerOverrides ?? {};
 
   const initialConfig: MutableDaemonConfig = {
@@ -642,14 +638,14 @@ export async function createPaseoDaemon(
     }),
     reloadSource: {
       resolve: (persisted) => {
-        const reloaded = resolveReloadableConfig(persisted, {
+        const reloaded = resolveConfigFromPersisted(config.paseoHome, persisted, {
           env: resolveReloadEnv(config),
           cli: config.configReload?.cli,
           relayEnabledFallback: config.configReload?.relayEnabledFallback,
         });
         return {
           mutable: createInitialMutableDaemonConfig(reloaded),
-          overrideControlledPaths: reloaded.overrideControlledPaths,
+          overrideControlledPaths: reloaded.configReload?.overrideControlledPaths ?? [],
         };
       },
     },
@@ -999,7 +995,6 @@ export async function createPaseoDaemon(
   const initialAgentManagerState = providerSnapshotManager.getAgentManagerProviderState();
   const agentManager = new AgentManager({
     pluginLifecycle: pluginRuntime,
-    pluginAgentTools: pluginRuntime,
     clients: initialAgentManagerState.clients,
     providerDefinitions: initialAgentManagerState.providerDefinitions,
     registry: agentStorage,
@@ -1020,10 +1015,6 @@ export async function createPaseoDaemon(
   const unsubscribePluginProviders =
     pluginRuntime.subscribeProviderRegistrations(syncPluginProviders);
 
-  const unsubscribePluginSessionChanges = pluginRuntime.subscribeSessionOpenChanges(() => {
-    agentManager.invalidatePluginSessions();
-  });
-
   const detachAgentStoragePersistence = attachAgentStoragePersistence(
     logger,
     agentManager,
@@ -1545,7 +1536,7 @@ export async function createPaseoDaemon(
       spawnWorkspaceScript,
       assertAutomationAllowed: (workspaceId) =>
         assertWorkspaceAutomationAllowedForWorkspace(workspaceRegistry, workspaceId),
-      getGlobalServicePorts: () => daemonConfigStore.readServicePorts(),
+      globalServicePorts: loadPersistedConfig(config.paseoHome).worktrees?.servicePorts,
     }),
     markWorkspaceArchiving: markWorkspaceArchivingExternal,
     clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
@@ -1923,7 +1914,6 @@ export async function createPaseoDaemon(
       localCredential = null;
       await deleteLocalCredential(config.paseoHome);
       unsubscribePluginProviders();
-      unsubscribePluginSessionChanges();
       await pluginRuntime.stopAllPlugins().catch(() => undefined);
       await serviceProxy.stopStandalone().catch(() => undefined);
       await agentProviderRuntime.shutdown().catch(() => undefined);
@@ -1943,7 +1933,6 @@ export async function createPaseoDaemon(
     // that is still open. Plugins themselves are stopped once every session
     // they serve has been closed, further down.
     unsubscribePluginProviders();
-    unsubscribePluginSessionChanges();
     await hubRelationships.stop();
     workspaceReconciliation.dispose();
     scriptHealthMonitor.stop();

packages/server/src/server/checkout-diff-cache.test.ts

@@ -132,22 +132,3 @@ test.each(["base", "uncommitted"] as const)(
     expect(await read("next", "next-after")).toEqual({ diff: "next-after" });
   },
 );
-
-test("superseding a diff cancels its highlighting while identical readers share work", async () => {
-  const cache = new CheckoutDiffCache(() => 0);
-  const release = Promise.withResolvers<{ diff: string }>();
-  let activeSignal: AbortSignal | undefined;
-  const load = (signal: AbortSignal) => {
-    activeSignal = signal;
-    return release.promise;
-  };
-  const first = cache.read({ cwd: "repo", compare: { mode: "base" }, load });
-  await Promise.resolve();
-  expect(activeSignal).toBeDefined();
-  expect(activeSignal!.aborted).toBe(false);
-  expect(cache.read({ cwd: "repo", compare: { mode: "base" }, load })).toBe(first);
-  cache.invalidate("repo", "base");
-  expect(activeSignal!.aborted).toBe(true);
-  release.resolve({ diff: "old snapshot" });
-  await first;
-});

packages/server/src/server/checkout-diff-cache.ts

@@ -4,7 +4,6 @@ import type { CheckoutDiffCompare, CheckoutDiffResult } from "../utils/checkout-
 interface ActiveRead {
   promise: Promise<CheckoutDiffResult>;
   invalidated: boolean;
-  controller: AbortController;
 }
 
 interface CachedDiff {
@@ -18,7 +17,7 @@ interface CheckoutDiffReadInput {
   compare: CheckoutDiffCompare;
   force?: boolean;
   reason?: string;
-  load: (signal: AbortSignal) => Promise<CheckoutDiffResult>;
+  load: () => Promise<CheckoutDiffResult>;
 }
 
 /** Completed payloads are bounded; active work survives invalidation and eviction. */
@@ -52,7 +51,6 @@ export class CheckoutDiffCache {
     if (pending) {
       if (force) {
         pending.invalidated = true;
-        pending.controller.abort();
         this.values.delete(key);
       }
       if (!pending.invalidated) return pending.promise;
@@ -68,9 +66,8 @@ export class CheckoutDiffCache {
     // Defer load until ownership is installed, including synchronous invalidations.
     const read: ActiveRead = {
       invalidated: false,
-      controller: new AbortController(),
       promise: Promise.resolve()
-        .then(() => load(read.controller.signal))
+        .then(load)
         .then((value) => {
           // Never repopulate the cache with a snapshot invalidated during its build.
           if (!read.invalidated)
@@ -89,10 +86,7 @@ export class CheckoutDiffCache {
       if (cachedCwd !== cwd || (cachedMode !== mode && cachedMode !== "all")) continue;
       this.values.delete(key);
       const pending = this.active.get(key);
-      if (pending) {
-        pending.invalidated = true;
-        pending.controller.abort();
-      }
+      if (pending) pending.invalidated = true;
     }
   }
 }

packages/server/src/server/config.test.ts

@@ -4,12 +4,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { afterEach, describe, expect, test } from "vitest";
 
-import {
-  loadConfig,
-  resolveBundledWebUiDistDir,
-  resolveConfigFromPersisted,
-  resolveReloadableConfig,
-} from "./config.js";
+import { loadConfig, resolveBundledWebUiDistDir, resolveConfigFromPersisted } from "./config.js";
 import { loadPersistedConfig } from "./persisted-config.js";
 
 const roots: string[] = [];
@@ -19,30 +14,6 @@ describe("server config", () => {
     await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
   });
 
-  test("resolves reloadable settings without resolving the startup password", async () => {
-    const paseoHome = await mkdtemp(path.join(os.tmpdir(), "paseo-config-auth-reload-"));
-    roots.push(paseoHome);
-    const env = { PASEO_PASSWORD: "synthetic-audit-password" };
-    const persisted = loadPersistedConfig(paseoHome);
-    const startup = resolveConfigFromPersisted(paseoHome, persisted, { env });
-    const started = performance.now();
-    const timer = new Promise<number>((resolve) =>
-      setTimeout(() => resolve(performance.now() - started), 0),
-    );
-    const reloaded = resolveReloadableConfig(
-      {
-        ...persisted,
-        daemon: { ...persisted.daemon, browserTools: { enabled: true } },
-      },
-      { env },
-    );
-    const gap = await timer;
-    expect(reloaded).not.toHaveProperty("auth");
-    expect(reloaded.browserToolsEnabled).toBe(true);
-    expect(startup.auth?.password).toBeTypeOf("string");
-    expect(gap).toBeLessThan(50);
-  });
-
   test("records when the daemon is managed by Paseo Desktop", async () => {
     const paseoHome = await mkdtemp(path.join(os.tmpdir(), "paseo-config-desktop-managed-"));
     roots.push(paseoHome);

packages/server/src/server/config.ts

@@ -568,43 +568,31 @@ interface ResolveConfigFromPersistedOptions {
   relayEnabledFallback?: boolean;
 }
 
-// Startup values, including authentication, never enter runtime settings resolution.
-export type ResolvedDaemonSettings = Pick<
-  PaseoDaemonConfig,
-  | "corsAllowedOrigins"
-  | "hostnames"
-  | "trustedProxies"
-  | "mcpEnabled"
-  | "mcpInjectIntoAgents"
-  | "browserToolsEnabled"
-  | "git"
-  | "autoArchiveAfterMerge"
-  | "enableTerminalAgentHooks"
-  | "appendSystemPrompt"
-  | "terminalProfiles"
-  | "agentProfiles"
-  | "skillSelection"
-  | "pluginsEnabled"
-  | "plugins"
-  | "relayEnabled"
-  | "relayRequireProtectedSecurity"
-  | "appBaseUrl"
-  | "idleRuntimeCleanup"
-  | "providerCatalogRefreshTimeoutMs"
-  | "metadataGeneration"
-  | "providerOverrides"
->;
-
 export function resolveConfigFromPersisted(
   paseoHome: string,
   persisted: PersistedConfig,
   options?: ResolveConfigFromPersistedOptions,
 ): PaseoDaemonConfig {
-  const env = configurationEnvironment(options?.env ?? process.env);
-  const cli = options?.cli;
+  const resolvedOptions = options ?? {};
+  const env = configurationEnvironment(resolvedOptions.env ?? process.env);
+  const cli = resolvedOptions.cli;
   const relayEnabledFallback =
-    options?.relayEnabledFallback ?? persisted.daemon?.relay?.enabled === undefined;
-  const { overrideControlledPaths, ...settings } = resolveReloadableConfig(persisted, options);
+    resolvedOptions.relayEnabledFallback ?? persisted.daemon?.relay?.enabled === undefined;
+
+  const listen = resolveListenAddress(env, cli, persisted);
+  const {
+    mcpEnabled,
+    mcpInjectIntoAgents,
+    browserToolsEnabled,
+    autoArchiveAfterMerge,
+    appendSystemPrompt,
+    terminalProfiles,
+    agentProfiles,
+    hostnames,
+    trustedProxies,
+    appBaseUrl,
+  } = resolveStaticLoadConfigSettings(env, cli, persisted);
+
   const relay = resolveRelayConfig({
     env,
     persisted,
@@ -612,14 +600,42 @@ export function resolveConfigFromPersisted(
     cliRelayUseTls: cli?.relayUseTls,
     enabledFallback: relayEnabledFallback,
   });
-  const { openai, speech } = resolveSpeechConfig({ paseoHome, env, persisted });
+  const serviceProxy = resolveServiceProxyConfig(env, persisted);
+  const webUi = resolveWebUiConfig(paseoHome, env, cli, persisted);
+
+  const { openai, speech } = resolveSpeechConfig({
+    paseoHome,
+    env,
+    persisted,
+  });
+
   const voiceLlm = resolveVoiceLlmConfig(env, persisted);
+  const providerOverrides = extractProviderOverrides(
+    persisted.agents?.providers as Record<string, unknown> | undefined,
+  );
+
+  const overrideControlledPaths = resolveOverrideControlledPaths(env, cli, persisted);
+
   return {
-    ...settings,
-    listen: resolveListenAddress(env, cli, persisted),
+    listen,
     paseoHome,
     desktopManaged: env.PASEO_DESKTOP_MANAGED === "1",
     worktreesRoot: resolveWorktreesRoot(paseoHome, persisted),
+    corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
+    hostnames,
+    trustedProxies,
+    mcpEnabled,
+    mcpInjectIntoAgents,
+    browserToolsEnabled,
+    git: resolveGitProcessConfig(env, persisted),
+    autoArchiveAfterMerge,
+    enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
+    appendSystemPrompt,
+    terminalProfiles,
+    agentProfiles,
+    skillSelection: persisted.agents?.skills?.selection,
+    pluginsEnabled: persisted.pluginsEnabled ?? false,
+    plugins: persisted.plugins,
     pluginRegistries: persisted.pluginRegistries,
     pluginRegistryUrl: env.PASEO_PLUGIN_REGISTRY,
     mcpDebug: env.MCP_DEBUG === "1",
@@ -627,20 +643,27 @@ export function resolveConfigFromPersisted(
     agentStoragePath: path.join(paseoHome, "agents"),
     staticDir: "public",
     agentClients: {},
+    relayEnabled: relay.enabled,
     relayEnabledMutable: relay.enabledMutable,
+    relayRequireProtectedSecurity: relay.requireProtectedSecurity,
     relayEndpoint: relay.endpoint,
     relayPublicEndpoint: relay.publicEndpoint,
     relayUseTls: relay.useTls,
     relayPublicUseTls: relay.publicUseTls,
-    serviceProxy: resolveServiceProxyConfig(env, persisted),
-    webUi: resolveWebUiConfig(paseoHome, env, cli, persisted),
+    serviceProxy,
+    webUi,
+    appBaseUrl,
     auth: resolveAuthConfig(env, persisted),
     openai,
     speech,
     voiceLlmProvider: voiceLlm.provider,
     voiceLlmProviderExplicit: voiceLlm.providerExplicit,
     voiceLlmModel: voiceLlm.model,
-    agentProviderSettings: extractAgentProviderSettings(settings.providerOverrides),
+    agentProviderSettings: extractAgentProviderSettings(providerOverrides),
+    idleRuntimeCleanup: persisted.agents?.idleRuntimeCleanup ?? true,
+    providerCatalogRefreshTimeoutMs: persisted.agents?.catalogRefreshTimeoutMs,
+    metadataGeneration: persisted.agents?.metadataGeneration,
+    providerOverrides,
     log: resolveLogConfigFromEnv(env, persisted),
     configReload: {
       env: { ...env },
@@ -652,40 +675,6 @@ export function resolveConfigFromPersisted(
   };
 }
 
-export function resolveReloadableConfig(
-  persisted: PersistedConfig,
-  options?: ResolveConfigFromPersistedOptions,
-): ResolvedDaemonSettings & { overrideControlledPaths: string[] } {
-  const env = configurationEnvironment(options?.env ?? process.env);
-  const cli = options?.cli;
-  const relay = resolveRelayConfig({
-    env,
-    persisted,
-    cliRelayEnabled: cli?.relayEnabled,
-    cliRelayUseTls: cli?.relayUseTls,
-    enabledFallback:
-      options?.relayEnabledFallback ?? persisted.daemon?.relay?.enabled === undefined,
-  });
-  return {
-    ...resolveStaticLoadConfigSettings(env, cli, persisted),
-    corsAllowedOrigins: resolveCorsAllowedOrigins(env, persisted),
-    git: resolveGitProcessConfig(env, persisted),
-    enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
-    skillSelection: persisted.agents?.skills?.selection,
-    pluginsEnabled: persisted.pluginsEnabled ?? false,
-    plugins: persisted.plugins,
-    relayEnabled: relay.enabled,
-    relayRequireProtectedSecurity: relay.requireProtectedSecurity,
-    idleRuntimeCleanup: persisted.agents?.idleRuntimeCleanup ?? true,
-    providerCatalogRefreshTimeoutMs: persisted.agents?.catalogRefreshTimeoutMs,
-    metadataGeneration: persisted.agents?.metadataGeneration,
-    providerOverrides: extractProviderOverrides(
-      persisted.agents?.providers as Record<string, unknown> | undefined,
-    ),
-    overrideControlledPaths: resolveOverrideControlledPaths(env, cli, persisted),
-  };
-}
-
 export function loadConfig(
   paseoHome: string,
   options?: Omit<ResolveConfigFromPersistedOptions, "relayEnabledFallback">,