@junctionpanel/server 0.1.62 → 0.1.64

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

@@ -1,6 +1,7 @@
 import pino from "pino";
 import { execSync, spawn } from "node:child_process";
 import fs from "node:fs/promises";
+import { createReadStream } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
@@ -14,7 +15,44 @@ import { writeImageAttachment } from "./image-attachments.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const TURN_COMPLETION_SETTLE_DELAY_MS = 75;
+const CODEX_ROLLOUT_SPAWN_POLL_MS = 900;
 const CODEX_PROVIDER = "codex";
+const CODEX_SESSION_SCAN_MAX_DEPTH = 4;
+const CODEX_THREAD_LIST_SOURCE_KINDS = [
+    "cli",
+    "vscode",
+    "exec",
+    "appServer",
+    "subAgent",
+    "subAgentReview",
+    "subAgentCompact",
+    "subAgentThreadSpawn",
+    "subAgentOther",
+    "unknown",
+];
+function parseCodexThreadListAllowedSourceKinds(errorMessage) {
+    const match = /expected one of (.+)$/i.exec(errorMessage);
+    if (!match) {
+        return null;
+    }
+    const allowed = match[1]
+        .split(",")
+        .map((value) => value.trim().replace(/^`|`$/g, ""))
+        .filter((value) => value.length > 0);
+    return allowed.length > 0 ? allowed : null;
+}
+function resolveCodexThreadListRetrySourceKinds(preferredSourceKinds, errorMessage) {
+    const allowedSourceKinds = parseCodexThreadListAllowedSourceKinds(errorMessage);
+    if (!allowedSourceKinds) {
+        return null;
+    }
+    const allowedSourceKindSet = new Set(allowedSourceKinds);
+    const retrySourceKinds = preferredSourceKinds.filter((value) => allowedSourceKindSet.has(value));
+    if (retrySourceKinds.length === 0 || retrySourceKinds.length === preferredSourceKinds.length) {
+        return null;
+    }
+    return retrySourceKinds;
+}
 const CODEX_APP_SERVER_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -112,6 +150,41 @@ function resolveCodexLaunchPrefix(runtimeSettings) {
 function resolveCodexHomeDir() {
     return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
 }
+function resolveCodexSessionRoot() {
+    return process.env.CODEX_SESSION_DIR ?? path.join(resolveCodexHomeDir(), "sessions");
+}
+function isCodexRolloutFileName(fileName) {
+    return (fileName.startsWith("rollout-") &&
+        (fileName.endsWith(".json") || fileName.endsWith(".jsonl")));
+}
+async function listCodexRolloutPaths(root) {
+    const rolloutPaths = [];
+    const stack = [{ dir: root, depth: 0 }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(current.dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(current.dir, entry.name);
+            if (entry.isFile() && isCodexRolloutFileName(entry.name)) {
+                rolloutPaths.push(entryPath);
+                continue;
+            }
+            if (entry.isDirectory() && current.depth < CODEX_SESSION_SCAN_MAX_DEPTH) {
+                stack.push({ dir: entryPath, depth: current.depth + 1 });
+            }
+        }
+    }
+    return rolloutPaths;
+}
 function tokenizeCommandArgs(args) {
     const tokens = [];
     let current = "";
@@ -196,11 +269,368 @@ function toRecord(value) {
 }
 function toNonEmptyString(value) {
     if (typeof value !== "string") {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return String(value);
+        }
         return null;
     }
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function readStringField(record, keys) {
+    if (!record) {
+        return null;
+    }
+    for (const key of keys) {
+        const value = toNonEmptyString(record[key]);
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
+function readNestedRecord(record, keys) {
+    if (!record) {
+        return null;
+    }
+    for (const key of keys) {
+        const value = toRecord(record[key]);
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
+function readCodexNotificationProvenance(input) {
+    const root = toRecord(input);
+    const turnRecord = readNestedRecord(root, ["turn"]);
+    const messageRecord = readNestedRecord(root, ["msg"]);
+    return {
+        threadId: readStringField(root, ["threadId", "thread_id"]) ??
+            readStringField(turnRecord, ["threadId", "thread_id"]) ??
+            readStringField(messageRecord, ["threadId", "thread_id"]),
+        turnId: readStringField(root, ["turnId", "turn_id"]) ??
+            readStringField(turnRecord, ["turnId", "turn_id"]) ??
+            readStringField(messageRecord, ["turnId", "turn_id"]),
+    };
+}
+function toTimestampDate(value, fallback) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value * 1000);
+    }
+    if (typeof value === "string") {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) {
+            return new Date(numeric * 1000);
+        }
+        const parsed = Date.parse(value);
+        if (!Number.isNaN(parsed)) {
+            return new Date(parsed);
+        }
+    }
+    return fallback;
+}
+const codexPersistedThreadMetadataCache = new Map();
+const CODEX_PERSISTED_THREAD_METADATA_CACHE_LIMIT = 512;
+function setCodexPersistedThreadMetadataCache(rolloutPath, entry) {
+    if (codexPersistedThreadMetadataCache.has(rolloutPath)) {
+        codexPersistedThreadMetadataCache.delete(rolloutPath);
+    }
+    codexPersistedThreadMetadataCache.set(rolloutPath, entry);
+    while (codexPersistedThreadMetadataCache.size >
+        CODEX_PERSISTED_THREAD_METADATA_CACHE_LIMIT) {
+        const oldestKey = codexPersistedThreadMetadataCache.keys().next().value;
+        if (typeof oldestKey !== "string") {
+            break;
+        }
+        codexPersistedThreadMetadataCache.delete(oldestKey);
+    }
+}
+function unwrapCodexPersistedThreadRecord(thread) {
+    const record = toRecord(thread);
+    if (!record) {
+        return null;
+    }
+    if (record.type === "session_meta") {
+        const payloadRecord = readNestedRecord(record, ["payload"]);
+        if (payloadRecord) {
+            return payloadRecord;
+        }
+    }
+    const nestedThreadRecord = readNestedRecord(record, ["thread"]);
+    if (nestedThreadRecord) {
+        return nestedThreadRecord;
+    }
+    return record;
+}
+function parseCodexPersistedThreadMetadata(thread, fallbackDate = new Date()) {
+    const threadRecord = unwrapCodexPersistedThreadRecord(thread);
+    const sourceRecord = readNestedRecord(threadRecord, ["source"]);
+    const subAgentRecord = readNestedRecord(sourceRecord, ["subAgent", "sub_agent", "subagent"]) ??
+        readNestedRecord(threadRecord, ["subAgent", "sub_agent", "subagent"]);
+    const threadSpawnRecord = readNestedRecord(subAgentRecord, ["thread_spawn", "threadSpawn"]) ??
+        readNestedRecord(sourceRecord, ["thread_spawn", "threadSpawn"]);
+    const createdAt = toTimestampDate(threadRecord?.createdAt, fallbackDate);
+    const updatedAt = toTimestampDate(threadRecord?.updatedAt ?? threadRecord?.createdAt, createdAt);
+    return {
+        threadId: toNonEmptyString(threadRecord?.id),
+        cwd: toNonEmptyString(threadRecord?.cwd),
+        title: toNonEmptyString(threadRecord?.preview) ?? null,
+        createdAt,
+        updatedAt,
+        parentSessionId: readStringField(threadRecord, [
+            "parentThreadId",
+            "parent_thread_id",
+            "forkedFromId",
+            "forked_from_id",
+        ]) ??
+            readStringField(threadSpawnRecord, [
+                "parentThreadId",
+                "parent_thread_id",
+                "forkedFromId",
+                "forked_from_id",
+            ]) ??
+            readStringField(subAgentRecord, [
+                "parentThreadId",
+                "parent_thread_id",
+                "forkedFromId",
+                "forked_from_id",
+            ]),
+        rootSessionId: readStringField(threadRecord, ["rootThreadId", "root_thread_id"]) ??
+            readStringField(threadSpawnRecord, ["rootThreadId", "root_thread_id"]) ??
+            readStringField(subAgentRecord, ["rootThreadId", "root_thread_id"]),
+        agentId: readStringField(threadRecord, ["agentId", "agent_id"]) ??
+            readStringField(threadSpawnRecord, ["agentId", "agent_id", "id"]) ??
+            readStringField(subAgentRecord, ["agentId", "agent_id", "id"]),
+        agentNickname: readStringField(threadRecord, ["agentNickname", "agent_nickname"]) ??
+            readStringField(threadSpawnRecord, [
+                "agentNickname",
+                "agent_nickname",
+                "nickname",
+                "name",
+            ]) ??
+            readStringField(subAgentRecord, [
+                "agentNickname",
+                "agent_nickname",
+                "nickname",
+                "name",
+            ]),
+        agentRole: readStringField(threadRecord, [
+            "agentRole",
+            "agent_role",
+            "agentType",
+            "agent_type",
+        ]) ??
+            readStringField(threadSpawnRecord, [
+                "agentRole",
+                "agent_role",
+                "agentType",
+                "agent_type",
+            ]) ??
+            readStringField(subAgentRecord, [
+                "agentRole",
+                "agent_role",
+                "agentType",
+                "agent_type",
+            ]),
+        model: readStringField(threadRecord, ["model", "modelProvider", "model_provider"]) ??
+            readStringField(threadSpawnRecord, ["model", "modelProvider", "model_provider"]) ??
+            readStringField(subAgentRecord, ["model", "modelProvider", "model_provider"]),
+    };
+}
+function mergeCodexPersistedThreadMetadata(base, incoming) {
+    const baseHasFallbackCwd = !base.cwd || base.cwd === process.cwd();
+    return {
+        threadId: base.threadId ?? incoming.threadId,
+        cwd: baseHasFallbackCwd ? incoming.cwd ?? base.cwd : base.cwd ?? incoming.cwd,
+        title: base.title ?? incoming.title,
+        createdAt: base.createdAt.getTime() <= incoming.createdAt.getTime()
+            ? base.createdAt
+            : incoming.createdAt,
+        updatedAt: base.updatedAt.getTime() >= incoming.updatedAt.getTime()
+            ? base.updatedAt
+            : incoming.updatedAt,
+        parentSessionId: base.parentSessionId ?? incoming.parentSessionId,
+        rootSessionId: base.rootSessionId ?? incoming.rootSessionId,
+        agentId: base.agentId ?? incoming.agentId,
+        agentNickname: base.agentNickname ?? incoming.agentNickname,
+        agentRole: base.agentRole ?? incoming.agentRole,
+        model: base.model ?? incoming.model,
+    };
+}
+async function readCodexPersistedThreadMetadataFromRolloutPath(rolloutPath, logger) {
+    if (rolloutPath.endsWith(".json")) {
+        try {
+            const raw = await fs.readFile(rolloutPath, "utf8");
+            return parseCodexPersistedThreadMetadata(JSON.parse(raw));
+        }
+        catch (error) {
+            logger?.debug({ err: error, rolloutPath }, "Failed to read Codex persisted thread metadata from JSON rollout path");
+            return null;
+        }
+    }
+    const input = createReadStream(rolloutPath, { encoding: "utf8" });
+    const lines = readline.createInterface({
+        input,
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const parsed = JSON.parse(trimmed);
+            return parseCodexPersistedThreadMetadata(parsed);
+        }
+    }
+    catch (error) {
+        logger?.debug({ err: error, rolloutPath }, "Failed to read Codex persisted thread metadata from rollout path");
+    }
+    finally {
+        lines.close();
+        input.destroy();
+    }
+    return null;
+}
+async function buildCodexPersistedDescriptorFromRolloutPath(input) {
+    let stat;
+    try {
+        stat = await fs.stat(input.rolloutPath);
+    }
+    catch {
+        return null;
+    }
+    const cached = codexPersistedThreadMetadataCache.get(input.rolloutPath);
+    let metadata = cached && cached.mtimeMs === stat.mtimeMs ? cached.metadata : undefined;
+    if (metadata === undefined) {
+        metadata = await readCodexPersistedThreadMetadataFromRolloutPath(input.rolloutPath, input.logger);
+        setCodexPersistedThreadMetadataCache(input.rolloutPath, {
+            mtimeMs: stat.mtimeMs,
+            metadata,
+        });
+    }
+    const threadId = metadata?.threadId;
+    if (!metadata || !threadId) {
+        return null;
+    }
+    const lastActivityAt = stat.mtime;
+    const timeline = input.includeTimeline
+        ? await loadCodexPersistedTimeline(threadId, { rolloutPath: input.rolloutPath, sessionRoot: resolveCodexSessionRoot() }, input.logger)
+        : [];
+    return {
+        provider: CODEX_PROVIDER,
+        sessionId: threadId,
+        cwd: metadata.cwd ?? process.cwd(),
+        title: metadata.title,
+        createdAt: metadata.createdAt,
+        lastActivityAt,
+        persistence: {
+            provider: CODEX_PROVIDER,
+            sessionId: threadId,
+            nativeHandle: threadId,
+            metadata: {
+                provider: CODEX_PROVIDER,
+                cwd: metadata.cwd ?? process.cwd(),
+                title: metadata.title,
+                threadId,
+            },
+        },
+        timeline,
+        model: metadata.model,
+        parentSessionId: metadata.parentSessionId,
+        rootSessionId: metadata.rootSessionId,
+        agentId: metadata.agentId,
+        agentNickname: metadata.agentNickname,
+        agentRole: metadata.agentRole,
+    };
+}
+async function requestCodexThreadList(input) {
+    try {
+        return (await input.client.request("thread/list", {
+            limit: input.limit,
+            ...(input.sourceKinds ? { sourceKinds: [...input.sourceKinds] } : {}),
+        }));
+    }
+    catch (error) {
+        const retrySourceKinds = error instanceof CodexAppServerRequestError && error.method === "thread/list"
+            ? resolveCodexThreadListRetrySourceKinds(input.sourceKinds ?? [], error.message)
+            : null;
+        if (!retrySourceKinds) {
+            throw error;
+        }
+        input.logger.warn({
+            rejectedSourceKinds: input.sourceKinds,
+            retrySourceKinds,
+            error: error instanceof Error ? error.message : String(error),
+        }, "Codex thread/list rejected sourceKinds; retrying with supported variants");
+        return (await input.client.request("thread/list", {
+            limit: input.limit,
+            sourceKinds: retrySourceKinds,
+        }));
+    }
+}
+async function readCodexPersistedDescriptorBySessionId(input) {
+    const response = (await input.client.request("thread/read", {
+        threadId: input.sessionId,
+        includeTurns: input.includeTimeline,
+    }));
+    const threadRecord = response?.thread ?? null;
+    if (!threadRecord) {
+        return null;
+    }
+    let metadata = parseCodexPersistedThreadMetadata(threadRecord);
+    const rolloutPath = readStringField(toRecord(threadRecord), ["path"]);
+    if (rolloutPath) {
+        const rolloutMetadata = await readCodexPersistedThreadMetadataFromRolloutPath(rolloutPath, input.logger);
+        if (rolloutMetadata) {
+            metadata = mergeCodexPersistedThreadMetadata(metadata, rolloutMetadata);
+        }
+    }
+    const threadId = metadata.threadId ?? input.sessionId.trim();
+    if (!threadId) {
+        return null;
+    }
+    const cwd = metadata.cwd ?? process.cwd();
+    let timeline = [];
+    if (input.includeTimeline) {
+        const rolloutTimeline = await loadCodexPersistedTimeline(threadId, undefined, input.logger).catch(() => []);
+        const turns = threadRecord.turns ?? [];
+        const threadTimeline = readCodexThreadTimelineFromTurns(turns, {
+            cwd,
+        });
+        timeline = mergeCodexThreadReadTimelineWithRolloutSpawnCalls({
+            threadTimeline,
+            rolloutTimeline,
+        });
+    }
+    return {
+        provider: CODEX_PROVIDER,
+        sessionId: threadId,
+        cwd,
+        title: metadata.title,
+        createdAt: metadata.createdAt,
+        lastActivityAt: metadata.updatedAt,
+        persistence: {
+            provider: CODEX_PROVIDER,
+            sessionId: threadId,
+            nativeHandle: threadId,
+            metadata: {
+                provider: CODEX_PROVIDER,
+                cwd,
+                title: metadata.title,
+                threadId,
+            },
+        },
+        timeline,
+        model: metadata.model,
+        parentSessionId: metadata.parentSessionId,
+        rootSessionId: metadata.rootSessionId,
+        agentId: metadata.agentId,
+        agentNickname: metadata.agentNickname,
+        agentRole: metadata.agentRole,
+    };
+}
 function parseUpdatedQuestionAnswers(updatedInput) {
     const parsed = {};
     const root = toRecord(updatedInput);
@@ -586,6 +1016,12 @@ class CodexAppServerClient {
     setNotificationHandler(handler) {
         this.notificationHandler = handler;
     }
+    dispatchNotification(method, params) {
+        if (this.disposed) {
+            return;
+        }
+        this.notificationHandler?.(method, params);
+    }
     setRequestHandler(method, handler) {
         this.requestHandlers.set(method, handler);
     }
@@ -903,6 +1339,25 @@ function normalizeCodexThreadItemType(rawType) {
     if (!rawType) {
         return rawType;
     }
+    const normalized = rawType.replace(/[._-]/g, "").toLowerCase();
+    switch (normalized) {
+        case "usermessage":
+            return "userMessage";
+        case "agentmessage":
+            return "agentMessage";
+        case "reasoning":
+            return "reasoning";
+        case "plan":
+            return "plan";
+        case "commandexecution":
+            return "commandExecution";
+        case "filechange":
+            return "fileChange";
+        case "mcptoolcall":
+            return "mcpToolCall";
+        case "websearch":
+            return "webSearch";
+    }
     switch (rawType) {
         case "UserMessage":
             return "userMessage";
@@ -1213,6 +1668,92 @@ function threadItemToTimeline(item, options) {
             return null;
     }
 }
+function readCodexThreadTimelineFromTurns(turns, options) {
+    const timeline = [];
+    for (const turn of turns) {
+        for (const item of turn.items ?? []) {
+            const timelineItem = threadItemToTimeline(item, {
+                cwd: options?.cwd ?? null,
+            });
+            if (timelineItem) {
+                timeline.push(timelineItem);
+            }
+        }
+    }
+    return timeline;
+}
+function areCodexTimelineItemsEquivalent(left, right) {
+    if (left.type !== right.type) {
+        return false;
+    }
+    switch (left.type) {
+        case "user_message":
+        case "assistant_message":
+        case "reasoning":
+            return left.text === right.text;
+        case "todo":
+            return JSON.stringify(left.items) === JSON.stringify(right.items);
+        case "tool_call":
+            if (left.callId && right.type === "tool_call" && right.callId) {
+                return left.callId === right.callId;
+            }
+            return false;
+        default:
+            return false;
+    }
+}
+function isCodexRolloutSpawnAgentToolCall(item) {
+    return item.type === "tool_call" && item.name === "spawn_agent";
+}
+function mergeCodexThreadReadTimelineWithRolloutSpawnCalls(input) {
+    if (input.rolloutTimeline.length === 0) {
+        return input.threadTimeline;
+    }
+    const existingSpawnCallIds = new Set(input.threadTimeline.flatMap((item) => isCodexRolloutSpawnAgentToolCall(item) && item.callId ? [item.callId] : []));
+    const queuedSpawnCallIds = new Set();
+    const insertionsByThreadIndex = new Map();
+    let searchIndex = 0;
+    let lastMatchedThreadIndex = -1;
+    for (const rolloutItem of input.rolloutTimeline) {
+        const matchedThreadIndex = input.threadTimeline.findIndex((threadItem, index) => index >= searchIndex && areCodexTimelineItemsEquivalent(threadItem, rolloutItem));
+        if (matchedThreadIndex >= 0) {
+            searchIndex = matchedThreadIndex + 1;
+            lastMatchedThreadIndex = matchedThreadIndex;
+            continue;
+        }
+        if (!isCodexRolloutSpawnAgentToolCall(rolloutItem)) {
+            continue;
+        }
+        if (rolloutItem.callId && existingSpawnCallIds.has(rolloutItem.callId)) {
+            continue;
+        }
+        if (rolloutItem.callId && queuedSpawnCallIds.has(rolloutItem.callId)) {
+            continue;
+        }
+        if (rolloutItem.callId) {
+            queuedSpawnCallIds.add(rolloutItem.callId);
+        }
+        const queue = insertionsByThreadIndex.get(lastMatchedThreadIndex) ?? [];
+        queue.push(rolloutItem);
+        insertionsByThreadIndex.set(lastMatchedThreadIndex, queue);
+    }
+    if (insertionsByThreadIndex.size === 0) {
+        return input.threadTimeline;
+    }
+    const merged = [];
+    const leadingInsertions = insertionsByThreadIndex.get(-1);
+    if (leadingInsertions) {
+        merged.push(...leadingInsertions);
+    }
+    for (const [index, item] of input.threadTimeline.entries()) {
+        merged.push(item);
+        const insertedAfter = insertionsByThreadIndex.get(index);
+        if (insertedAfter) {
+            merged.push(...insertedAfter);
+        }
+    }
+    return merged;
+}
 function toSandboxPolicy(type, networkAccess) {
     switch (type) {
         case "read-only":
@@ -1234,6 +1775,7 @@ const TurnStartedNotificationSchema = z.object({
 const TurnCompletedNotificationSchema = z.object({
     turn: z
         .object({
+        id: z.string().optional(),
         status: z.string(),
         error: z
             .object({
@@ -1282,6 +1824,10 @@ const CodexEventTurnAbortedNotificationSchema = z.object({
     msg: z
         .object({
         type: z.literal("turn_aborted"),
+        turn_id: z.string().optional(),
+        turnId: z.string().optional(),
+        thread_id: z.string().optional(),
+        threadId: z.string().optional(),
         reason: z.string().optional(),
     })
         .passthrough(),
@@ -1290,6 +1836,12 @@ const CodexEventTaskCompleteNotificationSchema = z.object({
     msg: z
         .object({
         type: z.literal("task_complete"),
+        turn_id: z.string().optional(),
+        turnId: z.string().optional(),
+        thread_id: z.string().optional(),
+        threadId: z.string().optional(),
+        last_agent_message: z.string().nullable().optional(),
+        lastAgentMessage: z.string().nullable().optional(),
     })
         .passthrough(),
 }).passthrough();
@@ -1383,12 +1935,19 @@ const CodexEventTurnDiffNotificationSchema = z.object({
 const CodexNotificationSchema = z.union([
     z.object({ method: z.literal("thread/started"), params: ThreadStartedNotificationSchema }).transform(({ params }) => ({ kind: "thread_started", threadId: params.thread.id })),
     z.object({ method: z.literal("thread/started"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", 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",
+        ...readCodexNotificationProvenance(params),
+        turnId: params.turn.id,
+    })),
     z.object({ method: z.literal("turn/started"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({ method: z.literal("turn/completed"), params: TurnCompletedNotificationSchema }).transform(({ params }) => ({
         kind: "turn_completed",
         status: params.turn.status,
         errorMessage: params.turn.error?.message ?? null,
+        turnId: params.turn.id ?? null,
+        threadId: readCodexNotificationProvenance(params).threadId,
+        lastAgentMessage: null,
     })),
     z.object({ method: z.literal("turn/completed"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({ method: z.literal("turn/plan/updated"), params: TurnPlanUpdatedNotificationSchema }).transform(({ params }) => ({
@@ -1403,6 +1962,7 @@ const CodexNotificationSchema = z.union([
         kind: "plan_delta",
         itemId: params.itemId,
         delta: params.delta,
+        ...readCodexNotificationProvenance(params),
     })),
     z.object({ method: z.literal("item/plan/delta"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({ method: z.literal("turn/diff/updated"), params: TurnDiffUpdatedNotificationSchema }).transform(({ params }) => ({ kind: "diff_updated", diff: params.diff })),
@@ -1424,6 +1984,7 @@ const CodexNotificationSchema = z.union([
         kind: "agent_message_delta",
         itemId: params.itemId,
         delta: params.delta,
+        ...readCodexNotificationProvenance(params),
     })),
     z.object({ method: z.literal("item/agentMessage/delta"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1433,11 +1994,22 @@ const CodexNotificationSchema = z.union([
         kind: "reasoning_delta",
         itemId: params.itemId,
         delta: params.delta,
+        ...readCodexNotificationProvenance(params),
     })),
     z.object({ method: z.literal("item/reasoning/summaryTextDelta"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
-    z.object({ method: z.literal("item/completed"), params: ItemLifecycleNotificationSchema }).transform(({ params }) => ({ kind: "item_completed", source: "item", item: params.item })),
+    z.object({ method: z.literal("item/completed"), params: ItemLifecycleNotificationSchema }).transform(({ params }) => ({
+        kind: "item_completed",
+        source: "item",
+        item: params.item,
+        ...readCodexNotificationProvenance(params),
+    })),
     z.object({ method: z.literal("item/completed"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
-    z.object({ method: z.literal("item/started"), params: ItemLifecycleNotificationSchema }).transform(({ params }) => ({ kind: "item_started", source: "item", item: params.item })),
+    z.object({ method: z.literal("item/started"), params: ItemLifecycleNotificationSchema }).transform(({ params }) => ({
+        kind: "item_started",
+        source: "item",
+        item: params.item,
+        ...readCodexNotificationProvenance(params),
+    })),
     z.object({ method: z.literal("item/started"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
         method: z.literal("codex/event/item_started"),
@@ -1446,6 +2018,7 @@ const CodexNotificationSchema = z.union([
         kind: "item_started",
         source: "codex_event",
         item: params.msg.item,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({ method: z.literal("codex/event/item_started"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1455,6 +2028,7 @@ const CodexNotificationSchema = z.union([
         kind: "item_completed",
         source: "codex_event",
         item: params.msg.item,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({ method: z.literal("codex/event/item_completed"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1465,6 +2039,7 @@ const CodexNotificationSchema = z.union([
         callId: params.msg.call_id ?? null,
         command: params.msg.command ?? null,
         cwd: params.msg.cwd ?? null,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({ method: z.literal("codex/event/exec_command_begin"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1483,6 +2058,7 @@ const CodexNotificationSchema = z.union([
         exitCode: params.msg.exit_code ?? params.msg.exitCode ?? null,
         success: params.msg.success ?? null,
         stderr: params.msg.stderr ?? null,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({ method: z.literal("codex/event/exec_command_end"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1493,6 +2069,7 @@ const CodexNotificationSchema = z.union([
         callId: params.msg.call_id ?? null,
         stream: params.msg.stream ?? null,
         chunk: params.msg.chunk ?? params.msg.delta ?? null,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({
         method: z.literal("codex/event/exec_command_output_delta"),
@@ -1505,6 +2082,7 @@ const CodexNotificationSchema = z.union([
         kind: "patch_apply_started",
         callId: params.msg.call_id ?? null,
         changes: params.msg.changes ?? null,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({ method: z.literal("codex/event/patch_apply_begin"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1517,6 +2095,7 @@ const CodexNotificationSchema = z.union([
         stdout: params.msg.stdout ?? null,
         stderr: params.msg.stderr ?? null,
         success: params.msg.success ?? null,
+        ...readCodexNotificationProvenance(params.msg),
     })),
     z.object({ method: z.literal("codex/event/patch_apply_end"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1526,6 +2105,7 @@ const CodexNotificationSchema = z.union([
         kind: "file_change_output_delta",
         itemId: params.itemId,
         delta: params.delta ?? params.chunk ?? null,
+        ...readCodexNotificationProvenance(params),
     })),
     z.object({ method: z.literal("item/fileChange/outputDelta"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
@@ -1539,19 +2119,25 @@ const CodexNotificationSchema = z.union([
     z.object({
         method: z.literal("codex/event/turn_aborted"),
         params: CodexEventTurnAbortedNotificationSchema,
-    }).transform(() => ({
+    }).transform(({ params }) => ({
         kind: "turn_completed",
         status: "interrupted",
         errorMessage: null,
+        turnId: params.msg.turn_id ?? params.msg.turnId ?? null,
+        threadId: params.msg.thread_id ?? params.msg.threadId ?? null,
+        lastAgentMessage: null,
     })),
     z.object({ method: z.literal("codex/event/turn_aborted"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
         method: z.literal("codex/event/task_complete"),
         params: CodexEventTaskCompleteNotificationSchema,
-    }).transform(() => ({
+    }).transform(({ params }) => ({
         kind: "turn_completed",
         status: "completed",
         errorMessage: null,
+        turnId: params.msg.turn_id ?? params.msg.turnId ?? null,
+        threadId: params.msg.thread_id ?? params.msg.threadId ?? null,
+        lastAgentMessage: params.msg.last_agent_message ?? params.msg.lastAgentMessage ?? null,
     })),
     z.object({ method: z.literal("codex/event/task_complete"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({ method: z.string(), params: z.unknown() }).transform(({ method, params }) => ({ kind: "unknown_method", method, params })),
@@ -1620,10 +2206,15 @@ export const __codexAppServerInternals = {
     shouldRetryInitializeWithoutExperimentalApi,
     shouldRetryTurnStartWithoutCollaborationMode,
     isCodexAppServerUnsupportedMethodError,
+    parseCodexThreadListAllowedSourceKinds,
+    resolveCodexThreadListRetrySourceKinds,
     readCodexConfiguredDefaults,
+    parseCodexPersistedThreadMetadata,
+    readCodexPersistedThreadMetadataFromRolloutPath,
     formatProposedPlanBlock,
     formatProposedPlanChunk,
     buildCompletedCodexTimelineItem,
+    mergeCodexThreadReadTimelineWithRolloutSpawnCalls,
     normalizeCodexQuestionDescriptors,
     parseUpdatedQuestionAnswers,
     buildCodexPermissionsResponse,
@@ -1637,6 +2228,20 @@ export const __codexAppServerInternals = {
         "mcpServer/elicitation/request",
     ],
 };
+function normalizeToolCallNameForFallback(name) {
+    return name.trim().replace(/[.\s-]+/g, "_").toLowerCase();
+}
+function isShellLikeToolCall(item) {
+    const normalizedName = normalizeToolCallNameForFallback(item.name);
+    return (item.detail.type === "shell" ||
+        normalizedName === "shell" ||
+        normalizedName === "bash");
+}
+function isSpawnAgentToolCall(item) {
+    return normalizeToolCallNameForFallback(item.name).endsWith("spawn_agent");
+}
+const COMPATIBILITY_FAILED_TOOL_STATUSES = new Set(["failed", "error"]);
+const COMPATIBILITY_CANCELED_TOOL_STATUSES = new Set(["canceled", "cancelled", "interrupted"]);
 class CodexAppServerAgentSession {
     constructor(config, resumeHandle, logger, spawnAppServer) {
         this.resumeHandle = resumeHandle;
@@ -1659,6 +2264,7 @@ class CodexAppServerAgentSession {
         this.pendingFileChangeOutputDeltas = new Map();
         this.emittedExecCommandStartedCallIds = new Set();
         this.emittedExecCommandCompletedCallIds = new Set();
+        this.emittedRolloutSpawnAgentCallIds = new Set();
         this.emittedItemStartedIds = new Set();
         this.emittedItemCompletedIds = new Set();
         this.warnedUnknownNotificationMethods = new Set();
@@ -1670,6 +2276,7 @@ class CodexAppServerAgentSession {
         this.cachedSkills = [];
         this.turnCompletionInFlight = false;
         this.deferredTurnCompletion = null;
+        this.rolloutSpawnPollTimer = null;
         this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
         if (config.modeId === undefined) {
             throw new Error("Codex agent requires modeId to be specified");
@@ -1802,24 +2409,26 @@ class CodexAppServerAgentSession {
                 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 rawTurns = thread?.turns ?? [];
+            for (const turn of rawTurns) {
+                const items = Array.isArray(turn.items) ? turn.items : [];
+                for (const item of items) {
+                    const timelineItem = threadItemToTimeline(item, {
+                        cwd: this.config.cwd ?? null,
+                    });
+                    if (timelineItem?.type === "tool_call") {
+                        this.warnOnIncompleteEditToolCall(timelineItem, "thread_read", item);
                     }
                 }
             }
-            const timeline = rolloutTimeline.length > 0 ? rolloutTimeline : threadTimeline;
+            const threadTimeline = readCodexThreadTimelineFromTurns(rawTurns, {
+                cwd: this.config.cwd ?? null,
+            });
+            const timeline = mergeCodexThreadReadTimelineWithRolloutSpawnCalls({
+                threadTimeline,
+                rolloutTimeline,
+            });
+            this.seedRolloutSpawnAgentCallIds(timeline);
             if (timeline.length > 0) {
                 this.persistedHistory = timeline;
                 this.historyPending = true;
@@ -2489,6 +3098,10 @@ class CodexAppServerAgentSession {
     }
     clearTurnState() {
         this.clearDeferredTurnCompletion();
+        if (this.rolloutSpawnPollTimer) {
+            clearTimeout(this.rolloutSpawnPollTimer);
+            this.rolloutSpawnPollTimer = null;
+        }
         this.currentTurnId = null;
         this.emittedItemStartedIds.clear();
         this.emittedItemCompletedIds.clear();
@@ -2507,6 +3120,128 @@ class CodexAppServerAgentSession {
             this.pendingReasoning.size > 0 ||
             this.pendingPlanTexts.size > 0);
     }
+    emitRolloutSpawnAgentCallsFromTimeline(rolloutTimeline) {
+        let emitted = 0;
+        for (const item of rolloutTimeline) {
+            if (item.type !== "tool_call" || !item.callId) {
+                continue;
+            }
+            if (isSpawnAgentToolCall(item)) {
+                if (this.emittedRolloutSpawnAgentCallIds.has(item.callId)) {
+                    continue;
+                }
+                this.emittedRolloutSpawnAgentCallIds.add(item.callId);
+                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item });
+                emitted += 1;
+                continue;
+            }
+            if (this.hasAlreadyEmittedFallbackToolCall(item)) {
+                continue;
+            }
+            this.markFallbackToolCallEmitted(item);
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item });
+            emitted += 1;
+        }
+        return emitted;
+    }
+    seedRolloutSpawnAgentCallIds(timeline) {
+        for (const item of timeline) {
+            if (item.type === "tool_call" && isSpawnAgentToolCall(item) && item.callId) {
+                this.emittedRolloutSpawnAgentCallIds.add(item.callId);
+            }
+        }
+    }
+    hasAlreadyEmittedFallbackToolCall(item) {
+        if (!item.callId) {
+            return false;
+        }
+        if (isShellLikeToolCall(item)) {
+            if (item.status === "running") {
+                return (this.emittedExecCommandStartedCallIds.has(item.callId) ||
+                    this.emittedExecCommandCompletedCallIds.has(item.callId));
+            }
+            return this.emittedExecCommandCompletedCallIds.has(item.callId);
+        }
+        if (item.status === "running") {
+            return (this.emittedItemStartedIds.has(item.callId) ||
+                this.emittedItemCompletedIds.has(item.callId));
+        }
+        return this.emittedItemCompletedIds.has(item.callId);
+    }
+    markFallbackToolCallEmitted(item) {
+        if (!item.callId) {
+            return;
+        }
+        if (isShellLikeToolCall(item)) {
+            if (item.status === "running") {
+                this.emittedExecCommandStartedCallIds.add(item.callId);
+            }
+            else {
+                this.emittedExecCommandCompletedCallIds.add(item.callId);
+                this.emittedExecCommandStartedCallIds.delete(item.callId);
+            }
+            return;
+        }
+        if (item.status === "running") {
+            this.emittedItemStartedIds.add(item.callId);
+            return;
+        }
+        this.emittedItemCompletedIds.add(item.callId);
+        this.emittedItemStartedIds.delete(item.callId);
+    }
+    hasForeignNotificationProvenance(input) {
+        return ((input.threadId !== null &&
+            this.currentThreadId !== null &&
+            input.threadId !== this.currentThreadId) ||
+            (input.turnId !== null &&
+                this.currentTurnId !== null &&
+                input.turnId !== this.currentTurnId));
+    }
+    async emitNewRolloutSpawnAgentCalls() {
+        if (!this.currentThreadId) {
+            return 0;
+        }
+        let rolloutTimeline;
+        try {
+            rolloutTimeline = await loadCodexPersistedTimeline(this.currentThreadId, undefined, this.logger);
+        }
+        catch (error) {
+            this.logger.trace({ error, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Failed to load Codex rollout timeline while reconciling spawn_agent calls");
+            return 0;
+        }
+        return this.emitRolloutSpawnAgentCallsFromTimeline(rolloutTimeline);
+    }
+    scheduleRolloutSpawnAgentPoll() {
+        if (!this.currentThreadId || !this.currentTurnId || this.rolloutSpawnPollTimer) {
+            return;
+        }
+        this.rolloutSpawnPollTimer = setTimeout(() => {
+            this.rolloutSpawnPollTimer = null;
+            void this.pollRolloutSpawnAgentCalls();
+        }, CODEX_ROLLOUT_SPAWN_POLL_MS);
+    }
+    async pollRolloutSpawnAgentCalls() {
+        if (!this.currentThreadId || !this.currentTurnId) {
+            return;
+        }
+        await this.emitNewRolloutSpawnAgentCalls();
+        if (this.currentThreadId && this.currentTurnId) {
+            this.scheduleRolloutSpawnAgentPoll();
+        }
+    }
+    async primeRolloutSpawnAgentPolling() {
+        if (!this.currentThreadId || !this.currentTurnId) {
+            return;
+        }
+        try {
+            const rolloutTimeline = await loadCodexPersistedTimeline(this.currentThreadId, undefined, this.logger);
+            this.emitRolloutSpawnAgentCallsFromTimeline(rolloutTimeline);
+        }
+        catch (error) {
+            this.logger.trace({ error, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Failed to prime Codex rollout spawn_agent polling");
+        }
+        this.scheduleRolloutSpawnAgentPoll();
+    }
     emitCompletedThreadItem(item, source) {
         const timelineItem = buildCompletedCodexTimelineItem(item, {
             cwd: this.config.cwd ?? null,
@@ -2533,6 +3268,67 @@ class CodexAppServerAgentSession {
         }
         return true;
     }
+    emitCompatibilityLifecycleNotifications(parsed) {
+        if (parsed.source !== "item" || !this.client) {
+            return;
+        }
+        const itemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
+        const lifecycleMethod = parsed.kind === "item_started"
+            ? "codex/event/item_started"
+            : "codex/event/item_completed";
+        if (itemType === "agentMessage" ||
+            itemType === "reasoning" ||
+            itemType === "plan") {
+            this.client.dispatchNotification(lifecycleMethod, {
+                msg: {
+                    type: parsed.kind,
+                    item: parsed.item,
+                    ...(parsed.threadId ? { threadId: parsed.threadId } : {}),
+                    ...(parsed.turnId ? { turnId: parsed.turnId } : {}),
+                },
+            });
+        }
+        if (itemType !== "commandExecution") {
+            return;
+        }
+        if (parsed.kind === "item_started") {
+            this.client.dispatchNotification("codex/event/exec_command_begin", {
+                msg: {
+                    type: "exec_command_begin",
+                    call_id: parsed.item.id ?? null,
+                    command: parsed.item.command ?? null,
+                    cwd: parsed.item.cwd ?? null,
+                    ...(parsed.threadId ? { threadId: parsed.threadId } : {}),
+                    ...(parsed.turnId ? { turnId: parsed.turnId } : {}),
+                },
+            });
+            return;
+        }
+        const exitCode = typeof parsed.item.exitCode === "number" ? parsed.item.exitCode : null;
+        const status = typeof parsed.item.status === "string" ? parsed.item.status.trim().toLowerCase() : "";
+        const success = typeof parsed.item.success === "boolean"
+            ? parsed.item.success
+            : status.length > 0
+                ? !COMPATIBILITY_FAILED_TOOL_STATUSES.has(status) &&
+                    !COMPATIBILITY_CANCELED_TOOL_STATUSES.has(status)
+                : exitCode === null || exitCode === 0;
+        this.client.dispatchNotification("codex/event/exec_command_end", {
+            msg: {
+                type: "exec_command_end",
+                call_id: parsed.item.id ?? null,
+                command: parsed.item.command ?? null,
+                cwd: parsed.item.cwd ?? null,
+                aggregated_output: typeof parsed.item.aggregatedOutput === "string"
+                    ? parsed.item.aggregatedOutput
+                    : null,
+                exit_code: exitCode,
+                success,
+                stderr: typeof parsed.item.stderr === "string" ? parsed.item.stderr : null,
+                ...(parsed.threadId ? { threadId: parsed.threadId } : {}),
+                ...(parsed.turnId ? { turnId: parsed.turnId } : {}),
+            },
+        });
+    }
     async reconcileTurnCompletionFromThreadRead() {
         if (!this.client || !this.currentThreadId) {
             return 0;
@@ -2620,6 +3416,15 @@ class CodexAppServerAgentSession {
     async finalizeTurnCompletion(parsed) {
         let terminalEventEmitted = false;
         try {
+            if (parsed.status === "completed") {
+                try {
+                    const emittedSpawnCalls = await this.emitNewRolloutSpawnAgentCalls();
+                    this.logger.trace({ emittedSpawnCalls, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Reconciled Codex spawn_agent rollout calls before turn completion");
+                }
+                catch (error) {
+                    this.logger.warn({ error, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Failed to reconcile Codex spawn_agent rollout calls before turn completion");
+                }
+            }
             if (parsed.status === "completed" && this.hasPendingBufferedCompletionContent()) {
                 this.logger.trace({
                     pendingAgentMessages: this.pendingAgentMessages.size,
@@ -2655,17 +3460,57 @@ class CodexAppServerAgentSession {
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
         if (parsed.kind === "thread_started") {
+            if (this.currentThreadId && this.currentThreadId !== parsed.threadId) {
+                this.logger.trace({
+                    currentThreadId: this.currentThreadId,
+                    ignoredThreadId: parsed.threadId,
+                    turnId: this.currentTurnId,
+                }, "Ignoring Codex thread_started for a different thread while session is already bound");
+                return;
+            }
             this.currentThreadId = parsed.threadId;
             this.emitEvent({ type: "thread_started", provider: CODEX_PROVIDER, sessionId: parsed.threadId });
             return;
         }
         if (parsed.kind === "turn_started") {
+            if (parsed.threadId && this.currentThreadId && parsed.threadId !== this.currentThreadId) {
+                this.logger.trace({
+                    currentThreadId: this.currentThreadId,
+                    ignoredThreadId: parsed.threadId,
+                    currentTurnId: this.currentTurnId,
+                    ignoredTurnId: parsed.turnId,
+                }, "Ignoring Codex turn_started for a different thread");
+                return;
+            }
+            if (this.currentTurnId && this.currentTurnId !== parsed.turnId) {
+                if (this.deferredTurnCompletion) {
+                    this.discardDeferredTurnCompletion("turn_started");
+                }
+            }
             this.clearTurnState();
             this.currentTurnId = parsed.turnId;
             this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
+            void this.primeRolloutSpawnAgentPolling();
             return;
         }
         if (parsed.kind === "turn_completed") {
+            if (parsed.threadId && this.currentThreadId && parsed.threadId !== this.currentThreadId) {
+                this.logger.trace({
+                    currentThreadId: this.currentThreadId,
+                    ignoredThreadId: parsed.threadId,
+                    turnId: parsed.turnId,
+                    currentTurnId: this.currentTurnId,
+                }, "Ignoring Codex terminal event for a different thread");
+                return;
+            }
+            if (parsed.turnId && this.currentTurnId && parsed.turnId !== this.currentTurnId) {
+                this.logger.trace({
+                    currentTurnId: this.currentTurnId,
+                    ignoredTurnId: parsed.turnId,
+                    threadId: this.currentThreadId,
+                }, "Ignoring Codex terminal event for a different turn");
+                return;
+            }
             // A later failed/interrupted terminal status must replace a deferred
             // "completed" status so we do not hide a real terminal error behind
             // the settle window.
@@ -2704,6 +3549,9 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "plan_delta") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("plan_delta");
             const previous = this.pendingPlanTexts.get(parsed.itemId) ?? "";
             const next = previous + parsed.delta;
@@ -2746,12 +3594,18 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "agent_message_delta") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("agent_message_delta");
             const prev = this.pendingAgentMessages.get(parsed.itemId) ?? "";
             this.pendingAgentMessages.set(parsed.itemId, prev + parsed.delta);
             return;
         }
         if (parsed.kind === "reasoning_delta") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("reasoning_delta");
             const prev = this.pendingReasoning.get(parsed.itemId) ?? [];
             prev.push(parsed.delta);
@@ -2759,17 +3613,29 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "exec_command_output_delta") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("exec_command_output_delta");
             this.appendOutputDeltaChunk(this.pendingCommandOutputDeltas, parsed.callId, parsed.chunk, { decodeBase64: true });
             return;
         }
         if (parsed.kind === "file_change_output_delta") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("file_change_output_delta");
             this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
             return;
         }
         if (parsed.kind === "exec_command_started") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("exec_command_started");
+            if (parsed.callId && this.emittedExecCommandStartedCallIds.has(parsed.callId)) {
+                return;
+            }
             if (parsed.callId) {
                 this.emittedExecCommandStartedCallIds.add(parsed.callId);
                 this.pendingCommandOutputDeltas.delete(parsed.callId);
@@ -2786,7 +3652,13 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "exec_command_completed") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("exec_command_completed");
+            if (parsed.callId && this.emittedExecCommandCompletedCallIds.has(parsed.callId)) {
+                return;
+            }
             const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
             const timelineItem = mapCodexExecNotificationToToolCall({
                 callId: parsed.callId,
@@ -2805,6 +3677,9 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "patch_apply_started") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("patch_apply_started");
             if (parsed.callId) {
                 this.pendingFileChangeOutputDeltas.delete(parsed.callId);
@@ -2825,6 +3700,9 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "patch_apply_completed") {
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("patch_apply_completed");
             const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
             const timelineItem = mapCodexPatchNotificationToToolCall({
@@ -2847,6 +3725,10 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "item_completed") {
+            this.emitCompatibilityLifecycleNotifications(parsed);
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("item_completed");
             // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
             // and canonical `item/*`. We render only the canonical channel to avoid
@@ -2858,6 +3740,11 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "item_started") {
+            this.emitCompatibilityLifecycleNotifications(parsed);
+            const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
+            if (this.hasForeignNotificationProvenance(parsed)) {
+                return;
+            }
             this.noteTurnActivityAfterPermission("item_started");
             if (parsed.source === "codex_event") {
                 return;
@@ -2867,7 +3754,6 @@ class CodexAppServerAgentSession {
                 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;
@@ -3226,43 +4112,61 @@ export class CodexAppServerAgentClient {
             });
             client.notify("initialized", {});
             const limit = options?.limit ?? 20;
-            const response = (await client.request("thread/list", { limit }));
+            const includeTimeline = options?.includeTimeline !== false;
+            const response = await requestCodexThreadList({
+                client,
+                logger: this.logger,
+                limit,
+                sourceKinds: CODEX_THREAD_LIST_SOURCE_KINDS,
+            });
             const threads = Array.isArray(response?.data) ? response.data : [];
-            const descriptors = [];
+            const descriptorsBySessionId = new Map();
+            const threadListSessionIds = new Set();
             for (const thread of threads.slice(0, limit)) {
-                const threadId = thread.id;
-                const cwd = thread.cwd ?? process.cwd();
-                const title = thread.preview ?? null;
-                let timeline = [];
-                try {
-                    const rolloutTimeline = await loadCodexPersistedTimeline(threadId, undefined, this.logger);
-                    const read = (await 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);
-                        }
+                const threadRecord = toRecord(thread);
+                const rolloutPath = readStringField(threadRecord, ["path"]);
+                let metadata = parseCodexPersistedThreadMetadata(thread);
+                if (rolloutPath) {
+                    const rolloutMetadata = await readCodexPersistedThreadMetadataFromRolloutPath(rolloutPath, this.logger);
+                    if (rolloutMetadata) {
+                        metadata = mergeCodexPersistedThreadMetadata(metadata, rolloutMetadata);
                     }
-                    timeline =
-                        rolloutTimeline.length > 0
-                            ? rolloutTimeline
-                            : itemsFromThreadRead;
                 }
-                catch {
-                    timeline = [];
+                const threadId = metadata.threadId;
+                if (!threadId) {
+                    continue;
                 }
-                descriptors.push({
+                threadListSessionIds.add(threadId);
+                const cwd = metadata.cwd ?? process.cwd();
+                const title = metadata.title;
+                const createdAt = metadata.createdAt;
+                const updatedAt = metadata.updatedAt;
+                let timeline = [];
+                if (includeTimeline) {
+                    try {
+                        const rolloutTimeline = await loadCodexPersistedTimeline(threadId, undefined, this.logger);
+                        const read = (await client.request("thread/read", {
+                            threadId,
+                            includeTurns: true,
+                        }));
+                        const turns = read.thread?.turns ?? [];
+                        const itemsFromThreadRead = readCodexThreadTimelineFromTurns(turns, { cwd });
+                        timeline = mergeCodexThreadReadTimelineWithRolloutSpawnCalls({
+                            threadTimeline: itemsFromThreadRead,
+                            rolloutTimeline,
+                        });
+                    }
+                    catch {
+                        timeline = [];
+                    }
+                }
+                descriptorsBySessionId.set(threadId, {
                     provider: CODEX_PROVIDER,
                     sessionId: threadId,
                     cwd,
                     title,
-                    lastActivityAt: new Date((thread.updatedAt ?? thread.createdAt ?? 0) * 1000),
+                    createdAt,
+                    lastActivityAt: updatedAt,
                     persistence: {
                         provider: CODEX_PROVIDER,
                         sessionId: threadId,
@@ -3275,9 +4179,77 @@ export class CodexAppServerAgentClient {
                         },
                     },
                     timeline,
+                    model: metadata.model,
+                    parentSessionId: metadata.parentSessionId,
+                    rootSessionId: metadata.rootSessionId,
+                    agentId: metadata.agentId,
+                    agentNickname: metadata.agentNickname,
+                    agentRole: metadata.agentRole,
                 });
             }
-            return descriptors;
+            const sessionRoot = resolveCodexSessionRoot();
+            const rolloutPaths = await listCodexRolloutPaths(sessionRoot);
+            const rolloutPathBySessionId = new Map();
+            for (const rolloutPath of rolloutPaths) {
+                const descriptor = await buildCodexPersistedDescriptorFromRolloutPath({
+                    rolloutPath,
+                    includeTimeline: false,
+                    logger: this.logger,
+                });
+                if (!descriptor) {
+                    continue;
+                }
+                rolloutPathBySessionId.set(descriptor.sessionId, rolloutPath);
+                if (!descriptorsBySessionId.has(descriptor.sessionId)) {
+                    if (!includeTimeline && !descriptor.parentSessionId) {
+                        continue;
+                    }
+                    descriptorsBySessionId.set(descriptor.sessionId, descriptor);
+                }
+            }
+            const descriptors = Array.from(descriptorsBySessionId.values())
+                .sort((left, right) => right.lastActivityAt.getTime() - left.lastActivityAt.getTime())
+                .slice(0, limit);
+            if (!includeTimeline) {
+                return descriptors;
+            }
+            return await Promise.all(descriptors.map(async (descriptor) => {
+                if (threadListSessionIds.has(descriptor.sessionId)) {
+                    return descriptor;
+                }
+                const rolloutPath = rolloutPathBySessionId.get(descriptor.sessionId);
+                if (!rolloutPath) {
+                    return descriptor;
+                }
+                return ((await buildCodexPersistedDescriptorFromRolloutPath({
+                    rolloutPath,
+                    includeTimeline: true,
+                    logger: this.logger,
+                })) ?? descriptor);
+            }));
+        }
+        finally {
+            await client.dispose();
+        }
+    }
+    async readPersistedAgent(options) {
+        const sessionId = options.sessionId.trim();
+        if (!sessionId) {
+            return null;
+        }
+        const child = this.spawnAppServer();
+        const client = new CodexAppServerClient(child, this.logger);
+        try {
+            await client.request("initialize", {
+                clientInfo: { name: "junction", title: "Junction", version: "0.0.0" },
+            });
+            client.notify("initialized", {});
+            return await readCodexPersistedDescriptorBySessionId({
+                client,
+                sessionId,
+                includeTimeline: options.includeTimeline !== false,
+                logger: this.logger,
+            });
         }
         finally {
             await client.dispose();