@jingyi0605/codingns 0.3.6 → 0.5.0

package/node_modules/@codingns/session-sync-core/dist/providers/codex.js

@@ -1,11 +1,13 @@
 import { basename, dirname, join } from "node:path";
-import { existsSync, readFileSync, readdirSync, renameSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
 import crypto from "node:crypto";
-import { appendJsonLine, createRawRef, encodeCursor, ensureDirectory, extractTextBlocks, ensureText, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath, readFirstNonEmptyLine, readJsonLines, readTrailingJsonLines, safeDate, sliceHistory, stringifyStructuredValue, walkJsonlFiles } from "./utils.js";
+import { appendJsonLine, createRawRef, encodeCursor, ensureDirectory, extractTextBlocks, ensureText, messageIdFromRawRef, messageIdFromStableKey, nextTimestamp, normalizeWorkspacePath, readFirstNonEmptyLine, readJsonLines, readTrailingJsonLines, safeDate, sliceHistory, stringifyStructuredValue, walkJsonlFiles } from "./utils.js";
+import { buildCodexResumeHistoryFromRawStore } from "../codex-resume-history.js";
 import { loadDatabaseSync } from "../sqlite/node-sqlite.js";
 const CODEX_SESSION_TITLE_MAX_LENGTH = 48;
 const HISTORY_CACHE_LIMIT = 6;
 const SESSION_SUMMARY_CACHE_LIMIT = 512;
+const SPAWN_RELATION_SCAN_CACHE_LIMIT = 512;
 const RECENT_HISTORY_INITIAL_BYTES = 256 * 1024;
 const RECENT_HISTORY_MAX_BYTES = 4 * 1024 * 1024;
 const RECENT_HISTORY_BUFFER_MESSAGES = 24;
@@ -19,20 +21,32 @@ export class CodexAdapter {
     providerId = "codex";
     historyCache = new Map();
     sessionSummaryCache = new Map();
+    spawnRelationScanCache = new Map();
     threadMetadataIndexCache = null;
     constructor(options) {
         this.options = options;
     }
     async detectSessions(workspacePath, options) {
+        const discovery = await this.detectSessionsDetailed(workspacePath, options);
+        return discovery.sessions;
+    }
+    async detectSessionsDetailed(workspacePath, options) {
+        const startedAt = Date.now();
         const targetPath = normalizeWorkspacePath(workspacePath);
-        const files = this.listSessionFiles();
         const knownSessions = (options?.knownSessions ?? []).filter((session) => session.provider === this.providerId);
+        const threadMetadataIndex = this.readThreadMetadataIndex();
+        const files = this.listSessionFiles(targetPath, threadMetadataIndex, knownSessions);
         const knownByRawStoreRef = new Map(knownSessions.map((session) => [session.rawStoreRef, session]));
         const knownByProviderSessionId = new Map(knownSessions.map((session) => [session.providerSessionId, session]));
         const sessionsByProviderSessionId = new Map();
         const retainedSummaries = [];
         const pendingFiles = [];
+        let scannedFiles = 0;
+        let skippedByMtimeSize = 0;
+        let parsedFiles = 0;
+        let bytesRead = 0;
         for (const filePath of files) {
+            scannedFiles += 1;
             const stats = statSync(filePath);
             const cachedSummary = this.sessionSummaryCache.get(filePath);
             const fileSessionId = basename(filePath, ".jsonl");
@@ -47,6 +61,7 @@ export class CodexAdapter {
                 if (cachedSummary.summary
                     && hasUsableCodexTitle(cachedSummary.summary.title)
                     && normalizeWorkspacePath(cachedSummary.summary.workspacePath) === targetPath) {
+                    skippedByMtimeSize += 1;
                     retainedSummaries.push({
                         filePath,
                         stats,
@@ -67,6 +82,7 @@ export class CodexAdapter {
                 && hasUsableCodexTitle(knownByPath.title)
                 && (!sessionIdentity
                     || knownByPath.providerSessionId === sessionIdentity.threadId)) {
+                skippedByMtimeSize += 1;
                 if (normalizeWorkspacePath(knownByPath.workspacePath) === targetPath) {
                     retainedSummaries.push({
                         filePath,
@@ -81,6 +97,8 @@ export class CodexAdapter {
                     mtimeMs: stats.mtimeMs,
                     size: stats.size,
                     workspacePath: knownByPath.workspacePath,
+                    providerSessionId: knownByPath.providerSessionId,
+                    title: null,
                     summary: null
                 });
                 continue;
@@ -92,6 +110,8 @@ export class CodexAdapter {
                     mtimeMs: stats.mtimeMs,
                     size: stats.size,
                     workspacePath: sessionIdentity.cwd,
+                    providerSessionId: sessionIdentity.threadId,
+                    title: null,
                     summary: null
                 });
                 continue;
@@ -107,13 +127,33 @@ export class CodexAdapter {
             });
         }
         if (pendingFiles.length === 0 && retainedSummaries.length === 0) {
-            return [...sessionsByProviderSessionId.values()].sort((left, right) => (left.lastMessageAt ?? "").localeCompare(right.lastMessageAt ?? ""));
+            const sessions = [...sessionsByProviderSessionId.values()].sort((left, right) => (left.lastMessageAt ?? "").localeCompare(right.lastMessageAt ?? ""));
+            const diagnostic = {
+                provider: this.providerId,
+                status: "success",
+                durationMs: Date.now() - startedAt,
+                sessionCount: sessions.length,
+                isComplete: true,
+                errorMessage: null,
+                scannedFiles,
+                skippedByMtimeSize,
+                parsedFiles,
+                bytesRead
+            };
+            return {
+                sessions,
+                isComplete: true,
+                providerDiagnostics: [diagnostic]
+            };
         }
-        const threadMetadataIndex = this.readThreadMetadataIndex();
         const pendingThreadIds = new Set([...pendingFiles, ...retainedSummaries]
             .map((entry) => entry.sessionIdentity?.threadId ?? null)
             .filter((value) => value !== null));
-        const spawnedAgentRelationIndex = this.readSpawnedAgentRelationIndex([...pendingFiles, ...retainedSummaries].map((entry) => entry.filePath), targetPath, threadMetadataIndex, pendingThreadIds);
+        const spawnedAgentRelationIndex = this.readSpawnedAgentRelationIndex([...pendingFiles, ...retainedSummaries].map((entry) => ({
+            filePath: entry.filePath,
+            stats: entry.stats,
+            sessionIdentity: entry.sessionIdentity
+        })), targetPath, threadMetadataIndex, pendingThreadIds);
         for (const entry of retainedSummaries) {
             const currentThreadId = entry.sessionIdentity?.threadId ?? entry.summary.providerSessionId;
             const currentThreadMetadata = threadMetadataIndex.get(currentThreadId) ?? null;
@@ -127,21 +167,28 @@ export class CodexAdapter {
                 mtimeMs: entry.stats.mtimeMs,
                 size: entry.stats.size,
                 workspacePath: summary.workspacePath,
+                providerSessionId: summary.providerSessionId,
+                title: summary.title,
                 summary
             });
             sessionsByProviderSessionId.set(summary.providerSessionId, summary);
         }
         for (const entry of pendingFiles) {
             const { filePath, fileSessionId, stats, sessionIdentity } = entry;
+            parsedFiles += 1;
+            bytesRead += stats.size;
             const records = readJsonLines(filePath);
             const meta = records.find((record) => record.data.type === "session_meta")?.data;
             const metaPayload = (meta?.payload ?? {});
+            const codexSessionId = this.resolveCodexSessionId(metaPayload, fileSessionId);
             if (shouldIgnoreCodingNsDraftSession(metaPayload)) {
                 this.touchSessionSummaryCache(filePath, {
                     filePath,
                     mtimeMs: stats.mtimeMs,
                     size: stats.size,
                     workspacePath: null,
+                    providerSessionId: codexSessionId,
+                    title: null,
                     summary: null
                 });
                 continue;
@@ -155,11 +202,12 @@ export class CodexAdapter {
                     mtimeMs: stats.mtimeMs,
                     size: stats.size,
                     workspacePath: cachedWorkspacePath,
+                    providerSessionId: codexSessionId,
+                    title: null,
                     summary: null
                 });
                 continue;
             }
-            const codexSessionId = this.resolveCodexSessionId(metaPayload, fileSessionId);
             const currentThreadMetadata = threadMetadataIndex.get(codexSessionId) ??
                 (sessionIdentity ? threadMetadataIndex.get(sessionIdentity.threadId) : null);
             const currentSpawnRelation = spawnedAgentRelationIndex.get(codexSessionId) ??
@@ -178,6 +226,8 @@ export class CodexAdapter {
                     mtimeMs: stats.mtimeMs,
                     size: stats.size,
                     workspacePath: sessionWorkspacePath,
+                    providerSessionId: summary.providerSessionId,
+                    title: summary.title,
                     summary
                 });
                 sessionsByProviderSessionId.set(codexSessionId, summary);
@@ -204,10 +254,29 @@ export class CodexAdapter {
                 mtimeMs: stats.mtimeMs,
                 size: stats.size,
                 workspacePath: sessionWorkspacePath,
+                providerSessionId: summary.providerSessionId,
+                title: summary.title,
                 summary
             });
         }
-        return [...sessionsByProviderSessionId.values()].sort((left, right) => (left.lastMessageAt ?? "").localeCompare(right.lastMessageAt ?? ""));
+        const sessions = [...sessionsByProviderSessionId.values()].sort((left, right) => (left.lastMessageAt ?? "").localeCompare(right.lastMessageAt ?? ""));
+        const diagnostic = {
+            provider: this.providerId,
+            status: "success",
+            durationMs: Date.now() - startedAt,
+            sessionCount: sessions.length,
+            isComplete: true,
+            errorMessage: null,
+            scannedFiles,
+            skippedByMtimeSize,
+            parsedFiles,
+            bytesRead
+        };
+        return {
+            sessions,
+            isComplete: true,
+            providerDiagnostics: [diagnostic]
+        };
     }
     async readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
         const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
@@ -345,7 +414,7 @@ export class CodexAdapter {
         try {
             await transport.initialize();
             if (options.sourceType === "session") {
-                const forked = await transport.forkThread(providerSessionId);
+                const forked = await this.forkThreadWithHistoryFallback(transport, providerSessionId, workspacePath, options.rawStoreRef);
                 return await this.buildForkResultFromTransport({
                     providerSessionId: forked.providerSessionId,
                     rawStoreRef: forked.rawStoreRef,
@@ -439,20 +508,50 @@ export class CodexAdapter {
     }
     async readSessionTitle(providerSessionId, rawStoreRef) {
         const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        const records = readJsonLines(resolvedStoreRef);
         const fileSessionId = basename(resolvedStoreRef, ".jsonl");
-        const meta = records.find((record) => record.data.type === "session_meta")?.data;
-        const metaPayload = (meta?.payload ?? {});
         const sessionIdentity = this.readSessionIdentity(resolvedStoreRef, fileSessionId);
-        const codexSessionId = this.resolveCodexSessionId(metaPayload, providerSessionId || fileSessionId);
         const threadMetadataIndex = this.readThreadMetadataIndex();
-        const messages = this.parseMessagesFromEntries(resolvedStoreRef, records, codexSessionId);
-        return (this.resolveIndexedTitle(threadMetadataIndex, codexSessionId) ??
+        const indexedTitle = this.resolveIndexedTitle(threadMetadataIndex, providerSessionId) ??
             (sessionIdentity
                 ? this.resolveIndexedTitle(threadMetadataIndex, sessionIdentity.threadId)
-                : null) ??
+                : null);
+        if (indexedTitle) {
+            return indexedTitle;
+        }
+        const stats = statSync(resolvedStoreRef);
+        const cachedSummary = this.sessionSummaryCache.get(resolvedStoreRef);
+        if (cachedSummary
+            && cachedSummary.mtimeMs === stats.mtimeMs
+            && cachedSummary.size === stats.size
+            && (cachedSummary.providerSessionId === providerSessionId
+                || (sessionIdentity
+                    && cachedSummary.providerSessionId === sessionIdentity.threadId))) {
+            this.touchSessionSummaryCache(resolvedStoreRef, cachedSummary);
+            if (cachedSummary.title) {
+                return cachedSummary.title;
+            }
+            if (cachedSummary.summary) {
+                return cachedSummary.summary.title;
+            }
+        }
+        const records = readJsonLines(resolvedStoreRef);
+        const meta = records.find((record) => record.data.type === "session_meta")?.data;
+        const metaPayload = (meta?.payload ?? {});
+        const codexSessionId = this.resolveCodexSessionId(metaPayload, providerSessionId || fileSessionId);
+        const messages = this.parseMessagesFromEntries(resolvedStoreRef, records, codexSessionId);
+        const resolvedTitle = (this.resolveIndexedTitle(threadMetadataIndex, codexSessionId) ??
             resolveCodexFallbackTitle(messages) ??
             fileSessionId);
+        this.touchSessionSummaryCache(resolvedStoreRef, {
+            filePath: resolvedStoreRef,
+            mtimeMs: stats.mtimeMs,
+            size: stats.size,
+            workspacePath: (sessionIdentity?.cwd ?? ensureText(metaPayload.cwd)) || null,
+            providerSessionId: codexSessionId,
+            title: resolvedTitle,
+            summary: null
+        });
+        return resolvedTitle;
     }
     async renameSessionTitle(providerSessionId, rawStoreRef, title) {
         const nextTitle = title.trim();
@@ -485,33 +584,112 @@ export class CodexAdapter {
         const nextStoreRef = isArchived
             ? join(this.options.homeDir, "archived_sessions", currentFileName)
             : buildCodexActiveSessionPath(this.options.homeDir, currentFileName);
+        const controlResult = await this.updateArchiveStateViaThreadControlTransport(providerSessionId, resolvedStoreRef, nextStoreRef, isArchived);
+        let finalStoreRef = nextStoreRef;
+        if (controlResult) {
+            finalStoreRef = controlResult.rawStoreRef;
+        }
+        else {
+            const stateDbPath = findLatestCodexStateDatabase(this.options.homeDir);
+            statSync(resolvedStoreRef);
+            if (resolvedStoreRef !== nextStoreRef) {
+                ensureDirectory(dirname(nextStoreRef));
+                renameSync(resolvedStoreRef, nextStoreRef);
+            }
+            if (stateDbPath) {
+                const DatabaseSync = loadDatabaseSync();
+                let db = null;
+                try {
+                    db = new DatabaseSync(stateDbPath, { open: true });
+                    db.prepare(`UPDATE threads
+             SET archived = ?,
+                 archived_at = ?,
+                 rollout_path = ?
+             WHERE id = ?`).run(isArchived ? 1 : 0, isArchived ? Math.floor(Date.now() / 1000) : null, nextStoreRef, providerSessionId);
+                }
+                finally {
+                    db?.close();
+                }
+            }
+        }
+        this.sessionSummaryCache.delete(resolvedStoreRef);
+        this.sessionSummaryCache.delete(finalStoreRef);
+        // 归档切换后线程索引的 archived / rollout_path 也变了，不能继续赌文件系统 mtime 一定会跳。
+        this.invalidateThreadMetadataIndexCache();
+        return {
+            rawStoreRef: finalStoreRef,
+            isArchived
+        };
+    }
+    async deleteSession(providerSessionId, rawStoreRef) {
+        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
+        const threadMetadata = this.readThreadMetadataIndex().get(providerSessionId) ?? null;
+        const resolvedMetadataStoreRef = threadMetadata?.rolloutPath && threadMetadata.rolloutPath.trim()
+            ? this.resolveSessionFilePath(threadMetadata.rolloutPath, providerSessionId)
+            : null;
+        const candidateFilePaths = new Set([resolvedStoreRef, resolvedMetadataStoreRef].filter((value) => typeof value === "string" && value.trim().length > 0));
         const stateDbPath = findLatestCodexStateDatabase(this.options.homeDir);
-        statSync(resolvedStoreRef);
-        if (resolvedStoreRef !== nextStoreRef) {
-            ensureDirectory(dirname(nextStoreRef));
-            renameSync(resolvedStoreRef, nextStoreRef);
+        let deletedAny = false;
+        for (const filePath of candidateFilePaths) {
+            if (!existsSync(filePath)) {
+                continue;
+            }
+            rmSync(filePath, { force: true });
+            this.historyCache.delete(filePath);
+            this.sessionSummaryCache.delete(filePath);
+            deletedAny = true;
         }
         if (stateDbPath) {
             const DatabaseSync = loadDatabaseSync();
             let db = null;
             try {
                 db = new DatabaseSync(stateDbPath, { open: true });
-                db.prepare(`UPDATE threads
-           SET archived = ?,
-               archived_at = ?,
-               rollout_path = ?
-           WHERE id = ?`).run(isArchived ? 1 : 0, isArchived ? Math.floor(Date.now() / 1000) : null, nextStoreRef, providerSessionId);
+                const result = db.prepare("DELETE FROM threads WHERE id = ?").run(providerSessionId);
+                deletedAny = deletedAny || result.changes > 0;
             }
             finally {
                 db?.close();
             }
         }
-        this.sessionSummaryCache.delete(resolvedStoreRef);
-        this.sessionSummaryCache.delete(nextStoreRef);
-        return {
-            rawStoreRef: nextStoreRef,
-            isArchived
-        };
+        this.invalidateThreadMetadataIndexCache();
+        if (!deletedAny) {
+            throw new Error("PROVIDER_SESSION_NOT_FOUND");
+        }
+    }
+    async updateArchiveStateViaThreadControlTransport(providerSessionId, resolvedStoreRef, nextStoreRef, isArchived) {
+        const createTransport = this.options.threadControlTransportFactory;
+        if (!createTransport) {
+            return null;
+        }
+        const transport = createTransport();
+        try {
+            await transport.initialize();
+            if (isArchived) {
+                await transport.archiveThread(providerSessionId);
+            }
+            else {
+                await transport.unarchiveThread(providerSessionId);
+            }
+            const result = await transport.readThread(providerSessionId).catch(() => null);
+            const thread = result && typeof result === "object"
+                ? (result.thread ?? null)
+                : null;
+            const appServerRawStoreRef = ensureText(thread?.path).trim();
+            const resolvedNextStoreRef = appServerRawStoreRef.length > 0
+                ? this.resolveSessionFilePath(appServerRawStoreRef, providerSessionId)
+                : this.resolveSessionFilePath(nextStoreRef, providerSessionId);
+            this.sessionSummaryCache.delete(resolvedStoreRef);
+            this.sessionSummaryCache.delete(resolvedNextStoreRef);
+            return {
+                rawStoreRef: resolvedNextStoreRef
+            };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            transport.close();
+        }
     }
     getProviderCapabilities() {
         return {
@@ -519,7 +697,7 @@ export class CodexAdapter {
             canStartSession: true,
             canResumeSession: true,
             canSendMessage: true,
-            inRunInputMode: "none",
+            inRunInputMode: "streaming_guidance",
             supportsSubagents: true,
             supportsInterrupt: true,
             supportsStructuredToolCalls: true,
@@ -528,9 +706,10 @@ export class CodexAdapter {
             supportsPermissionPrompt: true,
             supportsCheckpoint: false,
             supportsSessionFork: true,
+            supportsSessionDelete: true,
             limitations: [
-                "Codex 产品原生支持将指导加入队列，但当前 SDK 0.116.0 仍未向宿主暴露运行中 queue/steer 提交入口。",
-                "当前实现只维护原生会话文件，不负责直接驱动 Codex CLI 进程执行。"
+                "运行中追加消息依赖 Codex CLI app-server 暴露 turn/steer；当前项目实测 codex-cli 0.118.0 可用。",
+                "当前 npm SDK 仍只有 run/runStreamed 轮询式接口，宿主运行时需经由 Codex CLI app-server 才能直发 steer。"
             ]
         };
     }
@@ -617,7 +796,8 @@ export class CodexAdapter {
                         firstUserMessage: null,
                         agentNickname: null,
                         agentRole: null,
-                        isArchived: null
+                        isArchived: null,
+                        rolloutPath: null
                     });
                 }
                 catch {
@@ -666,6 +846,7 @@ export class CodexAdapter {
                     firstUserMessage: ensureText(row.first_user_message).trim() || (current?.firstUserMessage ?? null),
                     agentNickname: ensureText(row.agent_nickname).trim() || (current?.agentNickname ?? null),
                     agentRole: ensureText(row.agent_role).trim() || (current?.agentRole ?? null),
+                    rolloutPath: ensureText(row.rollout_path).trim() || (current?.rolloutPath ?? null),
                     isArchived: typeof row.archived === "number"
                         ? row.archived === 1
                         : ensureText(row.rollout_path).includes("archived_sessions")
@@ -694,11 +875,40 @@ export class CodexAdapter {
         };
         return index;
     }
-    listSessionFiles() {
+    listSessionFiles(targetPath, threadMetadataIndex, knownSessions) {
         const activeFiles = walkJsonlFiles(join(this.options.homeDir, "sessions"));
-        const archivedFiles = walkJsonlFiles(join(this.options.homeDir, "archived_sessions"));
+        const archivedFiles = this.listArchivedSessionFiles(targetPath, threadMetadataIndex, knownSessions);
         return [...activeFiles, ...archivedFiles];
     }
+    listArchivedSessionFiles(targetPath, threadMetadataIndex, knownSessions) {
+        const archivedFiles = new Set();
+        for (const metadata of threadMetadataIndex.values()) {
+            if (metadata.isArchived !== true
+                || !metadata.rolloutPath) {
+                continue;
+            }
+            if (targetPath.length > 0
+                && normalizeWorkspacePath(metadata.cwd ?? "") !== targetPath) {
+                continue;
+            }
+            archivedFiles.add(metadata.rolloutPath);
+        }
+        for (const session of knownSessions) {
+            if (session.isArchived !== true
+                || normalizeWorkspacePath(session.workspacePath) !== targetPath
+                || !isCodexArchivedFilePath(session.rawStoreRef)) {
+                continue;
+            }
+            archivedFiles.add(session.rawStoreRef);
+        }
+        if (archivedFiles.size > 0) {
+            return [...archivedFiles].filter((filePath) => existsSync(filePath));
+        }
+        if (threadMetadataIndex.size === 0) {
+            return walkJsonlFiles(join(this.options.homeDir, "archived_sessions"));
+        }
+        return [];
+    }
     resolveSessionFilePath(rawStoreRef, providerSessionId) {
         const matchedByThreadId = this.findSessionFileByThreadId(providerSessionId);
         if (existsSync(rawStoreRef)) {
@@ -732,7 +942,10 @@ export class CodexAdapter {
         return buildSyntheticCodexHistoryPath(this.options.homeDir, providerSessionId);
     }
     findSessionFileByThreadId(providerSessionId) {
-        for (const filePath of this.listSessionFiles()) {
+        const threadMetadataIndex = this.readThreadMetadataIndex();
+        const activeFiles = walkJsonlFiles(join(this.options.homeDir, "sessions"));
+        const archivedFiles = this.listArchivedSessionFiles("", threadMetadataIndex, []);
+        for (const filePath of [...activeFiles, ...archivedFiles]) {
             const threadId = this.readThreadIdFromRawStore(filePath);
             if (threadId === providerSessionId) {
                 return filePath;
@@ -823,6 +1036,26 @@ export class CodexAdapter {
             providerSourceMessageId: input.providerSourceMessageId
         };
     }
+    async forkThreadWithHistoryFallback(transport, providerSessionId, workspacePath, rawStoreRef) {
+        try {
+            return await transport.forkThread(providerSessionId);
+        }
+        catch (error) {
+            const history = buildCodexResumeHistoryFromRawStore(rawStoreRef);
+            if (!shouldFallbackCodexForkFromHistory(error, history)) {
+                throw error;
+            }
+            // app-server 的 thread/fork 依赖源 thread 已经挂在当前连接上。
+            // 这个前提跨请求就会失效，所以这里退回到本地 transcript 冷恢复一次。
+            const rebuilt = await transport.resumeThreadFromHistory({
+                providerSessionId: null,
+                workspacePath,
+                history,
+                model: null
+            });
+            return await transport.forkThread(rebuilt.providerSessionId);
+        }
+    }
     touchSessionSummaryCache(filePath, entry) {
         this.sessionSummaryCache.delete(filePath);
         this.sessionSummaryCache.set(filePath, entry);
@@ -834,6 +1067,20 @@ export class CodexAdapter {
             this.sessionSummaryCache.delete(oldestKey);
         }
     }
+    invalidateThreadMetadataIndexCache() {
+        this.threadMetadataIndexCache = null;
+    }
+    touchSpawnRelationScanCache(filePath, entry) {
+        this.spawnRelationScanCache.delete(filePath);
+        this.spawnRelationScanCache.set(filePath, entry);
+        while (this.spawnRelationScanCache.size > SPAWN_RELATION_SCAN_CACHE_LIMIT) {
+            const oldestKey = this.spawnRelationScanCache.keys().next().value;
+            if (!oldestKey) {
+                break;
+            }
+            this.spawnRelationScanCache.delete(oldestKey);
+        }
+    }
     isForkedChildHistoryAligned(childThreadReadResult, expectedHistory) {
         const expectedSignatures = collectCodexForkComparableSignatures(expectedHistory);
         if (expectedSignatures.length === 0) {
@@ -880,22 +1127,65 @@ export class CodexAdapter {
     readSpawnedAgentRelationIndex(files, targetPath, threadMetadataIndex, candidateThreadIds) {
         const directRelations = new Map();
         const spawnRecords = [];
-        for (const filePath of files) {
-            const sessionIdentity = this.readSessionIdentity(filePath, basename(filePath, ".jsonl"));
+        for (const entry of files) {
+            const { filePath, stats } = entry;
+            const cached = this.spawnRelationScanCache.get(filePath);
+            if (cached
+                && cached.mtimeMs === stats.mtimeMs
+                && cached.size === stats.size) {
+                this.touchSpawnRelationScanCache(filePath, cached);
+                if (cached.workspacePath !== targetPath) {
+                    continue;
+                }
+                for (const [threadId, relation] of cached.directRelations) {
+                    directRelations.set(threadId, relation);
+                }
+                spawnRecords.push(...cached.spawnRecords);
+                continue;
+            }
+            const sessionIdentity = entry.sessionIdentity ?? this.readSessionIdentity(filePath, basename(filePath, ".jsonl"));
             if (!sessionIdentity) {
+                this.touchSpawnRelationScanCache(filePath, {
+                    filePath,
+                    mtimeMs: stats.mtimeMs,
+                    size: stats.size,
+                    workspacePath: null,
+                    directRelations: [],
+                    spawnRecords: []
+                });
                 continue;
             }
-            if (normalizeWorkspacePath(sessionIdentity.cwd) !== targetPath) {
+            const workspacePath = normalizeWorkspacePath(sessionIdentity.cwd);
+            if (workspacePath !== targetPath) {
+                this.touchSpawnRelationScanCache(filePath, {
+                    filePath,
+                    mtimeMs: stats.mtimeMs,
+                    size: stats.size,
+                    workspacePath,
+                    directRelations: [],
+                    spawnRecords: []
+                });
                 continue;
             }
             if (sessionIdentity.parentThreadId) {
-                directRelations.set(sessionIdentity.threadId, {
+                const relation = {
                     parentProviderSessionId: sessionIdentity.parentThreadId
+                };
+                directRelations.set(sessionIdentity.threadId, relation);
+                this.touchSpawnRelationScanCache(filePath, {
+                    filePath,
+                    mtimeMs: stats.mtimeMs,
+                    size: stats.size,
+                    workspacePath,
+                    directRelations: [[sessionIdentity.threadId, relation]],
+                    spawnRecords: []
                 });
                 continue;
             }
             const records = readJsonLines(filePath).map((record) => record.data);
             const spawnCallById = new Map();
+            const fileSpawnRecords = [];
+            const fileDirectRelations = [];
             for (const record of records) {
                 if (record.type !== "response_item") {
                     continue;
@@ -916,6 +1206,7 @@ export class CodexAdapter {
                         timestampMs: toTimestampMs(record.timestamp)
                     };
                     spawnCallById.set(callId, spawnRecord);
+                    fileSpawnRecords.push(spawnRecord);
                     spawnRecords.push(spawnRecord);
                     continue;
                 }
@@ -931,10 +1222,20 @@ export class CodexAdapter {
                 if (!agentId) {
                     continue;
                 }
-                directRelations.set(agentId, {
+                const relation = {
                     parentProviderSessionId: spawnRecord.parentProviderSessionId
-                });
+                };
+                directRelations.set(agentId, relation);
+                fileDirectRelations.push([agentId, relation]);
             }
+            this.touchSpawnRelationScanCache(filePath, {
+                filePath,
+                mtimeMs: stats.mtimeMs,
+                size: stats.size,
+                workspacePath,
+                directRelations: fileDirectRelations,
+                spawnRecords: fileSpawnRecords
+            });
         }
         const relationCandidates = candidateThreadIds === undefined
             ? [...threadMetadataIndex.entries()]
@@ -1058,7 +1359,13 @@ export class CodexAdapter {
                     const content = ensureText(payload.message);
                     if (content.length > 0) {
                         pushMessage("event_msg", {
-                            messageId: messageIdFromRawRef(rawRef),
+                            messageId: resolveCodexParsedMessageId({
+                                providerSessionId,
+                                rawRef,
+                                role: "user",
+                                kind: "text",
+                                payloadId: payload.id
+                            }),
                             provider: this.providerId,
                             providerSessionId,
                             role: "user",
@@ -1074,7 +1381,13 @@ export class CodexAdapter {
                     const content = ensureText(payload.message);
                     if (content.length > 0) {
                         pushMessage("event_msg", {
-                            messageId: messageIdFromRawRef(rawRef),
+                            messageId: resolveCodexParsedMessageId({
+                                providerSessionId,
+                                rawRef,
+                                role: "assistant",
+                                kind: "text",
+                                payloadId: payload.id
+                            }),
                             provider: this.providerId,
                             providerSessionId,
                             role: "assistant",
@@ -1090,7 +1403,13 @@ export class CodexAdapter {
                     const content = extractTextBlocks(payload.text ?? payload.message).trim();
                     if (content.length > 0) {
                         pushMessage("event_msg", {
-                            messageId: messageIdFromRawRef(rawRef),
+                            messageId: resolveCodexParsedMessageId({
+                                providerSessionId,
+                                rawRef,
+                                role: "assistant",
+                                kind: "thinking",
+                                payloadId: payload.id
+                            }),
                             provider: this.providerId,
                             providerSessionId,
                             role: "assistant",
@@ -1112,7 +1431,13 @@ export class CodexAdapter {
                         return;
                     }
                     pushMessage("response_item", {
-                        messageId: messageIdFromRawRef(rawRef),
+                        messageId: resolveCodexParsedMessageId({
+                            providerSessionId,
+                            rawRef,
+                            role: "assistant",
+                            kind: "thinking",
+                            payloadId: payload.id
+                        }),
                         provider: this.providerId,
                         providerSessionId,
                         role: "assistant",
@@ -1131,7 +1456,13 @@ export class CodexAdapter {
                     const input = stringifyStructuredValue(inputSource);
                     toolNameById.set(callId, name);
                     pushMessage("response_item", {
-                        messageId: messageIdFromRawRef(rawRef),
+                        messageId: resolveCodexParsedMessageId({
+                            providerSessionId,
+                            rawRef,
+                            role: "tool",
+                            kind: "tool_call",
+                            callId
+                        }),
                         provider: this.providerId,
                         providerSessionId,
                         role: "tool",
@@ -1156,7 +1487,13 @@ export class CodexAdapter {
                     const output = extractTextBlocks(payload.output).trim() || stringifyStructuredValue(payload.output);
                     const resultState = resolveToolResultState(payload, output);
                     pushMessage("response_item", {
-                        messageId: messageIdFromRawRef(rawRef),
+                        messageId: resolveCodexParsedMessageId({
+                            providerSessionId,
+                            rawRef,
+                            role: "tool",
+                            kind: "tool_result",
+                            callId
+                        }),
                         provider: this.providerId,
                         providerSessionId,
                         role: "tool",
@@ -1184,7 +1521,13 @@ export class CodexAdapter {
                     return;
                 }
                 pushMessage("response_item", {
-                    messageId: messageIdFromRawRef(rawRef),
+                    messageId: resolveCodexParsedMessageId({
+                        providerSessionId,
+                        rawRef,
+                        role,
+                        kind: "text",
+                        payloadId: payload.id
+                    }),
                     provider: this.providerId,
                     providerSessionId,
                     role,
@@ -1380,6 +1723,37 @@ function areCodexTimestampsNear(left, right) {
     }
     return Math.abs(leftMs - rightMs) <= 1000;
 }
+function resolveCodexParsedMessageId(input) {
+    const stableIdentity = resolveCodexStableIdentity(input);
+    if (!stableIdentity) {
+        return messageIdFromRawRef(input.rawRef);
+    }
+    return messageIdFromStableKey(buildCodexStableMessageKey(input.providerSessionId, stableIdentity));
+}
+function resolveCodexStableIdentity(input) {
+    if (input.kind === "tool_call" || input.kind === "tool_result") {
+        const normalizedCallId = ensureText(input.callId).trim();
+        if (!normalizedCallId) {
+            return null;
+        }
+        return input.kind === "tool_call"
+            ? `tool:call:${normalizedCallId}`
+            : `tool:result:${normalizedCallId}`;
+    }
+    if (input.role !== "assistant"
+        && input.role !== "user") {
+        return null;
+    }
+    const normalizedPayloadId = ensureText(input.payloadId).trim();
+    if (!normalizedPayloadId) {
+        return null;
+    }
+    const identityKind = input.kind === "thinking" ? "thinking" : "text";
+    return `${input.role}:${identityKind}:${normalizedPayloadId}`;
+}
+function buildCodexStableMessageKey(providerSessionId, stableIdentity) {
+    return `codex:${providerSessionId}:${stableIdentity}`;
+}
 function extractTextFromArray(value) {
     if (!Array.isArray(value)) {
         return "";
@@ -1926,4 +2300,16 @@ function stringifyCodexReasoningContent(content) {
         .join("\n")
         .trim();
 }
+function shouldFallbackCodexForkFromHistory(error, history) {
+    if (history.length === 0) {
+        return false;
+    }
+    return isCodexThreadLoadError(error);
+}
+function isCodexThreadLoadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.trim().toLowerCase();
+    return (normalized.includes("thread not loaded") ||
+        normalized.includes("no rollout found for thread id"));
+}
 //# sourceMappingURL=codex.js.map