ctxpool 0.1.1 → 0.4.0

package/dist/session.js

@@ -1,81 +1,600 @@
-import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
-import { findRecentFiles, unique } from "./util.js";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { oneLine, truncate } from "./text.js";
+import { CtxError, canonicalPath, findRecentFiles, unique } from "./util.js";
+import { commandStatus } from "./verify.js";
+const DEFAULT_EXCERPT_TOKENS = 3_000;
+const AMBIGUITY_WINDOW_MS = 10 * 60 * 1000;
+const MAX_CANDIDATES = 200;
+export function codexHome() {
+    return process.env.CODEX_HOME || join(homedir(), ".codex");
+}
+export function claudeHome() {
+    return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+/** Gemini CLI keeps its data in `.gemini` under GEMINI_CLI_HOME, or under the home directory. */
+export function geminiHome() {
+    return join(process.env.GEMINI_CLI_HOME || homedir(), ".gemini");
+}
+/**
+ * Antigravity CLI (`agy`) always keeps its data in ~/.gemini/antigravity-cli. CTXPOOL_ANTIGRAVITY_DIR points
+ * ContextPool somewhere else; agy itself does not read it.
+ */
+export function antigravityHome() {
+    return process.env.CTXPOOL_ANTIGRAVITY_DIR || join(homedir(), ".gemini", "antigravity-cli");
+}
+/** Every agent ContextPool can read, in the order `--from auto` lists them. */
+export const SOURCE_AGENTS = ["codex", "claude", "gemini", "antigravity"];
+const SOURCE_LABELS = { codex: "Codex", claude: "Claude", gemini: "Gemini", antigravity: "Antigravity" };
+export function sourceLabel(source) {
+    return SOURCE_LABELS[source] || source;
+}
+/** Where each agent keeps the sessions ContextPool reads. */
+export function sourceSessionDirs() {
+    return {
+        codex: join(codexHome(), "sessions"),
+        claude: join(claudeHome(), "projects"),
+        gemini: join(geminiHome(), "tmp"),
+        antigravity: join(antigravityHome(), "conversations")
+    };
+}
 export function resolveSessionSource(options) {
     const from = normalizeFrom(options.from || "auto");
-    const cwd = resolve(options.cwd);
-    if (options.session) {
-        return resolveExplicitSession(from, cwd, options.session, options.budget);
-    }
-    if (from === "codex")
-        return parseCandidate(requiredBest(findCodexCandidates(cwd), "codex", cwd), options.budget);
-    if (from === "claude")
-        return parseCandidate(requiredBest(findClaudeCandidates(cwd), "claude", cwd), options.budget);
-    const candidates = [...findCodexCandidates(cwd), ...findClaudeCandidates(cwd)]
-        .sort(compareCandidates);
-    if (candidates.length === 0) {
-        throw new Error("No Codex or Claude session files were found. Pass --from and --session with a JSONL path.");
-    }
-    const [first, second] = candidates;
-    if (first &&
-        second &&
-        first.matchedCwd &&
-        second.matchedCwd &&
-        first.source !== second.source &&
-        Math.abs(Date.parse(first.updatedAt) - Date.parse(second.updatedAt)) < 10 * 60 * 1000) {
-        throw new Error(`Both Codex and Claude have recent sessions for this workspace. Re-run with --from ${first.source} or --from ${second.source}.`);
+    const scope = toScope(options.cwd, options.repoRoot);
+    if (options.session)
+        return resolveExplicitSession(from, scope, options.session, options.budget);
+    const matched = listSessionCandidates({ ...scope, from }).filter((candidate) => candidate.matchedCwd);
+    const [first] = matched;
+    if (!first) {
+        const label = from === "auto" ? joinWords(SOURCE_AGENTS.map(sourceLabel), "or") : sourceLabel(from);
+        throw new CtxError(`No ${label} session found for ${scope.cwd}.`, "Run `ctxpool sessions --all` to list sessions, then pass --session <id or path>.");
+    }
+    if (from === "auto") {
+        const recent = matched.filter((candidate) => Date.parse(first.updatedAt) - Date.parse(candidate.updatedAt) < AMBIGUITY_WINDOW_MS);
+        const active = Array.from(new Set(recent.map((candidate) => candidate.source)));
+        if (active.length > 1) {
+            throw new CtxError(`${joinWords(active.map(sourceLabel), "and")} were ${active.length === 2 ? "both" : "all"} active in this workspace in the last 10 minutes.`, `Re-run with ${joinWords(active.map((source, index) => `--from ${source}${index === 0 ? " (most recent)" : ""}`), "or")}.`);
+        }
     }
     return parseCandidate(first, options.budget);
 }
+/** Primary agent sessions, most relevant first. Subagent and reviewer threads are excluded. */
+export function listSessionCandidates(options) {
+    const scope = toScope(options.cwd, options.repoRoot);
+    const from = options.from || "auto";
+    const sources = from === "auto" ? SOURCE_AGENTS : [from];
+    return sources.flatMap((source) => CANDIDATE_FINDERS[source](scope, options.includeSecondary === true)).sort(compareCandidates);
+}
 function normalizeFrom(from) {
-    if (from === "auto" || from === "codex" || from === "claude")
+    if (from === "auto" || SOURCE_AGENTS.includes(from))
         return from;
-    throw new Error(`Unsupported --from value "${from}". Use auto, codex, or claude.`);
+    throw new CtxError(`Unsupported --from value "${from}".`, `Use ${joinWords(["auto", ...SOURCE_AGENTS], "or")}.`);
+}
+function resolveExplicitSession(from, scope, session, budget) {
+    const asPath = resolve(session);
+    if (existsSync(asPath) && statSync(asPath).isFile()) {
+        const source = from === "auto" ? detectSource(asPath) : from;
+        const parsed = SESSION_PARSERS[source](asPath, budget);
+        parsed.matchedCwd = matchesWorkspace(parsed.cwd, scope);
+        return parsed;
+    }
+    const match = listSessionCandidates({ ...scope, from, includeSecondary: true }).find((candidate) => candidate.id === session || candidate.id.startsWith(session) || basename(candidate.path).includes(session));
+    if (!match)
+        throw new CtxError(`No session matched "${session}".`, "Pass an id from `ctxpool sessions --all` or a path to a session file.");
+    return parseCandidate(match, budget);
+}
+function parseCandidate(candidate, budget) {
+    const session = SESSION_PARSERS[candidate.source](candidate.path, budget);
+    session.id = candidate.id || session.id;
+    session.cwd = session.cwd || candidate.cwd;
+    session.updatedAt = candidate.updatedAt;
+    session.matchedCwd = candidate.matchedCwd;
+    session.threadName = session.threadName || candidate.title;
+    return session;
+}
+function compareCandidates(a, b) {
+    if (a.matchedCwd !== b.matchedCwd)
+        return a.matchedCwd ? -1 : 1;
+    return Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+}
+/** "a", "a or b", "a, b, or c". */
+function joinWords(words, conjunction) {
+    if (words.length <= 2)
+        return words.join(` ${conjunction} `);
+    return `${words.slice(0, -1).join(", ")}, ${conjunction} ${words.at(-1)}`;
+}
+const CANDIDATE_FINDERS = {
+    codex: findCodexCandidates,
+    claude: findClaudeCandidates,
+    gemini: findGeminiCandidates,
+    antigravity: findAntigravityCandidates
+};
+const SESSION_PARSERS = {
+    codex: parseCodexSession,
+    claude: parseClaudeSession,
+    gemini: parseGeminiSession,
+    antigravity: parseAntigravitySession
+};
+// ---------------------------------------------------------------------------
+// Discovery
+function findCodexCandidates(scope, includeSecondary) {
+    const index = readCodexIndex();
+    const candidates = [];
+    for (const path of findRecentFiles(join(codexHome(), "sessions"), MAX_CANDIDATES, /\.jsonl$/i)) {
+        const meta = readCodexMeta(path);
+        if (meta.secondary && !includeSecondary)
+            continue;
+        const id = meta.id || sessionIdFromPath(path);
+        candidates.push({
+            source: "codex",
+            path,
+            id,
+            cwd: meta.cwd,
+            updatedAt: mtimeIso(path),
+            matchedCwd: matchesWorkspace(meta.cwd, scope),
+            title: index.get(id)
+        });
+    }
+    return candidates;
+}
+function findClaudeCandidates(scope, includeSecondary) {
+    const projects = join(claudeHome(), "projects");
+    const preferred = unique([scope.cwd, scope.repoRoot || ""].filter(Boolean).map((path) => join(projects, encodeClaudeProjectPath(path)))).filter(existsSync);
+    const roots = preferred.length ? preferred : [projects];
+    const skipDirs = includeSecondary ? [] : ["subagents"];
+    const candidates = [];
+    for (const path of roots.flatMap((root) => findRecentFiles(root, MAX_CANDIDATES, /\.jsonl$/i, skipDirs))) {
+        const meta = readClaudeMeta(path);
+        if (!meta.cwd && !meta.id)
+            continue;
+        candidates.push({
+            source: "claude",
+            path,
+            id: meta.id || sessionIdFromPath(path),
+            cwd: meta.cwd,
+            updatedAt: mtimeIso(path),
+            matchedCwd: matchesWorkspace(meta.cwd, scope),
+            title: meta.title
+        });
+    }
+    return candidates;
+}
+/**
+ * Gemini CLI writes one chat per session to tmp/<project>/chats/session-<time>-<id>.jsonl (a single .json file in
+ * older builds). Subagent chats sit in a folder named after the parent session.
+ */
+function findGeminiCandidates(scope, includeSecondary) {
+    const tmp = join(geminiHome(), "tmp");
+    const registry = readGeminiProjectRegistry();
+    const byId = new Map();
+    for (const project of listDirectories(tmp)) {
+        const chats = join(tmp, project, "chats");
+        const projectRoot = readGeminiProjectRoot(join(tmp, project), registry);
+        for (const path of findRecentFiles(chats, MAX_CANDIDATES, /\.jsonl?$/i)) {
+            const meta = readGeminiMeta(path);
+            if (!meta.id)
+                continue;
+            if ((meta.subagent || dirname(path) !== chats) && !includeSecondary)
+                continue;
+            const cwd = projectRoot || geminiRootFromHash(meta.projectHash, scope);
+            const candidate = {
+                source: "gemini",
+                path,
+                id: meta.id,
+                cwd,
+                updatedAt: mtimeIso(path),
+                matchedCwd: matchesWorkspace(cwd, scope),
+                title: meta.title
+            };
+            // Resuming an old .json chat copies it to a .jsonl file beside the original; keep the newer copy.
+            const existing = byId.get(meta.id);
+            if (!existing || Date.parse(candidate.updatedAt) > Date.parse(existing.updatedAt))
+                byId.set(meta.id, candidate);
+        }
+    }
+    return [...byId.values()];
+}
+function readGeminiMeta(path) {
+    let metadata = {};
+    let firstPrompt = "";
+    if (/\.json$/i.test(path)) {
+        const conversation = readGeminiConversation(path);
+        metadata = conversation.metadata;
+        firstPrompt = conversation.messages.map(geminiUserPrompt).find(Boolean) || "";
+    }
+    else {
+        for (const line of readHead(path, 128_000).split(/\r?\n/).slice(0, 60)) {
+            const record = objectValue(parseJson(line));
+            if (typeof record.sessionId === "string" && typeof record.projectHash === "string")
+                metadata = { ...metadata, ...record };
+            else if (!firstPrompt && record.type === "user")
+                firstPrompt = geminiUserPrompt(record);
+        }
+        for (const line of readTail(path, 96_000).split(/\r?\n/)) {
+            if (!line.includes('"summary"'))
+                continue;
+            const summary = stringValue(objectValue(objectValue(parseJson(line)).$set).summary);
+            if (summary)
+                metadata.summary = summary;
+        }
+    }
+    return {
+        id: stringValue(metadata.sessionId) || undefined,
+        projectHash: stringValue(metadata.projectHash) || undefined,
+        subagent: metadata.kind === "subagent",
+        title: stringValue(metadata.summary) || (firstPrompt ? truncate(oneLine(firstPrompt), 80) : undefined)
+    };
+}
+/** projects.json maps each project root to the short folder name Gemini uses under tmp/. */
+function readGeminiProjectRegistry() {
+    const map = new Map();
+    const path = join(geminiHome(), "projects.json");
+    if (!existsSync(path))
+        return map;
+    for (const [root, name] of Object.entries(objectValue(objectValue(parseJson(readFileSync(path, "utf8"))).projects))) {
+        if (typeof name === "string")
+            map.set(name, root);
+    }
+    return map;
+}
+function readGeminiProjectRoot(projectDir, registry = readGeminiProjectRegistry()) {
+    const marker = join(projectDir, ".project_root");
+    const root = existsSync(marker) ? readFileSync(marker, "utf8").trim() : "";
+    return root || registry.get(basename(projectDir));
+}
+/** Older Gemini builds name project folders by the SHA-256 of the project root and leave no marker file. */
+function geminiRootFromHash(projectHash, scope) {
+    if (!projectHash)
+        return undefined;
+    return [scope.cwd, scope.repoRoot].find((root) => root && createHash("sha256").update(root).digest("hex") === projectHash);
+}
+/** The tmp/<project> folder that holds a chat file, for main and subagent chats alike. */
+function geminiProjectDir(path) {
+    let dir = dirname(path);
+    for (let depth = 0; depth < 2; depth++, dir = dirname(dir))
+        if (basename(dir) === "chats")
+            return dirname(dir);
+    return undefined;
+}
+/**
+ * Antigravity CLI stores each conversation as a SQLite database, conversations/<id>.db, and indexes them in
+ * conversation_summaries.db. Subagent conversations name their parent there and in their own metadata.
+ */
+function findAntigravityCandidates(scope, includeSecondary) {
+    const index = readAntigravityIndex();
+    const candidates = [];
+    for (const path of findRecentFiles(join(antigravityHome(), "conversations"), MAX_CANDIDATES, /\.db$/i)) {
+        const id = antigravityId(path);
+        const summary = index.get(id) || readAntigravityMetadata(path);
+        if (summary.parentId && !includeSecondary)
+            continue;
+        candidates.push({
+            source: "antigravity",
+            path,
+            id,
+            cwd: summary.cwd,
+            updatedAt: antigravityUpdatedAt(path),
+            matchedCwd: matchesWorkspace(summary.cwd, scope),
+            title: summary.title
+        });
+    }
+    return candidates;
+}
+function readAntigravityIndex() {
+    const index = new Map();
+    const db = openAntigravityDb(join(antigravityHome(), "conversation_summaries.db"));
+    if (!db)
+        return index;
+    try {
+        const rows = db.prepare("SELECT conversation_id, title, workspace_uris, parent_conversation_id FROM conversation_summaries").all();
+        for (const row of rows) {
+            const workspaces = parseJson(String(row.workspace_uris ?? ""));
+            index.set(String(row.conversation_id), {
+                cwd: fileUriToPath(Array.isArray(workspaces) ? stringValue(workspaces[0]) : ""),
+                title: String(row.title ?? "") || undefined,
+                parentId: String(row.parent_conversation_id ?? "") || undefined
+            });
+        }
+    }
+    catch {
+        // An older or newer index layout; each conversation's own metadata still names its workspace.
+    }
+    finally {
+        db.close();
+    }
+    return index;
+}
+/** For conversations missing from the index: the workspace from their own metadata, titled by the first prompt still on record. */
+function readAntigravityMetadata(path) {
+    const db = openAntigravityDb(path);
+    if (!db)
+        return {};
+    try {
+        const row = db.prepare("SELECT step_payload FROM steps WHERE step_type = ? AND status != ? ORDER BY idx LIMIT 1").get(AGY_STEP.userInput, AGY_STATUS.cleared);
+        const prompt = row?.step_payload instanceof Uint8Array ? antigravityPrompt(pbMessage(pbDecode(row.step_payload), 19)) : "";
+        return { ...antigravityTrajectoryMetadata(db), title: prompt ? truncate(oneLine(cleanText(prompt)), 80) : undefined };
+    }
+    catch {
+        return antigravityTrajectoryMetadata(db);
+    }
+    finally {
+        db.close();
+    }
+}
+/** The CortexTrajectoryMetadata proto: workspaces[].workspace_folder_absolute_uri (1.1), workspace_uris (7), parent_conversation_id (5). */
+function antigravityTrajectoryMetadata(db) {
+    try {
+        const row = db.prepare("SELECT data FROM trajectory_metadata_blob WHERE id = 'main'").get();
+        const metadata = pbDecode(row?.data instanceof Uint8Array ? row.data : undefined);
+        const uri = pbString(pbMessage(metadata, 1), 1) || pbString(metadata, 7);
+        return { cwd: fileUriToPath(uri), parentId: pbString(metadata, 5) || undefined };
+    }
+    catch {
+        return {};
+    }
+}
+/** agy writes recent steps to the -wal file first, so it can be newer than the database. An empty one holds nothing new. */
+function antigravityUpdatedAt(path) {
+    const database = statSync(path).mtime;
+    const wal = existsSync(`${path}-wal`) ? statSync(`${path}-wal`) : undefined;
+    return (wal?.size && wal.mtime > database ? wal.mtime : database).toISOString();
+}
+function antigravityId(path) {
+    return basename(path).replace(/\.db$/i, "");
+}
+function fileUriToPath(uri) {
+    if (!uri)
+        return undefined;
+    try {
+        return uri.startsWith("file:") ? fileURLToPath(uri) : uri;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readCodexMeta(path) {
+    const record = objectValue(parseJson(readFirstLine(path)));
+    if (stringValue(record.type) !== "session_meta")
+        return { secondary: false };
+    const payload = objectValue(record.payload);
+    const threadSource = stringValue(payload.thread_source);
+    const source = payload.source;
+    const secondary = threadSource === "subagent" || threadSource === "guardian_review" || (typeof source === "object" && source !== null && "subagent" in source);
+    return { id: stringValue(payload.id) || undefined, cwd: stringValue(payload.cwd) || undefined, secondary };
 }
-export function parseCodexSession(path, budget = 12_000) {
+function readClaudeMeta(path) {
+    let id;
+    let cwd;
+    let firstPrompt;
+    for (const line of readHead(path, 128_000).split(/\r?\n/).slice(0, 60)) {
+        const record = objectValue(parseJson(line));
+        id ||= stringValue(record.sessionId) || undefined;
+        cwd ||= stringValue(record.cwd) || undefined;
+        if (!firstPrompt && record.type === "user" && !record.isMeta && !record.isSidechain) {
+            const content = objectValue(record.message).content;
+            if (typeof content === "string")
+                firstPrompt = cleanText(parseClaudeUserText(content).prompt) || undefined;
+        }
+        if (id && cwd && firstPrompt)
+            break;
+    }
+    let title;
+    for (const line of readTail(path, 96_000).split(/\r?\n/)) {
+        if (!line.includes("title") && !line.includes("summary"))
+            continue;
+        const record = objectValue(parseJson(line));
+        title = claudeTitle(record) || title;
+    }
+    return { id, cwd, title: title || (firstPrompt ? truncate(oneLine(firstPrompt), 80) : undefined) };
+}
+function readCodexIndex() {
+    const map = new Map();
+    const indexPath = join(codexHome(), "session_index.jsonl");
+    if (!existsSync(indexPath))
+        return map;
+    for (const line of readFileSync(indexPath, "utf8").split(/\r?\n/)) {
+        const record = objectValue(parseJson(line));
+        const id = stringValue(record.id);
+        const name = stringValue(record.thread_name);
+        if (id && name)
+            map.set(id, name);
+    }
+    return map;
+}
+function detectSource(path) {
+    // Only Gemini writes a whole session as one JSON document, and only Antigravity keeps one in SQLite.
+    if (/\.json$/i.test(path))
+        return "gemini";
+    if (/\.db$/i.test(path))
+        return "antigravity";
+    for (const line of readHead(path, 64_000).split(/\r?\n/).slice(0, 10)) {
+        const record = objectValue(parseJson(line));
+        if (record.type === "session_meta" || "payload" in record)
+            return "codex";
+        if ("projectHash" in record || "$set" in record || "$rewindTo" in record)
+            return "gemini";
+        if ("sessionId" in record || "message" in record)
+            return "claude";
+    }
+    if (path.includes(join(".gemini", "tmp")))
+        return "gemini";
+    return path.includes(`${join(".claude", "projects")}`) ? "claude" : "codex";
+}
+function listDirectories(root) {
+    try {
+        return readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Parsing
+class SessionBuilder {
+    transcript = [];
+    commands = [];
+    edits = [];
+    plan;
+    planText;
+    compactSummary;
+    links = [];
+    seq = 0;
+    pendingCommands = new Map();
+    message(role, text, timestamp) {
+        const clean = cleanText(text);
+        if (!isUsefulText(clean))
+            return;
+        const last = this.transcript.at(-1);
+        if (last && last.role === role && last.text === clean)
+            return;
+        this.seq++;
+        this.transcript.push({ role, text: clean, timestamp, kind: "message" });
+    }
+    toolCall(name, detail, timestamp) {
+        this.seq++;
+        this.transcript.push({ role: "tool", text: detail ? `${name}: ${truncate(oneLine(detail), 240)}` : name, timestamp, kind: "tool_call" });
+    }
+    /**
+     * Record a command whose result may arrive later under `callId`. `assumeSuccess` marks logs where a
+     * result without an error flag means exit 0 (Claude); elsewhere a missing exit code stays unknown.
+     */
+    commandCall(callId, command, timestamp, assumeSuccess = false) {
+        if (!command)
+            return;
+        this.toolCall("Shell", command, timestamp);
+        this.recordCommand(command, undefined, "");
+        if (callId)
+            this.pendingCommands.set(callId, { index: this.commands.length - 1, assumeSuccess });
+    }
+    commandResult(callId, output, options = {}) {
+        const pending = this.pendingCommands.get(callId);
+        if (!pending)
+            return;
+        this.pendingCommands.delete(callId);
+        const exitCode = options.exitCode ?? parseExitCode(output) ?? (options.isError ? 1 : pending.assumeSuccess ? 0 : undefined);
+        const run = { ...this.commands[pending.index], ...commandOutcome(this.commands[pending.index].command, exitCode, output) };
+        this.commands[pending.index] = run;
+        if (run.status === "failed")
+            this.pushFailure(run);
+    }
+    /** A command whose call and result are logged together. */
+    command(command, exitCode, output, timestamp) {
+        if (!command)
+            return;
+        this.toolCall("Shell", command, timestamp);
+        this.recordCommand(command, exitCode, output);
+    }
+    edit(path, timestamp) {
+        if (!path)
+            return;
+        this.seq++;
+        this.edits.push({ path, seq: this.seq });
+        this.transcript.push({ role: "tool", text: `Edit: ${path}`, timestamp, kind: "edit" });
+    }
+    setPlan(items) {
+        if (items.length)
+            this.plan = items;
+    }
+    updatePlan(update) {
+        if (!this.plan)
+            return;
+        const plan = this.plan.map((item) => ({ ...item }));
+        if (update.advance) {
+            const current = plan.findIndex((item) => item.status === "in_progress");
+            if (current >= 0)
+                plan[current].status = "completed";
+            const next = plan.findIndex((item, index) => index > current && item.status === "pending");
+            if (next >= 0)
+                plan[next].status = "in_progress";
+        }
+        for (const index of update.done || [])
+            if (plan[index - 1])
+                plan[index - 1].status = "completed";
+        if (update.start && plan[update.start - 1])
+            plan[update.start - 1].status = "in_progress";
+        this.plan = plan;
+    }
+    recordCommand(command, exitCode, output) {
+        this.seq++;
+        const run = { command: truncate(oneLine(command), 400), ...commandOutcome(command, exitCode, output), seq: this.seq };
+        this.commands.push(run);
+        if (run.status === "failed")
+            this.pushFailure(run);
+    }
+    pushFailure(run) {
+        const label = run.exitCode ? `Exit ${run.exitCode}` : "Failed";
+        this.transcript.push({ role: "tool", text: `${label}${run.errorLine ? `: ${run.errorLine}` : ""}`, kind: "tool_error" });
+    }
+}
+function commandOutcome(command, exitCode, output) {
+    const status = commandStatus(command, exitCode, output);
+    return { status, exitCode, errorLine: status === "failed" ? firstErrorLine(output) : undefined };
+}
+export function parseCodexSession(path, budget = DEFAULT_EXCERPT_TOKENS) {
     const lines = readSessionLines(path);
-    const transcript = [];
+    const builder = new SessionBuilder();
     let id = sessionIdFromPath(path);
     let cwd;
-    let updatedAt = statSync(path).mtime.toISOString();
+    // Newer Codex logs record typed items; older ones mirror messages across event_msg and response_item.
+    const mode = lines.some((line) => line.includes('"item_completed"'))
+        ? "items"
+        : lines.some((line) => line.includes('"user_message"'))
+            ? "events"
+            : "responses";
     for (const line of lines) {
-        const item = parseJson(line);
-        if (!item || typeof item !== "object")
-            continue;
-        const record = item;
+        const record = objectValue(parseJson(line));
         const type = stringValue(record.type);
+        const payload = objectValue(record.payload);
+        const timestamp = stringValue(record.timestamp) || stringValue(payload.timestamp) || undefined;
         if (type === "session_meta") {
-            const payload = objectValue(record.payload);
             id = stringValue(payload.id) || id;
             cwd = stringValue(payload.cwd) || cwd;
-            updatedAt = stringValue(payload.timestamp) || updatedAt;
             continue;
         }
-        const timestamp = stringValue(record.timestamp) || stringValue(objectValue(record.payload).timestamp);
-        if (type === "event_msg") {
-            const payload = objectValue(record.payload);
-            const payloadType = stringValue(payload.type);
-            if (payloadType === "user_message")
-                pushEntry(transcript, "user", stringValue(payload.message), timestamp, "message");
-            if (payloadType === "agent_message")
-                pushEntry(transcript, "assistant", stringValue(payload.message), timestamp, "message");
+        if (type === "compacted") {
+            const message = stringValue(payload.message);
+            if (message.trim())
+                builder.compactSummary = cleanText(message);
             continue;
         }
-        if (type === "response_item") {
-            const payload = objectValue(record.payload);
-            const itemType = stringValue(payload.type);
-            if (itemType === "message") {
-                const role = stringValue(payload.role) === "user" ? "user" : "assistant";
-                pushEntry(transcript, role, collectText(payload.content).join("\n"), timestamp, "message");
+        if (type === "event_msg") {
+            const eventType = stringValue(payload.type);
+            if (mode === "items" && eventType === "item_completed") {
+                readCodexItem(builder, objectValue(payload.item), timestamp);
             }
-            else if (itemType === "function_call") {
-                const name = stringValue(payload.name) || "tool_call";
-                pushEntry(transcript, "tool", `${name} ${stringValue(payload.arguments)}`.trim(), timestamp, "tool_call");
+            else if (mode === "events" && eventType === "user_message") {
+                builder.message("user", stringValue(payload.message), timestamp);
             }
-            else if (itemType === "function_call_output") {
-                pushEntry(transcript, "tool", stringValue(payload.output), timestamp, "tool_output");
+            else if (mode === "events" && eventType === "agent_message") {
+                builder.message("assistant", stringValue(payload.message), timestamp);
             }
+            else if (mode !== "items" && eventType === "exec_command_end") {
+                builder.commandResult(stringValue(payload.call_id), outputText(payload.aggregated_output ?? payload.stdout ?? payload.formatted_output), {
+                    exitCode: numberValue(payload.exit_code)
+                });
+            }
+            continue;
+        }
+        if (type !== "response_item")
+            continue;
+        const itemType = stringValue(payload.type);
+        if (itemType === "message" && mode === "responses") {
+            const role = stringValue(payload.role);
+            if (role === "user" || role === "assistant")
+                builder.message(role, collectText(payload.content).join("\n"), timestamp);
+        }
+        else if (itemType === "function_call" || itemType === "custom_tool_call" || itemType === "local_shell_call") {
+            readCodexCall(builder, payload, mode, timestamp);
+        }
+        else if ((itemType === "function_call_output" || itemType === "custom_tool_call_output") && mode !== "items") {
+            const output = outputText(payload.output);
+            builder.commandResult(stringValue(payload.call_id), output, { exitCode: parseExitCode(output) });
         }
     }
     return buildSession({
@@ -83,39 +602,133 @@ export function parseCodexSession(path, budget = 12_000) {
         id,
         path,
         cwd,
-        updatedAt,
-        matchedCwd: false,
         lineCount: lines.length,
-        transcript,
-        budget
+        builder,
+        budget,
+        threadName: undefined
     });
 }
-export function parseClaudeSession(path, budget = 12_000) {
+function readCodexItem(builder, item, timestamp) {
+    switch (stringValue(item.type)) {
+        case "UserMessage":
+            builder.message("user", collectText(item.content).join("\n"), timestamp);
+            return;
+        case "AgentMessage":
+            builder.message("assistant", collectText(item.content).join("\n"), timestamp);
+            return;
+        case "CommandExecution": {
+            const command = Array.isArray(item.command) ? shellCommand(item.command) : stringValue(item.command);
+            builder.command(command, numberValue(item.exit_code) ?? (stringValue(item.status) === "failed" ? 1 : undefined), outputText(item.aggregated_output), timestamp);
+            return;
+        }
+        case "FileChange":
+            for (const path of Object.keys(objectValue(item.changes)))
+                builder.edit(path, timestamp);
+            return;
+        case "McpToolCall":
+            builder.toolCall(`${stringValue(item.server)}.${stringValue(item.tool)}`, stringValue(item.status) === "failed" ? "failed" : "", timestamp);
+            return;
+        case "TodoList": {
+            const items = Array.isArray(item.items) ? item.items.map(objectValue) : [];
+            builder.setPlan(items
+                .map((entry) => ({ text: oneLine(stringValue(entry.text)), status: entry.completed === true ? "completed" : "pending" }))
+                .filter((entry) => entry.text));
+            return;
+        }
+    }
+}
+function readCodexCall(builder, payload, mode, timestamp) {
+    const name = stringValue(payload.name);
+    const callId = stringValue(payload.call_id);
+    const rawArgs = stringValue(payload.arguments) || stringValue(payload.input);
+    const args = objectValue(parseJson(rawArgs));
+    if (name === "update_plan") {
+        builder.setPlan(planItemsFrom(args.plan));
+        return;
+    }
+    // Items mode records commands and edits as typed items; skip the raw calls to avoid double counting.
+    if (mode === "items")
+        return;
+    if (name === "apply_patch") {
+        for (const path of patchFiles(rawArgs))
+            builder.edit(path, timestamp);
+        return;
+    }
+    if (stringValue(payload.type) === "local_shell_call") {
+        const action = objectValue(payload.action);
+        builder.command(Array.isArray(action.command) ? shellCommand(action.command) : "", undefined, "", timestamp);
+        return;
+    }
+    if (name === "shell" || name === "container.exec" || name === "local_shell" || name === "exec_command") {
+        const command = Array.isArray(args.command) ? shellCommand(args.command) : stringValue(args.cmd) || stringValue(args.command);
+        if (command.includes("apply_patch")) {
+            for (const path of patchFiles(command))
+                builder.edit(path, timestamp);
+            return;
+        }
+        builder.commandCall(callId, command, timestamp);
+        return;
+    }
+    if (name)
+        builder.toolCall(name, "", timestamp);
+}
+export function parseClaudeSession(path, budget = DEFAULT_EXCERPT_TOKENS) {
     const lines = readSessionLines(path);
-    const transcript = [];
+    const builder = new SessionBuilder();
     let id = sessionIdFromPath(path);
     let cwd;
-    let updatedAt = statSync(path).mtime.toISOString();
+    let title;
     for (const line of lines) {
-        const item = parseJson(line);
-        if (!item || typeof item !== "object")
+        const record = objectValue(parseJson(line));
+        const type = stringValue(record.type);
+        const recordTitle = claudeTitle(record);
+        if (recordTitle) {
+            title = recordTitle;
             continue;
-        const record = item;
-        if (record.isMeta === true)
+        }
+        if (type === "pr-link" && stringValue(record.prUrl)) {
+            builder.links.push(stringValue(record.prUrl));
+            continue;
+        }
+        if (type !== "user" && type !== "assistant")
+            continue;
+        if (record.isMeta === true || record.isSidechain === true)
             continue;
         id = stringValue(record.sessionId) || id;
         cwd = stringValue(record.cwd) || cwd;
-        const timestamp = stringValue(record.timestamp);
-        updatedAt = timestamp || updatedAt;
-        const type = stringValue(record.type);
-        const message = objectValue(record.message);
-        if (message.role || message.content) {
-            const role = stringValue(message.role) === "assistant" ? "assistant" : stringValue(message.role) === "user" ? "user" : "system";
-            pushEntry(transcript, role, collectText(message.content).join("\n"), timestamp, "message");
+        const timestamp = stringValue(record.timestamp) || undefined;
+        const content = objectValue(record.message).content;
+        if (record.isCompactSummary === true) {
+            builder.compactSummary = cleanText(collectText(content).join("\n"));
+            continue;
+        }
+        if (type === "user") {
+            if (typeof content === "string") {
+                const parsed = parseClaudeUserText(content);
+                if (parsed.prompt)
+                    builder.message("user", parsed.prompt, timestamp);
+                continue;
+            }
+            const texts = [];
+            for (const block of Array.isArray(content) ? content.map(objectValue) : []) {
+                if (block.type === "text") {
+                    const parsed = parseClaudeUserText(stringValue(block.text));
+                    if (parsed.prompt)
+                        texts.push(parsed.prompt);
+                }
+                else if (block.type === "tool_result") {
+                    builder.commandResult(stringValue(block.tool_use_id), collectText(block.content).join("\n"), { isError: block.is_error === true });
+                }
+            }
+            if (texts.length)
+                builder.message("user", texts.join("\n"), timestamp);
             continue;
         }
-        if (type === "system" || stringValue(record.subtype) === "local_command") {
-            pushEntry(transcript, "tool", collectText(record.content).join("\n"), timestamp, stringValue(record.subtype) || "system");
+        for (const block of Array.isArray(content) ? content.map(objectValue) : []) {
+            if (block.type === "text")
+                builder.message("assistant", stringValue(block.text), timestamp);
+            else if (block.type === "tool_use")
+                readClaudeTool(builder, stringValue(block.name), objectValue(block.input), stringValue(block.id), timestamp);
         }
     }
     return buildSession({
@@ -123,208 +736,498 @@ export function parseClaudeSession(path, budget = 12_000) {
         id,
         path,
         cwd,
-        updatedAt,
-        matchedCwd: false,
         lineCount: lines.length,
-        transcript,
+        builder,
         budget,
+        threadName: title,
         supplementalPaths: latestClaudeSupplementalPaths()
     });
 }
-function resolveExplicitSession(from, cwd, session, budget) {
-    if (existsSync(session)) {
-        const source = from === "auto" ? inferSourceFromPath(session) : from;
-        if (source === "claude")
-            return parseWithMatch(parseClaudeSession(session, budget), cwd);
-        return parseWithMatch(parseCodexSession(session, budget), cwd);
+function readClaudeTool(builder, name, input, callId, timestamp) {
+    if (name === "Bash" || name === "PowerShell") {
+        builder.commandCall(callId, stringValue(input.command), timestamp, input.run_in_background !== true);
+        return;
     }
-    if (from === "claude") {
-        throw new Error("--session for Claude must be a JSONL path.");
+    if (name === "Edit" || name === "Write" || name === "MultiEdit" || name === "NotebookEdit") {
+        builder.edit(stringValue(input.file_path) || stringValue(input.notebook_path), timestamp);
+        return;
     }
-    const match = findRecentFiles(join(homedir(), ".codex", "sessions"), 500)
-        .find((path) => path.includes(session));
-    if (!match)
-        throw new Error(`No Codex session file matched "${session}". Pass a JSONL path instead.`);
-    return parseWithMatch(parseCodexSession(match, budget), cwd);
-}
-function findCodexCandidates(cwd) {
-    const paths = findRecentFiles(join(homedir(), ".codex", "sessions"), 300)
-        .filter((path) => path.endsWith(".jsonl"));
-    const index = readCodexIndex();
-    return paths.map((path) => {
-        const meta = readCodexMeta(path);
-        const id = meta.id || sessionIdFromPath(path);
-        return {
-            source: "codex",
-            path,
-            id,
-            cwd: meta.cwd,
-            updatedAt: meta.updatedAt || statSync(path).mtime.toISOString(),
-            matchedCwd: samePath(meta.cwd, cwd),
-            threadName: index.get(id)
-        };
-    }).sort(compareCandidates);
-}
-function findClaudeCandidates(cwd) {
-    const encoded = encodeClaudeProjectPath(cwd);
-    const preferred = join(homedir(), ".claude", "projects", encoded);
-    const roots = existsSync(preferred) ? [preferred] : [join(homedir(), ".claude", "projects")];
-    return roots
-        .flatMap((root) => findRecentFiles(root, 300))
-        .filter((path) => path.endsWith(".jsonl"))
-        .map((path) => {
-        const meta = readClaudeMeta(path);
-        return {
-            source: "claude",
-            path,
-            id: meta.id || sessionIdFromPath(path),
-            cwd: meta.cwd,
-            updatedAt: meta.updatedAt || statSync(path).mtime.toISOString(),
-            matchedCwd: samePath(meta.cwd, cwd)
-        };
-    })
-        .sort(compareCandidates);
+    if (name === "ExitPlanMode") {
+        if (stringValue(input.plan))
+            builder.planText = cleanText(stringValue(input.plan));
+        return;
+    }
+    const planItems = planItemsFrom(input.todos ?? input.items ?? input.plan);
+    if (planItems.length) {
+        builder.setPlan(planItems);
+        return;
+    }
+    if (/update_plan$/.test(name)) {
+        builder.updatePlan({
+            advance: input.advance === true,
+            done: Array.isArray(input.done) ? input.done.filter((value) => typeof value === "number") : undefined,
+            start: numberValue(input.start)
+        });
+        return;
+    }
+    const detail = stringValue(input.file_path) || stringValue(input.pattern) || stringValue(input.url) || stringValue(input.query) || stringValue(input.description);
+    builder.toolCall(name, detail, timestamp);
 }
-function parseCandidate(candidate, budget) {
-    const session = candidate.source === "codex" ? parseCodexSession(candidate.path, budget) : parseClaudeSession(candidate.path, budget);
-    session.id = candidate.id || session.id;
-    session.cwd = candidate.cwd || session.cwd;
-    session.updatedAt = candidate.updatedAt || session.updatedAt;
-    session.matchedCwd = candidate.matchedCwd;
-    session.threadName = candidate.threadName || session.threadName;
-    return session;
+function parseClaudeUserText(text) {
+    const commandName = /<command-name>([\s\S]*?)<\/command-name>/.exec(text)?.[1]?.trim();
+    if (commandName) {
+        const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(text)?.[1]?.trim();
+        return { prompt: [commandName, args].filter(Boolean).join(" ") };
+    }
+    if (/^\s*<(?:local-command-stdout|local-command-stderr|bash-input|bash-stdout|bash-stderr|task-notification)>/.test(text))
+        return { prompt: "" };
+    if (/^\[Request interrupted by user/.test(text.trim()))
+        return { prompt: "" };
+    return { prompt: text };
 }
-function requiredBest(candidates, source, cwd) {
-    const best = candidates[0];
-    if (!best)
-        throw new Error(`No ${source} sessions were found for ${cwd}. Pass --session with a JSONL path.`);
-    return best;
+function claudeTitle(record) {
+    switch (record.type) {
+        case "custom-title":
+            return stringValue(record.customTitle) || undefined;
+        case "ai-title":
+            return stringValue(record.aiTitle) || undefined;
+        case "summary":
+            return stringValue(record.summary) || undefined;
+        default:
+            return undefined;
+    }
 }
-function compareCandidates(a, b) {
-    if (a.matchedCwd !== b.matchedCwd)
-        return a.matchedCwd ? -1 : 1;
-    return Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+export function parseGeminiSession(path, budget = DEFAULT_EXCERPT_TOKENS) {
+    const { metadata, messages, lineCount } = readGeminiConversation(path);
+    const builder = new SessionBuilder();
+    const id = stringValue(metadata.sessionId) || sessionIdFromPath(path);
+    const projectDir = geminiProjectDir(path);
+    for (const message of messages) {
+        const timestamp = stringValue(message.timestamp) || undefined;
+        if (message.type === "user") {
+            builder.message("user", geminiUserPrompt(message), timestamp);
+        }
+        else if (message.type === "gemini") {
+            builder.message("assistant", geminiText(message.content), timestamp);
+            for (const call of Array.isArray(message.toolCalls) ? message.toolCalls.map(objectValue) : []) {
+                readGeminiTool(builder, call, timestamp, projectDir ? join(projectDir, id, "plans") : undefined);
+            }
+        }
+        // info, warning, and error records are CLI notices, not conversation.
+    }
+    return buildSession({
+        source: "gemini",
+        id,
+        path,
+        cwd: projectDir ? readGeminiProjectRoot(projectDir) : undefined,
+        lineCount,
+        builder,
+        budget,
+        threadName: stringValue(metadata.summary) || undefined
+    });
 }
-function buildSession(args) {
-    const transcript = args.transcript.filter((entry) => isUsefulText(entry.text));
-    return {
-        source: args.source,
-        id: args.id,
-        path: args.path,
-        cwd: args.cwd,
-        updatedAt: args.updatedAt,
-        matchedCwd: args.matchedCwd,
-        lineCount: args.lineCount,
-        transcript,
-        transcriptExcerpt: renderTranscriptExcerpt(transcript, args.budget || 12_000),
-        supplementalPaths: args.supplementalPaths
+/**
+ * Replays a Gemini chat file the way Gemini CLI loads it: a message record is rewritten in place each time its id
+ * repeats, `$set` updates metadata (or replaces every message), and `$rewindTo` drops that message and all after it.
+ */
+function readGeminiConversation(path) {
+    if (/\.json$/i.test(path)) {
+        const record = objectValue(parseJson(readFileSync(path, "utf8")));
+        const messages = Array.isArray(record.messages) ? record.messages.map(objectValue) : [];
+        return { metadata: record, messages, lineCount: messages.length };
+    }
+    const lines = readSessionLines(path);
+    const messages = new Map();
+    const addMessages = (value) => {
+        for (const message of Array.isArray(value) ? value.map(objectValue) : [])
+            if (typeof message.id === "string")
+                messages.set(message.id, message);
     };
+    let metadata = {};
+    for (const line of lines) {
+        const record = objectValue(parseJson(line));
+        if (typeof record.$rewindTo === "string") {
+            const ids = [...messages.keys()];
+            const index = ids.indexOf(record.$rewindTo);
+            for (const messageId of index >= 0 ? ids.slice(index) : ids)
+                messages.delete(messageId);
+        }
+        else if (typeof record.id === "string") {
+            messages.set(record.id, record);
+        }
+        else if (record.$set && typeof record.$set === "object") {
+            const update = objectValue(record.$set);
+            if (Array.isArray(update.messages)) {
+                messages.clear();
+                addMessages(update.messages);
+            }
+            metadata = { ...metadata, ...update };
+        }
+        else if (typeof record.sessionId === "string") {
+            metadata = { ...metadata, ...record };
+            addMessages(record.messages);
+        }
+    }
+    return { metadata, messages: [...messages.values()], lineCount: lines.length };
 }
-function renderTranscriptExcerpt(entries, budget) {
-    const rendered = entries.slice(-80).map((entry) => {
-        const when = entry.timestamp ? ` ${entry.timestamp}` : "";
-        const kind = entry.kind ? `/${entry.kind}` : "";
-        return `### ${entry.role}${kind}${when}\n${entry.text}`;
-    });
-    let output = rendered.join("\n\n").trim();
-    if (output.length > budget)
-        output = output.slice(output.length - budget).replace(/^[\s\S]*?(?=### )/, "");
-    return output || "No transcript excerpt captured.";
+const GEMINI_REFERENCED_FILES = "--- Content from referenced files ---";
+/** What the user typed. `displayContent` holds it when `@file` expansion rewrote `content`; tool results carry no text. */
+function geminiUserPrompt(message) {
+    if (message.type !== "user")
+        return "";
+    const text = geminiText(message.displayContent ?? message.content).split(GEMINI_REFERENCED_FILES)[0];
+    return cleanText(text);
 }
-function readCodexMeta(path) {
-    for (const line of readHeadLines(path).slice(0, 20)) {
-        const item = parseJson(line);
-        if (!item || typeof item !== "object")
-            continue;
-        const record = item;
-        if (stringValue(record.type) !== "session_meta")
-            continue;
-        const payload = objectValue(record.payload);
-        return {
-            id: stringValue(payload.id),
-            cwd: stringValue(payload.cwd),
-            updatedAt: stringValue(payload.timestamp)
-        };
-    }
-    return {};
+function geminiText(value) {
+    if (typeof value === "string")
+        return value;
+    const parts = Array.isArray(value) ? value.map(objectValue) : [objectValue(value)];
+    return parts
+        .filter((part) => typeof part.text === "string" && part.thought !== true)
+        .map((part) => part.text)
+        .join("");
 }
-function readClaudeMeta(path) {
-    for (const line of readHeadLines(path).slice(0, 30)) {
-        const item = parseJson(line);
-        if (!item || typeof item !== "object")
-            continue;
-        const record = item;
-        const cwd = stringValue(record.cwd);
-        if (!cwd)
-            continue;
-        return {
-            id: stringValue(record.sessionId),
-            cwd,
-            updatedAt: stringValue(record.timestamp)
-        };
+function readGeminiTool(builder, call, messageTimestamp, plansDir) {
+    const name = stringValue(call.name);
+    const args = objectValue(call.args);
+    const status = stringValue(call.status);
+    const timestamp = stringValue(call.timestamp) || messageTimestamp;
+    switch (name) {
+        case "run_shell_command": {
+            const command = stringValue(args.command);
+            if (status === "cancelled") {
+                builder.toolCall("Shell", `${command} (cancelled)`, timestamp);
+                return;
+            }
+            const output = geminiToolOutput(call);
+            const background = args.is_background === true || output.startsWith("Command moved to background");
+            // The shell tool appends "Exit Code: N" only when N is non-zero.
+            const exitCode = parseExitCode(output) ?? (status === "error" ? 1 : status === "success" && !background ? 0 : undefined);
+            builder.command(command, exitCode, output, timestamp);
+            return;
+        }
+        case "replace":
+        case "write_file":
+            if (status !== "error" && status !== "cancelled")
+                builder.edit(stringValue(args.file_path), timestamp);
+            return;
+        case "write_todos":
+            builder.setPlan(planItemsFrom(args.todos));
+            return;
+        case "exit_plan_mode": {
+            const planFile = plansDir && stringValue(args.plan_filename) ? join(plansDir, basename(stringValue(args.plan_filename))) : "";
+            if (planFile && existsSync(planFile))
+                builder.planText = cleanText(readFileSync(planFile, "utf8"));
+            return;
+        }
     }
-    return {};
+    const detail = stringValue(args.file_path) || stringValue(args.dir_path) || stringValue(args.pattern) || stringValue(args.query) || stringValue(args.url) || stringValue(args.description);
+    builder.toolCall(name, detail, timestamp);
 }
-function readCodexIndex() {
-    const indexPath = join(homedir(), ".codex", "session_index.jsonl");
-    const map = new Map();
-    if (!existsSync(indexPath))
-        return map;
-    for (const line of readLines(indexPath)) {
-        const item = parseJson(line);
-        if (!item || typeof item !== "object")
-            continue;
-        const record = item;
-        const id = stringValue(record.id);
-        const name = stringValue(record.thread_name);
-        if (id && name)
-            map.set(id, name);
+/** The text a tool returned to the model. The shell tool prefixes the command's output with "Output: ". */
+function geminiToolOutput(call) {
+    const texts = (Array.isArray(call.result) ? call.result.map(objectValue) : [])
+        .flatMap((part) => {
+        const response = objectValue(objectValue(part.functionResponse).response);
+        return [stringValue(response.output), stringValue(response.error), stringValue(part.text)];
+    })
+        .filter(Boolean);
+    const text = texts.length ? texts.join("\n") : stringValue(call.resultDisplay);
+    return text.replace(/^Output: /, "");
+}
+// Field numbers below come from the protos agy embeds: gemini_coder.Step and the exa.cortex_pb step payloads.
+const AGY_STEP = { userInput: 14, plannerResponse: 15, errorMessage: 17, checkpoint: 23, commandStatus: 28 };
+const AGY_STATUS = { cleared: 5, canceled: 6, error: 7 };
+const AGY_EDIT_TOOLS = new Set(["replace_file_content", "multi_replace_file_content", "write_to_file"]);
+export function parseAntigravitySession(path, budget = DEFAULT_EXCERPT_TOKENS) {
+    const db = openAntigravityDb(path);
+    if (!db)
+        throw new CtxError(`Could not open the Antigravity conversation ${path}.`, "Check that the file exists and is readable.");
+    const builder = new SessionBuilder();
+    const id = antigravityId(path);
+    let metadata = {};
+    let stepCount = 0;
+    let checkpointTitle;
+    try {
+        metadata = antigravityTrajectoryMetadata(db);
+        for (const row of db.prepare("SELECT step_payload FROM steps ORDER BY idx").all()) {
+            if (!(row.step_payload instanceof Uint8Array))
+                continue;
+            stepCount++;
+            checkpointTitle = readAntigravityStep(builder, pbDecode(row.step_payload)) || checkpointTitle;
+        }
     }
-    return map;
+    finally {
+        db.close();
+    }
+    const summary = readAntigravityIndex().get(id);
+    const firstPrompt = builder.transcript.find((entry) => entry.role === "user")?.text;
+    return buildSession({
+        source: "antigravity",
+        id,
+        path,
+        cwd: metadata.cwd || summary?.cwd,
+        lineCount: stepCount,
+        builder,
+        budget,
+        threadName: summary?.title || checkpointTitle || (firstPrompt ? truncate(oneLine(firstPrompt), 80) : undefined)
+    });
 }
-function latestClaudeSupplementalPaths() {
-    return unique([
-        ...findRecentFiles(join(homedir(), ".claude", "plans"), 5).filter((path) => path.endsWith(".md")),
-        ...findRecentFiles(join(homedir(), ".claude", "tasks"), 5).filter((path) => path.endsWith(".json"))
-    ]).slice(0, 8);
+/** Feeds one gemini_coder.Step into the builder; returns a conversation title when a checkpoint carries one. */
+function readAntigravityStep(builder, step) {
+    const type = pbInt(step, 1);
+    const status = pbInt(step, 4);
+    const metadata = pbMessage(step, 5);
+    const timestamp = pbTimestamp(pbMessage(metadata, 1));
+    // Steps that Antigravity has compacted out of context keep their metadata but lose their payload, so old
+    // prompts and replies come back empty here; the latest checkpoint summarizes them.
+    switch (type) {
+        case AGY_STEP.userInput:
+            builder.message("user", antigravityPrompt(pbMessage(step, 19)), timestamp);
+            return undefined;
+        case AGY_STEP.plannerResponse: {
+            const response = pbMessage(step, 20);
+            builder.message("assistant", pbString(response, 8) || pbString(response, 1), timestamp);
+            return undefined;
+        }
+        case AGY_STEP.checkpoint: {
+            const checkpoint = pbMessage(step, 30);
+            const summary = pbString(checkpoint, 5);
+            if (summary.trim())
+                builder.compactSummary = cleanText(summary);
+            return pbString(checkpoint, 10) || undefined;
+        }
+        case AGY_STEP.commandStatus: {
+            const result = pbMessage(step, 37);
+            builder.commandResult(pbString(result, 1), pbString(result, 9) || pbString(result, 3), { exitCode: pbInt(result, 5) });
+            return undefined;
+        }
+        case AGY_STEP.errorMessage:
+            // The tool call failed before it ran.
+            return undefined;
+    }
+    const call = pbMessage(metadata, 4);
+    const name = pbString(call, 2);
+    // System and ephemeral messages carry no tool call.
+    if (name)
+        readAntigravityTool(builder, name, objectValue(parseJson(pbString(call, 3))), step, status, timestamp);
+    return undefined;
 }
-function readLines(path) {
-    return readFileSync(path, "utf8").split(/\r?\n/).filter(Boolean);
+/** CortexStepUserInput: what the user sent (2), else its text items (3), else the raw query (1). */
+function antigravityPrompt(input) {
+    return pbString(input, 2) || pbMessages(input, 3).map((item) => pbString(item, 1)).join("") || pbString(input, 1);
 }
-function readHeadLines(path) {
-    const stats = statSync(path);
-    if (stats.size <= 256_000)
-        return readLines(path);
-    return readSlice(path, 0, 256_000).split(/\r?\n/).filter(Boolean);
+function readAntigravityTool(builder, name, args, step, status, timestamp) {
+    // Newer agy builds run every tool as a generic step (140) whose result carries the typed step as a google.protobuf.Any.
+    const result = pbMessage(pbMessage(step, 140), 2);
+    const resultText = pbString(result, 1);
+    const payload = pbMessage(result, 6);
+    const typed = pbString(payload, 1).endsWith("gemini_coder.Step") ? pbDecode(pbBytes(payload, 2)) : step;
+    if (name === "run_command") {
+        const run = pbMessage(typed, 28);
+        const command = stringValue(args.CommandLine) || pbString(run, 23) || pbString(run, 1);
+        if (status === AGY_STATUS.canceled || pbInt(run, 14) === 1 || /^Encountered error in step execution: context canceled/.test(resultText.trim())) {
+            builder.toolCall("Shell", `${command} (cancelled)`, timestamp);
+            return;
+        }
+        const exitCode = pbInt(run, 6) ?? numberFromMatch(/exited with code (-?\d+)/.exec(resultText)) ?? (status === AGY_STATUS.error ? 1 : undefined);
+        const output = pbString(pbMessage(run, 21), 1) || resultText;
+        const commandId = pbString(run, 13);
+        // A command that went to the background reports its exit code in a later command_status step.
+        if (exitCode === undefined && commandId && status !== AGY_STATUS.cleared)
+            builder.commandCall(commandId, command, timestamp);
+        else
+            builder.command(command, exitCode, output, timestamp);
+        return;
+    }
+    if (AGY_EDIT_TOOLS.has(name)) {
+        const file = stringValue(args.TargetFile);
+        // Plans and walkthroughs that agy writes to its own brain folder are not repo edits.
+        if (file && status !== AGY_STATUS.canceled && status !== AGY_STATUS.error && !isInside(resolve(file), resolve(antigravityHome())))
+            builder.edit(file, timestamp);
+        return;
+    }
+    const detail = stringValue(args.AbsolutePath) || stringValue(args.DirectoryPath) || stringValue(args.SearchPath) || stringValue(args.Query) || stringValue(args.query) || stringValue(args.Url);
+    builder.toolCall(name, detail, timestamp);
 }
-function readSessionLines(path) {
-    const stats = statSync(path);
-    if (stats.size <= 4_000_000)
-        return readLines(path);
-    const head = readSlice(path, 0, 512_000);
-    const tailLength = Math.min(2_000_000, stats.size);
-    const tail = readSlice(path, stats.size - tailLength, tailLength);
-    return `${head}\n${tail}`.split(/\r?\n/).filter(Boolean);
+function numberFromMatch(match) {
+    return match ? Number(match[1]) : undefined;
 }
-function readSlice(path, position, length) {
-    const fd = openSync(path, "r");
+const requireBuiltin = createRequire(import.meta.url);
+let sqliteModule;
+/** node:sqlite prints an ExperimentalWarning on load in Node 22; keep CLI output clean. */
+function loadSqlite() {
+    if (sqliteModule)
+        return sqliteModule;
+    const emitWarning = process.emitWarning;
+    process.emitWarning = ((warning, ...rest) => {
+        const message = typeof warning === "string" ? warning : warning.message;
+        if (/SQLite is an experimental feature/i.test(message))
+            return;
+        return emitWarning.call(process, warning, ...rest);
+    });
     try {
-        const buffer = Buffer.alloc(length);
-        const bytesRead = readSync(fd, buffer, 0, length, position);
-        return buffer.subarray(0, bytesRead).toString("utf8");
+        sqliteModule = requireBuiltin("node:sqlite");
+        return sqliteModule;
     }
     finally {
-        closeSync(fd);
+        process.emitWarning = emitWarning;
     }
 }
-function parseJson(line) {
+/**
+ * Opens an Antigravity database without changing anything next to it. A running agy keeps its newest steps in the
+ * -wal file, so read through it while agy has it open. Otherwise open the file as immutable: a plain read-only open
+ * of a WAL database would create -wal and -shm files in agy's folder.
+ */
+function openAntigravityDb(path) {
+    if (!existsSync(path))
+        return undefined;
+    const { DatabaseSync } = loadSqlite();
+    if (existsSync(`${path}-wal`) && existsSync(`${path}-shm`)) {
+        try {
+            return new DatabaseSync(path, { readOnly: true });
+        }
+        catch {
+            // Fall back to the last checkpointed state.
+        }
+    }
     try {
-        return JSON.parse(line);
+        const url = pathToFileURL(path);
+        url.searchParams.set("immutable", "1");
+        return new DatabaseSync(url, { readOnly: true });
     }
     catch {
         return undefined;
     }
 }
+function buildSession(args) {
+    const { builder } = args;
+    return {
+        source: args.source,
+        id: args.id,
+        path: args.path,
+        cwd: args.cwd,
+        updatedAt: mtimeIso(args.path),
+        matchedCwd: false,
+        lineCount: args.lineCount,
+        transcript: builder.transcript,
+        transcriptExcerpt: renderTranscriptExcerpt(builder.transcript, args.budget),
+        threadName: args.threadName,
+        supplementalPaths: args.supplementalPaths,
+        plan: builder.plan,
+        planText: builder.planText,
+        commands: builder.commands,
+        edits: builder.edits,
+        compactSummary: builder.compactSummary,
+        links: unique(builder.links)
+    };
+}
+/** Most recent conversation (and failures) that fits the token budget, oldest first. Routine tool calls are left out. */
+export function renderTranscriptExcerpt(entries, budgetTokens = DEFAULT_EXCERPT_TOKENS) {
+    const maxChars = Math.max(500, budgetTokens * 4);
+    const rendered = [];
+    let used = 0;
+    for (const entry of [...entries].reverse()) {
+        if (entry.kind === "tool_call" || entry.kind === "edit")
+            continue;
+        const text = entry.role === "tool" ? entry.text : truncate(entry.text, 1_500);
+        const line = `[${entry.role}] ${text}`;
+        if (used + line.length > maxChars)
+            break;
+        rendered.unshift(line);
+        used += line.length + 1;
+    }
+    return rendered.join("\n");
+}
+function latestClaudeSupplementalPaths() {
+    const root = claudeHome();
+    return unique([...findRecentFiles(join(root, "plans"), 3, /\.md$/i), ...findRecentFiles(join(root, "tasks"), 3, /\.json$/i)]);
+}
+// ---------------------------------------------------------------------------
+// Text helpers
+const NOISE_BLOCKS = [
+    "system-reminder",
+    "local-command-caveat",
+    "permissions instructions",
+    "app-context",
+    "collaboration_mode",
+    "skills_instructions",
+    "plugins_instructions",
+    "environment_context",
+    "user_instructions",
+    "session_context",
+    "hook_context",
+    "INSTRUCTIONS"
+];
+function cleanText(text) {
+    let next = text.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
+    for (const tag of NOISE_BLOCKS)
+        next = next.replace(new RegExp(`<${tag}>[\\s\\S]*?</${tag}>`, "g"), "");
+    return next.replace(/"encrypted_content":"[^"]+"/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function isUsefulText(text) {
+    if (!text || text.length < 2)
+        return false;
+    if (/^(?:# AGENTS\.md instructions|# Handoff[:\s·]|<environment_context>|<user_instructions>|<turn_aborted>)/.test(text))
+        return false;
+    if (/You are Codex|Knowledge cutoff:|Filesystem sandboxing defines|DO NOT respond to these messages/.test(text))
+        return false;
+    return true;
+}
+function planItemsFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map(objectValue)
+        .map((entry) => ({
+        text: oneLine(stringValue(entry.content) || stringValue(entry.step) || stringValue(entry.text) || stringValue(entry.subject) || stringValue(entry.description)),
+        status: planStatus(entry.status)
+    }))
+        .filter((entry) => entry.text && entry.status !== undefined);
+}
+function planStatus(value) {
+    if (value === "completed" || value === "done")
+        return "completed";
+    if (value === "in_progress" || value === "in-progress" || value === "active")
+        return "in_progress";
+    if (value === "pending" || value === "todo" || value === "not_started" || value === "blocked")
+        return "pending";
+    return undefined;
+}
+function patchFiles(patch) {
+    return unique(Array.from(patch.matchAll(/\*\*\* (?:Add|Update|Delete) File: ([^\n\\"]+)/g), (match) => match[1].trim()));
+}
+function shellCommand(parts) {
+    const strings = parts.filter((part) => typeof part === "string");
+    if (strings.length >= 3 && /(?:^|\/)(?:ba|z|fi)?sh$/.test(strings[0]) && /^-l?c$/.test(strings[1]))
+        return strings.slice(2).join(" ");
+    return strings.join(" ");
+}
+function parseExitCode(output) {
+    const match = /"exit_code"\s*:\s*(-?\d+)/.exec(output) ||
+        /Process exited with code (-?\d+)/i.exec(output) ||
+        /^Exit code:?\s*(-?\d+)/im.exec(output);
+    return match ? Number(match[1]) : undefined;
+}
+function firstErrorLine(output) {
+    const lines = output
+        .split(/\r?\n/)
+        .map((line) => line.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "").trim())
+        .filter((line) => line && !/^(?:Exit code|Process exited|Wall time|Chunk ID|Output:)/i.test(line));
+    const line = lines.find((candidate) => /(error|fail|exception|traceback|cannot|not found|denied|panic|assert|expected)/i.test(candidate)) || lines[0];
+    return line ? truncate(line, 200) : undefined;
+}
+function outputText(value) {
+    if (typeof value === "string") {
+        const parsed = objectValue(parseJson(value));
+        if (typeof parsed.output === "string") {
+            const exit = numberValue(objectValue(parsed.metadata).exit_code);
+            return exit === undefined ? parsed.output : `Exit code: ${exit}\n${parsed.output}`;
+        }
+        return value;
+    }
+    return collectText(value).join("\n");
+}
 function collectText(value) {
     if (typeof value === "string")
         return [value];
@@ -333,78 +1236,168 @@ function collectText(value) {
     if (!value || typeof value !== "object")
         return [];
     const record = value;
-    return ["text", "content", "message", "output", "error", "body", "name", "input"].flatMap((key) => collectText(record[key]));
+    return ["text", "content", "output"].flatMap((key) => collectText(record[key]));
 }
-function pushEntry(entries, role, text, timestamp, kind) {
-    const clean = cleanText(text);
-    if (!isUsefulText(clean))
-        return;
-    entries.push({ role, text: clean, timestamp, kind });
-}
-function cleanText(text) {
-    return text
-        .replace(/\u001b\[[0-9;]*m/g, "")
-        .replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, "")
-        .replace(/<permissions instructions>[\s\S]*?<\/permissions instructions>/g, "")
-        .replace(/<app-context>[\s\S]*?<\/app-context>/g, "")
-        .replace(/<collaboration_mode>[\s\S]*?<\/collaboration_mode>/g, "")
-        .replace(/<skills_instructions>[\s\S]*?<\/skills_instructions>/g, "")
-        .replace(/<plugins_instructions>[\s\S]*?<\/plugins_instructions>/g, "")
-        .replace(/"encrypted_content":"[^"]+"/g, "")
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
+function sessionIdFromPath(path) {
+    return basename(path)
+        .replace(/\.(jsonl|json)$/i, "")
+        .replace(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-/, "");
 }
-function isUsefulText(text) {
-    if (!text || text.length < 3)
-        return false;
-    if (text.includes("base_instructions"))
+function matchesWorkspace(sessionCwd, scope) {
+    if (!sessionCwd)
         return false;
-    if (text.includes("Knowledge cutoff:"))
-        return false;
-    if (text.includes("You are Codex"))
-        return false;
-    if (text.includes("Filesystem sandboxing defines"))
-        return false;
-    if (text.includes("# Codex desktop context"))
-        return false;
-    if (text.includes("### Available skills"))
-        return false;
-    if (text.includes("### Skill roots"))
-        return false;
-    if (text.includes("Tool definitions"))
-        return false;
-    if (text.includes("Valid channels:"))
-        return false;
-    if (text.includes("# Handoff:"))
-        return false;
-    if (text.includes("DO NOT respond to these messages"))
-        return false;
-    if (text.includes("deferred_tools_delta"))
-        return false;
-    return true;
+    const target = canonicalPath(sessionCwd);
+    if (target === scope.cwd)
+        return true;
+    return Boolean(scope.repoRoot && isInside(target, scope.repoRoot));
+}
+function isInside(path, root) {
+    const rel = relative(root, path);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function toScope(cwd, repoRoot) {
+    return { cwd: canonicalPath(cwd), repoRoot: repoRoot ? canonicalPath(repoRoot) : undefined };
+}
+/** Claude Code stores projects under the cwd with every non-alphanumeric character replaced by "-". */
+export function encodeClaudeProjectPath(cwd) {
+    return resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
 }
 function objectValue(value) {
-    return value && typeof value === "object" ? value : {};
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function stringValue(value) {
     return typeof value === "string" ? value : "";
 }
-function sessionIdFromPath(path) {
-    return basename(path).replace(/\.(jsonl|json)$/i, "").replace(/^rollout-[^-]+-[^-]+-[^-]+-/, "");
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function samePath(a, b) {
-    if (!a)
-        return false;
-    return resolve(a) === resolve(b);
+function parseJson(line) {
+    if (!line)
+        return undefined;
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
 }
-function parseWithMatch(session, cwd) {
-    session.matchedCwd = samePath(session.cwd, cwd);
-    return session;
+function mtimeIso(path) {
+    return statSync(path).mtime.toISOString();
+}
+const utf8 = new TextDecoder();
+/** One level of a serialized message. Nested messages stay as bytes until asked for; a malformed tail is dropped. */
+function pbDecode(bytes) {
+    const fields = new Map();
+    if (!bytes)
+        return fields;
+    let offset = 0;
+    const varint = () => {
+        let value = 0n;
+        for (let shift = 0n; offset < bytes.length; shift += 7n) {
+            const byte = bytes[offset++];
+            value |= BigInt(byte & 0x7f) << shift;
+            if (byte < 0x80)
+                return value;
+        }
+        throw new Error("truncated varint");
+    };
+    try {
+        while (offset < bytes.length) {
+            const key = varint();
+            const field = Number(key >> 3n);
+            const wire = Number(key & 7n);
+            let value;
+            if (wire === 0) {
+                value = varint();
+            }
+            else if (wire === 2) {
+                const length = Number(varint());
+                if (offset + length > bytes.length)
+                    break;
+                value = bytes.subarray(offset, offset + length);
+                offset += length;
+            }
+            else if (wire === 1 || wire === 5) {
+                offset += wire === 1 ? 8 : 4;
+                continue;
+            }
+            else {
+                break;
+            }
+            const values = fields.get(field);
+            if (values)
+                values.push(value);
+            else
+                fields.set(field, [value]);
+        }
+    }
+    catch {
+        // Keep the fields read so far.
+    }
+    return fields;
+}
+function pbBytes(message, field) {
+    const value = message.get(field)?.at(-1);
+    return value instanceof Uint8Array ? value : undefined;
+}
+function pbString(message, field) {
+    const bytes = pbBytes(message, field);
+    return bytes ? utf8.decode(bytes) : "";
+}
+function pbMessage(message, field) {
+    return pbDecode(pbBytes(message, field));
+}
+function pbMessages(message, field) {
+    return (message.get(field) || []).filter((value) => value instanceof Uint8Array).map(pbDecode);
+}
+/** An int32/enum/bool field; undefined when absent. */
+function pbInt(message, field) {
+    const value = message.get(field)?.at(-1);
+    return typeof value === "bigint" ? Number(BigInt.asIntN(32, value)) : undefined;
+}
+/** A google.protobuf.Timestamp as an ISO string. */
+function pbTimestamp(timestamp) {
+    const seconds = timestamp.get(1)?.at(-1);
+    if (typeof seconds !== "bigint")
+        return undefined;
+    const nanos = timestamp.get(2)?.at(-1);
+    return new Date(Number(seconds) * 1000 + (typeof nanos === "bigint" ? Number(nanos) / 1e6 : 0)).toISOString();
+}
+// ---------------------------------------------------------------------------
+// File reading
+function readSessionLines(path) {
+    const size = statSync(path).size;
+    const text = size <= 16_000_000 ? readFileSync(path, "utf8") : `${readSlice(path, 0, 2_000_000)}\n${readSlice(path, size - 10_000_000, 10_000_000)}`;
+    return text.split(/\r?\n/).filter(Boolean);
+}
+function readFirstLine(path, maxBytes = 2_000_000) {
+    let length = 32_000;
+    while (true) {
+        const chunk = readSlice(path, 0, length);
+        const newline = chunk.indexOf("\n");
+        if (newline >= 0)
+            return chunk.slice(0, newline);
+        if (chunk.length < length || length >= maxBytes)
+            return chunk;
+        length *= 4;
+    }
+}
+function readHead(path, bytes) {
+    return readSlice(path, 0, bytes);
 }
-function inferSourceFromPath(path) {
-    return path.includes("/.claude/") ? "claude" : "codex";
+function readTail(path, bytes) {
+    const size = statSync(path).size;
+    return readSlice(path, Math.max(0, size - bytes), Math.min(bytes, size));
 }
-function encodeClaudeProjectPath(cwd) {
-    return resolve(cwd).replace(/[\/\\]/g, "-");
+function readSlice(path, position, length) {
+    const fd = openSync(path, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const bytesRead = readSync(fd, buffer, 0, length, position);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
 }
 //# sourceMappingURL=session.js.map