toolroll 0.9.104 → 0.9.105

package/dist/evidence-pack.d.ts

@@ -1,186 +0,0 @@
-import { type Filer } from "./approval-policy.js";
-import { type AssignmentAccess, type AssignmentSnapshot } from "./assignment.js";
-import type { SealedLedgerEntry, Store } from "./store.js";
-import type { LedgerChainReport } from "./ledger-chain.js";
-import { type Html } from "./html.js";
-export declare const EVIDENCE_PACK_FORMAT = "standing-orders/evidence-pack/v1";
-/** How to recheck one entry's seal, for whoever reads the JSON. */
-export declare const SEAL_RECIPE = "hash = sha256(prev + \"\\n\" + JSON.stringify([id, at, actor, repo, taskId, runId, action, outcome, source, detail]))";
-type SealedEntry = SealedLedgerEntry;
-export type EvidencePack = {
-    format: typeof EVIDENCE_PACK_FORMAT;
-    generatedAt: string;
-    generatedBy: string;
-    task: {
-        id: string;
-        title: string;
-        state: string;
-        repo: string | null;
-        project: string | null;
-        filedAt: string;
-    };
-    rules: {
-        now: string;
-        changes: {
-            id: number;
-            at: string;
-            by: string;
-            change: string | null;
-        }[];
-    } | null;
-    /** The task and each revision of it, oldest first. */
-    versions: {
-        id: string;
-        title: string;
-        state: string;
-        filedAt: string;
-        filedBy: Filer | null;
-        scope: {
-            goal: string;
-            outOfScope: string | null;
-            touches: string[];
-            acceptance: {
-                id: string;
-                statement: string;
-            }[];
-            budgetUsd: number | null;
-            digest: string;
-            approved: {
-                by: string;
-                at: string;
-                digest: string;
-                basis: "person" | "lead" | "mode" | "flow" | "schedule" | "carried" | "unknown";
-                current: boolean;
-            } | null;
-            writtenBy: {
-                digest: string;
-                author: string;
-                at: string;
-            }[];
-            approvals: {
-                digest: string;
-                approver: string;
-                at: string;
-            }[];
-        } | null;
-        runs: {
-            id: number;
-            role: string;
-            agent: string;
-            model: string | null;
-            outcome: string | null;
-            reason: string | null;
-            base: string | null;
-            head: string | null;
-            startedAt: string;
-            finishedAt: string | null;
-            tokensIn: number | null;
-            tokensOut: number | null;
-            costUsd: number | null;
-            /** The files a build changed (renames on both sides); null when its record can't be read whole. */
-            changedFiles: string[] | null;
-            diff: {
-                sha256: string;
-                bytes: number;
-                complete: boolean;
-            } | null;
-            proof: {
-                verdict: string;
-                decidedAt: string;
-                reasons: string[];
-            } | null;
-            publication: {
-                repo: string;
-                branch: string;
-                commit: string;
-                state: string;
-                pr: number | null;
-                url: string | null;
-                remoteState: string | null;
-                checks: string | null;
-            } | null;
-        }[];
-    }[];
-    result: {
-        runId: number;
-        base: string | null;
-        head: string | null;
-        kind: string | null;
-        checks: {
-            status: string;
-            command: string | null;
-            exitCode: number | null;
-            detail: string;
-        };
-        completedBy: string | null;
-        completedAt: string | null;
-        caveats: string[];
-        publication: AssignmentSnapshot["publication"];
-    } | null;
-    totals: {
-        runs: number;
-        costUsd: number;
-        tokensIn: number;
-        tokensOut: number;
-    };
-    ledger: {
-        entries: SealedEntry[];
-        /** More entries (or requests) exist than a pack carries; the ledger export has them all. */
-        truncated: boolean;
-        /** `checkedAt`: when the whole chain was last walked (entries since were checked as they came). */
-        chain: {
-            ok: boolean;
-            entries: number;
-            through: number | null;
-            head: string;
-            problem: string | null;
-            checkedAt: string | null;
-        };
-        checkpoint: {
-            through: number;
-            hash: string;
-            at: string;
-        } | null;
-        recipe: string;
-    };
-    /** sha256 of this pack's JSON without this field. */
-    digest: string;
-};
-/** The pack for one task (the whole family: the task and every revision), as `who` may see it. null when they can't. */
-export declare function evidencePack(store: Store, taskId: string, access: AssignmentAccess, who: string, now: Date, evidenceRoot: string, checked?: LedgerChainReport): EvidencePack | null;
-export declare function packDigest(body: Omit<EvidencePack, "digest">): string;
-/** A day as the export takes it (YYYY-MM-DD, UTC), or null. */
-export declare function exportDay(value: string | null): string | null;
-export type LedgerExport = {
-    format: "standing-orders/ledger-export/v1";
-    generatedAt: string;
-    generatedBy: string;
-    from: string;
-    to: string;
-    chain: EvidencePack["ledger"]["chain"];
-    checkpoint: EvidencePack["ledger"]["checkpoint"];
-    recipe: string;
-    entries: SealedEntry[];
-    /** An evidence pack for every task the range's entries name. */
-    packs: EvidencePack[];
-    truncated: {
-        entries: boolean;
-        packs: boolean;
-    };
-};
-/** Every ledger entry in [from, to) that `who` may read, sealed, with a pack for each task they name: one JSON
- * document (a `LedgerExport`), a piece at a time (a page of entries, or one pack), so an export never holds
- * the whole range at once. */
-export declare function ledgerExportChunks(store: Store, range: {
-    from: string;
-    to: string;
-}, scope: {
-    repos: readonly string[] | null;
-    instance: boolean;
-}, access: AssignmentAccess, who: string, now: Date, evidenceRoot: string): Generator<string, void, undefined>;
-export declare const EVIDENCE_PACK_CSS: string;
-/** The pack as a page: the same facts, in the order an auditor reads them. No script. */
-export declare function evidencePackHtml(pack: EvidencePack): Html;
-/** The page as a file on its own (the CLI's --html): the same facts with just enough style to print. */
-export declare function standaloneEvidenceHtml(pack: EvidencePack): string;
-export {};

package/dist/evidence-pair.d.ts

@@ -1,53 +0,0 @@
-import type { Store } from "./store.js";
-export type EvidenceReading = "failing" | "fixed" | "still-failing" | "check-changed" | "out-of-date";
-export type EvidenceSide = {
-    run: number;
-    head: string;
-    status: "passed" | "failed";
-    via: "build" | "follow-up";
-    screenshots: number[];
-};
-export type EvidencePair = {
-    id: number;
-    familyRoot: string;
-    before: EvidenceSide;
-    receiptDigest: string;
-    commandDigest: string | null;
-    savedBy: string;
-    savedAt: string;
-    after: EvidenceSide | null;
-    latestHead: string | null;
-    latestRun: number | null;
-    reading: EvidenceReading;
-};
-export declare function evidencePairsOf(store: Store, root: string, taskId: string, now: Date): EvidencePair[];
-export type SavePair = {
-    ok: true;
-    id: number;
-    existing: boolean;
-} | {
-    ok: false;
-    reason: "unknown" | "not-on-task" | "no-failed-check";
-    message: string;
-};
-/** Save a run's failed check as the before side. Only a sealed failure can be saved: there's nothing else to compare. */
-export declare function saveEvidencePair(store: Store, root: string, input: {
-    taskId: string;
-    runId?: number;
-    by: string;
-}, now: Date): SavePair;
-export type RerunPair = {
-    ok: true;
-    run: number;
-    head: string;
-    request: number;
-    existing: boolean;
-} | {
-    ok: false;
-    message: string;
-};
-/** Ask for the same check on the latest commit. Its level is the one the saved failure ran at. The caller proves the person. */
-export declare function rerunEvidence(store: Store, taskId: string, actor: string, now: Date): RerunPair;
-/** How a pair reads, in one sentence. */
-export declare function evidenceWords(pair: EvidencePair): string;
-export { askFailingFirst, dropFailingFirst, FAILING_FIRST_FILE, failingFirstOf, failingFirstReportSchema, failingFirstWords, saveFailingFirstReport, type FailingFirst } from "./failing-first.js";

package/dist/evidence.d.ts

@@ -1,371 +0,0 @@
-/**
- * Evidence: what actually happened, captured by the machine (§4, §7).
- *
- * The agent does not choose what counts as evidence — a diff the agent could
- * fabricate is a screenshot of a different crime scene. At park time the
- * builder captures the working state itself, relative to the base revision
- * stamped before the agent spent anything, and records how each capture was
- * made, whether it is complete, and what it hashes to. A truncated capture
- * says truncated; a failed capture stores the failure. Presenting either as
- * the whole story is the one dishonesty this module exists to rule out.
- *
- * Files live under the evidence root — outside every worktree, so an agent
- * cannot pre-write them — created exclusively (`wx`) with mode 0600. The
- * store holds keys relative to that root, never absolute paths.
- */
-import { type ParsedReport, type ReportImage } from "./scout-report.js";
-import { type ParsedProof } from "./proof.js";
-import { type HandoffArtifact } from "./contracts/handoff.js";
-import type { DiffStat } from "./contracts/diff-stat.js";
-export type { HandoffArtifact } from "./contracts/handoff.js";
-import type { Artifact, Store } from "./store.js";
-import type { ExecResult } from "./exec.js";
-/** The park mailbox pattern. Each run's actual name carries a nonce; see `mailboxName`. */
-export declare const MAILBOX_PREFIX = "STANDING-ORDERS-PARK-";
-/** The terminal handoff: how every non-parking attempt says how it ended. */
-export declare const HANDOFF_PREFIX = "STANDING-ORDERS-DONE-";
-/** The planner's terminal handoff: the proposed scope and the plan document. */
-export declare const PLAN_PREFIX = "STANDING-ORDERS-PLAN-";
-/** The reviewer's former comment mailbox (v29–evidence-review-v1): the
- * reviewer now replies in its final message and writes nothing, but the
- * pattern stays recognized so a sweep still cleans up a stray file this
- * name left by an older build. */
-export declare const REVIEW_PREFIX = "STANDING-ORDERS-REVIEW-";
-/** The scout's terminal handoff (v34): the report, its only deliverable. */
-export declare const REPORT_PREFIX = "STANDING-ORDERS-REPORT-";
-/** The build's proof manifest (Priority 2): optional, and read only after
- * the handoff — a completed attempt's proof, never a parking or failure
- * artifact. */
-export declare const PROOF_PREFIX = "STANDING-ORDERS-PROOF-";
-export declare const RUBRIC_PREFIX = "STANDING-ORDERS-RUBRIC-";
-/** The running build's atomic milestone checkpoint (adaptive execution
- * plans): overwritten in place — a temp name, then a rename — rather than
- * created once and unlinked, since progress is reported many times across
- * one attempt. Read, never consumed, by the pulse and by settlement. */
-export declare const PROGRESS_PREFIX = "STANDING-ORDERS-PROGRESS-";
-/** The running build's bounded, evidence-linked plan-revision proposal
- * (adaptive execution plans): a terminal file like park or proof, written
- * at most once, read once at settlement. */
-export declare const PROPOSAL_PREFIX = "STANDING-ORDERS-PROPOSAL-";
-/** The running build's steering mailbox: a FOLDER, not a file. The pulse
- * writes each operator note into it as NNN.json (a temp name, then a
- * rename); the agent acknowledges a note by moving it into `handled/`. */
-export declare const STEER_PREFIX = "STANDING-ORDERS-STEER-";
-/** The running build's status file (Agents board): JSON lines the agent appends
- * (working, needs-decision, blocked, done), read forward by the pulse. */
-export declare const STATUS_PREFIX = "STANDING-ORDERS-STATUS-";
-export declare const MAILBOX_SUFFIX = ".json";
-/** v105: left in a run's evidence folder when the retention setting removed its files (retention.ts). */
-export declare const RETENTION_NOTE = "REMOVED-BY-RETENTION";
-/** Bounds on a claimed screenshot file's own bytes — independent of the
- * proof manifest's byte cap, since these are binary images, not JSON. */
-export declare const SCREENSHOT_BYTE_CAP: number;
-/** Check evidence lives in the run's evidence, never on the branch: images a
- * build adds under this folder are left out of its commit. */
-export declare const WORKTREE_EVIDENCE_DIR = "evidence/";
-export declare function isImagePath(path: string): boolean;
-/** Images and other files that are never read as text, judged by name alone. */
-export declare function isBinaryAssetPath(path: string): boolean;
-/** Bytes each kind may store. Originals can be any size; the record says what was cut. */
-/** Bound one captured stream to `cap` bytes keeping its beginning and, mostly,
- * its end: a test runner's summary and failure list come last, and that is
- * what a reviewer or a repair needs to read. */
-export declare const SHORTENED_MARKER = "\n\u2026 output shortened; ending follows \u2026\n";
-export declare function boundStreamHeadTail(value: string, cap: number, headShare?: number): string;
-export declare const EVIDENCE_CAPS: Record<Artifact["kind"], number>;
-/**
- * The bound a writer may seal a kind at with storeEvidence's `cap`, above its default: a release check's sealed report and
- * inventory (check-report.ts CHECK_ARTIFACT_CAP, 256 KiB). Readers accept exactly what writers may seal: 0.9.77 sealed
- * reports up to 256 KiB but read structured output back only to 64 KiB, so every full report over that (~85 KiB for a
- * 585-file suite) read as "no longer verifies" and the release's check as unavailable.
- */
-export declare const SEALED_EVIDENCE_CAPS: Partial<Record<Artifact["kind"], number>>;
-/** The most a stored artifact of this kind may hold: its default cap, or the larger bound a sealed payload may use. */
-export declare function evidenceReadCap(kind: Artifact["kind"]): number;
-export declare function evidenceRoot(home: string): string;
-/**
- * Unpredictable per attempt, so nothing on disk before this build can already
- * be the mailbox: a stale file, however it got there, simply has the wrong
- * name. The agent learns the name from its brief and nowhere else.
- */
-export declare function mailboxName(): string;
-/** Every protocol file the sweep must never let an old attempt leave behind.
- * The pre-rename NIGHTORDERS- prefix stays recognized here — a worktree cut
- * down before 2026-08-13 may still hold one, and cleanup has no vintage. */
-export declare function looksLikeProtocolFile(name: string): boolean;
-/** A steering mailbox folder, or anything in it, as a directory listing or
- * `git status` names it: an untracked folder is reported with a trailing
- * slash, or file by file where a repository shows every untracked file. */
-export declare function looksLikeSteerFolder(name: string): boolean;
-/** An agent status file (Agents board), by its exact nonce-shaped name. */
-export declare function looksLikeStatusFile(name: string): boolean;
-export declare function statusFileName(): string;
-export declare function steerFolderName(): string;
-export declare function handoffName(): string;
-export declare function planFileName(): string;
-/** The build's optional proof manifest (Priority 2), named exactly like
- * every other protocol file — a nonce the agent learns only from its brief. */
-export declare function proofFileName(): string;
-export declare function rubricFileName(): string;
-export declare function reportFileName(): string;
-export declare function progressFileName(): string;
-export declare function proposalFileName(): string;
-/**
- * Read a mailbox without following anything: the path must be a regular file,
- * opened O_NOFOLLOW and measured through its own descriptor — an agent that
- * made the pathname a symlink or FIFO gets a refusal, not a runner reading an
- * unrelated local file into web-visible evidence.
- */
-export declare function readMailbox(path: string, cap?: number): {
-    ok: true;
-    raw: Buffer;
-} | {
-    ok: false;
-    problem: string;
-    missing: boolean;
-    raw?: Buffer;
-    bytesOriginal?: number;
-};
-/** A scout's report as a surface reads it (mate arc §10): the newest
- * scout run's artifact, VERIFIED before a byte is parsed, then parsed with
- * the same 422 rule that admitted it. null = no report; a problem names
- * why an existing artifact cannot be shown rather than showing nothing. */
-export type ReportView = {
-    ok: true;
-    run: number;
-    report: ParsedReport;
-    shots: ReportShot[];
-} | {
-    ok: false;
-    run: number;
-    problem: string;
-};
-/** A report's screenshot as a page shows it: its stored evidence, or why it can't be shown. The bytes are
- * verified again whenever the image itself is served. */
-export type ReportShot = {
-    file: string;
-    caption: string;
-    url: string;
-    artifactId: number | null;
-    problem: string | null;
-};
-/** Each image a report names, matched to the screenshot evidence its own run stored with the same sha256. */
-export declare function reportShotsOf(artifacts: readonly Artifact[], root: string, run: number, images: readonly ReportImage[]): ReportShot[];
-export declare function readVerifiedReport(store: Store, root: string, taskRef: number): ReportView | null;
-/** A build's proof, read the same verified way as a scout's report — but
- * keyed by RUN, not task: unlike a scout's report (the task's one rolling
- * deliverable), a proof belongs to the one attempt whose page is showing
- * it. null = no proof artifact for this run; a problem names why an
- * existing one cannot be shown. */
-export type ProofView = {
-    ok: true;
-    run: number;
-    proof: ParsedProof;
-} | {
-    ok: false;
-    run: number;
-    problem: string;
-};
-/** Verifies this run's proof bytes and format. A handoff that relies on a
- * revision's ancestors must also recheck its saved review-context custody. */
-export declare function readVerifiedProofForRun(store: Store, root: string, runId: number): ProofView | null;
-export declare function sniffImageKind(bytes: Buffer): "png" | "jpeg" | null;
-/** Whether bytes claimed as a screenshot actually are a bounded PNG or
- * JPEG — the one check standing between a claimed path and stored,
- * immutable image evidence. */
-export declare function validateScreenshotBytes(bytes: Buffer): {
-    ok: true;
-    kind: "png" | "jpeg";
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * Pixel dimensions read straight from the format's own header — never
- * decoded, never trusting a claimed size (v39, screenshot evidence:
- * "meaningful byte size and at least 320 by 200 dimensions"). `null` when
- * the bytes are a valid signature but the header could not be read (a
- * genuinely corrupt or truncated file) — the caller treats that the same
- * as failing the size floor, never as passing it.
- *
- * PNG: the IHDR chunk is fixed at bytes 8-25 for every valid PNG — width
- * and height are the two big-endian uint32s right after it starts.
- *
- * JPEG: scan markers from byte 2. Every marker except the two without a
- * payload (SOI 0xD8, EOI 0xD9) and the RST markers (0xD0-0xD7) carries a
- * two-byte big-endian length; the SOF markers (0xC0-0xCF, excluding the
- * DHT/JPG/DAC markers 0xC4/0xC8/0xCC, which share the range but are not
- * frame headers) hold precision(1) + height(2) + width(2) right after
- * that length field.
- */
-export declare function imageDimensions(bytes: Buffer, kind: "png" | "jpeg"): {
-    width: number;
-    height: number;
-} | null;
-/**
- * Write one evidence file and record it. The row is written through the
- * store the caller passed — inside whatever transaction the caller holds.
- */
-export declare function storeEvidence(store: Store, root: string, runId: number, kind: Artifact["kind"], name: string, content: Buffer, capture: string, now: Date, options?: {
-    redacted?: boolean;
-    captureStatus?: "ok" | "failed";
-    sourceBytesOriginal?: number;
-    cap?: number;
-}): number;
-/**
- * Read an artifact's bytes back, believing nothing until it is proved on the
- * descriptor actually read (§7's honesty, applied to serving). The record's
- * key must be a normalized relative path; the resolved path must live under
- * the root; the open refuses symlinks; the size and hash checks run against
- * the same descriptor the bytes come from — so a pathname swapped between a
- * check and the read buys an attacker nothing. Only a buffer whose SHA-256
- * matches the row is ever returned: unverified bytes never leave this
- * function, which is what lets a caller stream with a clear conscience.
- * Success proves stored-byte integrity only. Callers must independently
- * decide whether a shortened representation or failed capture is usable;
- * a verified failure log is still a failure, not successful evidence.
- */
-export declare function readVerifiedArtifact(root: string, artifact: Artifact): {
-    ok: true;
-    content: Buffer;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * Whether an artifact's bytes still verify, without returning them. Status
- * sweeps ask this of every artifact of every run, so a file proved earlier and
- * not touched since (same artifact row, device, inode, size, mtime and ctime
- * on the descriptor just opened) costs an fstat, not a re-read and SHA-256.
- * Every path check still runs on each call; a changed or new file is hashed.
- */
-export declare function verifyArtifact(root: string, artifact: Artifact): {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-/** The file alone, no row — quarantines use this; they belong to no live run. */
-export declare function writeEvidenceFile(root: string, runId: number, name: string, content: Buffer): string;
-/**
- * Sweep every park-shaped file out of a worktree before the agent runs.
- *
- * A mailbox left by a cut-down attempt is never ingested as a decision — the
- * lease that could have vouched for it is gone — but its bytes may still say
- * what the agent meant, so what can be read safely is kept under quarantine
- * in the current run's evidence directory. What cannot be read safely (a
- * symlink, a FIFO, something oversized) is removed unread.
- */
-export declare function quarantineMailboxes(worktree: string, root: string | null, runId: number | null): string[];
-/**
- * Capture the park's evidence: the complete working state against the base
- * revision, and the porcelain inventory that names what the diff cannot —
- * untracked and staged files included. External diff drivers and textconv
- * are disabled by name: both run repository-configured commands, and this
- * capture must not execute anything the agent may have just written.
- */
-export declare function captureParkEvidence(store: Store, git: (file: string, args: readonly string[], options?: {
-    cwd?: string;
-}) => Promise<ExecResult>, worktree: string, baseRevision: string | null, root: string, runId: number, now: Date): Promise<number[]>;
-/** The terminal diff-stat and its file rows: src/contracts/diff-stat.ts. */
-export type { DiffStat, DiffStatFile } from "./contracts/diff-stat.js";
-/**
- * Parse `git diff --numstat -z` output. NUL-delimited, so filenames are never
- * guessed out of patch headers (Codex roadmap review, scope cut A.3): plain
- * entries are one token "adds\tdels\tpath"; renames are "adds\tdels\t" with
- * the two paths as the following tokens. Binary files carry "-" counts,
- * recorded as null — never coerced to zero.
- */
-export declare function parseNumstat(raw: string, base: string, head: string): DiffStat;
-/**
- * Write the handoff artifact (M6.10): the machine's own statement of where
- * a finished run left the world — workspace identity, exact base and head,
- * which answered decisions the brief carried, and a freshness stamp a
- * successor can PROVE against the branch before spending a token on stale
- * context. This is what makes a cold takeover context-bearing rather than
- * repo-only; a provider session is memory, not a freshness proof.
- */
-export declare function storeHandoffArtifact(store: Store, root: string, payload: Omit<HandoffArtifact, "version">, now: Date): number;
-/**
- * High-confidence secret shapes ONLY (audit IV-7): a detector that cries
- * wolf trains people to approve wolves. Each pattern is a format no
- * ordinary source line matches by accident; generic "password=" shapes
- * are deliberately absent — test fixtures would drown the signal.
- */
-export declare const SECRET_PATTERNS: readonly {
-    name: string;
-    pattern: RegExp;
-}[];
-export type SecretHit = {
-    name: string;
-    line: number;
-};
-/** Scan text line by line; every hit names its pattern and line. */
-export declare function scanForSecrets(text: string): SecretHit[];
-/**
- * Whether one matched secret shape is a documented or reserved placeholder:
- * anything spelling EXAMPLE (AWS's own AKIAIOSFODNN7EXAMPLE), a password on
- * a reserved example host, or a value that is mostly one repeated character.
- */
-export declare function isPlaceholderSecret(name: string, line: string, match: RegExpExecArray): boolean;
-/** A secret shape the diff ADDS, with the patch line (for redaction) and
- * the file and line it lands on at the new head (for the alert). */
-export type PatchSecretHit = SecretHit & {
-    file: string;
-    fileLine: number;
-};
-/**
- * Scan a unified diff for secrets it commits: only added lines count —
- * removing a line cannot commit a secret, and context lines were already
- * there — and documented or reserved placeholders are not secrets.
- */
-export declare function scanPatchForSecrets(patch: string): PatchSecretHit[];
-/** The alert for a candidate head with a flagged added line: where each
- * hit is and what to do, without repeating the value. */
-export declare function secretAlert(hits: readonly PatchSecretHit[], runId: number): {
-    subject: string;
-    body: string;
-};
-/** Replace every hit line with a marker naming what was found — the display copy holds no secret. */
-export declare function redactSecretLines(text: string, hits: readonly SecretHit[]): string;
-/**
- * Fit a DiffStat under its cap by shedding FILES, never bytes (audit C-4):
- * a structured artifact cut mid-token is not a smaller stat, it is no stat.
- * Aggregate counts always survive; the file list shrinks until the encoded
- * JSON fits, and filesTruncated says so.
- */
-export declare function budgetedStatJson(stat: DiffStat): Buffer;
-/**
- * Capture the TERMINAL diff — the immutable base→head patch of a run that
- * committed, taken before its worktree is released (M5.3; the Codex scope
- * cut is the spec). Two artifacts: the bounded plain patch, and a
- * machine-parsed stat whose filenames came NUL-delimited from git, never
- * from patch headers. Same execution posture as the park capture: external
- * diff drivers and textconv disabled by name, because this must not run
- * anything the agent may have just written. A no-change run stores the
- * explicit zero-stat rather than storing nothing — "no diff" and "capture
- * failed" have to read differently.
- */
-export declare function captureTerminalDiff(store: Store, git: (file: string, args: readonly string[], options?: {
-    cwd?: string;
-}) => Promise<ExecResult>, worktree: string, base: string, head: string, root: string, runId: number, now: Date): Promise<{
-    diffId: number;
-    statId: number;
-}>;
-/**
- * The live peek's base snapshot (live-peek v3 §1), captured in the same
- * pre-spawn window that computed `base` itself — one `ls-tree` against the
- * project clone (NEVER a worktree), lazy-fetch and replace-refs disabled
- * on argv, the child's environment reduced to an allowlist that contains
- * no GIT_* at all. The parsed listing is round-tripped through the strict
- * snapshot codec: any entry the codec refuses — including paths the UTF-8
- * decode mangled into U+FFFD — refuses the WHOLE snapshot, recorded as a
- * failed capture. Integrity class: the database's own, claimed as nothing
- * more (round-3 finding 42).
- */
-export declare function captureBaseTree(store: Store, git: (file: string, args: readonly string[], options?: {
-    cwd?: string;
-    envAllowlist?: readonly string[];
-}) => Promise<ExecResult>, repoRoot: string, repo: string, base: string, root: string, runId: number, now: Date): Promise<{
-    ok: boolean;
-}>;