@jingyi0605/codingns 0.7.4 → 0.8.0

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

@@ -1,2436 +0,0 @@
-import { basename, dirname, join } from "node:path";
-import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
-import crypto from "node:crypto";
-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 { buildApplyPatchFromCodexCommandLikeValue } from "../patch-builder.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;
-const CODEX_CONFIG_CONTEXT_WINDOW_PATTERN = /(?:^|\n)\s*model_context_window\s*=\s*(\d+)\s*(?:\n|$)/i;
-const KNOWN_CODEX_CONTEXT_WINDOWS = new Map([
-    ["gpt-5.3-codex", 400_000],
-    ["codex-mini-latest", 200_000]
-]);
-export class CodexAdapter {
-    options;
-    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 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");
-            const sessionIdentity = this.readSessionIdentity(filePath, fileSessionId);
-            if (cachedSummary
-                && cachedSummary.mtimeMs === stats.mtimeMs
-                && cachedSummary.size === stats.size
-                && (!cachedSummary.summary
-                    || !sessionIdentity
-                    || cachedSummary.summary.providerSessionId === sessionIdentity.threadId)) {
-                this.touchSessionSummaryCache(filePath, cachedSummary);
-                if (cachedSummary.summary
-                    && hasUsableCodexTitle(cachedSummary.summary.title)
-                    && normalizeWorkspacePath(cachedSummary.summary.workspacePath) === targetPath) {
-                    skippedByMtimeSize += 1;
-                    retainedSummaries.push({
-                        filePath,
-                        stats,
-                        sessionIdentity,
-                        summary: cachedSummary.summary
-                    });
-                    continue;
-                }
-                if (cachedSummary.workspacePath
-                    && normalizeWorkspacePath(cachedSummary.workspacePath) !== targetPath) {
-                    continue;
-                }
-            }
-            const knownByPath = knownByRawStoreRef.get(filePath);
-            if (knownByPath
-                && knownByPath.sourceMtimeMs === stats.mtimeMs
-                && knownByPath.sourceSizeBytes === stats.size
-                && hasUsableCodexTitle(knownByPath.title)
-                && (!sessionIdentity
-                    || knownByPath.providerSessionId === sessionIdentity.threadId)) {
-                skippedByMtimeSize += 1;
-                if (normalizeWorkspacePath(knownByPath.workspacePath) === targetPath) {
-                    retainedSummaries.push({
-                        filePath,
-                        stats,
-                        sessionIdentity,
-                        summary: knownByPath
-                    });
-                    continue;
-                }
-                this.touchSessionSummaryCache(filePath, {
-                    filePath,
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size,
-                    workspacePath: knownByPath.workspacePath,
-                    providerSessionId: knownByPath.providerSessionId,
-                    title: null,
-                    summary: null
-                });
-                continue;
-            }
-            if (sessionIdentity?.cwd
-                && normalizeWorkspacePath(sessionIdentity.cwd) !== targetPath) {
-                this.touchSessionSummaryCache(filePath, {
-                    filePath,
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size,
-                    workspacePath: sessionIdentity.cwd,
-                    providerSessionId: sessionIdentity.threadId,
-                    title: null,
-                    summary: null
-                });
-                continue;
-            }
-            pendingFiles.push({
-                filePath,
-                fileSessionId,
-                stats: {
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size
-                },
-                sessionIdentity
-            });
-        }
-        if (pendingFiles.length === 0 && retainedSummaries.length === 0) {
-            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 pendingThreadIds = new Set([...pendingFiles, ...retainedSummaries]
-            .map((entry) => entry.sessionIdentity?.threadId ?? null)
-            .filter((value) => value !== null));
-        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;
-            const currentSpawnRelation = spawnedAgentRelationIndex.get(currentThreadId) ?? null;
-            const summary = this.hydrateSessionSummary({
-                ...entry.summary,
-                workspacePath: entry.sessionIdentity?.cwd || entry.summary.workspacePath
-            }, entry.filePath, entry.stats, currentThreadMetadata, currentSpawnRelation);
-            this.touchSessionSummaryCache(entry.filePath, {
-                filePath: entry.filePath,
-                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;
-            }
-            const cwd = ensureText(metaPayload.cwd);
-            const cachedWorkspacePath = cwd || null;
-            const sessionWorkspacePath = cwd || workspacePath;
-            if (normalizeWorkspacePath(cwd) !== targetPath) {
-                this.touchSessionSummaryCache(filePath, {
-                    filePath,
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size,
-                    workspacePath: cachedWorkspacePath,
-                    providerSessionId: codexSessionId,
-                    title: null,
-                    summary: null
-                });
-                continue;
-            }
-            const currentThreadMetadata = threadMetadataIndex.get(codexSessionId) ??
-                (sessionIdentity ? threadMetadataIndex.get(sessionIdentity.threadId) : null);
-            const currentSpawnRelation = spawnedAgentRelationIndex.get(codexSessionId) ??
-                (sessionIdentity ? spawnedAgentRelationIndex.get(sessionIdentity.threadId) : null);
-            const knownBySessionId = knownByProviderSessionId.get(codexSessionId);
-            if (knownBySessionId
-                && knownBySessionId.sourceMtimeMs === stats.mtimeMs
-                && knownBySessionId.sourceSizeBytes === stats.size
-                && hasUsableCodexTitle(knownBySessionId.title)) {
-                const summary = this.hydrateSessionSummary({
-                    ...knownBySessionId,
-                    workspacePath: sessionWorkspacePath
-                }, filePath, stats, currentThreadMetadata, currentSpawnRelation);
-                this.touchSessionSummaryCache(filePath, {
-                    filePath,
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size,
-                    workspacePath: sessionWorkspacePath,
-                    providerSessionId: summary.providerSessionId,
-                    title: summary.title,
-                    summary
-                });
-                sessionsByProviderSessionId.set(codexSessionId, summary);
-                continue;
-            }
-            const messages = this.parseMessagesFromEntries(filePath, records, codexSessionId);
-            const title = this.resolveIndexedTitle(threadMetadataIndex, codexSessionId) ??
-                resolveCodexFallbackTitle(messages) ??
-                fileSessionId;
-            const lastMessageAt = messages.at(-1)?.timestamp ?? (ensureText(metaPayload.timestamp) || null);
-            const summary = this.hydrateSessionSummary({
-                provider: this.providerId,
-                providerSessionId: codexSessionId,
-                title,
-                workspacePath: sessionWorkspacePath,
-                rawStoreRef: filePath,
-                lastMessageAt,
-                messageCount: messages.length,
-                isArchived: false
-            }, filePath, stats, currentThreadMetadata, currentSpawnRelation);
-            sessionsByProviderSessionId.set(codexSessionId, summary);
-            this.touchSessionSummaryCache(filePath, {
-                filePath,
-                mtimeMs: stats.mtimeMs,
-                size: stats.size,
-                workspacePath: sessionWorkspacePath,
-                providerSessionId: summary.providerSessionId,
-                title: summary.title,
-                summary
-            });
-        }
-        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);
-        if (!existsSync(resolvedStoreRef)) {
-            return {
-                messages: [],
-                cursor,
-                nextCursor: null,
-                total: 0
-            };
-        }
-        const messages = this.getParsedMessages(resolvedStoreRef, providerSessionId);
-        return sliceHistory(messages, cursor, limit, direction);
-    }
-    async readRecentSessionHistory(providerSessionId, rawStoreRef, totalMessageCount, limit) {
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        if (!existsSync(resolvedStoreRef)) {
-            return null;
-        }
-        const stats = statSync(resolvedStoreRef);
-        const cached = this.historyCache.get(resolvedStoreRef);
-        if (cached
-            && cached.providerSessionId === providerSessionId
-            && cached.mtimeMs === stats.mtimeMs
-            && cached.size === stats.size) {
-            this.touchHistoryCache(resolvedStoreRef, cached);
-            return sliceHistory(cached.messages, null, limit, "backward");
-        }
-        const safeLimit = Math.max(1, Math.min(Math.trunc(limit), 100));
-        let maxBytes = Math.min(RECENT_HISTORY_INITIAL_BYTES, stats.size);
-        while (maxBytes > 0) {
-            const lines = readTrailingJsonLines(resolvedStoreRef, maxBytes);
-            if (lines.length > 0) {
-                const messages = this.parseMessagesFromEntries(resolvedStoreRef, lines, providerSessionId);
-                if (messages.length > 0
-                    && (messages.length >= Math.min(totalMessageCount, safeLimit + RECENT_HISTORY_BUFFER_MESSAGES)
-                        || maxBytes >= stats.size)) {
-                    return buildRecentHistoryPage(messages, totalMessageCount, safeLimit);
-                }
-            }
-            if (maxBytes >= stats.size || maxBytes >= RECENT_HISTORY_MAX_BYTES) {
-                break;
-            }
-            maxBytes = Math.min(stats.size, maxBytes * 2, RECENT_HISTORY_MAX_BYTES);
-        }
-        return null;
-    }
-    subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent) {
-        let currentCursor = cursor;
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        let lastMtime = existsSync(resolvedStoreRef) ? statSync(resolvedStoreRef).mtimeMs : 0;
-        const timer = setInterval(async () => {
-            if (!existsSync(resolvedStoreRef)) {
-                return;
-            }
-            const nextStat = statSync(resolvedStoreRef);
-            if (nextStat.mtimeMs <= lastMtime) {
-                return;
-            }
-            lastMtime = nextStat.mtimeMs;
-            const page = await this.readSessionHistory(providerSessionId, rawStoreRef, currentCursor, limit);
-            if (page.messages.length === 0) {
-                return;
-            }
-            currentCursor = page.cursor;
-            await onEvent({
-                messages: page.messages,
-                cursor: page.cursor
-            });
-        }, 300);
-        return {
-            close() {
-                clearInterval(timer);
-            }
-        };
-    }
-    async resumeSession(providerSessionId, rawStoreRef) {
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        statSync(resolvedStoreRef);
-        return {
-            provider: this.providerId,
-            providerSessionId,
-            resumedAt: nextTimestamp(),
-            rawStoreRef: resolvedStoreRef
-        };
-    }
-    async startSession(workspacePath, options) {
-        const now = new Date();
-        const sessionId = `rollout-${now.toISOString().replaceAll(":", "-")}-${crypto.randomUUID()}`;
-        const folder = join(this.options.homeDir, "sessions", `${now.getUTCFullYear()}`, `${String(now.getUTCMonth() + 1).padStart(2, "0")}`, `${String(now.getUTCDate()).padStart(2, "0")}`);
-        ensureDirectory(folder);
-        const filePath = join(folder, `${sessionId}.jsonl`);
-        const nowIso = nextTimestamp();
-        appendJsonLine(filePath, {
-            timestamp: nowIso,
-            type: "session_meta",
-            payload: {
-                id: sessionId,
-                timestamp: nowIso,
-                cwd: workspacePath,
-                originator: "CodingNS Host",
-                source: "codingns"
-            }
-        });
-        if (options.initialPrompt) {
-            appendJsonLine(filePath, {
-                timestamp: nextTimestamp(),
-                type: "event_msg",
-                payload: {
-                    type: "user_message",
-                    message: options.initialPrompt
-                }
-            });
-        }
-        return {
-            session: {
-                provider: this.providerId,
-                providerSessionId: sessionId,
-                title: options.initialPrompt?.slice(0, CODEX_SESSION_TITLE_MAX_LENGTH) || "New Codex session",
-                workspacePath,
-                rawStoreRef: filePath,
-                isArchived: false,
-                lastMessageAt: nextTimestamp(),
-                messageCount: options.initialPrompt ? 1 : 0
-            },
-            initialCursor: encodeCursor(options.initialPrompt ? 1 : 0)
-        };
-    }
-    async forkSession(providerSessionId, workspacePath, options) {
-        const transportFactory = this.options.forkTransportFactory;
-        if (!transportFactory) {
-            throw new Error("CODEX_FORK_TRANSPORT_NOT_CONFIGURED");
-        }
-        const transport = transportFactory();
-        try {
-            await transport.initialize();
-            if (options.sourceType === "session") {
-                const forked = await this.forkThreadWithHistoryFallback(transport, providerSessionId, workspacePath, options.rawStoreRef);
-                return await this.buildForkResultFromTransport({
-                    providerSessionId: forked.providerSessionId,
-                    rawStoreRef: forked.rawStoreRef,
-                    workspacePath,
-                    fallbackParentProviderSessionId: providerSessionId,
-                    forkMethod: "native_session_fork",
-                    forkSourceType: "session",
-                    providerSourceMessageId: null
-                });
-            }
-            const targetMessageId = options.sourceMessageId?.trim();
-            if (!targetMessageId) {
-                throw new Error("FORK_SOURCE_MESSAGE_ID_REQUIRED");
-            }
-            if (options.strategy === "reconstruct-only") {
-                throw new Error("CODEX_RECONSTRUCTED_MESSAGE_FORK_NOT_SUPPORTED");
-            }
-            const resolvedStoreRef = this.resolveSessionFilePath(options.rawStoreRef, providerSessionId);
-            const parsedMessages = this.getParsedMessages(resolvedStoreRef, providerSessionId);
-            const targetMessage = parsedMessages.find((message) => message.messageId === targetMessageId);
-            if (!targetMessage) {
-                throw new Error("FORK_SOURCE_MESSAGE_NOT_FOUND");
-            }
-            const targetSnapshot = applyForkSourceMessageSnapshot(targetMessage, options.sourceMessageSnapshot);
-            const threadReadResult = await transport.readThread(providerSessionId);
-            const threadSnapshot = extractCodexThreadHistorySnapshot(threadReadResult);
-            const truncatedHistory = truncateCodexThreadHistory(threadSnapshot.value, parsedMessages, targetSnapshot);
-            if (truncatedHistory.length === 0) {
-                throw new Error("CODEX_FORK_HISTORY_EMPTY");
-            }
-            if (threadSnapshot.kind !== "turns") {
-                throw new Error("CODEX_RECONSTRUCTED_MESSAGE_FORK_NOT_SUPPORTED");
-            }
-            const rollbackPlan = buildCodexTurnRollbackPlan(threadSnapshot, parsedMessages, targetSnapshot);
-            const forked = await transport.forkThread(providerSessionId);
-            const finalized = rollbackPlan.numTurnsToRollback > 0
-                ? await transport.rollbackThread(forked.providerSessionId, rollbackPlan.numTurnsToRollback)
-                : forked;
-            const childThreadReadResult = await transport.readThread(finalized.providerSessionId);
-            if (!this.isForkedChildHistoryAligned(childThreadReadResult, truncatedHistory)) {
-                throw new Error("CODEX_NATIVE_MESSAGE_FORK_DIRTY");
-            }
-            return await this.buildForkResultFromTransport({
-                providerSessionId: finalized.providerSessionId,
-                rawStoreRef: finalized.rawStoreRef,
-                workspacePath,
-                fallbackParentProviderSessionId: providerSessionId,
-                forkMethod: "native_message_fork",
-                forkSourceType: "message",
-                providerSourceMessageId: null,
-                messageCountOverride: targetSnapshot.sequence,
-                inheritedPrefixMessageCountOverride: targetSnapshot.sequence,
-                lastMessageAtOverride: targetSnapshot.timestamp
-            });
-        }
-        finally {
-            transport.close();
-        }
-    }
-    async sendMessage(providerSessionId, rawStoreRef, content, clientRequestId, _permissionMode) {
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        const lineNumber = readJsonLines(resolvedStoreRef).length + 1;
-        const acceptedAt = nextTimestamp();
-        appendJsonLine(resolvedStoreRef, {
-            timestamp: acceptedAt,
-            type: "event_msg",
-            payload: {
-                type: "user_message",
-                message: content,
-                clientRequestId
-            }
-        });
-        const rawRef = createRawRef(this.providerId, resolvedStoreRef, lineNumber);
-        this.historyCache.delete(resolvedStoreRef);
-        return {
-            acceptedAt,
-            clientRequestId,
-            message: {
-                messageId: messageIdFromRawRef(rawRef),
-                provider: this.providerId,
-                providerSessionId,
-                role: "user",
-                kind: "text",
-                content,
-                toolCall: null,
-                timestamp: acceptedAt,
-                sequence: this.parseMessages(rawStoreRef, readJsonLines(resolvedStoreRef), providerSessionId).length,
-                rawRef
-            }
-        };
-    }
-    async readSessionTitle(providerSessionId, rawStoreRef) {
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        const fileSessionId = basename(resolvedStoreRef, ".jsonl");
-        const sessionIdentity = this.readSessionIdentity(resolvedStoreRef, fileSessionId);
-        const threadMetadataIndex = this.readThreadMetadataIndex();
-        const indexedTitle = this.resolveIndexedTitle(threadMetadataIndex, providerSessionId) ??
-            (sessionIdentity
-                ? this.resolveIndexedTitle(threadMetadataIndex, sessionIdentity.threadId)
-                : 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();
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        const indexPath = join(this.options.homeDir, "session_index.jsonl");
-        const stateDbPath = findLatestCodexStateDatabase(this.options.homeDir);
-        statSync(resolvedStoreRef);
-        ensureDirectory(this.options.homeDir);
-        appendJsonLine(indexPath, {
-            id: providerSessionId,
-            thread_name: nextTitle
-        });
-        if (stateDbPath) {
-            const DatabaseSync = loadDatabaseSync();
-            let db = null;
-            try {
-                db = new DatabaseSync(stateDbPath, { open: true });
-                db.prepare("UPDATE threads SET title = ? WHERE id = ?").run(nextTitle, providerSessionId);
-            }
-            finally {
-                db?.close();
-            }
-        }
-        this.sessionSummaryCache.delete(resolvedStoreRef);
-        return nextTitle;
-    }
-    async updateSessionArchiveState(providerSessionId, rawStoreRef, isArchived) {
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        const currentFileName = basename(resolvedStoreRef) || `${providerSessionId}.jsonl`;
-        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);
-        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 });
-                const result = db.prepare("DELETE FROM threads WHERE id = ?").run(providerSessionId);
-                deletedAny = deletedAny || result.changes > 0;
-            }
-            finally {
-                db?.close();
-            }
-        }
-        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 {
-            provider: this.providerId,
-            canStartSession: true,
-            canResumeSession: true,
-            canSendMessage: true,
-            inRunInputMode: "streaming_guidance",
-            supportsSubagents: true,
-            supportsInterrupt: true,
-            supportsStructuredToolCalls: true,
-            supportsTokenUsage: true,
-            supportsAttachments: true,
-            supportsPermissionPrompt: true,
-            supportsCheckpoint: false,
-            supportsSessionFork: true,
-            supportsSessionDelete: true,
-            limitations: [
-                "运行中追加消息依赖 Codex CLI app-server 暴露 turn/steer；当前项目实测 codex-cli 0.118.0 可用。",
-                "当前 npm SDK 仍只有 run/runStreamed 轮询式接口，宿主运行时需经由 Codex CLI app-server 才能直发 steer。"
-            ]
-        };
-    }
-    async getSessionCapabilities() {
-        return this.getProviderCapabilities();
-    }
-    async readContextUsage(providerSessionId, rawStoreRef) {
-        const resolvedStoreRef = this.resolveSessionFilePath(rawStoreRef, providerSessionId);
-        const records = readJsonLines(resolvedStoreRef).map((record) => record.data);
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const record = records[index];
-            if (ensureText(record.type).trim() !== "event_msg") {
-                continue;
-            }
-            const payload = (record.payload ?? {});
-            if (ensureText(payload.type).trim() !== "token_count") {
-                continue;
-            }
-            const info = (payload.info ?? {});
-            const lastUsage = (info.last_token_usage ?? {});
-            const uncachedInputTokens = readNonNegativeInteger(lastUsage.input_tokens);
-            const cachedInputTokens = readNonNegativeInteger(lastUsage.cached_input_tokens);
-            if (uncachedInputTokens === null && cachedInputTokens === null) {
-                continue;
-            }
-            const promptTokens = uncachedInputTokens ?? 0;
-            const modelId = ensureText(info.model ?? info.model_id).trim() || null;
-            const runtimeContextWindow = readNonNegativeInteger(info.model_context_window);
-            const contextWindow = runtimeContextWindow
-                ?? resolveCodexKnownContextWindow(modelId)
-                ?? readCodexConfigContextWindow(this.options.homeDir);
-            if (contextWindow === null || contextWindow <= 0) {
-                return null;
-            }
-            return {
-                provider: this.providerId,
-                promptTokens,
-                uncachedInputTokens: uncachedInputTokens ?? 0,
-                cachedInputTokens: cachedInputTokens ?? 0,
-                contextWindow,
-                usageRatio: clampUsageRatio(promptTokens, contextWindow),
-                source: "provider-log",
-                contextWindowSource: runtimeContextWindow !== null
-                    ? "provider-log"
-                    : resolveCodexKnownContextWindow(modelId) !== null
-                        ? "model-map"
-                        : "provider-config",
-                modelId,
-                capturedAt: safeDate(record.timestamp, "").trim() || null,
-                isEstimated: runtimeContextWindow === null
-            };
-        }
-        return null;
-    }
-    readThreadMetadataIndex() {
-        const indexPath = join(this.options.homeDir, "session_index.jsonl");
-        const indexPathMtimeMs = existsSync(indexPath) ? statSync(indexPath).mtimeMs : null;
-        const stateDbPath = findLatestCodexStateDatabase(this.options.homeDir);
-        const stateDbMtimeMs = stateDbPath && existsSync(stateDbPath) ? statSync(stateDbPath).mtimeMs : null;
-        const cached = this.threadMetadataIndexCache;
-        if (cached
-            && cached.indexPathMtimeMs === indexPathMtimeMs
-            && cached.stateDbPath === stateDbPath
-            && cached.stateDbMtimeMs === stateDbMtimeMs) {
-            return cached.index;
-        }
-        const index = new Map();
-        if (existsSync(indexPath)) {
-            const lines = readFileSync(indexPath, "utf8")
-                .split(/\r?\n/)
-                .filter((line) => line.trim().length > 0);
-            // 这里容忍单行脏数据，避免某一条坏记录把整个会话列表拖死。
-            for (const line of lines) {
-                try {
-                    const record = JSON.parse(line);
-                    const id = ensureText(record.id).trim();
-                    if (id.length === 0) {
-                        continue;
-                    }
-                    index.set(id, {
-                        title: normalizeCodexIndexedTitle(ensureText(record.thread_name)) || null,
-                        cwd: null,
-                        createdAtMs: null,
-                        firstUserMessage: null,
-                        agentNickname: null,
-                        agentRole: null,
-                        isArchived: null,
-                        rolloutPath: null
-                    });
-                }
-                catch {
-                    continue;
-                }
-            }
-        }
-        if (!stateDbPath) {
-            this.threadMetadataIndexCache = {
-                indexPathMtimeMs,
-                stateDbPath: null,
-                stateDbMtimeMs: null,
-                index
-            };
-            return index;
-        }
-        const DatabaseSync = loadDatabaseSync();
-        let db = null;
-        try {
-            db = new DatabaseSync(stateDbPath, { open: true, readOnly: true });
-            const rows = db.prepare(`SELECT
-           id,
-           title,
-           cwd,
-           created_at,
-           archived,
-           first_user_message,
-           agent_nickname,
-           agent_role,
-           rollout_path
-         FROM threads`).all();
-            for (const row of rows) {
-                const id = ensureText(row.id).trim();
-                if (id.length === 0) {
-                    continue;
-                }
-                const current = index.get(id);
-                const dbTitle = normalizeCodexIndexedTitle(ensureText(row.title)) || null;
-                const createdAtSeconds = typeof row.created_at === "number"
-                    ? row.created_at
-                    : Number.parseInt(ensureText(row.created_at), 10);
-                index.set(id, {
-                    title: current?.title ?? dbTitle,
-                    cwd: ensureText(row.cwd).trim() || (current?.cwd ?? null),
-                    createdAtMs: Number.isFinite(createdAtSeconds) ? createdAtSeconds * 1000 : null,
-                    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")
-                            ? true
-                            : (current?.isArchived ?? null)
-                });
-            }
-        }
-        catch {
-            this.threadMetadataIndexCache = {
-                indexPathMtimeMs,
-                stateDbPath,
-                stateDbMtimeMs,
-                index
-            };
-            return index;
-        }
-        finally {
-            db?.close();
-        }
-        this.threadMetadataIndexCache = {
-            indexPathMtimeMs,
-            stateDbPath,
-            stateDbMtimeMs,
-            index
-        };
-        return index;
-    }
-    listSessionFiles(targetPath, threadMetadataIndex, knownSessions) {
-        const activeFiles = walkJsonlFiles(join(this.options.homeDir, "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 metadata of threadMetadataIndex.values()) {
-            if (metadata.isArchived === true
-                || !metadata.rolloutPath) {
-                continue;
-            }
-            if (targetPath.length > 0
-                && normalizeWorkspacePath(metadata.cwd ?? "") !== targetPath) {
-                continue;
-            }
-            const archivedCandidate = this.resolveArchivedSessionCandidate(metadata.rolloutPath);
-            if (archivedCandidate) {
-                archivedFiles.add(archivedCandidate);
-            }
-        }
-        for (const session of knownSessions) {
-            if (session.isArchived !== true
-                || normalizeWorkspacePath(session.workspacePath) !== targetPath
-                || !isCodexArchivedFilePath(session.rawStoreRef)) {
-                continue;
-            }
-            archivedFiles.add(session.rawStoreRef);
-        }
-        for (const session of knownSessions) {
-            if (session.isArchived === true
-                || normalizeWorkspacePath(session.workspacePath) !== targetPath) {
-                continue;
-            }
-            const archivedCandidate = this.resolveArchivedSessionCandidate(session.rawStoreRef);
-            if (archivedCandidate) {
-                archivedFiles.add(archivedCandidate);
-            }
-        }
-        if (archivedFiles.size > 0) {
-            return [...archivedFiles].filter((filePath) => existsSync(filePath));
-        }
-        if (threadMetadataIndex.size === 0) {
-            return walkJsonlFiles(join(this.options.homeDir, "archived_sessions"));
-        }
-        return [];
-    }
-    resolveArchivedSessionCandidate(filePath) {
-        if (!filePath || existsSync(filePath)) {
-            return null;
-        }
-        const archivedCandidate = join(this.options.homeDir, "archived_sessions", basename(filePath));
-        if (!existsSync(archivedCandidate)) {
-            return null;
-        }
-        return archivedCandidate;
-    }
-    resolveSessionFilePath(rawStoreRef, providerSessionId) {
-        const matchedByThreadId = this.findSessionFileByThreadId(providerSessionId);
-        if (existsSync(rawStoreRef)) {
-            const boundThreadId = this.readThreadIdFromRawStore(rawStoreRef);
-            if (!boundThreadId || boundThreadId === providerSessionId) {
-                return rawStoreRef;
-            }
-            if (matchedByThreadId) {
-                return matchedByThreadId;
-            }
-            return buildSyntheticCodexHistoryPath(this.options.homeDir, providerSessionId);
-        }
-        const fileName = basename(rawStoreRef) || `${providerSessionId}.jsonl`;
-        const match = fileName.match(/^rollout-(\d{4})-(\d{2})-(\d{2})T.+\.jsonl$/);
-        const candidates = [
-            join(this.options.homeDir, "archived_sessions", fileName),
-            match
-                ? join(this.options.homeDir, "sessions", match[1], match[2], match[3], fileName)
-                : null
-        ].filter((value) => value !== null);
-        const matchedPath = candidates.find((candidate) => existsSync(candidate));
-        if (matchedPath) {
-            return matchedPath;
-        }
-        if (matchedByThreadId) {
-            return matchedByThreadId;
-        }
-        if (isSyntheticCodexHistoryPath(rawStoreRef)) {
-            return rawStoreRef;
-        }
-        return buildSyntheticCodexHistoryPath(this.options.homeDir, providerSessionId);
-    }
-    findSessionFileByThreadId(providerSessionId) {
-        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;
-            }
-        }
-        return null;
-    }
-    readThreadIdFromRawStore(filePath) {
-        if (!existsSync(filePath)) {
-            return null;
-        }
-        const firstLine = readFirstNonEmptyLine(filePath);
-        if (!firstLine) {
-            return null;
-        }
-        try {
-            const record = JSON.parse(firstLine);
-            if (ensureText(record.type).trim() !== "session_meta") {
-                return null;
-            }
-            const threadId = ensureText(record.payload?.id).trim();
-            return threadId.length > 0 ? threadId : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    getParsedMessages(filePath, providerSessionId) {
-        const stats = statSync(filePath);
-        const cached = this.historyCache.get(filePath);
-        if (cached
-            && cached.providerSessionId === providerSessionId
-            && cached.mtimeMs === stats.mtimeMs
-            && cached.size === stats.size) {
-            this.touchHistoryCache(filePath, cached);
-            return cached.messages;
-        }
-        const records = readJsonLines(filePath);
-        const messages = this.parseMessagesFromEntries(filePath, records, providerSessionId);
-        this.touchHistoryCache(filePath, {
-            filePath,
-            providerSessionId,
-            mtimeMs: stats.mtimeMs,
-            size: stats.size,
-            messages
-        });
-        return messages;
-    }
-    touchHistoryCache(filePath, entry) {
-        this.historyCache.delete(filePath);
-        this.historyCache.set(filePath, entry);
-        while (this.historyCache.size > HISTORY_CACHE_LIMIT) {
-            const oldestKey = this.historyCache.keys().next().value;
-            if (!oldestKey) {
-                break;
-            }
-            this.historyCache.delete(oldestKey);
-        }
-    }
-    async buildForkResultFromTransport(input) {
-        const resolvedStoreRef = input.rawStoreRef
-            ? this.resolveSessionFilePath(input.rawStoreRef, input.providerSessionId)
-            : this.findSessionFileByThreadId(input.providerSessionId)
-                ?? buildCodexActiveSessionPath(this.options.homeDir, `${input.providerSessionId}.jsonl`);
-        const messages = existsSync(resolvedStoreRef)
-            ? this.getParsedMessages(resolvedStoreRef, input.providerSessionId)
-            : [];
-        const threadMetadataIndex = this.readThreadMetadataIndex();
-        const threadMetadata = threadMetadataIndex.get(input.providerSessionId) ?? null;
-        const title = this.resolveIndexedTitle(threadMetadataIndex, input.providerSessionId)
-            ?? resolveCodexFallbackTitle(messages)
-            ?? "";
-        return {
-            session: {
-                provider: this.providerId,
-                providerSessionId: input.providerSessionId,
-                title,
-                workspacePath: input.workspacePath,
-                rawStoreRef: resolvedStoreRef,
-                isArchived: resolveCodexArchivedState(threadMetadata, resolvedStoreRef),
-                lastMessageAt: input.lastMessageAtOverride ?? messages.at(-1)?.timestamp ?? nextTimestamp(),
-                messageCount: input.messageCountOverride ?? messages.length,
-                parentProviderSessionId: input.fallbackParentProviderSessionId
-            },
-            forkMethod: input.forkMethod,
-            forkSourceType: input.forkSourceType,
-            inheritedPrefixMessageCount: input.inheritedPrefixMessageCountOverride ?? messages.length,
-            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);
-        while (this.sessionSummaryCache.size > SESSION_SUMMARY_CACHE_LIMIT) {
-            const oldestKey = this.sessionSummaryCache.keys().next().value;
-            if (!oldestKey) {
-                break;
-            }
-            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) {
-            return false;
-        }
-        let childHistory;
-        try {
-            childHistory = extractCodexThreadHistory(childThreadReadResult);
-        }
-        catch {
-            return false;
-        }
-        const childSignatures = collectCodexForkComparableSignatures(childHistory);
-        if (childSignatures.length !== expectedSignatures.length) {
-            return false;
-        }
-        return expectedSignatures.every((signature, index) => childSignatures[index] === signature);
-    }
-    resolveCodexSessionId(metaPayload, providerSessionId) {
-        const metaId = ensureText(metaPayload.id).trim();
-        const normalizedProviderSessionId = ensureText(providerSessionId).trim();
-        if (looksLikeCodexThreadId(metaId)) {
-            return metaId;
-        }
-        const matched = normalizedProviderSessionId.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
-        if (matched?.[1]) {
-            return matched[1];
-        }
-        return metaId || normalizedProviderSessionId;
-    }
-    resolveIndexedTitle(index, sessionId) {
-        const metadata = index.get(sessionId);
-        const indexedTitle = normalizeCodexIndexedTitle(metadata?.title);
-        const normalizedFirstUserMessage = normalizeCodexIndexedTitle(metadata?.firstUserMessage);
-        if (indexedTitle) {
-            // Codex 有时会把第一条用户消息原样回填成 title，这种脏标题仍然按统一长度预算裁掉。
-            if (normalizedFirstUserMessage && indexedTitle === normalizedFirstUserMessage) {
-                return indexedTitle.slice(0, CODEX_SESSION_TITLE_MAX_LENGTH);
-            }
-            return indexedTitle;
-        }
-        return normalizeCodexMessageTitle(metadata?.firstUserMessage);
-    }
-    readSpawnedAgentRelationIndex(files, targetPath, threadMetadataIndex, candidateThreadIds) {
-        const directRelations = new Map();
-        const spawnRecords = [];
-        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;
-            }
-            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) {
-                const relation = {
-                    parentProviderSessionId: sessionIdentity.parentThreadId,
-                    kind: sessionIdentity.parentThreadKind ?? "fork"
-                };
-                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;
-                }
-                const payload = (record.payload ?? {});
-                const payloadType = ensureText(payload.type).trim();
-                if (payloadType === "function_call" && ensureText(payload.name).trim() === "spawn_agent") {
-                    const callId = ensureText(payload.call_id).trim();
-                    const args = parseStructuredJson(ensureText(payload.arguments));
-                    const message = ensureText(args?.message).trim();
-                    if (callId.length === 0 || message.length === 0) {
-                        continue;
-                    }
-                    const spawnRecord = {
-                        parentProviderSessionId: sessionIdentity.threadId,
-                        workspacePath: sessionIdentity.cwd,
-                        message,
-                        timestampMs: toTimestampMs(record.timestamp)
-                    };
-                    spawnCallById.set(callId, spawnRecord);
-                    fileSpawnRecords.push(spawnRecord);
-                    spawnRecords.push(spawnRecord);
-                    continue;
-                }
-                if (payloadType !== "function_call_output") {
-                    continue;
-                }
-                const callId = ensureText(payload.call_id).trim();
-                const spawnRecord = spawnCallById.get(callId);
-                if (!spawnRecord) {
-                    continue;
-                }
-                const agentId = parseCodexAgentIdFromToolOutput(ensureText(payload.output));
-                if (!agentId) {
-                    continue;
-                }
-                const relation = {
-                    parentProviderSessionId: spawnRecord.parentProviderSessionId,
-                    kind: "spawn"
-                };
-                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()]
-            : [...new Set(candidateThreadIds)]
-                .map((threadId) => [threadId, threadMetadataIndex.get(threadId) ?? null])
-                .filter((entry) => entry[1] !== null);
-        for (const [threadId, metadata] of relationCandidates) {
-            if (directRelations.has(threadId)) {
-                continue;
-            }
-            if (!metadata.agentRole && !metadata.agentNickname) {
-                continue;
-            }
-            const firstUserMessage = metadata.firstUserMessage?.trim();
-            const workspacePath = metadata.cwd ? normalizeWorkspacePath(metadata.cwd) : null;
-            if (!firstUserMessage || workspacePath !== targetPath) {
-                continue;
-            }
-            const matchedSpawn = pickClosestCodexSpawnRecord(spawnRecords, workspacePath, firstUserMessage, metadata.createdAtMs);
-            if (!matchedSpawn) {
-                continue;
-            }
-            directRelations.set(threadId, {
-                parentProviderSessionId: matchedSpawn.parentProviderSessionId,
-                kind: "spawn"
-            });
-        }
-        return directRelations;
-    }
-    readSessionIdentity(filePath, fallbackSessionId) {
-        if (!existsSync(filePath)) {
-            return null;
-        }
-        const firstLine = readFirstNonEmptyLine(filePath);
-        if (!firstLine) {
-            return null;
-        }
-        try {
-            const record = JSON.parse(firstLine);
-            if (ensureText(record.type).trim() !== "session_meta") {
-                return null;
-            }
-            const payload = (record.payload ?? {});
-            const parentThreadRelation = resolveCodexParentThreadRelation(payload);
-            return {
-                threadId: this.resolveCodexSessionId(payload, fallbackSessionId),
-                cwd: ensureText(payload.cwd).trim(),
-                parentThreadId: parentThreadRelation.parentThreadId,
-                parentThreadKind: parentThreadRelation.kind
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    hydrateSessionSummary(summary, filePath, stats, metadata, relation) {
-        const resolvedRelation = relation ?? null;
-        const resolvedMetadata = metadata ?? null;
-        const isSubagent = resolvedMetadata || resolvedRelation
-            ? isCodexSubagentThread(resolvedMetadata, resolvedRelation)
-            : Boolean(summary.isSubagent);
-        return {
-            ...summary,
-            rawStoreRef: filePath,
-            isArchived: resolveCodexArchivedState(resolvedMetadata, filePath),
-            parentProviderSessionId: resolvedRelation?.parentProviderSessionId ?? summary.parentProviderSessionId ?? null,
-            isSubagent,
-            subagentLabel: resolvedMetadata !== null
-                ? buildCodexSubagentLabel(resolvedMetadata)
-                : summary.subagentLabel ?? null,
-            sourceMtimeMs: stats.mtimeMs,
-            sourceSizeBytes: stats.size
-        };
-    }
-    parseMessages(filePath, records, providerSessionId) {
-        return this.parseMessagesFromEntries(filePath, records, providerSessionId);
-    }
-    parseMessagesFromEntries(filePath, records, providerSessionId) {
-        const effectiveRecords = filterRolledBackCodexRecords(records);
-        const messages = [];
-        const messageIndexesByKey = new Map();
-        const toolNameById = new Map();
-        const toolInputById = new Map();
-        const commandPatchByCallId = collectCodexCommandPatchesByCallId(effectiveRecords, filePath);
-        let sequence = 0;
-        const pushMessage = (source, message) => {
-            const dedupeKey = buildCodexMessageDedupeKey(message);
-            const candidateIndexes = messageIndexesByKey.get(dedupeKey) ?? [];
-            for (let index = candidateIndexes.length - 1; index >= 0; index -= 1) {
-                const existingIndex = candidateIndexes[index];
-                const existing = messages[existingIndex];
-                if (!isEquivalentCodexMessage(existing.message, message)) {
-                    continue;
-                }
-                const mergedEquivalent = mergeEquivalentCodexMessages(existing.message, existing.source, message, source);
-                if (mergedEquivalent.source !== existing.source
-                    || mergedEquivalent.message.messageId !== existing.message.messageId
-                    || mergedEquivalent.message.rawRef !== existing.message.rawRef
-                    || mergedEquivalent.message.timestamp !== existing.message.timestamp
-                    || JSON.stringify(mergedEquivalent.message.toolCall) !== JSON.stringify(existing.message.toolCall)) {
-                    messages[existingIndex] = {
-                        source: mergedEquivalent.source,
-                        dedupeKey: buildCodexMessageDedupeKey(mergedEquivalent.message),
-                        message: {
-                            ...mergedEquivalent.message,
-                            sequence: existing.message.sequence
-                        }
-                    };
-                }
-                return;
-            }
-            sequence += 1;
-            messageIndexesByKey.set(dedupeKey, [...candidateIndexes, messages.length]);
-            messages.push({
-                source,
-                dedupeKey,
-                message: {
-                    ...message,
-                    sequence
-                }
-            });
-        };
-        effectiveRecords.forEach(({ lineNumber, partIndex, data: record }) => {
-            const rawRef = createRawRef(this.providerId, filePath, lineNumber, partIndex || undefined);
-            if (record.type === "event_msg") {
-                const payload = (record.payload ?? {});
-                const eventType = ensureText(payload.type);
-                if (eventType === "user_message") {
-                    const content = ensureText(payload.message);
-                    if (content.length > 0) {
-                        pushMessage("event_msg", {
-                            messageId: resolveCodexParsedMessageId({
-                                providerSessionId,
-                                rawRef,
-                                role: "user",
-                                kind: "text",
-                                payloadId: payload.id
-                            }),
-                            provider: this.providerId,
-                            providerSessionId,
-                            role: "user",
-                            kind: "text",
-                            content,
-                            toolCall: null,
-                            timestamp: safeDate(record.timestamp, nextTimestamp()),
-                            rawRef
-                        });
-                    }
-                }
-                if (eventType === "agent_message") {
-                    const content = ensureText(payload.message);
-                    if (content.length > 0) {
-                        pushMessage("event_msg", {
-                            messageId: resolveCodexParsedMessageId({
-                                providerSessionId,
-                                rawRef,
-                                role: "assistant",
-                                kind: "text",
-                                payloadId: payload.id
-                            }),
-                            provider: this.providerId,
-                            providerSessionId,
-                            role: "assistant",
-                            kind: "text",
-                            content,
-                            toolCall: null,
-                            timestamp: safeDate(record.timestamp, nextTimestamp()),
-                            rawRef
-                        });
-                    }
-                }
-                if (eventType === "agent_reasoning") {
-                    const content = extractTextBlocks(payload.text ?? payload.message).trim();
-                    if (content.length > 0) {
-                        pushMessage("event_msg", {
-                            messageId: resolveCodexParsedMessageId({
-                                providerSessionId,
-                                rawRef,
-                                role: "assistant",
-                                kind: "thinking",
-                                payloadId: payload.id
-                            }),
-                            provider: this.providerId,
-                            providerSessionId,
-                            role: "assistant",
-                            kind: "thinking",
-                            content,
-                            toolCall: null,
-                            timestamp: safeDate(record.timestamp, nextTimestamp()),
-                            rawRef
-                        });
-                    }
-                }
-            }
-            if (record.type === "response_item") {
-                const payload = (record.payload ?? {});
-                const payloadType = ensureText(payload.type);
-                if (payloadType === "reasoning") {
-                    const content = extractTextFromArray(payload.summary);
-                    if (content.length === 0) {
-                        return;
-                    }
-                    pushMessage("response_item", {
-                        messageId: resolveCodexParsedMessageId({
-                            providerSessionId,
-                            rawRef,
-                            role: "assistant",
-                            kind: "thinking",
-                            payloadId: payload.id
-                        }),
-                        provider: this.providerId,
-                        providerSessionId,
-                        role: "assistant",
-                        kind: "thinking",
-                        content,
-                        toolCall: null,
-                        timestamp: safeDate(record.timestamp, nextTimestamp()),
-                        rawRef
-                    });
-                    return;
-                }
-                if (payloadType === "function_call" || payloadType === "custom_tool_call") {
-                    const callId = ensureText(payload.call_id).trim() || rawRef;
-                    const rawName = ensureText(payload.name).trim() || "tool";
-                    const inputSource = payloadType === "custom_tool_call" ? payload.input : payload.arguments;
-                    const commandPatch = buildApplyPatchFromCodexCommandLikeValue(inputSource) ?? commandPatchByCallId.get(callId) ?? null;
-                    const name = commandPatch ? "apply_patch" : rawName;
-                    const input = commandPatch ?? stringifyStructuredValue(inputSource);
-                    toolNameById.set(callId, name);
-                    toolInputById.set(callId, input);
-                    pushMessage("response_item", {
-                        messageId: resolveCodexParsedMessageId({
-                            providerSessionId,
-                            rawRef,
-                            role: "tool",
-                            kind: "tool_call",
-                            callId
-                        }),
-                        provider: this.providerId,
-                        providerSessionId,
-                        role: "tool",
-                        kind: "tool_call",
-                        content: input,
-                        toolCall: {
-                            callId,
-                            name,
-                            input,
-                            output: null,
-                            error: null,
-                            status: "running"
-                        },
-                        timestamp: safeDate(record.timestamp, nextTimestamp()),
-                        rawRef
-                    });
-                    return;
-                }
-                if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
-                    const callId = ensureText(payload.call_id).trim() || rawRef;
-                    const output = extractTextBlocks(payload.output).trim() || stringifyStructuredValue(payload.output);
-                    const outputPatch = buildApplyPatchFromCodexCommandLikeValue(payload.output);
-                    const name = outputPatch ? "apply_patch" : (toolNameById.get(callId) ?? "tool");
-                    const input = resolveCodexCommandPatchResultInput(outputPatch, toolInputById.get(callId));
-                    const resultState = resolveToolResultState(payload, output);
-                    pushMessage("response_item", {
-                        messageId: resolveCodexParsedMessageId({
-                            providerSessionId,
-                            rawRef,
-                            role: "tool",
-                            kind: "tool_result",
-                            callId
-                        }),
-                        provider: this.providerId,
-                        providerSessionId,
-                        role: "tool",
-                        kind: "tool_result",
-                        content: output,
-                        toolCall: {
-                            callId,
-                            name,
-                            input,
-                            output: resultState.status === "failed" ? null : output,
-                            error: resultState.status === "failed" ? output : null,
-                            status: resultState.status
-                        },
-                        timestamp: safeDate(record.timestamp, nextTimestamp()),
-                        rawRef
-                    });
-                    return;
-                }
-                if (payloadType !== "message") {
-                    return;
-                }
-                const role = ensureText(payload.role);
-                const content = extractTextFromArray(payload.content);
-                if (content.length === 0 || (role !== "assistant" && role !== "user")) {
-                    return;
-                }
-                pushMessage("response_item", {
-                    messageId: resolveCodexParsedMessageId({
-                        providerSessionId,
-                        rawRef,
-                        role,
-                        kind: "text",
-                        payloadId: payload.id
-                    }),
-                    provider: this.providerId,
-                    providerSessionId,
-                    role,
-                    kind: "text",
-                    content,
-                    toolCall: null,
-                    timestamp: safeDate(record.timestamp, nextTimestamp()),
-                    rawRef
-                });
-            }
-        });
-        return messages.map((entry) => entry.message);
-    }
-}
-function resolveCodexCommandPatchResultInput(outputPatch, storedInput) {
-    if (!outputPatch) {
-        return storedInput ?? "";
-    }
-    if (storedInput && isCodexPatchWithHunks(storedInput) && !isCodexPatchWithHunks(outputPatch)) {
-        return storedInput;
-    }
-    return outputPatch;
-}
-function isCodexPatchWithHunks(value) {
-    return /(?:^|\n)@@\s/.test(value);
-}
-function collectCodexCommandPatchesByCallId(records, filePath) {
-    const patches = new Map();
-    for (const { lineNumber, partIndex, data: record } of records) {
-        if (record.type !== "response_item") {
-            continue;
-        }
-        const payload = (record.payload ?? {});
-        const payloadType = ensureText(payload.type).trim();
-        if (payloadType !== "function_call_output" && payloadType !== "custom_tool_call_output") {
-            continue;
-        }
-        const rawRef = createRawRef("codex", filePath, lineNumber, partIndex || undefined);
-        const callId = ensureText(payload.call_id).trim() || rawRef;
-        const patchText = buildApplyPatchFromCodexCommandLikeValue(payload.output);
-        if (patchText && !patches.has(callId)) {
-            patches.set(callId, patchText);
-        }
-    }
-    return patches;
-}
-function filterRolledBackCodexRecords(records) {
-    const completedTurnSegments = [];
-    let activeTurnStartLineNumber = null;
-    let sawRollbackEvent = false;
-    for (const recordEntry of records) {
-        const record = recordEntry.data;
-        if (record.type !== "event_msg") {
-            continue;
-        }
-        const payload = (record.payload ?? {});
-        const eventType = ensureText(payload.type).trim();
-        if (eventType === "task_started") {
-            activeTurnStartLineNumber = recordEntry.lineNumber;
-            continue;
-        }
-        if (eventType === "task_complete" || eventType === "task_failed") {
-            if (activeTurnStartLineNumber !== null) {
-                completedTurnSegments.push({
-                    startLineNumber: activeTurnStartLineNumber,
-                    endLineNumber: recordEntry.lineNumber,
-                    rolledBack: false
-                });
-            }
-            activeTurnStartLineNumber = null;
-            continue;
-        }
-        if (eventType !== "thread_rolled_back") {
-            continue;
-        }
-        sawRollbackEvent = true;
-        const requestedTurnCount = Math.max(0, Math.trunc(typeof payload.num_turns === "number"
-            ? payload.num_turns
-            : Number.parseInt(ensureText(payload.num_turns), 10)) || 0);
-        if (requestedTurnCount <= 0) {
-            continue;
-        }
-        let remainingTurnsToRollback = requestedTurnCount;
-        for (let index = completedTurnSegments.length - 1; index >= 0; index -= 1) {
-            const segment = completedTurnSegments[index];
-            if (!segment || segment.rolledBack) {
-                continue;
-            }
-            segment.rolledBack = true;
-            remainingTurnsToRollback -= 1;
-            if (remainingTurnsToRollback <= 0) {
-                break;
-            }
-        }
-    }
-    if (!sawRollbackEvent) {
-        return records;
-    }
-    const rolledBackSegments = completedTurnSegments
-        .filter((segment) => segment.rolledBack)
-        .sort((left, right) => left.startLineNumber - right.startLineNumber);
-    if (rolledBackSegments.length === 0) {
-        return records;
-    }
-    const filteredRecords = [];
-    let segmentIndex = 0;
-    for (const recordEntry of records) {
-        while (segmentIndex < rolledBackSegments.length
-            && recordEntry.lineNumber > rolledBackSegments[segmentIndex].endLineNumber) {
-            segmentIndex += 1;
-        }
-        const activeSegment = segmentIndex < rolledBackSegments.length ? rolledBackSegments[segmentIndex] : null;
-        if (activeSegment
-            && recordEntry.lineNumber >= activeSegment.startLineNumber
-            && recordEntry.lineNumber <= activeSegment.endLineNumber) {
-            continue;
-        }
-        filteredRecords.push(recordEntry);
-    }
-    return filteredRecords;
-}
-function buildRecentHistoryPage(messages, totalMessageCount, limit) {
-    const effectiveTotal = Math.max(totalMessageCount, messages.length);
-    const pageMessages = messages.slice(-Math.min(limit, messages.length)).map((message, index, items) => ({
-        ...message,
-        sequence: effectiveTotal - items.length + index + 1
-    }));
-    const nextCursor = effectiveTotal > pageMessages.length
-        ? encodeCursor(effectiveTotal - pageMessages.length)
-        : null;
-    return {
-        messages: pageMessages,
-        cursor: encodeCursor(effectiveTotal),
-        nextCursor,
-        total: effectiveTotal
-    };
-}
-function buildCodexMessageDedupeKey(message) {
-    const comparable = toComparableCodexMessage(message);
-    return JSON.stringify({
-        role: comparable.role,
-        kind: comparable.kind,
-        content: comparable.content,
-        toolCall: comparable.toolCall
-            ? {
-                callId: comparable.toolCall.callId,
-                name: comparable.toolCall.name,
-                input: comparable.toolCall.input,
-                output: comparable.toolCall.output,
-                error: comparable.toolCall.error,
-                status: comparable.toolCall.status
-            }
-            : null
-    });
-}
-function mergeEquivalentCodexMessages(current, currentSource, incoming, incomingSource) {
-    const preferredBySource = codexMessageSourcePriority(incomingSource) > codexMessageSourcePriority(currentSource)
-        ? incoming
-        : current;
-    const preferredSource = codexMessageSourcePriority(incomingSource) > codexMessageSourcePriority(currentSource)
-        ? incomingSource
-        : currentSource;
-    const preferredStableMessageId = pickPreferredCodexEquivalentMessageId(current, incoming);
-    return {
-        source: preferredSource,
-        message: {
-            ...preferredBySource,
-            messageId: preferredStableMessageId
-        }
-    };
-}
-function pickPreferredCodexEquivalentMessageId(current, incoming) {
-    const currentUsesStableIdentity = current.messageId !== messageIdFromRawRef(current.rawRef);
-    const incomingUsesStableIdentity = incoming.messageId !== messageIdFromRawRef(incoming.rawRef);
-    if (currentUsesStableIdentity !== incomingUsesStableIdentity) {
-        return currentUsesStableIdentity ? current.messageId : incoming.messageId;
-    }
-    return incoming.messageId;
-}
-function resolveCodexFallbackTitle(messages) {
-    const preferredMessage = messages.find((message) => message.role === "user" && !looksLikeCodexRulesMessage(message.content));
-    if (preferredMessage) {
-        return normalizeCodexMessageTitle(preferredMessage.content);
-    }
-    const firstUserMessage = messages.find((message) => message.role === "user");
-    return normalizeCodexMessageTitle(firstUserMessage?.content);
-}
-function looksLikeCodexRulesMessage(content) {
-    const normalized = content.trim();
-    const beginsWithRulesHeader = /^#?\s*AGENTS\.md instructions for\b/i.test(normalized);
-    if (beginsWithRulesHeader) {
-        return true;
-    }
-    return /AGENTS\.md instructions for/i.test(normalized)
-        && /<INSTRUCTIONS>/i.test(normalized);
-}
-function codexMessageSourcePriority(source) {
-    return source === "response_item" ? 2 : 1;
-}
-function isEquivalentCodexMessage(left, right) {
-    const comparableLeft = toComparableCodexMessage(left);
-    const comparableRight = toComparableCodexMessage(right);
-    if (comparableLeft.role !== comparableRight.role ||
-        comparableLeft.kind !== comparableRight.kind ||
-        comparableLeft.content !== comparableRight.content) {
-        return false;
-    }
-    if (JSON.stringify(comparableLeft.toolCall) !== JSON.stringify(comparableRight.toolCall)) {
-        return false;
-    }
-    return areCodexTimestampsNear(left.timestamp, right.timestamp);
-}
-function toComparableCodexMessage(message) {
-    return {
-        role: message.role,
-        kind: message.kind,
-        content: normalizeComparableCodexContent(message.kind, message.content),
-        toolCall: message.toolCall
-            ? {
-                callId: message.toolCall.callId,
-                name: message.toolCall.name,
-                input: normalizeComparableCodexLineEndings(message.toolCall.input),
-                output: message.toolCall.output === null
-                    ? null
-                    : normalizeComparableCodexLineEndings(message.toolCall.output),
-                error: message.toolCall.error === null
-                    ? null
-                    : normalizeComparableCodexLineEndings(message.toolCall.error),
-                status: message.toolCall.status
-            }
-            : null
-    };
-}
-function normalizeComparableCodexContent(kind, content) {
-    const normalized = normalizeComparableCodexLineEndings(content);
-    if (kind === "text" || kind === "thinking") {
-        return normalized.trimEnd();
-    }
-    return normalized;
-}
-function normalizeComparableCodexLineEndings(content) {
-    return content.replace(/\r\n/g, "\n");
-}
-function areCodexTimestampsNear(left, right) {
-    const leftMs = Date.parse(left);
-    const rightMs = Date.parse(right);
-    if (!Number.isFinite(leftMs) || !Number.isFinite(rightMs)) {
-        return 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 "";
-    }
-    return value
-        .map((item) => extractTextBlocks(item).trim())
-        .filter((item) => item.length > 0)
-        .join("\n");
-}
-function resolveToolResultState(payload, output) {
-    const statusText = ensureText(payload.status).trim().toLowerCase();
-    if (statusText === "failed" || statusText === "error") {
-        return { status: "failed" };
-    }
-    if (output.toLowerCase().includes("apply_patch was requested via exec_command")) {
-        return { status: "failed" };
-    }
-    if (statusText === "completed" || statusText === "success" || statusText === "succeeded") {
-        return { status: "completed" };
-    }
-    if (typeof payload.success === "boolean") {
-        return {
-            status: payload.success ? "completed" : "failed"
-        };
-    }
-    if (typeof payload.is_error === "boolean") {
-        return {
-            status: payload.is_error ? "failed" : "completed"
-        };
-    }
-    if (typeof payload.exit_code === "number") {
-        return {
-            status: payload.exit_code === 0 ? "completed" : "failed"
-        };
-    }
-    const exitCodeMatch = output.match(/(?:^|\n)Exit code:\s*(-?\d+)/i);
-    if (exitCodeMatch) {
-        return {
-            status: Number(exitCodeMatch[1]) === 0 ? "completed" : "failed"
-        };
-    }
-    if (payload.error != null) {
-        return { status: "failed" };
-    }
-    return { status: "completed" };
-}
-function shouldIgnoreCodingNsDraftSession(metaPayload) {
-    const source = ensureText(metaPayload.source).trim().toLowerCase();
-    const sessionId = ensureText(metaPayload.id).trim().toLowerCase();
-    return source === "codingns" && sessionId.startsWith("rollout-");
-}
-function looksLikeCodexThreadId(value) {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
-function findLatestCodexStateDatabase(homeDir) {
-    if (!existsSync(homeDir)) {
-        return null;
-    }
-    const candidates = readdirSync(homeDir, { withFileTypes: true })
-        .filter((entry) => entry.isFile() && /^state_\d+\.sqlite$/i.test(entry.name))
-        .map((entry) => {
-        const filePath = join(homeDir, entry.name);
-        return {
-            filePath,
-            mtimeMs: statSync(filePath).mtimeMs
-        };
-    })
-        .sort((left, right) => right.mtimeMs - left.mtimeMs);
-    return candidates[0]?.filePath ?? null;
-}
-function parseStructuredJson(value) {
-    const text = value.trim();
-    if (text.length === 0) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(text);
-        return parsed && typeof parsed === "object" ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-function readNonNegativeInteger(value) {
-    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
-        return Math.trunc(value);
-    }
-    if (typeof value === "string" && /^\d+$/.test(value.trim())) {
-        return Number.parseInt(value.trim(), 10);
-    }
-    return null;
-}
-function clampUsageRatio(promptTokens, contextWindow) {
-    if (contextWindow <= 0) {
-        return 0;
-    }
-    return Math.min(Math.max(promptTokens / contextWindow, 0), 1);
-}
-function resolveCodexKnownContextWindow(modelId) {
-    if (!modelId) {
-        return null;
-    }
-    return KNOWN_CODEX_CONTEXT_WINDOWS.get(modelId) ?? null;
-}
-function readCodexConfigContextWindow(homeDir) {
-    const configPath = join(homeDir, "config.toml");
-    if (!existsSync(configPath)) {
-        return null;
-    }
-    try {
-        const content = readFileSync(configPath, "utf8");
-        const matched = content.match(CODEX_CONFIG_CONTEXT_WINDOW_PATTERN);
-        if (!matched?.[1]) {
-            return null;
-        }
-        return Number.parseInt(matched[1], 10);
-    }
-    catch {
-        return null;
-    }
-}
-function parseCodexAgentIdFromToolOutput(output) {
-    const parsed = parseStructuredJson(output);
-    const agentId = ensureText(parsed?.agent_id ?? parsed?.agentId).trim();
-    if (looksLikeCodexThreadId(agentId)) {
-        return agentId;
-    }
-    const matched = output.match(/"agent(?:_id|Id)"\s*:\s*"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"/i);
-    return matched?.[1] ?? null;
-}
-function resolveCodexParentThreadRelation(payload) {
-    const source = typeof payload.source === "object" && payload.source !== null
-        ? payload.source
-        : null;
-    const subagent = typeof source?.subagent === "object" && source.subagent !== null
-        ? source.subagent
-        : null;
-    const threadSpawn = typeof subagent?.thread_spawn === "object" && subagent.thread_spawn !== null
-        ? subagent.thread_spawn
-        : null;
-    const nestedParentThreadId = ensureText(threadSpawn?.parent_thread_id).trim();
-    if (nestedParentThreadId.length > 0) {
-        return {
-            parentThreadId: nestedParentThreadId,
-            kind: "spawn"
-        };
-    }
-    const directParentThreadId = ensureText(payload.forked_from_id).trim();
-    if (directParentThreadId.length > 0) {
-        return {
-            parentThreadId: directParentThreadId,
-            kind: "fork"
-        };
-    }
-    return {
-        parentThreadId: null,
-        kind: null
-    };
-}
-function toTimestampMs(value) {
-    const timestampMs = Date.parse(ensureText(value).trim());
-    return Number.isFinite(timestampMs) ? timestampMs : null;
-}
-function pickClosestCodexSpawnRecord(spawnRecords, workspacePath, message, createdAtMs) {
-    const matchedRecords = spawnRecords.filter((record) => record.workspacePath !== null &&
-        normalizeWorkspacePath(record.workspacePath) === workspacePath &&
-        record.message === message);
-    if (matchedRecords.length === 0) {
-        return null;
-    }
-    if (createdAtMs === null) {
-        return matchedRecords.at(-1) ?? null;
-    }
-    const closeRecord = matchedRecords
-        .filter((record) => record.timestampMs !== null)
-        .sort((left, right) => Math.abs((left.timestampMs ?? createdAtMs) - createdAtMs) -
-        Math.abs((right.timestampMs ?? createdAtMs) - createdAtMs))
-        .find((record) => Math.abs((record.timestampMs ?? createdAtMs) - createdAtMs) <= 120_000);
-    return closeRecord ?? matchedRecords.at(-1) ?? null;
-}
-function isCodexSubagentThread(metadata, relation) {
-    return Boolean(relation?.kind === "spawn" || metadata?.agentRole || metadata?.agentNickname);
-}
-function buildCodexSubagentLabel(metadata) {
-    const agentRole = metadata?.agentRole?.trim() || "";
-    const agentNickname = metadata?.agentNickname?.trim() || "";
-    if (agentRole && agentNickname) {
-        return `${agentRole} · ${agentNickname}`;
-    }
-    return agentNickname || agentRole || null;
-}
-function resolveCodexArchivedState(metadata, filePath) {
-    if (isCodexArchivedFilePath(filePath)) {
-        return true;
-    }
-    if (typeof metadata?.isArchived === "boolean") {
-        return metadata.isArchived;
-    }
-    return false;
-}
-function isCodexArchivedFilePath(filePath) {
-    return filePath.replaceAll("\\", "/").includes("/archived_sessions/");
-}
-function buildCodexActiveSessionPath(homeDir, fileName) {
-    const match = fileName.match(/^rollout-(\d{4})-(\d{2})-(\d{2})T.+\.jsonl$/);
-    if (!match) {
-        return join(homeDir, "sessions", fileName);
-    }
-    return join(homeDir, "sessions", match[1], match[2], match[3], fileName);
-}
-function buildSyntheticCodexHistoryPath(homeDir, providerSessionId) {
-    return join(homeDir, "runtime", "codex", `${providerSessionId}.jsonl`);
-}
-function isSyntheticCodexHistoryPath(rawStoreRef) {
-    const normalized = rawStoreRef.replaceAll("\\", "/").toLowerCase();
-    return normalized.includes("/runtime/codex/") || normalized.startsWith("runtime/codex/");
-}
-function hasUsableCodexTitle(title) {
-    return normalizeCodexIndexedTitle(title) !== null;
-}
-function normalizeCodexIndexedTitle(title) {
-    const normalized = ensureText(title).trim();
-    if (normalized.length === 0 || looksLikeCodexRulesMessage(normalized)) {
-        return null;
-    }
-    return normalized;
-}
-function normalizeCodexMessageTitle(content) {
-    const normalized = normalizeCodexIndexedTitle(content);
-    return normalized ? normalized.slice(0, CODEX_SESSION_TITLE_MAX_LENGTH) : null;
-}
-function extractCodexThreadHistory(result) {
-    const snapshot = extractCodexThreadHistorySnapshot(result);
-    return snapshot.value;
-}
-function extractCodexThreadHistorySnapshot(result) {
-    const directHistory = pickCodexHistoryArray(result)
-        ?? pickCodexHistoryArray(toRecord(result.thread))
-        ?? pickCodexHistoryArray(toRecord(result.data));
-    if (directHistory) {
-        return {
-            kind: "entries",
-            value: directHistory,
-            comparableEntries: directHistory.flatMap((entry, entryIndex) => {
-                const signature = buildCodexThreadHistorySignature(entry);
-                return signature ? [{ signature, entryIndex }] : [];
-            })
-        };
-    }
-    const turns = pickCodexTurnArray(result.turns)
-        ?? pickCodexTurnArray(toRecord(result.thread)?.turns)
-        ?? pickCodexTurnArray(toRecord(result.data)?.turns);
-    if (!turns) {
-        throw new Error("CODEX_THREAD_HISTORY_MISSING");
-    }
-    const comparableEntries = turns.flatMap((turn, turnIndex) => collectCodexTurnComparableEntries(turn, turnIndex));
-    if (comparableEntries.length === 0) {
-        throw new Error("CODEX_THREAD_HISTORY_MISSING");
-    }
-    return {
-        kind: "turns",
-        value: turns,
-        comparableEntries
-    };
-}
-function isSyntheticCodexSessionTitle(title) {
-    const normalizedTitle = ensureText(title).trim();
-    if (normalizedTitle.length === 0) {
-        return false;
-    }
-    return (/^rollout-\d{4}-\d{2}-\d{2}t/i.test(normalizedTitle) ||
-        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(normalizedTitle));
-}
-function pickCodexHistoryArray(value) {
-    const record = toRecord(value);
-    if (!record) {
-        return null;
-    }
-    for (const key of ["history", "items"]) {
-        const candidate = record[key];
-        if (Array.isArray(candidate)
-            && candidate.some((entry) => buildCodexThreadHistorySignature(entry) !== null)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function pickCodexTurnArray(value) {
-    return Array.isArray(value) ? value : null;
-}
-function collectCodexTurnComparableEntries(value, turnIndex, parentPath = []) {
-    const record = toRecord(value);
-    if (!record) {
-        return [];
-    }
-    for (const key of ["history", "items"]) {
-        const candidate = record[key];
-        if (Array.isArray(candidate)
-            && candidate.some((entry) => buildCodexThreadHistorySignature(entry) !== null)) {
-            const containerPath = [...parentPath, key];
-            return candidate.flatMap((entry, entryIndex) => {
-                const signature = buildCodexThreadHistorySignature(entry);
-                return signature
-                    ? [{
-                            signature,
-                            turnIndex,
-                            containerPath,
-                            entryIndex
-                        }]
-                    : [];
-            });
-        }
-    }
-    return [
-        ["input", record.input],
-        ["output", record.output],
-        ["turn", record.turn],
-        ["data", record.data],
-        ["result", record.result]
-    ].flatMap(([key, candidate]) => collectCodexTurnComparableEntries(candidate, turnIndex, [...parentPath, key]));
-}
-function toRecord(value) {
-    return typeof value === "object" && value !== null
-        ? value
-        : null;
-}
-function truncateCodexThreadHistory(history, parsedMessages, targetMessage) {
-    const snapshot = normalizeCodexThreadHistorySnapshot(history);
-    if (snapshot.kind === "entries") {
-        const targetEntry = resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage);
-        return snapshot.value.slice(0, targetEntry.entryIndex + 1);
-    }
-    const targetEntry = resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage);
-    const truncatedTurns = snapshot.value.slice(0, targetEntry.turnIndex + 1);
-    const lastTurn = truncatedTurns.at(-1);
-    if (!lastTurn) {
-        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
-    }
-    return [
-        ...flattenCodexTurnHistory(truncatedTurns.slice(0, -1)),
-        ...collectCodexTurnHistoryItems(truncateCodexTurnAtPath(lastTurn, targetEntry.containerPath, targetEntry.entryIndex))
-    ];
-}
-function normalizeCodexThreadHistorySnapshot(history) {
-    const directComparableEntries = history.flatMap((entry, entryIndex) => {
-        const signature = buildCodexThreadHistorySignature(entry);
-        return signature ? [{ signature, entryIndex }] : [];
-    });
-    if (directComparableEntries.length > 0) {
-        return {
-            kind: "entries",
-            value: history,
-            comparableEntries: directComparableEntries
-        };
-    }
-    const turnComparableEntries = history.flatMap((turn, turnIndex) => collectCodexTurnComparableEntries(turn, turnIndex));
-    if (turnComparableEntries.length > 0) {
-        return {
-            kind: "turns",
-            value: history,
-            comparableEntries: turnComparableEntries
-        };
-    }
-    throw new Error("CODEX_THREAD_HISTORY_MISSING");
-}
-function resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage) {
-    const targetSignature = buildCodexThreadHistorySignature(targetMessage);
-    if (!targetSignature) {
-        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
-    }
-    const matchingEntries = snapshot.comparableEntries.filter((entry) => entry.signature === targetSignature);
-    if (matchingEntries.length === 0) {
-        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
-    }
-    const targetOccurrence = resolveCodexMessageSignatureOccurrence(parsedMessages, targetMessage);
-    return matchingEntries[Math.min(targetOccurrence, matchingEntries.length) - 1] ?? matchingEntries.at(-1);
-}
-function resolveCodexMessageSignatureOccurrence(parsedMessages, targetMessage) {
-    const targetSignature = buildCodexThreadHistorySignature(targetMessage);
-    if (!targetSignature) {
-        return 1;
-    }
-    let occurrence = 0;
-    for (const message of parsedMessages) {
-        if (buildCodexThreadHistorySignature(message) !== targetSignature) {
-            continue;
-        }
-        occurrence += 1;
-        if (message.messageId === targetMessage.messageId) {
-            return occurrence;
-        }
-    }
-    return Math.max(1, occurrence);
-}
-function buildCodexTurnRollbackPlan(snapshot, parsedMessages, targetMessage) {
-    const targetEntry = resolveCodexThreadHistoryTargetEntry(snapshot, parsedMessages, targetMessage);
-    const turnEntries = snapshot.comparableEntries.filter((entry) => entry.turnIndex === targetEntry.turnIndex);
-    const lastComparableEntryInTurn = turnEntries.at(-1) ?? null;
-    if (!lastComparableEntryInTurn) {
-        throw new Error("CODEX_FORK_SOURCE_MESSAGE_UNMAPPABLE");
-    }
-    if (lastComparableEntryInTurn.containerPath.join("/") !== targetEntry.containerPath.join("/")
-        || lastComparableEntryInTurn.entryIndex !== targetEntry.entryIndex) {
-        throw new Error("CODEX_MESSAGE_FORK_TURN_BOUNDARY_REQUIRED");
-    }
-    return {
-        targetTurnIndex: targetEntry.turnIndex,
-        numTurnsToRollback: Math.max(0, snapshot.value.length - targetEntry.turnIndex - 1)
-    };
-}
-function truncateCodexTurnAtPath(turn, containerPath, entryIndex) {
-    if (containerPath.length === 0) {
-        return turn;
-    }
-    const record = toRecord(turn);
-    if (!record) {
-        return turn;
-    }
-    const [head, ...rest] = containerPath;
-    const current = record[head];
-    if (rest.length === 0) {
-        if (!Array.isArray(current)) {
-            return turn;
-        }
-        return {
-            ...record,
-            [head]: current.slice(0, entryIndex + 1)
-        };
-    }
-    return {
-        ...record,
-        [head]: truncateCodexTurnAtPath(current, rest, entryIndex)
-    };
-}
-function flattenCodexTurnHistory(turns) {
-    return turns.flatMap((turn) => collectCodexTurnHistoryItems(turn));
-}
-function collectCodexTurnHistoryItems(value) {
-    const direct = pickCodexHistoryArray(value);
-    if (direct) {
-        return direct;
-    }
-    const record = toRecord(value);
-    if (!record) {
-        return [];
-    }
-    return [
-        record.input,
-        record.output,
-        record.turn,
-        record.data,
-        record.result
-    ].flatMap((candidate) => collectCodexTurnHistoryItems(candidate));
-}
-function buildCodexThreadHistorySignature(value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const item = value;
-    const normalizedKind = ensureText(item.kind).trim();
-    const normalizedRole = ensureText(item.role).trim();
-    const normalizedContent = ensureText(item.content).trim();
-    if (normalizedKind && normalizedRole) {
-        return `${normalizedRole}:${normalizedKind}:${normalizedContent}`;
-    }
-    const type = ensureText(item.type).trim();
-    if (type === "userMessage") {
-        const content = stringifyCodexThreadMessageContent(item.content);
-        return content ? `user:text:${content}` : null;
-    }
-    if (type === "agentMessage") {
-        const content = ensureText(item.text).trim() || stringifyCodexThreadMessageContent(item.content);
-        return content ? `assistant:text:${content}` : null;
-    }
-    if (type === "message") {
-        const role = ensureText(item.role).trim();
-        const content = stringifyCodexThreadMessageContent(item.content);
-        if (!role || !content) {
-            return null;
-        }
-        return `${role}:text:${content}`;
-    }
-    if (type === "reasoning") {
-        const content = stringifyCodexReasoningContent(item.summary ?? item.content);
-        return content ? `assistant:thinking:${content}` : null;
-    }
-    if (type === "function_call" || type === "tool_call") {
-        const name = ensureText(item.name).trim();
-        const inputValue = item.arguments ?? item.input;
-        const content = stringifyStructuredValue(inputValue);
-        return name || content ? `assistant:tool_call:${name}:${content}` : null;
-    }
-    if (type === "function_call_output" || type === "tool_result") {
-        const content = ensureText(item.output ?? item.content).trim();
-        return content ? `tool:tool_result:${content}` : null;
-    }
-    if (normalizedRole && normalizedContent) {
-        return `${normalizedRole}:text:${normalizedContent}`;
-    }
-    return null;
-}
-function applyForkSourceMessageSnapshot(targetMessage, snapshot) {
-    if (!snapshot) {
-        return targetMessage;
-    }
-    return {
-        ...targetMessage,
-        role: snapshot.role,
-        kind: snapshot.kind,
-        content: snapshot.content
-    };
-}
-function collectCodexForkComparableSignatures(history) {
-    try {
-        return normalizeCodexThreadHistorySnapshot(history).comparableEntries.map((entry) => entry.signature);
-    }
-    catch {
-        return [];
-    }
-}
-function stringifyCodexThreadMessageContent(content) {
-    if (typeof content === "string") {
-        return content.trim();
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content
-        .map((part) => {
-        if (!part || typeof part !== "object") {
-            return "";
-        }
-        const record = part;
-        return ensureText(record.text
-            ?? record.input_text
-            ?? record.output_text
-            ?? (ensureText(record.type).trim() === "text" ? record.text : null)).trim();
-    })
-        .filter((value) => value.length > 0)
-        .join("\n")
-        .trim();
-}
-function stringifyCodexReasoningContent(content) {
-    if (typeof content === "string") {
-        return content.trim();
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content
-        .map((part) => {
-        if (!part || typeof part !== "object") {
-            return "";
-        }
-        const record = part;
-        return ensureText(record.text ?? record.summary_text).trim();
-    })
-        .filter((value) => value.length > 0)
-        .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