Add active-turn steering (#3394)

* feat(agents): add active-turn steering

Let users choose whether an immediate prompt interrupts or joins the active turn. The daemon owns exact-turn admission, provider delivery, safe fallback, and canonical timeline identity while queueing remains client-side.

* fix(agents): stabilize steering history and replay QA

* fix(agents): preserve steering timeline order

* fix(agents): reconcile resumed provider history

* fix(agents): serialize steering with cancellation

* test(agents): prove Claude multi-tool steering

* test(agents): force explicit history hydration

* fix(agents): flush output before steer admission

packages/app/e2e/browser/agent-message-submission.spec.ts

@@ -30,13 +30,14 @@ import { buildHostWorkspaceRoute } from "@/utils/host-routes";
 import { WORKSPACE_DECK_MAX_MOUNTED_WORKSPACES } from "@/screens/workspace/workspace-deck-retention";
 import { delayBrowserAgentCreatedStatus } from "../support/helpers/new-workspace";
 import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
-import { selectModel } from "../support/helpers/app";
+import { gotoAppShell, openSettings, selectModel } from "../support/helpers/app";
 import { observeTimelineSubscriptions } from "../support/helpers/timeline-delivery";
 import {
   expectResumeOverflowFallsBackToOneTail,
   rememberTimelineRequestCounts,
 } from "../support/helpers/timeline-resume";
 import { workspaceDeckEntryLocator } from "../support/helpers/workspace-ui";
+import { expectInFlightForkAvailable } from "../support/helpers/assistant-fork";
 import {
   scrollTimelineToNewestLoadedEdge,
   scrollTimelineUntilOlderHistoryIsReachable,
@@ -264,14 +265,20 @@ async function submitMessageThatWillBeRejected(page: Page, prompt: string): Prom
 
 async function expectRejectedSubmissionRestored(
   page: Page,
-  input: { prompt: string; errorMessage: string },
+  input: { prompt: string; errorMessage: string; preservesActiveTurn?: boolean },
 ): Promise<void> {
-  await expect(page.getByText(input.errorMessage)).toBeVisible({ timeout: 30_000 });
+  await expect(page.getByRole("alert").filter({ hasText: input.errorMessage })).toBeVisible({
+    timeout: 30_000,
+  });
   await expectComposerDraft(page, input.prompt);
   await expectComposerEditable(page);
   await expectAttachmentPill(page, "composer-image-attachment-pill");
-  await expect(page.getByRole("button", { name: "Send message" })).toBeEnabled();
   await expect(page.getByTestId("user-message").filter({ hasText: input.prompt })).toHaveCount(0);
+  if (input.preservesActiveTurn) {
+    await expect(page.getByTestId("turn-working-indicator")).toBeVisible();
+    return;
+  }
+  await expect(page.getByRole("button", { name: "Send message" })).toBeEnabled();
   await expect(page.getByTestId("turn-working-indicator")).toHaveCount(0);
 }
 
@@ -284,6 +291,60 @@ async function retryRestoredSubmission(page: Page, prompt: string): Promise<void
   await expect(page.getByTestId("composer-image-attachment-pill")).toHaveCount(0);
 }
 
+async function configureSteerInSettings(page: Page): Promise<void> {
+  const modifier = process.platform === "darwin" ? "Meta" : "Control";
+  await page.keyboard.press(`${modifier}+Comma`);
+  await expect(page).toHaveURL(/\/settings\/general$/);
+  await selectSteerInSettings(page);
+}
+
+async function selectSteerInSettings(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Steer", exact: true }).click();
+  await expect
+    .poll(async () => {
+      const raw = await page.evaluate(() => localStorage.getItem("@paseo:app-settings"));
+      return raw ? (JSON.parse(raw) as { sendBehavior?: unknown }).sendBehavior : null;
+    })
+    .toBe("steer");
+}
+
+async function replaySteeredSleepTurnInBrowser(
+  page: Page,
+  testInfo: { workerIndex: number },
+  shape: "claude" | "codex",
+): Promise<void> {
+  const gate = await installDaemonWebSocketGate(page);
+  gate.holdNextShellToolCall("completed");
+  await gotoAppShell(page);
+  await openSettings(page);
+  await selectSteerInSettings(page);
+  const agent = await startRunningMockAgent(page, {
+    prefix: `steer-replay-${shape}-${testInfo.workerIndex}-`,
+    model: "ten-second-stream",
+    prompt: `Replay a ${shape}-shaped foreground shell tool call while the user steers this turn.`,
+  });
+  try {
+    await expect(page.getByTestId("tool-call-badge").last()).toBeVisible({ timeout: 30_000 });
+    await expectComposerVisible(page);
+    await submitMessage(page, "hello");
+
+    await expect(page.getByText("hello", { exact: true })).toHaveCount(1);
+    await expect(page.getByRole("button", { name: /^Worked for/ })).toHaveCount(0);
+    await expectInFlightForkAvailable(page);
+
+    await gate.waitForHeldServerMessage();
+    gate.releaseHeldServerMessage();
+    await agent.client.waitForFinish(agent.agentId, 30_000);
+
+    await expect(page.getByText("hello", { exact: true })).toHaveCount(1);
+    await expect(page.getByRole("button", { name: /^Worked for/ })).toHaveCount(1);
+    await expect(page.getByRole("button", { name: "Fork chat" }).last()).toBeVisible();
+  } finally {
+    gate.restore();
+    await agent.cleanup();
+  }
+}
+
 async function queueMessage(page: Page, prompt: string): Promise<void> {
   await fillComposerDraft(page, prompt);
   await sendDraftToQueue(page);
@@ -1030,6 +1091,83 @@ test.describe("Agent message submission", () => {
     await retryRestoredSubmission(page, prompt);
   });
 
+  test("restores an ambiguous Steer failure without retrying or interrupting", async ({
+    page,
+  }, testInfo) => {
+    test.setTimeout(120_000);
+    const gate = await installDaemonWebSocketGate(page);
+    const prompt = "Restore this ambiguous Steer submission.";
+    const agent = await startRunningMockAgent(page, {
+      prefix: `steer-ambiguous-${testInfo.workerIndex}-`,
+      model: "one-minute-stream",
+      prompt: "Keep this turn active while a Steer request fails.",
+      featureValues: { mockSteerAmbiguousFailures: 1 },
+    });
+    try {
+      await configureSteerInSettings(page);
+      await page.goBack();
+      await expectComposerVisible(page);
+      await expectAgentReadyToInterrupt(page);
+      const sendsBefore = gate.getClientRequestCount("send_agent_message_request");
+      const cancelsBefore = gate.getClientRequestCount("cancel_agent_request");
+
+      await submitMessageThatWillBeRejected(page, prompt);
+      await expectRejectedSubmissionRestored(page, {
+        prompt,
+        errorMessage: "Requested mock steer transport failure",
+        preservesActiveTurn: true,
+      });
+
+      expect(gate.getClientRequestCount("send_agent_message_request")).toBe(sendsBefore + 1);
+      expect(gate.getClientRequestCount("cancel_agent_request")).toBe(cancelsBefore);
+      expect(gate.getClientRequests("send_agent_message_request").at(-1)).toMatchObject({
+        text: prompt,
+        activeTurnBehavior: "steer",
+      });
+    } finally {
+      gate.restore();
+      await agent.cleanup();
+    }
+  });
+
+  test("keeps an optimistic Steer prompt inside the active turn before acknowledgement", async ({
+    page,
+  }, testInfo) => {
+    test.setTimeout(120_000);
+    const gate = await installDaemonWebSocketGate(page);
+    const agent = await startRunningMockAgent(page, {
+      prefix: `steer-optimistic-${testInfo.workerIndex}-`,
+      model: "one-minute-stream",
+      prompt: "Keep this turn active while the user steers it.",
+    });
+    try {
+      await configureSteerInSettings(page);
+      await page.goBack();
+      await expectComposerVisible(page);
+      await expectAgentReadyToInterrupt(page);
+      gate.holdNextServerMessage("send_agent_message_response");
+      await submitMessage(page, "hello");
+      await gate.waitForHeldServerMessage("send_agent_message_response");
+      await expect(page.getByText("hello", { exact: true })).toHaveCount(1);
+      await expect(page.getByText(/^Worked for/)).toHaveCount(0);
+      gate.releaseHeldServerMessage("send_agent_message_response");
+      await expect(page.getByText("hello", { exact: true })).toHaveCount(1);
+    } finally {
+      gate.restore();
+      await agent.cleanup();
+    }
+  });
+
+  test("replays Claude-shaped steering inside one active turn", async ({ page }, testInfo) => {
+    test.setTimeout(120_000);
+    await replaySteeredSleepTurnInBrowser(page, testInfo, "claude");
+  });
+
+  test("replays Codex-shaped steering inside one active turn", async ({ page }, testInfo) => {
+    test.setTimeout(120_000);
+    await replaySteeredSleepTurnInBrowser(page, testInfo, "codex");
+  });
+
   test("restores overlapping queued sends when their connection fails", async ({
     page,
   }, testInfo) => {

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

@@ -12,7 +12,7 @@ async function pressSettingsToggleShortcut(page: import("@playwright/test").Page
 
 async function expectSendBehavior(
   page: import("@playwright/test").Page,
-  expected: "interrupt" | "queue",
+  expected: "interrupt" | "queue" | "steer",
 ) {
   await expect
     .poll(async () => {

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

@@ -198,13 +198,20 @@ export async function selectGithubOption(
 export interface MockAgentSetup {
   client: SeedDaemonClient;
   repo: Awaited<ReturnType<typeof createTempGitRepo>>;
+  workspaceId: string;
+  agentId: string;
   cleanup: () => Promise<void>;
 }
 
 /** Create a temp repo, start a mock agent, navigate to it, and wait for it to be running. */
 export async function startRunningMockAgent(
   page: Page,
-  opts: { prefix: string; model: string; prompt: string },
+  opts: {
+    prefix: string;
+    model: string;
+    prompt: string;
+    featureValues?: Record<string, unknown>;
+  },
 ): Promise<MockAgentSetup> {
   const serverId = getServerId();
 
@@ -222,6 +229,7 @@ export async function startRunningMockAgent(
     cwd: repo.path,
     workspaceId: workspace.id,
     model: opts.model,
+    featureValues: opts.featureValues,
   });
   const agentUrl = `${buildHostWorkspaceRoute(serverId, workspace.id)}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
   await page.goto(agentUrl);
@@ -233,6 +241,8 @@ export async function startRunningMockAgent(
   return {
     client,
     repo,
+    workspaceId: workspace.id,
+    agentId: agent.id,
     cleanup: async () => {
       await client.removeProject(workspace.projectId).catch(() => undefined);
       await client.close().catch(() => undefined);

packages/app/e2e/support/helpers/daemon-websocket-gate.ts

@@ -20,6 +20,9 @@ interface ClientRequest {
   payload?: unknown;
   mode?: unknown;
   path?: unknown;
+  agentId?: unknown;
+  text?: unknown;
+  activeTurnBehavior?: unknown;
 }
 
 interface ServerMessage {
@@ -48,6 +51,11 @@ interface HeldServerMessage {
   blockedAgentId?: string;
 }
 
+interface PendingServerMessageHold {
+  matches: (message: ClientRequest | null) => boolean;
+  blockAgentStreamFollowers?: boolean;
+}
+
 function readSessionMessage(message: string | Buffer): ClientRequest | null {
   try {
     const envelope = JSON.parse(typeof message === "string" ? message : message.toString()) as {
@@ -125,6 +133,25 @@ function forceTimelineReset(message: string | Buffer, enabled: boolean): string
   return JSON.stringify(envelope);
 }
 
+function rewriteShellToolCommand(
+  message: string | Buffer,
+  command: string | null,
+): string | Buffer {
+  if (!command || typeof message !== "string") return message;
+  const envelope = JSON.parse(message) as {
+    message?: { payload?: { event?: { type?: unknown; item?: Record<string, unknown> } } };
+    payload?: { event?: { type?: unknown; item?: Record<string, unknown> } };
+  };
+  const event = (envelope.message?.payload ?? envelope.payload)?.event;
+  if (event?.type !== "timeline" || event.item?.type !== "tool_call") return message;
+  const detail = event.item.detail;
+  if (!detail || typeof detail !== "object" || (detail as { type?: unknown }).type !== "shell") {
+    return message;
+  }
+  (detail as { command?: unknown }).command = command;
+  return JSON.stringify(envelope);
+}
+
 function readAgentStreamEventType(message: ClientRequest | null): string | null {
   if (message?.type !== "agent_stream" || !message.payload || typeof message.payload !== "object") {
     return null;
@@ -152,6 +179,36 @@ function readAgentStreamItemType(message: ClientRequest | null): string | null {
     : null;
 }
 
+function matchesToolCall(
+  message: ClientRequest | null,
+  input: { status: string; command?: string },
+): boolean {
+  if (readAgentStreamItemType(message) !== "tool_call") return false;
+  const event = (
+    message?.payload as
+      | {
+          event?: { item?: { status?: unknown; detail?: { command?: unknown } } };
+        }
+      | undefined
+  )?.event;
+  return (
+    event?.item?.status === input.status &&
+    (input.command === undefined || event.item.detail?.command === input.command)
+  );
+}
+
+function matchesShellToolCall(message: ClientRequest | null, status: string): boolean {
+  if (readAgentStreamItemType(message) !== "tool_call") return false;
+  const event = (
+    message?.payload as
+      | {
+          event?: { item?: { status?: unknown; detail?: { type?: unknown } } };
+        }
+      | undefined
+  )?.event;
+  return event?.item?.status === status && event.item.detail?.type === "shell";
+}
+
 function shouldSuppressServerMessage(input: {
   message: ClientRequest | null;
   messageTypes: ReadonlySet<string>;
@@ -226,10 +283,11 @@ export async function installDaemonWebSocketGate(page: Page) {
   let forceTimelineEpochReset = false;
   let stripAssistantMessageIds = false;
   let stripCanonicalSubmittedPromptsFeature = false;
+  let shellToolCommandOverride: string | null = null;
   let heldClientRequestType: string | null = null;
   let heldClientRequest: { server: WebSocketRoute; message: string | Buffer } | null = null;
   let resolveHeldClientRequest: (() => void) | null = null;
-  const pendingServerMessageHolds = new Map<string, (message: ClientRequest | null) => boolean>();
+  const pendingServerMessageHolds = new Map<string, PendingServerMessageHold>();
   const heldServerMessages: HeldServerMessage[] = [];
   const heldServerMessageWaiters = new Set<() => void>();
   const suppressedServerMessageTypes = new Set<string>();
@@ -243,6 +301,7 @@ export async function installDaemonWebSocketGate(page: Page) {
     total: { agents: 0, workspaces: 0 },
   };
   const clientRequestCounts = new Map<string, number>();
+  const clientRequests = new Map<string, ClientRequest[]>();
   const timelineRequestCounts = new Map<string, number>();
   const serverMessageCounts = new Map<string, number>();
   const agentStreamEventCounts = new Map<string, number>();
@@ -322,11 +381,11 @@ export async function installDaemonWebSocketGate(page: Page) {
       if (!suppressed) blocked.agentStreamFollowers.push(input.message);
       return true;
     }
-    const matchedHold = Array.from(pendingServerMessageHolds).find(([, matches]) =>
-      matches(input.parsed),
+    const matchedHold = Array.from(pendingServerMessageHolds).find(([, hold]) =>
+      hold.matches(input.parsed),
     );
     if (!matchedHold) return suppressed;
-    const [key] = matchedHold;
+    const [key, hold] = matchedHold;
     pendingServerMessageHolds.delete(key);
     heldServerMessages.push({
       browser: input.browser,
@@ -334,7 +393,7 @@ export async function installDaemonWebSocketGate(page: Page) {
       key,
       agentStreamFollowers: [],
       blockedAgentId:
-        readAgentStreamEventType(input.parsed) === "turn_started"
+        hold.blockAgentStreamFollowers || readAgentStreamEventType(input.parsed) === "turn_started"
           ? (agentId ?? undefined)
           : undefined,
     });
@@ -385,6 +444,11 @@ export async function installDaemonWebSocketGate(page: Page) {
       }
       const request = readClientRequest(message);
       recordClientRequest(request, clientRequestCounts, timelineRequestCounts, directoryStarts);
+      if (typeof request?.type === "string") {
+        const requests = clientRequests.get(request.type) ?? [];
+        requests.push(request);
+        clientRequests.set(request.type, requests);
+      }
       if (request?.type === heldClientRequestType) {
         heldClientRequest = { server, message };
         resolveHeldClientRequest?.();
@@ -417,6 +481,7 @@ export async function installDaemonWebSocketGate(page: Page) {
         stripAssistantMessageIds,
         serverMessage?.type,
       );
+      outboundMessage = rewriteShellToolCommand(outboundMessage, shellToolCommandOverride);
       outboundMessage = stripCanonicalSubmittedPrompts(
         outboundMessage,
         stripCanonicalSubmittedPromptsFeature,
@@ -516,25 +581,36 @@ export async function installDaemonWebSocketGate(page: Page) {
       heldClientRequestType = null;
     },
     holdNextServerMessage(type: string): void {
-      pendingServerMessageHolds.set(serverMessageKey(type), (message) => message?.type === type);
+      pendingServerMessageHolds.set(serverMessageKey(type), {
+        matches: (message) => message?.type === type,
+      });
     },
     holdNextAgentUpdate(agentId: string, status: string): void {
       const heldAgentUpdate = { agentId, status };
-      pendingServerMessageHolds.set(agentUpdateKey(agentId, status), (message) =>
-        matchesAgentUpdate(message, heldAgentUpdate),
-      );
+      pendingServerMessageHolds.set(agentUpdateKey(agentId, status), {
+        matches: (message) => matchesAgentUpdate(message, heldAgentUpdate),
+      });
     },
     holdNextAgentStreamEvent(type: string): void {
-      pendingServerMessageHolds.set(
-        agentStreamEventKey(type),
-        (message) => readAgentStreamEventType(message) === type,
-      );
+      pendingServerMessageHolds.set(agentStreamEventKey(type), {
+        matches: (message) => readAgentStreamEventType(message) === type,
+      });
     },
     holdNextAgentStreamItem(type: string): void {
-      pendingServerMessageHolds.set(
-        agentStreamItemKey(type),
-        (message) => readAgentStreamItemType(message) === type,
-      );
+      pendingServerMessageHolds.set(agentStreamItemKey(type), {
+        matches: (message) => readAgentStreamItemType(message) === type,
+      });
+    },
+    holdNextToolCall(input: { status: string; command?: string }): void {
+      pendingServerMessageHolds.set(`tool-call:${input.status}:${input.command ?? ""}`, {
+        matches: (message) => matchesToolCall(message, input),
+      });
+    },
+    holdNextShellToolCall(status: string): void {
+      pendingServerMessageHolds.set(`shell-tool-call:${status}`, {
+        matches: (message) => matchesShellToolCall(message, status),
+        blockAgentStreamFollowers: true,
+      });
     },
     async waitForHeldServerMessage(type?: string): Promise<void> {
       const key = type ? serverMessageKey(type) : null;
@@ -686,6 +762,9 @@ export async function installDaemonWebSocketGate(page: Page) {
     setCanonicalSubmittedPromptsStripped(stripped: boolean): void {
       stripCanonicalSubmittedPromptsFeature = stripped;
     },
+    setShellToolCommandOverride(command: string | null): void {
+      shellToolCommandOverride = command;
+    },
     setAgentStreamSuppressed(suppressed: boolean): void {
       suppressAgentStream = suppressed;
     },
@@ -702,6 +781,9 @@ export async function installDaemonWebSocketGate(page: Page) {
     getClientRequestCount(type: string): number {
       return clientRequestCounts.get(type) ?? 0;
     },
+    getClientRequests(type: string): ReadonlyArray<ClientRequest> {
+      return [...(clientRequests.get(type) ?? [])];
+    },
     getTimelineRequestCount(direction: "tail" | "before" | "after"): number {
       return timelineRequestCounts.get(direction) ?? 0;
     },

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

@@ -26,6 +26,7 @@ function assistantMessage(
   id: string,
   seed: number,
   block?: { groupId: string; index: number },
+  turnId?: string,
 ): Extract<StreamItem, { kind: "assistant_message" }> {
   return {
     kind: "assistant_message",
@@ -33,14 +34,20 @@ function assistantMessage(
     text: id,
     timestamp: timestamp(seed),
     ...(block ? { blockGroupId: block.groupId, blockIndex: block.index } : {}),
+    ...(turnId ? { turnId } : {}),
   };
 }
 
-function toolCall(id: string, seed: number): Extract<StreamItem, { kind: "tool_call" }> {
+function toolCall(
+  id: string,
+  seed: number,
+  turnId?: string,
+): Extract<StreamItem, { kind: "tool_call" }> {
   return {
     kind: "tool_call",
     id,
     timestamp: timestamp(seed),
+    ...(turnId ? { turnId } : {}),
     payload: {
       source: "orchestrator",
       data: {
@@ -143,6 +150,44 @@ function findLayoutItem(layout: StreamLayout, id: string): StreamLayoutItem {
 }
 
 describe("layoutStream", () => {
+  it("does not borrow an assistant footer across adjacent tagged tool-only turns", () => {
+    const priorAssistant = assistantMessage("prior", 1, undefined, "turn-1");
+    const nextTool = toolCall("next-tool", 2, "turn-2");
+    const layout = layoutFor({
+      platform: "web",
+      tail: [priorAssistant, nextTool],
+      timingIds: [priorAssistant.id],
+    });
+
+    expect(layout.auxiliaryTurnFooter).toBeNull();
+    expect(footerOwners(layout)).toEqual([priorAssistant.id]);
+  });
+
+  it("recomputes cached history layout when only the live boundary turn changes", () => {
+    const priorAssistant = assistantMessage("prior", 1, undefined, "turn-1");
+    const history = [priorAssistant];
+    const liveHead = [toolCall("live-tool", 2, "turn-1")];
+    const strategy = strategyFor("web");
+    const first = layoutStream({
+      strategy,
+      isTurnActive: true,
+      history,
+      liveHead,
+      timingByAssistantId: timingFor(priorAssistant.id),
+    });
+
+    liveHead[0] = { ...liveHead[0]!, turnId: "turn-2" };
+    const second = layoutStream({
+      strategy,
+      isTurnActive: true,
+      history,
+      liveHead,
+      timingByAssistantId: timingFor(priorAssistant.id),
+    });
+
+    expect(footerOwners(first)).toEqual([]);
+    expect(footerOwners(second)).toEqual([priorAssistant.id]);
+  });
   it.each(["web", "android"] as const)(
     "marks only the active live-head assistant block as streaming on %s",
     (platform) => {
@@ -249,6 +294,18 @@ describe("layoutStream", () => {
     expect(assistantRow.frameOrder).toBe("footer-then-content");
   });
 
+  it("keeps an accepted steer inline while its canonical turn is active", () => {
+    const assistant = { ...assistantMessage("a1", 2), turnId: "turn-1" };
+    const steer = { ...userMessage("u2", 3), turnId: "turn-1" };
+    const layout = layoutFor({
+      platform: "web",
+      isTurnActive: true,
+      tail: [{ ...userMessage("u1", 1), turnId: "turn-1" }, assistant, steer],
+      timingIds: [assistant.id],
+    });
+    expect(footerOwners(layout)).toEqual([]);
+  });
+
   it("keeps forward stream content before its completed footer", () => {
     const assistant = assistantMessage("a1", 2);
     const layout = layoutFor({

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

@@ -2,6 +2,7 @@ import type { TurnTiming } from "@/timeline/turn-time";
 import type { StreamItem } from "@/types/stream";
 import { getAssistantBlockSpacing, getGapBetweenStreamItems } from "./spacing";
 import type { StreamFrameChildOrder, StreamStrategy } from "./strategy";
+import { continuesTurn, isTurnBoundary } from "./turn-membership";
 
 export type StreamToolSequence = "single" | "first" | "middle" | "last" | "none";
 
@@ -87,6 +88,7 @@ function findLatestAssistantInTurn(input: {
   let items = input.items;
   let index = input.startIndex;
   let canCrossBoundary = true;
+  let laterItem: StreamItem | null = null;
 
   while (true) {
     for (
@@ -95,12 +97,13 @@ function findLatestAssistantInTurn(input: {
       index = input.strategy.getNeighborIndex(index, "above")
     ) {
       const item = items[index];
-      if (!item || item.kind === "user_message") {
+      if (!item || (laterItem && !continuesTurn(item, laterItem))) {
         return null;
       }
       if (item.kind === "assistant_message") {
         return { item, items, index };
       }
+      laterItem = item;
     }
 
     if (
@@ -157,7 +160,7 @@ function resolveCompletedFooter(input: {
   boundaryAboveItems: StreamItem[] | null;
   boundaryAboveIndex: number | null;
 }): TurnFooterHost | null {
-  if (input.item.kind === "user_message" || input.belowItem?.kind !== "user_message") {
+  if (input.item.kind === "user_message" || !isTurnBoundary(input.item, input.belowItem)) {
     return null;
   }
 
@@ -194,8 +197,10 @@ function getToolSequence(input: {
     return "none";
   }
 
-  const hasAbove = isToolSequenceItem(input.aboveItem);
-  const hasBelow = isToolSequenceItem(input.belowItem);
+  const hasAbove =
+    isToolSequenceItem(input.aboveItem) && continuesTurn(input.aboveItem, input.item);
+  const hasBelow =
+    isToolSequenceItem(input.belowItem) && continuesTurn(input.item, input.belowItem);
   if (hasAbove && hasBelow) {
     return "middle";
   }
@@ -273,7 +278,9 @@ function layoutSegment(input: LayoutSegmentInput): StreamLayoutItem[] {
       toolSequence: getToolSequence({ item, aboveItem, belowItem }),
       isFirstInUserGroup: item.kind === "user_message" && aboveItem?.kind !== "user_message",
       isLastInUserGroup: item.kind === "user_message" && belowItem?.kind !== "user_message",
-      isLastInToolSequence: isToolSequenceItem(item) && !isToolSequenceItem(belowItem),
+      isLastInToolSequence:
+        isToolSequenceItem(item) &&
+        !(isToolSequenceItem(belowItem) && continuesTurn(item, belowItem)),
       frameOrder: input.frameOrder,
       phase: input.phase,
     };
@@ -297,14 +304,14 @@ export function layoutStream(input: StreamLayoutInput): StreamLayout {
 
   let history: StreamLayoutItem[];
   if (input.history.length > 0) {
-    // The cache key encodes every input that can change history layout. liveHeadBoundaryItem.id
-    // and .kind are stable across text-only flushes (text growth doesn't change what kind of
-    // item borders history), so cached layout stays valid between flushes.
+    // The cache key encodes every input that can change history layout. The boundary turn ID
+    // is membership, so changing it must not reuse a layout from the adjacent turn.
     const historyCacheKey = [
       frameOrder,
       historyBoundaryIndex ?? "null",
       liveHeadBoundaryItem?.id ?? "null",
       liveHeadBoundaryItem?.kind ?? "null",
+      liveHeadBoundaryItem?.turnId ?? "null",
       auxiliaryTurnFooter?.itemId ?? "null",
     ].join(":");
     let byKey = historyLayoutCache.get(input.history);

packages/app/src/agent-stream/render-strategy.test.ts

@@ -38,6 +38,24 @@ function assistantMessage(id: string, text: string, seed: number): StreamItem {
   };
 }
 
+function toolCall(id: string, seed: number): StreamItem {
+  return {
+    kind: "tool_call",
+    id,
+    timestamp: createTimestamp(seed),
+    payload: {
+      source: "orchestrator",
+      data: {
+        toolCallId: id,
+        toolName: "Shell",
+        arguments: "echo hi",
+        result: null,
+        status: "completed",
+      },
+    },
+  };
+}
+
 describe("resolveStreamRenderStrategy", () => {
   it("uses forward_stream on web", () => {
     const strategy = resolveStreamRenderStrategy({
@@ -196,6 +214,23 @@ describe("neighbor and traversal semantics", () => {
     ).toBe("assistant-1\n\nassistant-2");
   });
 
+  it("does not collect copy or fork content across an adjacent tagged turn", () => {
+    const chronological: StreamItem[] = [
+      { ...assistantMessage("a1", "first turn", 1), turnId: "turn-1" },
+      { ...toolCall("tool", 2), turnId: "turn-2" },
+      { ...assistantMessage("a2", "second turn", 3), turnId: "turn-2" },
+    ];
+    const strategy = resolveStreamRenderStrategy({ platform: "web", isMobileBreakpoint: false });
+
+    expect(
+      collectAssistantTurnContentForStreamRenderStrategy({
+        strategy,
+        items: chronological,
+        startIndex: 2,
+      }),
+    ).toBe("second turn");
+  });
+
   it("returns undefined neighbor when index would be out of bounds", () => {
     const forward = resolveStreamRenderStrategy({
       platform: "web",

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

@@ -1,6 +1,7 @@
 import type { ComponentType, ReactElement, ReactNode, RefObject } from "react";
 import type { StyleProp, ViewStyle } from "react-native";
 import type { StreamItem } from "@/types/stream";
+import { continuesTurn } from "./turn-membership";
 import type { StreamHistoryBoundary, StreamRenderSegments } from "./model";
 import type {
   BottomAnchorLocalRequest,
@@ -165,18 +166,20 @@ export function createStreamStrategy(config: StreamStrategyConfig): StreamStrate
     },
     collectAssistantTurnContent: (items, startIndex) => {
       const messages: string[] = [];
+      let laterItem: StreamItem | null = null;
       for (
         let index = startIndex;
         index >= 0 && index < items.length;
         index += config.assistantTurnTraversalStep
       ) {
         const currentItem = items[index];
-        if (currentItem.kind === "user_message") {
+        if (!currentItem || (laterItem && !continuesTurn(currentItem, laterItem))) {
           break;
         }
         if (currentItem.kind === "assistant_message") {
           messages.push(currentItem.text);
         }
+        laterItem = currentItem;
       }
       return messages.toReversed().join("\n\n");
     },

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

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import type { StreamItem } from "@/types/stream";
+import { buildAgentStreamRenderModel } from "./model";
+import { layoutStream } from "./layout";
+import { resolveStreamRenderStrategy } from "./strategy-resolver";
+import { continuesTurn } from "./turn-membership";
+
+function at(second: number): Date {
+  return new Date(`2026-01-01T00:00:${second.toString().padStart(2, "0")}.000Z`);
+}
+
+function user(id: string, second: number, turnId: string): StreamItem {
+  return { kind: "user_message", id, text: id, timestamp: at(second), turnId };
+}
+
+function assistant(id: string, second: number, turnId: string): StreamItem {
+  return { kind: "assistant_message", id, text: id, timestamp: at(second), turnId };
+}
+
+function runningTool(id: string, second: number, turnId: string): StreamItem {
+  return {
+    kind: "tool_call",
+    id,
+    timestamp: at(second),
+    turnId,
+    payload: {
+      source: "agent",
+      data: {
+        provider: "claude",
+        callId: id,
+        name: "Bash",
+        status: "running",
+        error: null,
+        detail: { type: "unknown", input: null, output: null },
+      },
+    },
+  };
+}
+
+function layoutFor(items: StreamItem[], isTurnActive: boolean) {
+  const model = buildAgentStreamRenderModel({
+    isTurnActive,
+    activeTurnStartedAt: isTurnActive ? at(1) : null,
+    tail: items,
+    head: [],
+    platform: "web",
+    isMobileBreakpoint: false,
+  });
+  return {
+    model,
+    layout: layoutStream({
+      strategy: resolveStreamRenderStrategy({ platform: "web", isMobileBreakpoint: false }),
+      isTurnActive,
+      history: model.segments.historyMounted,
+      liveHead: model.segments.liveHead,
+      timingByAssistantId: model.turnTiming.byAssistantId,
+    }),
+  };
+}
+
+function completedFooterIds(layout: ReturnType<typeof layoutFor>["layout"]): string[] {
+  return [
+    ...layout.history.flatMap((row) => (row.completedFooter ? [row.completedFooter.itemId] : [])),
+    ...layout.liveHead.flatMap((row) => (row.completedFooter ? [row.completedFooter.itemId] : [])),
+    ...(layout.auxiliaryTurnFooter ? [layout.auxiliaryTurnFooter.itemId] : []),
+  ];
+}
+
+describe("canonical turn membership", () => {
+  it("stops tagged traversal at every mismatching turn ID", () => {
+    expect(continuesTurn(assistant("first", 1, "turn-1"), runningTool("next", 2, "turn-2"))).toBe(
+      false,
+    );
+    expect(continuesTurn(runningTool("first", 1, "turn-1"), assistant("next", 2, "turn-1"))).toBe(
+      true,
+    );
+  });
+
+  it.each([
+    [
+      "Claude",
+      (turnId: string) => [
+        user("prompt", 1, turnId),
+        runningTool("sleep", 2, turnId),
+        user("hello", 3, turnId),
+      ],
+    ],
+    [
+      "Codex",
+      (turnId: string) => [
+        user("prompt", 1, turnId),
+        assistant("preface", 2, turnId),
+        runningTool("sleep", 3, turnId),
+        user("hello", 4, turnId),
+      ],
+    ],
+  ] as const)("keeps %s-shaped active steers in one visible turn", (_provider, build) => {
+    const turnId = "turn-1";
+    const active = layoutFor(build(turnId), true);
+
+    expect(completedFooterIds(active.layout)).toEqual([]);
+    expect(active.model.turnTiming.runningStartedAt).toEqual(at(1));
+
+    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({
+      startedAt: at(1),
+      completedAt: at(9),
+      durationMs: 8000,
+    });
+  });
+});

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

@@ -0,0 +1,26 @@
+import type { StreamItem } from "@/types/stream";
+
+/**
+ * Canonical turn IDs take precedence. Timelines without them retain the legacy
+ * user-message boundary rule so old daemons and persisted rows need no rewrite.
+ */
+export function continuesTurn(previous: StreamItem | null, next: StreamItem | null): boolean {
+  if (!previous || !next) return false;
+  if (previous.turnId !== undefined && next.turnId !== undefined) {
+    return previous.turnId === next.turnId;
+  }
+  return next.kind !== "user_message";
+}
+
+export function isTurnBoundary(previous: StreamItem | null, next: StreamItem | null): boolean {
+  return previous !== null && next !== null && !continuesTurn(previous, next);
+}
+
+/** Whether `item` begins a new chronological turn after `previous`. */
+export function startsNewTurn(item: StreamItem, previous: StreamItem | null): boolean {
+  return previous === null || isTurnBoundary(previous, item);
+}
+
+export function belongsToTurn(item: StreamItem, turnId: string | null): boolean {
+  return turnId !== null && item.turnId === turnId;
+}

packages/app/src/composer/actions.test.ts

@@ -179,6 +179,7 @@ interface FakeSendCall {
   text: string;
   options: {
     messageId: string;
+    activeTurnBehavior?: "interrupt" | "steer";
     images: Array<{ data: string; mimeType: string }>;
     attachments: AgentAttachment[];
   };
@@ -417,6 +418,50 @@ describe("pickAndPersistImages", () => {
 });
 
 describe("dispatchComposerAgentMessage", () => {
+  it("forwards the configured active-turn intent without provider capability checks", async () => {
+    const client = createFakeSendClient();
+    const stream = createFakeStream();
+
+    await dispatchComposerAgentMessage({
+      client,
+      agentId: "agent",
+      text: "steer this turn",
+      attachments: [],
+      encodeImages: async () => [],
+      submission: stream,
+      activeTurnBehavior: "steer",
+    });
+
+    expect(client.calls[0]?.options.activeTurnBehavior).toBe("steer");
+  });
+
+  it("stamps only a steer optimistic row with the daemon active turn ID", async () => {
+    const client = createFakeSendClient();
+    const stream = createFakeStream();
+    await dispatchComposerAgentMessage({
+      client,
+      agentId: "agent",
+      text: "hello",
+      attachments: [],
+      encodeImages: async () => [],
+      submission: stream,
+      activeTurnBehavior: "steer",
+      activeTurnId: "turn-1",
+    });
+    expect(stream.tail.get("agent")?.[0]).toMatchObject({ turnId: "turn-1" });
+    const legacy = createFakeStream();
+    await dispatchComposerAgentMessage({
+      client,
+      agentId: "legacy",
+      text: "hello",
+      attachments: [],
+      encodeImages: async () => [],
+      submission: legacy,
+      activeTurnBehavior: "steer",
+    });
+    expect(legacy.tail.get("legacy")?.[0]?.turnId).toBeUndefined();
+  });
+
   it("removes the submitted prompt when the host rejects it", async () => {
     const rejection = new Error("Host rejected prompt");
     const client = createFakeSendClient({ rejection });
@@ -477,6 +522,28 @@ describe("dispatchComposerAgentMessage", () => {
     ).rejects.toBe(transportError);
   });
 
+  it("surfaces an ambiguous failure even when a concurrent canonical echo was observed", async () => {
+    const transportError = new Error("Connection lost after delivery may have occurred");
+    const client = createFakeSendClient({ rejection: transportError });
+    const submission: MessageSubmissionWriter = {
+      begin: () => {},
+      accept: () => {},
+      reject: () => "accepted",
+    };
+
+    await expect(
+      dispatchComposerAgentMessage({
+        client,
+        agentId: "agent",
+        text: "ambiguous steer",
+        attachments: [],
+        encodeImages: passthroughEncodeImages,
+        submission,
+        activeTurnBehavior: "steer",
+      }),
+    ).rejects.toBe(transportError);
+  });
+
   it("sends text + image data + structured attachments and appends user_message to the tail when head is empty", async () => {
     const client = createFakeSendClient();
     const stream = createFakeStream();

packages/app/src/composer/actions.ts

@@ -1,4 +1,5 @@
 import type { ForgeSearchItem } from "@getpaseo/protocol/messages";
+import type { ActiveTurnBehavior } from "@getpaseo/protocol/messages";
 import type {
   AttachmentMetadata,
   ComposerAttachment,
@@ -48,6 +49,7 @@ export interface ComposerSendClient {
     text: string,
     options: {
       messageId: string;
+      activeTurnBehavior?: ActiveTurnBehavior;
       images: Array<{ data: string; mimeType: string }>;
       attachments: ReturnType<typeof splitComposerAttachmentsForSubmit>["attachments"];
     },
@@ -176,6 +178,8 @@ export interface DispatchComposerAgentMessageInput {
     images: AttachmentMetadata[],
   ) => Promise<Array<{ data: string; mimeType: string }> | undefined>;
   submission: MessageSubmissionWriter;
+  activeTurnBehavior?: ActiveTurnBehavior;
+  activeTurnId?: string;
 }
 
 export async function dispatchComposerAgentMessage(
@@ -191,19 +195,22 @@ export async function dispatchComposerAgentMessage(
     timestamp: new Date(),
     images: wirePayload.images,
     attachments: wirePayload.attachments,
+    ...(input.activeTurnBehavior === "steer" && input.activeTurnId
+      ? { turnId: input.activeTurnId }
+      : {}),
   });
   input.submission.begin(input.agentId, userMessage);
   try {
     const imagesData = await input.encodeImages(wirePayload.images);
     await input.client.sendAgentMessage(input.agentId, input.text, {
       messageId: clientMessageId,
+      ...(input.activeTurnBehavior ? { activeTurnBehavior: input.activeTurnBehavior } : {}),
       images: imagesData ?? [],
       attachments: wirePayload.attachments,
     });
     input.submission.accept(input.agentId, clientMessageId);
   } catch (error) {
-    const outcome = input.submission.reject(input.agentId, clientMessageId);
-    if (outcome === "accepted") return;
+    input.submission.reject(input.agentId, clientMessageId);
     throw error;
   }
 }

packages/app/src/composer/index.tsx

@@ -1324,12 +1324,6 @@ function ComposerContentImpl({
   autocompleteOnKeyPressRef.current = autocomplete.onKeyPress;
 
   // Clear send error when user edits the input
-  useEffect(() => {
-    if (sendError && userInput) {
-      setSendError(null);
-    }
-  }, [userInput, sendError]);
-
   useEffect(() => {
     setCursorIndex((current) => Math.min(current, userInput.length));
   }, [userInput.length]);
@@ -1338,7 +1332,13 @@ function ComposerContentImpl({
   const { pickFiles } = useFilePicker();
   const agentIdRef = useRef(agentId);
   const sendAgentMessageRef = useRef<
-    ((agentId: string, text: string, attachments: ComposerAttachment[]) => Promise<void>) | null
+    | ((
+        agentId: string,
+        text: string,
+        attachments: ComposerAttachment[],
+        activeTurnBehavior: "interrupt" | "steer",
+      ) => Promise<void>)
+    | null
   >(null);
   const onSubmitMessageRef = useRef(onSubmitMessage);
 
@@ -1399,9 +1399,14 @@ function ComposerContentImpl({
       if (!sendAgentMessageRef.current) {
         throw new Error(t("workspace.terminal.hostDisconnected"));
       }
-      await sendAgentMessageRef.current(agentIdRef.current, text, submitAttachments);
+      await sendAgentMessageRef.current(
+        agentIdRef.current,
+        text,
+        submitAttachments,
+        appSettings.sendBehavior === "steer" ? "steer" : "interrupt",
+      );
     },
-    [cwd, onMessageSent, t],
+    [appSettings.sendBehavior, cwd, onMessageSent, t],
   );
 
   useEffect(() => {
@@ -1413,6 +1418,7 @@ function ComposerContentImpl({
       targetAgentId: string,
       text: string,
       sendAttachments: ComposerAttachment[],
+      activeTurnBehavior: "interrupt" | "steer",
     ) => {
       if (!client) {
         throw new Error(t("workspace.terminal.hostDisconnected"));
@@ -1427,10 +1433,16 @@ function ComposerContentImpl({
         }),
         encodeImages,
         submission: createMessageSubmissionWriter(serverId),
+        activeTurnBehavior,
+        activeTurnId:
+          activeTurnBehavior === "steer"
+            ? (useSessionStore.getState().sessions[serverId]?.agents.get(targetAgentId)?.activeTurn
+                ?.turnId ?? undefined)
+            : undefined,
       });
       onAttentionPromptSend?.();
     };
-  }, [client, onAttentionPromptSend, serverId, supportsForgeSearch, t]);
+  }, [appSettings.sendBehavior, client, onAttentionPromptSend, serverId, supportsForgeSearch, t]);
 
   useEffect(() => {
     onSubmitMessageRef.current = onSubmitMessage;
@@ -2185,7 +2197,12 @@ function ComposerContentImpl({
   const messageInputAutoFocus = autoFocus && isDesktopWebBreakpoint;
   const submitLoadingPressHandler = isAgentRunning ? handleCancelAgent : undefined;
   const sendErrorNode = useMemo(
-    () => (sendError ? <Text style={styles.sendErrorText}>{sendError}</Text> : null),
+    () =>
+      sendError ? (
+        <Text accessibilityRole="alert" style={styles.sendErrorText}>
+          {sendError}
+        </Text>
+      ) : null,
     [sendError],
   );
   const githubEmptyText = githubSearchResultsQuery.isFetching

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

@@ -131,7 +131,7 @@ export interface MessageInputProps {
   isAgentRunning?: boolean;
   /** Controls what the default send action (Enter, send button, dictation) does
    *  when the agent is running. "interrupt" sends immediately, "queue" queues. */
-  defaultSendBehavior?: "interrupt" | "queue";
+  defaultSendBehavior?: "interrupt" | "steer" | "queue";
   /** Callback for queue button when agent is running */
   onQueue?: (payload: MessagePayload) => void;
   /** Optional handler used when submit button is in loading state. */
@@ -1002,7 +1002,7 @@ interface SendButtonStateInput {
   isSubmitDisabled: boolean;
   isSubmitLoading: boolean;
   onSubmitLoadingPress: (() => void) | undefined;
-  defaultSendBehavior: "interrupt" | "queue";
+  defaultSendBehavior: "interrupt" | "steer" | "queue";
   isAgentRunning: boolean;
 }
 
@@ -1052,7 +1052,7 @@ interface ResolvedMessageInputProps {
   voiceServerId: string | undefined;
   voiceAgentId: string | undefined;
   isAgentRunning: boolean;
-  defaultSendBehavior: "interrupt" | "queue";
+  defaultSendBehavior: "interrupt" | "steer" | "queue";
   onQueue: ((payload: MessagePayload) => void) | undefined;
   onSubmitLoadingPress: (() => void) | undefined;
   onKeyPressCallback: ((event: { key: string; preventDefault: () => void }) => boolean) | undefined;
@@ -1608,6 +1608,7 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       submitButtonAccessibilityLabel,
       canPressLoadingButton,
       defaultActionQueues,
+      defaultSendBehavior,
       isAgentRunning,
       t,
     });

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

@@ -10,6 +10,7 @@ const translations: Record<string, string> = {
   "composer.input.interruptAgent": "Interrupt agent",
   "composer.input.queueMessage": "Queue message",
   "composer.input.sendAndInterrupt": "Send and interrupt",
+  "composer.input.sendAndSteer": "Send and steer",
   "composer.input.sendMessage": "Send message",
   "composer.input.queue": "Queue",
   "composer.input.send": "Send",
@@ -31,6 +32,7 @@ describe("composer input labels", () => {
         submitButtonAccessibilityLabel: undefined,
         canPressLoadingButton: true,
         defaultActionQueues: false,
+        defaultSendBehavior: "interrupt",
         isAgentRunning: true,
         t,
       }),
@@ -40,6 +42,7 @@ describe("composer input labels", () => {
         submitButtonAccessibilityLabel: undefined,
         canPressLoadingButton: false,
         defaultActionQueues: true,
+        defaultSendBehavior: "queue",
         isAgentRunning: true,
         t,
       }),
@@ -49,6 +52,7 @@ describe("composer input labels", () => {
         submitButtonAccessibilityLabel: undefined,
         canPressLoadingButton: false,
         defaultActionQueues: false,
+        defaultSendBehavior: "interrupt",
         isAgentRunning: true,
         t,
       }),
@@ -58,6 +62,17 @@ describe("composer input labels", () => {
         submitButtonAccessibilityLabel: undefined,
         canPressLoadingButton: false,
         defaultActionQueues: false,
+        defaultSendBehavior: "steer",
+        isAgentRunning: true,
+        t,
+      }),
+    ).toBe("Send and steer");
+    expect(
+      resolveSubmitAccessibilityLabel({
+        submitButtonAccessibilityLabel: undefined,
+        canPressLoadingButton: false,
+        defaultActionQueues: false,
+        defaultSendBehavior: "interrupt",
         isAgentRunning: false,
         t,
       }),
@@ -70,6 +85,7 @@ describe("composer input labels", () => {
         submitButtonAccessibilityLabel: "Run now",
         canPressLoadingButton: false,
         defaultActionQueues: false,
+        defaultSendBehavior: "interrupt",
         isAgentRunning: false,
         t,
       }),

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

@@ -1,16 +1,24 @@
 import type { TFunction } from "i18next";
+import type { SendBehavior } from "@/hooks/use-settings/storage";
 
 export function resolveSubmitAccessibilityLabel(input: {
   submitButtonAccessibilityLabel: string | undefined;
   canPressLoadingButton: boolean;
   defaultActionQueues: boolean;
+  defaultSendBehavior: SendBehavior;
   isAgentRunning: boolean;
   t: TFunction;
 }): string {
   if (input.submitButtonAccessibilityLabel) return input.submitButtonAccessibilityLabel;
   if (input.canPressLoadingButton) return input.t("composer.input.interruptAgent");
   if (input.defaultActionQueues) return input.t("composer.input.queueMessage");
-  if (input.isAgentRunning) return input.t("composer.input.sendAndInterrupt");
+  if (input.isAgentRunning) {
+    return input.t(
+      input.defaultSendBehavior === "steer"
+        ? "composer.input.sendAndSteer"
+        : "composer.input.sendAndInterrupt",
+    );
+  }
   return input.t("composer.input.sendMessage");
 }
 

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

@@ -221,6 +221,29 @@ describe("composer send behavior", () => {
     expect(alternateAction.calls).toEqual(["queue"]);
   });
 
+  it("uses Enter to steer and Mod+Enter to queue when steer is selected", () => {
+    const defaultAction = actions();
+    runDefaultSendAction({
+      defaultSendBehavior: "steer",
+      isAgentRunning: true,
+      onQueue: defaultAction.onQueue,
+      handleSendMessage: defaultAction.handleSendMessage,
+      handleQueueMessage: defaultAction.handleQueueMessage,
+    });
+
+    const alternateAction = actions();
+    runAlternateSendAction({
+      defaultSendBehavior: "steer",
+      isAgentRunning: true,
+      onQueue: alternateAction.onQueue,
+      handleSendMessage: alternateAction.handleSendMessage,
+      handleQueueMessage: alternateAction.handleQueueMessage,
+    });
+
+    expect(defaultAction.calls).toEqual(["send"]);
+    expect(alternateAction.calls).toEqual(["queue"]);
+  });
+
   it("uses Enter to queue and Mod+Enter to submit when queue is selected", () => {
     const defaultAction = actions();
     runDefaultSendAction({

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

@@ -1,8 +1,9 @@
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
+import type { ActiveTurnBehavior } from "@getpaseo/protocol/messages";
 import type { MessagePayload } from "@/composer/types";
 import type { MessageInputKeyboardActionKind } from "@/keyboard/actions";
 
-export type SendBehavior = "interrupt" | "queue";
+export type SendBehavior = ActiveTurnBehavior | "queue";
 
 interface ComposerSurfaceState {
   opacity: 0 | 1;

packages/app/src/composer/submit.test.ts

@@ -184,6 +184,39 @@ describe("submitAgentInput", () => {
     expect(clearDraft).not.toHaveBeenCalled();
   });
 
+  it("restores a steered active-turn draft after an ambiguous immediate-send error", async () => {
+    const error = new Error("connection lost after delivery");
+    const setUserInput = vi.fn();
+    const setAttachments = vi.fn();
+    const setSendError = vi.fn();
+    const setIsProcessing = vi.fn();
+
+    await expect(
+      submitAgentInput({
+        message: "  steer this turn  ",
+        attachments: [{ id: "img-1" }],
+        forceSend: true,
+        isAgentRunning: true,
+        canSubmit: true,
+        queueMessage: vi.fn(),
+        submitMessage: async () => {
+          throw error;
+        },
+        clearDraft: vi.fn(),
+        setUserInput,
+        setAttachments,
+        setSendError,
+        setIsProcessing,
+      }),
+    ).resolves.toBe("failed");
+
+    expect(setUserInput).toHaveBeenNthCalledWith(1, "");
+    expect(setUserInput).toHaveBeenNthCalledWith(2, "steer this turn");
+    expect(setAttachments).toHaveBeenNthCalledWith(1, []);
+    expect(setAttachments).toHaveBeenNthCalledWith(2, [{ id: "img-1" }]);
+    expect(setSendError).toHaveBeenLastCalledWith("connection lost after delivery");
+  });
+
   it("submits when empty submit is explicitly allowed", async () => {
     const queueMessage = vi.fn();
     const submitMessage = vi.fn(async () => {});

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

@@ -35,6 +35,14 @@ function makeDeps(
 }
 
 describe("loadAppSettingsFromStorage", () => {
+  it("preserves a persisted steer send behavior", async () => {
+    const deps = makeDeps({
+      storage: createInMemoryKeyValueStorage({
+        "@paseo:app-settings": JSON.stringify({ sendBehavior: "steer" }),
+      }),
+    });
+    expect((await loadAppSettingsFromStorage(deps)).sendBehavior).toBe("steer");
+  });
   it("defaults theme to auto when storage is empty", async () => {
     const deps = makeDeps();
 

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

@@ -1,4 +1,5 @@
 import { isSyntaxThemeId, type SyntaxThemeId } from "@getpaseo/highlight";
+import type { ActiveTurnBehavior } from "@getpaseo/protocol/messages";
 import type { QueryClient } from "@tanstack/react-query";
 import type { DesktopSettings } from "@/desktop/settings/desktop-settings";
 import { parseAppLanguage, type AppLanguage } from "@/i18n/locales";
@@ -21,7 +22,7 @@ export const APP_SETTINGS_KEY = "@paseo:app-settings";
 export const APP_SETTINGS_QUERY_KEY = ["app-settings"];
 const LEGACY_SETTINGS_KEY = "@paseo:settings";
 
-export type SendBehavior = "interrupt" | "queue";
+export type SendBehavior = ActiveTurnBehavior | "queue";
 export type ReleaseChannel = "stable" | "beta";
 export type ServiceUrlBehavior = "ask" | "in-app" | "external";
 export type WorkspaceTitleSource = "title" | "branch";
@@ -92,7 +93,7 @@ const StoredAppSettingsSchema = z.strictObject({
   language: z
     .enum(["system", "ar", "en", "es", "fr", "ja", "ko", "pt-BR", "ru", "zh-CN"])
     .optional(),
-  sendBehavior: z.enum(["interrupt", "queue"]).optional(),
+  sendBehavior: z.enum(["interrupt", "steer", "queue"]).optional(),
   serviceUrlBehavior: z.enum(["ask", "in-app", "external"]).optional(),
   terminalScrollbackLines: z.union([z.number(), z.string()]).optional(),
   useLegacyTerminalRenderer: z.boolean().optional(),
@@ -296,7 +297,11 @@ function pickEnumAppSettings(stored: StoredAppSettings): Partial<AppSettings> {
   if (typeof stored.theme === "string" && VALID_THEMES.has(stored.theme)) {
     result.theme = stored.theme;
   }
-  if (stored.sendBehavior === "interrupt" || stored.sendBehavior === "queue") {
+  if (
+    stored.sendBehavior === "interrupt" ||
+    stored.sendBehavior === "steer" ||
+    stored.sendBehavior === "queue"
+  ) {
     result.sendBehavior = stored.sendBehavior;
   }
   if (

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

@@ -97,6 +97,7 @@ export const ar: TranslationResources = {
       interruptAgent: "عامل المقاطعة",
       queueMessage: "رسالة قائمة الانتظار",
       sendAndInterrupt: "إرسال ومقاطعة",
+      sendAndSteer: "إرسال وتوجيه",
       sendMessage: "أرسل رسالة",
       queue: "طابور",
       send: "يرسل",
@@ -1826,10 +1827,13 @@ export const ar: TranslationResources = {
         descriptions: {
           interrupt:
             "عند تشغيل الوكيل، يوقف Enter التشغيل. Command/Ctrl+Enter يضيف إلى قائمة الانتظار.",
+          steer:
+            "عند تشغيل الوكيل، يوجّه Enter الجولة النشطة. يضيف Command/Ctrl+Enter إلى قائمة الانتظار.",
           queue: "عند تشغيل الوكيل، يضيف Enter إلى قائمة الانتظار. Command/Ctrl+Enter يرسل.",
         },
         options: {
           interrupt: "مقاطعة",
+          steer: "توجيه",
           queue: "طابور",
         },
       },

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

@@ -94,6 +94,7 @@ export const en = {
       interruptAgent: "Interrupt agent",
       queueMessage: "Queue message",
       sendAndInterrupt: "Send and interrupt",
+      sendAndSteer: "Send and steer",
       sendMessage: "Send message",
       queue: "Queue",
       send: "Send",
@@ -1890,10 +1891,13 @@ export const en = {
         label: "Default send",
         descriptions: {
           interrupt: "When the agent is running, Enter interrupts. Command/Ctrl+Enter queues.",
+          steer:
+            "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.",
         },
         options: {
           interrupt: "Interrupt",
+          steer: "Steer",
           queue: "Queue",
         },
       },

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

@@ -97,6 +97,7 @@ export const es: TranslationResources = {
       interruptAgent: "agente de interrupción",
       queueMessage: "mensaje de cola",
       sendAndInterrupt: "Enviar e interrumpir",
+      sendAndSteer: "Enviar y orientar",
       sendMessage: "enviar mensaje",
       queue: "Cola",
       send: "Enviar",
@@ -1871,11 +1872,14 @@ export const es: TranslationResources = {
         descriptions: {
           interrupt:
             "Cuando el agente se está ejecutando, Enter interrumpe. Command/Ctrl+Enter pone en cola.",
+          steer:
+            "Cuando el agente se está ejecutando, Enter dirige el turno activo. Command/Ctrl+Enter pone en cola.",
           queue:
             "Cuando el agente se está ejecutando, Enter pone en cola. Command/Ctrl+Enter envía.",
         },
         options: {
           interrupt: "Interrumpir",
+          steer: "Dirigir",
           queue: "Cola",
         },
       },

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

@@ -99,6 +99,7 @@ export const fr: TranslationResources = {
       interruptAgent: "Agent d'interruption",
       queueMessage: "Message de file d'attente",
       sendAndInterrupt: "Envoyer et interrompre",
+      sendAndSteer: "Envoyer et guider",
       sendMessage: "Envoyer un message",
       queue: "File d'attente",
       send: "Envoyer",
@@ -1874,11 +1875,14 @@ export const fr: TranslationResources = {
         descriptions: {
           interrupt:
             "Lorsque l'agent est en cours d'exécution, Entrée interrompt. Commande/Ctrl+Entrée met en file d'attente.",
+          steer:
+            "Lorsque l’agent est en cours d’exécution, Entrée oriente le tour actif. Commande/Ctrl+Entrée met en file d’attente.",
           queue:
             "Lorsque l'agent est en cours d'exécution, Entrée met en file d'attente. Commande/Ctrl+Entrée envoie.",
         },
         options: {
           interrupt: "Interrompre",
+          steer: "Orienter",
           queue: "File d'attente",
         },
       },

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

@@ -97,6 +97,7 @@ export const ja: TranslationResources = {
       interruptAgent: "エージェントを中断",
       queueMessage: "メッセージをキューに追加",
       sendAndInterrupt: "送信して中断",
+      sendAndSteer: "送信して指示を追加",
       sendMessage: "メッセージを送信",
       queue: "キュー",
       send: "送信",
@@ -1841,10 +1842,13 @@ export const ja: TranslationResources = {
         label: "デフォルトの送信",
         descriptions: {
           interrupt: "エージェント実行中、Enterで中断します。Command/Ctrl+Enterでキューに追加。",
+          steer:
+            "エージェント実行中、Enterで現在のターンに指示を送ります。Command/Ctrl+Enterでキューに追加。",
           queue: "エージェント実行中、Enterでキューに追加します。Command/Ctrl+Enterで送信。",
         },
         options: {
           interrupt: "中断",
+          steer: "指示",
           queue: "キュー",
         },
       },

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

@@ -97,6 +97,7 @@ export const ko: TranslationResources = {
       interruptAgent: "에이전트 중단",
       queueMessage: "메시지 대기열에 추가",
       sendAndInterrupt: "보내고 중단",
+      sendAndSteer: "보내고 지시 추가",
       sendMessage: "메시지 보내기",
       queue: "대기열",
       send: "보내기",
@@ -1836,11 +1837,14 @@ export const ko: TranslationResources = {
         descriptions: {
           interrupt:
             "에이전트가 실행 중일 때 Enter는 중단합니다. Command/Ctrl+Enter는 대기열에 추가합니다.",
+          steer:
+            "에이전트가 실행 중일 때 Enter는 현재 턴에 지시합니다. Command/Ctrl+Enter는 대기열에 추가합니다.",
           queue:
             "에이전트가 실행 중일 때 Enter는 대기열에 추가합니다. Command/Ctrl+Enter는 제출합니다.",
         },
         options: {
           interrupt: "중단",
+          steer: "지시",
           queue: "대기열",
         },
       },

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

@@ -97,6 +97,7 @@ export const ptBR: TranslationResources = {
       interruptAgent: "Interromper agente",
       queueMessage: "Enfileirar mensagem",
       sendAndInterrupt: "Enviar e interromper",
+      sendAndSteer: "Enviar e orientar",
       sendMessage: "Enviar mensagem",
       queue: "Fila",
       send: "Enviar",
@@ -1856,10 +1857,13 @@ export const ptBR: TranslationResources = {
         descriptions: {
           interrupt:
             "Quando o agente está em execução, Enter interrompe. Command/Ctrl+Enter enfileira.",
+          steer:
+            "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.",
         },
         options: {
           interrupt: "Interromper",
+          steer: "Orientar",
           queue: "Fila",
         },
       },

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

@@ -97,6 +97,7 @@ export const ru: TranslationResources = {
       interruptAgent: "Агент прерываний",
       queueMessage: "Сообщение в очереди",
       sendAndInterrupt: "Отправить и прервать",
+      sendAndSteer: "Отправить и направить",
       sendMessage: "Отправить сообщение",
       queue: "Очередь",
       send: "Отправлять",
@@ -1860,10 +1861,13 @@ export const ru: TranslationResources = {
         label: "Отправка по умолчанию",
         descriptions: {
           interrupt: "Когда агент работает, Enter прерывает. Command/Ctrl+Enter ставит в очередь.",
+          steer:
+            "Когда агент работает, Enter направляет текущий ход. Command/Ctrl+Enter ставит в очередь.",
           queue: "Когда агент работает, Enter ставит в очередь. Command/Ctrl+Enter отправляет.",
         },
         options: {
           interrupt: "Прерывать",
+          steer: "Направить",
           queue: "Очередь",
         },
       },

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

@@ -97,6 +97,7 @@ export const zhCN: TranslationResources = {
       interruptAgent: "中断 Agent",
       queueMessage: "消息排队",
       sendAndInterrupt: "发送并中断",
+      sendAndSteer: "发送并引导",
       sendMessage: "发送消息",
       queue: "排队",
       send: "发送",
@@ -1804,10 +1805,12 @@ export const zhCN: TranslationResources = {
         label: "默认发送",
         descriptions: {
           interrupt: "Agent 运行时，Enter 会中断。Command/Ctrl+Enter 会排队。",
+          steer: "Agent 运行时，Enter 会引导当前回合。Command/Ctrl+Enter 会排队。",
           queue: "Agent 运行时，Enter 会排队。Command/Ctrl+Enter 会提交。",
         },
         options: {
           interrupt: "中断",
+          steer: "引导",
           queue: "排队",
         },
       },

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

@@ -278,6 +278,43 @@ describe("ReplicaCache", () => {
     });
   });
 
+  it("restores canonical turn membership without downgrading tagged rows", async () => {
+    const storage = new MemoryStorage();
+    const writer = new ReplicaCache(storage);
+    writer.setHosts([SERVER_ID]);
+    seedSession();
+    const initial: StreamItem = {
+      kind: "user_message",
+      id: "initial",
+      text: "initial",
+      timestamp: new Date(1),
+      turnId: "turn-1",
+    };
+    const hello: StreamItem = {
+      kind: "user_message",
+      id: "hello",
+      text: "hello",
+      timestamp: new Date(2),
+      turnId: "turn-1",
+      clientMessageId: "hello-client",
+      messageId: "hello-client",
+    };
+    useSessionStore
+      .getState()
+      .setAgentStreamTail(
+        SERVER_ID,
+        new Map([["agent-1", [initial, message("assistant", "done"), hello]]]),
+      );
+    await writer.flush();
+    useSessionStore.getState().clearSession(SERVER_ID);
+    const reader = new ReplicaCache(storage);
+    reader.setHosts([SERVER_ID]);
+    await reader.restore();
+    const tail =
+      useSessionStore.getState().sessions[SERVER_ID]?.agentStreamTail.get("agent-1") ?? [];
+    expect(tail.find((item) => item.id === "hello")?.turnId).toBe("turn-1");
+  });
+
   it("restores tool calls inside an authoritative cached window", async () => {
     const storage = new MemoryStorage();
     const writer = new ReplicaCache(storage);

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

@@ -31,6 +31,8 @@ const TimelinePositionSchema = z.strictObject({
 const TimelineItemBaseShape = {
   id: z.string(),
   timelineCursor: TimelinePositionSchema.optional(),
+  // COMPAT(active-turn-membership): absent on caches written before turn membership.
+  turnId: z.string().optional(),
   timestamp: IsoDateSchema,
 };
 
@@ -320,6 +322,7 @@ function timelineBase(item: StreamItem) {
   return {
     id: item.id,
     ...(item.timelineCursor ? { timelineCursor: item.timelineCursor } : {}),
+    ...(item.turnId ? { turnId: item.turnId } : {}),
     timestamp: item.timestamp.toISOString(),
   };
 }
@@ -394,6 +397,7 @@ function deserializeTimelineItem(item: StoredTimelineItem): StreamItem {
   const base = {
     id: item.id,
     ...(item.timelineCursor ? { timelineCursor: item.timelineCursor } : {}),
+    ...(item.turnId ? { turnId: item.turnId } : {}),
     timestamp: new Date(item.timestamp),
   };
   switch (item.kind) {

packages/app/src/screens/settings-screen.tsx

@@ -249,6 +249,7 @@ function selectedSidebarItemStyle({ hovered }: PressableStateCallbackType & { ho
 function getSendBehaviorOptions(t: TFunction) {
   return [
     { value: "interrupt" as const, label: t("settings.general.defaultSend.options.interrupt") },
+    { value: "steer" as const, label: t("settings.general.defaultSend.options.steer") },
     { value: "queue" as const, label: t("settings.general.defaultSend.options.queue") },
   ];
 }
@@ -340,10 +341,7 @@ function GeneralSection({
   const { t, i18n } = useTranslation();
   const activeLocale = getActiveLocale(i18n.language);
   const sendBehaviorOptions = useMemo(() => getSendBehaviorOptions(t), [t]);
-  const sendBehaviorDescriptionKey =
-    settings.sendBehavior === "interrupt"
-      ? "settings.general.defaultSend.descriptions.interrupt"
-      : "settings.general.defaultSend.descriptions.queue";
+  const sendBehaviorDescriptionKey = `settings.general.defaultSend.descriptions.${settings.sendBehavior}`;
   const selectedLanguageOption = LANGUAGE_OPTIONS.find(
     (option) => option.value === settings.language,
   );

packages/app/src/timeline/session-stream-reducers.test.ts

@@ -197,6 +197,32 @@ describe("deriveAgentStreamTurnLiveness", () => {
   });
 });
 
+describe("timeline turn membership compatibility", () => {
+  it("hydrates tagged rows while retaining legacy rows without a turn ID", () => {
+    const hydrated = hydrateStreamState([
+      {
+        event: {
+          type: "timeline",
+          provider: "claude",
+          turnId: "turn-1",
+          item: { type: "user_message", text: "prompt", clientMessageId: "prompt-id" },
+        },
+        timestamp: new Date(1000),
+      },
+      {
+        event: {
+          type: "timeline",
+          provider: "claude",
+          item: { type: "assistant_message", text: "legacy" },
+        },
+        timestamp: new Date(2000),
+      },
+    ]);
+
+    expect(hydrated.map((item) => item.turnId)).toEqual(["turn-1", undefined]);
+  });
+});
+
 describe("detached timeline windows", () => {
   it("does not apply or catch up live events while viewing an older window", () => {
     const currentTail = [makeAssistantItem("older window")];
@@ -285,8 +311,17 @@ describe("processTimelineResponse", () => {
       text: "local prompt",
       timestamp: new Date(1000),
       timelineCursor: { epoch: "epoch-1", seq: 1 },
+      turnId: "turn-1",
     });
-    const currentTail = [canonical, makeAssistantItem("existing tail", "existing-tail")];
+    const hello = createUserMessage({
+      id: "hello",
+      clientMessageId: "hello-client",
+      text: "hello",
+      timestamp: new Date(1500),
+      timelineCursor: { epoch: "epoch-1", seq: 2 },
+      turnId: "turn-1",
+    });
+    const currentTail = [canonical, makeAssistantItem("existing tail", "existing-tail"), hello];
     const currentHead = [makeAssistantItem("existing head", "existing-head")];
 
     const result = processTimelineResponse({
@@ -314,6 +349,7 @@ describe("processTimelineResponse", () => {
         ],
       },
     });
+    expect(result.tail.find((item) => item.id === "hello")?.turnId).toBe("turn-1");
 
     expect(result.commit).toBe("discard");
     expect(result.tail).toBe(currentTail);

packages/app/src/timeline/session-stream-reducers.ts

@@ -126,6 +126,7 @@ interface TimelineResponseEntry {
   sourceSeqRanges?: TimelineSeqRange[];
   collapsed?: string[];
   provider: string;
+  turnId?: string;
   item: Record<string, unknown>;
   timestamp: string;
 }
@@ -1269,6 +1270,7 @@ export function processTimelineResponse(
       type: "timeline",
       provider: entry.provider,
       item: entry.item,
+      ...(entry.turnId ? { turnId: entry.turnId } : {}),
     } as AgentStreamEventPayload,
     timestamp: new Date(entry.timestamp),
   }));

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

@@ -1,4 +1,5 @@
 import type { StreamItem } from "@/types/stream";
+import { startsNewTurn } from "@/agent-stream/turn-membership";
 
 export interface TurnTiming {
   startedAt: Date;
@@ -21,6 +22,7 @@ export function deriveStreamTurnTiming(params: {
   let currentUserAt: Date | null = null;
   let currentLastItemAt: Date | null = null;
   let currentAssistantIds: string[] = [];
+  let previousItem: StreamItem | null = null;
 
   const flushCompletedTurn = () => {
     if (!currentUserAt || !currentLastItemAt || currentAssistantIds.length === 0) {
@@ -37,20 +39,21 @@ export function deriveStreamTurnTiming(params: {
   };
 
   const visitItem = (item: StreamItem) => {
-    if (item.kind === "user_message") {
+    if (startsNewTurn(item, previousItem)) {
       flushCompletedTurn();
-      currentUserAt = item.timestamp;
+      currentUserAt = item.kind === "user_message" ? item.timestamp : null;
       currentLastItemAt = null;
       currentAssistantIds = [];
-      return;
     }
     if (!currentUserAt) {
+      previousItem = item;
       return;
     }
     currentLastItemAt = item.timestamp;
     if (item.kind === "assistant_message") {
       currentAssistantIds.push(item.id);
     }
+    previousItem = item;
   };
 
   for (const item of params.tail) {

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

@@ -22,6 +22,77 @@ import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display"
 type CanonicalToolStatus = "running" | "completed" | "failed" | "canceled";
 
 describe("user message identity", () => {
+  it("replaces provisional optimistic turn membership with canonical membership", () => {
+    const optimistic = createUserMessage({
+      clientMessageId: "hello-client",
+      text: "hello",
+      timestamp: new Date("2026-08-15T10:00:00Z"),
+      turnId: "turn-a",
+    });
+
+    const result = applyStreamEvent({
+      tail: [optimistic],
+      head: [],
+      event: {
+        type: "timeline",
+        provider: "codex",
+        turnId: "turn-b",
+        item: {
+          type: "user_message",
+          text: "hello",
+          clientMessageId: "hello-client",
+          messageId: "provider-hello",
+        },
+      },
+      timestamp: new Date("2026-08-15T10:00:01Z"),
+    });
+
+    expect(result.tail).toHaveLength(1);
+    expect(result.tail[0]).toEqual(
+      expect.objectContaining({
+        kind: "user_message",
+        clientMessageId: "hello-client",
+        messageId: "provider-hello",
+        turnId: "turn-b",
+      }),
+    );
+  });
+
+  it("clears provisional optimistic turn membership for a legacy canonical row", () => {
+    const optimistic = createUserMessage({
+      clientMessageId: "hello-client",
+      text: "hello",
+      timestamp: new Date("2026-08-15T10:00:00Z"),
+      turnId: "turn-a",
+    });
+
+    const result = applyStreamEvent({
+      tail: [optimistic],
+      head: [],
+      event: {
+        type: "timeline",
+        provider: "codex",
+        item: {
+          type: "user_message",
+          text: "hello",
+          clientMessageId: "hello-client",
+          messageId: "provider-hello",
+        },
+      },
+      timestamp: new Date("2026-08-15T10:00:01Z"),
+    });
+
+    expect(result.tail).toHaveLength(1);
+    expect(result.tail[0]).toEqual(
+      expect.objectContaining({
+        kind: "user_message",
+        clientMessageId: "hello-client",
+        messageId: "provider-hello",
+      }),
+    );
+    expect(result.tail[0]).not.toHaveProperty("turnId");
+  });
+
   it("adds provider identity without replacing local presentation", () => {
     const timestamp = new Date("2026-07-26T10:00:00.000Z");
     const local = createUserMessage({

packages/app/src/types/stream.ts

@@ -88,6 +88,7 @@ export interface UserMessageItem {
   id: string;
   clientMessageId?: string;
   messageId?: string;
+  turnId?: string;
   timelineCursor?: TimelinePosition;
   text: string;
   timestamp: Date;
@@ -99,6 +100,7 @@ export interface UserMessageInput {
   id?: string;
   clientMessageId?: string;
   messageId?: string;
+  turnId?: string;
   timelineCursor?: TimelinePosition;
   text: string;
   timestamp: Date;
@@ -116,6 +118,7 @@ export function createUserMessage(input: UserMessageInput): UserMessageItem {
     id,
     ...(input.clientMessageId ? { clientMessageId: input.clientMessageId } : {}),
     ...(input.messageId ? { messageId: input.messageId } : {}),
+    ...(input.turnId ? { turnId: input.turnId } : {}),
     ...(input.timelineCursor ? { timelineCursor: input.timelineCursor } : {}),
     text: input.text,
     timestamp: input.timestamp,
@@ -676,6 +679,7 @@ export interface AssistantMessageItem {
   kind: "assistant_message";
   id: string;
   messageId?: string;
+  turnId?: string;
   timelineCursor?: TimelinePosition;
   text: string;
   timestamp: Date;
@@ -694,6 +698,7 @@ export interface ThoughtItem {
   kind: "thought";
   id: string;
   timelineCursor?: TimelinePosition;
+  turnId?: string;
   text: string;
   timestamp: Date;
   status: ThoughtStatus;
@@ -729,6 +734,7 @@ export interface ToolCallItem {
   kind: "tool_call";
   id: string;
   timelineCursor?: TimelinePosition;
+  turnId?: string;
   timestamp: Date;
   payload: ToolCallPayload;
 }
@@ -747,6 +753,7 @@ export interface ActivityLogItem {
   kind: "activity_log";
   id: string;
   timelineCursor?: TimelinePosition;
+  turnId?: string;
   timestamp: Date;
   activityType: ActivityLogType;
   message: string;
@@ -757,6 +764,7 @@ export interface CompactionItem {
   kind: "compaction";
   id: string;
   timelineCursor?: TimelinePosition;
+  turnId?: string;
   timestamp: Date;
   status: "loading" | "completed";
   trigger?: "auto" | "manual";
@@ -779,6 +787,7 @@ export interface TodoListItem {
   kind: "todo_list";
   id: string;
   timelineCursor?: TimelinePosition;
+  turnId?: string;
   timestamp: Date;
   provider: AgentProvider;
   items: TodoEntry[];
@@ -839,6 +848,7 @@ function appendUserMessage(
   messageId?: string,
   clientMessageId?: string,
   timelineCursor?: TimelinePosition,
+  turnId?: string,
 ): StreamItem[] {
   const { chunk, hasContent } = normalizeChunk(text);
   if (!hasContent) {
@@ -851,6 +861,7 @@ function appendUserMessage(
     clientMessageId,
     messageId,
     timelineCursor,
+    turnId,
     text: chunk,
     timestamp,
   });
@@ -1414,6 +1425,7 @@ function reduceTimelineEvent(
           item.messageId,
           item.clientMessageId,
           timelineCursor,
+          event.turnId,
         ),
       );
     case "assistant_message":
@@ -1478,13 +1490,16 @@ export function reduceStreamUpdate(
   const source = options?.source ?? "live";
   switch (event.type) {
     case "timeline":
-      return reduceTimelineEvent(
-        state,
+      return applyTimelineTurnId(
+        reduceTimelineEvent(
+          state,
+          event,
+          timestamp,
+          source,
+          options?.reservedItemIds,
+          options?.timelineCursor,
+        ),
         event,
-        timestamp,
-        source,
-        options?.reservedItemIds,
-        options?.timelineCursor,
       );
     case "thread_started":
     case "turn_started":
@@ -1500,6 +1515,51 @@ export function reduceStreamUpdate(
   }
 }
 
+function applyTimelineTurnId(
+  items: StreamItem[],
+  event: Extract<AgentStreamEventPayload, { type: "timeline" }>,
+): StreamItem[] {
+  const clientMessageId =
+    event.item.type === "user_message" ? event.item.clientMessageId : undefined;
+  if (clientMessageId) {
+    return reconcileCanonicalUserTurnMembership(items, clientMessageId, event.turnId);
+  }
+
+  if (!event.turnId || items.length === 0) return items;
+  const index = items.length - 1;
+  const last = items[index];
+  if (!last || last.turnId === event.turnId) return items;
+  return [
+    ...items.slice(0, index),
+    { ...last, turnId: event.turnId } as StreamItem,
+    ...items.slice(index + 1),
+  ];
+}
+
+function reconcileCanonicalUserTurnMembership(
+  items: StreamItem[],
+  clientMessageId: string,
+  turnId: string | undefined,
+): StreamItem[] {
+  const index = items.findIndex(
+    (item) => item.kind === "user_message" && item.clientMessageId === clientMessageId,
+  );
+  const matched = items[index];
+  if (!matched || matched.kind !== "user_message" || matched.turnId === turnId) {
+    return items;
+  }
+
+  // A canonical user row is authoritative for membership. This replaces a
+  // provisional optimistic turn and clears it for daemons that do not emit IDs.
+  const next = turnId
+    ? { ...matched, turnId }
+    : (() => {
+        const { turnId: _, ...withoutTurnId } = matched;
+        return withoutTurnId;
+      })();
+  return [...items.slice(0, index), next, ...items.slice(index + 1)];
+}
+
 /**
  * Hydrate stream state from a batch of AgentManager stream events
  */
@@ -1790,6 +1850,7 @@ function applyCanonicalUserMessageEvent(params: {
       createUniqueTimelineId([...tail, ...head], "user", normalized.chunk.trim(), timestamp),
     messageId: event.item.messageId,
     clientMessageId: event.item.clientMessageId,
+    turnId: event.turnId,
     timelineCursor,
     text: normalized.chunk,
     timestamp,
@@ -1802,11 +1863,25 @@ function applyCanonicalUserMessageEvent(params: {
       insert: normalized.hasContent ? "head" : "none",
       presentation: "existing",
     });
+    const reconciledTail = canonical.clientMessageId
+      ? reconcileCanonicalUserTurnMembership(
+          reconciled.tail,
+          canonical.clientMessageId,
+          event.turnId,
+        )
+      : reconciled.tail;
+    const reconciledHead = canonical.clientMessageId
+      ? reconcileCanonicalUserTurnMembership(
+          reconciled.head,
+          canonical.clientMessageId,
+          event.turnId,
+        )
+      : reconciled.head;
     return {
-      tail: reconciled.tail,
-      head: reconciled.head,
-      changedTail: reconciled.changedTail,
-      changedHead: reconciled.changedHead,
+      tail: reconciledTail,
+      head: reconciledHead,
+      changedTail: reconciled.changedTail || reconciledTail !== reconciled.tail,
+      changedHead: reconciled.changedHead || reconciledHead !== reconciled.head,
       acknowledgedClientMessageIds:
         reconciled.location?.matched && reconciled.location.message.clientMessageId
           ? [reconciled.location.message.clientMessageId]
@@ -1814,10 +1889,17 @@ function applyCanonicalUserMessageEvent(params: {
     };
   }
   const reconciled = placeCanonicalUserMessageAtTail(flushedTail, canonical, normalized.hasContent);
+  const reconciledTail = canonical.clientMessageId
+    ? reconcileCanonicalUserTurnMembership(
+        reconciled.items,
+        canonical.clientMessageId,
+        event.turnId,
+      )
+    : reconciled.items;
   return {
-    tail: reconciled.items,
+    tail: reconciledTail,
     head: flushedHead,
-    changedTail: flushedTail !== tail || reconciled.items !== flushedTail,
+    changedTail: flushedTail !== tail || reconciledTail !== flushedTail,
     changedHead: flushedHead !== head,
     acknowledgedClientMessageIds:
       reconciled.matched && reconciled.message.clientMessageId

packages/client/src/daemon-client.ts

@@ -13,6 +13,7 @@ import {
   ShutdownRequestedStatusPayloadSchema,
   DaemonUpdateResponseSchema,
   SessionInboundMessageSchema,
+  type ActiveTurnBehavior,
   type ServerInfoStatusPayload,
 } from "@getpaseo/protocol/messages";
 import { validateWSOutboundMessage } from "@getpaseo/protocol/validation/ws-outbound";
@@ -336,6 +337,7 @@ export interface DaemonClientTrace {
 
 export interface SendMessageOptions {
   messageId?: string;
+  activeTurnBehavior?: ActiveTurnBehavior;
   images?: Array<{ data: string; mimeType: string }>;
   attachments?: SendAgentMessageRequest["attachments"];
 }
@@ -2947,6 +2949,7 @@ export class DaemonClient {
       agentId,
       text,
       ...(messageId ? { messageId } : {}),
+      ...(options?.activeTurnBehavior ? { activeTurnBehavior: options.activeTurnBehavior } : {}),
       ...(options?.images ? { images: options.images } : {}),
       ...(options?.attachments ? { attachments: options.attachments } : {}),
     });

packages/protocol/src/messages.active-turn-behavior.test.ts

@@ -0,0 +1,87 @@
+import {
+  AgentStreamEventPayloadSchema,
+  AgentTimelineEntryPayloadSchema,
+  SendAgentMessageRequestSchema,
+} from "./messages";
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+
+describe("send_agent_message_request active-turn behavior", () => {
+  it("accepts an optional steer intent while retaining interrupt compatibility", () => {
+    expect(
+      SendAgentMessageRequestSchema.parse({
+        type: "send_agent_message_request",
+        requestId: "request-1",
+        agentId: "agent-1",
+        text: "Follow this instruction",
+        activeTurnBehavior: "steer",
+      }).activeTurnBehavior,
+    ).toBe("steer");
+
+    expect(
+      SendAgentMessageRequestSchema.parse({
+        type: "send_agent_message_request",
+        requestId: "request-2",
+        agentId: "agent-1",
+        text: "Keep the old behavior",
+      }).activeTurnBehavior,
+    ).toBeUndefined();
+  });
+});
+
+describe("canonical timeline turn ID compatibility", () => {
+  it("accepts both new turn-tagged wire rows and legacy rows without IDs", () => {
+    const entry = {
+      provider: "codex" as const,
+      item: { type: "assistant_message" as const, text: "done" },
+      timestamp: "2026-01-01T00:00:00.000Z",
+      seqStart: 1,
+      seqEnd: 1,
+      sourceSeqRanges: [{ startSeq: 1, endSeq: 1 }],
+      collapsed: [],
+    };
+    expect(AgentTimelineEntryPayloadSchema.parse(entry).turnId).toBeUndefined();
+    expect(AgentTimelineEntryPayloadSchema.parse({ ...entry, turnId: "turn-1" }).turnId).toBe(
+      "turn-1",
+    );
+
+    const timeline = {
+      type: "timeline" as const,
+      provider: "codex" as const,
+      item: { type: "assistant_message" as const, text: "done" },
+    };
+    expect(AgentStreamEventPayloadSchema.parse(timeline).turnId).toBeUndefined();
+    expect(AgentStreamEventPayloadSchema.parse({ ...timeline, turnId: "turn-1" }).turnId).toBe(
+      "turn-1",
+    );
+  });
+});
+
+describe("legacy daemon send request schema compatibility", () => {
+  const LegacySendAgentMessageRequestSchema = z.object({
+    type: z.literal("send_agent_message_request"),
+    requestId: z.string(),
+    agentId: z.string(),
+    text: z.string(),
+    messageId: z.string().optional(),
+  });
+
+  it("ignores a new client's active-turn intent and retains legacy interrupt dispatch", () => {
+    const newClientRequest = SendAgentMessageRequestSchema.parse({
+      type: "send_agent_message_request",
+      requestId: "request-legacy",
+      agentId: "agent-1",
+      text: "replace the turn",
+      activeTurnBehavior: "steer",
+    });
+    const legacyRequest = LegacySendAgentMessageRequestSchema.parse(newClientRequest);
+
+    expect(legacyRequest).toEqual({
+      type: "send_agent_message_request",
+      requestId: "request-legacy",
+      agentId: "agent-1",
+      text: "replace the turn",
+    });
+    expect("activeTurnBehavior" in legacyRequest).toBe(false);
+  });
+});

packages/protocol/src/messages.ts

@@ -748,6 +748,7 @@ export const AgentStreamEventPayloadSchema = z.discriminatedUnion("type", [
     type: z.literal("timeline"),
     provider: AgentProviderSchema,
     item: AgentTimelineItemPayloadSchema,
+    turnId: z.string().optional(),
   }),
   z.object({
     type: z.literal("permission_requested"),
@@ -1138,11 +1139,15 @@ const ImageAttachmentSchema = z.object({
   mimeType: z.string(), // e.g., "image/jpeg", "image/png"
 });
 
+export const ActiveTurnBehaviorSchema = z.enum(["interrupt", "steer"]);
+export type ActiveTurnBehavior = z.infer<typeof ActiveTurnBehaviorSchema>;
+
 export const SendAgentMessageSchema = z.object({
   type: z.literal("send_agent_message"),
   agentId: z.string(),
   text: z.string(),
   messageId: z.string().optional(), // Client-provided ID for deduplication
+  activeTurnBehavior: ActiveTurnBehaviorSchema.optional(),
   images: z.array(ImageAttachmentSchema).optional(),
   attachments: AgentAttachmentsSchema,
 });
@@ -1295,6 +1300,7 @@ export const SendAgentMessageRequestSchema = z.object({
   agentId: z.string(),
   text: z.string(),
   messageId: z.string().optional(), // Client-provided ID for deduplication
+  activeTurnBehavior: ActiveTurnBehaviorSchema.optional(),
   images: z.array(ImageAttachmentSchema).optional(),
   attachments: AgentAttachmentsSchema,
 });
@@ -4035,6 +4041,7 @@ const AgentTimelineSeqRangeSchema = z.object({
 export const AgentTimelineEntryPayloadSchema = z.object({
   provider: AgentProviderSchema,
   item: AgentTimelineItemPayloadSchema,
+  turnId: z.string().optional(),
   timestamp: z.string(),
   seqStart: z.number().int().nonnegative(),
   seqEnd: z.number().int().nonnegative(),

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

@@ -438,7 +438,7 @@ describe("target coalesced behavior", () => {
       });
       session.setHistory([timelineEvent(toolCall({ status: "completed", output }))]);
 
-      await harness.manager.hydrateTimelineFromProvider(agentId);
+      await harness.manager.hydrateTimelineFromProvider(agentId, { force: true });
 
       expect(getTimelineItems(await harness.manager.getTimelineRows(agentId))).toEqual([
         expectedItem,
@@ -1209,7 +1209,7 @@ describe("target coalesced behavior", () => {
       const { agentId, session } = await createManagedSession(harness);
       session.setHistory([assistant("a1"), assistant("a2"), reasoning("r1"), reasoning("r2")]);
 
-      await harness.manager.hydrateTimelineFromProvider(agentId);
+      await harness.manager.hydrateTimelineFromProvider(agentId, { force: true });
 
       const rows = await harness.manager.getTimelineRows(agentId);
       expect(getTimelineItems(rows)).toEqual([

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

@@ -38,6 +38,7 @@ import {
   type AgentRunResult,
   type AgentSession,
   type AgentSessionConfig,
+  type SteerResult,
   type AgentStreamEvent,
   type AgentTimelineItem,
   type AgentUsage,
@@ -59,6 +60,8 @@ import type {
   AgentTimelineRow,
   AgentTimelineStore,
 } from "./agent-timeline-store-types.js";
+import { DurableTimelineBuffer, type DurableTimelineTimers } from "./durable-timeline-buffer.js";
+import { reconcileProviderHistory } from "./history-reconciliation.js";
 import {
   AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS,
   AgentStreamCoalescer,
@@ -277,10 +280,20 @@ export interface AgentManagerOptions {
   paseoToolCatalogFactory?: PaseoToolCatalogFactory;
   appendSystemPrompt?: string;
   agentStreamCoalesceWindowMs?: number;
+  durableTimelineCoalesceWindowMs?: number;
+  durableTimelineTimers?: DurableTimelineTimers;
   rescueTimeouts?: AgentManagerRescueTimeouts;
+  beforeSteerUnavailableFallback?: (input: {
+    agentId: string;
+    expectedTurnId: string;
+  }) => Promise<void>;
   logger: Logger;
 }
 
+export type ActiveTurnSteerDispatchResult =
+  | { status: "inactive" | "steered" }
+  | { status: "replaced"; iterator: AsyncGenerator<AgentStreamEvent> };
+
 export interface WaitForAgentOptions {
   signal?: AbortSignal;
   waitForActive?: boolean;
@@ -452,6 +465,12 @@ function attachManagedTurnIdentity(
       const turnId = agent.activeForegroundTurnId ?? agent.activeTurnId ?? undefined;
       return turnId ? { event: { ...event, turnId }, turnId } : { event, turnId };
     }
+    case "timeline": {
+      // Live provider items belong to the foreground turn that owns their dispatch.
+      // History deliberately keeps absent IDs so old persisted rows retain legacy grouping.
+      const turnId = agent.activeForegroundTurnId ?? agent.activeTurnId ?? undefined;
+      return turnId ? { event: { ...event, turnId }, turnId } : { event, turnId };
+    }
     default:
       return { event, turnId: undefined };
   }
@@ -496,6 +515,10 @@ interface SubscriptionRecord {
   agentId: string | null;
 }
 
+interface SteerEventBarrier {
+  events: AgentStreamEvent[];
+}
+
 const BUSY_STATUSES: Set<AgentLifecycleStatus> = new Set(["initializing", "running"]);
 const AgentIdSchema = z.guid();
 
@@ -645,11 +668,14 @@ export class AgentManager {
   private readonly providerSubagents = new ProviderSubagentStore();
   private readonly agentsAwaitingInitialSnapshotPersist = new Set<string>();
   private readonly sessionEventTails = new Map<string, Promise<void>>();
+  private readonly steerEventBarriers = new Map<string, SteerEventBarrier>();
+  private readonly foregroundMutationTails = new Map<string, Promise<void>>();
   private readonly runs = new AgentRunState();
   private readonly subscribers = new Set<SubscriptionRecord>();
   private readonly idFactory: () => string;
   private readonly registry?: AgentStorage;
   private readonly durableTimelineStore?: AgentTimelineStore;
+  private readonly durableTimelineBuffer?: DurableTimelineBuffer;
   private readonly previousStatuses = new Map<string, AgentLifecycleStatus>();
   private readonly backgroundTasks = new Set<Promise<void>>();
   private readonly agentRegistrationTasks = new Set<Promise<void>>();
@@ -666,6 +692,7 @@ export class AgentManager {
   private onWorkspaceStateMayHaveChanged?: (params: { cwd: string }) => void;
   private logger: Logger;
   private readonly rescueTimeouts: Required<AgentManagerRescueTimeouts>;
+  private readonly beforeSteerUnavailableFallback?: AgentManagerOptions["beforeSteerUnavailableFallback"];
   private acceptingAgentRegistrations = true;
 
   constructor(options: AgentManagerOptions) {
@@ -679,12 +706,14 @@ export class AgentManager {
     this.configurePaseoTools(options);
     this.appendSystemPrompt = options.appendSystemPrompt ?? "";
     this.logger = options.logger.child({ module: "agent", component: "agent-manager" });
+    this.durableTimelineBuffer = this.createDurableTimelineBuffer(options);
     this.rescueTimeouts = {
       reloadSessionCloseMs:
         options.rescueTimeouts?.reloadSessionCloseMs ?? RELOAD_SESSION_CLOSE_TIMEOUT_MS,
       interruptSessionMs:
         options.rescueTimeouts?.interruptSessionMs ?? INTERRUPT_SESSION_TIMEOUT_MS,
     };
+    this.beforeSteerUnavailableFallback = options.beforeSteerUnavailableFallback;
     this.agentStreamCoalescer = new AgentStreamCoalescer({
       windowMs: options.agentStreamCoalesceWindowMs ?? AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS,
       timers: { setTimeout, clearTimeout },
@@ -699,6 +728,20 @@ export class AgentManager {
     });
   }
 
+  private createDurableTimelineBuffer(
+    options: AgentManagerOptions,
+  ): DurableTimelineBuffer | undefined {
+    if (!this.durableTimelineStore) return undefined;
+    return new DurableTimelineBuffer(
+      this.durableTimelineStore,
+      options.durableTimelineCoalesceWindowMs ?? 25,
+      options.durableTimelineTimers ?? { setTimeout, clearTimeout },
+      (agentId, error) => {
+        this.logger.error({ err: error, agentId }, "Failed to persist queued timeline rows");
+      },
+    );
+  }
+
   private configurePaseoTools(options: AgentManagerOptions): void {
     this.paseoToolsEnabled = options.paseoToolsEnabled ?? true;
     this.paseoToolCatalogFactory = options.paseoToolCatalogFactory ?? null;
@@ -1134,6 +1177,7 @@ export class AgentManager {
       initialTitle: options.initialTitle,
       workspaceId: options.workspaceId,
       owner: options.owner,
+      historyPrimed: true,
     });
   }
 
@@ -2199,6 +2243,7 @@ export class AgentManager {
       if (options?.clientMessageId) {
         this.recordSubmittedPrompt(agent, prompt, options.clientMessageId, {
           messageId: options.clientMessageId,
+          turnId,
           providerMessageId:
             stagedSubmittedPromptEcho?.item.type === "user_message"
               ? stagedSubmittedPromptEcho.item.messageId
@@ -2347,6 +2392,169 @@ export class AgentManager {
     }
   }
 
+  async steerAgentRun(
+    agentId: string,
+    prompt: AgentPromptInput,
+    options?: AgentRunOptions,
+  ): Promise<SteerResult> {
+    const agent = this.requireSessionAgent(agentId);
+    const expectedTurnId = agent.activeForegroundTurnId;
+    if (!expectedTurnId || !this.runs.hasRun(agentId) || !agent.session.steerActiveTurn) {
+      return { status: "unavailable" };
+    }
+    const result = await this.runSteerAdmission(agent, expectedTurnId, async () => {
+      const admission = await agent.session.steerActiveTurn!(prompt, {
+        ...options,
+        expectedTurnId,
+      });
+      if (admission.status === "accepted") {
+        await this.recordAcceptedSteer(agent, prompt, options?.clientMessageId, expectedTurnId);
+      }
+      return admission;
+    });
+    // An unavailable answer is only safe to fall back from while this admission
+    // still owns the foreground. Never let an A admission replace a later B.
+    if (result.status === "unavailable" && agent.activeForegroundTurnId !== expectedTurnId) {
+      throw new Error("Active turn changed before steering could be delivered");
+    }
+    return result;
+  }
+
+  async steerOrReplaceActiveTurn(
+    agentId: string,
+    prompt: AgentPromptInput,
+    options?: AgentRunOptions,
+  ): Promise<ActiveTurnSteerDispatchResult> {
+    const agent = this.requireSessionAgent(agentId);
+    const expectedTurnId = agent.activeForegroundTurnId;
+    if (!expectedTurnId || !this.runs.hasRun(agentId)) {
+      return { status: "inactive" };
+    }
+
+    const result = agent.session.steerActiveTurn
+      ? await this.runSteerAdmission(agent, expectedTurnId, async () => {
+          const admission = await agent.session.steerActiveTurn!(prompt, {
+            ...options,
+            expectedTurnId,
+          });
+          if (admission.status === "accepted") {
+            await this.recordAcceptedSteer(agent, prompt, options?.clientMessageId, expectedTurnId);
+          }
+          return admission;
+        })
+      : { status: "unavailable" as const };
+    if (result.status === "accepted") {
+      return { status: "steered" };
+    }
+
+    await this.beforeSteerUnavailableFallback?.({ agentId, expectedTurnId });
+    this.assertSteerAdmissionOwnsForeground(agent, expectedTurnId);
+    return {
+      status: "replaced",
+      iterator: await this.replaceAdmittedForegroundTurn(agent, expectedTurnId, prompt, options),
+    };
+  }
+
+  private assertSteerAdmissionOwnsForeground(
+    agent: ActiveManagedAgent,
+    expectedTurnId: string,
+  ): void {
+    if (agent.activeForegroundTurnId !== expectedTurnId || !this.runs.hasRun(agent.id)) {
+      throw new Error("Active turn changed before steering could be delivered");
+    }
+  }
+
+  private async runSteerAdmission<T>(
+    agent: ActiveManagedAgent,
+    expectedTurnId: string,
+    operation: () => Promise<T>,
+  ): Promise<T> {
+    return this.runForegroundMutation(agent.id, async () => {
+      await this.drainSessionEvents(agent.id);
+      this.agentStreamCoalescer.flushFor(agent.id);
+      this.assertSteerAdmissionOwnsForeground(agent, expectedTurnId);
+      const barrier: SteerEventBarrier = { events: [] };
+      this.steerEventBarriers.set(agent.id, barrier);
+      try {
+        return await operation();
+      } finally {
+        if (this.steerEventBarriers.get(agent.id) === barrier) {
+          this.steerEventBarriers.delete(agent.id);
+        }
+        for (const event of barrier.events) {
+          this.enqueueSessionEvent(agent.id, event);
+        }
+        await this.drainSessionEvents(agent.id);
+      }
+    });
+  }
+
+  private async runForegroundMutation<T>(agentId: string, operation: () => Promise<T>): Promise<T> {
+    const previous = this.foregroundMutationTails.get(agentId) ?? Promise.resolve();
+    const run = previous.catch(() => undefined).then(operation);
+    const tail = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.foregroundMutationTails.set(agentId, tail);
+    try {
+      return await run;
+    } finally {
+      if (this.foregroundMutationTails.get(agentId) === tail) {
+        this.foregroundMutationTails.delete(agentId);
+      }
+    }
+  }
+
+  private async replaceAdmittedForegroundTurn(
+    agent: ActiveManagedAgent,
+    expectedTurnId: string,
+    prompt: AgentPromptInput,
+    options?: AgentRunOptions,
+  ): Promise<AsyncGenerator<AgentStreamEvent>> {
+    this.assertSteerAdmissionOwnsForeground(agent, expectedTurnId);
+    agent.pendingReplacement = true;
+    agent.lifecycle = "running";
+    this.touchUpdatedAt(agent);
+    this.emitState(agent);
+
+    try {
+      await this.cancelAgentRunBefore(agent.id, "replace");
+      return this.streamAgent(agent.id, prompt, options);
+    } catch (error) {
+      const latest = this.agents.get(agent.id);
+      if (latest) {
+        latest.pendingReplacement = false;
+      }
+      throw error;
+    }
+  }
+
+  private async recordAcceptedSteer(
+    agent: ActiveManagedAgent,
+    prompt: AgentPromptInput,
+    clientMessageId: string | undefined,
+    expectedTurnId: string,
+  ): Promise<void> {
+    if (!clientMessageId) {
+      return;
+    }
+    this.recordSubmittedPrompt(agent, prompt, clientMessageId, {
+      messageId: clientMessageId,
+      turnId: expectedTurnId,
+    });
+    if (this.durableTimelineBuffer) {
+      try {
+        await this.durableTimelineBuffer.flush(agent.id);
+      } catch (error) {
+        throw new Error("Steering was accepted but its canonical message could not be persisted", {
+          cause: error,
+        });
+      }
+    }
+    this.emitState(agent);
+  }
+
   async waitForAgentRunStart(agentId: string, options?: WaitForAgentStartOptions): Promise<void> {
     const snapshot = this.getAgent(agentId);
     if (!snapshot) {
@@ -2489,6 +2697,10 @@ export class AgentManager {
   }
 
   async cancelAgentRun(agentId: string): Promise<AgentRunCancellationResult> {
+    return this.runForegroundMutation(agentId, () => this.cancelAgentRunNow(agentId));
+  }
+
+  private async cancelAgentRunNow(agentId: string): Promise<AgentRunCancellationResult> {
     const agent = this.requireSessionAgent(agentId);
     const run =
       this.runs.getRun(agentId) ??
@@ -2651,6 +2863,7 @@ export class AgentManager {
     if (!this.durableTimelineStore) {
       return;
     }
+    await this.durableTimelineBuffer?.discard(agentId);
     await this.durableTimelineStore.deleteAgent(agentId);
   }
 
@@ -2935,7 +3148,7 @@ export class AgentManager {
       );
 
       const now = new Date();
-      const { durableTimelineHasRows } = await this.initializeAgentTimelineForRegister({
+      const { durableHistoryComplete } = await this.initializeAgentTimelineForRegister({
         agentId: resolvedAgentId,
         now,
         options,
@@ -2946,10 +3159,12 @@ export class AgentManager {
         session,
         config,
         now,
-        durableTimelineHasRows,
         options,
       });
 
+      if (managed.historyPrimed && !durableHistoryComplete) {
+        await this.commitCompleteHistorySnapshot(resolvedAgentId);
+      }
       this.assertAcceptingAgentRegistrations();
       this.agents.set(resolvedAgentId, managed);
       registered = true;
@@ -3029,7 +3244,7 @@ export class AgentManager {
           updatedAt?: Date;
         }
       | undefined;
-  }): Promise<{ durableTimelineHasRows: boolean }> {
+  }): Promise<{ durableHistoryComplete: boolean }> {
     const { agentId, now, options } = params;
     const timelineAlreadyPrimed = this.timelineStore.has(agentId);
     const explicitTimelineSeed = buildExplicitTimelineSeedForRegister(now, options);
@@ -3040,9 +3255,8 @@ export class AgentManager {
     const durableTimelineSeed = shouldSeedFromDurable
       ? await this.loadCommittedTimelineSeed(agentId, now)
       : null;
-    const durableTimelineHasRows =
-      timelineAlreadyPrimed ||
-      (durableTimelineSeed != null && (durableTimelineSeed.nextSeq ?? 1) > 1);
+    const durableHistoryComplete =
+      timelineAlreadyPrimed || durableTimelineSeed?.historyComplete === true;
     const timelineSeed = explicitTimelineSeed ?? durableTimelineSeed;
     if (timelineSeed || !this.timelineStore.has(agentId)) {
       this.timelineStore.initialize(agentId, timelineSeed ?? { timestamp: now.toISOString() });
@@ -3050,7 +3264,7 @@ export class AgentManager {
     if (options?.timelineRows?.length) {
       this.enqueueDurableTimelineBulkInsert(agentId, options.timelineRows);
     }
-    return { durableTimelineHasRows };
+    return { durableHistoryComplete };
   }
 
   private buildManagedAgentForRegister(params: {
@@ -3058,7 +3272,6 @@ export class AgentManager {
     session: AgentSession;
     config: AgentSessionConfig;
     now: Date;
-    durableTimelineHasRows: boolean;
     options:
       | {
           createdAt?: Date;
@@ -3075,7 +3288,7 @@ export class AgentManager {
         }
       | undefined;
   }): ActiveManagedAgent {
-    const { resolvedAgentId, session, config, now, durableTimelineHasRows, options } = params;
+    const { resolvedAgentId, session, config, now, options } = params;
     return {
       id: resolvedAgentId,
       provider: config.provider,
@@ -3105,7 +3318,7 @@ export class AgentManager {
         options?.persistence ?? session.describePersistence(),
         config.cwd,
       ),
-      historyPrimed: options?.historyPrimed ?? durableTimelineHasRows,
+      historyPrimed: options?.historyPrimed ?? false,
       lastUserMessageAt: options?.lastUserMessageAt ?? null,
       lastUsage: options?.lastUsage,
       lastError: options?.lastError,
@@ -3118,14 +3331,18 @@ export class AgentManager {
   private async loadCommittedTimelineSeed(
     agentId: string,
     now: Date,
-  ): Promise<SeedAgentTimelineOptions> {
+  ): Promise<SeedAgentTimelineOptions & { historyComplete?: boolean }> {
     if (!this.durableTimelineStore) {
       return { timestamp: now.toISOString() };
     }
 
+    const snapshot = await this.durableTimelineStore.getCommittedSnapshot(agentId);
+    const rows = snapshot.rows;
     return {
-      nextSeq: (await this.durableTimelineStore.getLatestCommittedSeq(agentId)) + 1,
+      rows,
+      nextSeq: rows.length > 0 ? rows[rows.length - 1]!.seq + 1 : 1,
       timestamp: now.toISOString(),
+      historyComplete: snapshot.historyComplete,
     };
   }
 
@@ -3196,6 +3413,11 @@ export class AgentManager {
       },
       "agent.manager.enqueue",
     );
+    const steerBarrier = this.steerEventBarriers.get(agentId);
+    if (steerBarrier) {
+      steerBarrier.events.push(event);
+      return;
+    }
     const pendingRun = this.runs.getPendingRun(agentId);
     if (pendingRun && !pendingRun.started) {
       pendingRun.stagedEvents.push(event);
@@ -3424,7 +3646,8 @@ export class AgentManager {
   ): Promise<void> {
     const historyEvents: Extract<AgentStreamEvent, { type: "timeline" }>[] = [];
     const providerSubagentEvents: Extract<AgentStreamEvent, { type: "provider_subagent" }>[] = [];
-    for await (const event of agent.session.streamHistory()) {
+    for await (const rawEvent of agent.session.streamHistory()) {
+      const event = limitAgentStreamEventContent(rawEvent);
       if (event.type === "timeline") {
         if (event.item.type === "user_message" && isSystemInjectedEnvelope(event.item.text)) {
           continue;
@@ -3435,11 +3658,17 @@ export class AgentManager {
       }
     }
 
+    const reconciledRows = reconcileProviderHistory(
+      this.timelineStore.getRows(agent.id),
+      historyEvents.map((event) => ({ item: event.item, timestamp: event.timestamp })),
+      { mode: "force" },
+    );
     this.agentStreamCoalescer.flushAndDiscard(agent.id);
+    await this.durableTimelineBuffer?.flush(agent.id);
     await this.deleteCommittedTimeline(agent.id);
     this.timelineStore.delete(agent.id);
-    this.timelineStore.initialize(agent.id, { timestamp: new Date().toISOString() });
-    agent.historyPrimed = true;
+    this.timelineStore.initialize(agent.id, { rows: reconciledRows });
+    agent.historyPrimed = false;
 
     for (const event of this.providerSubagents.deleteParent(agent.id)) {
       if (broadcast) {
@@ -3452,20 +3681,11 @@ export class AgentManager {
         this.dispatch({ type: "provider_subagent", event: update });
       }
     }
-    for (const event of historyEvents) {
-      const row = this.recordTimeline(
-        agent.id,
-        event.item,
-        event.timestamp ? { timestamp: event.timestamp } : undefined,
-      );
-      if (broadcast) {
-        this.dispatchStream(agent.id, event, {
-          seq: row.seq,
-          epoch: this.timelineStore.getEpoch(agent.id),
-          timestamp: row.timestamp,
-        });
-      }
+    if (broadcast) {
+      this.dispatchReconciledTimelineRows(agent, reconciledRows);
     }
+    await this.commitCompleteHistorySnapshot(agent.id);
+    agent.historyPrimed = true;
     this.touchUpdatedAt(agent);
     this.emitState(agent);
   }
@@ -3475,14 +3695,13 @@ export class AgentManager {
     broadcast: boolean | (() => boolean),
   ): Promise<void> {
     const deferredBroadcast = typeof broadcast === "function";
-    const timelineEvents: Array<{
-      event: Extract<AgentStreamEvent, { type: "timeline" }>;
-      row: AgentTimelineRow;
-    }> = [];
+    let timelineRows: AgentTimelineRow[] = [];
     const providerSubagentEvents: AgentManagerEvent[] = [];
-    agent.historyPrimed = true;
+    const historyEvents: Extract<AgentStreamEvent, { type: "timeline" }>[] = [];
+    agent.historyPrimed = false;
     try {
-      for await (const event of agent.session.streamHistory()) {
+      for await (const rawEvent of agent.session.streamHistory()) {
+        const event = limitAgentStreamEventContent(rawEvent);
         if (event.type === "provider_subagent") {
           const update = this.providerSubagents.apply(agent.id, event.provider, event.event);
           const managerEvent: AgentManagerEvent = { type: "provider_subagent", event: update };
@@ -3499,23 +3718,27 @@ export class AgentManager {
         if (event.item.type === "user_message" && isSystemInjectedEnvelope(event.item.text)) {
           continue;
         }
-        const row = this.recordTimeline(
-          agent.id,
-          event.item,
-          event.timestamp ? { timestamp: event.timestamp } : undefined,
-        );
-        if (deferredBroadcast) {
-          timelineEvents.push({ event, row });
-        } else if (broadcast) {
-          this.dispatchStream(agent.id, event, {
-            seq: row.seq,
-            epoch: this.timelineStore.getEpoch(agent.id),
-            timestamp: row.timestamp,
-          });
-        }
+        historyEvents.push(event);
       }
-    } catch {
-      // ignore history failures
+
+      const reconciledRows = reconcileProviderHistory(
+        this.timelineStore.getRows(agent.id),
+        historyEvents.map((event) => ({ item: event.item, timestamp: event.timestamp })),
+      );
+      this.timelineStore.initialize(agent.id, { rows: reconciledRows });
+      if (deferredBroadcast) {
+        timelineRows = reconciledRows;
+      } else if (broadcast) {
+        this.dispatchReconciledTimelineRows(agent, reconciledRows);
+      }
+      await this.commitCompleteHistorySnapshot(agent.id);
+      agent.historyPrimed = true;
+    } catch (error) {
+      this.logger.warn(
+        { err: error, agentId: agent.id },
+        "Failed to commit provider history snapshot",
+      );
+      throw error;
     }
 
     if (typeof broadcast !== "function" || !broadcast()) {
@@ -3524,15 +3747,42 @@ export class AgentManager {
     for (const event of providerSubagentEvents) {
       this.dispatch(event);
     }
-    for (const { event, row } of timelineEvents) {
-      this.dispatchStream(agent.id, event, {
-        seq: row.seq,
-        epoch: this.timelineStore.getEpoch(agent.id),
-        timestamp: row.timestamp,
-      });
+    this.dispatchReconciledTimelineRows(agent, timelineRows);
+  }
+
+  private dispatchReconciledTimelineRows(
+    agent: ActiveManagedAgent,
+    rows: readonly AgentTimelineRow[],
+  ): void {
+    const epoch = this.timelineStore.getEpoch(agent.id);
+    for (const row of rows) {
+      this.dispatchStream(
+        agent.id,
+        {
+          type: "timeline",
+          provider: agent.provider,
+          item: row.item,
+          ...(row.turnId ? { turnId: row.turnId } : {}),
+          timestamp: row.timestamp,
+        },
+        {
+          seq: row.seq,
+          epoch,
+          timestamp: row.timestamp,
+        },
+      );
     }
   }
 
+  private async commitCompleteHistorySnapshot(agentId: string): Promise<void> {
+    if (!this.durableTimelineStore) return;
+    await this.durableTimelineBuffer?.flush(agentId);
+    await this.durableTimelineStore.replaceCommittedSnapshot(agentId, {
+      rows: this.timelineStore.getRows(agentId),
+      historyComplete: true,
+    });
+  }
+
   private notifyForegroundTurnWaiters(agentId: string, event: AgentStreamEvent): void {
     const turnId = getAgentStreamEventTurnId(event);
     if (turnId == null) {
@@ -3812,7 +4062,7 @@ export class AgentManager {
     if (
       event.item.type === "user_message" &&
       event.item.clientMessageId &&
-      this.reconcileSubmittedPromptEcho(agent, event.item)
+      this.reconcileSubmittedPromptEcho(agent, event.item, event.turnId)
     ) {
       flags.shouldDispatchEvent = false;
       flags.shouldNotifyWaiters = false;
@@ -4045,7 +4295,7 @@ export class AgentManager {
     turnId?: string,
     options?: { providerMessageId?: string },
   ): AgentStreamEvent {
-    const row = this.recordTimeline(agentId, item, options);
+    const row = this.recordTimeline(agentId, item, { ...options, turnId });
     const event: AgentStreamEvent = {
       type: "timeline",
       item,
@@ -4077,7 +4327,7 @@ export class AgentManager {
     agent: ActiveManagedAgent,
     prompt: AgentPromptInput,
     clientMessageId: string,
-    options?: { messageId?: string; providerMessageId?: string },
+    options?: { messageId?: string; providerMessageId?: string; turnId?: string },
   ): void {
     if (this.timelineStore.getSubmittedUserMessage(agent.id, clientMessageId)) {
       return;
@@ -4090,16 +4340,25 @@ export class AgentManager {
       clientMessageId,
       ...(options?.messageId ? { messageId: options.messageId } : {}),
     };
-    this.recordAndDispatchTimelineItem(agent.id, item, agent.provider, undefined, options);
+    this.recordAndDispatchTimelineItem(agent.id, item, agent.provider, options?.turnId, options);
   }
 
   private reconcileSubmittedPromptEcho(
     agent: ActiveManagedAgent,
     item: Extract<AgentTimelineItem, { type: "user_message" }>,
+    turnId?: string,
   ): AgentTimelineRow | null {
     const { clientMessageId, messageId } = item;
     if (!clientMessageId) return null;
-    const existing = this.timelineStore.getSubmittedUserMessage(agent.id, clientMessageId);
+    let existing = this.timelineStore.getSubmittedUserMessage(agent.id, clientMessageId);
+    if (!existing) {
+      this.recordSubmittedPrompt(agent, item.text, clientMessageId, {
+        messageId: clientMessageId,
+        ...(messageId ? { providerMessageId: messageId } : {}),
+        ...(turnId ? { turnId } : {}),
+      });
+      existing = this.timelineStore.getSubmittedUserMessage(agent.id, clientMessageId);
+    }
     if (!existing || existing.item.type !== "user_message") return null;
     if (messageId) {
       const enriched = this.timelineStore.enrichSubmittedUserMessage(
@@ -4169,11 +4428,18 @@ export class AgentManager {
   private recordTimeline(
     agentId: string,
     item: AgentTimelineItem,
-    options?: { timestamp?: string; providerMessageId?: string },
+    options?: {
+      timestamp?: string;
+      providerMessageId?: string;
+      turnId?: string;
+      persist?: boolean;
+    },
   ): AgentTimelineRow {
     item = limitAgentTimelineItemContent(item);
     const row = this.timelineStore.append(agentId, item, options);
-    this.enqueueDurableTimelineAppend(agentId, row);
+    if (options?.persist !== false) {
+      this.enqueueDurableTimelineAppend(agentId, row);
+    }
     return row;
   }
 
@@ -4260,19 +4526,10 @@ export class AgentManager {
   }
 
   private enqueueDurableTimelineAppend(agentId: string, row: AgentTimelineRow): void {
-    if (!this.durableTimelineStore) {
+    if (!this.durableTimelineBuffer) {
       return;
     }
-    const task = this.durableTimelineStore
-      .bulkInsert(agentId, [row])
-      .then(() => undefined)
-      .catch((err) => {
-        this.logger.error(
-          { err, agentId, seq: row.seq, itemType: row.item.type },
-          "Failed to append timeline row to durable store",
-        );
-      });
-    this.trackBackgroundTask(task);
+    this.durableTimelineBuffer.enqueue(agentId, row);
   }
 
   private enqueueDurableTimelineBulkInsert(
@@ -4282,18 +4539,15 @@ export class AgentManager {
     if (!this.durableTimelineStore || rows.length === 0) {
       return;
     }
-    const task = this.durableTimelineStore.bulkInsert(agentId, rows).catch((err) => {
-      this.logger.error(
-        { err, agentId, rowCount: rows.length },
-        "Failed to seed durable timeline store",
-      );
-    });
-    this.trackBackgroundTask(task);
+    for (const row of rows) this.durableTimelineBuffer?.enqueue(agentId, row);
   }
 
   private enqueueDurableTimelineUpdate(agentId: string, row: AgentTimelineRow): void {
     if (!this.durableTimelineStore) return;
-    const task = this.durableTimelineStore.updateCommittedRow(agentId, row).catch((err) => {
+    const task = (async () => {
+      await this.durableTimelineBuffer?.flush(agentId);
+      await this.durableTimelineStore?.updateCommittedRow(agentId, row);
+    })().catch((err) => {
       this.logger.error(
         { err, agentId, seq: row.seq, itemType: row.item.type },
         "Failed to enrich durable timeline row",
@@ -4340,6 +4594,7 @@ export class AgentManager {
 
   private async flushTasks(options: { includeAgentRegistrations: boolean }): Promise<void> {
     this.agentStreamCoalescer.flushAll();
+    await this.durableTimelineBuffer?.flushAll();
     // Drain tasks, including tasks spawned while awaiting.
     while (
       this.backgroundTasks.size > 0 ||

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

@@ -7,7 +7,6 @@ import { AgentStorage } from "./agent-storage.js";
 import {
   formatSystemNotificationPrompt,
   isSystemInjectedEnvelope,
-  sendPromptToAgent,
   setupFinishNotification,
 } from "./agent-prompt.js";
 import type { AgentManagerEvent, ManagedAgent } from "./agent-manager.js";
@@ -245,45 +244,6 @@ test("isSystemInjectedEnvelope matches the envelope formatSystemNotificationProm
   expect(isSystemInjectedEnvelope("hello world")).toBe(false);
 });
 
-test("sendPromptToAgent forwards the client message id as run options", async () => {
-  const agent: ManagedAgent = Object.create(null);
-  Reflect.set(agent, "id", "agent-1");
-  Reflect.set(agent, "provider", "codex");
-
-  const streamAgentSpy = vi.fn(() => (async function* noop() {})());
-  const agentManager: AgentManager = Object.create(AgentManager.prototype);
-  Reflect.set(
-    agentManager,
-    "getAgent",
-    vi.fn(() => agent),
-  );
-  Reflect.set(agentManager, "tryRunOutOfBand", vi.fn().mockReturnValue(false));
-  Reflect.set(agentManager, "hasInFlightRun", vi.fn().mockReturnValue(false));
-  Reflect.set(agentManager, "streamAgent", streamAgentSpy);
-
-  const agentStorage: AgentStorage = Object.create(AgentStorage.prototype);
-  Reflect.set(
-    agentStorage,
-    "get",
-    vi.fn(async () => null),
-  );
-
-  await sendPromptToAgent({
-    agentManager,
-    agentStorage,
-    agentId: "agent-1",
-    prompt: "hello",
-    messageId: "msg-client-1",
-    runOptions: { outputSchema: { type: "object" } },
-    logger: createTestLogger(),
-  });
-
-  expect(streamAgentSpy).toHaveBeenCalledWith("agent-1", "hello", {
-    outputSchema: { type: "object" },
-    clientMessageId: "msg-client-1",
-  });
-});
-
 test("finish notifications tell the parent the child's last assistant message", async () => {
   const scenario = createFinishNotificationScenario({
     childLastAssistantMessage: "Implemented the cleanup and all checks pass.",

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

@@ -9,26 +9,77 @@ import type { AgentManager, ManagedAgent } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
 import { ensureAgentLoaded } from "./agent-loading.js";
 import { getParentAgentIdFromLabels } from "@getpaseo/protocol/agent-labels";
+import type { ActiveTurnBehavior } from "@getpaseo/protocol/messages";
 
 export type AgentUnarchiveController = Pick<AgentManager, "notifyAgentState" | "unarchiveSnapshot">;
 
 export type AgentRunController = Pick<
   AgentManager,
-  "getAgent" | "tryRunOutOfBand" | "hasInFlightRun" | "replaceAgentRun" | "streamAgent"
+  | "getAgent"
+  | "tryRunOutOfBand"
+  | "hasInFlightRun"
+  | "replaceAgentRun"
+  | "steerOrReplaceActiveTurn"
+  | "streamAgent"
 >;
 
 export interface StartAgentRunOptions {
   replaceRunning?: boolean;
+  activeTurnBehavior?: ActiveTurnBehavior;
   runOptions?: AgentRunOptions;
 }
 
+export type PromptDispatchDisposition = "out_of_band" | "steered" | "turn_started";
+
+async function steerOrReplaceActiveRun(
+  agentManager: AgentRunController,
+  agentId: string,
+  prompt: AgentPromptInput,
+  options: StartAgentRunOptions | undefined,
+): Promise<
+  | { disposition: "steered" }
+  | {
+      disposition: "turn_started";
+      iterator: AsyncGenerator<import("./agent-sdk-types.js").AgentStreamEvent>;
+    }
+  | null
+> {
+  if (options?.activeTurnBehavior !== "steer") {
+    return null;
+  }
+  const result = await agentManager.steerOrReplaceActiveTurn(agentId, prompt, options.runOptions);
+  if (result.status === "steered") {
+    return { disposition: "steered" };
+  }
+  if (result.status === "replaced") {
+    return { disposition: "turn_started", iterator: result.iterator };
+  }
+  return null;
+}
+
+async function startOrReplaceRun(
+  agentManager: AgentRunController,
+  agentId: string,
+  prompt: AgentPromptInput,
+  options: StartAgentRunOptions | undefined,
+): Promise<{
+  iterator: AsyncGenerator<import("./agent-sdk-types.js").AgentStreamEvent>;
+  replaced: boolean;
+}> {
+  const replaced = Boolean(options?.replaceRunning && agentManager.hasInFlightRun(agentId));
+  const iterator = replaced
+    ? await agentManager.replaceAgentRun(agentId, prompt, options?.runOptions)
+    : agentManager.streamAgent(agentId, prompt, options?.runOptions);
+  return { iterator, replaced };
+}
+
 export async function startAgentRun(
   agentManager: AgentRunController,
   agentId: string,
   prompt: AgentPromptInput,
   logger: Logger,
   options?: StartAgentRunOptions,
-): Promise<{ outOfBand: boolean }> {
+): Promise<{ disposition: PromptDispatchDisposition }> {
   const snapshot = agentManager.getAgent(agentId);
   logger.trace(
     {
@@ -46,19 +97,21 @@ export async function startAgentRun(
   // in-flight turn — replaceAgentRun would interrupt the running turn. The
   // intercept lives at this layer so it covers every prompt entrypoint.
   if (agentManager.tryRunOutOfBand(agentId, prompt, options?.runOptions)) {
-    return { outOfBand: true };
+    return { disposition: "out_of_band" };
   }
-  const shouldReplace = Boolean(options?.replaceRunning && agentManager.hasInFlightRun(agentId));
-  const runOptions = options?.runOptions;
-  const iterator = shouldReplace
-    ? await agentManager.replaceAgentRun(agentId, prompt, runOptions)
-    : agentManager.streamAgent(agentId, prompt, runOptions);
+  const steered = await steerOrReplaceActiveRun(agentManager, agentId, prompt, options);
+  if (steered?.disposition === "steered") {
+    return steered;
+  }
+  const { iterator, replaced } = steered
+    ? { iterator: steered.iterator, replaced: true }
+    : await startOrReplaceRun(agentManager, agentId, prompt, options);
   logger.trace(
     {
       agentId,
       provider: snapshot?.provider,
       providerSessionId: snapshot?.persistence?.sessionId ?? undefined,
-      shouldReplace,
+      shouldReplace: replaced,
     },
     "agent.session.start_stream.iterator_returned",
   );
@@ -88,7 +141,7 @@ export async function startAgentRun(
       logger.error({ err: error, agentId }, "Agent stream failed");
     }
   })();
-  return { outOfBand: false };
+  return { disposition: "turn_started" };
 }
 
 /**
@@ -130,6 +183,7 @@ export interface SendPromptToAgentParams {
   /** Prompt to dispatch to the provider (may include image blocks or wrapped text). */
   prompt: AgentPromptInput;
   messageId?: string;
+  activeTurnBehavior?: ActiveTurnBehavior;
   runOptions?: AgentRunOptions;
   /** Optional mode to set on the agent before the run starts. */
   sessionMode?: string;
@@ -176,17 +230,17 @@ export async function waitForAgentRunStartWithTimeout(
  * drift between them.
  *
  * When `unarchive` is false and the agent is archived, the call is a silent
- * no-op (returns `{ outOfBand: false }`) — the agent is not run.
+ * no-op (returns the normal turn-start disposition) — the agent is not run.
  */
 export async function sendPromptToAgent(
   params: SendPromptToAgentParams,
-): Promise<{ outOfBand: boolean }> {
+): Promise<{ disposition: PromptDispatchDisposition }> {
   const unarchive = params.unarchive ?? true;
 
   const record = await params.agentStorage.get(params.agentId);
   if (record?.archivedAt) {
     if (!unarchive) {
-      return { outOfBand: false };
+      return { disposition: "turn_started" };
     }
     await unarchiveAgentState(params.agentStorage, params.agentManager, params.agentId);
   }
@@ -207,6 +261,7 @@ export async function sendPromptToAgent(
 
   return await startAgentRun(params.agentManager, params.agentId, params.prompt, params.logger, {
     replaceRunning: true,
+    activeTurnBehavior: params.activeTurnBehavior,
     runOptions,
   });
 }
@@ -233,7 +288,7 @@ export async function startCreatedAgentInitialPrompt(
     },
   );
 
-  if (!dispatchResult.outOfBand) {
+  if (dispatchResult.disposition === "turn_started") {
     await waitForAgentRunStartWithTimeout(params.agentManager, params.agentId);
   }
 

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

@@ -214,6 +214,12 @@ export interface AgentRunOptions {
   clientMessageId?: string;
 }
 
+export type SteerResult = { status: "accepted" } | { status: "unavailable" };
+
+export interface SteerActiveTurnOptions extends AgentRunOptions {
+  expectedTurnId: string;
+}
+
 export interface AgentUsage {
   inputTokens?: number;
   cachedInputTokens?: number;
@@ -629,6 +635,7 @@ export interface AgentSession {
   readonly features?: AgentFeature[];
   run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
   startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{ turnId: string }>;
+  steerActiveTurn?(prompt: AgentPromptInput, options: SteerActiveTurnOptions): Promise<SteerResult>;
   subscribe(callback: (event: AgentStreamEvent) => void): () => void;
   streamHistory(): AsyncGenerator<AgentStreamEvent>;
   getRuntimeInfo(): Promise<AgentRuntimeInfo>;

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

@@ -4,6 +4,7 @@ export interface AgentTimelineRow {
   seq: number;
   timestamp: string;
   item: AgentTimelineItem;
+  readonly turnId?: string;
   readonly providerMessageId?: string;
 }
 
@@ -31,6 +32,12 @@ export interface AgentTimelineWindow {
   nextSeq: number;
 }
 
+/** A committed canonical transcript and whether provider history is fully represented. */
+export interface AgentTimelineSnapshot {
+  rows: AgentTimelineRow[];
+  historyComplete: boolean;
+}
+
 export interface AgentTimelineFetchResult {
   epoch: string;
   direction: AgentTimelineFetchDirection;
@@ -47,7 +54,7 @@ export interface AgentTimelineStore {
   appendCommitted(
     agentId: string,
     item: AgentTimelineItem,
-    options?: { timestamp?: string },
+    options?: { timestamp?: string; turnId?: string },
   ): Promise<AgentTimelineRow>;
   fetchCommitted(
     agentId: string,
@@ -55,9 +62,11 @@ export interface AgentTimelineStore {
   ): Promise<AgentTimelineFetchResult>;
   getLatestCommittedSeq(agentId: string): Promise<number>;
   getCommittedRows(agentId: string): Promise<AgentTimelineRow[]>;
+  getCommittedSnapshot(agentId: string): Promise<AgentTimelineSnapshot>;
   getLastItem(agentId: string): Promise<AgentTimelineItem | null>;
   getLastAssistantMessage(agentId: string): Promise<string | null>;
   deleteAgent(agentId: string): Promise<void>;
   bulkInsert(agentId: string, rows: readonly AgentTimelineRow[]): Promise<void>;
+  replaceCommittedSnapshot(agentId: string, snapshot: AgentTimelineSnapshot): Promise<void>;
   updateCommittedRow(agentId: string, row: AgentTimelineRow): Promise<void>;
 }

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

@@ -264,13 +264,14 @@ export class InMemoryAgentTimelineStore {
   append(
     agentId: string,
     item: AgentTimelineItem,
-    options?: { timestamp?: string; providerMessageId?: string },
+    options?: { timestamp?: string; providerMessageId?: string; turnId?: string },
   ): AgentTimelineRow {
     const state = this.requireState(agentId);
     const row: AgentTimelineRow = {
       seq: state.nextSeq,
       timestamp: options?.timestamp ?? new Date().toISOString(),
       item,
+      ...(options?.turnId ? { turnId: options.turnId } : {}),
       ...(options?.providerMessageId ? { providerMessageId: options.providerMessageId } : {}),
     };
     state.nextSeq += 1;

packages/server/src/server/agent/durable-timeline-buffer.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, test } from "vitest";
+
+import { DurableTimelineBuffer } from "./durable-timeline-buffer.js";
+import type {
+  AgentTimelineFetchResult,
+  AgentTimelineRow,
+  AgentTimelineSnapshot,
+  AgentTimelineStore,
+} from "./agent-timeline-store-types.js";
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+
+const row = (seq: number): AgentTimelineRow => ({
+  seq,
+  timestamp: "2026-01-01T00:00:00.000Z",
+  item: { type: "assistant_message", text: String(seq) },
+});
+
+class RecordingStore implements AgentTimelineStore {
+  readonly batches: AgentTimelineRow[][] = [];
+  failuresRemaining = 0;
+
+  async appendCommitted(): Promise<AgentTimelineRow> {
+    throw new Error("not used");
+  }
+  async fetchCommitted(): Promise<AgentTimelineFetchResult> {
+    throw new Error("not used");
+  }
+  async getLatestCommittedSeq(): Promise<number> {
+    return 0;
+  }
+  async getCommittedRows(): Promise<AgentTimelineRow[]> {
+    return [];
+  }
+  async getCommittedSnapshot(): Promise<AgentTimelineSnapshot> {
+    return { rows: [], historyComplete: false };
+  }
+  async getLastItem(): Promise<AgentTimelineItem | null> {
+    return null;
+  }
+  async getLastAssistantMessage(): Promise<string | null> {
+    return null;
+  }
+  async deleteAgent(): Promise<void> {}
+  async bulkInsert(_agentId: string, rows: readonly AgentTimelineRow[]): Promise<void> {
+    this.batches.push([...rows]);
+    if (this.failuresRemaining > 0) {
+      this.failuresRemaining -= 1;
+      throw new Error("disk full");
+    }
+  }
+  async replaceCommittedSnapshot(): Promise<void> {}
+  async updateCommittedRow(): Promise<void> {}
+}
+
+class ControlledTimers {
+  readonly delays: number[] = [];
+  private readonly callbacks = new Map<number, () => void>();
+  private nextId = 1;
+
+  setTimeout = (callback: () => void, delayMs: number): ReturnType<typeof setTimeout> => {
+    const id = this.nextId++;
+    this.delays.push(delayMs);
+    this.callbacks.set(id, callback);
+    return id as unknown as ReturnType<typeof setTimeout>;
+  };
+
+  clearTimeout = (timer: ReturnType<typeof setTimeout>): void => {
+    this.callbacks.delete(timer as unknown as number);
+  };
+
+  async runNext(): Promise<void> {
+    const next = this.callbacks.entries().next().value as [number, () => void] | undefined;
+    if (!next) throw new Error("Expected a scheduled timer");
+    this.callbacks.delete(next[0]);
+    next[1]();
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+
+  get size(): number {
+    return this.callbacks.size;
+  }
+}
+
+const timers = {
+  setTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+  clearTimeout: () => undefined,
+};
+
+describe("DurableTimelineBuffer", () => {
+  test("retries a failed prefix with later rows without a sequence hole", async () => {
+    const store = new RecordingStore();
+    store.failuresRemaining = 1;
+    const buffer = new DurableTimelineBuffer(store, 25, timers, () => undefined);
+
+    buffer.enqueue("agent", row(1));
+    await expect(buffer.flush("agent")).rejects.toThrow("disk full");
+    buffer.enqueue("agent", row(2));
+    await buffer.flush("agent");
+
+    const batchSequences = store.batches.map(batchSequencesFor);
+    expect(batchSequences).toEqual([[1], [1, 2]]);
+  });
+
+  test("coalesces a burst into one bounded atomic write and flush drains it", async () => {
+    const store = new RecordingStore();
+    const buffer = new DurableTimelineBuffer(store, 25, timers, () => undefined);
+
+    for (let seq = 1; seq <= 50; seq += 1) buffer.enqueue("agent", row(seq));
+    await buffer.flushAll();
+
+    expect(store.batches).toHaveLength(1);
+    expect(store.batches[0]?.map((entry) => entry.seq)).toEqual(
+      Array.from({ length: 50 }, (_, index) => index + 1),
+    );
+  });
+
+  test("discard drops a pending batch so a later global flush cannot resurrect it", async () => {
+    const store = new RecordingStore();
+    const buffer = new DurableTimelineBuffer(store, 25, timers, () => undefined);
+
+    buffer.enqueue("agent", row(1));
+    await buffer.discard("agent");
+    await buffer.flushAll();
+    buffer.enqueue("agent", row(1));
+    await buffer.flushAll();
+
+    expect(store.batches).toEqual([[row(1)]]);
+  });
+
+  test("retries a final failed batch without another enqueue", async () => {
+    const store = new RecordingStore();
+    store.failuresRemaining = 1;
+    const controlledTimers = new ControlledTimers();
+    const errors: unknown[] = [];
+    const buffer = new DurableTimelineBuffer(
+      store,
+      25,
+      controlledTimers,
+      (_agentId, error) => errors.push(error),
+      { baseDelayMs: 10, maxDelayMs: 40 },
+    );
+
+    buffer.enqueue("agent", row(1));
+    await controlledTimers.runNext();
+    expect(store.batches.map(batchSequencesFor)).toEqual([[1]]);
+    expect(errors).toHaveLength(1);
+    expect(controlledTimers.delays).toEqual([25, 10]);
+
+    await controlledTimers.runNext();
+    expect(store.batches.map(batchSequencesFor)).toEqual([[1], [1]]);
+    expect(controlledTimers.size).toBe(0);
+  });
+
+  test("grows retry delays to a deterministic cap", async () => {
+    const store = new RecordingStore();
+    store.failuresRemaining = 4;
+    const controlledTimers = new ControlledTimers();
+    const buffer = new DurableTimelineBuffer(store, 25, controlledTimers, () => undefined, {
+      baseDelayMs: 10,
+      maxDelayMs: 40,
+    });
+
+    buffer.enqueue("agent", row(1));
+    await controlledTimers.runNext();
+    await controlledTimers.runNext();
+    await controlledTimers.runNext();
+    await controlledTimers.runNext();
+    await controlledTimers.runNext();
+
+    expect(controlledTimers.delays).toEqual([25, 10, 20, 40, 40]);
+    expect(store.batches).toHaveLength(5);
+  });
+
+  test("joins a later enqueue behind the retained failed prefix", async () => {
+    const store = new RecordingStore();
+    store.failuresRemaining = 1;
+    const controlledTimers = new ControlledTimers();
+    const buffer = new DurableTimelineBuffer(store, 25, controlledTimers, () => undefined, {
+      baseDelayMs: 10,
+    });
+
+    buffer.enqueue("agent", row(1));
+    await controlledTimers.runNext();
+    buffer.enqueue("agent", row(2));
+    await controlledTimers.runNext();
+
+    expect(store.batches.map(batchSequencesFor)).toEqual([[1], [1, 2]]);
+  });
+
+  test("discard cancels a retry after failure", async () => {
+    const store = new RecordingStore();
+    store.failuresRemaining = 1;
+    const controlledTimers = new ControlledTimers();
+    const buffer = new DurableTimelineBuffer(store, 25, controlledTimers, () => undefined, {
+      baseDelayMs: 10,
+    });
+
+    buffer.enqueue("agent", row(1));
+    await controlledTimers.runNext();
+    await buffer.discard("agent");
+
+    expect(controlledTimers.size).toBe(0);
+    expect(store.batches.map(batchSequencesFor)).toEqual([[1]]);
+  });
+
+  test("manual flush rejects while retaining an autonomous retry", async () => {
+    const store = new RecordingStore();
+    store.failuresRemaining = 1;
+    const controlledTimers = new ControlledTimers();
+    const buffer = new DurableTimelineBuffer(store, 25, controlledTimers, () => undefined, {
+      baseDelayMs: 10,
+    });
+
+    buffer.enqueue("agent", row(1));
+    await expect(buffer.flush("agent")).rejects.toThrow("disk full");
+    expect(controlledTimers.delays).toEqual([25, 10]);
+
+    await controlledTimers.runNext();
+    expect(store.batches.map(batchSequencesFor)).toEqual([[1], [1]]);
+  });
+});
+
+function batchSequencesFor(batch: AgentTimelineRow[]): number[] {
+  return batch.map((entry) => entry.seq);
+}

packages/server/src/server/agent/durable-timeline-buffer.ts

@@ -0,0 +1,118 @@
+import type { AgentTimelineRow, AgentTimelineStore } from "./agent-timeline-store-types.js";
+
+export interface DurableTimelineTimers {
+  setTimeout(callback: () => void, delayMs: number): ReturnType<typeof setTimeout>;
+  clearTimeout(timer: ReturnType<typeof setTimeout>): void;
+}
+
+export interface DurableTimelineRetryOptions {
+  baseDelayMs?: number;
+  maxDelayMs?: number;
+}
+
+const DEFAULT_RETRY_MAX_DELAY_MS = 5_000;
+
+interface PendingAgentRows {
+  rows: AgentTimelineRow[];
+  timer: ReturnType<typeof setTimeout> | null;
+  flushing: Promise<void> | null;
+  retryAttempt: number;
+}
+
+/** Keeps each agent's durable transcript contiguous while coalescing live writes. */
+export class DurableTimelineBuffer {
+  private readonly pending = new Map<string, PendingAgentRows>();
+
+  constructor(
+    private readonly store: AgentTimelineStore,
+    private readonly delayMs: number,
+    private readonly timers: DurableTimelineTimers,
+    private readonly onError: (agentId: string, error: unknown) => void,
+    private readonly retryOptions: DurableTimelineRetryOptions = {},
+  ) {}
+
+  enqueue(agentId: string, row: AgentTimelineRow): void {
+    const state = this.stateFor(agentId);
+    state.rows.push(row);
+    this.schedule(agentId, state, this.delayMs);
+  }
+
+  async flush(agentId: string): Promise<void> {
+    const state = this.pending.get(agentId);
+    if (!state) return;
+    if (state.timer !== null) {
+      this.timers.clearTimeout(state.timer);
+      state.timer = null;
+    }
+    if (state.flushing) {
+      await state.flushing;
+      return this.flush(agentId);
+    }
+    if (state.rows.length === 0) {
+      this.pending.delete(agentId);
+      return;
+    }
+    const batch = [...state.rows];
+    state.flushing = this.store.bulkInsert(agentId, batch);
+    try {
+      await state.flushing;
+      state.rows.splice(0, batch.length);
+      state.retryAttempt = 0;
+    } catch (error) {
+      this.scheduleRetry(agentId, state);
+      throw error;
+    } finally {
+      state.flushing = null;
+      if (state.rows.length === 0 && state.timer === null) {
+        this.pending.delete(agentId);
+      } else if (state.rows.length > 0 && state.timer === null) {
+        this.schedule(agentId, state, this.delayMs);
+      }
+    }
+  }
+
+  async flushAll(): Promise<void> {
+    await Promise.all([...this.pending.keys()].map((agentId) => this.flush(agentId)));
+  }
+
+  async discard(agentId: string): Promise<void> {
+    const state = this.pending.get(agentId);
+    if (!state) return;
+    if (state.timer !== null) this.timers.clearTimeout(state.timer);
+    state.timer = null;
+    state.rows.length = 0;
+    await state.flushing?.catch(() => undefined);
+    this.pending.delete(agentId);
+  }
+
+  private stateFor(agentId: string): PendingAgentRows {
+    let state = this.pending.get(agentId);
+    if (!state) {
+      state = { rows: [], timer: null, flushing: null, retryAttempt: 0 };
+      this.pending.set(agentId, state);
+    }
+    return state;
+  }
+
+  private schedule(agentId: string, state: PendingAgentRows, delayMs: number): void {
+    if (state.timer !== null || state.rows.length === 0) return;
+    state.timer = this.timers.setTimeout(() => {
+      state.timer = null;
+      void this.flush(agentId).catch((error) => this.onError(agentId, error));
+    }, delayMs);
+    this.unref(state.timer);
+  }
+
+  private scheduleRetry(agentId: string, state: PendingAgentRows): void {
+    const baseDelayMs = this.retryOptions.baseDelayMs ?? this.delayMs;
+    const maxDelayMs = this.retryOptions.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS;
+    const delayMs = Math.min(baseDelayMs * 2 ** state.retryAttempt, maxDelayMs);
+    state.retryAttempt += 1;
+    this.schedule(agentId, state, delayMs);
+  }
+
+  private unref(timer: ReturnType<typeof setTimeout>): void {
+    const candidate = timer as unknown as { unref?: () => void };
+    candidate.unref?.();
+  }
+}

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

@@ -0,0 +1,226 @@
+import { mkdtemp, readdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { writeJsonFileAtomic } from "../atomic-file.js";
+import { createTestLogger } from "../../test-utils/test-logger.js";
+import { AgentStorage } from "./agent-storage.js";
+import { FileAgentTimelineStore } from "./file-agent-timeline-store.js";
+import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
+
+const user = (text: string) => ({ type: "user_message" as const, text });
+
+async function storeDirectory(): Promise<string> {
+  return await mkdtemp(path.join(tmpdir(), "paseo-timeline-"));
+}
+
+function filePath(directory: string, agentId: string): string {
+  return path.join(directory, `agent-${Buffer.from(agentId, "utf8").toString("base64url")}.json`);
+}
+
+function document(rows: AgentTimelineRow[], nextSeq: number) {
+  return { version: 1, epoch: "epoch-1", nextSeq, rows };
+}
+
+describe("FileAgentTimelineStore", () => {
+  it("loads a missing agent file as an empty timeline", async () => {
+    const store = new FileAgentTimelineStore(await storeDirectory());
+    expect(await store.getCommittedRows("agent")).toEqual([]);
+  });
+
+  it("loads legacy rows without turnId", async () => {
+    const directory = await storeDirectory();
+    await writeJsonFileAtomic(
+      filePath(directory, "agent"),
+      document([{ seq: 1, timestamp: "2026-01-01T00:00:00.000Z", item: user("old") }], 2),
+    );
+
+    expect(
+      (await new FileAgentTimelineStore(directory).getCommittedRows("agent"))[0]?.turnId,
+    ).toBeUndefined();
+  });
+
+  it("treats existing rows as incomplete until an atomic history snapshot commits", async () => {
+    const directory = await storeDirectory();
+    const store = new FileAgentTimelineStore(directory);
+    const row = { seq: 1, timestamp: "2026-01-01T00:00:00.000Z", item: user("old") };
+
+    await store.bulkInsert("agent", [row]);
+    expect((await store.getCommittedSnapshot("agent")).historyComplete).toBe(false);
+
+    await store.replaceCommittedSnapshot("agent", { rows: [row], historyComplete: true });
+    expect(await new FileAgentTimelineStore(directory).getCommittedSnapshot("agent")).toEqual({
+      rows: [row],
+      historyComplete: true,
+    });
+  });
+
+  it("round-trips supplied canonical rows without changing sequence or identity", async () => {
+    const directory = await storeDirectory();
+    const row: AgentTimelineRow = {
+      seq: 7,
+      timestamp: "2026-01-01T00:00:00.000Z",
+      item: { type: "user_message", text: "hello", clientMessageId: "hello-client" },
+      turnId: "turn-1",
+      providerMessageId: "provider-hello",
+    };
+
+    await new FileAgentTimelineStore(directory).bulkInsert("agent", [row]);
+    const reopened = new FileAgentTimelineStore(directory);
+    expect(await reopened.getCommittedRows("agent")).toEqual([row]);
+    expect((await reopened.fetchCommitted("agent", { limit: 0 })).window.nextSeq).toBe(8);
+  });
+
+  it("treats duplicate supplied rows as idempotent and rejects conflicting sequence reuse", async () => {
+    const directory = await storeDirectory();
+    let writeCount = 0;
+    const store = new FileAgentTimelineStore(directory, {
+      writeJson: async (file, value) => {
+        writeCount += 1;
+        await writeJsonFileAtomic(file, value);
+      },
+    });
+    const row: AgentTimelineRow = {
+      seq: 3,
+      timestamp: "2026-01-01T00:00:00.000Z",
+      item: user("hello"),
+      providerMessageId: "provider-hello",
+      turnId: "turn-1",
+    };
+
+    await store.bulkInsert("agent", [row]);
+    await store.bulkInsert("agent", [row]);
+    expect(writeCount).toBe(1);
+    await expect(store.bulkInsert("agent", [{ ...row, item: user("different") }])).rejects.toThrow(
+      "Conflicting timeline row sequence 3",
+    );
+    expect(await store.getCommittedRows("agent")).toEqual([row]);
+  });
+
+  it("serializes concurrent mutations for one agent without losing rows", async () => {
+    const store = new FileAgentTimelineStore(await storeDirectory());
+    await Promise.all([
+      store.appendCommitted("agent", user("one")),
+      store.appendCommitted("agent", user("two")),
+    ]);
+    expect((await store.getCommittedRows("agent")).map((row) => row.seq)).toEqual([1, 2]);
+  });
+
+  it("updates an existing row exactly and rejects a missing row sequence", async () => {
+    const store = new FileAgentTimelineStore(await storeDirectory());
+    await store.bulkInsert("agent", [
+      { seq: 1, timestamp: "2026-01-01T00:00:00.000Z", item: user("before") },
+    ]);
+    const replacement: AgentTimelineRow = {
+      seq: 1,
+      timestamp: "2026-01-01T00:00:01.000Z",
+      item: user("after"),
+      turnId: "turn-1",
+      providerMessageId: "provider-1",
+    };
+
+    await store.updateCommittedRow("agent", replacement);
+    expect(await store.getCommittedRows("agent")).toEqual([replacement]);
+    await expect(store.updateCommittedRow("agent", { ...replacement, seq: 2 })).rejects.toThrow(
+      "Cannot update missing timeline row sequence 2",
+    );
+  });
+
+  it("recovers an agent mutation lane after a rejected write without committing the failed row", async () => {
+    const directory = await storeDirectory();
+    let writeCount = 0;
+    const store = new FileAgentTimelineStore(directory, {
+      writeJson: async (file, value) => {
+        writeCount += 1;
+        if (writeCount === 1) throw new Error("disk full");
+        await writeJsonFileAtomic(file, value);
+      },
+    });
+
+    await expect(store.appendCommitted("agent", user("lost"))).rejects.toThrow("disk full");
+    expect(await store.getCommittedRows("agent")).toEqual([]);
+    await expect(store.appendCommitted("agent", user("saved"))).resolves.toMatchObject({ seq: 1 });
+    expect(await store.getCommittedRows("agent")).toEqual([
+      expect.objectContaining({ seq: 1, item: user("saved") }),
+    ]);
+  });
+
+  it("isolates corrupt files and failed mutation lanes to their own agent", async () => {
+    const directory = await storeDirectory();
+    await writeFile(filePath(directory, "broken"), "not json");
+    const store = new FileAgentTimelineStore(directory, {
+      writeJson: async (file, value) => {
+        if (file === filePath(directory, "failing")) throw new Error("failing agent write");
+        await writeJsonFileAtomic(file, value);
+      },
+    });
+
+    await expect(store.getCommittedRows("broken")).rejects.toThrow();
+    await expect(store.appendCommitted("valid", user("works"))).resolves.toMatchObject({ seq: 1 });
+    await expect(store.appendCommitted("failing", user("fails"))).rejects.toThrow(
+      "failing agent write",
+    );
+    await expect(store.appendCommitted("valid", user("still works"))).resolves.toMatchObject({
+      seq: 2,
+    });
+  });
+
+  it("does not serialize agent B behind a held agent A write", async () => {
+    const directory = await storeDirectory();
+    let releaseA!: () => void;
+    const aWrite = new Promise<void>((resolve) => {
+      releaseA = resolve;
+    });
+    const store = new FileAgentTimelineStore(directory, {
+      writeJson: async (file, value) => {
+        if (file === filePath(directory, "agent-a")) await aWrite;
+        await writeJsonFileAtomic(file, value);
+      },
+    });
+
+    const appendA = store.appendCommitted("agent-a", user("held"));
+    await expect(store.appendCommitted("agent-b", user("independent"))).resolves.toMatchObject({
+      seq: 1,
+    });
+    releaseA();
+    await expect(appendA).resolves.toMatchObject({ seq: 1 });
+  });
+
+  it.each([
+    {
+      name: "invalid timeline item",
+      value: document([{ seq: 1, timestamp: "now", item: { type: "not-a-timeline-item" } }], 2),
+    },
+    {
+      name: "out-of-order rows",
+      value: document(
+        [
+          { seq: 2, timestamp: "now", item: user("two") },
+          { seq: 1, timestamp: "now", item: user("one") },
+        ],
+        3,
+      ),
+    },
+    {
+      name: "next sequence at the committed maximum",
+      value: document([{ seq: 1, timestamp: "now", item: user("one") }], 1),
+    },
+  ])("rejects persisted $name", async ({ value }) => {
+    const directory = await storeDirectory();
+    await writeJsonFileAtomic(filePath(directory, "agent"), value);
+    await expect(new FileAgentTimelineStore(directory).getCommittedRows("agent")).rejects.toThrow();
+  });
+
+  it("writes outside AgentStorage discovery", async () => {
+    const root = await storeDirectory();
+    const agentStorageDirectory = path.join(root, "agents");
+    const timelineDirectory = path.join(root, "timelines");
+    const store = new FileAgentTimelineStore(timelineDirectory);
+
+    await store.appendCommitted("agent", user("hello"));
+
+    expect(await readdir(timelineDirectory)).toEqual(["agent-YWdlbnQ.json"]);
+    expect(await new AgentStorage(agentStorageDirectory, createTestLogger()).list()).toEqual([]);
+  });
+});

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

@@ -0,0 +1,274 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+
+import { writeJsonFileAtomic } from "../atomic-file.js";
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import { InMemoryAgentTimelineStore } from "./agent-timeline-store.js";
+import { AgentTimelineItemPayloadSchema } from "@getpaseo/protocol/messages";
+import type {
+  AgentTimelineFetchOptions,
+  AgentTimelineFetchResult,
+  AgentTimelineRow,
+  AgentTimelineSnapshot,
+  AgentTimelineStore,
+} from "./agent-timeline-store-types.js";
+
+const TimelineRowSchema: z.ZodType<AgentTimelineRow, unknown> = z.object({
+  seq: z.number().int().positive(),
+  timestamp: z.string(),
+  item: AgentTimelineItemPayloadSchema,
+  turnId: z.string().optional(),
+  providerMessageId: z.string().optional(),
+});
+
+const TimelineDocumentSchema = z.object({
+  version: z.literal(1),
+  epoch: z.string(),
+  nextSeq: z.number().int().positive(),
+  rows: z.array(TimelineRowSchema),
+  // Documents written before history completeness existed are intentionally incomplete.
+  historyComplete: z.boolean().optional().default(false),
+});
+
+type TimelineDocument = z.infer<typeof TimelineDocumentSchema>;
+
+export interface FileAgentTimelineStoreOptions {
+  writeJson?: (filePath: string, value: unknown) => Promise<void>;
+}
+
+function cloneRow(row: AgentTimelineRow): AgentTimelineRow {
+  return { ...row, item: structuredClone(row.item) };
+}
+
+function cloneDocument(document: TimelineDocument): TimelineDocument {
+  return { ...document, rows: document.rows.map(cloneRow) };
+}
+
+function validateDocument(value: unknown): TimelineDocument {
+  const document = TimelineDocumentSchema.parse(value);
+  let previousSeq = 0;
+  for (const row of document.rows) {
+    if (row.seq <= previousSeq) {
+      throw new Error("Timeline rows must have strictly increasing sequence numbers");
+    }
+    previousSeq = row.seq;
+  }
+  if (document.nextSeq <= previousSeq) {
+    throw new Error("Timeline nextSeq must be greater than every row sequence number");
+  }
+  return document;
+}
+
+function emptyDocument(): TimelineDocument {
+  return { version: 1, epoch: randomUUID(), nextSeq: 1, rows: [], historyComplete: false };
+}
+
+function fileNameForAgent(agentId: string): string {
+  return `agent-${Buffer.from(agentId, "utf8").toString("base64url")}.json`;
+}
+
+function selectRows(
+  document: TimelineDocument,
+  options?: AgentTimelineFetchOptions,
+): AgentTimelineFetchResult {
+  const memory = new InMemoryAgentTimelineStore();
+  memory.initialize("timeline", document);
+  return memory.fetch("timeline", options);
+}
+
+/** Durable canonical timeline rows, isolated as one atomic document per agent. */
+export class FileAgentTimelineStore implements AgentTimelineStore {
+  private readonly documents = new Map<string, TimelineDocument>();
+  private readonly loading = new Map<string, Promise<TimelineDocument>>();
+  private readonly mutationTails = new Map<string, Promise<void>>();
+  private readonly writeJson: (filePath: string, value: unknown) => Promise<void>;
+
+  constructor(
+    private readonly directory: string,
+    options?: FileAgentTimelineStoreOptions,
+  ) {
+    this.writeJson = options?.writeJson ?? writeJsonFileAtomic;
+  }
+
+  async appendCommitted(
+    agentId: string,
+    item: AgentTimelineItem,
+    options?: { timestamp?: string; turnId?: string },
+  ): Promise<AgentTimelineRow> {
+    return this.mutate(agentId, (document) => {
+      const row: AgentTimelineRow = {
+        seq: document.nextSeq,
+        timestamp: options?.timestamp ?? new Date().toISOString(),
+        item: structuredClone(item),
+        ...(options?.turnId ? { turnId: options.turnId } : {}),
+      };
+      document.rows.push(row);
+      document.nextSeq += 1;
+      return cloneRow(row);
+    });
+  }
+
+  async fetchCommitted(
+    agentId: string,
+    options?: AgentTimelineFetchOptions,
+  ): Promise<AgentTimelineFetchResult> {
+    return selectRows(await this.getDocument(agentId), options);
+  }
+
+  async getLatestCommittedSeq(agentId: string): Promise<number> {
+    return (await this.getDocument(agentId)).rows.at(-1)?.seq ?? 0;
+  }
+
+  async getCommittedRows(agentId: string): Promise<AgentTimelineRow[]> {
+    return (await this.getDocument(agentId)).rows.map(cloneRow);
+  }
+
+  async getCommittedSnapshot(agentId: string): Promise<AgentTimelineSnapshot> {
+    const document = await this.getDocument(agentId);
+    return { rows: document.rows.map(cloneRow), historyComplete: document.historyComplete };
+  }
+
+  async getLastItem(agentId: string): Promise<AgentTimelineItem | null> {
+    const item = (await this.getDocument(agentId)).rows.at(-1)?.item;
+    return item ? structuredClone(item) : null;
+  }
+
+  async getLastAssistantMessage(agentId: string): Promise<string | null> {
+    const rows = (await this.getDocument(agentId)).rows;
+    const chunks: string[] = [];
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+      const item = rows[index]!.item;
+      if (item.type !== "assistant_message") {
+        if (chunks.length > 0) break;
+        continue;
+      }
+      chunks.push(item.text);
+    }
+    return chunks.length > 0 ? chunks.toReversed().join("") : null;
+  }
+
+  async deleteAgent(agentId: string): Promise<void> {
+    await this.runMutation(agentId, async () => {
+      await fs.rm(this.filePath(agentId), { force: true });
+      this.documents.delete(agentId);
+    });
+  }
+
+  async bulkInsert(agentId: string, rows: readonly AgentTimelineRow[]): Promise<void> {
+    await this.runMutation(agentId, async () => {
+      const current = await this.getDocument(agentId);
+      const proposed = cloneDocument(current);
+      let changed = false;
+      for (const row of rows) {
+        const parsed = TimelineRowSchema.parse(row);
+        const existing = proposed.rows.find((candidate) => candidate.seq === parsed.seq);
+        if (existing) {
+          if (!isDeepStrictEqual(existing, parsed)) {
+            throw new Error(`Conflicting timeline row sequence ${parsed.seq}`);
+          }
+          continue;
+        }
+        proposed.rows.push(cloneRow(parsed));
+        changed = true;
+      }
+      if (!changed) return;
+      proposed.rows.sort((left, right) => left.seq - right.seq);
+      const maxSeq = proposed.rows.at(-1)?.seq ?? 0;
+      proposed.nextSeq = Math.max(proposed.nextSeq, maxSeq + 1);
+      validateDocument(proposed);
+      await this.writeJson(this.filePath(agentId), proposed);
+      this.documents.set(agentId, proposed);
+    });
+  }
+
+  async replaceCommittedSnapshot(agentId: string, snapshot: AgentTimelineSnapshot): Promise<void> {
+    await this.runMutation(agentId, async () => {
+      const current = await this.getDocument(agentId);
+      const rows = snapshot.rows.map((row) => cloneRow(TimelineRowSchema.parse(row)));
+      const nextSeq = (rows.at(-1)?.seq ?? 0) + 1;
+      const proposed: TimelineDocument = {
+        version: 1,
+        epoch: current.epoch,
+        nextSeq,
+        rows,
+        historyComplete: snapshot.historyComplete,
+      };
+      validateDocument(proposed);
+      await this.writeJson(this.filePath(agentId), proposed);
+      this.documents.set(agentId, proposed);
+    });
+  }
+
+  async updateCommittedRow(agentId: string, row: AgentTimelineRow): Promise<void> {
+    await this.mutate(agentId, (document) => {
+      const parsed = TimelineRowSchema.parse(row);
+      const index = document.rows.findIndex((candidate) => candidate.seq === parsed.seq);
+      if (index < 0) {
+        throw new Error(`Cannot update missing timeline row sequence ${parsed.seq}`);
+      }
+      document.rows[index] = cloneRow(parsed);
+    });
+  }
+
+  private async mutate<T>(
+    agentId: string,
+    mutation: (document: TimelineDocument) => T,
+  ): Promise<T> {
+    return this.runMutation(agentId, async () => {
+      const current = await this.getDocument(agentId);
+      const proposed = cloneDocument(current);
+      const result = mutation(proposed);
+      validateDocument(proposed);
+      await this.writeJson(this.filePath(agentId), proposed);
+      this.documents.set(agentId, proposed);
+      return result;
+    });
+  }
+
+  private async getDocument(agentId: string): Promise<TimelineDocument> {
+    const cached = this.documents.get(agentId);
+    if (cached) return cached;
+    let load = this.loading.get(agentId);
+    if (!load) {
+      load = this.loadDocument(agentId);
+      this.loading.set(agentId, load);
+    }
+    try {
+      const document = await load;
+      this.documents.set(agentId, document);
+      return document;
+    } finally {
+      if (this.loading.get(agentId) === load) this.loading.delete(agentId);
+    }
+  }
+
+  private async loadDocument(agentId: string): Promise<TimelineDocument> {
+    try {
+      return validateDocument(JSON.parse(await fs.readFile(this.filePath(agentId), "utf8")));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return emptyDocument();
+      throw error;
+    }
+  }
+
+  private async runMutation<T>(agentId: string, operation: () => Promise<T>): Promise<T> {
+    const previous = this.mutationTails.get(agentId) ?? Promise.resolve();
+    const result = previous.catch(() => undefined).then(operation);
+    const tail = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.mutationTails.set(agentId, tail);
+    void tail.finally(() => {
+      if (this.mutationTails.get(agentId) === tail) this.mutationTails.delete(agentId);
+    });
+    return result;
+  }
+
+  private filePath(agentId: string): string {
+    return path.join(this.directory, fileNameForAgent(agentId));
+  }
+}

packages/server/src/server/agent/history-reconciliation.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test } from "vitest";
+
+import { reconcileProviderHistory } from "./history-reconciliation.js";
+
+const user = (text: string, id?: string) => ({
+  type: "user_message" as const,
+  text,
+  ...(id ? { clientMessageId: id } : {}),
+});
+
+describe("reconcileProviderHistory", () => {
+  test("puts missing provider prefix before a newer durable suffix while preserving suffix metadata", () => {
+    const rows = reconcileProviderHistory(
+      [
+        {
+          seq: 2,
+          timestamp: "2026-01-02T00:00:00.000Z",
+          item: user("suffix", "suffix"),
+          turnId: "turn-1",
+          providerMessageId: "p-suffix",
+        },
+      ],
+      [
+        { item: user("prefix"), timestamp: "2026-01-01T00:00:00.000Z" },
+        { item: user("suffix"), timestamp: "2026-01-02T00:00:00.000Z" },
+      ],
+    );
+    expect(rows).toMatchObject([
+      { seq: 1, item: { text: "prefix" } },
+      {
+        seq: 2,
+        turnId: "turn-1",
+        providerMessageId: "p-suffix",
+        item: { text: "suffix", clientMessageId: "suffix" },
+      },
+    ]);
+  });
+
+  test("pairs repeated identical user text by ordered occurrence", () => {
+    const rows = reconcileProviderHistory(
+      [
+        {
+          seq: 1,
+          timestamp: "2026-01-01T00:00:00.000Z",
+          item: user("same", "one"),
+          turnId: "turn-1",
+        },
+        {
+          seq: 2,
+          timestamp: "2026-01-02T00:00:00.000Z",
+          item: user("same", "two"),
+          turnId: "turn-2",
+        },
+      ],
+      [{ item: user("same") }, { item: user("same") }],
+    );
+    expect(
+      rows.map((row) => [
+        row.item.type === "user_message" ? row.item.clientMessageId : null,
+        row.turnId,
+      ]),
+    ).toEqual([
+      ["one", "turn-1"],
+      ["two", "turn-2"],
+    ]);
+  });
+
+  test("retains a canonical suffix when provider history is lagging", () => {
+    const rows = reconcileProviderHistory(
+      [
+        {
+          seq: 1,
+          timestamp: "2026-01-01T00:00:00.000Z",
+          item: user("initial", "initial"),
+          turnId: "turn-1",
+        },
+        {
+          seq: 2,
+          timestamp: "2026-01-02T00:00:00.000Z",
+          item: user("hello", "hello"),
+          turnId: "turn-1",
+        },
+      ],
+      [{ item: user("initial") }],
+    );
+
+    expect(rows).toMatchObject([
+      { seq: 1, item: { text: "initial", clientMessageId: "initial" }, turnId: "turn-1" },
+      { seq: 2, item: { text: "hello", clientMessageId: "hello" }, turnId: "turn-1" },
+    ]);
+  });
+
+  test("does not transfer provider identity between ambiguous repeated prompts", () => {
+    const rows = reconcileProviderHistory(
+      [
+        {
+          seq: 1,
+          timestamp: "2026-01-01T00:00:00.000Z",
+          item: user("same", "one"),
+          turnId: "turn-1",
+        },
+        {
+          seq: 2,
+          timestamp: "2026-01-02T00:00:00.000Z",
+          item: user("same", "two"),
+          turnId: "turn-2",
+        },
+      ],
+      [{ item: { type: "user_message", text: "same", messageId: "provider-two" } }],
+    );
+
+    expect(rows).toMatchObject([
+      { item: { clientMessageId: "one" }, turnId: "turn-1" },
+      { item: { clientMessageId: "two" }, turnId: "turn-2" },
+    ]);
+    expect(rows.some((row) => row.providerMessageId === "provider-two")).toBe(false);
+  });
+
+  test("does not invent turn membership for provider-only rows", () => {
+    expect(
+      reconcileProviderHistory([], [{ item: { type: "assistant_message", text: "provider" } }])[0]
+        ?.turnId,
+    ).toBeUndefined();
+  });
+
+  test("clears unmatched rows for an authoritative forced history", () => {
+    expect(
+      reconcileProviderHistory(
+        [{ seq: 1, timestamp: "now", item: user("old", "old"), turnId: "turn-1" }],
+        [],
+        { mode: "force" },
+      ),
+    ).toEqual([]);
+  });
+});

packages/server/src/server/agent/history-reconciliation.ts

@@ -0,0 +1,157 @@
+import { isDeepStrictEqual } from "node:util";
+
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
+
+export interface ProviderHistoryTimelineEntry {
+  item: AgentTimelineItem;
+  timestamp?: string;
+}
+
+/** Reconciles canonical metadata onto provider-ordered history without inventing membership. */
+export function reconcileProviderHistory(
+  canonicalRows: readonly AgentTimelineRow[],
+  providerEntries: readonly ProviderHistoryTimelineEntry[],
+  options?: { mode?: "incomplete" | "force" },
+): AgentTimelineRow[] {
+  if (providerEntries.length === 0) {
+    return options?.mode === "force"
+      ? []
+      : canonicalRows.map((row, index) => ({ ...row, seq: index + 1 }));
+  }
+  const remaining = canonicalRows.map((row, canonicalIndex) => ({
+    row,
+    canonicalIndex,
+    used: false,
+  }));
+  const structuralCounts = countStructuralOccurrences(canonicalRows, providerEntries);
+  const providerRows = providerEntries.map((entry) => {
+    const match = takeMatch(remaining, entry.item, structuralCounts);
+    return { entry, match };
+  });
+  const rows: AgentTimelineRow[] = [];
+  const emittedCanonicalIndexes = new Set<number>();
+
+  for (const { entry, match } of providerRows) {
+    if (match) {
+      for (const candidate of remaining) {
+        if (candidate.canonicalIndex >= match.canonicalIndex) break;
+        if (!emittedCanonicalIndexes.has(candidate.canonicalIndex)) {
+          rows.push({ ...candidate.row });
+          emittedCanonicalIndexes.add(candidate.canonicalIndex);
+        }
+      }
+      rows.push(
+        match.transferProviderIdentity ? mergeMatchedRow(match.row, entry) : { ...match.row },
+      );
+      emittedCanonicalIndexes.add(match.canonicalIndex);
+      continue;
+    }
+    rows.push({
+      seq: 0,
+      timestamp: entry.timestamp ?? new Date(0).toISOString(),
+      item: entry.item,
+    });
+  }
+
+  if (options?.mode !== "force") {
+    for (const candidate of remaining) {
+      if (!emittedCanonicalIndexes.has(candidate.canonicalIndex)) {
+        rows.push({ ...candidate.row });
+      }
+    }
+  }
+  rows.forEach((row, index) => {
+    row.seq = index + 1;
+  });
+  return rows;
+}
+
+function takeMatch(
+  remaining: Array<{ row: AgentTimelineRow; canonicalIndex: number; used: boolean }>,
+  provider: AgentTimelineItem,
+  structuralCounts: Map<string, { canonical: number; provider: number }>,
+): { row: AgentTimelineRow; canonicalIndex: number; transferProviderIdentity: boolean } | null {
+  const strong = remaining.find(
+    (candidate) => !candidate.used && hasSharedIdentity(candidate.row, provider),
+  );
+  const structural =
+    strong ??
+    remaining.find(
+      (candidate) => !candidate.used && structurallyMatches(candidate.row.item, provider),
+    );
+  if (!structural) return null;
+  structural.used = true;
+  const key = structuralKey(provider);
+  const counts = structuralCounts.get(key);
+  return {
+    row: structural.row,
+    canonicalIndex: structural.canonicalIndex,
+    transferProviderIdentity:
+      strong !== undefined || (counts?.canonical === 1 && counts.provider === 1),
+  };
+}
+
+function mergeMatchedRow(
+  canonical: AgentTimelineRow,
+  provider: ProviderHistoryTimelineEntry,
+): AgentTimelineRow {
+  return {
+    ...canonical,
+    item: mergeCanonicalIdentity(canonical.item, provider.item),
+  };
+}
+
+function countStructuralOccurrences(
+  canonicalRows: readonly AgentTimelineRow[],
+  providerEntries: readonly ProviderHistoryTimelineEntry[],
+): Map<string, { canonical: number; provider: number }> {
+  const counts = new Map<string, { canonical: number; provider: number }>();
+  for (const row of canonicalRows) {
+    const key = structuralKey(row.item);
+    const count = counts.get(key) ?? { canonical: 0, provider: 0 };
+    count.canonical += 1;
+    counts.set(key, count);
+  }
+  for (const entry of providerEntries) {
+    const key = structuralKey(entry.item);
+    const count = counts.get(key) ?? { canonical: 0, provider: 0 };
+    count.provider += 1;
+    counts.set(key, count);
+  }
+  return counts;
+}
+
+function structuralKey(item: AgentTimelineItem): string {
+  return item.type === "user_message"
+    ? `user:${item.text}`
+    : `${item.type}:${JSON.stringify(item)}`;
+}
+
+function hasSharedIdentity(row: AgentTimelineRow, provider: AgentTimelineItem): boolean {
+  if (row.item.type !== "user_message" || provider.type !== "user_message") return false;
+  const identities = [row.item.clientMessageId, row.item.messageId, row.providerMessageId].filter(
+    Boolean,
+  );
+  return identities.some(
+    (identity) => identity === provider.clientMessageId || identity === provider.messageId,
+  );
+}
+
+function structurallyMatches(left: AgentTimelineItem, right: AgentTimelineItem): boolean {
+  if (left.type === "user_message" && right.type === "user_message")
+    return left.text === right.text;
+  return isDeepStrictEqual(left, right);
+}
+
+function mergeCanonicalIdentity(
+  canonical: AgentTimelineItem,
+  provider: AgentTimelineItem,
+): AgentTimelineItem {
+  if (canonical.type !== "user_message" || provider.type !== "user_message") return provider;
+  return {
+    ...provider,
+    ...(canonical.clientMessageId ? { clientMessageId: canonical.clientMessageId } : {}),
+    ...(canonical.messageId ? { messageId: canonical.messageId } : {}),
+  };
+}

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

@@ -829,6 +829,54 @@ describe("ClaudeAgentSession features", () => {
     await session.close();
   });
 
+  test("pushes a steer into the exact active Claude query without starting another turn", async () => {
+    const { queryFactory } = createQueryMock();
+    const client = new ClaudeAgentClient({
+      logger,
+      queryFactory,
+      resolveBinary: async () => "/test/claude/bin",
+    });
+    const session = await client.createSession({ provider: "claude", cwd: process.cwd() });
+    const events: AgentStreamEvent[] = [];
+    const unsubscribe = session.subscribe((event) => events.push(event));
+    try {
+      const { turnId } = await session.startTurn("first turn");
+      const input = queryFactory.mock.calls[0]?.[0].prompt as AsyncIterable<SDKUserMessage>;
+      const iterator = input[Symbol.asyncIterator]();
+      await expect(iterator.next()).resolves.toMatchObject({ value: { type: "user" } });
+
+      await expect(
+        session.steerActiveTurn?.("same turn follow-up", {
+          expectedTurnId: turnId,
+          clientMessageId: "steer-client-id",
+        }),
+      ).resolves.toEqual({ status: "accepted" });
+      await expect(iterator.next()).resolves.toMatchObject({
+        value: {
+          type: "user",
+          priority: "next",
+          message: { content: [{ type: "text", text: "same turn follow-up" }] },
+        },
+      });
+      expect(events.filter((event) => event.type === "turn_started")).toHaveLength(1);
+
+      await expect(
+        session.steerActiveTurn?.("/rewind submitted-message-id", { expectedTurnId: turnId }),
+      ).resolves.toEqual({ status: "unavailable" });
+      let rewindReachedLiveInput = false;
+      void iterator.next().then(() => {
+        rewindReachedLiveInput = true;
+        return undefined;
+      });
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(rewindReachedLiveInput).toBe(false);
+    } finally {
+      unsubscribe();
+      await session.close();
+    }
+  });
+
   test.each([
     ["supported model", "claude-opus-4-8", { type: "disabled" }, undefined],
     ["unsupported model", "claude-fable-5", { type: "adaptive" }, "high"],

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

@@ -110,6 +110,8 @@ import {
   type AgentSession,
   type AgentSessionConfig,
   type AgentSlashCommand,
+  type SteerActiveTurnOptions,
+  type SteerResult,
   type AgentStreamEvent,
   type AgentTimelineItem,
   type AgentUsage,
@@ -2021,6 +2023,9 @@ class ClaudeAgentSession implements AgentSession {
   private query: Query | null = null;
   private childProcess: ChildProcess | null = null;
   private input: AsyncMessageInput<SDKUserMessage> | null = null;
+  /** The exact SDK query/input pair that owns the current foreground turn. */
+  private activeForegroundQuery: Query | null = null;
+  private activeForegroundInput: AsyncMessageInput<SDKUserMessage> | null = null;
   private claudeSessionId: string | null;
   private persistence: AgentPersistenceHandle | null;
   private currentMode: PermissionMode;
@@ -2236,6 +2241,8 @@ class ClaudeAgentSession implements AgentSession {
       if (!this.input) {
         throw new Error("Claude session input stream not initialized");
       }
+      this.activeForegroundQuery = this.query;
+      this.activeForegroundInput = this.input;
       this.startQueryPump();
       this.input.push(sdkMessage);
       setTimeout(() => {
@@ -2252,6 +2259,39 @@ class ClaudeAgentSession implements AgentSession {
     return { turnId };
   }
 
+  async steerActiveTurn(
+    prompt: AgentPromptInput,
+    options: SteerActiveTurnOptions,
+  ): Promise<SteerResult> {
+    if (this.resolveSlashCommandInvocation(prompt)) {
+      return { status: "unavailable" };
+    }
+    if (this.compacting || this.activeForegroundTurnId !== options.expectedTurnId) {
+      return { status: "unavailable" };
+    }
+
+    // Capture both ends of the live SDK stream before creating or delivering the message. There
+    // is deliberately no await below: a finished A cannot make this input point at a later B.
+    const query = this.activeForegroundQuery;
+    const input = this.activeForegroundInput;
+    if (!query || !input || this.query !== query || this.input !== input) {
+      return { status: "unavailable" };
+    }
+    const message = this.toSdkUserMessage(prompt);
+    message.priority = "next";
+    if (
+      this.activeForegroundTurnId !== options.expectedTurnId ||
+      this.activeForegroundQuery !== query ||
+      this.activeForegroundInput !== input ||
+      this.query !== query ||
+      this.input !== input
+    ) {
+      return { status: "unavailable" };
+    }
+    input.push(message);
+    return { status: "accepted" };
+  }
+
   subscribe(callback: (event: AgentStreamEvent) => void): () => void {
     this.subscribers.add(callback);
     return () => {
@@ -2527,6 +2567,8 @@ class ClaudeAgentSession implements AgentSession {
     this.cancelCurrentTurn?.();
     this.subscribers.clear();
     this.activeForegroundTurnId = null;
+    this.activeForegroundQuery = null;
+    this.activeForegroundInput = null;
     this.autonomousTurn = null;
     this.cancelCurrentTurn = null;
     this.turnState = "idle";
@@ -2640,7 +2682,10 @@ class ClaudeAgentSession implements AgentSession {
     if (!parsed) {
       return null;
     }
-    return parsed.commandName === REWIND_COMMAND_NAME ? parsed : null;
+    return parsed.commandName === REWIND_COMMAND_NAME ||
+      CLAUDE_ROOT_ONLY_COMMANDS.has(parsed.commandName)
+      ? parsed
+      : null;
   }
 
   private parseSlashCommandInput(text: string): SlashCommandInvocation | null {
@@ -3410,6 +3455,8 @@ class ClaudeAgentSession implements AgentSession {
     }
     this.notifySubscribers(event);
     this.activeForegroundTurnId = null;
+    this.activeForegroundQuery = null;
+    this.activeForegroundInput = null;
     this.cancelCurrentTurn = null;
     this.activeTurnHasAssistantText = false;
     this.syncTurnState("foreground turn terminal");
@@ -3425,6 +3472,8 @@ class ClaudeAgentSession implements AgentSession {
     if (terminalSeen) {
       if (this.activeForegroundTurnId) {
         this.activeForegroundTurnId = null;
+        this.activeForegroundQuery = null;
+        this.activeForegroundInput = null;
         this.cancelCurrentTurn = null;
         this.activeTurnHasAssistantText = false;
         this.syncTurnState("foreground turn terminal");
@@ -3800,6 +3849,8 @@ class ClaudeAgentSession implements AgentSession {
     this.queryRestartNeeded = false;
     this.autonomousTurn = null;
     this.activeForegroundTurnId = null;
+    this.activeForegroundQuery = null;
+    this.activeForegroundInput = null;
     this.syncTurnState("missing resumed conversation");
     return true;
   }

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

@@ -46,6 +46,7 @@ describe("mapCodexPlanUpdateToTodo", () => {
     });
   });
 });
+
 import { CodexAppServerClient } from "./codex/app-server-transport.js";
 import {
   createFakeCodexAppServer,
@@ -144,6 +145,144 @@ function createProviderWithFakeAppServer(appServer: FakeCodexAppServer): CodexAp
   return provider;
 }
 
+async function startPublicSteeringSession(
+  appServer: FakeCodexAppServer,
+  resolveSlashCommandInvocation?: (prompt: AgentPromptInput) => Promise<{
+    commandName: string;
+    args?: string;
+  } | null>,
+): Promise<{ session: AgentSession; paseoTurnId: string }> {
+  const session = new CodexAppServerAgentSession(
+    createConfig({ cwd: "/workspace/project" }),
+    null,
+    createTestLogger(),
+    async () => appServer.child,
+    { resolveSlashCommandInvocation },
+  );
+  const started = await session.startTurn("first");
+  await appServer.waitForTurnStart();
+  appServer.startsTurn({ threadId: "thread-1", turnId: "native-A" });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  return { session, paseoTurnId: started.turnId };
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
+
+describe("Codex active-turn steering admission", () => {
+  test("does not steer B when A completes while command resolution is pending", async () => {
+    const commandResolution = deferred<{ commandName: string } | null>();
+    const resolverEntered = deferred<void>();
+    const appServer = createFakeCodexAppServer();
+    const { session, paseoTurnId } = await startPublicSteeringSession(appServer, async (prompt) => {
+      if (prompt !== "/held") return null;
+      resolverEntered.resolve();
+      return commandResolution.promise;
+    });
+
+    const steer = session.steerActiveTurn!("/held", {
+      expectedTurnId: paseoTurnId,
+      clientMessageId: "steer-A",
+    });
+    await resolverEntered.promise;
+    appServer.completeTurn({ threadId: "thread-1" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const startedB = await session.startTurn("second");
+    appServer.startsTurn({ threadId: "thread-1", turnId: "native-B" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    commandResolution.resolve(null);
+
+    await expect(steer).resolves.toEqual({ status: "unavailable" });
+    expect(startedB.turnId).not.toBe(paseoTurnId);
+    expect(appServer.requests().filter((request) => request.method === "turn/steer")).toEqual([]);
+    await session.close();
+    appServer.assertNoErrors();
+  });
+
+  test.each([
+    ["method unavailable", -32601, "method not found", undefined, "unavailable"],
+    ["no active turn", -32600, "no active turn to steer", undefined, "unavailable"],
+    [
+      "expected turn mismatch",
+      -32600,
+      "expected active turn id `native-A` but found `native-B`",
+      undefined,
+      "unavailable",
+    ],
+    [
+      "output schema mismatch",
+      -32600,
+      "active turn uses a different output schema",
+      undefined,
+      "unavailable",
+    ],
+    [
+      "review turn",
+      -32600,
+      "cannot steer a review turn",
+      { codexErrorInfo: { activeTurnNotSteerable: { turnKind: "review" } } },
+      "unavailable",
+    ],
+    ["unknown invalid request", -32600, "input must not be empty", undefined, "throws"],
+  ] as const)("classifies JSON-RPC $0", async (_name, code, message, data, expected) => {
+    const appServer = createFakeCodexAppServer({
+      "turn/steer": () => ({ __jsonRpcError: { code, message, ...(data ? { data } : {}) } }),
+    });
+    const { session, paseoTurnId } = await startPublicSteeringSession(appServer);
+    const steer = session.steerActiveTurn!("follow up", {
+      expectedTurnId: paseoTurnId,
+      clientMessageId: "steer-frame",
+    });
+    if (expected === "unavailable") {
+      await expect(steer).resolves.toEqual({ status: "unavailable" });
+    } else {
+      await expect(steer).rejects.toThrow(message);
+    }
+    await session.close();
+    appServer.assertNoErrors();
+  });
+
+  test("leaves a JSON-RPC server error ambiguous", async () => {
+    const appServer = createFakeCodexAppServer({
+      "turn/steer": () => ({
+        __jsonRpcError: { code: -32000, message: "connection lost" },
+      }),
+    });
+    const { session, paseoTurnId } = await startPublicSteeringSession(appServer);
+    await expect(
+      session.steerActiveTurn!("follow up", {
+        expectedTurnId: paseoTurnId,
+        clientMessageId: "steer-transport",
+      }),
+    ).rejects.toThrow("connection lost");
+    await session.close();
+  });
+
+  test("rejects an in-flight steer when the app-server transport disconnects", async () => {
+    const appServer = createFakeCodexAppServer({
+      "turn/steer": () => new Promise<void>(() => undefined),
+    });
+    const { session, paseoTurnId } = await startPublicSteeringSession(appServer);
+    const steer = session.steerActiveTurn!("follow up", {
+      expectedTurnId: paseoTurnId,
+      clientMessageId: "steer-disconnect",
+    });
+    await appServer.waitForRequest("turn/steer");
+    appServer.disconnect();
+
+    await expect(steer).rejects.toThrow("Codex app-server exited");
+    expect(appServer.requests().filter((request) => request.method === "turn/steer")).toHaveLength(
+      1,
+    );
+    await session.close();
+  });
+});
+
 async function startCompactionTurnTest(): Promise<{
   appServer: FakeCodexAppServer;
   session: AgentSession;

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

@@ -22,6 +22,8 @@ import {
   type AgentRuntimeInfo,
   type AgentSession,
   type AgentSessionConfig,
+  type SteerActiveTurnOptions,
+  type SteerResult,
   type AgentSlashCommand,
   type AgentStreamEvent,
   type AgentTimelineItem,
@@ -73,6 +75,7 @@ import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mappe
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
 import {
   CodexAppServerClient,
+  CodexAppServerRpcError,
   parseCodexThreadForkResponse,
   parseCodexThreadRollbackResponse,
   type CodexThreadForkParams,
@@ -261,6 +264,9 @@ interface CodexAppServerAgentDeps {
     logger: Logger,
     getTraceContext: () => CodexAppServerTraceContext,
   ) => CodexAppServerClientLike;
+  resolveSlashCommandInvocation?: (
+    prompt: AgentPromptInput,
+  ) => Promise<{ commandName: string; args?: string } | null>;
 }
 
 interface CodexModePreset {
@@ -833,6 +839,24 @@ function toObjectRecord(value: unknown): Record<string, unknown> | undefined {
   return isRecord(value) ? value : undefined;
 }
 
+function isDefinitiveCodexSteerRejection(error: unknown): boolean {
+  if (!(error instanceof CodexAppServerRpcError)) return false;
+  if (error.code === -32601) return true;
+  if (error.code !== -32600) return false;
+
+  const data = toObjectRecord(error.data);
+  if (data && isRecord(toObjectRecord(data.codexErrorInfo)?.activeTurnNotSteerable)) return true;
+
+  // These app-server invalid-request messages describe requests that reached
+  // Codex but could not have submitted input. Keep this exact: a generic
+  // invalid-request, timeout, disconnect, or unknown error is ambiguous.
+  return (
+    error.message === "no active turn to steer" ||
+    /^expected active turn id `[^`]+` but found `[^`]+`$/.test(error.message) ||
+    error.message === "active turn uses a different output schema"
+  );
+}
+
 // Codex app-server API response types
 interface CodexReasoningEffortEntry {
   reasoningEffort?: string;
@@ -1603,10 +1627,14 @@ function mapCodexThreadUserMessageItem(
   }
   const text = extractUserText(normalizedItem.content) ?? "";
   const messageId = nonEmptyString(normalizedItem.id);
+  const clientMessageId = nonEmptyString(
+    normalizedItem.clientId ?? normalizedItem.client_id ?? normalizedItem.clientUserMessageId,
+  );
   return {
     type: "user_message",
     text,
     ...(messageId ? { messageId } : {}),
+    ...(clientMessageId ? { clientMessageId } : {}),
   };
 }
 
@@ -3808,6 +3836,9 @@ export class CodexAppServerAgentSession implements AgentSession {
   private async resolveSlashCommandInvocation(
     prompt: AgentPromptInput,
   ): Promise<{ commandName: string; args?: string } | null> {
+    if (this.deps.resolveSlashCommandInvocation) {
+      return this.deps.resolveSlashCommandInvocation(prompt);
+    }
     if (typeof prompt !== "string") {
       return null;
     }
@@ -4096,6 +4127,63 @@ export class CodexAppServerAgentSession implements AgentSession {
     }
   }
 
+  async steerActiveTurn(
+    prompt: AgentPromptInput,
+    options: SteerActiveTurnOptions,
+  ): Promise<SteerResult> {
+    const client = this.client;
+    const threadId = this.currentThreadId;
+    const nativeTurnId = this.currentTurnId;
+    const foregroundTurnId = this.activeForegroundTurnId;
+    if (!client || !threadId || !nativeTurnId || foregroundTurnId !== options.expectedTurnId) {
+      return { status: "unavailable" };
+    }
+    if (await this.resolveSlashCommandInvocation(prompt)) return { status: "unavailable" };
+    if (!this.matchesSteerAdmission({ client, threadId, nativeTurnId, foregroundTurnId })) {
+      return { status: "unavailable" };
+    }
+    const input = await this.buildUserInput(prompt);
+    if (!this.matchesSteerAdmission({ client, threadId, nativeTurnId, foregroundTurnId })) {
+      return { status: "unavailable" };
+    }
+    try {
+      const response = await client.request(
+        "turn/steer",
+        {
+          threadId,
+          expectedTurnId: nativeTurnId,
+          input,
+          ...(options.clientMessageId ? { clientUserMessageId: options.clientMessageId } : {}),
+        },
+        TURN_START_TIMEOUT_MS,
+      );
+      const record = toObjectRecord(response);
+      const turn = record ? toObjectRecord(record.turn) : null;
+      const acknowledgedTurnId = nonEmptyString(record?.turnId) ?? nonEmptyString(turn?.id);
+      if (acknowledgedTurnId !== nativeTurnId) {
+        throw new Error("Codex returned an invalid steer acknowledgement");
+      }
+      return { status: "accepted" };
+    } catch (error) {
+      if (isDefinitiveCodexSteerRejection(error)) return { status: "unavailable" };
+      throw error;
+    }
+  }
+
+  private matchesSteerAdmission(admission: {
+    client: CodexAppServerClientLike;
+    threadId: string;
+    nativeTurnId: string;
+    foregroundTurnId: string;
+  }): boolean {
+    return (
+      this.client === admission.client &&
+      this.currentThreadId === admission.threadId &&
+      this.currentTurnId === admission.nativeTurnId &&
+      this.activeForegroundTurnId === admission.foregroundTurnId
+    );
+  }
+
   private rememberCodexUserMessageTurn(messageId: string | null | undefined): boolean {
     if (typeof messageId !== "string" || messageId.length === 0) {
       return false;
@@ -6231,9 +6319,8 @@ export class CodexAppServerAgentSession implements AgentSession {
     if (!this.rememberCodexUserMessageTurn(timelineItem.messageId)) {
       return;
     }
-    const item = this.activeClientMessageId
-      ? { ...timelineItem, clientMessageId: this.activeClientMessageId }
-      : timelineItem;
+    const clientMessageId = timelineItem.clientMessageId ?? this.activeClientMessageId;
+    const item = clientMessageId ? { ...timelineItem, clientMessageId } : timelineItem;
     this.activeClientMessageId = null;
     this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item });
   }

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

@@ -19,7 +19,7 @@ interface JsonRpcRequest {
 interface JsonRpcResponse {
   id: number;
   result?: unknown;
-  error?: { message?: string };
+  error?: { message?: string; code?: string | number; data?: unknown };
 }
 
 interface JsonRpcNotification {
@@ -33,6 +33,17 @@ interface PendingRequest {
   timer: NodeJS.Timeout;
 }
 
+export class CodexAppServerRpcError extends Error {
+  constructor(
+    message: string,
+    readonly code: string | number | undefined,
+    readonly data: unknown,
+  ) {
+    super(message);
+    this.name = "CodexAppServerRpcError";
+  }
+}
+
 type RequestHandler = (params: unknown, requestId: number) => unknown;
 type NotificationHandler = (method: string, params: unknown) => void;
 type UnexpectedTerminationHandler = (error: Error) => void;
@@ -329,7 +340,13 @@ export class CodexAppServerClient {
         clearTimeout(pending.timer);
         this.pending.delete(id);
         if (raw.error) {
-          pending.reject(new Error(raw.error.message ?? "Unknown error"));
+          pending.reject(
+            new CodexAppServerRpcError(
+              raw.error.message ?? "Unknown error",
+              raw.error.code,
+              raw.error.data,
+            ),
+          );
         } else {
           pending.resolve(raw.result);
         }

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

@@ -47,8 +47,11 @@ type CodexAppServerChildProcess = ChildProcessWithoutNullStreams & {
 export interface FakeCodexAppServer {
   readonly child: CodexAppServerChildProcess;
   readonly recordedRollbacks: JsonObject[];
+  requests(): readonly JsonObject[];
   assertNoErrors(): void;
   waitForTurnStart(): Promise<JsonObject>;
+  waitForRequest(method: string): Promise<JsonObject>;
+  disconnect(): void;
   nextResponse(): Promise<string>;
   startsTurn(params: { threadId: string; turnId?: string }): void;
   startsCompaction(params: { threadId: string; itemId: string }): void;
@@ -205,6 +208,11 @@ export function createFakeCodexAppServer(
 
     Promise.resolve(handler(message.params))
       .then((result) => {
+        const rpcError = toJsonObject(result).__jsonRpcError;
+        if (rpcError) {
+          child.stdout.write(`${JSON.stringify({ id: message.id, error: rpcError })}\n`);
+          return undefined;
+        }
         child.stdout.write(`${JSON.stringify({ id: message.id, result })}\n`);
         return undefined;
       })
@@ -297,6 +305,9 @@ export function createFakeCodexAppServer(
   return {
     child,
     recordedRollbacks,
+    requests() {
+      return messages;
+    },
     assertNoErrors() {
       if (errors.length > 0) {
         throw errors[0];
@@ -309,6 +320,16 @@ export function createFakeCodexAppServer(
       );
       return toJsonObject(message.params);
     },
+    async waitForRequest(method) {
+      const message = await waitForMessage(
+        (candidate) => candidate.method === method,
+        `${method} request`,
+      );
+      return toJsonObject(message.params);
+    },
+    disconnect() {
+      child.emit("exit", null, "SIGTERM");
+    },
     nextResponse() {
       return new Promise<string>((resolve) => {
         child.stdin.once("data", (chunk) => resolve(chunk.toString()));

packages/server/src/server/agent/providers/mock-load-test-agent.ts

@@ -25,6 +25,8 @@ import type {
   ImportProviderSessionContext,
   ImportProviderSessionInput,
   ProviderCatalog,
+  SteerActiveTurnOptions,
+  SteerResult,
   ToolCallDetail,
   ToolCallTimelineItem,
 } from "../agent-sdk-types.js";
@@ -37,6 +39,10 @@ export const MOCK_LOAD_TEST_HANDLED_COMMAND = "/mock handled-command";
 const MOCK_LOAD_TEST_MODE_ID = "load-test";
 const MOCK_LOAD_TEST_DURATION_MS = 5 * 60 * 1000;
 const MOCK_LOAD_TEST_INTERVAL_MS = 40;
+
+function getPositiveFeatureInteger(value: unknown): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
 const ONE_PIXEL_PNG_BASE64 =
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl4Kj8AAAAASUVORK5CYII=";
 
@@ -160,6 +166,8 @@ interface AgentStreamStressRequest {
   coalesced: boolean;
 }
 
+type SteeringReplayShape = "claude" | "codex";
+
 interface MockQuestionOption {
   label: string;
   description?: string;
@@ -188,6 +196,13 @@ function shouldEmitTurnFailure(prompt: AgentPromptInput): boolean {
   return /emit\s+(?:a\s+)?synthetic\s+turn\s+failure/i.test(promptToText(prompt));
 }
 
+function parseSteeringReplayShape(prompt: AgentPromptInput): SteeringReplayShape | null {
+  const match = /replay a (claude|codex)-shaped foreground shell tool call/i.exec(
+    promptToText(prompt),
+  );
+  return match?.[1] === "claude" || match?.[1] === "codex" ? match[1] : null;
+}
+
 function parseSettledAssistantImageMarkdown(prompt: AgentPromptInput): string | null {
   const match = /^emit settled assistant image markdown:\s*(!\[[^\]\r\n]*\]\(.+\))\s*$/i.exec(
     promptToText(prompt),
@@ -648,6 +663,7 @@ export class MockLoadTestAgentSession implements AgentSession {
   private readonly streamingAssistantIntervalMs: number;
   private readonly rewindError: string | null;
   private remainingPromptRejections: number;
+  private remainingSteerFailures: number;
 
   constructor(options: { config: AgentSessionConfig; sessionId: string; logger?: Logger }) {
     this.id = options.sessionId;
@@ -681,6 +697,9 @@ export class MockLoadTestAgentSession implements AgentSession {
       requestedPromptRejections > 0
         ? requestedPromptRejections
         : 0;
+    this.remainingSteerFailures = getPositiveFeatureInteger(
+      options.config.featureValues?.mockSteerAmbiguousFailures,
+    );
   }
 
   async run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult> {
@@ -732,9 +751,12 @@ export class MockLoadTestAgentSession implements AgentSession {
     const questionPrompt = parseMockQuestionPrompt(prompt);
     const structuredBranchName = parseStructuredBranchNamePrompt(prompt);
     const settledAssistantImageMarkdown = parseSettledAssistantImageMarkdown(prompt);
+    const steeringReplayShape = parseSteeringReplayShape(prompt);
     const scheduleTurn = () => {
       if (shouldEmitTurnFailure(prompt)) {
         this.scheduleFailedTurn(turn);
+      } else if (steeringReplayShape) {
+        this.scheduleSteeringReplayTurn(turn, steeringReplayShape);
       } else if (this.streamingAssistantResponse !== null) {
         this.scheduleStreamingAssistantTurn(turn, this.streamingAssistantResponse);
       } else if (this.assistantResponse !== null) {
@@ -928,6 +950,20 @@ export class MockLoadTestAgentSession implements AgentSession {
     });
   }
 
+  async steerActiveTurn(
+    _prompt: AgentPromptInput,
+    options: SteerActiveTurnOptions,
+  ): Promise<SteerResult> {
+    if (this.activeTurn?.turnId !== options.expectedTurnId) {
+      return { status: "unavailable" };
+    }
+    if (this.remainingSteerFailures > 0) {
+      this.remainingSteerFailures -= 1;
+      throw new Error("Requested mock steer transport failure");
+    }
+    return { status: "accepted" };
+  }
+
   async close(): Promise<void> {
     await this.interrupt();
     this.listeners.clear();
@@ -1025,6 +1061,52 @@ export class MockLoadTestAgentSession implements AgentSession {
     turn.timer.unref?.();
   }
 
+  private scheduleSteeringReplayTurn(turn: ActiveTurn, shape: SteeringReplayShape): void {
+    turn.timer = setTimeout(() => {
+      if (this.activeTurn !== turn) return;
+      this.clearTurnTimer(turn);
+      this.emitTurnStarted(turn);
+      if (shape === "codex") {
+        this.emitTimeline(turn.turnId, {
+          type: "assistant_message",
+          text: "Running the foreground command.",
+          messageId: turn.assistantMessageId,
+        });
+      }
+      const callId = `${turn.turnId}:steering-replay-shell`;
+      const detail: ToolCallDetail = {
+        type: "shell",
+        command: "sleep 5",
+        cwd: "/tmp/paseo-mock-load",
+      };
+      this.emitTimeline(
+        turn.turnId,
+        createToolCall({ callId, name: "bash", status: "running", detail }),
+      );
+      turn.timer = setTimeout(() => {
+        if (this.activeTurn !== turn) return;
+        this.clearTurnTimer(turn);
+        this.emitTimeline(
+          turn.turnId,
+          createToolCall({
+            callId,
+            name: "bash",
+            status: "completed",
+            detail: { ...detail, output: "", exitCode: 0 },
+          }),
+        );
+        this.emitTimeline(turn.turnId, {
+          type: "assistant_message",
+          text: "Foreground command completed after steering.",
+          messageId: turn.assistantMessageId,
+        });
+        this.finishTurnWithText(turn, "Foreground command completed after steering.");
+      }, 5_000);
+      turn.timer.unref?.();
+    }, 0);
+    turn.timer.unref?.();
+  }
+
   private scheduleStressTurn(turn: ActiveTurn, stress: AgentStreamStressRequest): void {
     turn.timer = setTimeout(() => {
       this.emitStressTurn(turn, stress);

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

@@ -13,6 +13,7 @@ export type TimelineLimitDirection = "tail" | "before" | "after";
 
 export interface TimelineProjectionEntry {
   item: AgentTimelineItem;
+  turnId?: string;
   timestamp: string;
   seqStart: number;
   seqEnd: number;
@@ -110,6 +111,7 @@ function mergeToolCallItems(
 function makeCanonicalEntries(rows: readonly AgentTimelineRow[]): WorkingEntry[] {
   return rows.map((row) => ({
     item: row.item,
+    ...(row.turnId ? { turnId: row.turnId } : {}),
     timestamp: row.timestamp,
     seqStart: row.seq,
     seqEnd: row.seq,
@@ -136,7 +138,7 @@ function collapseToolLifecycle(entries: readonly WorkingEntry[]): WorkingEntry[]
     }
 
     const existing = output[existingIndex];
-    if (!existing || existing.item.type !== "tool_call") {
+    if (!existing || existing.item.type !== "tool_call" || existing.turnId !== entry.turnId) {
       output.push(entry);
       continue;
     }
@@ -169,7 +171,8 @@ function mergeReasoningChunks(entries: readonly WorkingEntry[]): WorkingEntry[]
       previous &&
       previous.item.type === "reasoning" &&
       entry.item.type === "reasoning" &&
-      previous.seqEnd + 1 === entry.seqStart;
+      previous.seqEnd + 1 === entry.seqStart &&
+      previous.turnId === entry.turnId;
 
     if (!shouldMerge || !previous) {
       output.push(entry);
@@ -209,7 +212,8 @@ function mergeAssistantChunks(entries: readonly WorkingEntry[]): WorkingEntry[]
       previous &&
       previous.item.type === "assistant_message" &&
       entry.item.type === "assistant_message" &&
-      previous.seqEnd + 1 === entry.seqStart;
+      previous.seqEnd + 1 === entry.seqStart &&
+      previous.turnId === entry.turnId;
 
     if (!shouldMerge || !previous) {
       output.push(entry);

packages/server/src/server/bootstrap.ts

@@ -128,6 +128,7 @@ import type { LocalSpeechProviderConfig } from "./speech/providers/local/config.
 import type { RequestedSpeechProviders } from "./speech/speech-types.js";
 import { createSpeechService } from "./speech/speech-runtime.js";
 import { AgentManager } from "./agent/agent-manager.js";
+import { FileAgentTimelineStore } from "./agent/file-agent-timeline-store.js";
 import { AgentStorage } from "./agent/agent-storage.js";
 import { attachAgentStoragePersistence } from "./persistence-hooks.js";
 import { createAgentMcpServer } from "./agent/mcp-server.js";
@@ -841,6 +842,7 @@ export async function createPaseoDaemon(
   }
 
   const agentStorage = new AgentStorage(config.agentStoragePath, logger);
+  const timelineStore = new FileAgentTimelineStore(path.join(config.paseoHome, "agent-timelines"));
   const projectRegistry = new FileBackedProjectRegistry(
     path.join(config.paseoHome, "projects", "projects.json"),
     logger,
@@ -889,6 +891,7 @@ export async function createPaseoDaemon(
   });
   const initialAgentManagerState = providerSnapshotManager.getAgentManagerProviderState();
   const agentManager = new AgentManager({
+    durableTimelineStore: timelineStore,
     clients: initialAgentManagerState.clients,
     providerDefinitions: initialAgentManagerState.providerDefinitions,
     registry: agentStorage,

packages/server/src/server/daemon-e2e/send-during-tool-call-claude.real.e2e.test.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import pino from "pino";
 
 import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
+import { ClaudeAgentClient } from "../agent/providers/claude/agent.js";
 import { DaemonClient } from "../test-utils/daemon-client.js";
 import {
   canRunRealProvider,
@@ -23,6 +24,55 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function within<T>(label: string, timeoutMs: number, operation: Promise<T>): Promise<T> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise<T>((_resolve, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+function generateClientMessageId(): string {
+  return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+
+interface ObservedForegroundSleep {
+  callId: string;
+  turnId?: string;
+}
+
+function getRunningClaudeSleep(
+  message: SessionOutboundMessage,
+  agentId: string,
+): ObservedForegroundSleep | null {
+  if (
+    message.type !== "agent_stream" ||
+    message.payload.agentId !== agentId ||
+    message.payload.event.type !== "timeline" ||
+    message.payload.event.item.type !== "tool_call"
+  ) {
+    return null;
+  }
+  const tool = message.payload.event.item;
+  if (
+    tool.status !== "running" ||
+    tool.detail.type !== "shell" ||
+    !/\bsleep 5\b/.test(tool.detail.command)
+  ) {
+    return null;
+  }
+  return { callId: tool.callId, turnId: message.payload.event.turnId };
+}
+
 function hasRunningToolCall(messages: SessionOutboundMessage[], agentId: string): boolean {
   for (const m of messages) {
     if (
@@ -38,6 +88,37 @@ function hasRunningToolCall(messages: SessionOutboundMessage[], agentId: string)
   return false;
 }
 
+function isCapturedSleepCompletion(
+  message: SessionOutboundMessage,
+  agentId: string,
+  callId: string,
+): boolean {
+  return (
+    message.type === "agent_stream" &&
+    message.payload.agentId === agentId &&
+    message.payload.event.type === "timeline" &&
+    message.payload.event.item.type === "tool_call" &&
+    message.payload.event.item.callId === callId &&
+    message.payload.event.item.status === "completed"
+  );
+}
+
+function isCapturedSleepCancellation(
+  message: SessionOutboundMessage,
+  agentId: string,
+  callId: string,
+): boolean {
+  return (
+    message.type === "agent_stream" &&
+    message.payload.agentId === agentId &&
+    message.payload.event.type === "timeline" &&
+    message.payload.event.item.type === "tool_call" &&
+    message.payload.event.item.callId === callId &&
+    (message.payload.event.item.status === "canceled" ||
+      message.payload.event.item.status === "failed")
+  );
+}
+
 function getAssistantTexts(messages: SessionOutboundMessage[], agentId: string): string[] {
   return messages
     .filter(
@@ -165,13 +246,72 @@ async function waitForRunningToolCall(
       .filter((entry) => entry.item.type === "assistant_message")
       .slice(-5)
       .map((entry) => entry.item.text) ?? [];
+  const snapshot = await client.fetchAgent({ agentId }).catch(() => null);
+  const streamFailures = collector.messages
+    .filter(
+      (message) =>
+        message.type === "agent_stream" &&
+        message.payload.agentId === agentId &&
+        (message.payload.event.type === "turn_failed" ||
+          message.payload.event.type === "turn_canceled"),
+    )
+    .map((message) => message.payload.event);
+  const permissionEvents = collector.messages
+    .filter(
+      (message) =>
+        message.type === "agent_stream" &&
+        message.payload.agentId === agentId &&
+        message.payload.event.type === "permission_requested",
+    )
+    .map((message) => message.payload.event);
   throw new Error(
-    `Timed out waiting for running tool call. Recent tool_calls=${JSON.stringify(recentToolCalls)} recent assistant text=${JSON.stringify(recentAssistantTexts)}`,
+    `Timed out waiting for running tool call. lifecycle=${snapshot?.agent.status ?? "missing"} activeTurn=${snapshot?.agent.activeForegroundTurnId ?? "none"} recent tool_calls=${JSON.stringify(recentToolCalls)} recent assistant text=${JSON.stringify(recentAssistantTexts)} stream failures=${JSON.stringify(streamFailures)} permissions=${JSON.stringify(permissionEvents)}`,
+  );
+}
+
+async function waitForRunningClaudeSleep(
+  client: DaemonClient,
+  collector: ReturnType<typeof createMessageCollector>,
+  agentId: string,
+  timeoutMs = 90_000,
+): Promise<ObservedForegroundSleep> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const observed = collector.messages
+      .map((message) => getRunningClaudeSleep(message, agentId))
+      .find((event): event is ObservedForegroundSleep => event !== null);
+    if (observed) {
+      return observed;
+    }
+
+    // Projection is only diagnostic here; tool lifecycle rows are collapsed by fetch.
+    const timeline = await client.fetchAgentTimeline(agentId, { limit: 100 }).catch(() => null);
+    const assistantTexts =
+      timeline?.entries
+        .filter((entry) => entry.item.type === "assistant_message")
+        .slice(-5)
+        .map((entry) => entry.item.text) ?? [];
+    const limitText = assistantTexts.find((text) => hasProviderLimitText(text));
+    if (limitText) {
+      throw new Error(`Claude provider rejected the run: ${limitText}`);
+    }
+    await sleep(50);
+  }
+
+  const timeline = await client.fetchAgentTimeline(agentId, { limit: 100 }).catch(() => null);
+  throw new Error(
+    `Timed out waiting for Claude to report the live foreground sleep 5 call. Recent timeline=${JSON.stringify(timeline ? summarizeTimelineItems(timeline) : [])}`,
   );
 }
 
 describe("daemon E2E (real claude) - send message during tool call", () => {
   let canRun = false;
+  interface SteeringResources {
+    cwd: string | null;
+    daemon: Awaited<ReturnType<typeof createTestPaseoDaemon>> | null;
+    client: DaemonClient | null;
+    collector: ReturnType<typeof createMessageCollector> | null;
+  }
 
   beforeAll(async () => {
     canRun = await canRunRealProvider("claude");
@@ -183,6 +323,187 @@ describe("daemon E2E (real claude) - send message during tool call", () => {
     }
   });
 
+  test("steers one active Claude turn without starting another", async () => {
+    const logger = pino({ level: "silent" });
+    const resources: SteeringResources = {
+      cwd: tmpCwd(),
+      daemon: null,
+      client: null,
+      collector: null,
+    };
+    try {
+      resources.daemon = await createTestPaseoDaemon({
+        // Use the installed SDK's configured authentication so this regression
+        // exercises the native streaming-input path.
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      resources.client = new DaemonClient({ url: `ws://127.0.0.1:${resources.daemon.port}/ws` });
+      const { client, cwd } = resources;
+      if (!client) throw new Error("Claude steering test client was not created");
+      await within("connect Claude steering test client", 15_000, client.connect());
+      await within(
+        "subscribe Claude steering test client",
+        15_000,
+        client.fetchAgents({ subscribe: { subscriptionId: "steer" } }),
+      );
+      const agent = await within(
+        "create Claude steering test agent",
+        30_000,
+        client.createAgent({
+          cwd: cwd ?? process.cwd(),
+          title: "claude-exact-turn-steer",
+          ...getRealProviderConfig("claude"),
+        }),
+      );
+      resources.collector = createMessageCollector(client);
+      await within(
+        "submit Claude foreground sleep turn",
+        30_000,
+        client.sendAgentMessage(
+          agent.id,
+          [
+            "Use the Bash tool.",
+            "Run exactly: sleep 5. Run it in the foreground. Do not finish until a later user message arrives.",
+            "After that message arrives, use the Bash tool again and run exactly: printf SECOND_BOUNDARY. Then reply exactly: STEERED_SAME_TURN.",
+            "Do not use a background task.",
+          ].join(" "),
+          { messageId: generateClientMessageId() },
+        ),
+      );
+      const foregroundSleep = await within(
+        "wait for Claude to begin the live foreground sleep tool",
+        90_000,
+        waitForRunningClaudeSleep(client, resources.collector, agent.id, 80_000),
+      );
+      await within(
+        "confirm Claude remains active at the first tool boundary",
+        15_000,
+        client.waitForAgentUpsert(agent.id, (snapshot) => snapshot.status === "running", 10_000),
+      );
+      const initialTurnStarts = resources.collector.messages.filter(
+        (message) =>
+          message.type === "agent_stream" &&
+          message.payload.agentId === agent.id &&
+          message.payload.event.type === "turn_started",
+      );
+      expect(initialTurnStarts).toHaveLength(1);
+      const initialTurnId = initialTurnStarts[0]?.payload.event.turnId;
+      expect(initialTurnId).toEqual(expect.any(String));
+      expect(foregroundSleep.turnId).toBe(initialTurnId);
+      const steeringMessageId = generateClientMessageId();
+      const messagesBeforeSteer = resources.collector.messages.length;
+      await within(
+        "submit Claude active-turn steer",
+        30_000,
+        client.sendAgentMessage(agent.id, "hello", {
+          messageId: steeringMessageId,
+          activeTurnBehavior: "steer",
+        }),
+      );
+      const finish = await within(
+        "wait for steered Claude turn to finish",
+        150_000,
+        client.waitForFinish(agent.id, 140_000),
+      );
+      expect(finish.status).toBe("idle");
+      const postSteerMessages = resources.collector.messages.slice(messagesBeforeSteer);
+      const turnStarts = postSteerMessages.filter(
+        (message) =>
+          message.type === "agent_stream" &&
+          message.payload.agentId === agent.id &&
+          message.payload.event.type === "turn_started",
+      );
+      expect(turnStarts).toHaveLength(0);
+      expect(
+        postSteerMessages.filter(
+          (message) =>
+            message.type === "agent_stream" &&
+            message.payload.agentId === agent.id &&
+            message.payload.event.type === "turn_canceled",
+        ),
+      ).toHaveLength(0);
+      expect(
+        postSteerMessages.filter(
+          (message) =>
+            message.type === "agent_stream" &&
+            message.payload.agentId === agent.id &&
+            message.payload.event.type === "turn_completed",
+        ),
+      ).toHaveLength(1);
+      expect(
+        postSteerMessages.some((message) =>
+          isCapturedSleepCompletion(message, agent.id, foregroundSleep.callId),
+        ),
+        "the exact live sleep 5 call must complete after hello is submitted",
+      ).toBe(true);
+      expect(
+        postSteerMessages.some((message) =>
+          isCapturedSleepCancellation(message, agent.id, foregroundSleep.callId),
+        ),
+        "the exact live sleep 5 call must not be canceled or fail after hello",
+      ).toBe(false);
+      const secondBoundaryEvents = postSteerMessages.filter(
+        (message) =>
+          message.type === "agent_stream" &&
+          message.payload.agentId === agent.id &&
+          message.payload.event.type === "timeline" &&
+          message.payload.event.item.type === "tool_call" &&
+          message.payload.event.item.detail.type === "shell" &&
+          /\bprintf\s+SECOND_BOUNDARY\b/.test(message.payload.event.item.detail.command),
+      );
+      expect(
+        secondBoundaryEvents.some(
+          (message) =>
+            message.payload.event.type === "timeline" &&
+            message.payload.event.item.type === "tool_call" &&
+            message.payload.event.item.status === "completed",
+        ),
+        "hello must drive a second completed tool call in the same active loop",
+      ).toBe(true);
+      expect(
+        secondBoundaryEvents.every(
+          (message) =>
+            message.payload.event.type === "timeline" &&
+            message.payload.event.turnId === initialTurnId,
+        ),
+        "both Claude tool boundaries must retain the original turn ID",
+      ).toBe(true);
+      const timeline = await within(
+        "fetch steered Claude timeline",
+        15_000,
+        client.fetchAgentTimeline(agent.id, { limit: 100 }),
+      );
+      const assistantText = timeline.entries
+        .filter((entry) => entry.item.type === "assistant_message")
+        .map(
+          (entry) => (entry.item as Extract<AgentTimelineItem, { type: "assistant_message" }>).text,
+        )
+        .join("\\n");
+      const steeringRows = timeline.entries.filter(
+        (entry) => entry.item.type === "user_message" && entry.item.text === "hello",
+      );
+      expect(steeringRows).toHaveLength(1);
+      expect(steeringRows[0]?.item).toMatchObject({
+        messageId: steeringMessageId,
+        clientMessageId: steeringMessageId,
+      });
+      expect(steeringRows[0]?.turnId).toBe(initialTurnId);
+      expect(assistantText).toContain("STEERED_SAME_TURN");
+    } finally {
+      const cleanup = await Promise.allSettled([
+        Promise.resolve(resources.collector?.unsubscribe()),
+        resources.client?.close() ?? Promise.resolve(),
+        resources.daemon?.close() ?? Promise.resolve(),
+      ]);
+      if (resources.cwd) rmSync(resources.cwd, { recursive: true, force: true });
+      const failures = cleanup.flatMap((result) =>
+        result.status === "rejected" ? [result.reason] : [],
+      );
+      expect(failures, "Claude steering E2E cleanup failures").toEqual([]);
+    }
+  }, 210_000);
+
   test("sending a message while a tool call is running replaces the turn without error, idle flash, or autonomous fallback", async () => {
     const logger = pino({ level: "silent" });
     const cwd = tmpCwd();

packages/server/src/server/daemon-e2e/send-during-tool-call-codex.real.e2e.test.ts

@@ -5,15 +5,12 @@ import path from "node:path";
 import pino from "pino";
 
 import type { AgentTimelineItem } from "../agent/agent-sdk-types.js";
+import { CodexAppServerAgentClient } from "../agent/providers/codex-app-server-agent.js";
 import { DaemonClient } from "../test-utils/daemon-client.js";
 import { createMessageCollector } from "../test-utils/message-collector.js";
 import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
 import type { SessionOutboundMessage } from "../messages.js";
-import {
-  canRunRealProvider,
-  createRealProviderClients,
-  getRealProviderConfig,
-} from "./real-provider-test-config.js";
+import { canRunRealProvider } from "./real-provider-test-config.js";
 
 function tmpCwd(): string {
   return mkdtempSync(path.join(tmpdir(), "daemon-real-codex-tool-interrupt-"));
@@ -23,6 +20,23 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function within<T>(label: string, timeoutMs: number, operation: Promise<T>): Promise<T> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise<T>((_resolve, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 function generateClientMessageId(): string {
   return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
 }
@@ -102,24 +116,84 @@ function summarizeTimelineItems(timeline: Awaited<ReturnType<DaemonClient["fetch
   });
 }
 
-async function waitForAssistantWaitingOnSleep(
+interface ObservedForegroundSleep {
+  callId: string;
+}
+
+function getRunningCodexSleep(
+  message: SessionOutboundMessage,
+  agentId: string,
+  command: RegExp,
+): ObservedForegroundSleep | null {
+  if (
+    message.type !== "agent_stream" ||
+    message.payload.agentId !== agentId ||
+    message.payload.event.type !== "timeline" ||
+    message.payload.event.item.type !== "tool_call"
+  ) {
+    return null;
+  }
+  const tool = message.payload.event.item;
+  if (
+    tool.status !== "running" ||
+    tool.detail.type !== "shell" ||
+    !command.test(tool.detail.command)
+  ) {
+    return null;
+  }
+  return { callId: tool.callId };
+}
+
+function isCapturedSleepCompletion(
+  message: SessionOutboundMessage,
+  agentId: string,
+  callId: string,
+): boolean {
+  return (
+    message.type === "agent_stream" &&
+    message.payload.agentId === agentId &&
+    message.payload.event.type === "timeline" &&
+    message.payload.event.item.type === "tool_call" &&
+    message.payload.event.item.callId === callId &&
+    message.payload.event.item.status === "completed"
+  );
+}
+
+function isCapturedSleepCancellation(
+  message: SessionOutboundMessage,
+  agentId: string,
+  callId: string,
+): boolean {
+  return (
+    message.type === "agent_stream" &&
+    message.payload.agentId === agentId &&
+    message.payload.event.type === "timeline" &&
+    message.payload.event.item.type === "tool_call" &&
+    message.payload.event.item.callId === callId &&
+    (message.payload.event.item.status === "canceled" ||
+      message.payload.event.item.status === "failed")
+  );
+}
+
+async function waitForRunningCodexSleep(
   client: DaemonClient,
+  collector: ReturnType<typeof createMessageCollector>,
   agentId: string,
   timeoutMs = 75_000,
-): Promise<void> {
+  command = /\bsleep 5\b/,
+): Promise<ObservedForegroundSleep> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    const timeline = await client.fetchAgentTimeline(agentId, { limit: 100 });
-    assertNoProviderLimit(timeline);
-    const assistantText = timeline.entries
-      .filter((entry) => entry.item.type === "assistant_message")
-      .map((entry) => entry.item.text)
-      .join("\n");
-    if (/still running|waiting/i.test(assistantText) && !/`done`|\bdone\b/i.test(assistantText)) {
-      return;
+    const observed = collector.messages
+      .map((message) => getRunningCodexSleep(message, agentId, command))
+      .find((event): event is ObservedForegroundSleep => event !== null);
+    if (observed) {
+      return observed;
     }
-
-    await sleep(500);
+    // Timeline fetches are diagnostic only: projection collapses the lifecycle row.
+    const timeline = await client.fetchAgentTimeline(agentId, { limit: 100 }).catch(() => null);
+    if (timeline) assertNoProviderLimit(timeline);
+    await sleep(50);
   }
 
   const timeline = await client.fetchAgentTimeline(agentId, { limit: 100 }).catch(() => null);
@@ -144,6 +218,12 @@ async function waitForAssistantWaitingOnSleep(
 
 describe("daemon E2E (real codex) - send message during tool call", () => {
   let canRun = false;
+  interface SteeringResources {
+    cwd: string | null;
+    daemon: Awaited<ReturnType<typeof createTestPaseoDaemon>> | null;
+    client: DaemonClient | null;
+    collector: ReturnType<typeof createMessageCollector> | null;
+  }
 
   beforeAll(async () => {
     canRun = await canRunRealProvider("codex");
@@ -155,11 +235,163 @@ describe("daemon E2E (real codex) - send message during tool call", () => {
     }
   });
 
+  test("steers one active Codex turn without starting another", async () => {
+    const logger = pino({ level: "silent" });
+    const resources: SteeringResources = {
+      cwd: tmpCwd(),
+      daemon: null,
+      client: null,
+      collector: null,
+    };
+    try {
+      resources.daemon = await createTestPaseoDaemon({
+        // Use the installed app-server so this regression exercises the native
+        // steering method rather than the broad provider smoke-test path.
+        agentClients: { codex: new CodexAppServerAgentClient(logger) },
+        logger,
+      });
+      resources.client = new DaemonClient({ url: `ws://127.0.0.1:${resources.daemon.port}/ws` });
+      const { client, cwd } = resources;
+      if (!client) throw new Error("Codex steering test client was not created");
+      await within("connect steering test client", 15_000, client.connect());
+      await within(
+        "subscribe steering test client",
+        15_000,
+        client.fetchAgents({ subscribe: { subscriptionId: "steer" } }),
+      );
+      const agent = await within(
+        "create Codex steering test agent",
+        30_000,
+        client.createAgent({
+          cwd: cwd ?? process.cwd(),
+          title: "codex-exact-turn-steer",
+          provider: "codex",
+          model: "gpt-5.4",
+          thinkingOptionId: "low",
+          modeId: "full-access",
+        }),
+      );
+      resources.collector = createMessageCollector(client);
+      await within(
+        "submit Codex foreground sleep turn",
+        30_000,
+        client.sendAgentMessage(
+          agent.id,
+          "Use the shell tool to run exactly: sleep 5. Run it in the foreground. Do not finish until a later user message arrives; after it arrives, reply exactly: STEERED_SAME_TURN.",
+          { messageId: generateClientMessageId() },
+        ),
+      );
+      const foregroundSleep = await within(
+        "wait for live Codex foreground sleep tool",
+        90_000,
+        waitForRunningCodexSleep(client, resources.collector, agent.id, 80_000),
+      );
+      await within(
+        "confirm Codex remains active at the first tool boundary",
+        15_000,
+        client.waitForAgentUpsert(agent.id, (snapshot) => snapshot.status === "running", 10_000),
+      );
+      const initialTurnStarts = resources.collector.messages.filter(
+        (message) =>
+          message.type === "agent_stream" &&
+          message.payload.agentId === agent.id &&
+          message.payload.event.type === "turn_started",
+      );
+      expect(initialTurnStarts).toHaveLength(1);
+      const initialTurnId = initialTurnStarts[0]?.payload.event.turnId;
+      expect(initialTurnId).toEqual(expect.any(String));
+      const steeringMessageId = generateClientMessageId();
+      const messagesBeforeSteer = resources.collector.messages.length;
+      await within(
+        "submit Codex active-turn steer",
+        30_000,
+        client.sendAgentMessage(agent.id, "hello", {
+          messageId: steeringMessageId,
+          activeTurnBehavior: "steer",
+        }),
+      );
+      const finish = await within(
+        "wait for steered Codex turn to finish",
+        150_000,
+        client.waitForFinish(agent.id, 140_000),
+      );
+      expect(finish.status).toBe("idle");
+      const postSteerMessages = resources.collector.messages.slice(messagesBeforeSteer);
+      const turnStarts = postSteerMessages.filter(
+        (message) =>
+          message.type === "agent_stream" &&
+          message.payload.agentId === agent.id &&
+          message.payload.event.type === "turn_started",
+      );
+      expect(turnStarts).toHaveLength(0);
+      expect(
+        postSteerMessages.filter(
+          (message) =>
+            message.type === "agent_stream" &&
+            message.payload.agentId === agent.id &&
+            message.payload.event.type === "turn_canceled",
+        ),
+      ).toHaveLength(0);
+      expect(
+        postSteerMessages.filter(
+          (message) =>
+            message.type === "agent_stream" &&
+            message.payload.agentId === agent.id &&
+            message.payload.event.type === "turn_completed",
+        ),
+      ).toHaveLength(1);
+      expect(
+        postSteerMessages.some((message) =>
+          isCapturedSleepCompletion(message, agent.id, foregroundSleep.callId),
+        ),
+        "the exact live sleep 5 call must complete after hello is submitted",
+      ).toBe(true);
+      expect(
+        postSteerMessages.some((message) =>
+          isCapturedSleepCancellation(message, agent.id, foregroundSleep.callId),
+        ),
+        "the exact live sleep 5 call must not be canceled or fail after hello",
+      ).toBe(false);
+      const timeline = await within(
+        "fetch steered Codex timeline",
+        15_000,
+        client.fetchAgentTimeline(agent.id, { limit: 100 }),
+      );
+      const assistantText = timeline.entries
+        .filter((entry) => entry.item.type === "assistant_message")
+        .map(
+          (entry) => (entry.item as Extract<AgentTimelineItem, { type: "assistant_message" }>).text,
+        )
+        .join("\n");
+      const steeringRows = timeline.entries.filter(
+        (entry) => entry.item.type === "user_message" && entry.item.text === "hello",
+      );
+      expect(steeringRows).toHaveLength(1);
+      expect(steeringRows[0]?.item).toMatchObject({
+        messageId: steeringMessageId,
+        clientMessageId: steeringMessageId,
+      });
+      expect(steeringRows[0]?.turnId).toBe(initialTurnId);
+      expect(assistantText).toContain("STEERED_SAME_TURN");
+    } finally {
+      const cleanup = await Promise.allSettled([
+        Promise.resolve(resources.collector?.unsubscribe()),
+        resources.client?.close() ?? Promise.resolve(),
+        resources.daemon?.close() ?? Promise.resolve(),
+      ]);
+      if (resources.cwd) rmSync(resources.cwd, { recursive: true, force: true });
+      const failures = cleanup.flatMap((result) =>
+        result.status === "rejected" ? [result.reason] : [],
+      );
+      expect(failures, "Codex steering E2E cleanup failures").toEqual([]);
+    }
+  }, 210_000);
+
   test("does not emit an idle agent_update between UI send and the replacement Codex turn", async () => {
     const logger = pino({ level: "silent" });
     const cwd = tmpCwd();
     const daemon = await createTestPaseoDaemon({
-      agentClients: createRealProviderClients(["codex"], logger),
+      agentClients: { codex: new CodexAppServerAgentClient(logger) },
       logger,
     });
     const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
@@ -172,7 +404,10 @@ describe("daemon E2E (real codex) - send message during tool call", () => {
       const agent = await client.createAgent({
         cwd,
         title: "codex-tool-interrupt-repro",
-        ...getRealProviderConfig("codex"),
+        provider: "codex",
+        model: "gpt-5.4",
+        thinkingOptionId: "low",
+        modeId: "full-access",
       });
 
       collector = createMessageCollector(client);
@@ -186,7 +421,7 @@ describe("daemon E2E (real codex) - send message during tool call", () => {
         (snapshot) => snapshot.status === "running",
         60_000,
       );
-      await waitForAssistantWaitingOnSleep(client, agent.id);
+      await waitForRunningCodexSleep(client, collector, agent.id, 75_000, /\bsleep 60\b/);
 
       collector.clear();
 
@@ -235,7 +470,7 @@ describe("daemon E2E (real codex) - send message during tool call", () => {
     const logger = pino({ level: "silent" });
     const cwd = tmpCwd();
     const daemon = await createTestPaseoDaemon({
-      agentClients: createRealProviderClients(["codex"], logger),
+      agentClients: { codex: new CodexAppServerAgentClient(logger) },
       logger,
     });
     const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
@@ -248,7 +483,10 @@ describe("daemon E2E (real codex) - send message during tool call", () => {
       const agent = await client.createAgent({
         cwd,
         title: "codex-quick-follow-up-repro",
-        ...getRealProviderConfig("codex"),
+        provider: "codex",
+        model: "gpt-5.4",
+        thinkingOptionId: "low",
+        modeId: "full-access",
       });
 
       collector = createMessageCollector(client);

packages/server/src/server/session.ts

@@ -6621,21 +6621,26 @@ export class Session {
             hasOlder: selectedTimeline.hasOlder,
             hasNewer: selectedTimeline.hasNewer,
             ...(msg.mergeWindow === true ? { mergeWindow: true } : {}),
-            entries: selectedTimeline.entries.map((entry) => ({
-              provider: snapshot.provider,
-              item: entry.item,
-              timestamp: entry.timestamp,
-              seqStart: entry.seqStart,
-              seqEnd: entry.seqEnd,
-              sourceSeqRanges: entry.sourceSeqRanges,
-              collapsed: (
-                source
-                  ? this.supportsForSource(CLIENT_CAPS.reasoningMergeEnum, source)
-                  : this.supports(CLIENT_CAPS.reasoningMergeEnum)
-              )
-                ? entry.collapsed
-                : entry.collapsed.filter((value) => value !== "reasoning_merge"),
-            })),
+            entries: selectedTimeline.entries.map((entry) => {
+              const payloadEntry = {
+                provider: snapshot.provider,
+                item: entry.item,
+                timestamp: entry.timestamp,
+                seqStart: entry.seqStart,
+                seqEnd: entry.seqEnd,
+                sourceSeqRanges: entry.sourceSeqRanges,
+                turnId: undefined as string | undefined,
+                collapsed: (
+                  source
+                    ? this.supportsForSource(CLIENT_CAPS.reasoningMergeEnum, source)
+                    : this.supports(CLIENT_CAPS.reasoningMergeEnum)
+                )
+                  ? entry.collapsed
+                  : entry.collapsed.filter((value) => value !== "reasoning_merge"),
+              };
+              payloadEntry.turnId = entry.turnId;
+              return payloadEntry;
+            }),
             error: null,
           },
         },
@@ -6904,11 +6909,12 @@ export class Session {
         {
           agentId,
           messageId: msg.messageId,
+          activeTurnBehavior: msg.activeTurnBehavior,
           textPrefix: msg.text.slice(0, 80),
         },
         "agent.session.send_agent_message",
       );
-      let dispatchResult: { outOfBand: boolean };
+      let dispatchResult: { disposition: "out_of_band" | "steered" | "turn_started" };
       try {
         dispatchResult = await sendPromptToAgent({
           agentManager: this.agentManager,
@@ -6916,6 +6922,7 @@ export class Session {
           agentId,
           prompt,
           messageId: msg.messageId,
+          activeTurnBehavior: msg.activeTurnBehavior ?? "interrupt",
           logger: this.sessionLogger,
         });
       } catch (error) {
@@ -6933,7 +6940,7 @@ export class Session {
         return;
       }
 
-      if (dispatchResult.outOfBand) {
+      if (dispatchResult.disposition !== "turn_started") {
         this.emit({
           type: "send_agent_message_response",
           payload: {

packages/server/src/server/wire-compat.test.ts

@@ -419,6 +419,32 @@ describe("wire compatibility", () => {
     expect(currentParsed.payload.entries[0]?.collapsed).toContain("reasoning_merge");
   });
 
+  test("carries canonical turn IDs to new clients while legacy schemas ignore them", async () => {
+    const response = await emitTimelineResponse({
+      rows: [
+        {
+          seq: 1,
+          timestamp: "2026-05-02T00:00:00.000Z",
+          turnId: "turn-1",
+          item: { type: "user_message", text: "prompt", clientMessageId: "message-1" },
+        },
+        {
+          seq: 2,
+          timestamp: "2026-05-02T00:00:01.000Z",
+          turnId: "turn-1",
+          item: { type: "assistant_message", text: "done" },
+        },
+      ],
+    });
+
+    expect(FetchAgentTimelineResponseMessageSchema.parse(response).payload.entries).toEqual(
+      expect.arrayContaining([expect.objectContaining({ turnId: "turn-1" })]),
+    );
+    expect(LegacyFetchAgentTimelineResponseMessageSchema.parse(response).payload.entries).toEqual(
+      expect.arrayContaining([expect.not.objectContaining({ turnId: expect.anything() })]),
+    );
+  });
+
   test("legacy worktree request shape normalizes to the same internal input as the new shape", async () => {
     const workflow = new InMemoryWorktreeWorkflow();