yepanywhere 0.5.2 → 0.6.0

package/dist/sessions/codex-reader.js

@@ -10,14 +10,53 @@
  *
  * Unlike Claude's DAG structure, Codex sessions are linear.
  */
+import { createHash, randomUUID } from "node:crypto";
 import { open, readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { getModelContextWindow, parseCodexSessionEntry, truncateSessionTitle, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
-import { canonicalizeProjectPath } from "../projects/paths.js";
-import { readFirstLine, readJsonlLines } from "../utils/jsonl.js";
-const CODEX_META_READ_MAX_BYTES = 1024 * 1024;
+import { getLogger } from "../logging/logger.js";
+import { canonicalizeProjectPath, getProjectIdentityKey, } from "../projects/paths.js";
+import { codexRolloutRepresentation, isCodexRolloutFileName, preferPlainCodexRollouts, } from "../utils/codexRolloutFiles.js";
+import { iterateJsonlLines, readJsonlLines } from "../utils/jsonl.js";
+import { createCodexSessionDiscoveryIndex, createCodexRolloutDiscoveryStats, readCodexRolloutMetadata, } from "./codex-discovery.js";
+import { normalizeSession } from "./normalization.js";
+import { SummaryParserClient } from "./summary-parser-worker-client.js";
 const CODEX_SCAN_CACHE_TTL_MS = 5000;
+const DEFAULT_SLOW_LOG_THRESHOLD_MS = 250;
+const CODEX_HEAD_SUMMARY_MAX_LINES = 200;
+const CODEX_HEAD_SUMMARY_MAX_BYTES = 1024 * 1024;
+const CODEX_FULL_SUMMARY_CACHE_MAX_ENTRIES = 256;
+const LOG_ENTRY_READS = process.env.CODEX_READER_LOG_PARSE === "true";
+function isCompressedCodexSessionFile(filePath) {
+    return filePath.endsWith(".jsonl.zst");
+}
 const codexSharedScanCache = new Map();
+const codexFullSummaryCache = new Map();
+function getCodexFullSummaryCacheKey(filePath, stats) {
+    return `${filePath}\0${Number(stats.mtimeMs)}\0${Number(stats.size)}`;
+}
+function cloneSessionSummary(summary) {
+    if (!summary)
+        return null;
+    return {
+        ...summary,
+        ownership: { ...summary.ownership },
+        ...(summary.contextUsage
+            ? { contextUsage: { ...summary.contextUsage } }
+            : {}),
+    };
+}
+function trimCodexFullSummaryCache() {
+    if (codexFullSummaryCache.size <= CODEX_FULL_SUMMARY_CACHE_MAX_ENTRIES) {
+        return;
+    }
+    const entriesToDelete = Array.from(codexFullSummaryCache.entries())
+        .sort((left, right) => left[1].lastAccessedAt - right[1].lastAccessedAt)
+        .slice(0, codexFullSummaryCache.size - CODEX_FULL_SUMMARY_CACHE_MAX_ENTRIES);
+    for (const [cacheKey] of entriesToDelete) {
+        codexFullSummaryCache.delete(cacheKey);
+    }
+}
 function parseCodexJsonlChunk(chunk, mayEndWithPartialLine) {
     const lines = chunk.split("\n");
     const partialLine = mayEndWithPartialLine ? (lines.pop() ?? "") : "";
@@ -34,6 +73,94 @@ function parseCodexJsonlChunk(chunk, mayEndWithPartialLine) {
     }
     return { entries, partialLine };
 }
+function getCodexMessagePayloadText(content) {
+    return content
+        .map((block) => (typeof block.text === "string" ? block.text : block.type))
+        .join("\n");
+}
+function getCodexEntryDedupeKey(entry) {
+    if (entry.type === "response_item") {
+        const { payload } = entry;
+        if (payload.type === "message") {
+            return [
+                entry.type,
+                entry.timestamp,
+                payload.type,
+                payload.role,
+                getCodexMessagePayloadText(payload.content),
+            ].join("\n");
+        }
+        return null;
+    }
+    if (entry.type === "event_msg") {
+        const { payload } = entry;
+        if (payload.type === "user_message" || payload.type === "agent_message") {
+            return [entry.type, entry.timestamp, payload.type, payload.message].join("\n");
+        }
+    }
+    return null;
+}
+function getCodexSummaryDedupeKey(entry) {
+    if (entry.type === "response_item") {
+        const { payload } = entry;
+        if (payload.type !== "message") {
+            return null;
+        }
+        const hash = createHash("sha256");
+        hash.update(entry.type);
+        hash.update("\0");
+        hash.update(entry.timestamp);
+        hash.update("\0");
+        hash.update(payload.type);
+        hash.update("\0");
+        hash.update(payload.role);
+        hash.update("\0");
+        payload.content.forEach((block, index) => {
+            if (index > 0)
+                hash.update("\n");
+            hash.update("text" in block && typeof block.text === "string"
+                ? block.text
+                : block.type);
+        });
+        return hash.digest("base64url");
+    }
+    if (entry.type === "event_msg") {
+        const { payload } = entry;
+        if (payload.type !== "user_message" && payload.type !== "agent_message") {
+            return null;
+        }
+        const hash = createHash("sha256");
+        hash.update(entry.type);
+        hash.update("\0");
+        hash.update(entry.timestamp);
+        hash.update("\0");
+        hash.update(payload.type);
+        hash.update("\0");
+        hash.update(payload.message);
+        return hash.digest("base64url");
+    }
+    return null;
+}
+function dedupeCodexEntries(entries) {
+    const seen = new Set();
+    let deduped = null;
+    entries.forEach((entry, index) => {
+        const key = getCodexEntryDedupeKey(entry);
+        if (!key) {
+            deduped?.push(entry);
+            return;
+        }
+        if (seen.has(key)) {
+            if (!deduped) {
+                deduped = entries.slice(0, index);
+            }
+            return;
+        }
+        seen.add(key);
+        deduped?.push(entry);
+    });
+    return deduped ?? entries;
+}
 /**
  * Codex-specific session reader for Codex CLI JSONL files.
  *
@@ -43,6 +170,14 @@ function parseCodexJsonlChunk(chunk, mayEndWithPartialLine) {
 export class CodexSessionReader {
     sessionsDir;
     projectPath;
+    projectIdentityKey;
+    dataDir;
+    discoveryIndex;
+    slowLogThresholdMs;
+    summaryParserWorkerMode;
+    summaryParserClient;
+    lastScanMetrics = null;
+    lastSummaryStreamMetrics = null;
     // Cache of session ID -> file path for quick lookups
     sessionFileCache = new Map();
     entryCache = new Map();
@@ -51,6 +186,21 @@ export class CodexSessionReader {
         this.projectPath = options.projectPath
             ? canonicalizeProjectPath(options.projectPath)
             : undefined;
+        this.projectIdentityKey = this.projectPath
+            ? getProjectIdentityKey(this.projectPath)
+            : undefined;
+        this.dataDir = options.dataDir;
+        this.discoveryIndex =
+            options.discoveryIndex ??
+                createCodexSessionDiscoveryIndex(options.dataDir, this.sessionsDir);
+        this.slowLogThresholdMs = Math.max(0, options.slowLogThresholdMs ?? DEFAULT_SLOW_LOG_THRESHOLD_MS);
+        this.summaryParserWorkerMode = options.summaryParserWorkerMode ?? "off";
+        this.summaryParserClient = options.summaryParserClient;
+    }
+    async close() {
+        const client = this.summaryParserClient;
+        this.summaryParserClient = undefined;
+        await client?.close();
     }
     invalidateCache() {
         this.sessionFileCache.clear();
@@ -61,16 +211,44 @@ export class CodexSessionReader {
             }
         }
     }
+    getLastScanMetrics() {
+        return this.lastScanMetrics
+            ? cloneCodexSessionReaderScanMetrics(this.lastScanMetrics)
+            : null;
+    }
+    getEntryCacheStats() {
+        let entries = 0;
+        let sourceBytes = 0;
+        let partialLineBytes = 0;
+        for (const cached of this.entryCache.values()) {
+            entries += cached.entries.length;
+            sourceBytes += cached.size;
+            partialLineBytes += cached.partialLine.length;
+        }
+        return {
+            sessions: this.entryCache.size,
+            entries,
+            sourceBytes,
+            partialLineBytes,
+        };
+    }
+    getLastSummaryStreamMetrics() {
+        return this.lastSummaryStreamMetrics
+            ? { ...this.lastSummaryStreamMetrics }
+            : null;
+    }
     async listSessions(projectId) {
         const summaries = [];
         const sessions = await this.scanSessions();
         for (const session of sessions) {
             // Filter by project path if set
-            if (this.projectPath &&
-                canonicalizeProjectPath(session.cwd) !== this.projectPath) {
+            if (this.projectIdentityKey &&
+                getProjectIdentityKey(session.cwd) !== this.projectIdentityKey) {
                 continue;
             }
-            const summary = await this.getSessionSummary(session.id, projectId);
+            const summary = await this.getSessionSummary(session.id, projectId, {
+                readMode: "head",
+            });
             if (summary) {
                 summaries.push(summary);
             }
@@ -79,87 +257,83 @@ export class CodexSessionReader {
         summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
         return summaries;
     }
-    async getSessionSummary(sessionId, projectId) {
+    async getSessionSummary(sessionId, projectId, options) {
         const sessionFile = await this.findSessionFile(sessionId);
         if (!sessionFile)
             return null;
         try {
-            const entries = await this.readEntries(sessionId, sessionFile.filePath);
-            if (entries.length === 0)
-                return null;
-            // Extract session metadata from first entry
-            const metaEntry = entries.find((e) => e.type === "session_meta");
-            if (!metaEntry)
-                return null;
+            const inProcessParser = () => this.buildSessionSummaryFromStream(sessionId, projectId, sessionFile.filePath, options);
+            if (options?.readMode === "head" ||
+                this.summaryParserWorkerMode === "off") {
+                if (options?.readMode === "head") {
+                    return await inProcessParser();
+                }
+                const stats = await stat(sessionFile.filePath);
+                return await this.getCoalescedFullSessionSummary(sessionFile.filePath, stats, () => this.buildSessionSummaryFromKnownStats(sessionId, projectId, sessionFile.filePath, stats, options));
+            }
             const stats = await stat(sessionFile.filePath);
-            const { title, fullTitle } = this.extractTitle(entries);
-            const messageCount = this.countMessages(entries);
-            const model = this.extractModel(entries);
-            const provider = this.determineProvider(metaEntry, model);
-            const turnContext = this.extractTurnContext(entries);
-            const contextUsage = this.extractContextUsage(entries, model, provider);
-            const parentSessionId = typeof metaEntry.payload.forked_from_id === "string"
-                ? metaEntry.payload.forked_from_id
-                : undefined;
-            // Skip sessions with no actual conversation messages
-            if (messageCount === 0)
-                return null;
-            return {
-                id: sessionId,
-                projectId,
-                title,
-                fullTitle,
-                createdAt: metaEntry.payload.timestamp,
-                updatedAt: stats.mtime.toISOString(),
-                messageCount,
-                ownership: { owner: "none" },
-                contextUsage,
-                provider,
-                model,
-                parentSessionId,
-                originator: metaEntry.payload.originator,
-                cliVersion: metaEntry.payload.cli_version,
-                source: metaEntry.payload.source,
-                approvalPolicy: turnContext?.payload.approval_policy,
-                sandboxPolicy: turnContext?.payload.sandbox_policy
-                    ? {
-                        type: turnContext.payload.sandbox_policy.type,
-                        networkAccess: turnContext.payload.sandbox_policy.network_access,
-                        excludeTmpdirEnvVar: turnContext.payload.sandbox_policy.exclude_tmpdir_env_var,
-                        excludeSlashTmp: turnContext.payload.sandbox_policy.exclude_slash_tmp,
-                    }
-                    : undefined,
-            };
+            return await this.getCoalescedFullSessionSummary(sessionFile.filePath, stats, async () => {
+                const request = {
+                    type: "parse",
+                    requestId: randomUUID(),
+                    provider: "codex",
+                    filePath: sessionFile.filePath,
+                    sessionId,
+                    projectId,
+                    stats: {
+                        size: Number(stats.size),
+                        mtimeMs: Number(stats.mtimeMs),
+                        mtimeIso: stats.mtime.toISOString(),
+                    },
+                    sourceHints: {
+                        codex: {
+                            sessionsDir: this.sessionsDir,
+                            ...(this.projectPath ? { projectPath: this.projectPath } : {}),
+                            ...(this.dataDir ? { dataDir: this.dataDir } : {}),
+                        },
+                    },
+                };
+                const result = await this.getSummaryParserClient().parse(request, inProcessParser);
+                return result.summary;
+            });
         }
         catch {
             return null;
         }
     }
     async getSession(sessionId, projectId, afterMessageId, _options) {
-        const summary = await this.getSessionSummary(sessionId, projectId);
-        if (!summary)
-            return null;
         const sessionFile = await this.findSessionFile(sessionId);
         if (!sessionFile)
             return null;
-        const entries = await this.readEntries(sessionId, sessionFile.filePath);
-        // Filter entries if needed (for incremental fetching)
-        // Note: Codex entries are not 1:1 with messages, so standard ID filtering is tricky
-        // with raw format. We return all entries for now.
-        // Ideally the client handles diffing/appending.
-        const finalEntries = entries;
-        if (afterMessageId) {
-            // Logic to filter entries would go here if strict incremental loading is needed
-        }
-        return {
-            summary,
-            data: {
-                provider: this.determineProviderFromEntries(entries),
-                session: {
-                    entries: finalEntries,
+        try {
+            const entries = await this.readEntries(sessionId, sessionFile.filePath, {
+                purpose: "detail",
+                cache: true,
+            });
+            const summary = await this.buildSessionSummaryFromEntries(sessionId, projectId, sessionFile, entries);
+            if (!summary)
+                return null;
+            // Filter entries if needed (for incremental fetching)
+            // Note: Codex entries are not 1:1 with messages, so standard ID filtering is tricky
+            // with raw format. We return all entries for now.
+            // Ideally the client handles diffing/appending.
+            const finalEntries = entries;
+            if (afterMessageId) {
+                // Logic to filter entries would go here if strict incremental loading is needed
+            }
+            return {
+                summary,
+                data: {
+                    provider: this.determineProviderFromEntries(entries),
+                    session: {
+                        entries: finalEntries,
+                    },
                 },
-            },
-        };
+            };
+        }
+        catch {
+            return null;
+        }
     }
     async getSessionSummaryIfChanged(sessionId, projectId, cachedMtime, cachedSize) {
         const sessionFile = await this.findSessionFile(sessionId);
@@ -182,19 +356,86 @@ export class CodexSessionReader {
             return null;
         }
     }
-    /**
-     * Codex doesn't have subagent sessions like Claude.
-     * Returns empty array for compatibility.
-     */
     async getAgentMappings() {
-        return [];
+        const sessions = await this.scanSessions();
+        const mappings = [];
+        const seenToolUseIds = new Set();
+        for (const session of sessions) {
+            if (this.projectIdentityKey &&
+                getProjectIdentityKey(session.cwd) !== this.projectIdentityKey) {
+                continue;
+            }
+            const entries = await this.readEntries(session.id, session.filePath, {
+                purpose: "agent-mapping",
+                cache: false,
+            });
+            const spawnAgentCallIds = new Set();
+            for (const entry of entries) {
+                if (entry.type !== "response_item") {
+                    continue;
+                }
+                const payload = entry.payload;
+                if (payload.type === "function_call" &&
+                    payload.name === "spawn_agent") {
+                    spawnAgentCallIds.add(payload.call_id);
+                    continue;
+                }
+                if (payload.type !== "function_call_output" ||
+                    !spawnAgentCallIds.has(payload.call_id) ||
+                    seenToolUseIds.has(payload.call_id)) {
+                    continue;
+                }
+                const agentId = parseCodexSpawnAgentOutput(payload.output);
+                if (!agentId) {
+                    continue;
+                }
+                mappings.push({ toolUseId: payload.call_id, agentId });
+                seenToolUseIds.add(payload.call_id);
+            }
+        }
+        return mappings;
     }
-    /**
-     * Codex doesn't have subagent sessions like Claude.
-     * Returns null for compatibility.
-     */
-    async getAgentSession(_agentId) {
-        return null;
+    async getAgentSession(agentId) {
+        const sessionFile = await this.findSessionFile(agentId);
+        if (!sessionFile)
+            return null;
+        const entries = await this.readEntries(agentId, sessionFile.filePath, {
+            purpose: "subagent",
+            cache: true,
+        });
+        if (entries.length === 0)
+            return null;
+        const metaEntry = entries.find((e) => e.type === "session_meta");
+        if (!metaEntry)
+            return null;
+        const { title, fullTitle } = this.extractTitle(entries);
+        const provider = this.determineProviderFromEntries(entries);
+        const summary = {
+            id: agentId,
+            projectId: "codex-subagent",
+            title,
+            fullTitle,
+            createdAt: metaEntry.payload.timestamp,
+            updatedAt: sessionFile.timestamp,
+            messageCount: this.countMessages(entries),
+            ownership: { owner: "none" },
+            provider,
+        };
+        const loaded = {
+            summary,
+            data: {
+                provider,
+                session: { entries },
+            },
+        };
+        const session = normalizeSession(loaded);
+        return {
+            messages: session.messages.map((message) => ({
+                ...message,
+                isSubagent: true,
+            })),
+            status: inferCodexAgentStatus(entries),
+        };
     }
     /**
      * Scan the sessions directory and find all session files.
@@ -204,15 +445,37 @@ export class CodexSessionReader {
         const cached = codexSharedScanCache.get(cacheKey);
         const now = Date.now();
         if (cached && now - cached.timestamp < CODEX_SCAN_CACHE_TTL_MS) {
+            const metrics = createCodexSessionReaderScanMetrics({
+                sessionsDir: this.sessionsDir,
+                projectPath: this.projectPath,
+                activeAfterMs: options?.activeAfterMs,
+                cacheKey,
+                sharedCacheStatus: cached.inFlight ? "in-flight" : "hit",
+            });
+            const startedAt = Date.now();
             if (cached.inFlight) {
                 const sessions = await cached.inFlight;
                 this.hydrateSessionFileCache(sessions);
-                return sessions.filter((session) => !session.isSubagent);
+                const visibleSessions = this.filterVisibleSessionsForScanMetrics(sessions, metrics);
+                metrics.durationMs = Date.now() - startedAt;
+                this.recordScanMetrics(metrics);
+                return visibleSessions;
             }
             this.hydrateSessionFileCache(cached.sessions);
-            return cached.sessions.filter((session) => !session.isSubagent);
+            const visibleSessions = this.filterVisibleSessionsForScanMetrics(cached.sessions, metrics);
+            metrics.durationMs = Date.now() - startedAt;
+            this.recordScanMetrics(metrics);
+            return visibleSessions;
         }
-        const inFlight = this.scanSessionsUncached(options);
+        const metrics = createCodexSessionReaderScanMetrics({
+            sessionsDir: this.sessionsDir,
+            projectPath: this.projectPath,
+            activeAfterMs: options?.activeAfterMs,
+            cacheKey,
+            sharedCacheStatus: "miss",
+        });
+        const startedAt = Date.now();
+        const inFlight = this.scanSessionsUncached(options, metrics);
         codexSharedScanCache.set(cacheKey, {
             timestamp: now,
             sessions: [],
@@ -225,9 +488,14 @@ export class CodexSessionReader {
                 sessions,
             });
             this.hydrateSessionFileCache(sessions);
-            return sessions.filter((session) => !session.isSubagent);
+            const visibleSessions = this.filterVisibleSessionsForScanMetrics(sessions, metrics);
+            metrics.durationMs = Date.now() - startedAt;
+            this.recordScanMetrics(metrics);
+            return visibleSessions;
         }
         catch (error) {
+            metrics.durationMs = Date.now() - startedAt;
+            this.recordScanMetrics(metrics);
             const entry = codexSharedScanCache.get(cacheKey);
             if (entry?.inFlight === inFlight) {
                 codexSharedScanCache.delete(cacheKey);
@@ -243,14 +511,54 @@ export class CodexSessionReader {
             this.sessionFileCache.set(session.id, session);
         }
     }
-    async scanSessionsUncached(options) {
+    filterVisibleSessionsForScanMetrics(sessions, metrics) {
+        const visibleSessions = sessions.filter((session) => {
+            if (session.isSubagent) {
+                metrics.subagentSessionsSkipped += 1;
+                return false;
+            }
+            return true;
+        });
+        metrics.sessionsReturned = visibleSessions.length;
+        return visibleSessions;
+    }
+    recordScanMetrics(metrics) {
+        this.lastScanMetrics = cloneCodexSessionReaderScanMetrics(metrics);
+        const payload = {
+            event: "codex_reader_scan",
+            ...metrics,
+        };
+        if (metrics.durationMs >= this.slowLogThresholdMs) {
+            getLogger().warn(payload, "CODEX_READER: slow scan");
+            return;
+        }
+        getLogger().debug(payload, "CODEX_READER: scan complete");
+    }
+    async scanSessionsUncached(options, metrics) {
         const sessions = [];
-        const files = await this.findJsonlFiles(this.sessionsDir);
+        try {
+            await stat(this.sessionsDir);
+            if (metrics)
+                metrics.sessionsDirExists = true;
+        }
+        catch {
+            return sessions;
+        }
+        const files = await this.findJsonlFiles(this.sessionsDir, metrics);
         for (const filePath of files) {
-            const session = await this.readSessionMeta(filePath, options);
+            const activeWindowSkipsBefore = metrics?.discovery.activeWindowSkips ?? 0;
+            const session = await this.readSessionMeta(filePath, options, metrics);
             if (session) {
                 sessions.push(session);
             }
+            else if (metrics &&
+                metrics.discovery.activeWindowSkips === activeWindowSkipsBefore) {
+                metrics.failedFiles += 1;
+            }
+        }
+        await this.discoveryIndex?.flush();
+        if (metrics) {
+            metrics.sessionsParsed = sessions.length;
         }
         return sessions;
     }
@@ -259,13 +567,13 @@ export class CodexSessionReader {
         return sessionFile?.filePath ?? null;
     }
     getIndexScopeKey(sessionDir) {
-        return `codex::${sessionDir}::${this.projectPath ?? "*"}`;
+        return `codex::${sessionDir}::${this.projectIdentityKey ?? "*"}`;
     }
     async listSessionFiles(_sessionDir, options) {
         const sessions = await this.scanSessions(options);
         return sessions
-            .filter((session) => (!this.projectPath ||
-            canonicalizeProjectPath(session.cwd) === this.projectPath) &&
+            .filter((session) => (!this.projectIdentityKey ||
+            getProjectIdentityKey(session.cwd) === this.projectIdentityKey) &&
             (!options?.activeAfterMs || session.mtime >= options.activeAfterMs))
             .map((session) => ({
             sessionId: session.id,
@@ -284,40 +592,529 @@ export class CodexSessionReader {
         await this.scanSessions();
         return this.sessionFileCache.get(sessionId) ?? null;
     }
-    async readEntries(sessionId, filePath) {
+    async readEntries(sessionId, filePath, options) {
+        const purpose = options?.purpose ?? "detail";
+        const shouldWriteCache = options?.cache ?? true;
+        const startedAt = Date.now();
+        const memoryBefore = process.memoryUsage();
         const stats = await stat(filePath);
         const cached = this.entryCache.get(sessionId);
         if (cached &&
             cached.filePath === filePath &&
             cached.size === stats.size &&
             cached.mtimeMs === stats.mtimeMs) {
-            return cached.entries;
+            cached.entries = dedupeCodexEntries(cached.entries);
+            this.recordEntryReadMetrics({
+                startedAt,
+                memoryBefore,
+                sessionId,
+                filePath,
+                purpose,
+                cacheMode: shouldWriteCache ? "read-write" : "read-only",
+                cacheStatus: "hit",
+                stats,
+                parsedEntries: cached.entries.length,
+                dedupedEntries: cached.entries.length,
+            });
+            return cached.entries.slice();
         }
-        if (cached && cached.filePath === filePath && cached.size < stats.size) {
+        if (shouldWriteCache &&
+            cached &&
+            cached.filePath === filePath &&
+            !isCompressedCodexSessionFile(filePath) &&
+            cached.size < stats.size) {
+            const readStartedAt = Date.now();
             const appended = await this.readFileRange(filePath, cached.size, stats.size - cached.size);
+            const readLinesMs = Date.now() - readStartedAt;
+            const parseStartedAt = Date.now();
             const { entries, partialLine } = parseCodexJsonlChunk(cached.partialLine + appended, stats.size > cached.size);
+            const parseMs = Date.now() - parseStartedAt;
+            const dedupeStartedAt = Date.now();
             cached.entries.push(...entries);
+            cached.entries = dedupeCodexEntries(cached.entries);
+            const dedupeMs = Date.now() - dedupeStartedAt;
             cached.partialLine = partialLine;
             cached.size = stats.size;
             cached.mtimeMs = stats.mtimeMs;
-            return cached.entries;
+            this.recordEntryReadMetrics({
+                startedAt,
+                memoryBefore,
+                sessionId,
+                filePath,
+                purpose,
+                cacheMode: "read-write",
+                cacheStatus: "append",
+                stats,
+                readLinesMs,
+                parseMs,
+                dedupeMs,
+                lineCount: entries.length,
+                parsedEntries: entries.length,
+                dedupedEntries: cached.entries.length,
+            });
+            return cached.entries.slice();
         }
+        const readStartedAt = Date.now();
         const lines = await readJsonlLines(filePath);
+        const readLinesMs = Date.now() - readStartedAt;
         const entries = [];
+        let maxLineLength = 0;
+        const parseStartedAt = Date.now();
         for (const line of lines) {
+            maxLineLength = Math.max(maxLineLength, line.length);
             const entry = parseCodexSessionEntry(line);
             if (entry) {
                 entries.push(entry);
             }
         }
-        this.entryCache.set(sessionId, {
+        const parseMs = Date.now() - parseStartedAt;
+        const dedupeStartedAt = Date.now();
+        const dedupedEntries = dedupeCodexEntries(entries);
+        const dedupeMs = Date.now() - dedupeStartedAt;
+        let cacheStoreMs = 0;
+        if (shouldWriteCache) {
+            const cacheStoreStartedAt = Date.now();
+            this.entryCache.set(sessionId, {
+                filePath,
+                mtimeMs: stats.mtimeMs,
+                size: stats.size,
+                entries: dedupedEntries,
+                partialLine: "",
+            });
+            cacheStoreMs = Date.now() - cacheStoreStartedAt;
+        }
+        this.recordEntryReadMetrics({
+            startedAt,
+            memoryBefore,
+            sessionId,
             filePath,
-            mtimeMs: stats.mtimeMs,
-            size: stats.size,
-            entries,
-            partialLine: "",
+            purpose,
+            cacheMode: shouldWriteCache ? "read-write" : "read-only",
+            cacheStatus: "miss",
+            stats,
+            readLinesMs,
+            parseMs,
+            dedupeMs,
+            cacheStoreMs,
+            lineCount: lines.length,
+            parsedEntries: entries.length,
+            dedupedEntries: dedupedEntries.length,
+            maxLineLength,
+        });
+        return dedupedEntries.slice();
+    }
+    async getSessionSummaryFromFile(sessionId, projectId, filePath, options) {
+        return this.buildSessionSummaryFromStream(sessionId, projectId, filePath, options);
+    }
+    async buildSessionSummaryFromStream(sessionId, projectId, filePath, options) {
+        const stats = await stat(filePath);
+        return this.buildSessionSummaryFromKnownStats(sessionId, projectId, filePath, stats, options);
+    }
+    async buildSessionSummaryFromKnownStats(sessionId, projectId, filePath, stats, options) {
+        const read = await this.readSummaryStream(sessionId, filePath, stats, options?.readMode ?? "full");
+        return this.buildSessionSummaryFromState(sessionId, projectId, stats, read.state);
+    }
+    async getCoalescedFullSessionSummary(filePath, stats, parse) {
+        const cacheKey = getCodexFullSummaryCacheKey(filePath, stats);
+        const cached = codexFullSummaryCache.get(cacheKey);
+        if (cached) {
+            cached.lastAccessedAt = Date.now();
+            return cloneSessionSummary(await cached.promise);
+        }
+        const promise = parse();
+        codexFullSummaryCache.set(cacheKey, {
+            promise,
+            lastAccessedAt: Date.now(),
         });
-        return entries;
+        trimCodexFullSummaryCache();
+        try {
+            return cloneSessionSummary(await promise);
+        }
+        catch (error) {
+            if (codexFullSummaryCache.get(cacheKey)?.promise === promise) {
+                codexFullSummaryCache.delete(cacheKey);
+            }
+            throw error;
+        }
+    }
+    getSummaryParserClient() {
+        this.summaryParserClient ??= new SummaryParserClient({
+            mode: this.summaryParserWorkerMode,
+        });
+        return this.summaryParserClient;
+    }
+    async readSummaryStream(sessionId, filePath, stats, readMode) {
+        const startedAt = Date.now();
+        const memoryBefore = process.memoryUsage();
+        const state = {
+            sawResponseItemUser: false,
+            eventUserMessageCount: 0,
+            responseMessageCount: 0,
+        };
+        const seenDedupeKeys = new Set();
+        let lineCount = 0;
+        let parsedEntries = 0;
+        let dedupedEntries = 0;
+        let skippedDuplicateEntries = 0;
+        let maxLineLength = 0;
+        let bytesRead = 0;
+        let stoppedEarly = false;
+        let stopReason = "eof";
+        const parseStartedAt = Date.now();
+        const headBudgetStopReason = () => {
+            if (readMode !== "head")
+                return null;
+            if (lineCount >= CODEX_HEAD_SUMMARY_MAX_LINES) {
+                return "line_budget";
+            }
+            if (bytesRead >= CODEX_HEAD_SUMMARY_MAX_BYTES) {
+                return "byte_budget";
+            }
+            return null;
+        };
+        const stopEarly = (reason) => {
+            stoppedEarly = true;
+            stopReason = reason;
+        };
+        for await (const line of iterateJsonlLines(filePath)) {
+            lineCount += 1;
+            maxLineLength = Math.max(maxLineLength, line.length);
+            bytesRead += Buffer.byteLength(line) + 1;
+            const trimmed = line.trim();
+            if (!trimmed) {
+                const budgetReason = headBudgetStopReason();
+                if (budgetReason) {
+                    stopEarly(budgetReason);
+                    break;
+                }
+                continue;
+            }
+            const entry = parseCodexSessionEntry(trimmed);
+            if (!entry) {
+                const budgetReason = headBudgetStopReason();
+                if (budgetReason) {
+                    stopEarly(budgetReason);
+                    break;
+                }
+                continue;
+            }
+            parsedEntries += 1;
+            const dedupeKey = getCodexSummaryDedupeKey(entry);
+            if (dedupeKey) {
+                if (seenDedupeKeys.has(dedupeKey)) {
+                    skippedDuplicateEntries += 1;
+                    continue;
+                }
+                seenDedupeKeys.add(dedupeKey);
+            }
+            dedupedEntries += 1;
+            this.applySummaryEntry(state, entry);
+            if (readMode === "head" && this.hasHeadSummary(state)) {
+                stopEarly("head_complete");
+                break;
+            }
+            const budgetReason = headBudgetStopReason();
+            if (budgetReason) {
+                stopEarly(budgetReason);
+                break;
+            }
+        }
+        const parseMs = Date.now() - parseStartedAt;
+        const read = {
+            state,
+            lineCount,
+            parsedEntries,
+            dedupedEntries,
+            skippedDuplicateEntries,
+            maxLineLength,
+            parseMs,
+            readMode,
+            stoppedEarly,
+            stopReason,
+        };
+        this.recordSummaryStreamMetrics({
+            startedAt,
+            memoryBefore,
+            sessionId,
+            filePath,
+            stats,
+            read,
+        });
+        return read;
+    }
+    hasHeadSummary(state) {
+        return !!(state.metaEntry &&
+            (state.firstResponseUserTitle || state.firstEventUserTitle));
+    }
+    applySummaryEntry(state, entry) {
+        if (entry.type === "session_meta") {
+            state.metaEntry ??= entry;
+            return;
+        }
+        if (entry.type === "turn_context") {
+            state.firstTurnContext ??= entry;
+            if (entry.payload.model) {
+                state.model = entry.payload.model;
+            }
+            return;
+        }
+        if (entry.type === "event_msg") {
+            if (entry.payload.type === "user_message") {
+                state.eventUserMessageCount += 1;
+                if (!state.firstEventUserTitle) {
+                    const fullTitle = entry.payload.message.trim();
+                    if (!this.isSystemPromptUserMessage(fullTitle)) {
+                        state.firstEventUserTitle = {
+                            title: truncateSessionTitle(fullTitle) || null,
+                            fullTitle,
+                        };
+                    }
+                }
+                return;
+            }
+            if (entry.payload.type === "token_count") {
+                const info = entry.payload.info;
+                const usage = info?.last_token_usage ?? info?.total_token_usage;
+                const inputTokens = usage?.input_tokens ?? 0;
+                if (inputTokens > 0) {
+                    state.contextCandidate = {
+                        inputTokens,
+                        ...(info?.model_context_window && info.model_context_window > 0
+                            ? { contextWindow: info.model_context_window }
+                            : {}),
+                    };
+                }
+            }
+            return;
+        }
+        if (entry.type !== "response_item") {
+            return;
+        }
+        const payload = entry.payload;
+        if (payload.type !== "message") {
+            return;
+        }
+        if (payload.role === "user" || payload.role === "assistant") {
+            state.responseMessageCount += 1;
+        }
+        if (payload.role !== "user") {
+            return;
+        }
+        state.sawResponseItemUser = true;
+        if (state.firstResponseUserTitle) {
+            return;
+        }
+        const fullTitle = payload.content
+            .map((content) => "text" in content && typeof content.text === "string"
+            ? content.text
+            : "")
+            .join("\n")
+            .trim();
+        if (fullTitle && !this.isSystemPromptUserMessage(fullTitle)) {
+            state.firstResponseUserTitle = {
+                title: truncateSessionTitle(fullTitle) || null,
+                fullTitle,
+            };
+        }
+    }
+    buildSessionSummaryFromState(sessionId, projectId, stats, state) {
+        const metaEntry = state.metaEntry;
+        if (!metaEntry)
+            return null;
+        const messageCount = state.responseMessageCount +
+            (state.sawResponseItemUser ? 0 : state.eventUserMessageCount);
+        if (messageCount === 0)
+            return null;
+        const model = state.model;
+        const provider = this.determineProvider(metaEntry, model);
+        const contextUsage = this.contextUsageFromSummaryCandidate(state.contextCandidate, model, provider);
+        const title = (state.sawResponseItemUser
+            ? state.firstResponseUserTitle
+            : state.firstEventUserTitle) ?? {
+            title: null,
+            fullTitle: null,
+        };
+        const parentSessionId = typeof metaEntry.payload.forked_from_id === "string"
+            ? metaEntry.payload.forked_from_id
+            : undefined;
+        return {
+            id: sessionId,
+            projectId,
+            title: title.title,
+            fullTitle: title.fullTitle,
+            createdAt: metaEntry.payload.timestamp,
+            updatedAt: stats.mtime.toISOString(),
+            messageCount,
+            ownership: { owner: "none" },
+            contextUsage,
+            provider,
+            model,
+            parentSessionId,
+            originator: metaEntry.payload.originator,
+            cliVersion: metaEntry.payload.cli_version,
+            source: codexSessionSourceLabel(metaEntry.payload.source),
+            approvalPolicy: state.firstTurnContext?.payload.approval_policy,
+            sandboxPolicy: state.firstTurnContext?.payload.sandbox_policy
+                ? {
+                    type: state.firstTurnContext.payload.sandbox_policy.type,
+                    networkAccess: state.firstTurnContext.payload.sandbox_policy.network_access,
+                    excludeTmpdirEnvVar: state.firstTurnContext.payload.sandbox_policy
+                        .exclude_tmpdir_env_var,
+                    excludeSlashTmp: state.firstTurnContext.payload.sandbox_policy.exclude_slash_tmp,
+                }
+                : undefined,
+        };
+    }
+    contextUsageFromSummaryCandidate(candidate, model, provider) {
+        if (!candidate) {
+            return undefined;
+        }
+        const contextWindow = candidate.contextWindow ?? getModelContextWindow(model, provider);
+        const percentage = Math.min(100, Math.round((candidate.inputTokens / contextWindow) * 100));
+        return {
+            inputTokens: candidate.inputTokens,
+            percentage,
+            contextWindow,
+        };
+    }
+    async buildSessionSummaryFromEntries(sessionId, projectId, sessionFile, entries) {
+        if (entries.length === 0)
+            return null;
+        const metaEntry = entries.find((e) => e.type === "session_meta");
+        if (!metaEntry)
+            return null;
+        const stats = await stat(sessionFile.filePath);
+        const { title, fullTitle } = this.extractTitle(entries);
+        const messageCount = this.countMessages(entries);
+        const model = this.extractModel(entries);
+        const provider = this.determineProvider(metaEntry, model);
+        const turnContext = this.extractTurnContext(entries);
+        const contextUsage = this.extractContextUsage(entries, model, provider);
+        const parentSessionId = typeof metaEntry.payload.forked_from_id === "string"
+            ? metaEntry.payload.forked_from_id
+            : undefined;
+        if (messageCount === 0)
+            return null;
+        return {
+            id: sessionId,
+            projectId,
+            title,
+            fullTitle,
+            createdAt: metaEntry.payload.timestamp,
+            updatedAt: stats.mtime.toISOString(),
+            messageCount,
+            ownership: { owner: "none" },
+            contextUsage,
+            provider,
+            model,
+            parentSessionId,
+            originator: metaEntry.payload.originator,
+            cliVersion: metaEntry.payload.cli_version,
+            source: codexSessionSourceLabel(metaEntry.payload.source),
+            approvalPolicy: turnContext?.payload.approval_policy,
+            sandboxPolicy: turnContext?.payload.sandbox_policy
+                ? {
+                    type: turnContext.payload.sandbox_policy.type,
+                    networkAccess: turnContext.payload.sandbox_policy.network_access,
+                    excludeTmpdirEnvVar: turnContext.payload.sandbox_policy.exclude_tmpdir_env_var,
+                    excludeSlashTmp: turnContext.payload.sandbox_policy.exclude_slash_tmp,
+                }
+                : undefined,
+        };
+    }
+    recordEntryReadMetrics(options) {
+        const durationMs = Date.now() - options.startedAt;
+        if (!LOG_ENTRY_READS && durationMs < this.slowLogThresholdMs) {
+            return;
+        }
+        const memoryAfter = process.memoryUsage();
+        const payload = {
+            event: "codex_entry_read",
+            sessionsDir: this.sessionsDir,
+            ...(this.projectPath ? { projectPath: this.projectPath } : {}),
+            sessionId: options.sessionId,
+            filePath: options.filePath,
+            purpose: options.purpose,
+            cacheMode: options.cacheMode,
+            cacheStatus: options.cacheStatus,
+            fileSize: Number(options.stats.size),
+            fileMtimeMs: Number(options.stats.mtimeMs),
+            durationMs,
+            ...(options.readLinesMs !== undefined
+                ? { readLinesMs: options.readLinesMs }
+                : {}),
+            ...(options.parseMs !== undefined ? { parseMs: options.parseMs } : {}),
+            ...(options.dedupeMs !== undefined
+                ? { dedupeMs: options.dedupeMs }
+                : {}),
+            ...(options.cacheStoreMs !== undefined
+                ? { cacheStoreMs: options.cacheStoreMs }
+                : {}),
+            ...(options.lineCount !== undefined
+                ? { lineCount: options.lineCount }
+                : {}),
+            ...(options.parsedEntries !== undefined
+                ? { parsedEntries: options.parsedEntries }
+                : {}),
+            ...(options.dedupedEntries !== undefined
+                ? { dedupedEntries: options.dedupedEntries }
+                : {}),
+            ...(options.maxLineLength !== undefined
+                ? { maxLineLength: options.maxLineLength }
+                : {}),
+            heapUsedBefore: options.memoryBefore.heapUsed,
+            heapUsedAfter: memoryAfter.heapUsed,
+            rssBefore: options.memoryBefore.rss,
+            rssAfter: memoryAfter.rss,
+            heapUsedDelta: memoryAfter.heapUsed - options.memoryBefore.heapUsed,
+            rssDelta: memoryAfter.rss - options.memoryBefore.rss,
+            entryCache: this.getEntryCacheStats(),
+        };
+        if (durationMs >= this.slowLogThresholdMs) {
+            getLogger().warn(payload, "CODEX_READER: slow entry read");
+            return;
+        }
+        getLogger().debug(payload, "CODEX_READER: entry read");
+    }
+    recordSummaryStreamMetrics(options) {
+        const durationMs = Date.now() - options.startedAt;
+        const memoryAfter = process.memoryUsage();
+        const payload = {
+            event: "codex_summary_stream",
+            sessionsDir: this.sessionsDir,
+            ...(this.projectPath ? { projectPath: this.projectPath } : {}),
+            sessionId: options.sessionId,
+            filePath: options.filePath,
+            fileSize: Number(options.stats.size),
+            fileMtimeMs: Number(options.stats.mtimeMs),
+            compressed: isCompressedCodexSessionFile(options.filePath),
+            durationMs,
+            parseMs: options.read.parseMs,
+            lineCount: options.read.lineCount,
+            parsedEntries: options.read.parsedEntries,
+            dedupedEntries: options.read.dedupedEntries,
+            skippedDuplicateEntries: options.read.skippedDuplicateEntries,
+            maxLineLength: options.read.maxLineLength,
+            readMode: options.read.readMode,
+            stoppedEarly: options.read.stoppedEarly,
+            stopReason: options.read.stopReason,
+            heapUsedBefore: options.memoryBefore.heapUsed,
+            heapUsedAfter: memoryAfter.heapUsed,
+            rssBefore: options.memoryBefore.rss,
+            rssAfter: memoryAfter.rss,
+            heapUsedDelta: memoryAfter.heapUsed - options.memoryBefore.heapUsed,
+            rssDelta: memoryAfter.rss - options.memoryBefore.rss,
+            entryCache: this.getEntryCacheStats(),
+        };
+        this.lastSummaryStreamMetrics = payload;
+        if (!LOG_ENTRY_READS && durationMs < this.slowLogThresholdMs) {
+            return;
+        }
+        if (durationMs >= this.slowLogThresholdMs) {
+            getLogger().warn(payload, "CODEX_READER: slow summary stream");
+            return;
+        }
+        getLogger().debug(payload, "CODEX_READER: summary stream");
     }
     async readFileRange(filePath, start, length) {
         if (length <= 0) {
@@ -334,70 +1131,79 @@ export class CodexSessionReader {
         }
     }
     /**
-     * Recursively find all .jsonl files in a directory.
+     * Recursively find all Codex rollout files in a directory.
      */
-    async findJsonlFiles(dir) {
+    async findJsonlFiles(dir, metrics) {
         const files = [];
+        await this.collectJsonlFiles(dir, files, metrics);
+        const preferredFiles = preferPlainCodexRollouts(files);
+        if (metrics) {
+            metrics.rolloutFilesAfterPrecedence = preferredFiles.length;
+            metrics.precedenceSkippedCompressed =
+                files.length - preferredFiles.length;
+        }
+        return preferredFiles;
+    }
+    async collectJsonlFiles(dir, files, metrics) {
         try {
+            if (metrics)
+                metrics.directoriesVisited += 1;
             const entries = await readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
                 const fullPath = join(dir, entry.name);
                 if (entry.isDirectory()) {
-                    const subFiles = await this.findJsonlFiles(fullPath);
-                    files.push(...subFiles);
+                    await this.collectJsonlFiles(fullPath, files, metrics);
                 }
-                else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                else if (entry.isFile() && isCodexRolloutFileName(entry.name)) {
                     files.push(fullPath);
+                    if (metrics) {
+                        metrics.rolloutFilesFound += 1;
+                        if (codexRolloutRepresentation(fullPath) === "zstd") {
+                            metrics.compressedRolloutFiles += 1;
+                        }
+                        else {
+                            metrics.plainRolloutFiles += 1;
+                        }
+                    }
                 }
             }
         }
         catch {
+            if (metrics)
+                metrics.directoryReadErrors += 1;
             // Ignore errors (permission denied, etc.)
         }
-        return files;
     }
     /**
      * Read session metadata from the first line of a file.
      */
-    async readSessionMeta(filePath, options) {
+    async readSessionMeta(filePath, options, metrics) {
         try {
-            const stats = await stat(filePath);
-            if (options?.activeAfterMs && stats.mtimeMs < options.activeAfterMs) {
-                return null;
-            }
-            const firstLine = await readFirstLine(filePath, CODEX_META_READ_MAX_BYTES);
-            if (!firstLine)
-                return null;
-            const entry = parseCodexSessionEntry(firstLine);
-            if (entry?.type !== "session_meta")
+            const session = await readCodexRolloutMetadata({
+                sessionsDir: this.sessionsDir,
+                filePath,
+                ...(this.discoveryIndex ? { discoveryIndex: this.discoveryIndex } : {}),
+                ...(options?.activeAfterMs !== undefined
+                    ? { activeAfterMs: options.activeAfterMs }
+                    : {}),
+                ...(metrics ? { metrics: metrics.discovery } : {}),
+            });
+            if (!session)
                 return null;
-            const meta = entry.payload;
             return {
-                id: meta.id,
+                id: session.id,
                 filePath,
-                cwd: meta.cwd,
-                timestamp: meta.timestamp,
-                mtime: stats.mtimeMs,
-                size: stats.size,
-                isSubagent: this.isSubagentSessionMeta(meta),
+                cwd: session.cwd,
+                timestamp: session.timestamp,
+                mtime: session.mtime,
+                size: session.size,
+                isSubagent: session.isSubagent,
             };
         }
         catch {
             return null;
         }
     }
-    isSubagentSessionMeta(meta) {
-        if (!("forked_from_id" in meta) ||
-            typeof meta.forked_from_id !== "string") {
-            return false;
-        }
-        const source = meta.source;
-        if (!source || typeof source !== "object")
-            return false;
-        const subagentSource = source;
-        return (typeof subagentSource.subagent?.thread_spawn?.parent_thread_id ===
-            "string");
-    }
     /**
      * Extract title from entries (first user message).
      */
@@ -506,9 +1312,11 @@ export class CodexSessionReader {
      * Extract the model from turn_context entries.
      */
     extractModel(entries) {
-        // Find first turn_context entry with a model
-        for (const entry of entries) {
-            if (entry.type === "turn_context" && entry.payload.model) {
+        // Last turn_context with a model: per-turn context tracks the model the
+        // session is currently using, which can change mid-transcript.
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            if (entry?.type === "turn_context" && entry.payload.model) {
                 return entry.payload.model;
             }
         }
@@ -579,4 +1387,124 @@ export class CodexSessionReader {
             entry.payload.role === "user");
     }
 }
+function createCodexSessionReaderScanMetrics(options) {
+    return {
+        sessionsDir: options.sessionsDir,
+        ...(options.projectPath ? { projectPath: options.projectPath } : {}),
+        ...(options.activeAfterMs !== undefined
+            ? { activeAfterMs: options.activeAfterMs }
+            : {}),
+        cacheKey: options.cacheKey,
+        sharedCacheStatus: options.sharedCacheStatus,
+        durationMs: 0,
+        sessionsDirExists: false,
+        directoriesVisited: 0,
+        directoryReadErrors: 0,
+        rolloutFilesFound: 0,
+        rolloutFilesAfterPrecedence: 0,
+        plainRolloutFiles: 0,
+        compressedRolloutFiles: 0,
+        precedenceSkippedCompressed: 0,
+        sessionsParsed: 0,
+        failedFiles: 0,
+        subagentSessionsSkipped: 0,
+        sessionsReturned: 0,
+        discovery: createCodexRolloutDiscoveryStats(),
+    };
+}
+function codexSessionSourceLabel(source) {
+    if (typeof source === "string") {
+        const trimmed = source.trim();
+        return trimmed || undefined;
+    }
+    if (isRecord(source) && isRecord(source.subagent)) {
+        return "subagent";
+    }
+    return undefined;
+}
+function parseCodexSpawnAgentOutput(output) {
+    const text = codexToolOutputText(output);
+    if (!text) {
+        return null;
+    }
+    const parsed = parseJsonRecord(text);
+    const agentId = stringField(parsed, "agent_id") ?? stringField(parsed, "agentId");
+    if (agentId) {
+        return agentId;
+    }
+    return (text.match(/"agent_id"\s*:\s*"([^"]+)"/)?.[1] ??
+        text.match(/"agentId"\s*:\s*"([^"]+)"/)?.[1] ??
+        null);
+}
+function codexToolOutputText(output) {
+    if (typeof output === "string") {
+        return output.trim();
+    }
+    if (!Array.isArray(output)) {
+        return "";
+    }
+    return output
+        .map((item) => isRecord(item) && typeof item.text === "string" ? item.text : "")
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+}
+function parseJsonRecord(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(record, field) {
+    const value = record?.[field];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function inferCodexAgentStatus(entries) {
+    let sawTaskStarted = false;
+    let sawTaskComplete = false;
+    let sawTurnAborted = false;
+    let sawAssistantMessage = false;
+    for (const entry of entries) {
+        if (entry.type === "event_msg") {
+            if (entry.payload.type === "task_started") {
+                sawTaskStarted = true;
+                sawTaskComplete = false;
+            }
+            else if (entry.payload.type === "task_complete") {
+                sawTaskComplete = true;
+            }
+            else if (entry.payload.type === "turn_aborted") {
+                sawTurnAborted = true;
+            }
+            continue;
+        }
+        if (entry.type === "response_item" &&
+            entry.payload.type === "message" &&
+            entry.payload.role === "assistant") {
+            sawAssistantMessage = true;
+        }
+    }
+    if (sawTurnAborted) {
+        return "failed";
+    }
+    if (sawTaskStarted && !sawTaskComplete) {
+        return "running";
+    }
+    if (sawTaskComplete || sawAssistantMessage) {
+        return "completed";
+    }
+    return "pending";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneCodexSessionReaderScanMetrics(metrics) {
+    return {
+        ...metrics,
+        discovery: { ...metrics.discovery },
+    };
+}
 //# sourceMappingURL=codex-reader.js.map