@1agents/session-reader 0.1.1

package/dist/src/overview.js

@@ -0,0 +1,324 @@
+import path from 'node:path';
+import { clip, oneLine } from './util/text.js';
+import { analyzableCommand, fileWrites } from './writes.js';
+import { summarizeTurns } from './turns.js';
+import { classifyUserTurn } from './classify.js';
+import { commandLedger, displayPath, errorLedger, fileLedger, jobCounts, jobLedger } from './ledger.js';
+const ABS_PATH = /(?:\/[\w.\-一-鿿]+){2,}/g;
+const SSH_HOST = /\b(?:ssh|scp|rsync)\b[^\n;|]*?\b[\w.-]+@((?:\d{1,3}(?:\.\d{1,3}){3})|(?:[\w-]+(?:\.[\w-]+)+))/g;
+const NOISE_DIR = /^\/(?:usr|bin|sbin|etc|proc|sys|dev|opt\/homebrew|Library|System)(?:\/|$)/;
+const REAL_ROOT = /^\/(?:home|Users|root|var|tmp|private|data|mnt|srv|opt|workspace|app)(?:\/|$)/;
+const UUID_SEGMENT = /\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/;
+const COMMIT_RESULT = /\[([\w./-]+)\s+([0-9a-f]{7,40})\]\s*(.+)/;
+function collectAnchors(session, summaries) {
+    const dirs = new Map();
+    const files = new Map();
+    const hosts = new Map();
+    const turnAt = (index) => summaries.find((turn) => index >= turn.events[0] && index <= turn.events[1])?.no ?? 1;
+    const note = (map, key, turn) => {
+        const seen = map.get(key);
+        if (seen) {
+            seen.hits++;
+            seen.firstTurn = Math.min(seen.firstTurn, turn);
+            seen.lastTurn = Math.max(seen.lastTurn, turn);
+        }
+        else {
+            map.set(key, { hits: 1, firstTurn: turn, lastTurn: turn });
+        }
+    };
+    for (const turn of session.turns) {
+        const body = `${turn.toolArgs ? JSON.stringify(turn.toolArgs) : ''}\n${turn.toolResult ?? ''}`;
+        if (!body.trim())
+            continue;
+        const at = turnAt(turn.index);
+        const command = analyzableCommand(turn);
+        for (const match of command ? command.matchAll(SSH_HOST) : []) {
+            if (match[1])
+                hosts.set(match[1], (hosts.get(match[1]) ?? 0) + 1);
+        }
+        for (const match of body.matchAll(ABS_PATH)) {
+            const found = match[0];
+            if (NOISE_DIR.test(found) || !REAL_ROOT.test(found) || UUID_SEGMENT.test(found))
+                continue;
+            if (/\.\w{1,6}$/.test(found)) {
+                note(files, found, at);
+                const dir = path.dirname(found);
+                if (REAL_ROOT.test(dir))
+                    note(dirs, dir, at);
+            }
+            else {
+                note(dirs, found, at);
+            }
+        }
+    }
+    const top = (map, kind) => [...map.entries()]
+        .sort((a, b) => b[1].hits - a[1].hits)
+        .slice(0, 10)
+        .map(([value, seen]) => ({
+        path: value,
+        hits: seen.hits,
+        kind,
+        firstTurn: seen.firstTurn,
+        lastTurn: seen.lastTurn,
+        // Anchors are mentions in text; nobody was seen acting on them.
+        provenance: 'candidate',
+    }));
+    return {
+        hosts: [...hosts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([host]) => host),
+        paths: [...top(dirs, 'dir'), ...top(files, 'file')],
+    };
+}
+/**
+ * A commit shows up twice — in the `git commit -m` call and in the `[branch sha]`
+ * the result echoes back. Key on the message so the echo fills in the sha
+ * instead of adding a second row for the same commit.
+ */
+function collectCommits(turns) {
+    const byMessage = new Map();
+    const key = (message) => message.slice(0, 60);
+    for (const turn of turns) {
+        const echoed = COMMIT_RESULT.exec(turn.toolResult ?? '');
+        if (echoed?.[2] && echoed[3]) {
+            const message = oneLine(echoed[3], 120);
+            const existing = byMessage.get(key(message));
+            if (existing)
+                existing.sha ??= echoed[2];
+            else
+                byMessage.set(key(message), { sha: echoed[2], message, timestamp: turn.timestamp });
+            continue;
+        }
+        const command = analyzableCommand(turn);
+        const matched = command ? /git commit[^\n]*?-m\s+(?:'([^']+)'|"([^"]+)")/.exec(command) : undefined;
+        const text = matched?.[1] ?? matched?.[2];
+        if (!text)
+            continue;
+        const message = oneLine(text, 120);
+        if (!byMessage.has(key(message)))
+            byMessage.set(key(message), { message, timestamp: turn.timestamp });
+    }
+    return [...byMessage.values()];
+}
+/** Strips the codex `exec` envelope so the actual error text survives. */
+function unwrapResult(result) {
+    let text = (result ?? '').replace(/^Script completed\s*Wall time [\d.]+ seconds\s*Output:\s*/i, '');
+    const outputs = [...text.matchAll(/"output"\s*:\s*"((?:[^"\\]|\\.)*)"/g)]
+        .map((match) => match[1] ?? '')
+        .filter(Boolean)
+        .sort((a, b) => b.length - a.length);
+    if (outputs[0])
+        text = outputs[0].replace(/\\n/g, ' ').replace(/\\"/g, '"');
+    return text.replace(/^Created At:.*?Completed At:.*?\n/s, '');
+}
+function collectPitfalls(turns) {
+    const out = [];
+    const seen = new Set();
+    for (const turn of turns) {
+        if (turn.kind !== 'tool_result' || !turn.isError)
+            continue;
+        const text = oneLine(unwrapResult(turn.toolResult), 200);
+        const key = text.slice(0, 60);
+        if (!text || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(text);
+    }
+    return out;
+}
+function buildStats(session, files, turnCount) {
+    const jobs = jobLedger(session);
+    const commands = commandLedger(session);
+    // One write action per extraction, before the ledger dedupes by path.
+    const writeActions = session.turns.reduce((total, turn) => total + fileWrites(turn).length, 0) +
+        session.stats.fileChanges.length;
+    const events = { user: 0, assistant: 0, thinking: 0, tool_call: 0, tool_result: 0 };
+    for (const turn of session.turns)
+        events[turn.kind]++;
+    const provider = session.stats;
+    return {
+        turns: turnCount,
+        events,
+        // Single definition, shared with `1session files`.
+        filesChanged: files.length,
+        fileChangeEvents: writeActions,
+        filesByProvenance: files.reduce((counts, file) => ({ ...counts, [file.provenance]: counts[file.provenance] + 1 }), { observed: 0, derived: 0, candidate: 0 }),
+        commands: commands.length,
+        // One definition of "failed", shared with `1session errors`.
+        errors: errorLedger(session).length,
+        commits: collectCommits(session.turns),
+        branches: provider.branches,
+        models: provider.models,
+        ...(provider.tokens ? { tokens: provider.tokens } : {}),
+        artifacts: session.artifacts,
+        uploads: provider.uploads,
+        jobs,
+        jobCounts: jobCounts(jobs),
+        extras: provider.extras,
+    };
+}
+/** The last thing of each kind that happened — facts, not a verdict. */
+function finalState(session, summaries) {
+    const commands = commandLedger(session);
+    const reversed = [...session.turns].reverse();
+    const lastOk = [...commands].reverse().find((record) => record.exitCode === 0);
+    const lastFailed = [...commands].reverse().find((record) => (record.exitCode ?? 0) !== 0);
+    const files = fileLedger(session);
+    return {
+        lastUser: reversed.find((event) => event.kind === 'user' && event.text?.trim()),
+        lastAssistant: reversed.find((event) => event.kind === 'assistant' && event.text?.trim()),
+        lastToolCall: reversed.find((event) => event.kind === 'tool_call'),
+        lastOk,
+        lastFailed,
+        lastFile: files.at(-1),
+        unfinishedTurns: summaries.filter((turn) => turn.status !== 'completed'),
+    };
+}
+function formatCount(value) {
+    return value >= 1000 ? `${(value / 1000).toFixed(1)}k` : String(value);
+}
+function render(overview, session, summaries) {
+    const workspace = session.ref.workspace;
+    const { session: ref, stats, goal, corrections, nudges, pastes, anchors, pitfalls } = overview;
+    const files = overview.writes;
+    const final = finalState(session, summaries);
+    const byGroup = (group) => files.filter((file) => file.group === group);
+    const cmd = (record) => record
+        ? `\`exit ${record.exitCode ?? '?'}\` ${oneLine(record.command, 140)}` +
+            `　\`E${record.eventIndex} · T${record.turn}\``
+        : '（无）';
+    const lines = [
+        `# 会话事实 · ${ref.provider}:${ref.id.slice(0, 8)}`,
+        '',
+        `**${ref.title ?? '（无标题）'}**`,
+        '',
+        `会话已结束（最后事件 ${ref.updatedAt ?? '?'}）｜ ${stats.jobCounts.unknown} 个作业无完成回执` +
+            `｜ ${final.unfinishedTurns.length} 轮未正常收尾`,
+        '',
+        `- 工作区：${ref.workspace ?? '未知'}　时间：${ref.createdAt ?? '?'} → ${ref.updatedAt ?? '?'}`,
+        ...(stats.models.length ? [`- 模型：${stats.models.join(', ')}`] : []),
+        ...(stats.branches.length ? [`- 分支：${stats.branches.join(', ')}`] : []),
+        ...(anchors.hosts.length ? [`- 远程主机：${anchors.hosts.join(', ')}`] : []),
+        '',
+        '## 末态（最后发生的事实）',
+        '',
+        `- 最后一条用户请求：${oneLine(final.lastUser?.text, 150) || '（无）'}`,
+        `- 最后一条 assistant：${oneLine(final.lastAssistant?.text, 150) || '（无）'}`,
+        `- 最后一次工具调用：${final.lastToolCall?.toolName ?? '（无）'}　\`E${final.lastToolCall?.index ?? '?'}\``,
+        `- 最后一条成功命令：${cmd(final.lastOk)}`,
+        `- 最后一条失败命令：${cmd(final.lastFailed)}`,
+        `- 最后改动的文件：${final.lastFile ? `${displayPath(final.lastFile, workspace)}　\`T${final.lastFile.turn}\`` : '（无）'}`,
+        ...(final.unfinishedTurns.length
+            ? [`- 未正常收尾的轮次：${final.unfinishedTurns.map((turn) => `T${turn.no}(${turn.status})`).join('、')}`]
+            : []),
+        '',
+        '> 当前主线 / 阻塞 / 下一步属语义层，本阶段不生成。',
+        '> 每条事实后的 `E<事件号> · T<轮次>` 可直接下钻：`1session turn <id> <T> --event <E>`。',
+        '',
+        '## 统计',
+        '',
+        '| 轮次 | 事件 | 文件 | 命令 | 失败 | 提交 | 产物 | 上传 | 作业 |',
+        '| --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+        `| ${stats.turns} | ${Object.values(stats.events).reduce((a, b) => a + b, 0)} | ` +
+            `${stats.filesChanged}（${stats.fileChangeEvents} 次写） | ` +
+            `${stats.commands} | ${stats.errors} | ${stats.commits.length} | ${stats.artifacts.length} | ` +
+            `${stats.uploads.length} | ${stats.jobs.length} |`,
+        '',
+        `文件溯源：observed ${stats.filesByProvenance.observed} · derived ${stats.filesByProvenance.derived}`,
+        '',
+        `事件构成：${Object.entries(stats.events).map(([kind, n]) => `${kind} ${n}`).join(' · ')}` +
+            (stats.tokens
+                ? `　｜　token：入 ${formatCount(stats.tokens.input)} / 出 ${formatCount(stats.tokens.output)}` +
+                    (stats.tokens.cacheRead ? `（另有 ${formatCount(stats.tokens.cacheRead)} 缓存复用）` : '')
+                : ''),
+        ...(Object.keys(stats.extras).length
+            ? ['', `其他：${Object.entries(stats.extras).map(([k, n]) => `${k} ${n}`).join(' · ')}`]
+            : []),
+        '',
+        '## 目标（最初的用户请求，非当前主线）',
+        '',
+        goal || '（未能识别）',
+        '',
+    ];
+    if (corrections.length) {
+        lines.push('## 指令轨迹', '', ...corrections.map((note, i) => `- **U${i + 1}** \`${note.timestamp?.slice(11, 19) ?? ''}\` ${note.text}`), '', `（另有 ${nudges} 条纯推进指令、${pastes} 条回灌的报告，已折叠）`, '');
+    }
+    lines.push('## 资源（candidate：文本中提及，非动作证据）', '', anchors.paths.length
+        ? anchors.paths
+            .map((anchor) => {
+            const tail = anchor.lastTurn === summaries.length
+                ? 'active'
+                : `末见于 T${anchor.lastTurn}，此后未再出现`;
+            return `- ${anchor.kind === 'dir' ? '📁' : '📄'} ${anchor.path}　首见 T${anchor.firstTurn} · ${anchor.hits} 次 · ${tail}`;
+        })
+            .join('\n')
+        : '- （无）', '');
+    if (stats.jobs.length) {
+        const counts = stats.jobCounts;
+        lines.push(`## 异步作业（completed ${counts.completed} · failed ${counts.failed} · running ${counts.running} · unknown ${counts.unknown}）`, '', ...stats.jobs
+            .slice(0, 12)
+            .map((job) => `- [${job.status}] ${job.log ?? job.id}${job.pid ? ` pid ${job.pid}` : ''}` +
+            `${job.host ? ` @${job.host}` : ''}` +
+            `${job.discoveredFrom !== undefined ? `　\`E${job.discoveredFrom}\`` : ''}` +
+            `\n  ${job.evidence.join('；')}`), ...(stats.jobs.length > 12 ? [`- …另有 ${stats.jobs.length - 12} 个，用 1session jobs 查看`] : []), '');
+    }
+    if (stats.commits.length) {
+        lines.push('## Git 提交', '', ...stats.commits.map((commit) => `- ${commit.sha ? `\`${commit.sha.slice(0, 7)}\` ` : ''}${commit.message}`), '');
+    }
+    const project = byGroup('project');
+    const runtime = byGroup('runtime');
+    const logs = byGroup('log');
+    lines.push('## 关键产物', '');
+    if (stats.artifacts.length) {
+        lines.push('### 会话产物', '', ...stats.artifacts.map((artifact) => `- [${artifact.kind}] ${artifact.name}${artifact.summary ? `\n  ${oneLine(artifact.summary, 200)}` : ''}`), '');
+    }
+    lines.push('### 项目文件', '', project.length
+        ? project
+            .map((file) => `- ${displayPath(file, workspace)}　\`${file.extractor}${file.eventIndex >= 0 ? ` E${file.eventIndex}` : ''} · T${file.turn}\``)
+            .join('\n')
+        : '- （无）', '', '### 运行态文件', '', runtime.length
+        ? runtime
+            .slice(0, 15)
+            .map((file) => `- ${displayPath(file, workspace)}　\`${file.extractor}\``)
+            .join('\n') +
+            (runtime.length > 15 ? `\n- …另有 ${runtime.length - 15} 个` : '')
+        : '- （无）', '', `### 日志与临时：${logs.length} 个（1session files ${ref.id.slice(0, 8)} --group log 查看）`, '');
+    const errors = errorLedger(session);
+    if (errors.length) {
+        lines.push(`## 错误（${errors.length} 条，exit_code ≠ 0）`, '', ...errors
+            .slice(0, 12)
+            .map((record) => `- \`exit ${record.exitCode ?? '?'}\` ${oneLine(record.command, 120)}　\`E${record.eventIndex} · T${record.turn}\`` +
+            `${record.laterSucceeded ? '　→ 同前缀命令后续成功过' : ''}` +
+            `${record.stderr ? `\n  ${oneLine(record.stderr, 150)}` : ''}`), ...(errors.length > 12 ? [`- …另有 ${errors.length - 12} 条，用 1session errors 查看`] : []), '');
+    }
+    else if (pitfalls.length) {
+        lines.push('## 错误', '', ...pitfalls.slice(0, 8).map((pitfall) => `- ${pitfall}`), '');
+    }
+    return lines.join('\n');
+}
+/**
+ * Tier one of the three-level view: everything about a session that is worth
+ * knowing before deciding which turn to open.
+ */
+export function buildOverview(session) {
+    const files = fileLedger(session);
+    const userTurns = session.turns.filter((turn) => turn.kind === 'user' && turn.text?.trim());
+    const notes = userTurns.slice(1).map((turn) => ({
+        timestamp: turn.timestamp,
+        kind: classifyUserTurn(turn.text),
+        text: oneLine(turn.text, 400),
+    }));
+    const lastAssistant = [...session.turns].reverse().find((turn) => turn.kind === 'assistant' && turn.text?.trim());
+    const summaries = summarizeTurns(session);
+    const overview = {
+        session: session.ref,
+        stats: buildStats(session, files, summaries.length),
+        goal: clip(userTurns[0]?.text, 1200),
+        corrections: notes.filter((note) => note.kind === 'correction'),
+        nudges: notes.filter((note) => note.kind === 'nudge').length,
+        pastes: notes.filter((note) => note.kind === 'paste').length,
+        anchors: collectAnchors(session, summaries),
+        writes: files,
+        pitfalls: collectPitfalls(session.turns),
+        lastWord: clip(lastAssistant?.text, 800),
+    };
+    return { ...overview, markdown: render(overview, session, summaries) };
+}

package/dist/src/parsers/antigravity.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderAdapter } from './provider.js';
+export declare const antigravityAdapter: ProviderAdapter;
+/** Antigravity shortens long step output in the transcript; this is the full copy. */
+export declare function readFullStepOutput(transcriptPath: string, stepIndex: number): Promise<string | undefined>;

package/dist/src/parsers/antigravity.js

@@ -0,0 +1,297 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { readJsonl } from '../util/jsonl.js';
+import { canonicalizePath, findRepoRoot } from '../util/paths.js';
+import { clip, oneLine, stripPromptEnvelope } from '../util/text.js';
+import { emptyProviderStats, } from '../types.js';
+const BRAIN_DIR = path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
+const TRANSCRIPTS = ['transcript.jsonl', 'transcript_full.jsonl'];
+/** Args whose value is an absolute path we can use to locate the repository. */
+const PATH_ARGS = ['AbsolutePath', 'DirectoryPath', 'SearchPath', 'TargetFile', 'FilePath'];
+/** Antigravity prints the exit status and a timestamp pair into the result text. */
+const EXIT_CODE = /The command exited with code (\d+)/;
+const TIME_PAIR = /Created At:\s*(\S+)\s*\nCompleted At:\s*(\S+)/;
+const IMAGE_EXT = /\.(?:png|jpe?g|gif|webp|svg)$/i;
+const TEXT_EXT = /\.(?:md|txt|json|csv)$/i;
+function artifactKind(name) {
+    if (IMAGE_EXT.test(name))
+        return 'image';
+    return /\.md$/i.test(name) ? 'markdown' : 'other';
+}
+/** Background jobs: `tasks/task-N.log` is the output, `messages/` the receipts. */
+async function readTasks(systemDir) {
+    const tasks = new Map();
+    for (const name of await fs.readdir(path.join(systemDir, 'tasks')).catch(() => [])) {
+        const id = name.replace(/\.log$/, '');
+        tasks.set(id, { id, log: path.join(systemDir, 'tasks', name), finished: false });
+    }
+    for (const name of await fs.readdir(path.join(systemDir, 'messages')).catch(() => [])) {
+        const file = path.join(systemDir, 'messages', name);
+        const notice = await fs
+            .readFile(file, 'utf8')
+            .then((raw) => JSON.parse(raw))
+            .catch(() => undefined);
+        if (!notice?.sender)
+            continue;
+        const id = notice.sender.split('/').pop() ?? notice.sender;
+        const existing = tasks.get(id) ?? { id, finished: false };
+        const title = notice.renderDetails?.messageTitle;
+        // A notice only exists once the job has reported back.
+        tasks.set(id, { ...existing, finished: true, ...(title === undefined ? {} : { title }) });
+    }
+    return [...tasks.values()];
+}
+async function readUploads(sessionDir) {
+    const uploads = [];
+    for (const dir of ['.user_uploaded', '.tempmediaStorage']) {
+        const full = path.join(sessionDir, dir);
+        for (const name of await fs.readdir(full).catch(() => [])) {
+            if (name.startsWith('.'))
+                continue;
+            const stat = await fs.stat(path.join(full, name)).catch(() => undefined);
+            uploads.push({
+                name,
+                path: path.join(full, name),
+                ...(stat ? { sizeBytes: stat.size } : {}),
+            });
+        }
+    }
+    return uploads;
+}
+/** Antigravity double-encodes every tool argument as a JSON string. */
+function unwrapArgs(args) {
+    const out = {};
+    for (const [key, raw] of Object.entries(args ?? {})) {
+        if (typeof raw === 'string') {
+            try {
+                out[key] = JSON.parse(raw);
+                continue;
+            }
+            catch {
+                /* plain string */
+            }
+        }
+        out[key] = raw;
+    }
+    return out;
+}
+function workspaceFromCall(name, args) {
+    if (name === 'run_command' && typeof args.Cwd === 'string' && args.Cwd) {
+        return canonicalizePath(args.Cwd);
+    }
+    for (const key of PATH_ARGS) {
+        const value = args[key];
+        if (typeof value === 'string' && value) {
+            const root = findRepoRoot(value);
+            if (root)
+                return root;
+        }
+    }
+    return undefined;
+}
+async function transcriptPath(dir) {
+    for (const name of TRANSCRIPTS) {
+        const file = path.join(dir, '.system_generated', 'logs', name);
+        try {
+            await fs.access(file);
+            return file;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return undefined;
+}
+/** Every file the agent left in the session directory, not just markdown. */
+async function readArtifacts(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const artifacts = [];
+    const names = entries.filter((name) => !name.startsWith('.') && !name.endsWith('.metadata.json')).sort();
+    for (const name of names) {
+        const file = path.join(dir, name);
+        const stat = await fs.stat(file).catch(() => undefined);
+        if (!stat?.isFile())
+            continue;
+        const kind = artifactKind(name);
+        const meta = await fs
+            .readFile(`${file}.metadata.json`, 'utf8')
+            .then((raw) => JSON.parse(raw))
+            .catch(() => undefined);
+        artifacts.push({
+            name,
+            path: file,
+            kind,
+            sizeBytes: stat.size,
+            ...(meta?.summary ? { summary: meta.summary } : {}),
+            ...(meta?.updatedAt ? { updatedAt: meta.updatedAt } : {}),
+            // Binary artifacts are listed, never loaded.
+            ...(kind !== 'image' && TEXT_EXT.test(name)
+                ? { content: await fs.readFile(file, 'utf8').catch(() => undefined) }
+                : {}),
+        });
+    }
+    return artifacts;
+}
+export const antigravityAdapter = {
+    provider: 'antigravity',
+    async listCandidates() {
+        let dirs;
+        try {
+            dirs = await fs.readdir(BRAIN_DIR);
+        }
+        catch {
+            return [];
+        }
+        const found = [];
+        for (const id of dirs) {
+            if (id.startsWith('.'))
+                continue;
+            const file = await transcriptPath(path.join(BRAIN_DIR, id));
+            if (!file)
+                continue;
+            const stat = await fs.stat(file).catch(() => undefined);
+            if (!stat)
+                continue;
+            found.push({ id, path: file, mtimeMs: stat.mtimeMs, sizeBytes: stat.size });
+        }
+        return found.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    },
+    async scanRef(candidate) {
+        let title;
+        let workspace;
+        let createdAt;
+        for await (const raw of readJsonl(candidate.path, { maxLines: 400 })) {
+            const step = raw;
+            createdAt ??= step.created_at;
+            if (!title && step.type === 'USER_INPUT' && step.content) {
+                title = oneLine(stripPromptEnvelope(step.content), 120);
+            }
+            for (const call of step.tool_calls ?? []) {
+                workspace ??= workspaceFromCall(call.name, unwrapArgs(call.args));
+            }
+            if (title && workspace)
+                break;
+        }
+        return {
+            id: candidate.id,
+            provider: 'antigravity',
+            path: candidate.path,
+            title,
+            workspace,
+            createdAt,
+            updatedAt: new Date(candidate.mtimeMs).toISOString(),
+            sizeBytes: candidate.sizeBytes,
+        };
+    },
+    /**
+     * `parse` also reads the artifacts sitting next to the transcript, so the
+     * transcript's own size and mtime are not the whole identity.
+     */
+    async auxFingerprint(candidate) {
+        const dir = path.dirname(path.dirname(path.dirname(candidate.path)));
+        const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => undefined);
+        if (!entries)
+            return undefined;
+        let newest = 0;
+        let count = 0;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const stat = await fs.stat(path.join(dir, entry.name)).catch(() => undefined);
+            if (!stat)
+                continue;
+            count++;
+            newest = Math.max(newest, Math.round(stat.mtimeMs));
+        }
+        return `${count}:${newest}`;
+    },
+    async parse(candidate) {
+        const turns = [];
+        let title;
+        let workspace;
+        let createdAt;
+        const stats = emptyProviderStats();
+        const push = (turn) => {
+            turns.push({ ...turn, index: turns.length, id: `${candidate.id}#${turns.length}` });
+        };
+        for await (const raw of readJsonl(candidate.path)) {
+            const step = raw;
+            const timestamp = step.created_at;
+            createdAt ??= timestamp;
+            const sourceIndex = step.step_index;
+            const truncated = (step.truncated_fields?.length ?? 0) > 0;
+            if (step.type && !['USER_INPUT', 'PLANNER_RESPONSE', 'GENERIC'].includes(step.type)) {
+                stats.extras[step.type] = (stats.extras[step.type] ?? 0) + 1;
+            }
+            if (step.type === 'USER_INPUT' && step.content) {
+                const text = stripPromptEnvelope(step.content);
+                title ??= oneLine(text, 120);
+                push({ kind: 'user', text, timestamp, sourceIndex });
+                continue;
+            }
+            if (step.thinking)
+                push({ kind: 'thinking', text: step.thinking, timestamp, sourceIndex });
+            if (step.type === 'PLANNER_RESPONSE' && step.content) {
+                push({ kind: 'assistant', text: step.content, timestamp, sourceIndex, truncated });
+            }
+            for (const call of step.tool_calls ?? []) {
+                const args = unwrapArgs(call.args);
+                workspace ??= workspaceFromCall(call.name, args);
+                push({ kind: 'tool_call', toolName: call.name, toolArgs: args, timestamp, sourceIndex, truncated });
+            }
+            if (step.type === 'GENERIC' && step.content) {
+                const exit = EXIT_CODE.exec(step.content);
+                const times = TIME_PAIR.exec(step.content);
+                const exitCode = exit ? Number(exit[1]) : undefined;
+                const durationMs = times
+                    ? Math.max(0, Date.parse(times[2]) - Date.parse(times[1])) || undefined
+                    : undefined;
+                push({
+                    kind: 'tool_result',
+                    toolResult: step.content,
+                    // Prefer the printed exit status; fall back to wording only without one.
+                    isError: exitCode !== undefined
+                        ? exitCode !== 0
+                        : /Encountered error|Error:|command failed/i.test(step.content.slice(0, 400)),
+                    timestamp,
+                    sourceIndex,
+                    truncated,
+                    ...(exitCode !== undefined ? { exitCode } : {}),
+                    ...(durationMs !== undefined ? { durationMs } : {}),
+                });
+            }
+        }
+        const dir = path.resolve(path.dirname(candidate.path), '..', '..');
+        const systemDir = path.join(dir, '.system_generated');
+        const artifacts = await readArtifacts(dir);
+        stats.backgroundTasks = await readTasks(systemDir);
+        stats.uploads = await readUploads(dir);
+        return {
+            ref: {
+                id: candidate.id,
+                provider: 'antigravity',
+                path: candidate.path,
+                title: title ?? clip(artifacts[0]?.name, 120),
+                workspace,
+                createdAt,
+                updatedAt: turns.at(-1)?.timestamp ?? new Date(candidate.mtimeMs).toISOString(),
+                sizeBytes: candidate.sizeBytes,
+            },
+            turns,
+            artifacts,
+            stats,
+        };
+    },
+};
+/** Antigravity shortens long step output in the transcript; this is the full copy. */
+export async function readFullStepOutput(transcriptPath, stepIndex) {
+    const systemDir = path.resolve(path.dirname(transcriptPath), '..');
+    return fs.readFile(path.join(systemDir, 'steps', String(stepIndex), 'output.txt'), 'utf8').catch(() => undefined);
+}

package/dist/src/parsers/claude.d.ts

@@ -0,0 +1,2 @@
+import { type ProviderAdapter } from './provider.js';
+export declare const claudeAdapter: ProviderAdapter;