@manyoars/oars 0.2.0 → 0.4.0

package/dist/gate/replay.js

@@ -0,0 +1,254 @@
+// `oars gate replay`: the crossing checks over logs already on disk. It reads raw transcripts under the allowlist and writes one file, `crossings.jsonl`.
+// It never calls `localSalt` or the step log, both of which write, and it holds no store lock, since a replay touches nothing a deposit reads.
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { compileAllow, runAllow } from '../sessions/allow.js';
+import { makeRedactor } from '../sessions/redact.js';
+import { paths, readState, writeAtomic } from '../sessions/store.js';
+import { GATE_VERSION, liveCrossings, mergeCrossings, parseRows } from './record.js';
+import { askable } from './registry.js';
+import { withLocalBin } from './local-bin.js';
+import { ageOf, againstLatestOf, askedOf, DAY_MS } from './registry-state.js';
+import { scopesOf, seedIndex } from './novelty.js';
+import { repositoryOf } from './scope.js';
+import { discover, readCalls, readOrigins } from './transcripts.js';
+export const crossingsFile = (storeDir) => join(storeDir, 'crossings.jsonl');
+export const REGISTRY_NOT_READ = 'registry state not read';
+/** A failed install is looked at for this many calls after it. */
+const NEXT_WINDOW = 10;
+const REGISTRY_WORKERS = 4;
+/** A kept registry answer older than this many days is asked again: a `latest` goes stale, and a row would otherwise read "as of this run" forever. */
+export const REGISTRY_MAX_DAYS = 30;
+const keyOf = (crossing) => `${crossing.class}\0${crossing.name}`;
+const PACKAGE_CLASSES = new Set(['npm-package', 'python-package']);
+const nextOf = (found, read) => {
+    if (found.status === 'ok')
+        return 'proceeded';
+    if (found.status === 'none')
+        return 'no-result';
+    const end = found.call + NEXT_WINDOW;
+    const { crossing } = found;
+    const later = read.found.find((one) => one.call > found.call && one.call <= end && one.crossing.class === crossing.class && (one.crossing.name === crossing.name || PACKAGE_CLASSES.has(crossing.class)));
+    if (read.pipes.some((call) => call > found.call && call <= end && (later === undefined || call < later.call)))
+        return 'routed-around';
+    if (later === undefined)
+        return 'stopped';
+    if (later.crossing.name !== crossing.name)
+        return 'changed-name';
+    return later.crossing.program === crossing.program && later.crossing.form === crossing.form ? 'retried' : 'routed-around';
+};
+const originsOf = async (transcript, read) => {
+    const firstLines = new Map();
+    const servers = new Set();
+    for (const { crossing, line } of read.found) {
+        if (!firstLines.has(crossing.name))
+            firstLines.set(crossing.name, line);
+        if (crossing.class === 'mcp-server')
+            servers.add(crossing.name);
+    }
+    return firstLines.size === 0 ? { origins: new Map(), prompted: new Set() } : readOrigins(transcript.file, firstLines, servers);
+};
+const byTime = (one, two) => {
+    if (one.ts === two.ts)
+        return 0;
+    if (one.ts === null)
+        return 1;
+    if (two.ts === null)
+        return -1;
+    return one.ts < two.ts ? -1 : 1;
+};
+/** The widest scope in which this is the first use, read in time order so a run's result does not depend on the order folders list in. */
+const noveltyWalker = () => {
+    const fleet = new Set();
+    const repositories = new Set();
+    const sessions = new Set();
+    return (held) => {
+        const key = keyOf(held.found.crossing);
+        const inRepository = `${repositoryOf(held.transcript.project)}\0${key}`;
+        const inSession = `${held.transcript.session}\0${key}`;
+        let novelty = 'none';
+        if (!fleet.has(key))
+            novelty = 'fleet';
+        else if (!repositories.has(inRepository))
+            novelty = 'repository';
+        else if (!sessions.has(inSession))
+            novelty = 'session';
+        fleet.add(key);
+        repositories.add(inRepository);
+        sessions.add(inSession);
+        return novelty;
+    };
+};
+const lastRemovals = (removals) => {
+    const last = new Map();
+    for (const { removal, transcript } of removals) {
+        if (removal.status === 'error' || removal.status === 'refused' || removal.ts === null)
+            continue;
+        const key = `${repositoryOf(transcript.project)}\0${keyOf(removal.removal)}`;
+        if ((last.get(key) ?? '') < removal.ts)
+            last.set(key, removal.ts);
+    }
+    return last;
+};
+const asAnswer = (row) => ({ state: row.state, latest: row.latest, created: row.created });
+const isFolder = (path) => stat(path).then((found) => found.isDirectory(), () => false);
+/** A command, its environment, or an earlier `cd` chose that call's registry or config: the gate cannot read it from here, so the name is not asked, kept answers included. */
+const unaskedKeys = (rows) => new Set(rows.filter(({ found }) => !found.crossing.registryAsked).map(({ found }) => keyOf(found.crossing)));
+/** One question per name, from the first call whose folder still exists: the manager reads its registry from there, and a guess at another folder could ask the wrong one. */
+const askRegistry = async (rows, reader, cached) => {
+    const unasked = unaskedKeys(rows);
+    const answers = new Map([...cached].filter(([key]) => !unasked.has(key)).map(([key, row]) => [key, asAnswer(row)]));
+    const folders = new Map();
+    const asks = new Map();
+    for (const { found } of rows) {
+        const { crossing, cwd } = found;
+        const key = keyOf(crossing);
+        if (cwd === null || unasked.has(key) || answers.has(key) || asks.has(key) || crossing.versionForm === 'url' || !askedOf(crossing) || !askable(crossing.class, crossing.name))
+            continue;
+        const exists = folders.get(cwd) ?? (await isFolder(cwd));
+        folders.set(cwd, exists);
+        if (exists)
+            asks.set(key, { class: crossing.class, name: crossing.name, cwd });
+    }
+    const queue = [...asks];
+    const worker = async () => {
+        for (let item = queue.shift(); item !== undefined; item = queue.shift()) {
+            const [key, ask] = item;
+            answers.set(key, await reader(ask).catch(() => ({ state: 'unreachable', latest: null, created: null })));
+        }
+    };
+    await Promise.all(Array.from({ length: REGISTRY_WORKERS }, worker));
+    return answers;
+};
+const recordOf = (held, novelty, removedAt, answers) => {
+    const { found, transcript, origin, prompted, next } = held;
+    const { crossing, ts, side } = found;
+    // An answer reaches a row only when that row's own program was asked and its command left the registry to the default: the same name can cross twice.
+    const answer = askedOf(crossing) ? answers?.get(keyOf(crossing)) : undefined;
+    return {
+        kind: 'crossing',
+        v: GATE_VERSION,
+        via: 'replay',
+        day: ts === null ? null : ts.slice(0, 10),
+        class: crossing.class,
+        form: crossing.form,
+        program: crossing.program,
+        versionForm: crossing.versionForm,
+        statusReports: crossing.statusReports,
+        origin,
+        novelty,
+        // The operator named it only on the main line: a subagent's prompt is another model's words.
+        decidedBy: prompted && !side ? 'operator' : 'agent',
+        permission: found.permission,
+        status: found.status,
+        next,
+        removedLater: removedAt !== undefined && ts !== null && ts < removedAt,
+        depth: side ? 'subagent' : 'main',
+        miss: found.miss,
+        againstLatest: answer === undefined ? 'not-read' : againstLatestOf(crossing, answer),
+        registryState: answer?.state ?? 'not-read',
+        registryAge: answer === undefined ? 'not-read' : ageOf(answer, ts),
+        arm: 'none',
+        lineShown: 'none',
+        lineHeld: 'none',
+        session: transcript.session,
+        agent: transcript.agent,
+        toolUseId: found.toolUseId,
+        ts,
+        name: crossing.name,
+        version: crossing.version,
+    };
+};
+const cachedAnswers = async (file, now) => {
+    const text = await readFile(file, 'utf8').catch(() => '');
+    return new Map(parseRows(text)
+        .filter((row) => row.kind === 'registry' && (now - Date.parse(row.day)) / DAY_MS <= REGISTRY_MAX_DAYS)
+        .map((row) => [keyOf(row), row]));
+};
+const registryRows = (answers, rows, cached, day) => {
+    const added = new Map();
+    const unasked = unaskedKeys(rows);
+    for (const { found } of rows) {
+        const key = keyOf(found.crossing);
+        const answer = answers.get(key);
+        // An unreachable registry says nothing about the name, so a later run asks again.
+        if (cached.has(key) || added.has(key) || answer === undefined || answer.state === 'unreachable')
+            continue;
+        added.set(key, { kind: 'registry', v: GATE_VERSION, day, class: found.crossing.class, state: answer.state, created: answer.created, name: found.crossing.name, latest: answer.latest });
+    }
+    return [...[...cached].filter(([key]) => !unasked.has(key)).map(([, row]) => row), ...added.values()];
+};
+const summaryText = (run, file) => [
+    `Read ${String(run.transcripts)} transcripts (${String(run.unreadable)} unreadable, ${String(run.badLines)} torn lines) and ${String(run.calls)} tool calls.`,
+    `Crossings: ${String(run.crossings)}. Written to ${file}.`,
+    run.registryRead ? 'Registry state read through the package manager, as of this run, not as of each crossing.' : REGISTRY_NOT_READ,
+    'Counts: oars gate report',
+].join('\n');
+const readAll = async (runtime, entries, domains) => {
+    const redact = makeRedactor(domains);
+    const { files, unreadable: unlisted } = await discover([runtime.projectsRoot, paths(runtime.storeDir).raw], compileAllow(entries));
+    const seen = new Map();
+    const reads = [];
+    let unreadable = unlisted;
+    for (const transcript of files) {
+        try {
+            reads.push({ transcript, read: await readCalls(transcript.file, transcript.agent, redact, seen) });
+        }
+        catch {
+            unreadable += 1;
+        }
+    }
+    // A folder's own bin is read once the whole record is in, so `nextOf` below sees the form the row will carry.
+    const memo = new Map();
+    for (const { read } of reads) {
+        for (const [at, found] of read.found.entries())
+            read.found[at] = { ...found, crossing: await withLocalBin(found.crossing, found.cwd, memo) };
+    }
+    return { reads, transcripts: files.length, unreadable };
+};
+export const replay = async (runtime, options) => {
+    const state = await readState(runtime.storeDir);
+    const entries = runAllow(state.allow, options.allow);
+    const { reads, transcripts, unreadable } = await readAll(runtime, entries, state.redactDomains);
+    const held = [];
+    for (const { transcript, read } of reads) {
+        const { origins, prompted } = await originsOf(transcript, read).catch(() => ({ origins: new Map(), prompted: new Set() }));
+        for (const found of read.found)
+            held.push({ found, transcript, origin: origins.get(found.crossing.name) ?? 'none-seen', prompted: prompted.has(found.crossing.name), next: nextOf(found, read) });
+    }
+    held.sort((one, two) => byTime(one.found, two.found));
+    const removedAt = lastRemovals(reads.flatMap(({ transcript, read }) => read.removals.map((removal) => ({ removal, transcript }))));
+    const file = crossingsFile(runtime.storeDir);
+    const cached = await cachedAnswers(file, options.now());
+    const answers = options.registry === undefined ? undefined : await askRegistry(held, options.registry, cached);
+    const novelty = noveltyWalker();
+    const records = held.map((one) => recordOf(one, novelty(one), removedAt.get(`${repositoryOf(one.transcript.project)}\0${keyOf(one.found.crossing)}`), answers));
+    const unread = {};
+    for (const { read } of reads) {
+        for (const shape of read.unread)
+            unread[shape] = (unread[shape] ?? 0) + 1;
+    }
+    const day = new Date(options.now()).toISOString().slice(0, 10);
+    const run = {
+        kind: 'run',
+        v: GATE_VERSION,
+        day,
+        transcripts,
+        unreadable,
+        badLines: reads.reduce((sum, { read }) => sum + read.badLines, 0),
+        calls: reads.reduce((sum, { read }) => sum + read.fresh, 0),
+        crossings: records.length,
+        unread,
+        registryRead: options.registry !== undefined,
+    };
+    const registry = registryRows(answers ?? new Map(), held, cached, day);
+    // The file is read again here, as late as it can be, so a row the hook appended while the transcripts were read is kept, not overwritten.
+    const live = liveCrossings(parseRows(await readFile(file, 'utf8').catch(() => '')));
+    await writeAtomic(file, `${[run, ...registry, ...mergeCrossings(records, live)].map((row) => JSON.stringify(row)).join('\n')}\n`);
+    // The hook reads novelty from a kept index, not from this file; every name a transcript showed is in it, in the scopes the hook names them in.
+    await seedIndex(runtime.storeDir, file, held.flatMap((one) => {
+        const scopes = scopesOf(keyOf(one.found.crossing), repositoryOf(one.transcript.project), one.transcript.session);
+        return [scopes.fleet, scopes.repository, scopes.session];
+    }));
+    return { run, file, text: summaryText(run, file) };
+};

package/dist/gate/report.d.ts

@@ -0,0 +1,50 @@
+import { type Row } from './record.js';
+export interface Tally {
+    value: string;
+    count: number;
+}
+export interface ClassCount {
+    class: string;
+    form: string;
+    count: number;
+    distinct: number;
+}
+export interface Report {
+    ok: true;
+    transcripts: number;
+    unreadable: number;
+    badLines: number;
+    calls: number;
+    crossings: number;
+    /** Whether a replay has run: when it has not, only the hook's rows are here and the transcript fields read `not-read`. */
+    replayed: boolean;
+    registryRead: boolean;
+    via: Tally[];
+    classes: ClassCount[];
+    origin: Tally[];
+    novelty: Tally[];
+    decidedBy: Tally[];
+    permission: Tally[];
+    status: Tally[];
+    next: Tally[];
+    miss: Tally[];
+    depth: Tally[];
+    againstLatest: Tally[];
+    registryState: Tally[];
+    registryAge: Tally[];
+    /** Whether a note that would show did (`shown`) or was held back (`held`); `none` is every row with no note to show, and every block. */
+    arm: Tally[];
+    /** The fixed id of the line a row showed. */
+    lineShown: Tally[];
+    /** The fixed id of the line a held note withheld. */
+    lineHeld: Tally[];
+    /** Which policy stood for the rows the hook wrote: no file, a file that fit, or one that did not (the defaults stood). Rows with no policy read (replay) are not counted. */
+    policy: Tally[];
+    removedLater: number;
+    unseen: Tally[];
+    limits: string[];
+}
+/** What a replay of logs on disk cannot see, said every time so a count is never read as the whole. */
+export declare const LIMITS: readonly string[];
+export declare const reportOf: (rows: readonly Row[]) => Report;
+export declare const formatReport: (report: Report) => string;

package/dist/gate/report.js

@@ -0,0 +1,89 @@
+// `oars gate report`: counts over the rows the hook and a replay wrote, each crossing once. No judgment word appears here; a count says what was seen, and `LIMITS` says what was not.
+import { AGAINST_LATEST, ARMS, LINE_IDS, CROSSING_CLASSES, CROSSING_FORMS, DEPTHS, DECIDERS, MISSES, NEXTS, NOVELTIES, ORIGINS, PERMISSIONS, REGISTRY_AGES, REGISTRY_STATES, STATUSES, VIAS, crossingsOf, } from './record.js';
+import { POLICY_SOURCES } from './policy.js';
+import { REGISTRY_NOT_READ } from './replay.js';
+/** What a replay of logs on disk cannot see, said every time so a count is never read as the whole. */
+export const LIMITS = [
+    'a command run from a script, an alias, or a Makefile target, because only the call the agent made is in the log',
+    'a change to a manifest or lockfile that a later bare install picked up',
+    'what a person saw or approved on screen; the permission mode is what the log kept',
+    'an MCP server that was started and never called',
+    'folders off the allowlist, and logs the harness has already cleaned up',
+    'a session in Codex, Cursor, Copilot, Gemini CLI, Grok Build, OpenCode, Pi, VS Code Copilot Chat, or an OpenTelemetry GenAI trace, which replay does not read (`--allow codex`, `--allow cursor`, `--allow copilot`, `--allow gemini`, `--allow grok`, `--allow opencode`, `--allow pi`, `--allow vscode-copilot`, and `--allow otel` add nothing to it): they keep sessions in their own formats, not as transcript files',
+    'pool reads, sign-in, and deposit prompts; this release reads none of them',
+];
+const tally = (vocabulary, rows, pick) => vocabulary.map((value) => ({ value, count: rows.filter((row) => pick(row) === value).length }));
+const classCounts = (rows) => CROSSING_CLASSES.flatMap((cls) => CROSSING_FORMS.flatMap((form) => {
+    const these = rows.filter((row) => row.class === cls && row.form === form);
+    return these.length === 0 ? [] : [{ class: cls, form, count: these.length, distinct: new Set(these.map((row) => row.name)).size }];
+}));
+export const reportOf = (rows) => {
+    const run = rows.find((row) => row.kind === 'run');
+    const crossings = crossingsOf(rows);
+    return {
+        ok: true,
+        transcripts: run?.transcripts ?? 0,
+        unreadable: run?.unreadable ?? 0,
+        badLines: run?.badLines ?? 0,
+        calls: run?.calls ?? 0,
+        crossings: crossings.length,
+        replayed: run !== undefined,
+        // A hook row carries the registry as it stood at its crossing, so a file with such a row has registry state to show even when no replay asked for it.
+        registryRead: (run?.registryRead ?? false) || crossings.some((row) => row.registryState !== 'not-read'),
+        via: tally(VIAS, crossings, (row) => row.via ?? 'replay'),
+        classes: classCounts(crossings),
+        origin: tally(ORIGINS, crossings, (row) => row.origin),
+        novelty: tally(NOVELTIES, crossings, (row) => row.novelty),
+        decidedBy: tally(DECIDERS, crossings, (row) => row.decidedBy),
+        permission: tally(PERMISSIONS, crossings, (row) => row.permission),
+        status: tally(STATUSES, crossings, (row) => row.status),
+        next: tally(NEXTS, crossings, (row) => row.next),
+        miss: tally(MISSES, crossings, (row) => row.miss),
+        depth: tally(DEPTHS, crossings, (row) => row.depth),
+        againstLatest: tally(AGAINST_LATEST, crossings, (row) => row.againstLatest),
+        registryState: tally(REGISTRY_STATES, crossings, (row) => row.registryState),
+        registryAge: tally(REGISTRY_AGES, crossings, (row) => row.registryAge),
+        arm: tally(ARMS, crossings, (row) => row.arm),
+        lineShown: tally(LINE_IDS, crossings, (row) => row.lineShown),
+        lineHeld: tally(LINE_IDS, crossings, (row) => row.lineHeld),
+        policy: tally(POLICY_SOURCES, crossings.filter((row) => row.policy !== undefined), (row) => row.policy ?? 'default'),
+        removedLater: crossings.filter((row) => row.removedLater === true).length,
+        unseen: Object.entries(run?.unread ?? {}).map(([value, count]) => ({ value, count })),
+        limits: [...LIMITS],
+    };
+};
+const line = (label, counts) => {
+    const shown = counts.filter((one) => one.count > 0).map((one) => `${one.value} ${String(one.count)}`);
+    return `${label}: ${shown.length === 0 ? 'none' : shown.join(', ')}`;
+};
+export const formatReport = (report) => {
+    const registry = report.registryRead
+        ? [line('Against latest', report.againstLatest), line('Registry state', report.registryState), line('Registry age', report.registryAge)]
+        : [REGISTRY_NOT_READ];
+    const books = report.replayed
+        ? [`Read ${String(report.transcripts)} transcripts (${String(report.unreadable)} unreadable, ${String(report.badLines)} torn lines) and ${String(report.calls)} tool calls.`]
+        : ['No replay has run: these rows come from the hook, and what a transcript gives reads not-read until `oars gate replay` fills it in.'];
+    return [
+        ...books,
+        `Crossings: ${String(report.crossings)}`,
+        line('Recorded by', report.via),
+        ...report.classes.map((one) => `  ${one.class} ${one.form}: ${String(one.count)} (${String(one.distinct)} distinct)`),
+        line('Name came from', report.origin),
+        line('New to', report.novelty),
+        line('Decided by', report.decidedBy),
+        line('Permission mode', report.permission),
+        line('Result', report.status),
+        line('What happened next', report.next),
+        line('Name not found', report.miss),
+        line('Line', report.depth),
+        `Removed later: ${String(report.removedLater)}`,
+        line('Notes', report.arm),
+        line('Line shown', report.lineShown),
+        line('Line held', report.lineHeld),
+        ...(report.policy.some((one) => one.count > 0) ? [line('Policy', report.policy)] : []),
+        ...registry,
+        'Replay cannot see:',
+        ...report.unseen.map((one) => `- ${String(one.count)} ${one.value} commands that state no name to record`),
+        ...report.limits.map((limit) => `- ${limit}`),
+    ].join('\n');
+};

package/dist/gate/scope.d.ts

@@ -0,0 +1,7 @@
+/** Claude Code names a worktree's folder `<repository>--claude-worktrees-<name>`, and a worktree is its repository. */
+export declare const repositoryOf: (project: string) => string;
+/**
+ * The repository a working directory is in: its nearest ancestor holding `.git` (a file in a worktree), after a worktree folder is taken off. The hook is handed
+ * where the session is now, which can be a subfolder; a few `stat` calls are all it costs.
+ */
+export declare const repositoryOfCwd: (cwd: string) => Promise<string>;

package/dist/gate/scope.js

@@ -0,0 +1,27 @@
+// The scopes a name is new in: the whole record (fleet), one repository, and one session. A repository is named by the slug Claude Code gives its project folder, with a
+// worktree counted as its repository, so a replay (which reads project folders) and a hook (which is handed a working directory) name the same repository the same way.
+import { stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { slugOf } from '../sessions/allow.js';
+/** Claude Code names a worktree's folder `<repository>--claude-worktrees-<name>`, and a worktree is its repository. */
+export const repositoryOf = (project) => project.replace(/--claude-worktrees-.*$/, '');
+const WORKTREE_FOLDER = /[\\/]\.claude[\\/]worktrees[\\/].*$/;
+const LEVELS = 12;
+const exists = (path) => stat(path).then(() => true, () => false);
+/**
+ * The repository a working directory is in: its nearest ancestor holding `.git` (a file in a worktree), after a worktree folder is taken off. The hook is handed
+ * where the session is now, which can be a subfolder; a few `stat` calls are all it costs.
+ */
+export const repositoryOfCwd = async (cwd) => {
+    const base = cwd.replace(WORKTREE_FOLDER, '');
+    let folder = base;
+    for (let level = 0; level < LEVELS; level += 1) {
+        if (await exists(join(folder, '.git')))
+            return repositoryOf(slugOf(folder));
+        const parent = dirname(folder);
+        if (parent === folder)
+            break;
+        folder = parent;
+    }
+    return repositoryOf(slugOf(base));
+};

package/dist/gate/transcripts.d.ts

@@ -0,0 +1,68 @@
+import type { Allow } from '../sessions/allow.js';
+import type { Redactor } from '../sessions/redact.js';
+import { type Crossing, type Removal, type UnreadShape } from './checks.js';
+import { type Miss, type Origin, type Permission, type Status } from './record.js';
+export interface TranscriptFile {
+    file: string;
+    project: string;
+    /** The main session: a subagent's is its parent's. */
+    session: string;
+    /** The subagent transcript's own name; null on a main transcript. */
+    agent: string | null;
+}
+/** One copy per project and relative path. `raw/` hard-links the same file, and the harness's copy, when it still has one, is at least as long. */
+export declare const discover: (roots: readonly string[], allow: Allow) => Promise<{
+    files: TranscriptFile[];
+    unreadable: number;
+}>;
+export interface Found {
+    crossing: Crossing;
+    ts: string | null;
+    /** In memory only: where a registry option would ask. Never written. */
+    cwd: string | null;
+    toolUseId: string | null;
+    permission: Permission;
+    /** The call's position in its transcript, and the line it sits on. */
+    call: number;
+    line: number;
+    side: boolean;
+    status: Status;
+    miss: Miss;
+}
+export interface FoundRemoval {
+    removal: Removal;
+    ts: string | null;
+    status: Status;
+}
+/** A call's answer can sit in another file when a resumed transcript holds it, so the entries are shared across a run. */
+interface CallEntry {
+    found: Found[];
+    removals: FoundRemoval[];
+}
+export type CallsSeen = Map<string, CallEntry>;
+export interface TranscriptRead {
+    found: Found[];
+    removals: FoundRemoval[];
+    unread: UnreadShape[];
+    /** The positions of the calls that pipe a download into a shell: a way around a stopped install. */
+    pipes: number[];
+    /** Every tool call line in this transcript, a replay of a resumed transcript's included: the position `Found.call` and `pipes` count in. */
+    calls: number;
+    /** The calls this transcript added to the run: those a transcript read earlier had not already shown. The run row's `calls`. */
+    fresh: number;
+    badLines: number;
+}
+/** The first pass: every call and its answer. Text is read only to settle a status; nothing of it leaves this function. */
+export declare const readCalls: (file: string, agent: string | null, redact: Redactor, seen: CallsSeen) => Promise<TranscriptRead>;
+/**
+ * The second pass, only for a transcript with a crossing, so the text of the rest is not read twice. A name's origin is what first showed it before
+ * its first crossing in this transcript, because after that the crossing's own output names it. Nothing shown, and it is `none-seen`, which says the
+ * transcript shows no source; the agent's own words do not count, since they are the thing being asked about.
+ */
+export interface Origins {
+    origins: Map<string, Origin>;
+    /** Names a main-line or subagent prompt showed before their first crossing, whatever showed them first: the operator typing a name is a decision whoever saw it first. */
+    prompted: Set<string>;
+}
+export declare const readOrigins: (file: string, firstLines: ReadonlyMap<string, number>, servers: ReadonlySet<string>) => Promise<Origins>;
+export {};