@@ -29,6 +29,7 @@ import type {
     ThreadGoalUpdatedNotification,
     ThreadTokenUsageUpdatedNotification,
     Turn,
+    TurnDiffUpdatedNotification,
     TurnPlanUpdatedNotification,
     WarningNotification
 } from "./app-server/v2";
@@ -232,6 +233,10 @@ export class CodexEventHandler {
     private readonly agentMessagePhases = new Map<string, string | null>();
     private readonly turnDiffs = new Map<string, string>();
     private readonly oversizedTurnDiffs = new Set<string>();
+    /** Latest diff of each subagent turn, keyed by child thread and turn; `null` marks an oversized diff. */
+    private readonly childTurnDiffs = new Map<string, {rootTurnId: string; diff: string | null}>();
+    /** The last root turn that ended, for subagent turns that outlive it. */
+    private latestRootTurnId: string | null = null;
     private readonly collectTurnDiffs: boolean;
     private readonly subagents: CodexSubagentEventRouter;
     /** Connection-level `authStatus` sink; the app-server account push feeds it. */
@@ -266,12 +271,20 @@ export class CodexEventHandler {
         return this.failure;
     }
 
+    /** The root turn's diff followed by the diffs of the subagent turns that ran during it. */
     getTurnDiff(turnId: string): string {
-        return this.turnDiffs.get(turnId) ?? "";
+        const diffs = [this.turnDiffs.get(turnId) ?? ""];
+        for (const child of this.childTurnDiffs.values()) {
+            if (child.rootTurnId === turnId && child.diff !== null) diffs.push(child.diff);
+        }
+        return diffs
+            .filter(diff => diff.trim() !== "")
+            .reduce((all, diff) => all === "" || all.endsWith("\n") ? all + diff : `${all}\n${diff}`, "");
     }
 
     isTurnDiffOversized(turnId: string): boolean {
-        return this.oversizedTurnDiffs.has(turnId);
+        return this.oversizedTurnDiffs.has(turnId)
+            || [...this.childTurnDiffs.values()].some(child => child.rootTurnId === turnId && child.diff === null);
     }
 
     getTerminalSessionFailureMeta(
@@ -399,6 +412,10 @@ export class CodexEventHandler {
             && isModelOutputItem(notification.params.item)) {
             this.sessionState.promptTokenUsage?.observeModelOutput();
         }
+        // Before subagent routing, which drops updates of ended children and of spawns that never materialized.
+        if (notification.method === "turn/diff/updated" && notification.params.threadId !== this.sessionState.sessionId) {
+            this.recordChildTurnDiff(notification.params);
+        }
         await this.flushPendingErrors();
         await this.finishCompactionsForNotification(notification);
         const closingChildren = this.subagents.closingChildSessions(notification);
@@ -502,6 +519,20 @@ export class CodexEventHandler {
         this.disposed = true;
         this.turnDiffs.clear();
         this.oversizedTurnDiffs.clear();
+        this.childTurnDiffs.clear();
+    }
+
+    /** Subagent threads report their own turn diffs; the root turn's file-change report must include them. */
+    private recordChildTurnDiff(params: TurnDiffUpdatedNotification): void {
+        if (this.disposed || !this.collectTurnDiffs) return;
+        const key = `${params.threadId}\n${params.turnId}`;
+        // A child turn stays with the root turn it started under, even if its diff updates arrive later.
+        const rootTurnId = this.childTurnDiffs.get(key)?.rootTurnId
+            ?? this.sessionState.currentTurnId
+            ?? this.latestRootTurnId;
+        if (rootTurnId === null) return;
+        const oversized = Buffer.byteLength(params.diff, "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES;
+        this.childTurnDiffs.set(key, {rootTurnId, diff: oversized ? null : params.diff});
     }
 
     private async createUpdateEvent(notification: ServerNotification): Promise<UpdateSessionEvent | null> {
@@ -560,6 +591,8 @@ export class CodexEventHandler {
             case "turn/completed":
                 await this.plans.flush();
                 this.plans.clearTurn();
+                // Subagents can keep running after the root turn ends; their turns still belong to it.
+                this.latestRootTurnId = this.sessionState.currentTurnId ?? this.latestRootTurnId;
                 this.sessionState.currentTurnId = null;
                 this.sessionState.interruptTurnId = null;
                 this.sessionState.toolCallReports.releaseOpen(this.subagents.notificationSessionId(notification));
 
@@ -6,11 +6,16 @@ import {
     type CodexMockTestFixture,
 } from "../acp-test-utils";
 import type {SessionState} from "../../CodexAcpServer";
+import {ACPSessionConnection} from "../../ACPSessionConnection";
+import {CodexSubagentEventRouter} from "../../subagents/CodexSubagentEventRouter";
+import type {ServerNotification} from "../../app-server";
 import {CodexCommands} from "../../CodexCommands";
 import {logger} from "../../Logger";
 import type {Turn, TurnCompletedNotification} from "../../app-server/v2";
 import {AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES} from "../../AgentFileChangeReport";
 
+const CHILD_THREAD_ID = "child-thread";
+
 function createTurn(id: string, status: Turn["status"]): Turn {
     return {
         id,
@@ -61,6 +66,60 @@ const FILE_CHANGE_REPORT_CLIENT_CAPABILITIES: acp.ClientCapabilities = {
     },
 };
 
+function modifiedFileDiff(pathname: string): string {
+    return `diff --git a/${pathname} b/${pathname}\n--- a/${pathname}\n+++ b/${pathname}\n@@ -1 +1 @@\n-old\n+new\n`;
+}
+
+function turnDiffUpdated(threadId: string, turnId: string, diff: string): ServerNotification {
+    return {method: "turn/diff/updated", params: {threadId, turnId, diff}};
+}
+
+/** Notifications of a root turn that spawns a native subagent, as Codex reports them. */
+function spawnChild(rootSessionId: string): ServerNotification[] {
+    return [
+        {
+            method: "item/started",
+            params: {
+                threadId: rootSessionId,
+                turnId: "main-turn",
+                startedAtMs: 0,
+                item: {
+                    type: "collabAgentToolCall",
+                    id: "spawn-child",
+                    tool: "spawnAgent",
+                    status: "inProgress",
+                    senderThreadId: rootSessionId,
+                    receiverThreadIds: [CHILD_THREAD_ID],
+                    prompt: "Edit the docs.",
+                    model: null,
+                    reasoningEffort: null,
+                    agentsStates: {[CHILD_THREAD_ID]: {status: "running", message: null}},
+                },
+            },
+        },
+        {
+            method: "item/started",
+            params: {
+                threadId: rootSessionId,
+                turnId: "main-turn",
+                startedAtMs: 0,
+                item: {
+                    type: "subAgentActivity",
+                    id: "activity-child",
+                    kind: "started",
+                    agentThreadId: CHILD_THREAD_ID,
+                    agentPath: "/root/docs_writer",
+                },
+            },
+        },
+        {method: "turn/started", params: {threadId: CHILD_THREAD_ID, turn: createTurn("child-turn", "inProgress")}},
+    ];
+}
+
+function childTurnCompleted(): ServerNotification {
+    return {method: "turn/completed", params: {threadId: CHILD_THREAD_ID, turn: createTurn("child-turn", "completed")}};
+}
+
 async function setupMainPrompt(negotiateCapability = true): Promise<{
     fixture: CodexMockTestFixture;
     sessionState: SessionState;
@@ -87,6 +146,32 @@ async function setupMainPrompt(negotiateCapability = true): Promise<{
     return {fixture, sessionState, turnStart, awaitTurnCompleted};
 }
 
+async function setupNativeSubagentPrompt(): Promise<{
+    fixture: CodexMockTestFixture;
+    sessionState: SessionState;
+    awaitTurnCompleted: ReturnType<typeof vi.spyOn>;
+}> {
+    const fixture = createCodexMockTestFixture();
+    await fixture.getCodexAcpAgent().initialize({
+        protocolVersion: acp.PROTOCOL_VERSION,
+        clientCapabilities: {
+            _meta: {jetbrains: {air: {version: 1, capabilities: ["agentFileChangeReport", "nativeSubagentSessions"]}}},
+        },
+    });
+    const sessionState = createTestSessionState({cwd: "/workspace"});
+    sessionState.subagents = new CodexSubagentEventRouter(
+        sessionState.sessionId,
+        true,
+        new ACPSessionConnection(fixture.getAcpConnection(), sessionState.sessionId),
+        () => {},
+    );
+    vi.spyOn(fixture.getCodexAcpAgent(), "getSessionState").mockReturnValue(sessionState);
+    vi.spyOn(fixture.getCodexAppServerClient(), "turnStart")
+        .mockResolvedValue({turn: createTurn("main-turn", "inProgress")});
+    const awaitTurnCompleted = vi.spyOn(fixture.getCodexAppServerClient(), "awaitTurnCompleted");
+    return {fixture, sessionState, awaitTurnCompleted};
+}
+
 describe("agent file-change report lifecycle", () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -321,4 +406,85 @@ describe("agent file-change report lifecycle", () => {
             }}}},
         });
     });
+
+    describe("with native subagents", () => {
+        it("includes the files a subagent changed during the root turn", async () => {
+            const {fixture, sessionState, awaitTurnCompleted} = await setupNativeSubagentPrompt();
+            awaitTurnCompleted.mockImplementationOnce(async (): Promise<TurnCompletedNotification> => {
+                for (const notification of [
+                    turnDiffUpdated(sessionState.sessionId, "main-turn", modifiedFileDiff("README.md")),
+                    ...spawnChild(sessionState.sessionId),
+                    turnDiffUpdated(CHILD_THREAD_ID, "child-turn", modifiedFileDiff("README.md")
+                        + modifiedFileDiff("community/README.md")),
+                    childTurnCompleted(),
+                ]) {
+                    fixture.sendServerNotification(notification);
+                }
+                return {threadId: sessionState.sessionId, turn: createTurn("main-turn", "completed")};
+            });
+
+            await expect(fixture.getCodexAcpAgent().prompt(
+                promptWithFileChangeReport(sessionState.sessionId, "request-subagent"),
+            )).resolves.toMatchObject({stopReason: "end_turn"});
+
+            expect(reportedUpdates(fixture)[0]).toMatchObject({
+                _meta: {jetbrains: {air: {agentFileChangeReport: {
+                    status: "reported",
+                    paths: ["/workspace/README.md", "/workspace/community/README.md"],
+                }}}},
+            });
+        });
+
+        it("includes the files of a subagent that finishes after the root turn ends", async () => {
+            const {fixture, sessionState, awaitTurnCompleted} = await setupNativeSubagentPrompt();
+            awaitTurnCompleted.mockImplementationOnce(async (): Promise<TurnCompletedNotification> => {
+                const completed = {threadId: sessionState.sessionId, turn: createTurn("main-turn", "completed")};
+                for (const notification of [
+                    ...spawnChild(sessionState.sessionId),
+                    {method: "turn/completed", params: completed} satisfies ServerNotification,
+                    turnDiffUpdated(CHILD_THREAD_ID, "child-turn", modifiedFileDiff("docs/guide.md")),
+                    childTurnCompleted(),
+                ]) {
+                    fixture.sendServerNotification(notification);
+                }
+                return completed;
+            });
+
+            await fixture.getCodexAcpAgent().prompt(
+                promptWithFileChangeReport(sessionState.sessionId, "request-late-subagent"),
+            );
+
+            expect(reportedUpdates(fixture)[0]).toMatchObject({
+                _meta: {jetbrains: {air: {agentFileChangeReport: {
+                    status: "reported",
+                    paths: ["/workspace/docs/guide.md"],
+                }}}},
+            });
+        });
+
+        it("publishes invalidOutput when a subagent turn diff is oversized", async () => {
+            const {fixture, sessionState, awaitTurnCompleted} = await setupNativeSubagentPrompt();
+            awaitTurnCompleted.mockImplementationOnce(async (): Promise<TurnCompletedNotification> => {
+                for (const notification of [
+                    ...spawnChild(sessionState.sessionId),
+                    turnDiffUpdated(CHILD_THREAD_ID, "child-turn", "x".repeat(AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES + 1)),
+                    childTurnCompleted(),
+                ]) {
+                    fixture.sendServerNotification(notification);
+                }
+                return {threadId: sessionState.sessionId, turn: createTurn("main-turn", "completed")};
+            });
+
+            await fixture.getCodexAcpAgent().prompt(
+                promptWithFileChangeReport(sessionState.sessionId, "request-oversized-subagent"),
+            );
+
+            expect(reportedUpdates(fixture)[0]).toMatchObject({
+                _meta: {jetbrains: {air: {agentFileChangeReport: {
+                    status: "unavailable",
+                    reason: "invalidOutput",
+                }}}},
+            });
+        });
+    });
 });
@@ -34,13 +34,22 @@ describe("CodexEventHandler - turn diff events", () => {
         expect(disabled.getTurnDiff("turn-1")).toBe("");
 
         const enabled = createHandler(true).handler;
-        await enabled.handleNotification(turnDiff("child-thread", "child diff"));
-        expect(enabled.getTurnDiff("turn-1")).toBe("");
-
         await enabled.handleNotification(turnDiff(sessionId, "root diff"));
         expect(enabled.getTurnDiff("turn-1")).toBe("root diff");
     });
 
+    it("appends subagent turn diffs to the root turn that was running", async () => {
+        const {handler} = createHandler(true);
+        await handler.handleNotification(turnDiff(sessionId, "root diff"));
+        await handler.handleNotification({
+            method: "turn/diff/updated",
+            params: {threadId: "child-thread", turnId: "child-turn", diff: "child diff\n"},
+        });
+
+        expect(handler.getTurnDiff("turn-1")).toBe("root diff\nchild diff\n");
+        expect(handler.getTurnDiff("child-turn")).toBe("");
+    });
+
     it("clears a prior snapshot when Codex emits the final empty aggregate", async () => {
         const {handler} = createHandler(true);
         await handler.handleNotification(turnDiff(sessionId, "root diff"));
@@ -119,6 +128,5 @@ describe("CodexEventHandler - turn diff events", () => {
         await handler.handleNotification(turnDiff("child-thread", "child diff"));
 
         expect(sessionState.sessionFailure).toMatchObject({severity: "warning"});
-        expect(handler.getTurnDiff("turn-1")).toBe("");
     });
 });