@1agents/session-reader 0.1.1

package/dist/bin/1session.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { aggregateWorkspaceSessions } from '../src/aggregator.js';
+import { distillSession } from '../src/distiller.js';
+import { buildOverview } from '../src/overview.js';
+import { eventDetail, summarizeTurns, turnDetail } from '../src/turns.js';
+import { commandLedger, displayPath, errorLedger, fileLedger, jobLedger } from '../src/ledger.js';
+import { listRecentSessions, loadSession } from '../src/resolver.js';
+import { searchSessions } from '../src/search.js';
+import { canonicalizePath } from '../src/util/paths.js';
+import { oneLine } from '../src/util/text.js';
+const USAGE = `1session — cross-agent session Read Plane
+
+  1session list [--limit <n>] [--workspace <path>] [--provider <name>] [--since 24h] [--json]
+  1session overview <session-id> [--json]              第 1 层：会话概要
+  1session turns <session-id> [--json]                 第 2 层：逐轮概要
+  1session turn <session-id> <n> [--event <k>] [--json] 第 3 层：单轮 / 单次工具调用明细
+  1session jobs <session-id> [--json]                  异步作业账本
+  1session commands <session-id> [--failed] [--host h] [--turn n] [--json]
+  1session files <session-id> [--group project|runtime|log|all] [--json]
+  1session errors <session-id> [--json]
+  1session digest <session-id> [--focus marketing|review|full] [--json]
+  1session workspace [path] [--since 24h] [--limit <n>] [--digest] [--focus <f>] [--json]
+  1session index [<session-id>] [--all] [--force] [--since 30d]  建立/刷新索引
+  1session graph <session-id> [--json]                 会话之间的引用关系
+  1session search <query> [--workspace path] [--since 24h] [--limit n] [--provider name]
+                          [--kind user,assistant,thinking,tool_call,tool_result]
+                          [--regex] [--case] [--context n] [--max-hits n] [--json]
+
+全局：--no-index 绕过索引直读源文件。索引位于 ~/.1agents/session-reader/index.db
+
+Providers: antigravity (~/.gemini/antigravity/brain), claude (~/.claude/projects), codex (~/.codex/sessions).
+`;
+/** Flags that never take a value, so they cannot swallow a positional. */
+const BOOLEAN_FLAGS = new Set([
+    'json', 'failed', 'digest', 'regex', 'case', 'all', 'force', 'no-index',
+]);
+function parseArgs(argv) {
+    const [command = 'help', ...rest] = argv;
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        const token = rest[i];
+        if (token === '-n') {
+            flags.n = rest[++i] ?? '';
+        }
+        else if (token.startsWith('--')) {
+            const name = token.slice(2);
+            const next = rest[i + 1];
+            if (!BOOLEAN_FLAGS.has(name) && next && !next.startsWith('--')) {
+                flags[name] = next;
+                i++;
+            }
+            else {
+                flags[name] = true;
+            }
+        }
+        else {
+            positional.push(token);
+        }
+    }
+    return { command, positional, flags };
+}
+const TURN_MARK = {
+    completed: '✓',
+    unfinished: '⚠',
+    nudged: '↻',
+    interrupted: '✂',
+    no_response: '⊘',
+    failed_tail: '✗',
+};
+const str = (value) => typeof value === 'string' ? value : undefined;
+const num = (value) => {
+    const text = typeof value === 'string' ? value : undefined;
+    if (text === undefined)
+        return undefined;
+    const parsed = Number(text);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const kindsOf = (value) => str(value)
+    ?.split(',')
+    .map((kind) => kind.trim())
+    .filter(Boolean);
+const focusOf = (value) => {
+    const focus = str(value);
+    return focus === 'marketing' || focus === 'full' ? focus : 'review';
+};
+function print(json, data, text) {
+    console.log(json ? JSON.stringify(data, null, 2) : text);
+}
+let useIndex = true;
+async function load(sessionId) {
+    if (!sessionId)
+        throw new Error('missing <session-id>');
+    return loadSession(sessionId, { useIndex });
+}
+/**
+ * Records "this session read that one" while it is happening, when the caller
+ * identity was injected. Costs nothing and is silently skipped otherwise.
+ */
+async function noteRead(verb, target) {
+    if (!useIndex || !target || !process.env.SESSION_READER_CALLER_SESSION)
+        return;
+    const { openStore } = await import('../src/store/db.js');
+    const { captureRuntimeEdge } = await import('../src/store/edges.js');
+    captureRuntimeEdge(await openStore(), verb, target);
+}
+async function main() {
+    const { command, positional, flags } = parseArgs(process.argv.slice(2));
+    const json = flags.json === true;
+    useIndex = flags['no-index'] !== true;
+    await noteRead(command, positional[0]);
+    switch (command) {
+        case 'list': {
+            const refs = await listRecentSessions({
+                limit: num(flags.limit) ?? 20,
+                workspace: str(flags.workspace),
+                since: str(flags.since),
+                provider: str(flags.provider),
+            });
+            print(json, refs, refs
+                .map((ref) => `${ref.provider.padEnd(11)} ${ref.id.slice(0, 8)}  ${ref.updatedAt ?? '?'}  ` +
+                `${ref.workspace ? path.basename(ref.workspace) : '-'}  ${oneLine(ref.title, 70)}`)
+                .join('\n') || '(no sessions found)');
+            break;
+        }
+        case 'overview': {
+            const session = await load(positional[0]);
+            const overview = buildOverview(session);
+            print(json, overview, overview.markdown);
+            break;
+        }
+        case 'jobs': {
+            const session = await load(positional[0]);
+            const jobs = jobLedger(session);
+            print(json, jobs, jobs.length
+                ? jobs
+                    .map((job) => `[${job.status}] ${job.log ?? job.id}${job.pid ? ` pid ${job.pid}` : ''}` +
+                    `${job.host ? ` @${job.host}` : ''}` +
+                    `${job.startedAt ? `  ${job.startedAt.slice(0, 19)}` : ''}` +
+                    `  [${job.provenance} · ${job.extractor}]` +
+                    `\n    ${job.evidence.join('；')}` +
+                    `${job.command ? `\n    ${oneLine(job.command, 150)}` : ''}`)
+                    .join('\n')
+                : '（该会话没有发现后台作业）');
+            break;
+        }
+        case 'commands': {
+            const session = await load(positional[0]);
+            const host = str(flags.host);
+            const turn = num(flags.turn);
+            const records = commandLedger(session).filter((record) => (flags.failed !== true || (record.exitCode ?? 0) !== 0) &&
+                (host === undefined || record.host === host) &&
+                (turn === undefined || record.turn === turn));
+            print(json, records, [
+                `${records.length} 条命令（来源：${[...new Set(records.map((r) => `${r.provenance}/${r.extractor}`))].join('  ') || '-'}）`,
+                '',
+                ...records.map((record) => `T${String(record.turn).padStart(2, ' ')} #${String(record.eventIndex).padStart(4, ' ')} ` +
+                    `exit ${String(record.exitCode ?? '?').padStart(3, ' ')}` +
+                    `${record.durationMs ? ` ${(record.durationMs / 1000).toFixed(1)}s` : ''}` +
+                    `${record.host ? ` @${record.host}` : ''}  ${oneLine(record.command, 130)}`),
+            ].join('\n'));
+            break;
+        }
+        case 'files': {
+            const session = await load(positional[0]);
+            const wanted = str(flags.group);
+            const records = fileLedger(session).filter((record) => 
+            // `all` means all; only the default view hides logs.
+            wanted === 'all' ? true : wanted === undefined ? record.group !== 'log' : record.group === wanted);
+            print(json, records, [
+                `${records.length} 个文件${wanted ? `（group=${wanted}）` : '（默认不含 log，用 --group all 看全部）'}`,
+                '',
+                ...records.map((record) => `[${record.group}] ${record.provenance.padEnd(9)} T${record.turn} ` +
+                    `${displayPath(record, session.ref.workspace)}　\`${record.extractor}${record.eventIndex >= 0 ? ` E${record.eventIndex}` : ''}\``),
+            ].join('\n'));
+            break;
+        }
+        case 'errors': {
+            const session = await load(positional[0]);
+            const records = errorLedger(session);
+            print(json, records, [
+                `${records.length} 条失败命令`,
+                '',
+                ...records.map((record) => `T${record.turn} #${record.eventIndex} exit ${record.exitCode ?? '?'}` +
+                    `${record.laterSucceeded ? '  → 同前缀命令后续成功过' : ''}` +
+                    `\n    ${oneLine(record.command, 150)}` +
+                    `${record.stderr ? `\n    ${oneLine(record.stderr, 150)}` : ''}`),
+            ].join('\n'));
+            break;
+        }
+        case 'digest': {
+            const session = await load(positional[0]);
+            const digest = distillSession(session, { focus: focusOf(flags.focus) });
+            print(json, digest, digest.markdown);
+            break;
+        }
+        case 'workspace': {
+            const target = canonicalizePath(positional[0] ?? '.');
+            if (flags.digest === true || flags.focus) {
+                const digest = await aggregateWorkspaceSessions(target, {
+                    since: str(flags.since),
+                    limit: num(flags.limit),
+                    focus: focusOf(flags.focus),
+                });
+                print(json, digest, digest.markdown);
+                break;
+            }
+            const refs = await listRecentSessions({
+                workspace: target,
+                since: str(flags.since),
+                limit: num(flags.limit) ?? 50,
+            });
+            print(json, { workspace: target, sessions: refs }, [
+                `workspace ${target}`,
+                `sessions  ${refs.length} across ${new Set(refs.map((r) => r.provider)).size} agents`,
+                '',
+                ...refs.map((ref) => `${ref.provider.padEnd(11)} ${ref.id.slice(0, 8)}  ${ref.updatedAt ?? '?'}  ${oneLine(ref.title, 70)}`),
+            ].join('\n'));
+            break;
+        }
+        case 'turns': {
+            const session = await load(positional[0]);
+            const summaries = summarizeTurns(session);
+            print(json, summaries, [
+                `${summaries.length} 轮 · 共 ${session.turns.length} 个事件`,
+                '',
+                ...summaries.flatMap((turn) => [
+                    `${TURN_MARK[turn.status] ?? '·'} T${String(turn.no).padStart(2, ' ')} ${turn.startedAt?.slice(0, 19) ?? '?'}` +
+                        `${turn.durationMs ? ` (${Math.round(turn.durationMs / 1000)}s)` : ''}` +
+                        `  事件 ${turn.events[0]}–${turn.events[1]}` +
+                        `  文件 ${turn.files.length} · 命令 ${turn.commands} · 失败 ${turn.errors}` +
+                        `${turn.status === 'completed' ? '' : `  [${turn.status}${turn.nudgeCount > 1 ? ` ×${turn.nudgeCount}` : ''}]`}`,
+                    ...(turn.evidence.length ? [`    ! ${turn.evidence.join('；')}`] : []),
+                    `    ▸ ${turn.prompt}`,
+                    ...(turn.outcome ? [`    ◂ ${turn.outcome}`] : []),
+                ]),
+            ].join('\n'));
+            break;
+        }
+        case 'turn': {
+            const session = await load(positional[0]);
+            const eventIndex = num(flags.event);
+            if (eventIndex !== undefined) {
+                const detail = await eventDetail(session, eventIndex);
+                const body = detail.fullText ?? detail.text ?? detail.toolResult ?? '';
+                print(json, detail, [
+                    `#${detail.index} ${detail.kind}${detail.toolName ? `(${detail.toolName})` : ''} ${detail.timestamp ?? ''}` +
+                        `${detail.truncated ? (detail.fullText ? '  [已从 steps/ 补全]' : '  [已截断]') : ''}`,
+                    ...(detail.toolArgs ? ['', '参数：', JSON.stringify(detail.toolArgs, null, 2)] : []),
+                    ...(body ? ['', '内容：', body] : []),
+                    ...(detail.truncationNote ? ['', `⚠️ ${detail.truncationNote}`] : []),
+                ].join('\n'));
+                break;
+            }
+            const detail = turnDetail(session, num(positional[1]) ?? 1);
+            print(json, detail, [
+                `T${detail.summary.no}  ${detail.summary.startedAt ?? '?'} → ${detail.summary.endedAt ?? '?'}` +
+                    `  事件 ${detail.summary.events[0]}–${detail.summary.events[1]}`,
+                `▸ ${detail.summary.prompt}`,
+                ...(detail.summary.files.length ? ['', `改动：${detail.summary.files.join(', ')}`] : []),
+                '',
+                ...detail.events.map((event) => {
+                    const head = `#${event.index} ${event.kind}${event.toolName ? `(${event.toolName})` : ''}` +
+                        `${event.truncated ? ' [截断]' : ''}${event.isError ? ' ✗' : ''}`;
+                    return `${head}  ${oneLine(event.text ?? event.toolResult ?? JSON.stringify(event.toolArgs), 160)}`;
+                }),
+                '',
+                `（用 --event <k> 展开单个事件的完整内容）`,
+            ].join('\n'));
+            break;
+        }
+        case 'search': {
+            const query = positional.join(' ');
+            const hits = await searchSessions(query, {
+                workspace: str(flags.workspace),
+                since: str(flags.since),
+                limit: num(flags.limit),
+                provider: str(flags.provider),
+                kinds: kindsOf(flags.kind),
+                regex: flags.regex === true,
+                caseSensitive: flags.case === true,
+                context: num(flags.context),
+                maxPerSession: num(flags['max-hits']),
+                useIndex,
+            });
+            const total = hits.reduce((sum, hit) => sum + hit.totalMatches, 0);
+            print(json, hits, hits.length
+                ? [
+                    `${total} 处命中，分布在 ${hits.length} 个会话`,
+                    ...hits.flatMap((hit) => [
+                        '',
+                        `### ${hit.session.provider} ${hit.session.id.slice(0, 8)}  ` +
+                            `${hit.session.createdAt ?? '?'} → ${hit.session.updatedAt ?? '?'}  (${hit.totalMatches} 命中)`,
+                        `    ${oneLine(hit.session.title, 80)}`,
+                        ...hit.matches.map((match) => `  #${match.index} ${match.kind}${match.toolName ? `(${match.toolName})` : ''}  ${match.excerpt}`),
+                        ...(hit.totalMatches > hit.matches.length
+                            ? [`  …另有 ${hit.totalMatches - hit.matches.length} 处（--max-hits 调大或 --json 查看全部）`]
+                            : []),
+                    ]),
+                ].join('\n')
+                : `无命中：${query}`);
+            break;
+        }
+        case 'index': {
+            const { openStore } = await import('../src/store/db.js');
+            const { indexSession } = await import('../src/store/indexer.js');
+            const { deriveEdges } = await import('../src/store/edges.js');
+            const { readSession, sessionRow } = await import('../src/store/read.js');
+            const { listResolvedSessions } = await import('../src/resolver.js');
+            const db = await openStore();
+            const force = flags.force === true;
+            if (flags.all !== true) {
+                const target = positional[0];
+                if (!target)
+                    throw new Error('missing <session-id> (or pass --all)');
+                const { resolveSession } = await import('../src/resolver.js');
+                const handle = await resolveSession(target);
+                if (!handle)
+                    throw new Error(`session not found: ${target}`);
+                const result = await indexSession(db, handle, { force });
+                print(json, result, `${result.id}  ${result.action}  ${result.session.turns.length} 个事件`);
+                break;
+            }
+            // Backfill indexes L1+L2 first and derives edges in a second pass, so a
+            // reference to a session that had not been indexed yet still lands.
+            const started = Date.now();
+            const handles = await listResolvedSessions({
+                limit: num(flags.limit) ?? Number.POSITIVE_INFINITY,
+                scan: num(flags.scan) ?? Number.POSITIVE_INFINITY,
+                ...(str(flags.since) ? { since: str(flags.since) } : {}),
+                ...(str(flags.provider) ? { provider: str(flags.provider) } : {}),
+            });
+            const counts = {};
+            for (const handle of handles) {
+                const result = await indexSession(db, handle, { force, edges: false });
+                counts[result.action] = (counts[result.action] ?? 0) + 1;
+            }
+            let edges = 0;
+            for (const handle of handles) {
+                const id = `${handle.adapter.provider}:${handle.candidate.id}`;
+                const row = sessionRow(db, id);
+                if (row)
+                    edges += deriveEdges(db, id, readSession(db, row));
+            }
+            const summary = {
+                sessions: handles.length,
+                actions: counts,
+                edges,
+                seconds: Number(((Date.now() - started) / 1000).toFixed(1)),
+            };
+            print(json, summary, `已索引 ${summary.sessions} 个会话，耗时 ${summary.seconds}s\n` +
+                Object.entries(counts)
+                    .map(([action, n]) => `  ${action.padEnd(16)} ${n}`)
+                    .join('\n') +
+                `\n  边证据             ${edges}`);
+            break;
+        }
+        case 'graph':
+        case 'related': {
+            // An inbound edge is the same fact read from the other end.
+            const INVERSE = {
+                references: 'referenced_by',
+                handoff_from: 'handed_off_to',
+                forked_from: 'forked_into',
+                resumed_from: 'resumed_into',
+                sends_to: 'sent_from',
+            };
+            const { openStore } = await import('../src/store/db.js');
+            const { edgeEvidence, edgesOf } = await import('../src/store/edges.js');
+            const { findSessionRow } = await import('../src/store/read.js');
+            const target = positional[0];
+            if (!target)
+                throw new Error('missing <session-id>');
+            await load(target); // make sure it is indexed before we look it up
+            const db = await openStore();
+            const row = findSessionRow(db, target);
+            if (!row)
+                throw new Error(`session not found: ${target}`);
+            const edges = edgesOf(db, row.id).map((edge) => ({
+                ...edge,
+                evidence: edgeEvidence(db, edge.from, edge.to, edge.relation),
+            }));
+            print(json, { session: row.id, edges }, edges.length
+                ? [
+                    `${row.id}　${oneLine(row.title ?? '', 60)}`,
+                    '',
+                    ...edges.map((edge) => edge.direction === 'out'
+                        ? `  → ${edge.relation.padEnd(13)} ${edge.to}　证据 ${edge.evidenceCount} 次` +
+                            `（${edge.evidence.map((item) => item.operation).join(' ')}）`
+                        : `  ← ${(INVERSE[edge.relation] ?? edge.relation).padEnd(13)} ${edge.from}　证据 ${edge.evidenceCount} 次` +
+                            `（${edge.evidence.map((item) => item.operation).join(' ')}）`),
+                    '',
+                    '> → 本会话查过对方；← 对方查过本会话。证据可下钻：1session turn <会话> <轮次>',
+                ].join('\n')
+                : `${row.id} 尚无关系边（没有任何会话通过 1session 查过它，它也没查过别人）`);
+            break;
+        }
+        default:
+            console.log(USAGE);
+            if (command !== 'help' && command !== '--help')
+                process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    console.error(`1session: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+});

package/dist/src/aggregator.d.ts

@@ -0,0 +1,12 @@
+import type { DigestFocus, WorkspaceDigest } from './types.js';
+export interface AggregateOptions {
+    since?: string | Date;
+    /** Maximum number of sessions to open and interleave. */
+    limit?: number;
+    focus?: DigestFocus;
+}
+/**
+ * Pulls every session that ran in `workspacePath` — regardless of which agent
+ * produced it — and interleaves them into a single project storyline.
+ */
+export declare function aggregateWorkspaceSessions(workspacePath: string, options?: AggregateOptions): Promise<WorkspaceDigest>;

package/dist/src/aggregator.js

@@ -0,0 +1,136 @@
+import path from 'node:path';
+import { shellCommand } from './distiller.js';
+import { fileWrites, resolveWritePath } from './writes.js';
+import { findResolvedByWorkspace, parseSince } from './resolver.js';
+import { canonicalizePath, isInside } from './util/paths.js';
+import { oneLine } from './util/text.js';
+const TIMELINE_CAP = 80;
+function relativize(file, workspace) {
+    return isInside(workspace, file) ? path.relative(workspace, file) || '.' : file;
+}
+/** Keeps the events that tell the story: requests, edits, failures, conclusions. */
+function significantEvents(session) {
+    const { provider, id } = session.ref;
+    const entries = [];
+    const lastAssistant = [...session.turns].reverse().find((t) => t.kind === 'assistant' && t.text?.trim());
+    for (const turn of session.turns) {
+        const base = { timestamp: turn.timestamp, provider, sessionId: id, kind: turn.kind };
+        if (turn.kind === 'user' && turn.text?.trim()) {
+            entries.push({ ...base, summary: `提出：${oneLine(turn.text, 180)}` });
+            continue;
+        }
+        const writes = fileWrites(turn);
+        if (writes.length) {
+            entries.push({
+                ...base,
+                summary: `${turn.toolName} → ${writes.map((w) => path.basename(w.path)).join(', ')}`,
+            });
+            continue;
+        }
+        if (turn.kind === 'tool_result' && turn.isError) {
+            entries.push({ ...base, summary: `失败：${oneLine(turn.toolResult, 140)}` });
+            continue;
+        }
+        if (turn === lastAssistant) {
+            entries.push({ ...base, summary: `收束：${oneLine(turn.text, 180)}` });
+        }
+    }
+    return entries;
+}
+function renderMarkdown(digest, focus, stats) {
+    const { workspace, sessions, collaboratingAgents, unifiedTimeline, fileAttribution } = digest;
+    const lines = [
+        `# ${path.basename(workspace)} · 跨智能体协作纪实`,
+        '',
+        `- 工作区：\`${workspace}\``,
+        `- 参与智能体：${collaboratingAgents.join(' / ') || '无'}`,
+        `- 会话：${sessions.length} 个，统一时间线 ${unifiedTimeline.length} 个节点，涉及 ${Object.keys(fileAttribution).length} 个文件`,
+        '',
+        '## 会话清单',
+        '',
+    ];
+    for (const ref of sessions) {
+        const stat = stats.get(ref.id);
+        lines.push(`- \`${ref.provider}\` ${ref.id.slice(0, 8)} · ${ref.createdAt ?? '?'} → ${ref.updatedAt ?? '?'}` +
+            (stat ? ` · ${stat.turns} 轮 / ${stat.files} 文件 / ${stat.commands} 命令` : '') +
+            `\n  ${ref.title ?? '（无标题）'}`);
+    }
+    lines.push('', '## 统一时间线', '');
+    const timeline = unifiedTimeline.slice(0, TIMELINE_CAP);
+    for (const entry of timeline) {
+        lines.push(`- \`${entry.timestamp ?? '?'}\` **${entry.provider}** ${entry.summary}`);
+    }
+    if (unifiedTimeline.length > timeline.length) {
+        lines.push(`- …另有 ${unifiedTimeline.length - timeline.length} 个节点`);
+    }
+    if (focus !== 'marketing') {
+        lines.push('', '## 文件归属（谁动了什么）', '');
+        const files = Object.entries(fileAttribution).sort((a, b) => b[1].length - a[1].length);
+        for (const [file, touches] of files.slice(0, 40)) {
+            const chain = [...new Set(touches.map((t) => t.provider))].join(' → ');
+            const inferred = touches.every((t) => t.provenance === 'derived') ? ' ~推断' : '';
+            lines.push(`- \`${file}\` — ${chain}（${touches.length} 次改动${inferred}）`);
+        }
+        if (!files.length)
+            lines.push('- （无文件改动记录）');
+        if (files.length > 40)
+            lines.push(`- …另有 ${files.length - 40} 个文件`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Pulls every session that ran in `workspacePath` — regardless of which agent
+ * produced it — and interleaves them into a single project storyline.
+ */
+export async function aggregateWorkspaceSessions(workspacePath, options = {}) {
+    const workspace = canonicalizePath(workspacePath);
+    const limit = options.limit ?? 10;
+    const focus = options.focus ?? 'review';
+    const resolved = await findResolvedByWorkspace(workspace, { since: options.since, limit });
+    // File mtimes only bound the search; the parsed timestamps decide what is in range.
+    const sinceMs = parseSince(options.since);
+    const sessions = [];
+    const timeline = [];
+    const fileAttribution = {};
+    const stats = new Map();
+    for (const handle of resolved) {
+        const session = await handle.adapter.parse(handle.candidate).catch(() => undefined);
+        if (!session)
+            continue;
+        if (sinceMs && Date.parse(session.ref.updatedAt ?? '') < sinceMs)
+            continue;
+        sessions.push(session.ref);
+        timeline.push(...significantEvents(session));
+        let commands = 0;
+        let files = 0;
+        for (const turn of session.turns) {
+            if (shellCommand(turn))
+                commands++;
+            for (const write of fileWrites(turn)) {
+                files++;
+                const key = relativize(resolveWritePath(write, session.ref.workspace), workspace);
+                (fileAttribution[key] ??= []).push({
+                    provider: session.ref.provider,
+                    sessionId: session.ref.id,
+                    timestamp: turn.timestamp,
+                    toolName: turn.toolName,
+                    provenance: write.provenance,
+                    ...(write.host ? { host: write.host } : {}),
+                });
+            }
+        }
+        stats.set(session.ref.id, { turns: session.turns.length, commands, files });
+    }
+    timeline.sort((a, b) => Date.parse(a.timestamp ?? '') - Date.parse(b.timestamp ?? ''));
+    sessions.sort((a, b) => Date.parse(a.createdAt ?? '') - Date.parse(b.createdAt ?? ''));
+    const collaboratingAgents = [...new Set(sessions.map((s) => s.provider))];
+    const digest = {
+        workspace,
+        sessions,
+        collaboratingAgents,
+        unifiedTimeline: timeline,
+        fileAttribution,
+    };
+    return { ...digest, markdown: renderMarkdown(digest, focus, stats) };
+}

package/dist/src/classify.d.ts

@@ -0,0 +1,2 @@
+import type { UserTurnKind } from './types.js';
+export declare function classifyUserTurn(text: string): UserTurnKind;

package/dist/src/classify.js

@@ -0,0 +1,11 @@
+/** Pure "keep going" replies carry no instruction worth handing on. */
+const NUDGE = /^(?:继续|再继续|contin|continue|go on|好的?|ok|okay|嗯+|再来|下一步|next|yes|是的|可以)[。.!！~]*$/i;
+export function classifyUserTurn(text) {
+    const value = text.trim();
+    if (NUDGE.test(value))
+        return 'nudge';
+    // Long markdown reports are the user pasting an agent's own output back in.
+    if (value.length > 300 && (/(^|\n)#{1,4}\s/.test(value) || /🎉|阶段性|全面完成/.test(value)))
+        return 'paste';
+    return 'correction';
+}

package/dist/src/distiller.d.ts

@@ -0,0 +1,7 @@
+import type { DigestFocus, NormalizedSession, SessionDigest, TurnEvent } from './types.js';
+/** Paths a tool call wrote to, including files written through the shell. */
+export declare function editedFiles(turn: TurnEvent, workspace?: string): string[];
+export declare function shellCommand(turn: TurnEvent): string | undefined;
+export declare function distillSession(session: NormalizedSession, options?: {
+    focus?: DigestFocus;
+}): SessionDigest;