@code-insights/cli 3.3.1 → 3.4.0

package/dist/providers/codex.js

@@ -4,7 +4,11 @@ import * as os from 'os';
 import { generateTitle, detectSessionCharacter } from '../parser/titles.js';
 /**
  * OpenAI Codex CLI session provider.
- * Discovers and parses rollout JSONL files from ~/.codex/sessions/
+ * Discovers and parses rollout files from ~/.codex/sessions/
+ *
+ * Supports two formats:
+ *   Format A: JSONL (v0.104.0+, 2026) — envelope/payload structure with response_item/event_msg
+ *   Format B: Single JSON object (pre-2025) — bare items array with no envelope
  */
 export class CodexProvider {
     getProviderName() {
@@ -44,17 +48,21 @@ function getCodexHome() {
     return fs.existsSync(defaultDir) ? defaultDir : null;
 }
 /**
- * Recursively collect rollout-*.jsonl files from date-organized directories.
- * Structure: sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl
+ * Recursively collect rollout-*.jsonl and rollout-*.json files from date-organized directories.
+ * Format A lives at: sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl
+ * Format B lives at: sessions/rollout-<date>-<uuid>.json (flat)
  */
-function collectRolloutFiles(dir, files) {
+function collectRolloutFiles(dir, files, depth = 0) {
+    if (depth > 10)
+        return; // Guard against symlink loops
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            collectRolloutFiles(fullPath, files);
+            collectRolloutFiles(fullPath, files, depth + 1);
         }
-        else if (entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) {
+        else if ((entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) ||
+            (entry.name.startsWith('rollout-') && entry.name.endsWith('.json'))) {
             files.push(fullPath);
         }
     }
@@ -73,8 +81,8 @@ function filterByProject(files, projectFilter) {
             fs.closeSync(fd);
             const firstLine = buf.toString('utf-8', 0, bytesRead).split('\n')[0];
             const meta = JSON.parse(firstLine);
-            // session_meta has cwd field
-            const cwd = meta.cwd || meta.payload?.cwd || '';
+            // session_meta has cwd field (Format A); Format B has session.cwd
+            const cwd = meta.cwd || meta.payload?.cwd || meta.session?.cwd || '';
             if (cwd.toLowerCase().includes(lowerFilter)) {
                 filtered.push(filePath);
             }
@@ -87,266 +95,450 @@ function filterByProject(files, projectFilter) {
     return filtered;
 }
 // ---------------------------------------------------------------------------
-// Parser
+// Parser entry point
 // ---------------------------------------------------------------------------
 function parseCodexSession(filePath) {
     try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const lines = content.split('\n').filter(line => line.trim());
-        if (lines.length === 0)
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        if (!content)
             return null;
-        // Parse first line — session metadata
-        const meta = parseSessionMeta(lines[0]);
-        if (!meta)
-            return null;
-        const sessionId = `codex:${meta.id}`;
-        // Parse remaining lines — events
-        const messages = [];
-        const usageEntries = [];
-        let model = meta.model || '';
-        let lastTimestamp = new Date(meta.timestamp);
-        // Accumulator for current assistant turn
-        let currentAssistantText = '';
-        let currentToolCalls = [];
-        let currentToolResults = [];
-        let currentThinking = null;
-        let turnUsage = null;
-        let toolCounter = 0;
-        function flushAssistantTurn() {
-            const text = currentAssistantText.trim();
-            if (!text && currentToolCalls.length === 0)
-                return;
-            const msgUsage = turnUsage ? {
-                inputTokens: turnUsage.input_tokens || 0,
-                outputTokens: turnUsage.output_tokens || 0,
-                cacheCreationTokens: 0,
-                cacheReadTokens: turnUsage.cached_input_tokens || 0,
-                model: model || 'unknown',
-                estimatedCostUsd: 0,
-            } : null;
-            messages.push({
-                id: `codex-assistant-${messages.length}`,
-                sessionId: sessionId,
-                type: 'assistant',
-                content: text.slice(0, 10000),
-                thinking: currentThinking,
-                toolCalls: [...currentToolCalls],
-                toolResults: [...currentToolResults],
-                usage: msgUsage,
-                timestamp: lastTimestamp,
-                parentId: null,
-            });
-            // Reset accumulators
-            currentAssistantText = '';
-            currentToolCalls = [];
-            currentToolResults = [];
-            currentThinking = null;
-            turnUsage = null;
+        // Detect format by file extension — content-sniffing is unreliable because
+        // JSONL files also start with '{' on line 1 (the session_meta object).
+        if (filePath.endsWith('.json')) {
+            return parseFormatB(content);
         }
-        for (let i = 1; i < lines.length; i++) {
-            const line = lines[i];
-            let event;
-            try {
-                event = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            // Unwrap RolloutLine envelope if present
-            const eventType = event.type;
-            const payload = (event.payload || event);
-            // Handle different event types
-            const innerType = payload.type || eventType;
-            switch (innerType) {
-                case 'message': {
-                    // response_item events: payload.type = "message", payload.role = "user"|"assistant"|"developer"
-                    const role = payload.role;
-                    if (role === 'user') {
-                        flushAssistantTurn();
-                        const userContent = extractUserContent(payload);
-                        if (userContent) {
-                            messages.push({
-                                id: payload.id || `codex-user-${messages.length}`,
-                                sessionId: sessionId,
-                                type: 'user',
-                                content: userContent.slice(0, 10000),
-                                thinking: null,
-                                toolCalls: [],
-                                toolResults: [],
-                                usage: null,
-                                timestamp: parseTimestamp(payload) || lastTimestamp,
-                                parentId: null,
-                            });
-                            lastTimestamp = messages[messages.length - 1].timestamp;
-                        }
-                    }
-                    else if (role === 'assistant') {
-                        const assistantContent = extractUserContent(payload);
-                        if (assistantContent) {
-                            currentAssistantText += assistantContent + '\n';
-                        }
-                    }
-                    // role === 'developer' = system/context messages — skip
+        return parseFormatA(content);
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Format A parser (v0.104.0+ JSONL with envelope/payload structure)
+// ---------------------------------------------------------------------------
+function parseFormatA(content) {
+    const lines = content.split('\n').filter(line => line.trim());
+    if (lines.length === 0)
+        return null;
+    // Parse first line — session metadata
+    const meta = parseSessionMeta(lines[0]);
+    if (!meta)
+        return null;
+    const sessionId = `codex:${meta.id}`;
+    const messages = [];
+    const usageEntries = [];
+    let model = meta.model || '';
+    let lastTimestamp = new Date(meta.timestamp);
+    // Accumulator for current assistant turn
+    let currentAssistantText = '';
+    let currentToolCalls = [];
+    let currentToolResults = [];
+    let currentThinking = null;
+    let turnUsage = null;
+    let toolCounter = 0;
+    function flushAssistantTurn() {
+        const text = currentAssistantText.trim();
+        if (!text && currentToolCalls.length === 0)
+            return;
+        const msgUsage = turnUsage ? {
+            inputTokens: turnUsage.input_tokens || 0,
+            outputTokens: turnUsage.output_tokens || 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: turnUsage.cached_input_tokens || 0,
+            model: model || 'unknown',
+            estimatedCostUsd: 0,
+        } : null;
+        messages.push({
+            id: `codex-assistant-${messages.length}`,
+            sessionId: sessionId,
+            type: 'assistant',
+            content: text.slice(0, 10000),
+            thinking: currentThinking,
+            toolCalls: [...currentToolCalls],
+            toolResults: [...currentToolResults],
+            usage: msgUsage,
+            timestamp: lastTimestamp,
+            parentId: null,
+        });
+        // Reset accumulators
+        currentAssistantText = '';
+        currentToolCalls = [];
+        currentToolResults = [];
+        currentThinking = null;
+        turnUsage = null;
+    }
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // Unwrap RolloutLine envelope if present
+        const eventType = event.type;
+        const payload = (event.payload || event);
+        // innerType is the meaningful event discriminant after unwrapping the envelope
+        const innerType = payload.type || eventType;
+        switch (innerType) {
+            case 'message': {
+                // response_item envelope: payload.type = "message", payload.role = "user"|"assistant"|"developer"
+                const role = payload.role;
+                if (role === 'developer') {
+                    // System prompts, permissions, collaboration mode — not real user messages
                     break;
                 }
-                case 'user_message':
-                case 'userMessage': {
-                    // Flush any pending assistant turn
-                    flushAssistantTurn();
-                    const userContent = extractUserContent(payload);
-                    if (userContent) {
-                        messages.push({
-                            id: payload.id || `codex-user-${messages.length}`,
-                            sessionId: sessionId,
-                            type: 'user',
-                            content: userContent.slice(0, 10000),
-                            thinking: null,
-                            toolCalls: [],
-                            toolResults: [],
-                            usage: null,
-                            timestamp: parseTimestamp(payload) || lastTimestamp,
-                            parentId: null,
-                        });
-                        lastTimestamp = messages[messages.length - 1].timestamp;
+                if (role === 'assistant') {
+                    // response_item assistant message: content has output_text items
+                    const assistantContent = extractContent(payload);
+                    if (assistantContent) {
+                        currentAssistantText += assistantContent + '\n';
                     }
-                    break;
+                    lastTimestamp = parseEnvelopeTimestamp(event) || lastTimestamp;
                 }
-                case 'agent_message':
-                case 'agentMessage':
-                case 'item.completed': {
-                    const item = (payload.item || payload);
-                    const itemType = item.type || innerType;
-                    if (itemType === 'agent_message' || itemType === 'agentMessage') {
-                        currentAssistantText += (item.text || payload.text || '') + '\n';
-                    }
-                    else if (itemType === 'command_execution' || itemType === 'commandExecution') {
-                        toolCounter++;
-                        currentToolCalls.push({
-                            id: item.id || `codex-tool-${toolCounter}`,
-                            name: 'shell',
-                            input: { command: item.command || '', cwd: item.cwd || '' },
-                        });
-                        if (item.aggregatedOutput) {
-                            currentToolResults.push({
-                                toolUseId: item.id || `codex-tool-${toolCounter}`,
-                                output: (item.aggregatedOutput || '').slice(0, 1000),
-                            });
-                        }
-                    }
-                    else if (itemType === 'file_change' || itemType === 'fileChange') {
-                        if (item.changes) {
-                            for (const change of item.changes) {
-                                toolCounter++;
-                                currentToolCalls.push({
-                                    id: `codex-file-${toolCounter}`,
-                                    name: 'apply_patch',
-                                    input: { path: change.path, kind: change.kind },
-                                });
-                                if (change.diff) {
-                                    currentToolResults.push({
-                                        toolUseId: `codex-file-${toolCounter}`,
-                                        output: change.diff.slice(0, 1000),
-                                    });
-                                }
-                            }
-                        }
+                // Skip role === 'user' — handled by event_msg/user_message case.
+                // Both response_item/message(role=user) and event_msg/user_message fire for
+                // every user prompt, so only capturing from one source avoids doubling the count.
+                break;
+            }
+            case 'user_message':
+            case 'userMessage': {
+                // event_msg/user_message: the real user prompt (payload.message = text string)
+                flushAssistantTurn();
+                // event_msg user_message stores the text directly in payload.message
+                const msgText = payload.message || '';
+                if (msgText) {
+                    messages.push({
+                        id: payload.id || `codex-user-${messages.length}`,
+                        sessionId: sessionId,
+                        type: 'user',
+                        content: msgText.slice(0, 10000),
+                        thinking: null,
+                        toolCalls: [],
+                        toolResults: [],
+                        usage: null,
+                        timestamp: parseEnvelopeTimestamp(event) || lastTimestamp,
+                        parentId: null,
+                    });
+                    lastTimestamp = messages[messages.length - 1].timestamp;
+                }
+                break;
+            }
+            case 'agent_message': {
+                // event_msg/agent_message fires alongside response_item/message(role=assistant).
+                // Text is already captured via that handler — only update timestamp here to
+                // avoid duplicating assistant content.
+                lastTimestamp = parseEnvelopeTimestamp(event) || lastTimestamp;
+                break;
+            }
+            case 'function_call': {
+                // response_item/function_call: tool invocation (exec_command, etc.)
+                // payload: { type, name, arguments (JSON string), call_id, status? }
+                toolCounter++;
+                const callId = payload.call_id || `codex-tool-${toolCounter}`;
+                let args = {};
+                try {
+                    args = JSON.parse(payload.arguments);
+                }
+                catch {
+                    // arguments not valid JSON — store raw
+                    args = { raw: payload.arguments };
+                }
+                currentToolCalls.push({
+                    id: callId,
+                    name: payload.name || 'unknown',
+                    input: args,
+                });
+                lastTimestamp = parseEnvelopeTimestamp(event) || lastTimestamp;
+                break;
+            }
+            case 'function_call_output': {
+                // response_item/function_call_output: tool result
+                // payload: { type, call_id, output (string) }
+                const fcoCallId = payload.call_id;
+                const output = (payload.output || '').slice(0, 1000);
+                if (fcoCallId) {
+                    currentToolResults.push({ toolUseId: fcoCallId, output });
+                }
+                break;
+            }
+            case 'custom_tool_call': {
+                // response_item/custom_tool_call: apply_patch and similar custom tools
+                // payload: { type, name, call_id, input (string), status? }
+                toolCounter++;
+                const ctcCallId = payload.call_id || `codex-custom-${toolCounter}`;
+                currentToolCalls.push({
+                    id: ctcCallId,
+                    name: payload.name || 'custom_tool',
+                    input: { raw: (payload.input || '').slice(0, 2000) },
+                });
+                lastTimestamp = parseEnvelopeTimestamp(event) || lastTimestamp;
+                break;
+            }
+            case 'custom_tool_call_output': {
+                // response_item/custom_tool_call_output: apply_patch result (output is JSON string)
+                // payload: { type, call_id, output (JSON string with nested .output field) }
+                const ctcoCallId = payload.call_id;
+                let ctcoOutput = payload.output || '';
+                try {
+                    // output field is often {"output":"...","metadata":{...}} — unwrap it
+                    const parsed = JSON.parse(ctcoOutput);
+                    if (typeof parsed.output === 'string') {
+                        ctcoOutput = parsed.output;
                     }
-                    else if (itemType === 'mcp_tool_call' || itemType === 'mcpToolCall') {
-                        toolCounter++;
-                        currentToolCalls.push({
-                            id: item.id || `codex-mcp-${toolCounter}`,
-                            name: item.tool || 'mcp_tool',
-                            input: item.arguments || {},
-                        });
-                        if (item.result) {
-                            currentToolResults.push({
-                                toolUseId: item.id || `codex-mcp-${toolCounter}`,
-                                output: (item.result || '').slice(0, 1000),
-                            });
-                        }
+                }
+                catch {
+                    // not JSON — use raw
+                }
+                if (ctcoCallId) {
+                    currentToolResults.push({ toolUseId: ctcoCallId, output: ctcoOutput.slice(0, 1000) });
+                }
+                break;
+            }
+            case 'reasoning': {
+                // response_item/reasoning: model's internal reasoning summary
+                // payload.summary is an array of { type: "summary_text", text: "..." }
+                const summary = payload.summary;
+                if (Array.isArray(summary)) {
+                    const reasoningText = summary
+                        .filter(s => s.type === 'summary_text')
+                        .map(s => s.text)
+                        .join('\n');
+                    if (reasoningText)
+                        currentThinking = (currentThinking || '') + reasoningText + '\n';
+                }
+                break;
+            }
+            case 'agent_reasoning': {
+                // event_msg/agent_reasoning: streaming thinking text
+                const reasoningText = payload.text || '';
+                if (reasoningText)
+                    currentThinking = (currentThinking || '') + reasoningText + '\n';
+                break;
+            }
+            case 'task_complete': {
+                // event_msg/task_complete: turn boundary — replaces the non-existent "turn.completed"
+                // Capture usage if present
+                const usageRaw = payload.usage;
+                if (usageRaw?.input_tokens) {
+                    turnUsage = usageRaw;
+                    usageEntries.push(usageRaw);
+                }
+                if (payload.model) {
+                    model = payload.model;
+                }
+                flushAssistantTurn();
+                break;
+            }
+            case 'turn.completed': {
+                // Legacy event name — handle in case some versions use it
+                const usage = (payload.usage || payload);
+                if (usage.input_tokens) {
+                    turnUsage = usage;
+                    usageEntries.push(usage);
+                }
+                if (payload.model) {
+                    model = payload.model;
+                }
+                flushAssistantTurn();
+                break;
+            }
+            case 'turn.started':
+            case 'thread.started':
+            case 'session_meta':
+            case 'task_started':
+            case 'token_count':
+            case 'turn_context':
+                // Lifecycle/telemetry events — skip
+                break;
+            default:
+                break;
+        }
+    }
+    // Flush any remaining assistant content after all lines processed
+    flushAssistantTurn();
+    return buildSession(sessionId, meta.cwd || 'codex://unknown', meta.cli_version || null, meta.timestamp, messages, usageEntries, model);
+}
+// ---------------------------------------------------------------------------
+// Format B parser (pre-2025 single JSON object: { session, items })
+// ---------------------------------------------------------------------------
+function parseFormatB(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed.session?.id || !Array.isArray(parsed.items))
+        return null;
+    const meta = parsed.session;
+    const sessionId = `codex:${meta.id}`;
+    const sessionTimestamp = meta.timestamp;
+    const messages = [];
+    const usageEntries = [];
+    const model = meta.model || '';
+    // Accumulators for current assistant turn
+    let currentToolCalls = [];
+    let currentToolResults = [];
+    let currentThinking = null;
+    let toolCounter = 0;
+    // Format B has no per-item timestamps — use session timestamp for all
+    const sessionDate = new Date(sessionTimestamp);
+    function flushAssistantTurn() {
+        if (currentToolCalls.length === 0 && !currentThinking)
+            return;
+        messages.push({
+            id: `codex-assistant-${messages.length}`,
+            sessionId: sessionId,
+            type: 'assistant',
+            content: '',
+            thinking: currentThinking,
+            toolCalls: [...currentToolCalls],
+            toolResults: [...currentToolResults],
+            usage: null,
+            timestamp: sessionDate,
+            parentId: null,
+        });
+        currentToolCalls = [];
+        currentToolResults = [];
+        currentThinking = null;
+    }
+    for (const item of parsed.items) {
+        if (!item.type)
+            continue;
+        if (item.role === 'user' && item.type === 'message') {
+            // Flush pending assistant turn before new user message
+            flushAssistantTurn();
+            const userContent = extractFormatBContent(item.content);
+            if (userContent && !isSystemContextMessage(userContent)) {
+                messages.push({
+                    id: `codex-user-${messages.length}`,
+                    sessionId: sessionId,
+                    type: 'user',
+                    content: userContent.slice(0, 10000),
+                    thinking: null,
+                    toolCalls: [],
+                    toolResults: [],
+                    usage: null,
+                    timestamp: sessionDate,
+                    parentId: null,
+                });
+            }
+            continue;
+        }
+        switch (item.type) {
+            case 'reasoning': {
+                // summary is array of { type: "summary_text", text: "..." }
+                // In older sessions summary may be empty []
+                if (Array.isArray(item.summary)) {
+                    const reasoningText = item.summary
+                        .filter(s => s.type === 'summary_text')
+                        .map(s => s.text)
+                        .join('\n');
+                    if (reasoningText)
+                        currentThinking = (currentThinking || '') + reasoningText + '\n';
+                }
+                break;
+            }
+            case 'function_call': {
+                // item: { type, id, name, arguments (JSON string), call_id, status }
+                toolCounter++;
+                const callId = item.call_id || item.id || `codex-tool-${toolCounter}`;
+                let args = {};
+                if (item.arguments) {
+                    try {
+                        args = JSON.parse(item.arguments);
                     }
-                    else if (itemType === 'reasoning') {
-                        currentThinking = item.summary || item.text || null;
+                    catch {
+                        args = { raw: item.arguments };
                     }
-                    break;
                 }
-                case 'turn.completed': {
-                    const usage = (payload.usage || payload);
-                    if (usage.input_tokens) {
-                        turnUsage = usage;
-                        usageEntries.push(usage);
-                    }
-                    if (payload.model) {
-                        model = payload.model;
+                currentToolCalls.push({
+                    id: callId,
+                    name: item.name || 'unknown',
+                    input: args,
+                });
+                break;
+            }
+            case 'function_call_output': {
+                // item: { type, call_id, output (JSON string) }
+                const fcoCallId = item.call_id;
+                let fcoOutput = item.output || '';
+                try {
+                    // output is often {"output":"...","metadata":{...}}
+                    const outputParsed = JSON.parse(fcoOutput);
+                    if (typeof outputParsed.output === 'string') {
+                        fcoOutput = outputParsed.output;
                     }
-                    // Flush assistant turn at turn boundary
-                    flushAssistantTurn();
-                    break;
                 }
-                case 'turn.started':
-                case 'thread.started':
-                case 'session_meta':
-                    // Lifecycle events — skip
-                    break;
+                catch {
+                    // not JSON — use raw
+                }
+                if (fcoCallId) {
+                    currentToolResults.push({ toolUseId: fcoCallId, output: fcoOutput.slice(0, 1000) });
+                }
+                break;
             }
         }
-        // Flush any remaining assistant content
-        flushAssistantTurn();
-        if (messages.length === 0)
-            return null;
-        // Build session
-        const userMessages = messages.filter(m => m.type === 'user');
-        const assistantMessages = messages.filter(m => m.type === 'assistant');
-        const toolCallCount = messages.reduce((sum, m) => sum + m.toolCalls.length, 0);
-        const timestamps = messages.map(m => m.timestamp.getTime()).filter(t => t > 0);
-        const startedAt = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : new Date(meta.timestamp);
-        const endedAt = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : lastTimestamp;
-        // Build session usage from accumulated turn usage
-        const totalInput = usageEntries.reduce((s, u) => s + (u.input_tokens || 0), 0);
-        const totalOutput = usageEntries.reduce((s, u) => s + (u.output_tokens || 0), 0);
-        const totalCached = usageEntries.reduce((s, u) => s + (u.cached_input_tokens || 0), 0);
-        const usage = totalInput > 0 ? {
-            totalInputTokens: totalInput,
-            totalOutputTokens: totalOutput,
-            cacheCreationTokens: 0,
-            cacheReadTokens: totalCached,
-            estimatedCostUsd: 0, // TODO: Codex pricing not public
-            modelsUsed: model ? [model] : [],
-            primaryModel: model || 'unknown',
-            usageSource: 'jsonl',
-        } : undefined;
-        const projectPath = meta.cwd || 'codex://unknown';
-        const projectName = path.basename(projectPath);
-        const session = {
-            id: sessionId,
-            projectPath,
-            projectName,
-            summary: null,
-            generatedTitle: null,
-            titleSource: null,
-            sessionCharacter: null,
-            startedAt,
-            endedAt,
-            messageCount: messages.length,
-            userMessageCount: userMessages.length,
-            assistantMessageCount: assistantMessages.length,
-            toolCallCount,
-            gitBranch: null,
-            claudeVersion: meta.cli_version || null,
-            sourceTool: 'codex-cli',
-            usage,
-            messages,
-        };
-        // Generate title and character
-        const titleResult = generateTitle(session);
-        session.generatedTitle = titleResult.title;
-        session.titleSource = titleResult.source;
-        session.sessionCharacter = titleResult.character || detectSessionCharacter(session);
-        return session;
     }
-    catch {
+    // Flush any remaining assistant content
+    flushAssistantTurn();
+    const projectPath = parsed.session.cwd || 'codex://unknown';
+    return buildSession(sessionId, projectPath, null, sessionTimestamp, messages, usageEntries, model);
+}
+// ---------------------------------------------------------------------------
+// Shared session builder
+// ---------------------------------------------------------------------------
+function buildSession(sessionId, projectPath, cliVersion, metaTimestamp, messages, usageEntries, model) {
+    if (messages.length === 0)
         return null;
-    }
+    const userMessages = messages.filter(m => m.type === 'user');
+    const assistantMessages = messages.filter(m => m.type === 'assistant');
+    const toolCallCount = messages.reduce((sum, m) => sum + m.toolCalls.length, 0);
+    const timestamps = messages.map(m => m.timestamp.getTime()).filter(t => t > 0);
+    const startedAt = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : new Date(metaTimestamp);
+    const endedAt = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : new Date(metaTimestamp);
+    const totalInput = usageEntries.reduce((s, u) => s + (u.input_tokens || 0), 0);
+    const totalOutput = usageEntries.reduce((s, u) => s + (u.output_tokens || 0), 0);
+    const totalCached = usageEntries.reduce((s, u) => s + (u.cached_input_tokens || 0), 0);
+    const usage = totalInput > 0 ? {
+        totalInputTokens: totalInput,
+        totalOutputTokens: totalOutput,
+        cacheCreationTokens: 0,
+        cacheReadTokens: totalCached,
+        estimatedCostUsd: 0, // Codex pricing not public
+        modelsUsed: model ? [model] : [],
+        primaryModel: model || 'unknown',
+        usageSource: 'jsonl',
+    } : undefined;
+    const projectName = path.basename(projectPath);
+    const session = {
+        id: sessionId,
+        projectPath,
+        projectName,
+        summary: null,
+        generatedTitle: null,
+        titleSource: null,
+        sessionCharacter: null,
+        startedAt,
+        endedAt,
+        messageCount: messages.length,
+        userMessageCount: userMessages.length,
+        assistantMessageCount: assistantMessages.length,
+        toolCallCount,
+        gitBranch: null,
+        claudeVersion: cliVersion,
+        sourceTool: 'codex-cli',
+        usage,
+        messages,
+    };
+    const titleResult = generateTitle(session);
+    session.generatedTitle = titleResult.title;
+    session.titleSource = titleResult.source;
+    session.sessionCharacter = titleResult.character || detectSessionCharacter(session);
+    return session;
 }
 // ---------------------------------------------------------------------------
 // Parsing helpers
@@ -354,7 +546,7 @@ function parseCodexSession(filePath) {
 function parseSessionMeta(line) {
     try {
         const parsed = JSON.parse(line);
-        // Handle RolloutLine envelope
+        // Handle RolloutLine envelope: { type: "session_meta", payload: { id, cwd, ... } }
         if (parsed.payload && parsed.type === 'session_meta') {
             return parsed.payload;
         }
@@ -368,28 +560,67 @@ function parseSessionMeta(line) {
         return null;
     }
 }
-function extractUserContent(payload) {
+/**
+ * Extract text content from a Format A payload.
+ * Handles: plain text, content arrays with input_text/output_text/text types,
+ * and nested item wrappers.
+ */
+function extractContent(payload) {
     if (typeof payload.text === 'string')
         return payload.text;
     if (typeof payload.content === 'string')
         return payload.content;
     if (Array.isArray(payload.content)) {
-        return payload.content
-            .filter(c => c.type === 'text' || c.type === 'input_text')
+        const parts = payload.content
+            .filter(c => c.type === 'text' || c.type === 'input_text' || c.type === 'output_text')
             .map(c => c.text)
-            .join('\n');
+            .filter(Boolean);
+        return parts.length > 0 ? parts.join('\n') : null;
     }
-    // Nested in item
+    // Nested in item wrapper
     const item = payload.item;
     if (item)
-        return extractUserContent(item);
+        return extractContent(item);
     return null;
 }
-function parseTimestamp(payload) {
-    const ts = payload.timestamp || payload.createdAt;
+/**
+ * Extract text content from Format B item content array.
+ */
+function extractFormatBContent(content) {
+    if (!Array.isArray(content))
+        return null;
+    const parts = content
+        .filter(c => c.type === 'text' || c.type === 'input_text' || c.type === 'output_text')
+        .map(c => c.text)
+        .filter(Boolean);
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+/**
+ * Parse the envelope-level timestamp from a Format A RolloutLine.
+ * Every line in Format A has a top-level `timestamp` ISO 8601 string.
+ */
+function parseEnvelopeTimestamp(event) {
+    const ts = event.timestamp;
     if (!ts)
         return null;
     const d = new Date(ts);
     return isNaN(d.getTime()) ? null : d;
 }
+/**
+ * Detect system context injection messages that should not be treated as user prompts.
+ * Codex CLI injects AGENTS.md, environment context, permissions, etc. as role="user" messages
+ * before the actual user prompt. We filter these out to avoid polluting the message list.
+ */
+function isSystemContextMessage(content) {
+    const trimmed = content.trimStart();
+    return (trimmed.startsWith('<permissions') ||
+        trimmed.startsWith('<environment_context') ||
+        trimmed.startsWith('<collaboration_mode') ||
+        trimmed.startsWith('# AGENTS.md') ||
+        trimmed.startsWith('## Apps') ||
+        trimmed.startsWith('## Tools') ||
+        trimmed.startsWith('<system') ||
+        trimmed.startsWith('## Shell') ||
+        trimmed.startsWith('## Current working directory'));
+}
 //# sourceMappingURL=codex.js.map