@getpaseo/server 0.1.63 → 0.1.66

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -5,15 +5,17 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { z } from "zod";
-import { loadCodexPersistedTimeline } from "./codex-rollout-timeline.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
+import { curateAgentActivity } from "../activity-curator.js";
 import { mapCodexRolloutToolCall, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
 import { createProviderEnv, createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
+import { terminateProcessTree } from "../../../utils/process-tree.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { runProviderTurn } from "./provider-runner.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
@@ -21,6 +23,7 @@ const APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 2000;
 const APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 const CODEX_PROVIDER = "codex";
 const CODEX_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
+const ASSISTANT_MESSAGE_BOUNDARY_MARKDOWN = "\n\n---\n\n";
 const CODEX_PLAN_IMPLEMENTATION_PROMPT_PREFIX = "The user approved the plan. Implement it now. Do not restate or revise the plan unless blocked.";
 const CODEX_APP_SERVER_CAPABILITIES = {
     supportsStreaming: true,
@@ -406,11 +409,7 @@ class CodexAppServerClient {
         this.nextId = 1;
         this.disposed = false;
         this.stderrBuffer = "";
-        this.resolveExitPromise = null;
         this.rl = readline.createInterface({ input: child.stdout });
-        this.exitPromise = new Promise((resolve) => {
-            this.resolveExitPromise = resolve;
-        });
         this.rl.on("line", (line) => this.handleLine(line));
         child.stderr.on("data", (chunk) => {
             this.stderrBuffer += chunk.toString();
@@ -426,8 +425,6 @@ class CodexAppServerClient {
             }
             this.pending.clear();
             this.disposed = true;
-            this.resolveExitPromise?.();
-            this.resolveExitPromise = null;
         });
         child.on("exit", (code, signal) => {
             const message = code === 0 && !signal
@@ -440,8 +437,6 @@ class CodexAppServerClient {
             }
             this.pending.clear();
             this.disposed = true;
-            this.resolveExitPromise?.();
-            this.resolveExitPromise = null;
         });
     }
     setNotificationHandler(handler) {
@@ -495,31 +490,15 @@ class CodexAppServerClient {
         catch {
             // ignore
         }
-        signalChildProcessTree(this.child, "SIGTERM");
-        if (await this.waitForExit(APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS)) {
-            return;
-        }
-        this.logger.warn({ timeoutMs: APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "Codex app-server did not exit after SIGTERM; sending SIGKILL");
-        signalChildProcessTree(this.child, "SIGKILL");
-        if (await this.waitForExit(APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS)) {
-            return;
-        }
-        this.logger.warn({ timeoutMs: APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "Codex app-server did not report exit after SIGKILL");
-    }
-    async waitForExit(timeoutMs) {
-        let timer = null;
-        try {
-            return await Promise.race([
-                this.exitPromise.then(() => true),
-                new Promise((resolve) => {
-                    timer = setTimeout(() => resolve(false), timeoutMs);
-                }),
-            ]);
-        }
-        finally {
-            if (timer) {
-                clearTimeout(timer);
-            }
+        const result = await terminateProcessTree(this.child, {
+            gracefulTimeoutMs: APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+            forceTimeoutMs: APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
+            onForceSignal: () => {
+                this.logger.warn({ timeoutMs: APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "Codex app-server did not exit after SIGTERM; sending SIGKILL");
+            },
+        });
+        if (result === "kill-timeout") {
+            this.logger.warn({ timeoutMs: APP_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "Codex app-server did not report exit after SIGKILL");
         }
     }
     async handleLine(line) {
@@ -572,26 +551,6 @@ class CodexAppServerClient {
         }
     }
 }
-function signalChildProcessTree(child, signal) {
-    if (child.exitCode !== null || child.signalCode !== null) {
-        return;
-    }
-    if (process.platform !== "win32" && typeof child.pid === "number" && child.pid > 0) {
-        try {
-            process.kill(-child.pid, signal);
-            return;
-        }
-        catch {
-            // Fall back to the direct child when no separate process group exists.
-        }
-    }
-    try {
-        child.kill(signal);
-    }
-    catch {
-        // ignore
-    }
-}
 function toAgentUsage(tokenUsage) {
     if (!tokenUsage || typeof tokenUsage !== "object")
         return undefined;
@@ -881,6 +840,8 @@ function normalizeCodexThreadItemType(rawType) {
             return "mcpToolCall";
         case "WebSearch":
             return "webSearch";
+        case "CollabAgentToolCall":
+            return "collabAgentToolCall";
         default:
             return rawType;
     }
@@ -1183,11 +1144,51 @@ function threadItemToTimeline(item, options) {
         case "fileChange":
         case "mcpToolCall":
         case "webSearch":
+        case "collabAgentToolCall":
             return mapCodexToolCallFromThreadItem(normalizedItem, { cwd });
         default:
             return null;
     }
 }
+const CodexThreadReadResponseSchema = z
+    .object({
+    thread: z
+        .object({
+        turns: z
+            .array(z
+            .object({
+            items: z.array(z.unknown()).default([]),
+        })
+            .passthrough())
+            .default([]),
+    })
+        .passthrough()
+        .default({ turns: [] }),
+})
+    .passthrough();
+async function requestCodexThreadHistory(requestThread, threadId) {
+    const response = await requestThread(threadId);
+    return CodexThreadReadResponseSchema.parse(response);
+}
+async function loadCodexThreadHistoryTimeline(params) {
+    const response = await requestCodexThreadHistory(params.requestThread, params.threadId);
+    const timeline = [];
+    for (const turn of response.thread.turns) {
+        for (const item of turn.items) {
+            const timelineItem = threadItemToTimeline(item, { cwd: params.cwd });
+            if (timelineItem) {
+                timeline.push(timelineItem);
+            }
+        }
+    }
+    return timeline;
+}
+function readCodexThread(client, threadId) {
+    return client.request("thread/read", {
+        threadId,
+        includeTurns: true,
+    });
+}
 function toSandboxPolicy(type, networkAccess) {
     switch (type) {
         case "read-only":
@@ -1234,11 +1235,13 @@ const ThreadStartedNotificationSchema = z
     .passthrough();
 const TurnStartedNotificationSchema = z
     .object({
+    threadId: z.string().optional(),
     turn: z.object({ id: z.string() }).passthrough(),
 })
     .passthrough();
 const TurnCompletedNotificationSchema = z
     .object({
+    threadId: z.string().optional(),
     turn: z
         .object({
         status: z.string(),
@@ -1275,12 +1278,14 @@ const ThreadTokenUsageUpdatedNotificationSchema = z
     .passthrough();
 const ItemTextDeltaNotificationSchema = z
     .object({
+    threadId: z.string().optional(),
     itemId: z.string(),
     delta: z.string(),
 })
     .passthrough();
 const ItemLifecycleNotificationSchema = z
     .object({
+    threadId: z.string().optional(),
     item: z
         .object({
         id: z.string().optional(),
@@ -1310,9 +1315,12 @@ const CodexEventTaskCompleteNotificationSchema = z
     .passthrough();
 const CodexEventItemLifecycleNotificationSchema = z
     .object({
+    threadId: z.string().optional(),
     msg: z
         .object({
         type: z.enum(["item_started", "item_completed"]),
+        threadId: z.string().optional(),
+        thread_id: z.string().optional(),
         item: z
             .object({
             id: z.string().optional(),
@@ -1442,9 +1450,11 @@ const CodexNotificationSchema = z.union([
         method,
         params,
     })),
-    z
-        .object({ method: z.literal("turn/started"), params: TurnStartedNotificationSchema })
-        .transform(({ params }) => ({ kind: "turn_started", turnId: params.turn.id })),
+    z.object({ method: z.literal("turn/started"), params: TurnStartedNotificationSchema }).transform(({ params }) => ({
+        kind: "turn_started",
+        turnId: params.turn.id,
+        threadId: params.threadId ?? null,
+    })),
     z.object({ method: z.literal("turn/started"), params: z.unknown() }).transform(({ method, params }) => ({
         kind: "invalid_payload",
         method,
@@ -1456,6 +1466,7 @@ const CodexNotificationSchema = z.union([
         kind: "turn_completed",
         status: params.turn.status,
         errorMessage: params.turn.error?.message ?? null,
+        threadId: params.threadId ?? null,
     })),
     z.object({ method: z.literal("turn/completed"), params: z.unknown() }).transform(({ method, params }) => ({
         kind: "invalid_payload",
@@ -1507,6 +1518,7 @@ const CodexNotificationSchema = z.union([
         kind: "agent_message_delta",
         itemId: params.itemId,
         delta: params.delta,
+        threadId: params.threadId ?? null,
     })),
     z.object({ method: z.literal("item/agentMessage/delta"), params: z.unknown() }).transform(({ method, params }) => ({
         kind: "invalid_payload",
@@ -1522,6 +1534,7 @@ const CodexNotificationSchema = z.union([
         kind: "reasoning_delta",
         itemId: params.itemId,
         delta: params.delta,
+        threadId: params.threadId ?? null,
     })),
     z.object({ method: z.literal("item/reasoning/summaryTextDelta"), params: z.unknown() }).transform(({ method, params }) => ({
         kind: "invalid_payload",
@@ -1533,6 +1546,7 @@ const CodexNotificationSchema = z.union([
         .transform(({ params }) => ({
         kind: "item_completed",
         source: "item",
+        threadId: params.threadId ?? null,
         item: params.item,
     })),
     z.object({ method: z.literal("item/completed"), params: z.unknown() }).transform(({ method, params }) => ({
@@ -1545,6 +1559,7 @@ const CodexNotificationSchema = z.union([
         .transform(({ params }) => ({
         kind: "item_started",
         source: "item",
+        threadId: params.threadId ?? null,
         item: params.item,
     })),
     z.object({ method: z.literal("item/started"), params: z.unknown() }).transform(({ method, params }) => ({
@@ -1560,6 +1575,7 @@ const CodexNotificationSchema = z.union([
         .transform(({ params }) => ({
         kind: "item_started",
         source: "codex_event",
+        threadId: params.threadId ?? params.msg.threadId ?? params.msg.thread_id ?? null,
         item: params.msg.item,
     })),
     z.object({ method: z.literal("codex/event/item_started"), params: z.unknown() }).transform(({ method, params }) => ({
@@ -1575,6 +1591,7 @@ const CodexNotificationSchema = z.union([
         .transform(({ params }) => ({
         kind: "item_completed",
         source: "codex_event",
+        threadId: params.threadId ?? params.msg.threadId ?? params.msg.thread_id ?? null,
         item: params.msg.item,
     })),
     z.object({ method: z.literal("codex/event/item_completed"), params: z.unknown() }).transform(({ method, params }) => ({
@@ -1759,6 +1776,7 @@ const CodexNotificationSchema = z.union([
         kind: "turn_completed",
         status: "interrupted",
         errorMessage: null,
+        threadId: null,
     })),
     z.object({ method: z.literal("codex/event/turn_aborted"), params: z.unknown() }).transform(({ method, params }) => ({
         kind: "invalid_payload",
@@ -1774,6 +1792,7 @@ const CodexNotificationSchema = z.union([
         kind: "turn_completed",
         status: "completed",
         errorMessage: null,
+        threadId: null,
     })),
     z.object({ method: z.literal("codex/event/task_complete"), params: z.unknown() }).transform(({ method, params }) => ({
         kind: "invalid_payload",
@@ -1824,40 +1843,49 @@ async function readCodexConfiguredDefaults(client, logger) {
 }
 export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
     if (typeof prompt === "string") {
-        return [{ type: "text", text: prompt }];
-    }
-    const blocks = prompt;
-    const output = await Promise.all(blocks.map(async (block) => {
-        if (!block || typeof block !== "object") {
-            return block;
+        return [toCodexTextInput(prompt)];
+    }
+    const output = [];
+    let previousTextBlock = false;
+    for (const block of prompt) {
+        if (block.type === "text") {
+            output.push(toCodexTextInput(block.text));
+            previousTextBlock = block.text.length > 0;
+            continue;
         }
-        const record = block;
-        if (record.type === "image" &&
-            typeof record.mimeType === "string" &&
-            typeof record.data === "string") {
+        if (block.type === "skill") {
+            output.push(block);
+            previousTextBlock = false;
+            continue;
+        }
+        if (block.type === "image") {
             try {
-                const filePath = await writeImageAttachment(record.mimeType, record.data);
-                return { type: "localImage", path: filePath };
+                const filePath = await writeImageAttachment(block.mimeType, block.data);
+                output.push({ type: "localImage", path: filePath });
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 logger.warn({ message }, "Failed to write Codex image attachment");
-                return {
-                    type: "text",
-                    text: `User attached image (failed to write temp file): ${message}`,
-                };
+                output.push({
+                    ...toCodexTextInput(`User attached image (failed to write temp file): ${message}`),
+                });
             }
+            previousTextBlock = false;
+            continue;
         }
-        if (record.type === "github_pr" || record.type === "github_issue") {
-            return {
-                type: "text",
-                text: renderPromptAttachmentAsText(record),
-            };
-        }
-        return block;
-    }));
+        const attachmentText = renderPromptAttachmentAsText(block);
+        output.push(toCodexTextInput(previousTextBlock ? `\n\n${attachmentText}` : attachmentText));
+        previousTextBlock = true;
+    }
     return output;
 }
+function toCodexTextInput(text) {
+    return {
+        type: "text",
+        text,
+        text_elements: [],
+    };
+}
 function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
     return createProviderEnv({
         runtimeSettings,
@@ -1901,6 +1929,7 @@ class CodexAppServerAgentSession {
         this.pendingReasoning = new Map();
         this.pendingCommandOutputDeltas = new Map();
         this.pendingFileChangeOutputDeltas = new Map();
+        this.pendingAssistantMessageBoundary = false;
         this.terminalCommandByProcessId = new Map();
         this.pendingUnlabeledTerminalInteractions = new Set();
         this.emittedTerminalInteractionKeys = new Set();
@@ -1908,6 +1937,8 @@ class CodexAppServerAgentSession {
         this.emittedExecCommandCompletedCallIds = new Set();
         this.emittedItemStartedIds = new Set();
         this.emittedItemCompletedIds = new Set();
+        this.subAgentCallsByCallId = new Map();
+        this.subAgentCallIdByChildThreadId = new Map();
         this.warnedUnknownNotificationMethods = new Set();
         this.warnedInvalidNotificationPayloads = new Set();
         this.warnedIncompleteEditToolCallIds = new Set();
@@ -1958,8 +1989,8 @@ class CodexAppServerAgentSession {
         await this.loadCollaborationModes();
         await this.loadSkills();
         if (this.currentThreadId) {
-            await this.loadPersistedHistory();
             await this.ensureThreadLoaded();
+            await this.loadPersistedHistory();
         }
         this.connected = true;
     }
@@ -2128,27 +2159,16 @@ class CodexAppServerAgentSession {
     async loadPersistedHistory() {
         if (!this.client || !this.currentThreadId)
             return;
+        const client = this.client;
+        const threadId = this.currentThreadId;
         try {
-            let rolloutTimeline = [];
-            try {
-                rolloutTimeline = await loadCodexPersistedTimeline(this.currentThreadId, undefined, this.logger);
-            }
-            catch {
-                rolloutTimeline = [];
-            }
-            const response = (await this.client.request("thread/read", {
-                threadId: this.currentThreadId,
-                includeTurns: true,
-            }));
-            const thread = response?.thread;
-            const threadTimeline = [];
-            if (thread && Array.isArray(thread.turns)) {
-                for (const turn of thread.turns) {
-                    const items = Array.isArray(turn.items) ? turn.items : [];
-                    this.collectThreadTurnTimelineItems(items, threadTimeline);
-                }
-            }
-            const timeline = rolloutTimeline.length > 0 ? rolloutTimeline : threadTimeline;
+            const timeline = await loadCodexThreadHistoryTimeline({
+                threadId,
+                cwd: this.config.cwd ?? null,
+                requestThread: (threadIdToRead) => {
+                    return readCodexThread(client, threadIdToRead);
+                },
+            });
             if (timeline.length > 0) {
                 this.persistedHistory = timeline;
                 this.historyPending = true;
@@ -2245,79 +2265,22 @@ class CodexAppServerAgentSession {
         return args ? `$${commandName} ${args}` : `$${commandName}`;
     }
     async run(prompt, options) {
-        const timeline = [];
-        let finalText = "";
-        let usage;
-        let turnId = null;
-        const bufferedEvents = [];
-        let settled = false;
-        let resolveCompletion;
-        let rejectCompletion;
-        const processEvent = (event) => {
-            if (settled) {
-                return;
-            }
-            const eventTurnId = event.turnId;
-            if (turnId && eventTurnId && eventTurnId !== turnId) {
-                return;
-            }
-            if (event.type === "timeline") {
-                timeline.push(event.item);
-                if (event.item.type === "assistant_message") {
-                    finalText = event.item.text;
+        return runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: async () => (await this.getRuntimeInfo()).sessionId ?? "",
+            reduceFinalText: ({ current, item }) => {
+                if (item.type === "assistant_message") {
+                    return item.text;
                 }
-                else if (event.item.type === "tool_call" && event.item.detail.type === "plan") {
-                    finalText = event.item.detail.text;
+                if (item.type === "tool_call" && item.detail.type === "plan") {
+                    return item.detail.text;
                 }
-                return;
-            }
-            if (event.type === "turn_completed") {
-                usage = event.usage;
-                settled = true;
-                resolveCompletion();
-                return;
-            }
-            if (event.type === "turn_failed") {
-                settled = true;
-                rejectCompletion(new Error(event.error));
-                return;
-            }
-            if (event.type === "turn_canceled") {
-                settled = true;
-                resolveCompletion();
-            }
-        };
-        const completion = new Promise((resolve, reject) => {
-            resolveCompletion = resolve;
-            rejectCompletion = reject;
-        });
-        const unsubscribe = this.subscribe((event) => {
-            if (!turnId) {
-                bufferedEvents.push(event);
-                return;
-            }
-            processEvent(event);
+                return current;
+            },
         });
-        try {
-            const result = await this.startTurn(prompt, options);
-            turnId = result.turnId;
-            for (const event of bufferedEvents) {
-                processEvent(event);
-            }
-            if (!settled) {
-                await completion;
-            }
-        }
-        finally {
-            unsubscribe();
-        }
-        const info = await this.getRuntimeInfo();
-        return {
-            sessionId: info.sessionId ?? "",
-            finalText,
-            usage,
-            timeline,
-        };
     }
     async startTurn(prompt, options) {
         if (this.activeForegroundTurnId) {
@@ -2740,17 +2703,11 @@ class CodexAppServerAgentSession {
     }
     async buildUserInput(prompt) {
         if (typeof prompt === "string") {
-            return [{ type: "text", text: prompt }];
+            return [toCodexTextInput(prompt)];
         }
-        const blocks = prompt;
-        return await codexAppServerTurnInputFromPrompt(blocks, this.logger);
+        return await codexAppServerTurnInputFromPrompt(prompt, this.logger);
     }
     emitEvent(event) {
-        if (event.type === "timeline") {
-            if (event.item.type === "assistant_message") {
-                this.pendingAgentMessages.clear();
-            }
-        }
         this.notifySubscribers(event);
     }
     notifySubscribers(event) {
@@ -2825,16 +2782,153 @@ class CodexAppServerAgentSession {
                 this.warnUnknownNotificationMethod(parsed.method, parsed.params);
         }
     }
+    getSubAgentCallIdForThread(threadId) {
+        if (!threadId || threadId === this.currentThreadId) {
+            return null;
+        }
+        return this.subAgentCallIdByChildThreadId.get(threadId) ?? null;
+    }
+    registerSubAgentToolCall(timelineItem, rawItem) {
+        if (timelineItem.detail.type !== "sub_agent") {
+            return;
+        }
+        const existing = this.subAgentCallsByCallId.get(timelineItem.callId);
+        const state = existing ??
+            {
+                callId: timelineItem.callId,
+                toolCall: timelineItem,
+                childItemOrder: [],
+                childItems: new Map(),
+            };
+        state.toolCall = {
+            ...timelineItem,
+            detail: {
+                ...timelineItem.detail,
+                log: timelineItem.detail.log ||
+                    (state.toolCall.detail.type === "sub_agent" ? state.toolCall.detail.log : ""),
+            },
+        };
+        this.subAgentCallsByCallId.set(timelineItem.callId, state);
+        const receiverThreadIds = Array.isArray(rawItem.receiverThreadIds)
+            ? rawItem.receiverThreadIds.filter((value) => typeof value === "string")
+            : [];
+        for (const receiverThreadId of receiverThreadIds) {
+            this.subAgentCallIdByChildThreadId.set(receiverThreadId, timelineItem.callId);
+        }
+    }
+    upsertSubAgentChildItem(callId, itemId, item) {
+        const state = this.subAgentCallsByCallId.get(callId);
+        if (!state) {
+            return;
+        }
+        if (!state.childItems.has(itemId)) {
+            state.childItemOrder.push(itemId);
+        }
+        state.childItems.set(itemId, item);
+    }
+    getSubAgentChildTimeline(state) {
+        return state.childItemOrder
+            .map((itemId) => state.childItems.get(itemId))
+            .filter((item) => Boolean(item));
+    }
+    emitSubAgentActivityUpdate(callId, status) {
+        const state = this.subAgentCallsByCallId.get(callId);
+        if (!state || state.toolCall.detail.type !== "sub_agent") {
+            return;
+        }
+        const childTimeline = this.getSubAgentChildTimeline(state);
+        const log = childTimeline.length > 0
+            ? curateAgentActivity(childTimeline, { labelAssistantMessages: true })
+            : "";
+        const resolvedStatus = status ?? state.toolCall.status;
+        const baseToolCall = {
+            ...state.toolCall,
+            detail: {
+                ...state.toolCall.detail,
+                log,
+            },
+        };
+        const nextToolCall = resolvedStatus === "failed"
+            ? {
+                ...baseToolCall,
+                status: "failed",
+                error: state.toolCall.error ?? { message: "Sub-agent failed" },
+            }
+            : {
+                ...baseToolCall,
+                status: resolvedStatus,
+                error: null,
+            };
+        state.toolCall = nextToolCall;
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: nextToolCall });
+    }
+    handleSubAgentChildItemCompleted(callId, itemId, timelineItem) {
+        this.applyBufferedDeltaTextToTimelineItem(timelineItem, itemId);
+        if (itemId) {
+            this.upsertSubAgentChildItem(callId, itemId, timelineItem);
+            this.pendingAgentMessages.delete(itemId);
+            this.pendingReasoning.delete(itemId);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            this.pendingFileChangeOutputDeltas.delete(itemId);
+        }
+        this.emitSubAgentActivityUpdate(callId, timelineItem.type === "tool_call" && timelineItem.status === "failed" ? "failed" : "running");
+    }
+    shouldSkipCompletedThreadItem(timelineItem, normalizedItemType, itemId) {
+        // For commandExecution items, codex/event/exec_command_* is authoritative.
+        if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
+            const callId = timelineItem.callId || itemId;
+            return Boolean(callId && this.emittedExecCommandCompletedCallIds.has(callId));
+        }
+        return Boolean(itemId && this.emittedItemCompletedIds.has(itemId));
+    }
     handleCodexDeltaNotification(parsed) {
         if (parsed.kind === "agent_message_delta") {
             const prev = this.pendingAgentMessages.get(parsed.itemId) ?? "";
-            this.pendingAgentMessages.set(parsed.itemId, prev + parsed.delta);
+            const text = prev + parsed.delta;
+            this.pendingAgentMessages.set(parsed.itemId, text);
+            const subAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+            if (subAgentCallId) {
+                this.upsertSubAgentChildItem(subAgentCallId, parsed.itemId, {
+                    type: "assistant_message",
+                    text,
+                });
+                this.emitSubAgentActivityUpdate(subAgentCallId, "running");
+                return;
+            }
+            const isFirstDeltaForItem = prev.length === 0;
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: isFirstDeltaForItem && this.pendingAssistantMessageBoundary
+                        ? `${ASSISTANT_MESSAGE_BOUNDARY_MARKDOWN}${parsed.delta}`
+                        : parsed.delta,
+                },
+            });
+            if (isFirstDeltaForItem) {
+                this.pendingAssistantMessageBoundary = false;
+            }
             return;
         }
         if (parsed.kind === "reasoning_delta") {
             const prev = this.pendingReasoning.get(parsed.itemId) ?? [];
             prev.push(parsed.delta);
             this.pendingReasoning.set(parsed.itemId, prev);
+            const subAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+            if (subAgentCallId) {
+                this.upsertSubAgentChildItem(subAgentCallId, parsed.itemId, {
+                    type: "reasoning",
+                    text: prev.join(""),
+                });
+                this.emitSubAgentActivityUpdate(subAgentCallId, "running");
+                return;
+            }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: { type: "reasoning", text: parsed.delta },
+            });
             return;
         }
         if (parsed.kind === "exec_command_output_delta") {
@@ -2854,11 +2948,28 @@ class CodexAppServerAgentSession {
         });
     }
     handleTurnStartedNotification(parsed) {
+        const subAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+        if (subAgentCallId) {
+            this.emitSubAgentActivityUpdate(subAgentCallId, "running");
+            return;
+        }
         this.currentTurnId = parsed.turnId;
         this.resetTurnTrackingState();
         this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
     }
     handleTurnCompletedNotification(parsed) {
+        const subAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+        if (subAgentCallId) {
+            let status = "completed";
+            if (parsed.status === "failed") {
+                status = "failed";
+            }
+            else if (parsed.status === "interrupted") {
+                status = "canceled";
+            }
+            this.emitSubAgentActivityUpdate(subAgentCallId, status);
+            return;
+        }
         if (parsed.status === "failed") {
             this.emitEvent({
                 type: "turn_failed",
@@ -2888,8 +2999,11 @@ class CodexAppServerAgentSession {
         this.emittedItemCompletedIds.clear();
         this.emittedExecCommandStartedCallIds.clear();
         this.emittedExecCommandCompletedCallIds.clear();
+        this.pendingAgentMessages.clear();
+        this.pendingReasoning.clear();
         this.pendingCommandOutputDeltas.clear();
         this.pendingFileChangeOutputDeltas.clear();
+        this.pendingAssistantMessageBoundary = false;
         this.warnedIncompleteEditToolCallIds.clear();
     }
     handlePlanUpdatedNotification(parsed) {
@@ -2902,6 +3016,12 @@ class CodexAppServerAgentSession {
         });
         if (timelineItem) {
             this.rememberPlanResult(timelineItem);
+            // In plan mode, the same plan is rendered through the synthetic approval
+            // permission. Keep the remembered text for that card, but do not also
+            // emit a static timeline plan panel.
+            if (this.planModeEnabled) {
+                return;
+            }
             this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
         }
     }
@@ -3018,26 +3138,43 @@ class CodexAppServerAgentSession {
         if (!timelineItem) {
             return;
         }
+        const childSubAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+        if (childSubAgentCallId) {
+            this.handleSubAgentChildItemCompleted(childSubAgentCallId, parsed.item.id, timelineItem);
+            return;
+        }
         const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
         const itemId = parsed.item.id;
-        // For commandExecution items, codex/event/exec_command_* is authoritative.
-        if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
-            const callId = timelineItem.callId || itemId;
-            if (callId && this.emittedExecCommandCompletedCallIds.has(callId)) {
-                return;
-            }
+        if (this.shouldSkipCompletedThreadItem(timelineItem, normalizedItemType, itemId)) {
+            return;
         }
-        if (itemId && this.emittedItemCompletedIds.has(itemId)) {
+        if (this.consumeStreamedTextCompletion(timelineItem, itemId)) {
+            if (timelineItem.type === "assistant_message") {
+                this.pendingAssistantMessageBoundary = true;
+            }
+            if (itemId) {
+                this.emittedItemCompletedIds.add(itemId);
+                this.emittedItemStartedIds.delete(itemId);
+            }
             return;
         }
         this.applyBufferedDeltaTextToTimelineItem(timelineItem, itemId);
         if (timelineItem.type === "tool_call") {
+            this.registerSubAgentToolCall(timelineItem, parsed.item);
             if (timelineItem.detail.type === "plan") {
                 this.rememberPlanResult(timelineItem);
+                // Codex can surface plans both as turn/plan updates and as completed
+                // thread items. In plan mode, approval owns the visible plan card.
+                if (this.planModeEnabled) {
+                    return;
+                }
             }
             this.warnOnIncompleteEditToolCall(timelineItem, "item_completed", parsed.item);
         }
         this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        if (timelineItem.type === "assistant_message") {
+            this.pendingAssistantMessageBoundary = true;
+        }
         if (itemId) {
             this.emittedItemCompletedIds.add(itemId);
             this.emittedItemStartedIds.delete(itemId);
@@ -3045,6 +3182,39 @@ class CodexAppServerAgentSession {
             this.pendingFileChangeOutputDeltas.delete(itemId);
         }
     }
+    consumeStreamedTextCompletion(timelineItem, itemId) {
+        if (!itemId) {
+            return false;
+        }
+        if (timelineItem.type === "assistant_message" && this.pendingAgentMessages.has(itemId)) {
+            const streamedText = this.pendingAgentMessages.get(itemId) ?? "";
+            this.pendingAgentMessages.delete(itemId);
+            this.emitMissingFinalTextSuffix(timelineItem, streamedText);
+            return true;
+        }
+        if (timelineItem.type === "reasoning" && this.pendingReasoning.has(itemId)) {
+            const streamedText = this.pendingReasoning.get(itemId)?.join("") ?? "";
+            this.pendingReasoning.delete(itemId);
+            this.emitMissingFinalTextSuffix(timelineItem, streamedText);
+            return true;
+        }
+        return false;
+    }
+    emitMissingFinalTextSuffix(timelineItem, streamedText) {
+        if (!timelineItem.text.startsWith(streamedText)) {
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+            return;
+        }
+        const suffix = timelineItem.text.slice(streamedText.length);
+        if (!suffix) {
+            return;
+        }
+        this.emitEvent({
+            type: "timeline",
+            provider: CODEX_PROVIDER,
+            item: { type: timelineItem.type, text: suffix },
+        });
+    }
     applyBufferedDeltaTextToTimelineItem(timelineItem, itemId) {
         if (!itemId) {
             return;
@@ -3074,6 +3244,14 @@ class CodexAppServerAgentSession {
         if (!timelineItem || timelineItem.type !== "tool_call") {
             return;
         }
+        const childSubAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+        if (childSubAgentCallId) {
+            if (parsed.item.id) {
+                this.upsertSubAgentChildItem(childSubAgentCallId, parsed.item.id, timelineItem);
+            }
+            this.emitSubAgentActivityUpdate(childSubAgentCallId, "running");
+            return;
+        }
         const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
         const itemId = parsed.item.id;
         if (normalizedItemType === "commandExecution") {
@@ -3086,6 +3264,7 @@ class CodexAppServerAgentSession {
             return;
         }
         this.warnOnIncompleteEditToolCall(timelineItem, "item_started", parsed.item);
+        this.registerSubAgentToolCall(timelineItem, parsed.item);
         this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
         if (itemId) {
             this.emittedItemStartedIds.add(itemId);
@@ -3167,20 +3346,6 @@ class CodexAppServerAgentSession {
         this.emittedTerminalInteractionKeys.add(key);
         return true;
     }
-    collectThreadTurnTimelineItems(items, target) {
-        for (const item of items) {
-            const timelineItem = threadItemToTimeline(item, {
-                cwd: this.config.cwd ?? null,
-            });
-            if (!timelineItem) {
-                continue;
-            }
-            if (timelineItem.type === "tool_call") {
-                this.warnOnIncompleteEditToolCall(timelineItem, "thread_read", item);
-            }
-            target.push(timelineItem);
-        }
-    }
     warnOnIncompleteEditToolCall(item, source, payload) {
         if (!isEditToolCallWithoutContent(item)) {
             return;
@@ -3368,23 +3533,13 @@ export class CodexAppServerAgentClient {
                 const title = typeof thread.preview === "string" ? thread.preview : null;
                 let timeline = [];
                 try {
-                    const [rolloutTimeline, read] = await Promise.all([
-                        loadCodexPersistedTimeline(threadId, undefined, this.logger),
-                        client.request("thread/read", {
-                            threadId,
-                            includeTurns: true,
-                        }),
-                    ]);
-                    const turns = read.thread?.turns ?? [];
-                    const itemsFromThreadRead = [];
-                    for (const turn of turns) {
-                        for (const item of turn.items ?? []) {
-                            const timelineItem = threadItemToTimeline(item, { cwd });
-                            if (timelineItem)
-                                itemsFromThreadRead.push(timelineItem);
-                        }
-                    }
-                    timeline = rolloutTimeline.length > 0 ? rolloutTimeline : itemsFromThreadRead;
+                    timeline = await loadCodexThreadHistoryTimeline({
+                        threadId,
+                        cwd,
+                        requestThread: (threadIdToRead) => {
+                            return readCodexThread(client, threadIdToRead);
+                        },
+                    });
                 }
                 catch {
                     timeline = [];