@@ -3563,17 +3563,22 @@ const chatSteeringQueueKey = locals.create<SteeringQueueEntry[]>("chat.steeringQ
 const chatTurnNewUIMessagesKey = locals.create<UIMessage[]>("chat.turnNewUIMessages");
 
 /**
- * Set when a steering drain appended to the UI accumulator, so the model
- * accumulator gets rebuilt from it at the end of the turn.
+ * Steering messages a drain consumed that the model accumulator has not been
+ * given yet.
  *
  * The two accumulators are maintained separately, and the model one is
  * normally advanced by appending each turn's delta. A drained message is
  * appended to the UI one but reaches the model only through the `prepareStep`
- * return value, which is per-step: without a rebuild the model lane never
- * learns the message exists and every later turn of the run answers without
- * it, while the browser, the snapshot and `chat.history.*` all still show it.
+ * return value, which is per-step: without this the model lane never learns
+ * the message exists and every later turn of the run answers without it,
+ * while the browser, the snapshot and `chat.history.*` all still show it.
+ *
+ * Held as the messages rather than a "rebuild me" flag because the model lane
+ * can only be appended to, never reconstructed. Compaction replaces it with a
+ * summary and deliberately leaves the UI lane whole, so reconverting the UI
+ * lane restores every message the summary replaced.
  */
-const chatModelLaneStaleKey = locals.create<boolean>("chat.modelLaneStale");
+const chatPendingSteerKey = locals.create<UIMessage[]>("chat.pendingSteer");
 /** @internal — IDs of messages that were successfully injected via prepareStep */
 const chatInjectedMessageIdsKey = locals.create<Set<string>>("chat.injectedMessageIds");
 /** @internal — non-transient data parts queued via chat.response or writer.write() for accumulation into the response message */
@@ -4315,7 +4320,11 @@ async function drainSteeringQueue(
         }
       }
       if (claimedUIMessages.length > 0 && currentUIMessages) {
-        locals.set(chatModelLaneStaleKey, true);
+        const pendingSteer = locals.get(chatPendingSteerKey) ?? [];
+        for (const m of claimedUIMessages) {
+          if (!pendingSteer.some((existing) => existing.id === m.id)) pendingSteer.push(m);
+        }
+        locals.set(chatPendingSteerKey, pendingSteer);
       }
 
       // Write injection confirmation chunk to the stream so the frontend
@@ -8543,6 +8552,27 @@ function chatAgent<
                   // Determine if the user stopped generation this turn (not a full run cancel).
                   const wasStopped = stopController.signal.aborted && !runSignal.aborted;
 
+                  // Give the model accumulator the steering messages the drain
+                  // consumed. Appended, never reconverted from the UI lane, so a
+                  // model-only compaction summary set just above survives; and done
+                  // before the response is appended so the order stays
+                  // steer-then-answer. Outside the `capturedResponseMessage`
+                  // branches below, so a turn that captured no response is covered.
+                  const pendingSteer = locals.get(chatPendingSteerKey);
+                  if (pendingSteer && pendingSteer.length > 0) {
+                    locals.set(chatPendingSteerKey, []);
+                    try {
+                      accumulatedMessages.push(
+                        ...(await toModelMessages(pendingSteer.map(stripProviderMetadata)))
+                      );
+                    } catch (error) {
+                      logger.warn(
+                        "chat.agent: toModelMessages failed for an injected message; it will be missing from the next turn",
+                        { error: error instanceof Error ? error.message : String(error) }
+                      );
+                    }
+                  }
+
                   // Append the assistant's response (partial or complete) to the accumulator.
                   // The onFinish callback fires even on abort/stop, so partial responses
                   // from stopped generation are captured correctly.
@@ -8631,23 +8661,6 @@ function chatAgent<
                     turnBufferedChunks.length = 0;
                   }
 
-                  // Bring the model accumulator back in line with the UI one
-                  // after a steering drain. Placed after response accumulation
-                  // and before compaction reads `accumulatedMessages`, and
-                  // outside the `capturedResponseMessage` branches so a turn
-                  // that captured no response is covered too.
-                  if (locals.get(chatModelLaneStaleKey)) {
-                    locals.set(chatModelLaneStaleKey, false);
-                    try {
-                      accumulatedMessages = await toModelMessages(accumulatedUIMessages);
-                    } catch (error) {
-                      logger.warn(
-                        "chat.agent: toModelMessages failed rebuilding after an injection; the injected message will be missing from the next turn",
-                        { error: error instanceof Error ? error.message : String(error) }
-                      );
-                    }
-                  }
-
                   if (runSignal.aborted) return "exit";
 
                   // Await deferred background work (e.g. DB writes from onTurnStart)
@@ -10669,20 +10682,18 @@ class ChatMessageAccumulator {
    * The drain only puts them in this step's prompt, so without this they
    * shape one answer and then exist in neither lane: not in `uiMessages`,
    * which is what an app persists from, and not in `modelMessages`, which is
-   * what every later turn sends. The UI lane is authoritative and the model
-   * lane is its conversion, matching how `chat.agent` reconciles the two.
+   * what every later turn sends.
+   *
+   * Both lanes are appended to. The model lane is never reconverted from the
+   * UI lane, because `compactIfNeeded` replaces it with a summary and leaves
+   * the UI lane whole: a reconversion would restore everything the summary
+   * replaced.
    */
   async absorbSteering(claimed: UIMessage[]): Promise<void> {
-    if (claimed.length === 0) return;
-    let added = false;
-    for (const m of claimed) {
-      if (!this.uiMessages.some((existing) => existing.id === m.id)) {
-        this.uiMessages.push(m);
-        added = true;
-      }
-    }
-    if (!added) return;
-    this.modelMessages = await toModelMessages(this.uiMessages);
+    const fresh = claimed.filter((m) => !this.uiMessages.some((e) => e.id === m.id));
+    if (fresh.length === 0) return;
+    this.uiMessages.push(...fresh);
+    this.modelMessages.push(...(await toModelMessages(fresh)));
   }
 
   /**
 
@@ -0,0 +1,60 @@
+import type { UIMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import { chat } from "../src/v3/ai.js";
+
+/**
+ * `chat.MessageAccumulator` compaction is model-only: it replaces
+ * `modelMessages` with a summary and leaves `uiMessages` whole so the chat can
+ * still display the conversation. Recording a steer by reconverting
+ * `modelMessages` from `uiMessages` therefore restores everything the summary
+ * replaced, on the next steer after any compaction.
+ *
+ * Asserted directly on the accumulator: no run, no model, no harness, because
+ * the whole question is which of its two lanes gets written and how.
+ */
+
+const USAGE = {
+  inputTokens: { total: 10, noCache: 10, cacheRead: undefined, cacheWrite: undefined },
+  outputTokens: { total: 5, text: 5, reasoning: undefined },
+  totalTokens: 15,
+};
+
+const userMessage = (text: string, id: string): UIMessage =>
+  ({ id, role: "user", parts: [{ type: "text", text }] }) as UIMessage;
+
+const assistantMessage = (text: string, id: string): UIMessage =>
+  ({ id, role: "assistant", parts: [{ type: "text", text }] }) as UIMessage;
+
+const flatten = (messages: { content: unknown }[]) => JSON.stringify(messages);
+
+describe("chat.MessageAccumulator steering after compaction", () => {
+  it("keeps the summary in the model lane when a later steer is absorbed", async () => {
+    const conversation = new chat.MessageAccumulator({
+      compaction: {
+        shouldCompact: () => true,
+        summarize: async () => "SUMMARY-OF-EVERYTHING",
+      },
+    });
+
+    await conversation.addIncoming([userMessage("EARLY-SENTINEL", "u-1")], "submit-message", 0);
+    await conversation.addResponse(assistantMessage("first answer", "a-1"));
+
+    const didCompact = await conversation.compactIfNeeded(USAGE as never);
+    expect(didCompact).toBe(true);
+
+    // Compaction is model-only, so the two lanes deliberately disagree here.
+    expect(flatten(conversation.modelMessages)).toContain("SUMMARY-OF-EVERYTHING");
+    expect(flatten(conversation.modelMessages)).not.toContain("EARLY-SENTINEL");
+    expect(JSON.stringify(conversation.uiMessages)).toContain("EARLY-SENTINEL");
+
+    await conversation.absorbSteering([userMessage("steer-me", "u-2")]);
+
+    // The steer has to land in both lanes.
+    expect(JSON.stringify(conversation.uiMessages)).toContain("steer-me");
+    expect(flatten(conversation.modelMessages)).toContain("steer-me");
+    // And the compaction has to survive it. Reconverting from the UI lane
+    // brings the compacted message back and drops the summary.
+    expect(flatten(conversation.modelMessages)).toContain("SUMMARY-OF-EVERYTHING");
+    expect(flatten(conversation.modelMessages)).not.toContain("EARLY-SENTINEL");
+  });
+});
@@ -0,0 +1,178 @@
+import { mockChatAgent } from "../src/v3/test/index.js";
+
+import { sessionStreams } from "@trigger.dev/core/v3";
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import { simulateReadableStream, stepCountIs, streamText, tool } from "ai";
+import { MockLanguageModelV3 } from "ai/test";
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { chat } from "../src/v3/ai.js";
+
+/**
+ * Steering and compaction in the same turn.
+ *
+ * Compaction is model-only by design: it replaces the model messages with a
+ * summary and deliberately leaves the UI messages whole, so the chat still
+ * displays the full conversation. Reconciling the model lane by rebuilding it
+ * from the UI lane therefore un-compacts it, and the next turn is sent the
+ * entire pre-compaction transcript.
+ *
+ * The assertion that catches this is the absence of an early message, not the
+ * presence of the steer: a rebuild puts the steer in the prompt too, so a
+ * steer-presence check passes while compaction has been silently undone.
+ */
+
+const USAGE = {
+  inputTokens: { total: 1, noCache: 1, cacheRead: undefined, cacheWrite: undefined },
+  outputTokens: { total: 1, text: 1, reasoning: undefined },
+};
+
+function userMessage(text: string, id: string) {
+  return { id, role: "user" as const, parts: [{ type: "text" as const, text }] };
+}
+
+function deferred() {
+  let resolve!: () => void;
+  const promise = new Promise<void>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+async function waitFor(check: () => boolean, label = "condition", timeoutMs = 8_000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (check()) return;
+    await new Promise((r) => setTimeout(r, 10));
+  }
+  throw new Error(`waitFor timed out: ${label}`);
+}
+
+function textChunks(text: string): LanguageModelV3StreamPart[] {
+  return [
+    { type: "text-start", id: "t1" },
+    { type: "text-delta", id: "t1", delta: text },
+    { type: "text-end", id: "t1" },
+    { type: "finish", finishReason: { unified: "stop", raw: "stop" }, usage: USAGE },
+  ];
+}
+
+function toolCallChunks(callId: string): LanguageModelV3StreamPart[] {
+  return [
+    { type: "tool-call", toolCallId: callId, toolName: "gate", input: JSON.stringify({ q: "go" }) },
+    { type: "finish", finishReason: { unified: "tool-calls", raw: "tool-calls" }, usage: USAGE },
+  ];
+}
+
+type SeqReader = { lastSeqNum: (chatId: string, dir: "in" | "out") => number | undefined };
+
+async function sendAndLand(
+  harness: { sendMessage: (m: ReturnType<typeof userMessage>) => Promise<unknown> },
+  chatId: string,
+  text: string,
+  id: string
+) {
+  const seqs = sessionStreams as unknown as SeqReader;
+  const before = seqs.lastSeqNum(chatId, "in") ?? -1;
+  void harness.sendMessage(userMessage(text, id));
+  await waitFor(() => (seqs.lastSeqNum(chatId, "in") ?? -1) > before, `append ${id}`);
+}
+
+const flatUserTexts = (prompt: { role: string; content: unknown }[]) =>
+  prompt
+    .filter((m) => m.role === "user")
+    .flatMap((m) =>
+      Array.isArray(m.content)
+        ? (m.content as { type: string; text?: string }[])
+            .filter((c) => c.type === "text")
+            .map((c) => c.text ?? "")
+        : []
+    );
+
+describe("chat.agent steering with compaction in the same turn", () => {
+  it("keeps the summary and adds the steer, rather than restoring the transcript", async () => {
+    const chatId = "steer-compaction";
+    const toolGate = deferred();
+    let toolEntered = false;
+    const prompts: string[][] = [];
+    const allPrompts: string[] = [];
+
+    const gateTool = tool({
+      description: "blocks until the test opens it",
+      inputSchema: z.object({ q: z.string() }),
+      execute: async () => {
+        toolEntered = true;
+        await toolGate.promise;
+        return "ok";
+      },
+    });
+
+    let step = 0;
+    const model = new MockLanguageModelV3({
+      doStream: async ({ prompt }) => {
+        prompts.push(flatUserTexts(prompt));
+        allPrompts.push(JSON.stringify(prompt));
+        const isToolStep = step++ % 2 === 0;
+        return {
+          stream: simulateReadableStream({
+            chunks: isToolStep ? toolCallChunks(`tc-${step}`) : textChunks("done"),
+            initialDelayInMs: 10,
+            chunkDelayInMs: 2,
+          }),
+        };
+      },
+    });
+
+    let compacted = 0;
+    const agent = chat.agent({
+      id: "steer-compaction",
+      pendingMessages: { shouldInject: () => true },
+      compaction: {
+        // Compact once, at the first step boundary of turn 1.
+        shouldCompact: () => compacted === 0,
+        summarize: async () => {
+          compacted++;
+          return "SUMMARY-OF-EVERYTHING";
+        },
+      },
+      run: async ({ messages, signal }) =>
+        streamText({
+          model,
+          messages,
+          abortSignal: signal,
+          ...chat.toStreamTextOptions(),
+          tools: { gate: gateTool },
+          stopWhen: stepCountIs(5),
+        }),
+    });
+
+    const harness = mockChatAgent(agent, { chatId });
+    try {
+      const first = harness.sendMessage(userMessage("EARLY-SENTINEL", "u-1"));
+      await waitFor(() => toolEntered, "tool entered");
+      await sendAndLand(harness, chatId, "steer-me", "u-2");
+      toolGate.resolve();
+      await first;
+
+      await waitFor(() => compacted > 0, "compaction ran");
+      const promptsAfterTurn1 = prompts.length;
+
+      await harness.sendMessage(userMessage("m3", "u-3"));
+      await waitFor(() => prompts.length > promptsAfterTurn1, "turn 2 prompt built");
+
+      const turn2 = prompts[promptsAfterTurn1]!;
+      const turn2Raw = allPrompts[promptsAfterTurn1]!;
+
+      // The steer has to survive.
+      expect(turn2).toContain("steer-me");
+      // And so does the compaction: the summary is what the model gets...
+      expect(turn2Raw).toContain("SUMMARY-OF-EVERYTHING");
+      // ...instead of the message the summary replaced. This is the assertion a
+      // rebuild-based reconciliation fails.
+      expect(turn2).not.toContain("EARLY-SENTINEL");
+    } finally {
+      toolGate.resolve();
+      await harness.close();
+    }
+  });
+});