@termfleet/core 0.1.0

package/dist/agent-session.js

@@ -0,0 +1,1688 @@
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { readFile as readFileAsync } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+// Agent transcripts live under the host home by default. TERMFLEET_AGENT_HOME
+// overrides the root so throwaway stacks and tests can seed a deterministic
+// `.claude`/`.codex` tree without touching the real home directory.
+export function agentHome() {
+    return process.env.TERMFLEET_AGENT_HOME || homedir();
+}
+// A bare session id becomes a path segment (the transcript file name), so before
+// it is used to BUILD A PATH it must be constrained to a filename-safe alphabet —
+// otherwise a value like "../../../../etc/passwd" climbs out of the agent-home
+// tree and turns a transcript read into an arbitrary-file read. Real
+// Claude/Codex/Gemini ids are UUIDs (legacy ids are numeric pids), so this never
+// rejects a genuine id. Applied at each transcript-path sink, NOT in the
+// normalize* strippers — those are also used to derive id fields (e.g. the
+// composite "claude-subagent:<parent>:<agent>" id), which legitimately contain
+// characters outside the path alphabet.
+export function assertSafeAgentSessionId(bareId) {
+    if (!/^[A-Za-z0-9_-]+$/.test(bareId)) {
+        throw new Error(`Invalid agent session id: ${JSON.stringify(bareId)}`);
+    }
+    return bareId;
+}
+export function normalizeClaudeSessionId(sessionId) {
+    return sessionId.startsWith("claude:") ? sessionId.slice("claude:".length) : sessionId;
+}
+export function encodeClaudeCwd(cwd) {
+    return cwd.replace(/[/. ]/g, "-");
+}
+export function claudeTranscriptPath(options) {
+    return join(options.home ?? agentHome(), ".claude", "projects", encodeClaudeCwd(options.cwd), `${assertSafeAgentSessionId(normalizeClaudeSessionId(options.sessionId))}.jsonl`);
+}
+export function normalizeCodexSessionId(sessionId) {
+    return sessionId.startsWith("codex:") ? sessionId.slice("codex:".length) : sessionId;
+}
+// Codex injects harness boilerplate as leading user-role turns: the project
+// AGENTS.md (`# AGENTS.md instructions for …`, wrapping `<INSTRUCTIONS>`), the
+// `<environment_context>` block, and `<user_instructions>`. None are human
+// conversation — they precede the real first message and must not become a
+// title or render as a user bubble.
+const CODEX_INJECTED_PREFIXES = ["# AGENTS.md instructions for ", "<environment_context>", "<user_instructions>"];
+export function isCodexInjectedContext(raw) {
+    const text = raw.trimStart();
+    return CODEX_INJECTED_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+export function codexTranscriptPath(options) {
+    const home = options.home ?? agentHome();
+    const sessionsRoot = join(home, ".codex", "sessions");
+    const codexSessionId = assertSafeAgentSessionId(normalizeCodexSessionId(options.sessionId));
+    return findCodexTranscriptById(sessionsRoot, codexSessionId);
+}
+export function readLocalClaudeSession(options) {
+    const transcriptPath = resolveClaudeTranscriptPath(options);
+    if (!transcriptPath) {
+        return emptyClaudeSession(options);
+    }
+    return parseClaudeSessionJsonl({
+        jsonl: readFileSync(transcriptPath, "utf8"),
+        sessionId: options.sessionId,
+        transcriptPath
+    });
+}
+// Resolve a Claude transcript by id, searching every project dir (so an agent's
+// working dir need not match the caller's). Returns undefined when no transcript
+// exists yet — which is not an error: a freshly-launched agent has a session id
+// but writes its transcript only once the conversation produces messages.
+export function resolveClaudeTranscriptPath(options) {
+    const expectedTranscriptPath = claudeTranscriptPath(options);
+    if (existsSync(expectedTranscriptPath)) {
+        return expectedTranscriptPath;
+    }
+    const found = findClaudeTranscriptById(join(options.home ?? agentHome(), ".claude", "projects"), assertSafeAgentSessionId(normalizeClaudeSessionId(options.sessionId)));
+    return existsSync(found) ? found : undefined;
+}
+// A real, openable chat for a session that has no transcript yet — just an empty
+// conversation. Parsing empty JSONL yields a well-formed session with zero
+// messages, so a just-launched agent displays as an empty chat instead of 500ing.
+export function emptyClaudeSession(options) {
+    return parseClaudeSessionJsonl({ jsonl: "", sessionId: options.sessionId, transcriptPath: claudeTranscriptPath(options) });
+}
+export function readLocalAgentSession(options) {
+    if (options.sessionId.startsWith("codex:")) {
+        return readLocalCodexSession(options);
+    }
+    if (options.sessionId.startsWith("gemini:")) {
+        return readLocalGeminiSession(options);
+    }
+    return readLocalClaudeSession(options);
+}
+// Gemini transcripts live at ~/.gemini/tmp/<slug>/chats/session-*.jsonl, one per
+// session, with the sessionId in the header (the filename is a short id, not the
+// session id). Resolve by narrowing to the cwd's chats dir via projects.json, then
+// matching the header sessionId; fall back to a full walk.
+// See docs/architecture/gemini-sessions.md.
+export function normalizeGeminiSessionId(sessionId) {
+    return sessionId.startsWith("gemini:") ? sessionId.slice("gemini:".length) : sessionId;
+}
+function geminiChatsDir(options) {
+    if (!options.cwd)
+        return undefined;
+    try {
+        const raw = JSON.parse(readFileSync(join(options.home ?? agentHome(), ".gemini", "projects.json"), "utf8"));
+        const slug = raw.projects?.[options.cwd];
+        if (slug)
+            return join(options.home ?? agentHome(), ".gemini", "tmp", slug, "chats");
+    }
+    catch { /* no projects.json — fall back to a full walk */ }
+    return undefined;
+}
+function geminiHeaderSessionId(transcriptPath) {
+    const fd = openSync(transcriptPath, "r");
+    try {
+        // Read until the first newline rather than a fixed buffer — a header line that
+        // exceeded 8KB used to truncate, fail to parse, and silently show an empty
+        // chat. Cap the scan so a newline-less file can't be read unboundedly, and
+        // search for the newline at the byte level so a multibyte char can't split.
+        const maxHeaderBytes = 1_048_576;
+        const chunk = Buffer.alloc(65536);
+        const parts = [];
+        let position = 0;
+        while (position < maxHeaderBytes) {
+            const read = readSync(fd, chunk, 0, chunk.length, position);
+            if (read === 0)
+                break;
+            const slice = chunk.subarray(0, read);
+            const newline = slice.indexOf(0x0a);
+            if (newline >= 0) {
+                parts.push(slice.subarray(0, newline));
+                break;
+            }
+            parts.push(Buffer.from(slice));
+            position += read;
+        }
+        const header = JSON.parse(Buffer.concat(parts).toString("utf8"));
+        return typeof header.sessionId === "string" ? header.sessionId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function resolveGeminiTranscriptPath(options) {
+    const bareId = assertSafeAgentSessionId(normalizeGeminiSessionId(options.sessionId));
+    const tmpRoot = join(options.home ?? agentHome(), ".gemini", "tmp");
+    const narrowed = geminiChatsDir(options);
+    const roots = narrowed && existsSync(narrowed) ? [narrowed, tmpRoot] : [tmpRoot];
+    const seen = new Set();
+    for (const root of roots) {
+        for (const transcriptPath of walkJsonl(root)) {
+            if (seen.has(transcriptPath))
+                continue;
+            seen.add(transcriptPath);
+            if (geminiHeaderSessionId(transcriptPath) === bareId)
+                return transcriptPath;
+        }
+    }
+    return undefined;
+}
+export function readLocalGeminiSession(options) {
+    const transcriptPath = resolveGeminiTranscriptPath(options);
+    const sessionId = options.sessionId.includes(":") ? options.sessionId : `gemini:${options.sessionId}`;
+    if (!transcriptPath) {
+        return { agentSessionId: sessionId, endOfTurn: false, lastAssistantText: "", messages: [], provider: "gemini", sessionId, timeline: [] };
+    }
+    return parseGeminiSessionJsonl({ jsonl: readFileSync(transcriptPath, "utf8"), sessionId, transcriptPath });
+}
+export function geminiContentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => (part && typeof part === "object" && typeof part.text === "string" ? part.text : ""))
+            .join(" ")
+            .trim();
+    }
+    return "";
+}
+export function parseGeminiSessionJsonl(options) {
+    const sessionId = options.sessionId.includes(":") ? options.sessionId : `gemini:${options.sessionId}`;
+    const messages = [];
+    const timeline = [];
+    for (const line of options.jsonl.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "user" && entry.type !== "gemini")
+            continue;
+        const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+        if (entry.type === "gemini" && Array.isArray(entry.thoughts)) {
+            const thought = entry.thoughts
+                .map((item) => (typeof item?.description === "string" ? item.description : typeof item?.subject === "string" ? item.subject : ""))
+                .filter(Boolean)
+                .join("\n");
+            if (thought)
+                timeline.push({ kind: "gemini_thinking", text: thought, ...(timestamp ? { timestamp } : {}) });
+        }
+        const text = geminiContentText(entry.content);
+        if (!text)
+            continue;
+        const role = entry.type === "user" ? "user" : "assistant";
+        messages.push({ role, text, ...(timestamp ? { timestamp } : {}) });
+        timeline.push({ kind: entry.type === "user" ? "gemini_user_message" : "gemini_assistant_message", text, ...(timestamp ? { timestamp } : {}) });
+    }
+    const assistantMessages = messages.filter((message) => message.role === "assistant");
+    const firstAssistantMessage = assistantMessages[0];
+    const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+    const firstMessage = messages[0];
+    const lastMessage = messages[messages.length - 1];
+    return {
+        agentSessionId: sessionId,
+        endOfTurn: lastMessage?.role === "assistant",
+        ...(firstAssistantMessage ? { firstAssistantMessage } : {}),
+        ...(firstMessage ? { firstMessage } : {}),
+        ...(lastAssistantMessage ? { lastAssistantMessage } : {}),
+        lastAssistantText: lastAssistantMessage?.text ?? "",
+        ...(lastMessage ? { lastMessage } : {}),
+        messages,
+        provider: "gemini",
+        sessionId,
+        timeline,
+        ...(options.transcriptPath ? { transcriptPath: options.transcriptPath } : {})
+    };
+}
+// Async twin used by the per-request session-detail path (HTTP open-a-chat,
+// socket subscribe ack). The full transcript read is the only large I/O — path
+// resolution is bounded (stat + first-line reads) — so reading it async keeps a
+// multi-megabyte transcript open from blocking the provider event loop. Parsing
+// is unavoidable CPU work but one-shot per open.
+export async function readLocalAgentSessionAsync(options) {
+    // A subagent sidechain, addressed by its composite id (claude-subagent:…).
+    // Read directly; it has no subagents of its own (no nesting).
+    const subagentRef = parseSubagentSessionId(options.sessionId);
+    if (subagentRef) {
+        const transcriptPath = resolveClaudeSubagentTranscriptPath({ ...(options.home ? { home: options.home } : {}), ...subagentRef });
+        return parseClaudeSessionJsonl({ jsonl: await readFileAsync(transcriptPath, "utf8"), sessionId: options.sessionId, transcriptPath });
+    }
+    if (options.sessionId.startsWith("codex:")) {
+        const transcriptPath = codexTranscriptPath(options);
+        if (!transcriptPath) {
+            throw new Error(`Codex session transcript was not found for ${options.sessionId} in ${options.cwd}`);
+        }
+        return parseCodexSessionJsonl({ jsonl: await readFileAsync(transcriptPath, "utf8"), sessionId: options.sessionId, transcriptPath });
+    }
+    if (options.sessionId.startsWith("gemini:")) {
+        const transcriptPath = resolveGeminiTranscriptPath(options);
+        if (!transcriptPath) {
+            return readLocalGeminiSession(options);
+        }
+        return parseGeminiSessionJsonl({ jsonl: await readFileAsync(transcriptPath, "utf8"), sessionId: options.sessionId, transcriptPath });
+    }
+    const transcriptPath = resolveClaudeTranscriptPath(options);
+    if (!transcriptPath) {
+        return emptyClaudeSession(options);
+    }
+    const details = parseClaudeSessionJsonl({ jsonl: await readFileAsync(transcriptPath, "utf8"), sessionId: options.sessionId, transcriptPath });
+    const subagents = listLocalAgentSubagents({ ...(options.home ? { home: options.home } : {}), sessionId: options.sessionId, transcriptPath });
+    return subagents.length ? { ...details, subagents } : details;
+}
+// Composite session id for a subagent sidechain, so the existing watcher/socket
+// (keyed by an opaque session id) can stream it live like any other session:
+//   claude-subagent:<parent-session-id>:<agent-id>
+const CLAUDE_SUBAGENT_PREFIX = "claude-subagent:";
+export function makeSubagentSessionId(parentSessionId, agentId) {
+    return `${CLAUDE_SUBAGENT_PREFIX}${normalizeClaudeSessionId(parentSessionId)}:${agentId}`;
+}
+export function parseSubagentSessionId(sessionId) {
+    if (!sessionId.startsWith(CLAUDE_SUBAGENT_PREFIX))
+        return undefined;
+    const rest = sessionId.slice(CLAUDE_SUBAGENT_PREFIX.length);
+    const separator = rest.indexOf(":");
+    if (separator <= 0 || separator === rest.length - 1)
+        return undefined;
+    return { agentId: rest.slice(separator + 1), parentSessionId: rest.slice(0, separator) };
+}
+// Resolve a subagent sidechain to its file. The agent id is constrained to the
+// file-name alphabet so it can never escape the resolved subagents directory.
+export function resolveClaudeSubagentTranscriptPath(options) {
+    if (!/^[A-Za-z0-9_-]+$/.test(options.agentId)) {
+        throw new Error(`Invalid subagent id: ${options.agentId}`);
+    }
+    const sessionId = options.parentSessionId ?? options.sessionId ?? "";
+    const dir = claudeSubagentsDir({ ...(options.home ? { home: options.home } : {}), sessionId });
+    if (!dir) {
+        throw new Error(`No subagents found for session ${sessionId}`);
+    }
+    const transcriptPath = join(dir, `agent-${options.agentId}.jsonl`);
+    if (!existsSync(transcriptPath)) {
+        throw new Error(`Subagent transcript was not found: ${options.agentId}`);
+    }
+    return transcriptPath;
+}
+// The subagents directory for a Claude session: a `subagents/` folder beside
+// the session's own `<id>/` directory. The transcript path is reused when known
+// (the open-a-chat path resolves it anyway); otherwise the parent is found by id.
+function claudeSubagentsDir(options) {
+    const bareId = assertSafeAgentSessionId(normalizeClaudeSessionId(options.sessionId));
+    const transcriptPath = options.transcriptPath
+        ?? findClaudeTranscriptById(join(options.home ?? agentHome(), ".claude", "projects"), bareId);
+    if (!existsSync(transcriptPath))
+        return undefined;
+    const dir = join(dirname(transcriptPath), bareId, "subagents");
+    return existsSync(dir) ? dir : undefined;
+}
+// List a session's subagent sidechains by id + mtime (oldest first, i.e. spawn
+// order). Metadata only — never reads transcript content — so opening a chat
+// stays cheap regardless of how many subagents it spawned.
+export function listLocalAgentSubagents(options) {
+    const dir = claudeSubagentsDir(options);
+    if (!dir)
+        return [];
+    const refs = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl") || !entry.name.startsWith("agent-"))
+            continue;
+        const agentId = entry.name.slice("agent-".length, -".jsonl".length);
+        if (!agentId)
+            continue;
+        refs.push({ agentId, updatedAt: new Date(statSync(join(dir, entry.name)).mtimeMs).toISOString() });
+    }
+    return refs.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt) || a.agentId.localeCompare(b.agentId));
+}
+// Read one subagent's full sidechain transcript on demand. The agent id is
+// constrained to the file-name alphabet so it can never escape the resolved
+// subagents directory.
+export async function readLocalAgentSubagentSessionAsync(options) {
+    const transcriptPath = resolveClaudeSubagentTranscriptPath(options);
+    return parseClaudeSessionJsonl({
+        jsonl: await readFileAsync(transcriptPath, "utf8"),
+        sessionId: `claude:${options.agentId}`,
+        transcriptPath
+    });
+}
+export function readLocalCodexSession(options) {
+    const transcriptPath = codexTranscriptPath(options);
+    if (!transcriptPath) {
+        throw new Error(`Codex session transcript was not found for ${options.sessionId} in ${options.cwd}`);
+    }
+    return parseCodexSessionJsonl({
+        jsonl: readFileSync(transcriptPath, "utf8"),
+        sessionId: options.sessionId,
+        transcriptPath
+    });
+}
+function messageSummaryFields(messages) {
+    const summaries = messages.map((message) => ({
+        role: message.role,
+        text: message.text,
+        ...(message.timestamp ? { timestamp: message.timestamp } : {})
+    }));
+    const assistantSummaries = summaries.filter((message) => message.role === "assistant");
+    return {
+        ...(assistantSummaries[0] ? { firstAssistantMessage: assistantSummaries[0] } : {}),
+        ...(summaries[0] ? { firstMessage: summaries[0] } : {}),
+        ...(assistantSummaries.length ? { lastAssistantMessage: assistantSummaries[assistantSummaries.length - 1] } : {}),
+        ...(summaries.length ? { lastMessage: summaries[summaries.length - 1] } : {})
+    };
+}
+// Incremental fold over transcript lines: feedLine accumulates parser state
+// one JSONL line at a time, finalize snapshots the current details. Feeding
+// further lines after a finalize is supported (tail readers rely on it); the
+// snapshot copies the top-level arrays, but a later tool-result line may
+// still attach to a timeline item shared with an earlier snapshot, so
+// consumers should serialize a snapshot before the next feed.
+export function createClaudeSessionParser(options) {
+    const messages = [];
+    const timeline = [];
+    const toolCallsById = new Map();
+    let lastAssistantMessage;
+    return {
+        feedLine(line) {
+            if (!line.trim())
+                return;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            const metadataItem = timelineItemFromMetadataEntry(entry);
+            if (metadataItem) {
+                timeline.push(metadataItem);
+                return;
+            }
+            if (entry.type !== "assistant" && entry.type !== "user")
+                return;
+            const message = entry.message;
+            if (!message || typeof message !== "object" || Array.isArray(message))
+                return;
+            const messageRecord = message;
+            const blocks = blocksFromContent(messageRecord.content);
+            const text = blocks.map((block) => blockText(block)).filter(Boolean).join("\n\n");
+            if (!text)
+                return;
+            const conversationalBlocks = conversationalClaudeBlocks({ blocks, role: entry.type });
+            if (conversationalBlocks.length > 0) {
+                const conversationalMessage = {
+                    blocks: conversationalBlocks,
+                    role: entry.type,
+                    text: conversationalBlocks.map((block) => blockText(block)).filter(Boolean).join("\n\n"),
+                    ...(typeof messageRecord.stop_reason === "string" ? { stopReason: messageRecord.stop_reason } : {}),
+                    ...(typeof entry.timestamp === "string" ? { timestamp: entry.timestamp } : {})
+                };
+                messages.push(conversationalMessage);
+                if (conversationalMessage.role === "assistant") {
+                    lastAssistantMessage = conversationalMessage;
+                }
+            }
+            timeline.push(...timelineItemsFromMessage({
+                blocks,
+                entry,
+                role: entry.type,
+                timeline,
+                toolCallsById
+            }));
+        },
+        finalize() {
+            const agentSessionId = normalizeClaudeSessionId(options.sessionId);
+            const summary = messageSummaryFields(messages);
+            return {
+                agentSessionId,
+                endOfTurn: lastAssistantMessage?.stopReason === "end_turn",
+                ...summary,
+                lastAssistantText: lastAssistantMessage?.text ?? "",
+                messages: messages.slice(),
+                provider: "claude",
+                sessionId: `claude:${agentSessionId}`,
+                timeline: timeline.slice(),
+                ...(options.transcriptPath ? { transcriptPath: options.transcriptPath } : {})
+            };
+        }
+    };
+}
+export function parseClaudeSessionJsonl(options) {
+    const parser = createClaudeSessionParser(options);
+    for (const line of options.jsonl.split("\n")) {
+        parser.feedLine(line);
+    }
+    return parser.finalize();
+}
+function conversationalClaudeBlocks({ blocks, role }) {
+    if (role === "user") {
+        return blocks.every((block) => block.kind === "text") ? blocks : [];
+    }
+    return blocks.filter((block) => block.kind === "text" || block.kind === "thinking");
+}
+function codexTimelineItemFromResponsePayload(payload, timestamp, callsById, timeline) {
+    const payloadType = typeof payload.type === "string" ? payload.type : "";
+    if (payloadType === "message") {
+        const role = typeof payload.role === "string" ? payload.role : "assistant";
+        const text = codexContentText(payload.content);
+        if (!text)
+            return undefined;
+        if (role === "user") {
+            // Codex prepends synthetic user turns (AGENTS.md, the environment context
+            // block, user instructions). They are harness boilerplate, not human
+            // conversation — render them as dimmed context, never as a user bubble.
+            if (isCodexInjectedContext(text)) {
+                return { kind: "codex_context", label: "Context", text, ...(timestamp ? { timestamp } : {}) };
+            }
+            return { kind: "codex_user_message", text, ...(timestamp ? { timestamp } : {}) };
+        }
+        if (role === "assistant") {
+            return {
+                kind: "codex_assistant_message",
+                phase: typeof payload.phase === "string" ? payload.phase : undefined,
+                text,
+                ...(timestamp ? { timestamp } : {})
+            };
+        }
+        return {
+            kind: "codex_context",
+            label: role,
+            text,
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (payloadType === "reasoning") {
+        const summary = codexReasoningSummary(payload.summary);
+        const text = typeof payload.content === "string" && payload.content.trim()
+            ? payload.content
+            : summary;
+        if (!text)
+            return undefined;
+        return { kind: "codex_reasoning", ...(summary ? { summary } : {}), text, ...(timestamp ? { timestamp } : {}) };
+    }
+    if (payloadType === "web_search_call") {
+        return undefined;
+    }
+    if (payloadType === "function_call" || payloadType === "custom_tool_call" || payloadType === "tool_search_call") {
+        const name = codexToolName(payload);
+        const callId = typeof payload.call_id === "string" ? payload.call_id : undefined;
+        const toolCategory = toolCategoryForCodexName(name);
+        const args = codexToolArguments(payload);
+        if (callId) {
+            callsById.set(callId, { arguments: args, name, timelineIndex: timeline.length, timestamp, toolCategory });
+        }
+        return {
+            arguments: args,
+            ...(callId ? { callId } : {}),
+            kind: "codex_tool_call",
+            name,
+            toolCategory,
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output" || payloadType === "tool_search_output") {
+        const callId = typeof payload.call_id === "string" ? payload.call_id : undefined;
+        const call = callId ? callsById.get(callId) : undefined;
+        const output = codexToolOutput(payload);
+        if (call?.timelineIndex !== undefined) {
+            const existing = timeline[call.timelineIndex];
+            if (existing?.kind === "codex_tool_call") {
+                timeline[call.timelineIndex] = {
+                    ...(callId ? { callId } : {}),
+                    kind: "codex_tool_exchange",
+                    result: {
+                        output,
+                        ...(typeof payload.status === "string" ? { status: payload.status } : {}),
+                        ...(timestamp ? { timestamp } : {})
+                    },
+                    toolUse: {
+                        arguments: existing.arguments,
+                        name: existing.name,
+                        toolCategory: existing.toolCategory,
+                        ...(existing.timestamp ? { timestamp: existing.timestamp } : {})
+                    },
+                    ...(existing.timestamp ? { timestamp: existing.timestamp } : timestamp ? { timestamp } : {})
+                };
+                return undefined;
+            }
+        }
+        return {
+            ...(callId ? { callId } : {}),
+            kind: "codex_tool_result",
+            ...(call?.name ? { name: call.name } : {}),
+            output,
+            ...(typeof payload.status === "string" ? { status: payload.status } : {}),
+            toolCategory: call?.toolCategory ?? "generic",
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    return undefined;
+}
+function codexTimelineItemFromEventPayload(payload, timestamp) {
+    const type = typeof payload.type === "string" ? payload.type : "";
+    if (type === "token_count")
+        return undefined;
+    if (type === "task_started") {
+        return {
+            kind: "codex_task_event",
+            label: "Task started",
+            text: summarizeKeyValues(payload, ["turn_id", "model_context_window", "collaboration_mode_kind", "started_at"]),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "task_complete") {
+        return {
+            kind: "codex_task_event",
+            label: "Task complete",
+            text: summarizeKeyValues(payload, ["duration_ms", "time_to_first_token_ms", "last_agent_message"]),
+            tone: "success",
+            ...(timestampFromPayload(payload, "completed_at") ?? timestamp ? { timestamp: timestampFromPayload(payload, "completed_at") ?? timestamp } : {})
+        };
+    }
+    if (type === "turn_aborted") {
+        return {
+            kind: "codex_task_event",
+            label: "Turn aborted",
+            text: typeof payload.reason === "string" ? payload.reason : safeJson(payload),
+            tone: "warning",
+            ...(timestampFromPayload(payload, "completed_at") ?? timestamp ? { timestamp: timestampFromPayload(payload, "completed_at") ?? timestamp } : {})
+        };
+    }
+    if (type === "context_compacted") {
+        return { kind: "codex_compaction", text: "Context compacted.", ...(timestamp ? { timestamp } : {}) };
+    }
+    if (type === "exec_command_end") {
+        return codexToolCompletionEvent(payload, "exec_command", timestamp);
+    }
+    if (type === "patch_apply_end") {
+        return {
+            ...(typeof payload.call_id === "string" ? { callId: payload.call_id } : {}),
+            changes: codexPatchChanges(payload.changes),
+            kind: "codex_patch",
+            output: [payload.stdout, payload.stderr].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n") || safeJson(payload),
+            status: typeof payload.status === "string" ? payload.status : undefined,
+            success: payload.success === true,
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "mcp_tool_call_end") {
+        return codexToolCompletionEvent(payload, "mcp_tool", timestamp);
+    }
+    if (type === "web_search_end") {
+        return {
+            ...(typeof payload.call_id === "string" ? { callId: payload.call_id } : {}),
+            kind: "codex_web_search",
+            query: codexWebSearchQuery(payload),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "view_image_tool_call") {
+        return {
+            arguments: typeof payload.path === "string" ? payload.path : safeJson(payload),
+            ...(typeof payload.call_id === "string" ? { callId: payload.call_id } : {}),
+            kind: "codex_tool_call",
+            name: "view_image",
+            toolCategory: "file_read",
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "thread_goal_updated") {
+        const goal = payload.goal && typeof payload.goal === "object" ? payload.goal : undefined;
+        return {
+            kind: "codex_goal",
+            status: typeof goal?.status === "string" ? goal.status : undefined,
+            text: goal ? summarizeCodexGoal(goal) : safeJson(payload),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "entered_review_mode" || type === "exited_review_mode" || type === "item_completed") {
+        return {
+            kind: "codex_review",
+            text: summarizeCodexReview(payload),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "error") {
+        return {
+            kind: "codex_error",
+            text: typeof payload.message === "string" ? payload.message : safeJson(payload),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type === "agent_reasoning") {
+        return {
+            kind: "codex_reasoning",
+            text: typeof payload.text === "string" ? payload.text : safeJson(payload),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (type.startsWith("collab_") || type === "thread_rolled_back") {
+        return {
+            kind: "codex_task_event",
+            label: codexEventLabel(type),
+            text: safeJson(payload),
+            tone: type.includes("end") ? "success" : "default",
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    return {
+        kind: "codex_task_event",
+        label: codexEventLabel(type || "Event"),
+        text: safeJson(payload),
+        ...(timestamp ? { timestamp } : {})
+    };
+}
+function mergeCodexEventItemIntoCall({ callsById, item, timeline }) {
+    if (!("callId" in item) || !item.callId)
+        return false;
+    const call = callsById.get(item.callId);
+    const timelineIndex = call?.timelineIndex ?? timeline.findIndex((candidate) => "callId" in candidate && candidate.callId === item.callId);
+    if (timelineIndex < 0)
+        return false;
+    const existing = timeline[timelineIndex];
+    if (!existing)
+        return false;
+    if (item.kind === "codex_patch" && (call?.name === "apply_patch" || codexTimelineToolName(existing) === "apply_patch")) {
+        timeline[timelineIndex] = item;
+        return true;
+    }
+    if (item.kind === "codex_web_search" && (call?.name === "web_search" || codexTimelineToolName(existing) === "web_search")) {
+        timeline[timelineIndex] = item;
+        return true;
+    }
+    if (item.kind === "codex_tool_call") {
+        return existing.kind === "codex_tool_call" || existing.kind === "codex_tool_exchange";
+    }
+    if (item.kind !== "codex_tool_result")
+        return false;
+    if (existing.kind === "codex_tool_exchange") {
+        timeline[timelineIndex] = {
+            ...existing,
+            result: {
+                output: item.output,
+                ...(item.status ? { status: item.status } : {}),
+                ...(item.timestamp ? { timestamp: item.timestamp } : {})
+            }
+        };
+        return true;
+    }
+    if (existing.kind === "codex_tool_call") {
+        timeline[timelineIndex] = {
+            ...(item.callId ? { callId: item.callId } : {}),
+            kind: "codex_tool_exchange",
+            result: {
+                output: item.output,
+                ...(item.status ? { status: item.status } : {}),
+                ...(item.timestamp ? { timestamp: item.timestamp } : {})
+            },
+            toolUse: {
+                arguments: existing.arguments,
+                name: existing.name,
+                toolCategory: existing.toolCategory,
+                ...(existing.timestamp ? { timestamp: existing.timestamp } : {})
+            },
+            ...(existing.timestamp ? { timestamp: existing.timestamp } : item.timestamp ? { timestamp: item.timestamp } : {})
+        };
+        return true;
+    }
+    if (existing.kind === "codex_tool_result") {
+        timeline[timelineIndex] = item;
+        return true;
+    }
+    return false;
+}
+function codexTimelineToolName(item) {
+    if (item.kind === "codex_tool_call")
+        return item.name;
+    if (item.kind === "codex_tool_result")
+        return item.name;
+    if (item.kind === "codex_tool_exchange")
+        return item.toolUse.name;
+    return undefined;
+}
+export function parseCodexSessionJsonl(options) {
+    const messages = [];
+    const timeline = [];
+    const callsById = new Map();
+    let agentSessionId = normalizeCodexSessionId(options.sessionId);
+    let lastAssistantText = "";
+    let endOfTurn = false;
+    for (const line of options.jsonl.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const timestamp = timestampFromEntry(entry);
+        const payload = entry.payload && typeof entry.payload === "object" ? entry.payload : undefined;
+        if (entry.type === "session_meta" && payload) {
+            if (typeof payload.id === "string")
+                agentSessionId = payload.id;
+            timeline.push({
+                cwd: typeof payload.cwd === "string" ? payload.cwd : undefined,
+                kind: "codex_context",
+                label: "Session",
+                model: typeof payload.model === "string" ? payload.model : undefined,
+                text: summarizeCodexSessionMeta(payload),
+                ...(timestamp ? { timestamp } : {})
+            });
+            continue;
+        }
+        if (entry.type === "turn_context" && payload) {
+            timeline.push({
+                cwd: typeof payload.cwd === "string" ? payload.cwd : undefined,
+                kind: "codex_context",
+                label: "Turn context",
+                model: typeof payload.model === "string" ? payload.model : undefined,
+                text: summarizeCodexTurnContext(payload),
+                ...(timestamp ? { timestamp } : {})
+            });
+            continue;
+        }
+        if (entry.type === "compacted" && payload) {
+            timeline.push({
+                kind: "codex_compaction",
+                text: typeof payload.message === "string" && payload.message.trim() ? payload.message : "Conversation compacted.",
+                ...(timestamp ? { timestamp } : {})
+            });
+            continue;
+        }
+        if (!payload)
+            continue;
+        const payloadType = typeof payload.type === "string" ? payload.type : "";
+        if (entry.type === "response_item") {
+            const item = codexTimelineItemFromResponsePayload(payload, timestamp, callsById, timeline);
+            if (item) {
+                timeline.push(item);
+                if (item.kind === "codex_assistant_message") {
+                    lastAssistantText = item.text;
+                    messages.push({ role: "assistant", text: item.text, ...(timestamp ? { timestamp } : {}) });
+                }
+                else if (item.kind === "codex_user_message") {
+                    messages.push({ role: "user", text: item.text, ...(timestamp ? { timestamp } : {}) });
+                }
+            }
+            continue;
+        }
+        if (entry.type === "event_msg") {
+            if (payloadType === "user_message") {
+                const text = typeof payload.message === "string" ? payload.message : safeJson(payload);
+                messages.push({ role: "user", text, ...(timestamp ? { timestamp } : {}) });
+                timeline.push({ kind: "codex_user_message", text, ...(timestamp ? { timestamp } : {}) });
+                continue;
+            }
+            if (payloadType === "agent_message") {
+                const text = typeof payload.message === "string" ? payload.message : safeJson(payload);
+                lastAssistantText = text;
+                timeline.push({
+                    kind: "codex_commentary",
+                    phase: typeof payload.phase === "string" ? payload.phase : undefined,
+                    text,
+                    ...(timestamp ? { timestamp } : {})
+                });
+                continue;
+            }
+            const eventItem = codexTimelineItemFromEventPayload(payload, timestamp);
+            if (eventItem) {
+                if (mergeCodexEventItemIntoCall({ callsById, item: eventItem, timeline })) {
+                    continue;
+                }
+                timeline.push(eventItem);
+                if (eventItem.kind === "codex_task_event" && eventItem.label === "Task complete") {
+                    endOfTurn = true;
+                }
+            }
+        }
+    }
+    const summary = messageSummaryFields(messages);
+    return {
+        agentSessionId,
+        endOfTurn,
+        ...summary,
+        lastAssistantText,
+        messages,
+        provider: "codex",
+        sessionId: `codex:${agentSessionId}`,
+        timeline,
+        ...(options.transcriptPath ? { transcriptPath: options.transcriptPath } : {})
+    };
+}
+function timelineItemsFromMessage({ blocks, entry, role, timeline, toolCallsById }) {
+    const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+    if (role === "user" && blocks.every((block) => block.kind === "text")) {
+        const text = blocks.map((block) => blockText(block)).join("\n\n");
+        const interruption = claudeInterruptionEvent(text, timestamp);
+        if (interruption)
+            return [interruption];
+        return [{
+                kind: "claude_user_message",
+                text,
+                ...(timestamp ? { timestamp } : {})
+            }];
+    }
+    if (role === "assistant" && blocks.every((block) => block.kind === "text")) {
+        const text = blocks.map((block) => blockText(block)).join("\n\n");
+        return [{
+                blocks,
+                kind: "claude_assistant_message",
+                text,
+                ...(timestamp ? { timestamp } : {})
+            }];
+    }
+    const items = [];
+    const assistantTextBlocks = [];
+    for (const block of blocks) {
+        if (role === "assistant" && block.kind === "text") {
+            assistantTextBlocks.push(block);
+            continue;
+        }
+        if (assistantTextBlocks.length > 0) {
+            items.push(assistantMessageItem(assistantTextBlocks, timestamp));
+            assistantTextBlocks.length = 0;
+        }
+        if (block.kind === "thinking") {
+            items.push({
+                kind: "claude_thinking",
+                text: block.text,
+                ...(timestamp ? { timestamp } : {})
+            });
+            continue;
+        }
+        if (block.kind === "tool_use") {
+            const taskItem = taskChecklistFromToolUse(block, timestamp);
+            if (taskItem) {
+                items.push(taskItem);
+            }
+            else {
+                const toolCategory = toolCategoryForClaudeName(block.name);
+                if (block.toolUseId) {
+                    toolCallsById.set(block.toolUseId, { name: block.name, timelineIndex: timeline.length + items.length, toolCategory });
+                }
+                items.push({
+                    input: block.input,
+                    kind: "claude_tool_use",
+                    name: block.name,
+                    toolCategory,
+                    ...(block.toolUseId ? { toolUseId: block.toolUseId } : {}),
+                    ...(timestamp ? { timestamp } : {})
+                });
+            }
+            continue;
+        }
+        if (block.kind === "tool_result") {
+            const call = block.toolUseId ? toolCallsById.get(block.toolUseId) : undefined;
+            const toolResult = {
+                isError: block.isError,
+                kind: "claude_tool_result",
+                ...(call?.name ? { name: call.name } : {}),
+                output: block.text,
+                toolCategory: call?.toolCategory ?? "generic",
+                ...(block.toolUseId ? { toolUseId: block.toolUseId } : {}),
+                ...(timestamp ? { timestamp } : {})
+            };
+            if (call?.timelineIndex !== undefined) {
+                const toolUse = timeline[call.timelineIndex];
+                if (toolUse?.kind === "claude_tool_use") {
+                    timeline[call.timelineIndex] = {
+                        kind: "claude_tool_exchange",
+                        result: {
+                            isError: block.isError,
+                            output: block.text,
+                            ...(timestamp ? { timestamp } : {})
+                        },
+                        toolUse: {
+                            input: toolUse.input,
+                            name: toolUse.name,
+                            toolCategory: toolUse.toolCategory,
+                            ...(toolUse.timestamp ? { timestamp: toolUse.timestamp } : {})
+                        },
+                        ...(block.toolUseId ? { toolUseId: block.toolUseId } : {}),
+                        ...(toolUse.timestamp ? { timestamp: toolUse.timestamp } : timestamp ? { timestamp } : {})
+                    };
+                }
+                else {
+                    items.push(toolResult);
+                }
+            }
+            else {
+                items.push(toolResult);
+            }
+            continue;
+        }
+        if (block.kind === "text") {
+            items.push({
+                kind: "claude_user_message",
+                text: block.text,
+                ...(timestamp ? { timestamp } : {})
+            });
+            continue;
+        }
+        items.push({
+            kind: "claude_attachment",
+            label: block.blockType,
+            text: block.text,
+            ...(timestamp ? { timestamp } : {})
+        });
+    }
+    if (assistantTextBlocks.length > 0) {
+        items.push(assistantMessageItem(assistantTextBlocks, timestamp));
+    }
+    return items;
+}
+function assistantMessageItem(blocks, timestamp) {
+    return {
+        blocks: [...blocks],
+        kind: "claude_assistant_message",
+        text: blocks.map((block) => blockText(block)).join("\n\n"),
+        ...(timestamp ? { timestamp } : {})
+    };
+}
+function timelineItemFromMetadataEntry(entry) {
+    const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+    if (entry.type === "mode") {
+        return sessionEvent("Mode", typeof entry.mode === "string" ? entry.mode : safeJson(entry), timestamp);
+    }
+    if (entry.type === "permission-mode") {
+        return sessionEvent("Permissions", typeof entry.permissionMode === "string" ? entry.permissionMode : safeJson(entry), timestamp, "warning");
+    }
+    if (entry.type === "ai-title") {
+        return sessionEvent("Title", typeof entry.aiTitle === "string" ? entry.aiTitle : safeJson(entry), timestamp);
+    }
+    if (entry.type === "agent-name") {
+        return sessionEvent("Agent", typeof entry.agentName === "string" ? entry.agentName : safeJson(entry), timestamp);
+    }
+    if (entry.type === "last-prompt") {
+        return sessionEvent("Last prompt", typeof entry.lastPrompt === "string" ? entry.lastPrompt : safeJson(entry), timestamp);
+    }
+    if (entry.type === "queue-operation") {
+        return {
+            kind: "claude_queued_message",
+            operation: typeof entry.operation === "string" ? entry.operation : "queued",
+            text: typeof entry.content === "string" ? entry.content : safeJson(entry),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (entry.type === "attachment") {
+        const attachment = entry.attachment && typeof entry.attachment === "object" ? entry.attachment : entry;
+        return timelineItemFromAttachment(attachment, timestamp);
+    }
+    if (entry.type === "file-history-snapshot") {
+        return {
+            kind: "claude_file_snapshot",
+            label: entry.isSnapshotUpdate === true ? "File snapshot updated" : "File snapshot",
+            text: typeof entry.messageId === "string" ? entry.messageId : safeJson(entry),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (entry.type === "pr-link" && typeof entry.prUrl === "string") {
+        return {
+            kind: "claude_pr_link",
+            ...(typeof entry.prRepository === "string" ? { repository: entry.prRepository } : {}),
+            title: typeof entry.prNumber === "number" ? `Pull request #${entry.prNumber}` : "Pull request",
+            url: entry.prUrl,
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (entry.type === "system" && entry.subtype === "turn_duration") {
+        return sessionEvent("Turn duration", typeof entry.durationMs === "number" ? `${Math.round(entry.durationMs / 1000)}s` : safeJson(entry), timestamp, "success");
+    }
+    if (entry.type === "system" && entry.subtype === "away_summary") {
+        return sessionEvent("Recap", textContentFromEntry(entry), timestamp);
+    }
+    if (entry.type === "system" && entry.subtype === "scheduled_task_fire") {
+        return sessionEvent("Scheduled resume", textContentFromEntry(entry), timestamp, "warning");
+    }
+    if (entry.type === "system" && entry.subtype === "compact_boundary") {
+        return sessionEvent("Compacted", textContentFromEntry(entry), timestamp);
+    }
+    if (entry.type === "system" && entry.subtype === "api_error") {
+        return sessionEvent("API error", summarizeApiError(entry), timestamp, "warning");
+    }
+    if (entry.type === "system" && entry.subtype === "local_command") {
+        return sessionEvent("Local command", textContentFromEntry(entry), timestamp);
+    }
+    if (entry.type === "system" && entry.subtype === "stop_hook_summary") {
+        return sessionEvent("Stop hook", summarizeStopHook(entry), timestamp);
+    }
+    if (entry.type === "started") {
+        return sessionEvent("Agent started", summarizeAgentEvent(entry), timestamp, "success");
+    }
+    if (entry.type === "result") {
+        return sessionEvent("Agent result", summarizeAgentEvent(entry), timestamp, "success");
+    }
+    return undefined;
+}
+function sessionEvent(label, text, timestamp, tone) {
+    return {
+        kind: "claude_system_event",
+        label,
+        text,
+        ...(tone ? { tone } : {}),
+        ...(timestamp ? { timestamp } : {})
+    };
+}
+function claudeInterruptionEvent(text, timestamp) {
+    const trimmed = text.trim();
+    if (trimmed === "[Request interrupted by user]") {
+        return sessionEvent("Interrupted", "Request interrupted by user.", timestamp, "warning");
+    }
+    if (trimmed === "[Request interrupted by user for tool use]") {
+        return sessionEvent("Interrupted", "Request interrupted by user for tool use.", timestamp, "warning");
+    }
+    return undefined;
+}
+function timelineItemFromAttachment(attachment, timestamp) {
+    const attachmentType = typeof attachment.type === "string" ? attachment.type : "";
+    if (attachmentType === "hook_non_blocking_error") {
+        return sessionEvent("Hook warning", summarizeHookAttachment(attachment), timestamp, "warning");
+    }
+    if (attachmentType === "hook_success") {
+        return sessionEvent("Hook success", summarizeHookAttachment(attachment), timestamp, "success");
+    }
+    if (attachmentType === "task_reminder" || attachmentType === "task_status") {
+        return sessionEvent("Task reminder", summarizeAttachment(attachment), timestamp, "warning");
+    }
+    if (attachmentType === "deferred_tools_delta") {
+        return sessionEvent("Tools updated", summarizeAttachment(attachment), timestamp);
+    }
+    if (attachmentType === "command_permissions") {
+        return sessionEvent("Command permissions", summarizeAttachment(attachment), timestamp);
+    }
+    if (attachmentType === "skill_listing" || attachmentType === "invoked_skills" || attachmentType === "dynamic_skill") {
+        return sessionEvent("Skills", summarizeAttachment(attachment), timestamp);
+    }
+    if (attachmentType === "nested_memory") {
+        return sessionEvent("Memory", summarizeAttachment(attachment), timestamp);
+    }
+    if (attachmentType === "agent_listing_delta") {
+        return sessionEvent("Agents", summarizeAttachment(attachment), timestamp);
+    }
+    if (attachmentType === "date_change") {
+        return sessionEvent("Date changed", summarizeAttachment(attachment), timestamp);
+    }
+    if (attachmentType === "workflow_keyword_request") {
+        return sessionEvent("Workflow request", summarizeAttachment(attachment), timestamp, "warning");
+    }
+    if (attachmentType === "queued_command") {
+        return {
+            kind: "claude_queued_message",
+            operation: "queued",
+            text: summarizeAttachment(attachment),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (attachmentType === "file" || attachmentType === "edited_text_file" || attachmentType === "compact_file_reference" || attachmentType === "plan_file_reference") {
+        return {
+            kind: "claude_file_snapshot",
+            label: attachmentType === "edited_text_file" ? "Edited file" : "File reference",
+            text: summarizeAttachment(attachment),
+            ...(timestamp ? { timestamp } : {})
+        };
+    }
+    if (attachmentType === "plan_mode" || attachmentType === "plan_mode_exit" || attachmentType === "plan_mode_reentry") {
+        return sessionEvent("Plan mode", summarizeAttachment(attachment), timestamp);
+    }
+    return {
+        kind: "claude_attachment",
+        label: attachmentType || "Attachment",
+        text: summarizeAttachment(attachment),
+        ...(timestamp ? { timestamp } : {})
+    };
+}
+function taskChecklistFromToolUse(block, timestamp) {
+    if (block.name !== "TodoWrite")
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(block.input);
+    }
+    catch {
+        return undefined;
+    }
+    const todos = parsed && typeof parsed === "object" && Array.isArray(parsed.todos)
+        ? parsed.todos
+        : [];
+    if (todos.length === 0)
+        return undefined;
+    return {
+        items: todos.map((todo) => {
+            if (!todo || typeof todo !== "object")
+                return { text: safeJson(todo) };
+            const record = todo;
+            return {
+                ...(typeof record.status === "string" ? { status: record.status } : {}),
+                text: typeof record.content === "string" ? record.content : safeJson(record)
+            };
+        }),
+        kind: "claude_todo",
+        title: "Task checklist",
+        ...(timestamp ? { timestamp } : {})
+    };
+}
+function toolCategoryForClaudeName(name) {
+    if (name === "Bash" || name === "bash")
+        return "shell";
+    if (name === "Read")
+        return "file_read";
+    if (name === "Edit" || name === "MultiEdit" || name === "Write" || name === "NotebookEdit")
+        return "file_edit";
+    if (name === "Grep" || name === "Glob" || name === "LS")
+        return "search";
+    if (name === "WebFetch" || name === "WebSearch")
+        return "web";
+    if (name === "Agent" || name === "Task")
+        return "subagent";
+    if (name === "AskUserQuestion")
+        return "human";
+    if (name === "CronCreate" || name === "CronDelete" || name === "ScheduleWakeup")
+        return "scheduler";
+    if (name === "EnterPlanMode" || name === "ExitPlanMode")
+        return "planning";
+    if (name === "Monitor")
+        return "monitor";
+    if (name === "SendMessage")
+        return "workflow";
+    if (name === "Skill" || name === "ToolSearch")
+        return "discovery";
+    if (name === "StructuredOutput")
+        return "structured";
+    if (name === "TaskCreate" || name === "TaskGet" || name === "TaskList" || name === "TaskOutput" || name === "TaskStop" || name === "TaskUpdate" || name === "TodoWrite")
+        return "task";
+    if (name === "Workflow")
+        return "workflow";
+    if (name.startsWith("mcp__playwright__browser_"))
+        return "browser";
+    if (name.startsWith("mcp__"))
+        return "mcp";
+    return "generic";
+}
+function blocksFromContent(content) {
+    if (typeof content === "string") {
+        return content.trim() ? [{ kind: "text", text: content }] : [];
+    }
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((block) => {
+        if (!block || typeof block !== "object")
+            return [];
+        const record = block;
+        const type = typeof record.type === "string" ? record.type : "unknown";
+        if (type === "text") {
+            return typeof record.text === "string" && record.text.trim()
+                ? [{ kind: "text", text: record.text }]
+                : [];
+        }
+        if (type === "thinking") {
+            return typeof record.thinking === "string" && record.thinking.trim()
+                ? [{ kind: "thinking", text: record.thinking }]
+                : [];
+        }
+        if (type === "tool_use") {
+            return [{
+                    input: stringifyToolInput(record.input),
+                    kind: "tool_use",
+                    name: typeof record.name === "string" ? record.name : "Tool",
+                    ...(typeof record.id === "string" ? { toolUseId: record.id } : {})
+                }];
+        }
+        if (type === "tool_result") {
+            return [{
+                    isError: record.is_error === true,
+                    kind: "tool_result",
+                    text: toolResultText(record.content),
+                    ...(typeof record.tool_use_id === "string" ? { toolUseId: record.tool_use_id } : {})
+                }];
+        }
+        return [{
+                blockType: type,
+                kind: "unknown",
+                text: safeJson(record)
+            }];
+    });
+}
+function blockText(block) {
+    if (block.kind === "tool_use")
+        return `${block.name}\n${block.input}`;
+    if (block.kind === "tool_result")
+        return block.text;
+    return block.text;
+}
+function stringifyToolInput(input) {
+    if (!input || typeof input !== "object")
+        return "";
+    const record = input;
+    if (typeof record.command === "string") {
+        return [
+            typeof record.description === "string" ? record.description : undefined,
+            record.command
+        ].filter((part) => Boolean(part)).join("\n");
+    }
+    return safeJson(input);
+}
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map(summarizeToolResultPart).join("\n");
+    }
+    return summarizeToolResultPart(content);
+}
+function summarizeAttachment(attachment) {
+    if (Array.isArray(attachment.addedNames)) {
+        return `Added tools: ${attachment.addedNames.filter((name) => typeof name === "string").slice(0, 12).join(", ")}`;
+    }
+    if (Array.isArray(attachment.allowedTools)) {
+        const tools = attachment.allowedTools.filter((name) => typeof name === "string");
+        return tools.length > 0 ? `Allowed tools: ${tools.slice(0, 12).join(", ")}` : "No command tools allowed.";
+    }
+    if (typeof attachment.filePath === "string")
+        return attachment.filePath;
+    if (typeof attachment.path === "string")
+        return attachment.path;
+    if (typeof attachment.filename === "string")
+        return attachment.filename;
+    if (typeof attachment.content === "string")
+        return attachment.content;
+    if (Array.isArray(attachment.content))
+        return attachment.content.length > 0 ? safeJson(attachment.content) : "No active items.";
+    if (typeof attachment.memoryType === "string")
+        return attachment.memoryType;
+    if (typeof attachment.date === "string")
+        return attachment.date;
+    if (typeof attachment.keyword === "string")
+        return attachment.keyword;
+    if (typeof attachment.text === "string")
+        return attachment.text;
+    if (typeof attachment.name === "string")
+        return attachment.name;
+    return safeJson(attachment);
+}
+function summarizeHookAttachment(attachment) {
+    return [
+        typeof attachment.hookName === "string" ? attachment.hookName : undefined,
+        typeof attachment.command === "string" ? attachment.command : undefined,
+        typeof attachment.stderr === "string" && attachment.stderr.trim() ? attachment.stderr : undefined,
+        typeof attachment.stdout === "string" && attachment.stdout.trim() ? attachment.stdout : undefined,
+        typeof attachment.exitCode === "number" ? `exit ${attachment.exitCode}` : undefined
+    ].filter((part) => Boolean(part)).join("\n") || summarizeAttachment(attachment);
+}
+function textContentFromEntry(entry) {
+    return typeof entry.content === "string" && entry.content.trim() ? entry.content : safeJson(entry);
+}
+function summarizeApiError(entry) {
+    const retryInMs = typeof entry.retryInMs === "number" ? ` Retry in ${Math.round(entry.retryInMs)}ms.` : "";
+    const retryAttempt = typeof entry.retryAttempt === "number" && typeof entry.maxRetries === "number"
+        ? ` Attempt ${entry.retryAttempt}/${entry.maxRetries}.`
+        : "";
+    const cause = entry.cause && typeof entry.cause === "object" ? entry.cause : undefined;
+    const code = typeof cause?.code === "string" ? cause.code : undefined;
+    const path = typeof cause?.path === "string" ? cause.path : undefined;
+    return [code, path].filter(Boolean).join(" ") + retryAttempt + retryInMs || safeJson(entry);
+}
+function summarizeStopHook(entry) {
+    const hookCount = typeof entry.hookCount === "number" ? `${entry.hookCount} hook${entry.hookCount === 1 ? "" : "s"}` : "Stop hook";
+    const prevented = entry.preventedContinuation === true ? "prevented continuation" : "completed";
+    const errors = Array.isArray(entry.hookErrors) && entry.hookErrors.length > 0 ? ` with ${entry.hookErrors.length} error${entry.hookErrors.length === 1 ? "" : "s"}` : "";
+    return `${hookCount} ${prevented}${errors}.`;
+}
+function summarizeAgentEvent(entry) {
+    const parts = [
+        typeof entry.agentId === "string" ? `agent ${entry.agentId}` : undefined,
+        typeof entry.skill === "string" ? `skill ${entry.skill}` : undefined,
+        typeof entry.runId === "string" ? `run ${entry.runId}` : undefined,
+        typeof entry.key === "string" ? entry.key : undefined
+    ].filter((part) => Boolean(part));
+    if (entry.result !== undefined) {
+        return `${parts.join(" · ") || "agent result"}\n${safeJson(entry.result)}`;
+    }
+    if (typeof entry.context === "string") {
+        return `${parts.join(" · ") || "agent started"}\n${entry.context}`;
+    }
+    return parts.join(" · ") || safeJson(entry);
+}
+function findCodexTranscriptById(root, sessionId) {
+    const candidates = Array.from(walkJsonl(root)).filter((path) => path.includes(sessionId));
+    if (candidates.length > 0)
+        return newestFile(candidates);
+    for (const path of walkJsonl(root)) {
+        let firstLine = "";
+        try {
+            firstLine = readFirstLine(path);
+        }
+        catch {
+            continue;
+        }
+        if (!firstLine.trim())
+            continue;
+        try {
+            const entry = JSON.parse(firstLine);
+            if (entry.payload?.id === sessionId)
+                return path;
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+}
+function findClaudeTranscriptById(root, sessionId) {
+    const filename = `${sessionId}.jsonl`;
+    const candidates = Array.from(walkJsonl(root)).filter((path) => basename(path) === filename);
+    if (candidates.length === 1 && candidates[0]) {
+        return candidates[0];
+    }
+    if (candidates.length > 1) {
+        throw new Error(`Claude session transcript lookup for ${sessionId} is ambiguous: ${candidates.join(", ")}`);
+    }
+    return join(root, "__missing__", filename);
+}
+// Session header lines are small; reading a bounded prefix avoids pulling
+// entire multi-megabyte transcripts into memory during id lookups.
+function readFirstLine(path, maxBytes = 16_384) {
+    const fd = openSync(path, "r");
+    try {
+        const buffer = Buffer.alloc(maxBytes);
+        const bytesRead = readSync(fd, buffer, 0, maxBytes, 0);
+        const text = buffer.toString("utf8", 0, bytesRead);
+        const newlineIndex = text.indexOf("\n");
+        return newlineIndex === -1 ? text : text.slice(0, newlineIndex);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function* walkJsonl(root) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(root, entry);
+        let stat;
+        try {
+            stat = statSync(path);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            yield* walkJsonl(path);
+        }
+        else if (path.endsWith(".jsonl")) {
+            yield path;
+        }
+    }
+}
+function newestFile(paths) {
+    return paths
+        .map((path) => {
+        try {
+            return { mtime: statSync(path).mtimeMs, path };
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((item) => Boolean(item))
+        .sort((a, b) => b.mtime - a.mtime)[0]?.path;
+}
+function timestampFromEntry(entry) {
+    if (typeof entry.timestamp === "string")
+        return entry.timestamp;
+    const payload = entry.payload && typeof entry.payload === "object" ? entry.payload : undefined;
+    return timestampFromPayload(payload, "timestamp")
+        ?? timestampFromPayload(payload, "started_at")
+        ?? timestampFromPayload(payload, "completed_at");
+}
+function timestampFromPayload(payload, key) {
+    const value = payload?.[key];
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number")
+        return new Date(value > 10_000_000_000 ? value : value * 1000).toISOString();
+    return undefined;
+}
+function codexContentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((item) => {
+        if (typeof item === "string")
+            return item;
+        if (item && typeof item === "object") {
+            const record = item;
+            if (typeof record.text === "string")
+                return record.text;
+        }
+        return "";
+    }).filter(Boolean).join("\n\n");
+}
+function codexReasoningSummary(summary) {
+    if (typeof summary === "string" && summary.trim())
+        return summary;
+    if (!Array.isArray(summary))
+        return undefined;
+    const text = summary.map((item) => {
+        if (typeof item === "string")
+            return item;
+        if (item && typeof item === "object" && typeof item.text === "string") {
+            return item.text;
+        }
+        return "";
+    }).filter(Boolean).join("\n");
+    return text || undefined;
+}
+function codexToolName(payload) {
+    if (typeof payload.name === "string")
+        return payload.name;
+    if (payload.type === "web_search_call")
+        return "web_search";
+    if (payload.type === "tool_search_call")
+        return "tool_search";
+    return "tool";
+}
+function codexToolArguments(payload) {
+    if (typeof payload.arguments === "string")
+        return prettyJsonString(payload.arguments);
+    if (typeof payload.input === "string")
+        return payload.input;
+    if (payload.arguments !== undefined)
+        return safeJson(payload.arguments);
+    if (payload.action !== undefined)
+        return safeJson(payload.action);
+    return safeJson(payload);
+}
+function codexToolOutput(payload) {
+    if (typeof payload.output === "string")
+        return summarizeCodexOutputString(payload.output);
+    if (payload.output !== undefined)
+        return summarizeStructuredToolOutput(payload.output);
+    if (payload.tools !== undefined)
+        return summarizeCodexTools(payload.tools);
+    return safeJson(payload);
+}
+function summarizeStructuredToolOutput(output) {
+    if (typeof output === "string")
+        return output;
+    if (Array.isArray(output))
+        return output.map(summarizeToolResultPart).join("\n");
+    return safeJson(output);
+}
+function summarizeCodexOutputString(output) {
+    if (!output.trim())
+        return output;
+    try {
+        const parsed = JSON.parse(output);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const record = parsed;
+            if (typeof record.output === "string")
+                return record.output;
+            if (record.metadata !== undefined)
+                return summarizeKeyValues(record, ["status", "exit_code", "duration_seconds"]);
+        }
+    }
+    catch {
+        // Plain text tool output is the common case.
+    }
+    return output;
+}
+function summarizeCodexTools(tools) {
+    if (!Array.isArray(tools))
+        return safeJson(tools);
+    const names = tools.flatMap((tool) => {
+        if (!tool || typeof tool !== "object")
+            return [];
+        const record = tool;
+        const nested = Array.isArray(record.tools)
+            ? record.tools.flatMap((child) => {
+                if (!child || typeof child !== "object")
+                    return [];
+                const childName = child.name;
+                return typeof childName === "string" ? [childName] : [];
+            })
+            : [];
+        return typeof record.name === "string" ? [record.name, ...nested] : nested;
+    });
+    return names.length > 0 ? `Tools found: ${names.slice(0, 16).join(", ")}` : `${tools.length} tool result${tools.length === 1 ? "" : "s"}.`;
+}
+function summarizeToolResultPart(item) {
+    if (typeof item === "string")
+        return item;
+    if (!item || typeof item !== "object")
+        return safeJson(item);
+    const record = item;
+    if (typeof record.text === "string")
+        return record.text;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type === "image" || type === "input_image") {
+        const source = record.source && typeof record.source === "object" ? record.source : undefined;
+        const mediaType = typeof source?.media_type === "string"
+            ? source.media_type
+            : typeof record.image_url === "string"
+                ? record.image_url.match(/^data:([^;,]+)/)?.[1]
+                : undefined;
+        return mediaType ? `Image result (${mediaType})` : "Image result";
+    }
+    if (type === "tool_reference") {
+        const toolName = typeof record.tool_name === "string" ? record.tool_name : undefined;
+        return toolName ? `Tool reference: ${toolName}` : "Tool reference";
+    }
+    return safeJson(item);
+}
+function prettyJsonString(value) {
+    try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        return value;
+    }
+}
+function toolCategoryForCodexName(name) {
+    if (name === "exec_command" || name === "write_stdin" || name === "send_input")
+        return "shell";
+    if (name === "apply_patch")
+        return "file_edit";
+    if (name === "view_image")
+        return "file_read";
+    if (name.includes("browser_") || name.startsWith("mcp__playwright__"))
+        return "browser";
+    if (name === "web_search" || name === "web_search_call")
+        return "web";
+    if (name === "tool_search")
+        return "discovery";
+    if (name === "spawn_agent" || name === "wait_agent" || name === "close_agent" || name === "resume_agent")
+        return "subagent";
+    if (name === "update_plan")
+        return "planning";
+    if (name === "create_goal" || name === "update_goal" || name === "get_goal")
+        return "task";
+    if (name.startsWith("mcp__"))
+        return "mcp";
+    return "generic";
+}
+function codexToolCompletionEvent(payload, fallbackName, timestamp) {
+    const name = typeof payload.name === "string" ? payload.name : fallbackName;
+    return {
+        ...(typeof payload.call_id === "string" ? { callId: payload.call_id } : {}),
+        kind: "codex_tool_result",
+        name,
+        output: codexToolCompletionText(payload),
+        status: typeof payload.status === "string" ? payload.status : undefined,
+        toolCategory: toolCategoryForCodexName(name),
+        ...(timestamp ? { timestamp } : {})
+    };
+}
+function codexToolCompletionText(payload) {
+    return [
+        typeof payload.command === "string" ? payload.command : Array.isArray(payload.command) ? payload.command.join(" ") : undefined,
+        typeof payload.formatted_output === "string" && payload.formatted_output.trim() ? payload.formatted_output : undefined,
+        typeof payload.aggregated_output === "string" && payload.aggregated_output.trim() ? payload.aggregated_output : undefined,
+        typeof payload.stdout === "string" && payload.stdout.trim() ? payload.stdout : undefined,
+        typeof payload.stderr === "string" && payload.stderr.trim() ? payload.stderr : undefined
+    ].filter((part) => Boolean(part)).join("\n\n") || safeJson(payload);
+}
+function codexPatchChanges(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    return Object.entries(value).map(([path, change]) => {
+        const record = change && typeof change === "object" ? change : {};
+        return {
+            path,
+            text: typeof record.unified_diff === "string" ? record.unified_diff : typeof record.content === "string" ? record.content : undefined,
+            type: typeof record.type === "string" ? record.type : "change"
+        };
+    });
+}
+function codexWebSearchQuery(payload) {
+    if (typeof payload.query === "string")
+        return payload.query;
+    const action = payload.action && typeof payload.action === "object" ? payload.action : undefined;
+    if (typeof action?.query === "string")
+        return action.query;
+    return safeJson(payload);
+}
+function summarizeCodexSessionMeta(payload) {
+    return summarizeKeyValues(payload, ["id", "cwd", "originator", "cli_version", "source", "model_provider"]);
+}
+function summarizeCodexTurnContext(payload) {
+    return summarizeKeyValues(payload, ["cwd", "model", "approval_policy", "personality", "current_date", "timezone"]);
+}
+function summarizeCodexGoal(goal) {
+    return [
+        typeof goal.objective === "string" ? goal.objective : undefined,
+        summarizeKeyValues(goal, ["status", "tokensUsed", "timeUsedSeconds"])
+    ].filter((part) => Boolean(part)).join("\n");
+}
+function summarizeCodexReview(payload) {
+    if (typeof payload.user_facing_hint === "string")
+        return payload.user_facing_hint;
+    if (payload.review_output && typeof payload.review_output === "object")
+        return safeJson(payload.review_output);
+    if (payload.item && typeof payload.item === "object" && typeof payload.item.text === "string") {
+        return payload.item.text;
+    }
+    return safeJson(payload);
+}
+function summarizeKeyValues(payload, keys) {
+    return keys.map((key) => {
+        const value = payload[key];
+        if (value === undefined || value === null || value === "")
+            return undefined;
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+            return `${key}: ${value}`;
+        return `${key}: ${safeJson(value)}`;
+    }).filter((part) => Boolean(part)).join("\n") || safeJson(payload);
+}
+function codexEventLabel(type) {
+    return type.split("_").map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : part).join(" ");
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}