@getpaseo/server 0.1.62 → 0.1.65

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 { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.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,
@@ -96,16 +99,16 @@ function isObjectSchemaNode(schema) {
         type === "object" ||
         (Array.isArray(type) && type.includes("object")));
 }
-function normalizeCodexOutputSchemaNode(schema, path) {
+function normalizeCodexOutputSchemaNode(schema, schemaPath) {
     if (Array.isArray(schema)) {
-        return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path}[${index}]`));
+        return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${schemaPath}[${index}]`));
     }
     if (!isSchemaRecord(schema)) {
         return schema;
     }
     const normalized = {};
     for (const [key, value] of Object.entries(schema)) {
-        normalized[key] = normalizeCodexOutputSchemaNode(value, `${path}.${key}`);
+        normalized[key] = normalizeCodexOutputSchemaNode(value, `${schemaPath}.${key}`);
     }
     if (!isObjectSchemaNode(normalized)) {
         return normalized;
@@ -114,7 +117,7 @@ function normalizeCodexOutputSchemaNode(schema, path) {
         normalized.additionalProperties = false;
     }
     else if (normalized.additionalProperties !== false) {
-        throw new Error(`Codex structured outputs require ${path} to set additionalProperties to false for object schemas.`);
+        throw new Error(`Codex structured outputs require ${schemaPath} to set additionalProperties to false for object schemas.`);
     }
     const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
     if (!properties) {
@@ -156,6 +159,29 @@ async function resolveCodexLaunchPrefix(runtimeSettings) {
 function resolveCodexHomeDir() {
     return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
 }
+function decodeEscapedChar(next) {
+    if (next === "n")
+        return "\n";
+    if (next === "t")
+        return "\t";
+    return next;
+}
+function resolvePermissionDecision(response) {
+    if (response.behavior === "allow")
+        return "accept";
+    if (response.interrupt)
+        return "cancel";
+    return "decline";
+}
+function firstPositiveFiniteNumber(primary, secondary) {
+    if (typeof primary === "number" && Number.isFinite(primary) && primary > 0) {
+        return primary;
+    }
+    if (typeof secondary === "number" && Number.isFinite(secondary) && secondary > 0) {
+        return secondary;
+    }
+    return undefined;
+}
 function tokenizeCommandArgs(args) {
     const tokens = [];
     let current = "";
@@ -171,7 +197,7 @@ function tokenizeCommandArgs(args) {
                 const next = args[i + 1];
                 if (next === quote || next === "\\" || next === "n" || next === "t") {
                     i += 1;
-                    current += next === "n" ? "\n" : next === "t" ? "\t" : next;
+                    current += decodeEscapedChar(next);
                     continue;
                 }
             }
@@ -242,35 +268,27 @@ async function listCodexCustomPrompts() {
     catch {
         return [];
     }
-    const commands = [];
-    for (const entry of entries) {
-        if (!entry.isFile()) {
-            continue;
-        }
-        if (!entry.name.endsWith(".md")) {
-            continue;
-        }
+    const mdEntries = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name.slice(0, -".md".length));
+    const parsedCommands = await Promise.all(mdEntries.map(async (entry) => {
         const name = entry.name.slice(0, -".md".length);
-        if (!name) {
-            continue;
-        }
         const fullPath = path.join(promptsDir, entry.name);
         let content;
         try {
             content = await fs.readFile(fullPath, "utf8");
         }
         catch {
-            continue;
+            return null;
         }
         const parsed = parseFrontMatter(content);
         const description = parsed.frontMatter["description"] ?? "Custom prompt";
         const argumentHint = parsed.frontMatter["argument-hint"] ?? parsed.frontMatter["argument_hint"] ?? "";
-        commands.push({
+        return {
             name: `prompts:${name}`,
             description,
             argumentHint,
-        });
-    }
+        };
+    }));
+    const commands = parsedCommands.filter((cmd) => cmd !== null);
     return commands.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function listCodexSkills(cwd, workspaceGitService) {
@@ -284,28 +302,30 @@ async function listCodexSkills(cwd, workspaceGitService) {
         candidates.push(path.join(repoRoot, ".codex", "skills"));
     }
     candidates.push(path.join(resolveCodexHomeDir(), "skills"));
-    const commandsByName = new Map();
-    for (const dir of candidates) {
+    const candidateReads = await Promise.all(candidates.map(async (dir) => {
         let entries;
         try {
             entries = await fs.readdir(dir, { withFileTypes: true });
         }
         catch {
-            continue;
+            return [];
         }
-        for (const entry of entries) {
-            if (!entry.isDirectory() && !entry.isSymbolicLink()) {
-                continue;
-            }
+        const dirEntries = entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink());
+        const skillContents = await Promise.all(dirEntries.map(async (entry) => {
             const skillDir = path.join(dir, entry.name);
             const skillPath = path.join(skillDir, "SKILL.md");
-            let content;
             try {
-                content = await fs.readFile(skillPath, "utf8");
+                return await fs.readFile(skillPath, "utf8");
             }
             catch {
-                continue;
+                return null;
             }
+        }));
+        return skillContents.filter((content) => content !== null);
+    }));
+    const commandsByName = new Map();
+    for (const skillContents of candidateReads) {
+        for (const content of skillContents) {
             const { frontMatter } = parseFrontMatter(content);
             const name = frontMatter["name"];
             const description = frontMatter["description"];
@@ -389,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();
@@ -409,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
@@ -423,8 +437,6 @@ class CodexAppServerClient {
             }
             this.pending.clear();
             this.disposed = true;
-            this.resolveExitPromise?.();
-            this.resolveExitPromise = null;
         });
     }
     setNotificationHandler(handler) {
@@ -478,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) {
@@ -555,48 +551,12 @@ 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;
     const usage = tokenUsage;
-    const contextWindowMaxTokens = typeof usage.model_context_window === "number" &&
-        Number.isFinite(usage.model_context_window) &&
-        usage.model_context_window > 0
-        ? usage.model_context_window
-        : typeof usage.modelContextWindow === "number" &&
-            Number.isFinite(usage.modelContextWindow) &&
-            usage.modelContextWindow > 0
-            ? usage.modelContextWindow
-            : undefined;
-    const contextWindowUsedTokens = typeof usage.last?.total_tokens === "number" &&
-        Number.isFinite(usage.last.total_tokens) &&
-        usage.last.total_tokens > 0
-        ? usage.last.total_tokens
-        : typeof usage.last?.totalTokens === "number" &&
-            Number.isFinite(usage.last.totalTokens) &&
-            usage.last.totalTokens > 0
-            ? usage.last.totalTokens
-            : undefined;
+    const contextWindowMaxTokens = firstPositiveFiniteNumber(usage.model_context_window, usage.modelContextWindow);
+    const contextWindowUsedTokens = firstPositiveFiniteNumber(usage.last?.total_tokens, usage.last?.totalTokens);
     return {
         inputTokens: usage.last?.inputTokens,
         cachedInputTokens: usage.last?.cachedInputTokens,
@@ -880,6 +840,8 @@ function normalizeCodexThreadItemType(rawType) {
             return "mcpToolCall";
         case "WebSearch":
             return "webSearch";
+        case "CollabAgentToolCall":
+            return "collabAgentToolCall";
         default:
             return rawType;
     }
@@ -970,8 +932,8 @@ function parseCodexPatchChanges(changes) {
         ];
     }
     return Object.entries(recordChanges)
-        .map(([path, value]) => {
-        const normalizedPath = path.trim();
+        .map(([entryPath, value]) => {
+        const normalizedPath = entryPath.trim();
         if (!normalizedPath) {
             return null;
         }
@@ -1096,11 +1058,7 @@ function mapCodexPatchNotificationToToolCall(params) {
             : {
                 ...(files.length > 0
                     ? {
-                        files: files.map((file) => ({
-                            path: file.path,
-                            ...(file.kind ? { kind: file.kind } : {}),
-                            ...codexPatchTextFields(file.content ?? patchText),
-                        })),
+                        files: files.map((file) => Object.assign({ path: file.path }, file.kind ? { kind: file.kind } : {}, codexPatchTextFields(file.content ?? patchText))),
                     }
                     : {}),
                 ...(params.stdout ? { stdout: params.stdout } : {}),
@@ -1139,52 +1097,98 @@ function mapCodexTerminalInteractionToToolCall(params) {
         ...(processId ? { metadata: { processId } } : {}),
     };
 }
+function mapCodexThreadPlanItem(normalizedItem) {
+    const callId = nonEmptyString(normalizedItem.id ?? normalizedItem.itemId ?? undefined) ??
+        `plan:${normalizePlanMarkdown(typeof normalizedItem.text === "string" ? normalizedItem.text : "")}`;
+    return mapCodexPlanToToolCall({
+        callId,
+        text: typeof normalizedItem.text === "string" ? normalizedItem.text : "",
+    });
+}
+function mapCodexThreadReasoningItem(normalizedItem) {
+    const summary = Array.isArray(normalizedItem.summary) ? normalizedItem.summary.join("\n") : "";
+    const content = Array.isArray(normalizedItem.content) ? normalizedItem.content.join("\n") : "";
+    const text = summary || content;
+    return text ? { type: "reasoning", text } : null;
+}
+function mapCodexThreadUserMessageItem(normalizedItem, includeUserMessage) {
+    if (!includeUserMessage) {
+        return null;
+    }
+    const text = extractUserText(normalizedItem.content) ?? "";
+    return { type: "user_message", text };
+}
 function threadItemToTimeline(item, options) {
     if (!item || typeof item !== "object")
         return null;
+    const itemRecord = item;
     const includeUserMessage = options?.includeUserMessage ?? true;
     const cwd = options?.cwd ?? null;
-    const normalizedType = normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined);
-    const normalizedItem = normalizedType && normalizedType !== item.type
-        ? { ...item, type: normalizedType }
-        : item;
+    const normalizedType = normalizeCodexThreadItemType(typeof itemRecord.type === "string" ? itemRecord.type : undefined);
+    const normalizedItem = normalizedType && normalizedType !== itemRecord.type
+        ? { ...itemRecord, type: normalizedType }
+        : itemRecord;
     switch (normalizedType) {
-        case "userMessage": {
-            if (!includeUserMessage) {
-                return null;
-            }
-            const text = extractUserText(normalizedItem.content) ?? "";
-            return { type: "user_message", text };
-        }
-        case "agentMessage": {
-            return { type: "assistant_message", text: normalizedItem.text ?? "" };
-        }
-        case "plan": {
-            return mapCodexPlanToToolCall({
-                callId: nonEmptyString(normalizedItem.id ?? normalizedItem.itemId ?? undefined) ??
-                    `plan:${normalizePlanMarkdown(normalizedItem.text ?? "")}`,
-                text: normalizedItem.text ?? "",
-            });
-        }
-        case "reasoning": {
-            const summary = Array.isArray(normalizedItem.summary)
-                ? normalizedItem.summary.join("\n")
-                : "";
-            const content = Array.isArray(normalizedItem.content)
-                ? normalizedItem.content.join("\n")
-                : "";
-            const text = summary || content;
-            return text ? { type: "reasoning", text } : null;
-        }
+        case "userMessage":
+            return mapCodexThreadUserMessageItem(normalizedItem, includeUserMessage);
+        case "agentMessage":
+            return {
+                type: "assistant_message",
+                text: typeof normalizedItem.text === "string" ? normalizedItem.text : "",
+            };
+        case "plan":
+            return mapCodexThreadPlanItem(normalizedItem);
+        case "reasoning":
+            return mapCodexThreadReasoningItem(normalizedItem);
         case "commandExecution":
         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":
@@ -1231,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(),
@@ -1272,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(),
@@ -1307,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(),
@@ -1439,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,
@@ -1453,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",
@@ -1504,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",
@@ -1519,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",
@@ -1530,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 }) => ({
@@ -1542,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 }) => ({
@@ -1557,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 }) => ({
@@ -1572,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 }) => ({
@@ -1756,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",
@@ -1771,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",
@@ -1821,54 +1843,55 @@ async function readCodexConfiguredDefaults(client, logger) {
 }
 export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
     if (typeof prompt === "string") {
-        return [{ type: "text", text: prompt }];
+        return [toCodexTextInput(prompt)];
     }
-    const blocks = prompt;
     const output = [];
-    for (const block of blocks) {
-        if (!block || typeof block !== "object") {
+    let previousTextBlock = false;
+    for (const block of prompt) {
+        if (block.type === "text") {
+            output.push(toCodexTextInput(block.text));
+            previousTextBlock = block.text.length > 0;
+            continue;
+        }
+        if (block.type === "skill") {
             output.push(block);
+            previousTextBlock = false;
             continue;
         }
-        const record = block;
-        if (record.type === "image" &&
-            typeof record.mimeType === "string" &&
-            typeof record.data === "string") {
+        if (block.type === "image") {
             try {
-                const filePath = await writeImageAttachment(record.mimeType, record.data);
+                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");
                 output.push({
-                    type: "text",
-                    text: `User attached image (failed to write temp file): ${message}`,
+                    ...toCodexTextInput(`User attached image (failed to write temp file): ${message}`),
                 });
             }
+            previousTextBlock = false;
             continue;
         }
-        if (record.type === "github_pr" || record.type === "github_issue") {
-            output.push({
-                type: "text",
-                text: renderPromptAttachmentAsText(record),
-            });
-            continue;
-        }
-        output.push(block);
+        const attachmentText = renderPromptAttachmentAsText(block);
+        output.push(toCodexTextInput(previousTextBlock ? `\n\n${attachmentText}` : attachmentText));
+        previousTextBlock = true;
     }
     return output;
 }
-function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
-    const env = applyProviderEnv(process.env, runtimeSettings);
-    if (!launchEnv) {
-        return env;
-    }
+function toCodexTextInput(text) {
     return {
-        ...env,
-        ...launchEnv,
+        type: "text",
+        text,
+        text_elements: [],
     };
 }
+function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
+    return createProviderEnv({
+        runtimeSettings,
+        overlays: [launchEnv],
+    });
+}
 function buildCodexAppServerInitializeParams() {
     return {
         clientInfo: {
@@ -1906,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();
@@ -1913,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();
@@ -1963,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;
     }
@@ -1975,11 +2001,11 @@ class CodexAppServerAgentSession {
             const response = (await this.client.request("collaborationMode/list", {}));
             const data = Array.isArray(response?.data) ? response.data : [];
             this.collaborationModes = data.map((entry) => ({
-                name: String(entry.name ?? ""),
-                mode: entry.mode ?? null,
-                model: entry.model ?? null,
-                reasoning_effort: entry.reasoning_effort ?? null,
-                developer_instructions: entry.developer_instructions ?? null,
+                name: typeof entry.name === "string" ? entry.name : "",
+                mode: typeof entry.mode === "string" ? entry.mode : null,
+                model: typeof entry.model === "string" ? entry.model : null,
+                reasoning_effort: typeof entry.reasoning_effort === "string" ? entry.reasoning_effort : null,
+                developer_instructions: typeof entry.developer_instructions === "string" ? entry.developer_instructions : null,
             }));
         }
         catch (error) {
@@ -1998,13 +2024,15 @@ class CodexAppServerAgentSession {
             const entries = Array.isArray(response?.data) ? response.data : [];
             const skills = [];
             for (const entry of entries) {
-                const list = Array.isArray(entry.skills) ? entry.skills : [];
+                const list = Array.isArray(entry.skills)
+                    ? entry.skills
+                    : [];
                 for (const skill of list) {
-                    if (!skill?.name || !skill?.path)
+                    if (typeof skill?.name !== "string" || typeof skill?.path !== "string")
                         continue;
                     skills.push({
                         name: skill.name,
-                        description: skill.description ?? skill.shortDescription ?? "Skill",
+                        description: resolveSkillDescription(skill),
                         path: skill.path,
                     });
                 }
@@ -2063,7 +2091,7 @@ class CodexAppServerAgentSession {
     }
     applyFeatureValue(featureId, value) {
         this.config.featureValues = {
-            ...(this.config.featureValues ?? {}),
+            ...this.config.featureValues,
             [featureId]: value,
         };
         if (featureId === "fast_mode") {
@@ -2131,37 +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 : [];
-                    for (const item of items) {
-                        const timelineItem = threadItemToTimeline(item, {
-                            cwd: this.config.cwd ?? null,
-                        });
-                        if (timelineItem) {
-                            if (timelineItem.type === "tool_call") {
-                                this.warnOnIncompleteEditToolCall(timelineItem, "thread_read", item);
-                            }
-                            threadTimeline.push(timelineItem);
-                        }
-                    }
-                }
-            }
-            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;
@@ -2258,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) {
@@ -2486,55 +2436,13 @@ class CodexAppServerAgentSession {
         }
         const pendingRequest = this.pendingPermissions.get(requestId) ?? null;
         if (pending.kind === "plan") {
-            let followUpPrompt;
-            if (response.behavior === "allow") {
-                followUpPrompt = this.preparePlanImplementation({
-                    planText: pending.planText ?? pendingRequest?.metadata?.planText,
-                });
-            }
-            this.pendingPermissionHandlers.delete(requestId);
-            this.pendingPermissions.delete(requestId);
-            this.resolvedPermissionRequests.add(requestId);
-            this.emitEvent({
-                type: "permission_resolved",
-                provider: CODEX_PROVIDER,
-                requestId,
-                resolution: response,
-            });
-            if (followUpPrompt) {
-                return { followUpPrompt };
-            }
-            return;
+            return this.handlePlanPermissionResponse({ requestId, response, pending, pendingRequest });
         }
         this.pendingPermissionHandlers.delete(requestId);
         this.pendingPermissions.delete(requestId);
         this.resolvedPermissionRequests.add(requestId);
         if (response.behavior === "deny" && pendingRequest?.kind === "tool") {
-            const fallbackName = pendingRequest.name === "CodexBash"
-                ? "shell"
-                : pendingRequest.name === "CodexFileChange"
-                    ? "apply_patch"
-                    : pendingRequest.name;
-            this.emitEvent({
-                type: "timeline",
-                provider: CODEX_PROVIDER,
-                item: {
-                    type: "tool_call",
-                    callId: requestId,
-                    name: fallbackName,
-                    status: "failed",
-                    error: { message: response.message ?? "Permission denied" },
-                    detail: pendingRequest.detail ?? {
-                        type: "unknown",
-                        input: pendingRequest.input ?? null,
-                        output: null,
-                    },
-                    metadata: {
-                        permissionRequestId: requestId,
-                        denied: true,
-                    },
-                },
-            });
+            this.emitDeniedToolCallTimelineEvent({ requestId, response, pendingRequest });
         }
         this.emitEvent({
             type: "permission_resolved",
@@ -2543,13 +2451,11 @@ class CodexAppServerAgentSession {
             resolution: response,
         });
         if (pending.kind === "command") {
-            const decision = response.behavior === "allow" ? "accept" : response.interrupt ? "cancel" : "decline";
-            pending.resolve({ decision });
+            pending.resolve({ decision: resolvePermissionDecision(response) });
             return;
         }
         if (pending.kind === "file") {
-            const decision = response.behavior === "allow" ? "accept" : response.interrupt ? "cancel" : "decline";
-            pending.resolve({ decision });
+            pending.resolve({ decision: resolvePermissionDecision(response) });
             return;
         }
         const questions = pending.questions ?? [];
@@ -2593,6 +2499,60 @@ class CodexAppServerAgentSession {
         });
         pending.resolve({ answers: {} });
     }
+    handlePlanPermissionResponse(params) {
+        const { requestId, response, pending, pendingRequest } = params;
+        let followUpPrompt;
+        if (response.behavior === "allow") {
+            followUpPrompt = this.preparePlanImplementation({
+                planText: pending.planText ?? pendingRequest?.metadata?.planText,
+            });
+        }
+        this.pendingPermissionHandlers.delete(requestId);
+        this.pendingPermissions.delete(requestId);
+        this.resolvedPermissionRequests.add(requestId);
+        this.emitEvent({
+            type: "permission_resolved",
+            provider: CODEX_PROVIDER,
+            requestId,
+            resolution: response,
+        });
+        if (followUpPrompt) {
+            return { followUpPrompt };
+        }
+    }
+    emitDeniedToolCallTimelineEvent(params) {
+        const { requestId, response, pendingRequest } = params;
+        let fallbackName;
+        if (pendingRequest.name === "CodexBash") {
+            fallbackName = "shell";
+        }
+        else if (pendingRequest.name === "CodexFileChange") {
+            fallbackName = "apply_patch";
+        }
+        else {
+            fallbackName = pendingRequest.name;
+        }
+        this.emitEvent({
+            type: "timeline",
+            provider: CODEX_PROVIDER,
+            item: {
+                type: "tool_call",
+                callId: requestId,
+                name: fallbackName,
+                status: "failed",
+                error: { message: response.message ?? "Permission denied" },
+                detail: pendingRequest.detail ?? {
+                    type: "unknown",
+                    input: pendingRequest.input ?? null,
+                    output: null,
+                },
+                metadata: {
+                    permissionRequestId: requestId,
+                    denied: true,
+                },
+            },
+        });
+    }
     describePersistence() {
         if (!this.currentThreadId)
             return null;
@@ -2663,12 +2623,10 @@ class CodexAppServerAgentSession {
             : [];
         return [...appServerSkills, ...fallbackSkills, ...prompts].sort((a, b) => a.name.localeCompare(b.name));
     }
-    async ensureThread() {
-        if (!this.client)
-            return;
-        if (this.currentThreadId)
-            return;
-        // Resolve model + thinking defaults when omitted.
+    async resolveModelAndThinking() {
+        if (!this.client) {
+            throw new Error("Codex client is not initialized");
+        }
         let configuredDefaults = {};
         let model = this.config.model;
         let thinkingOptionId = normalizeCodexThinkingOptionId(this.config.thinkingOptionId);
@@ -2696,6 +2654,17 @@ class CodexAppServerAgentSession {
                 thinkingOptionId = normalizeCodexThinkingOptionId(selectedModel.defaultReasoningEffort);
             }
         }
+        if (!model) {
+            throw new Error("Unable to resolve Codex model");
+        }
+        return { model, thinkingOptionId };
+    }
+    async ensureThread() {
+        if (!this.client)
+            return;
+        if (this.currentThreadId)
+            return;
+        const { model, thinkingOptionId } = await this.resolveModelAndThinking();
         this.config.model = model;
         this.config.thinkingOptionId = thinkingOptionId;
         const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
@@ -2734,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) {
@@ -2764,105 +2727,208 @@ class CodexAppServerAgentSession {
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
-        if (parsed.kind === "thread_started") {
-            this.currentThreadId = parsed.threadId;
-            this.emitEvent({
-                type: "thread_started",
-                provider: CODEX_PROVIDER,
-                sessionId: parsed.threadId,
-            });
-            return;
+        switch (parsed.kind) {
+            case "thread_started":
+                this.handleThreadStartedNotification(parsed);
+                return;
+            case "turn_started":
+                this.handleTurnStartedNotification(parsed);
+                return;
+            case "turn_completed":
+                this.handleTurnCompletedNotification(parsed);
+                return;
+            case "plan_updated":
+                this.handlePlanUpdatedNotification(parsed);
+                return;
+            case "diff_updated":
+                // NOTE: Codex app-server emits frequent `turn/diff/updated` notifications
+                // containing a full accumulated unified diff for the *entire turn*.
+                // This is not a concrete file-change tool call; it is progress telemetry.
+                return;
+            case "token_usage_updated":
+                this.handleTokenUsageUpdatedNotification(parsed);
+                return;
+            case "agent_message_delta":
+            case "reasoning_delta":
+            case "exec_command_output_delta":
+            case "file_change_output_delta":
+                this.handleCodexDeltaNotification(parsed);
+                return;
+            case "exec_command_started":
+                this.handleExecCommandStartedNotification(parsed);
+                return;
+            case "exec_command_completed":
+                this.handleExecCommandCompletedNotification(parsed);
+                return;
+            case "terminal_interaction":
+                this.handleTerminalInteractionNotification(parsed);
+                return;
+            case "patch_apply_started":
+                this.handlePatchApplyStartedNotification(parsed);
+                return;
+            case "patch_apply_completed":
+                this.handlePatchApplyCompletedNotification(parsed);
+                return;
+            case "item_completed":
+                this.handleItemCompletedNotification(parsed);
+                return;
+            case "item_started":
+                this.handleItemStartedNotification(parsed);
+                return;
+            case "invalid_payload":
+                this.warnInvalidNotificationPayload(parsed.method, parsed.params);
+                return;
+            default:
+                this.warnUnknownNotificationMethod(parsed.method, parsed.params);
         }
-        if (parsed.kind === "turn_started") {
-            this.currentTurnId = parsed.turnId;
-            this.latestPlanResult = null;
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
-            this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
-            return;
+    }
+    getSubAgentCallIdForThread(threadId) {
+        if (!threadId || threadId === this.currentThreadId) {
+            return null;
         }
-        if (parsed.kind === "turn_completed") {
-            if (parsed.status === "failed") {
-                this.emitEvent({
-                    type: "turn_failed",
-                    provider: CODEX_PROVIDER,
-                    error: parsed.errorMessage ?? "Codex turn failed",
-                });
-            }
-            else if (parsed.status === "interrupted") {
-                this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
-            }
-            else {
-                if (this.planModeEnabled && this.latestPlanResult?.text) {
-                    this.emitSyntheticPlanApprovalRequest(this.latestPlanResult.text);
-                }
-                this.emitEvent({
-                    type: "turn_completed",
-                    provider: CODEX_PROVIDER,
-                    usage: this.latestUsage,
-                });
-            }
-            this.activeForegroundTurnId = null;
-            this.latestPlanResult = null;
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
+        return this.subAgentCallIdByChildThreadId.get(threadId) ?? null;
+    }
+    registerSubAgentToolCall(timelineItem, rawItem) {
+        if (timelineItem.detail.type !== "sub_agent") {
             return;
         }
-        if (parsed.kind === "plan_updated") {
-            const timelineItem = mapCodexPlanToToolCall({
-                callId: `plan:${this.currentTurnId ?? this.currentThreadId ?? "current"}`,
-                text: planStepsToMarkdown(parsed.plan.map((entry) => ({
-                    step: entry.step ?? "",
-                    status: entry.status ?? "pending",
-                }))),
-            });
-            if (timelineItem) {
-                this.rememberPlanResult(timelineItem);
-                this.emitEvent({
-                    type: "timeline",
-                    provider: CODEX_PROVIDER,
-                    item: timelineItem,
-                });
-            }
+        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 (parsed.kind === "diff_updated") {
-            // NOTE: Codex app-server emits frequent `turn/diff/updated` notifications
-            // containing a full accumulated unified diff for the *entire turn*.
-            // This is not a concrete file-change tool call; it is progress telemetry.
-            // We intentionally do NOT store every diff update in the timeline.
+        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;
         }
-        if (parsed.kind === "token_usage_updated") {
-            this.latestUsage = toAgentUsage(parsed.tokenUsage);
-            if (this.latestUsage) {
-                this.notifySubscribers({
-                    type: "usage_updated",
-                    provider: CODEX_PROVIDER,
-                    usage: this.latestUsage,
-                });
+        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" },
             }
-            return;
+            : {
+                ...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") {
@@ -2871,192 +2937,340 @@ class CodexAppServerAgentSession {
             });
             return;
         }
-        if (parsed.kind === "file_change_output_delta") {
-            this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
+        this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
+    }
+    handleThreadStartedNotification(parsed) {
+        this.currentThreadId = parsed.threadId;
+        this.emitEvent({
+            type: "thread_started",
+            provider: CODEX_PROVIDER,
+            sessionId: parsed.threadId,
+        });
+    }
+    handleTurnStartedNotification(parsed) {
+        const subAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
+        if (subAgentCallId) {
+            this.emitSubAgentActivityUpdate(subAgentCallId, "running");
             return;
         }
-        if (parsed.kind === "exec_command_started") {
-            if (parsed.callId) {
-                this.emittedExecCommandStartedCallIds.add(parsed.callId);
-                this.pendingCommandOutputDeltas.delete(parsed.callId);
+        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";
             }
-            const timelineItem = mapCodexExecNotificationToToolCall({
-                callId: parsed.callId,
-                command: parsed.command,
-                cwd: parsed.cwd ?? this.config.cwd ?? null,
-                running: true,
-            });
-            if (timelineItem) {
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+            else if (parsed.status === "interrupted") {
+                status = "canceled";
             }
+            this.emitSubAgentActivityUpdate(subAgentCallId, status);
             return;
         }
-        if (parsed.kind === "exec_command_completed") {
-            const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
-            const resolvedOutput = parsed.output ?? bufferedOutput;
-            this.rememberTerminalProcessForCommand(parsed.command, resolvedOutput);
-            const timelineItem = mapCodexExecNotificationToToolCall({
-                callId: parsed.callId,
-                command: parsed.command,
-                cwd: parsed.cwd ?? this.config.cwd ?? null,
-                output: resolvedOutput,
-                exitCode: parsed.exitCode,
-                success: parsed.success,
-                stderr: parsed.stderr,
-                running: false,
+        if (parsed.status === "failed") {
+            this.emitEvent({
+                type: "turn_failed",
+                provider: CODEX_PROVIDER,
+                error: parsed.errorMessage ?? "Codex turn failed",
             });
-            if (timelineItem) {
-                this.emittedExecCommandCompletedCallIds.add(timelineItem.callId);
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+        else if (parsed.status === "interrupted") {
+            this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
+        }
+        else {
+            if (this.planModeEnabled && this.latestPlanResult?.text) {
+                this.emitSyntheticPlanApprovalRequest(this.latestPlanResult.text);
             }
-            return;
+            this.emitEvent({
+                type: "turn_completed",
+                provider: CODEX_PROVIDER,
+                usage: this.latestUsage,
+            });
         }
-        if (parsed.kind === "terminal_interaction") {
-            const interactionKey = [parsed.processId ?? "", parsed.stdin ?? ""].join("\u0000");
-            if (!this.shouldEmitTerminalInteractionKey(interactionKey)) {
+        this.activeForegroundTurnId = null;
+        this.resetTurnTrackingState();
+    }
+    resetTurnTrackingState() {
+        this.latestPlanResult = null;
+        this.emittedItemStartedIds.clear();
+        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) {
+        const timelineItem = mapCodexPlanToToolCall({
+            callId: `plan:${this.currentTurnId ?? this.currentThreadId ?? "current"}`,
+            text: planStepsToMarkdown(parsed.plan.map((entry) => ({
+                step: entry.step ?? "",
+                status: entry.status ?? "pending",
+            }))),
+        });
+        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;
             }
-            const command = (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
-                null;
-            if (!command && parsed.processId) {
-                this.pendingUnlabeledTerminalInteractions.add(parsed.processId);
-            }
-            const timelineItem = mapCodexTerminalInteractionToToolCall({
-                processId: parsed.processId,
-                fallbackCallId: parsed.callId,
-                command,
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleTokenUsageUpdatedNotification(parsed) {
+        this.latestUsage = toAgentUsage(parsed.tokenUsage);
+        if (this.latestUsage) {
+            this.notifySubscribers({
+                type: "usage_updated",
+                provider: CODEX_PROVIDER,
+                usage: this.latestUsage,
             });
+        }
+    }
+    handleExecCommandStartedNotification(parsed) {
+        if (parsed.callId) {
+            this.emittedExecCommandStartedCallIds.add(parsed.callId);
+            this.pendingCommandOutputDeltas.delete(parsed.callId);
+        }
+        const timelineItem = mapCodexExecNotificationToToolCall({
+            callId: parsed.callId,
+            command: parsed.command,
+            cwd: parsed.cwd ?? this.config.cwd ?? null,
+            running: true,
+        });
+        if (timelineItem) {
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleExecCommandCompletedNotification(parsed) {
+        const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
+        const resolvedOutput = parsed.output ?? bufferedOutput;
+        this.rememberTerminalProcessForCommand(parsed.command, resolvedOutput);
+        const timelineItem = mapCodexExecNotificationToToolCall({
+            callId: parsed.callId,
+            command: parsed.command,
+            cwd: parsed.cwd ?? this.config.cwd ?? null,
+            output: resolvedOutput,
+            exitCode: parsed.exitCode,
+            success: parsed.success,
+            stderr: parsed.stderr,
+            running: false,
+        });
+        if (timelineItem) {
+            this.emittedExecCommandCompletedCallIds.add(timelineItem.callId);
             this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleTerminalInteractionNotification(parsed) {
+        const interactionKey = [parsed.processId ?? "", parsed.stdin ?? ""].join("\u0000");
+        if (!this.shouldEmitTerminalInteractionKey(interactionKey)) {
             return;
         }
-        if (parsed.kind === "patch_apply_started") {
-            if (parsed.callId) {
-                this.pendingFileChangeOutputDeltas.delete(parsed.callId);
-            }
-            const timelineItem = mapCodexPatchNotificationToToolCall({
+        const command = (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
+            null;
+        if (!command && parsed.processId) {
+            this.pendingUnlabeledTerminalInteractions.add(parsed.processId);
+        }
+        const timelineItem = mapCodexTerminalInteractionToToolCall({
+            processId: parsed.processId,
+            fallbackCallId: parsed.callId,
+            command,
+        });
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+    }
+    handlePatchApplyStartedNotification(parsed) {
+        if (parsed.callId) {
+            this.pendingFileChangeOutputDeltas.delete(parsed.callId);
+        }
+        const timelineItem = mapCodexPatchNotificationToToolCall({
+            callId: parsed.callId,
+            changes: parsed.changes,
+            cwd: this.config.cwd ?? null,
+            running: true,
+        });
+        if (timelineItem) {
+            this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_started", {
                 callId: parsed.callId,
                 changes: parsed.changes,
-                cwd: this.config.cwd ?? null,
-                running: true,
             });
-            if (timelineItem) {
-                this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_started", {
-                    callId: parsed.callId,
-                    changes: parsed.changes,
-                });
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-            }
-            return;
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
         }
-        if (parsed.kind === "patch_apply_completed") {
-            const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
-            const timelineItem = mapCodexPatchNotificationToToolCall({
+    }
+    handlePatchApplyCompletedNotification(parsed) {
+        const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
+        const timelineItem = mapCodexPatchNotificationToToolCall({
+            callId: parsed.callId,
+            changes: parsed.changes,
+            cwd: this.config.cwd ?? null,
+            stdout: parsed.stdout ?? bufferedOutput,
+            stderr: parsed.stderr,
+            success: parsed.success,
+            running: false,
+        });
+        if (timelineItem) {
+            this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_completed", {
                 callId: parsed.callId,
                 changes: parsed.changes,
-                cwd: this.config.cwd ?? null,
-                stdout: parsed.stdout ?? bufferedOutput,
-                stderr: parsed.stderr,
-                success: parsed.success,
-                running: false,
+                stdout: parsed.stdout,
             });
-            if (timelineItem) {
-                this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_completed", {
-                    callId: parsed.callId,
-                    changes: parsed.changes,
-                    stdout: parsed.stdout,
-                });
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-            }
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleItemCompletedNotification(parsed) {
+        // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
+        // and canonical `item/*`. We render only the canonical channel to avoid
+        // duplicated assistant/reasoning rows.
+        if (parsed.source === "codex_event") {
             return;
         }
-        if (parsed.kind === "item_completed") {
-            // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
-            // and canonical `item/*`. We render only the canonical channel to avoid
-            // duplicated assistant/reasoning rows.
-            if (parsed.source === "codex_event") {
-                return;
+        const timelineItem = threadItemToTimeline(parsed.item, {
+            includeUserMessage: false,
+            cwd: this.config.cwd ?? null,
+        });
+        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;
+        if (this.shouldSkipCompletedThreadItem(timelineItem, normalizedItemType, itemId)) {
+            return;
+        }
+        if (this.consumeStreamedTextCompletion(timelineItem, itemId)) {
+            if (timelineItem.type === "assistant_message") {
+                this.pendingAssistantMessageBoundary = true;
             }
-            const timelineItem = threadItemToTimeline(parsed.item, {
-                includeUserMessage: false,
-                cwd: this.config.cwd ?? null,
-            });
-            if (timelineItem) {
-                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.
-                // Keep item/completed as fallback only when no exec_command completion was seen.
-                if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
-                    const callId = timelineItem.callId || itemId;
-                    if (callId && this.emittedExecCommandCompletedCallIds.has(callId)) {
-                        return;
-                    }
-                }
-                if (itemId && this.emittedItemCompletedIds.has(itemId)) {
+            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;
                 }
-                if (timelineItem.type === "assistant_message" && itemId) {
-                    const buffered = this.pendingAgentMessages.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered;
-                    }
-                }
-                if (timelineItem.type === "reasoning" && itemId) {
-                    const buffered = this.pendingReasoning.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered.join("");
-                    }
-                }
-                if (timelineItem.type === "tool_call") {
-                    if (timelineItem.detail.type === "plan") {
-                        this.rememberPlanResult(timelineItem);
-                    }
-                    this.warnOnIncompleteEditToolCall(timelineItem, "item_completed", parsed.item);
-                }
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-                if (itemId) {
-                    this.emittedItemCompletedIds.add(itemId);
-                    this.emittedItemStartedIds.delete(itemId);
-                    this.pendingCommandOutputDeltas.delete(itemId);
-                    this.pendingFileChangeOutputDeltas.delete(itemId);
-                }
             }
+            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);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            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;
         }
-        if (parsed.kind === "item_started") {
-            if (parsed.source === "codex_event") {
-                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;
+        }
+        if (timelineItem.type === "assistant_message") {
+            const buffered = this.pendingAgentMessages.get(itemId);
+            if (buffered && buffered.length > 0) {
+                timelineItem.text = buffered;
             }
-            const timelineItem = threadItemToTimeline(parsed.item, {
-                includeUserMessage: false,
-                cwd: this.config.cwd ?? null,
-            });
-            if (timelineItem && timelineItem.type === "tool_call") {
-                const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
-                const itemId = parsed.item.id;
-                if (normalizedItemType === "commandExecution") {
-                    const callId = timelineItem.callId || itemId;
-                    if (callId && this.emittedExecCommandStartedCallIds.has(callId)) {
-                        return;
-                    }
-                }
-                if (itemId && this.emittedItemStartedIds.has(itemId)) {
-                    return;
-                }
-                this.warnOnIncompleteEditToolCall(timelineItem, "item_started", parsed.item);
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-                if (itemId) {
-                    this.emittedItemStartedIds.add(itemId);
-                    this.pendingCommandOutputDeltas.delete(itemId);
-                    this.pendingFileChangeOutputDeltas.delete(itemId);
-                }
+            return;
+        }
+        if (timelineItem.type === "reasoning") {
+            const buffered = this.pendingReasoning.get(itemId);
+            if (buffered && buffered.length > 0) {
+                timelineItem.text = buffered.join("");
+            }
+        }
+    }
+    handleItemStartedNotification(parsed) {
+        if (parsed.source === "codex_event") {
+            return;
+        }
+        const timelineItem = threadItemToTimeline(parsed.item, {
+            includeUserMessage: false,
+            cwd: this.config.cwd ?? null,
+        });
+        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;
         }
-        if (parsed.kind === "invalid_payload") {
-            this.warnInvalidNotificationPayload(parsed.method, parsed.params);
+        const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
+        const itemId = parsed.item.id;
+        if (normalizedItemType === "commandExecution") {
+            const callId = timelineItem.callId || itemId;
+            if (callId && this.emittedExecCommandStartedCallIds.has(callId)) {
+                return;
+            }
+        }
+        if (itemId && this.emittedItemStartedIds.has(itemId)) {
             return;
         }
-        this.warnUnknownNotificationMethod(parsed.method, parsed.params);
+        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);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            this.pendingFileChangeOutputDeltas.delete(itemId);
+        }
     }
     warnUnknownNotificationMethod(method, params) {
         if (this.warnedUnknownNotificationMethods.has(method)) {
@@ -3280,7 +3494,10 @@ export class CodexAppServerAgentClient {
         return spawnProcess(launchPrefix.command, [...launchPrefix.args, "app-server"], {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
-            env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [launchEnv],
+            }),
         });
     }
     async createSession(config, launchContext) {
@@ -3310,38 +3527,31 @@ export class CodexAppServerAgentClient {
             const limit = options?.limit ?? 20;
             const response = (await client.request("thread/list", { limit }));
             const threads = Array.isArray(response?.data) ? response.data : [];
-            const descriptors = [];
-            for (const thread of threads.slice(0, limit)) {
-                const threadId = thread.id;
-                const cwd = thread.cwd ?? process.cwd();
-                const title = thread.preview ?? null;
+            const descriptors = await Promise.all(threads.slice(0, limit).map(async (thread) => {
+                const threadId = typeof thread.id === "string" ? thread.id : "";
+                const cwd = typeof thread.cwd === "string" ? thread.cwd : process.cwd();
+                const title = typeof thread.preview === "string" ? thread.preview : null;
                 let timeline = [];
                 try {
-                    const rolloutTimeline = await loadCodexPersistedTimeline(threadId, undefined, this.logger);
-                    const read = (await client.request("thread/read", {
+                    timeline = await loadCodexThreadHistoryTimeline({
                         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;
+                        cwd,
+                        requestThread: (threadIdToRead) => {
+                            return readCodexThread(client, threadIdToRead);
+                        },
+                    });
                 }
                 catch {
                     timeline = [];
                 }
-                descriptors.push({
+                return {
                     provider: CODEX_PROVIDER,
                     sessionId: threadId,
                     cwd,
                     title,
-                    lastActivityAt: new Date((thread.updatedAt ?? thread.createdAt ?? 0) * 1000),
+                    lastActivityAt: new Date(((typeof thread.updatedAt === "number" ? thread.updatedAt : undefined) ??
+                        (typeof thread.createdAt === "number" ? thread.createdAt : undefined) ??
+                        0) * 1000),
                     persistence: {
                         provider: CODEX_PROVIDER,
                         sessionId: threadId,
@@ -3354,8 +3564,8 @@ export class CodexAppServerAgentClient {
                         },
                     },
                     timeline,
-                });
-            }
+                };
+            }));
             return descriptors;
         }
         finally {
@@ -3377,55 +3587,11 @@ export class CodexAppServerAgentClient {
             const hasConfiguredDefaultModel = typeof configuredDefaultModelId === "string"
                 ? models.some((model) => model?.id === configuredDefaultModelId)
                 : false;
-            return models.map((model) => {
-                const defaultReasoningEffort = normalizeCodexThinkingOptionId(typeof model.defaultReasoningEffort === "string" ? model.defaultReasoningEffort : null);
-                const resolvedDefaultReasoningEffort = configuredDefaultThinkingOptionId ?? defaultReasoningEffort;
-                const thinkingById = new Map();
-                if (Array.isArray(model.supportedReasoningEfforts)) {
-                    for (const entry of model.supportedReasoningEfforts) {
-                        const id = normalizeCodexThinkingOptionId(typeof entry?.reasoningEffort === "string" ? entry.reasoningEffort : null);
-                        if (!id)
-                            continue;
-                        const description = typeof entry?.description === "string" && entry.description.trim().length > 0
-                            ? entry.description
-                            : undefined;
-                        thinkingById.set(id, { id, label: id, description });
-                    }
-                }
-                if (resolvedDefaultReasoningEffort && !thinkingById.has(resolvedDefaultReasoningEffort)) {
-                    thinkingById.set(resolvedDefaultReasoningEffort, {
-                        id: resolvedDefaultReasoningEffort,
-                        label: resolvedDefaultReasoningEffort,
-                        description: configuredDefaultThinkingOptionId === resolvedDefaultReasoningEffort
-                            ? "Configured default reasoning effort"
-                            : "Model default reasoning effort",
-                    });
-                }
-                const thinkingOptions = Array.from(thinkingById.values()).map((option) => ({
-                    ...option,
-                    isDefault: option.id === resolvedDefaultReasoningEffort,
-                }));
-                const defaultThinkingOptionId = resolvedDefaultReasoningEffort ??
-                    thinkingOptions.find((option) => option.isDefault)?.id ??
-                    thinkingOptions[0]?.id;
-                const isDefaultModel = hasConfiguredDefaultModel
-                    ? model.id === configuredDefaultModelId
-                    : model.isDefault;
-                return {
-                    provider: CODEX_PROVIDER,
-                    id: model.id,
-                    label: normalizeCodexModelLabel(model.displayName),
-                    description: model.description,
-                    isDefault: isDefaultModel,
-                    thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
-                    defaultThinkingOptionId,
-                    metadata: {
-                        model: model.model,
-                        defaultReasoningEffort: model.defaultReasoningEffort,
-                        supportedReasoningEfforts: model.supportedReasoningEfforts,
-                    },
-                };
-            });
+            return models.map((model) => buildCodexModelDefinition(model, {
+                configuredDefaultModelId,
+                configuredDefaultThinkingOptionId,
+                hasConfiguredDefaultModel,
+            }));
         }
         finally {
             await client.dispose();
@@ -3484,6 +3650,67 @@ export class CodexAppServerAgentClient {
         }
     }
 }
+function buildCodexModelDefinition(model, ctx) {
+    const defaultReasoningEffort = normalizeCodexThinkingOptionId(typeof model.defaultReasoningEffort === "string" ? model.defaultReasoningEffort : null);
+    const resolvedDefaultReasoningEffort = ctx.configuredDefaultThinkingOptionId ?? defaultReasoningEffort;
+    const thinkingById = buildCodexThinkingOptionMap(model.supportedReasoningEfforts, resolvedDefaultReasoningEffort, ctx.configuredDefaultThinkingOptionId);
+    const thinkingOptions = Array.from(thinkingById.values()).map((option) => Object.assign({}, option, {
+        isDefault: option.id === resolvedDefaultReasoningEffort,
+    }));
+    const defaultThinkingOptionId = resolvedDefaultReasoningEffort ??
+        thinkingOptions.find((option) => option.isDefault)?.id ??
+        thinkingOptions[0]?.id;
+    const isDefaultModel = ctx.hasConfiguredDefaultModel
+        ? model.id === ctx.configuredDefaultModelId
+        : model.isDefault;
+    return {
+        provider: CODEX_PROVIDER,
+        id: model.id,
+        label: normalizeCodexModelLabel(model.displayName ?? ""),
+        description: model.description,
+        isDefault: isDefaultModel,
+        thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+        defaultThinkingOptionId,
+        metadata: {
+            model: model.model,
+            defaultReasoningEffort: model.defaultReasoningEffort,
+            supportedReasoningEfforts: model.supportedReasoningEfforts,
+        },
+    };
+}
+function buildCodexThinkingOptionMap(supportedReasoningEfforts, resolvedDefaultReasoningEffort, configuredDefaultThinkingOptionId) {
+    const thinkingById = new Map();
+    if (Array.isArray(supportedReasoningEfforts)) {
+        for (const entry of supportedReasoningEfforts) {
+            const id = normalizeCodexThinkingOptionId(typeof entry?.reasoningEffort === "string" ? entry.reasoningEffort : null);
+            if (!id)
+                continue;
+            const description = typeof entry?.description === "string" && entry.description.trim().length > 0
+                ? entry.description
+                : undefined;
+            thinkingById.set(id, { id, label: id, description });
+        }
+    }
+    if (resolvedDefaultReasoningEffort && !thinkingById.has(resolvedDefaultReasoningEffort)) {
+        thinkingById.set(resolvedDefaultReasoningEffort, {
+            id: resolvedDefaultReasoningEffort,
+            label: resolvedDefaultReasoningEffort,
+            description: configuredDefaultThinkingOptionId === resolvedDefaultReasoningEffort
+                ? "Configured default reasoning effort"
+                : "Model default reasoning effort",
+        });
+    }
+    return thinkingById;
+}
+function resolveSkillDescription(skill) {
+    if (typeof skill.description === "string") {
+        return skill.description;
+    }
+    if (typeof skill.shortDescription === "string") {
+        return skill.shortDescription;
+    }
+    return "Skill";
+}
 export const __codexAppServerInternals = {
     buildCodexAppServerEnv,
     CodexAppServerClient,