toolroll 0.9.104 → 0.9.105

package/dist/contracts/release-check.d.ts

@@ -1,371 +0,0 @@
-/**
- * The release check's structured results (docs/plans/release-once.md, parts 2 and 3): what the orchestrator
- * (`scripts/release-check.mjs`) reports on its last stdout line, what the plane seals before and after a check runs
- * (the inventory, the execution context, a targeted plan and its obligation snapshot), and the identities every one of
- * them names. Only the plane writes the sealed payloads, from typed values; the report comes from the check itself and
- * is read strictly — anything that doesn't match is no report.
- *
- * Coverage trusts test code (Alex, 2026-10-25): a test runs as the same user as the harness, so these results guard
- * against accidental damage — stray processes, leftover files, output that looks like a report — not a hostile test.
- * Authority decisions never read them.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** The parts a release check is made of. */
-export declare const CHECK_PARTS: readonly ["typecheck", "build", "unit", "flows", "app", "flows-real", "app-real", "upgrade"];
-export type CheckPart = typeof CHECK_PARTS[number];
-export declare const JOURNEY_SCRIPTS: readonly ["app", "flows"];
-export type JourneyScript = typeof JOURNEY_SCRIPTS[number];
-/** What the orchestrator reports, as the last line of its output: `TOOLROLL_CHECK_REPORT <json>`, at most 256 KiB. */
-export declare const CHECK_REPORT_PREFIX = "TOOLROLL_CHECK_REPORT ";
-export declare const CHECK_REPORT_MAX_BYTES: number;
-export declare const checkReportSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    nonce: z.ZodString;
-    mode: z.ZodEnum<{
-        full: "full";
-        targeted: "targeted";
-    }>;
-    planDigest: z.ZodNullable<z.ZodString>;
-    exitCode: z.ZodInt;
-    parts: z.ZodArray<z.ZodObject<{
-        part: z.ZodEnum<{
-            app: "app";
-            "app-real": "app-real";
-            build: "build";
-            flows: "flows";
-            "flows-real": "flows-real";
-            typecheck: "typecheck";
-            unit: "unit";
-            upgrade: "upgrade";
-        }>;
-        selected: z.ZodBoolean;
-        ran: z.ZodBoolean;
-        code: z.ZodNullable<z.ZodInt>;
-        timedOut: z.ZodBoolean;
-        startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        signal: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        stopped: z.ZodOptional<z.ZodBoolean>;
-        spawnFailed: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    units: z.ZodNullable<z.ZodObject<{
-        reusedFromCI: z.ZodBoolean;
-        finished: z.ZodBoolean;
-        runErrors: z.ZodInt;
-        files: z.ZodArray<z.ZodObject<{
-            file: z.ZodString;
-            state: z.ZodEnum<{
-                failed: "failed";
-                passed: "passed";
-                skipped: "skipped";
-            }>;
-            passed: z.ZodInt;
-            failed: z.ZodInt;
-            skipped: z.ZodInt;
-            flaky: z.ZodBoolean;
-        }, z.core.$strict>>;
-        identities: z.ZodArray<z.ZodObject<{
-            file: z.ZodString;
-            name: z.ZodString;
-            state: z.ZodEnum<{
-                failed: "failed";
-                passed: "passed";
-                skipped: "skipped";
-            }>;
-            flaky: z.ZodBoolean;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    journeys: z.ZodArray<z.ZodObject<{
-        script: z.ZodEnum<{
-            app: "app";
-            flows: "flows";
-        }>;
-        kind: z.ZodEnum<{
-            real: "real";
-            scripted: "scripted";
-        }>;
-        finished: z.ZodBoolean;
-        inventoried: z.ZodOptional<z.ZodBoolean>;
-        groups: z.ZodArray<z.ZodObject<{
-            group: z.ZodString;
-            state: z.ZodEnum<{
-                failed: "failed";
-                "not-run": "not-run";
-                passed: "passed";
-            }>;
-            retried: z.ZodBoolean;
-            unattributed: z.ZodBoolean;
-            journeys: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                state: z.ZodEnum<{
-                    failed: "failed";
-                    passed: "passed";
-                    skipped: "skipped";
-                }>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    upgrades: z.ZodNullable<z.ZodObject<{
-        finished: z.ZodBoolean;
-        inventoried: z.ZodOptional<z.ZodBoolean>;
-        versions: z.ZodArray<z.ZodObject<{
-            version: z.ZodString;
-            state: z.ZodEnum<{
-                failed: "failed";
-                "not-run": "not-run";
-                passed: "passed";
-            }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type CheckReport = z.infer<typeof checkReportSchema>;
-export declare function readCheckReport(input: unknown): ContractResult<CheckReport>;
-/** What a check must account for, sealed before it runs: the unit files (from the verified tree and Vitest's include
- * globs) and the parts selected. The journey groups and upgrade versions come from the check's own report and are
- * sealed beside these after it ran. */
-export declare const checkInventorySchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    units: z.ZodArray<z.ZodString>;
-    parts: z.ZodArray<z.ZodEnum<{
-        app: "app";
-        "app-real": "app-real";
-        build: "build";
-        flows: "flows";
-        "flows-real": "flows-real";
-        typecheck: "typecheck";
-        unit: "unit";
-        upgrade: "upgrade";
-    }>>;
-    ciSubstitute: z.ZodOptional<z.ZodBoolean>;
-    release: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type CheckInventory = z.infer<typeof checkInventorySchema>;
-/** The sealed inventory artifact: what was sealed before the run, and what the run declared. */
-export declare const sealedInventorySchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    sealed: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        units: z.ZodArray<z.ZodString>;
-        parts: z.ZodArray<z.ZodEnum<{
-            app: "app";
-            "app-real": "app-real";
-            build: "build";
-            flows: "flows";
-            "flows-real": "flows-real";
-            typecheck: "typecheck";
-            unit: "unit";
-            upgrade: "upgrade";
-        }>>;
-        ciSubstitute: z.ZodOptional<z.ZodBoolean>;
-        release: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>;
-    declared: z.ZodObject<{
-        groups: z.ZodArray<z.ZodObject<{
-            script: z.ZodEnum<{
-                app: "app";
-                flows: "flows";
-            }>;
-            kind: z.ZodEnum<{
-                real: "real";
-                scripted: "scripted";
-            }>;
-            groups: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-        versions: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type SealedInventory = z.infer<typeof sealedInventorySchema>;
-/** Where a check ran: what has to match for an earlier result to stand beside a later one. */
-export declare const checkContextSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    node: z.ZodString;
-    platform: z.ZodString;
-    arch: z.ZodString;
-    lockfile: z.ZodNullable<z.ZodString>;
-    harness: z.ZodString;
-    grant: z.ZodObject<{
-        id: z.ZodInt;
-        digest: z.ZodString;
-    }, z.core.$strict>;
-    access: z.ZodString;
-}, z.core.$strict>;
-export type CheckContext = z.infer<typeof checkContextSchema>;
-/** A targeted check's plan: exactly what it runs, sealed before it runs. */
-export declare const targetedPlanSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    base: z.ZodInt;
-    units: z.ZodArray<z.ZodString>;
-    sanity: z.ZodArray<z.ZodString>;
-    groups: z.ZodArray<z.ZodObject<{
-        script: z.ZodEnum<{
-            app: "app";
-            flows: "flows";
-        }>;
-        kind: z.ZodEnum<{
-            real: "real";
-            scripted: "scripted";
-        }>;
-        groups: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    versions: z.ZodArray<z.ZodString>;
-    parts: z.ZodArray<z.ZodEnum<{
-        app: "app";
-        "app-real": "app-real";
-        build: "build";
-        flows: "flows";
-        "flows-real": "flows-real";
-        typecheck: "typecheck";
-        unit: "unit";
-        upgrade: "upgrade";
-    }>>;
-    required: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type TargetedPlan = z.infer<typeof targetedPlanSchema>;
-/** The earlier targeted runs of this generation a targeted attempt took into account, sealed with it. */
-export declare const obligationSnapshotSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    authority: z.ZodInt;
-    base: z.ZodInt;
-    earlier: z.ZodArray<z.ZodObject<{
-        run: z.ZodInt;
-        reportDigest: z.ZodNullable<z.ZodString>;
-        failed: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ObligationSnapshot = z.infer<typeof obligationSnapshotSchema>;
-/** What the plane writes on the check's stdin before closing it. `learn` (docs/plans/learning-loops.md) is advisory and
- * apart from everything else: exact case identities the check is asked to say it ran, on their own line
- * (LEARN_PREFIX), never in the report and never part of what the check owes. */
-export type CheckHandshake = {
-    nonce: string;
-    mode: "full" | "targeted";
-    plan: TargetedPlan | null;
-    watch: string[];
-    owed?: CheckPart[];
-    ciSubstitute?: boolean;
-    learn?: string[];
-};
-/** The advisory learning line a check prints before its report: `TOOLROLL-LEARN <json>`, at most 64 KiB, holding only
- * the requested identities that ran. Never part of the report: buildReport, reportLine and fullCheckProblem don't read
- * it, and a missing, malformed or oversized one loses learning evidence only. */
-export declare const LEARN_PREFIX = "TOOLROLL-LEARN ";
-export declare const LEARN_MAX_BYTES: number;
-export declare const LEARN_MAX_IDENTITIES = 200;
-export declare const isExactCase: (identity: unknown) => identity is string;
-/** What the plane asks a check to report for learning: exact cases only, first seen first, at most 200. */
-export declare function learnRequest(identities: readonly unknown[]): string[];
-export declare const learnLineSchema: z.ZodObject<{
-    nonce: z.ZodString;
-    results: z.ZodArray<z.ZodObject<{
-        identity: z.ZodString;
-        state: z.ZodEnum<{
-            failed: "failed";
-            passed: "passed";
-            skipped: "skipped";
-        }>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type LearnLine = z.infer<typeof learnLineSchema>;
-/** A unit test: its file and full name. */
-export declare const unitIdentity: (file: string, testName: string) => string;
-/** A unit file. */
-export declare const fileIdentity: (file: string) => string;
-/** A journey group of a script and kind. */
-export declare const groupIdentity: (script: string, kind: string, group: string) => string;
-/** One journey in its group. */
-export declare const journeyIdentity: (script: string, kind: string, group: string, journey: string) => string;
-/** An upgrade version. */
-export declare const versionIdentity: (version: string) => string;
-/** A whole part. */
-export declare const partIdentity: (part: string) => string;
-/** One fd-3 result line a harness process writes (test/release-reporter.ts, scripts/check-results.mjs). The
- * orchestrator reads only these shapes; anything else on the pipe is passed over. */
-export declare const checkResultLineSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"unit-case">;
-    file: z.ZodString;
-    name: z.ZodString;
-    state: z.ZodEnum<{
-        failed: "failed";
-        passed: "passed";
-        skipped: "skipped";
-    }>;
-    flaky: z.ZodBoolean;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"unit-file">;
-    file: z.ZodString;
-    state: z.ZodEnum<{
-        failed: "failed";
-        passed: "passed";
-        skipped: "skipped";
-    }>;
-    passed: z.ZodInt;
-    failed: z.ZodInt;
-    skipped: z.ZodInt;
-    flaky: z.ZodBoolean;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"unit-end">;
-    reason: z.ZodString;
-    errors: z.ZodInt;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"journey-inventory">;
-    script: z.ZodEnum<{
-        app: "app";
-        flows: "flows";
-    }>;
-    journeys: z.ZodString;
-    groups: z.ZodArray<z.ZodString>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"journey">;
-    name: z.ZodString;
-    state: z.ZodEnum<{
-        failed: "failed";
-        passed: "passed";
-        skipped: "skipped";
-    }>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"journey-end">;
-    script: z.ZodOptional<z.ZodEnum<{
-        app: "app";
-        flows: "flows";
-    }>>;
-    journeys: z.ZodOptional<z.ZodString>;
-    browserCheck: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    unstopped: z.ZodOptional<z.ZodBoolean>;
-    catalogue: z.ZodOptional<z.ZodInt>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"journey-group">;
-    script: z.ZodEnum<{
-        app: "app";
-        flows: "flows";
-    }>;
-    journeys: z.ZodString;
-    group: z.ZodString;
-    state: z.ZodEnum<{
-        failed: "failed";
-        "not-run": "not-run";
-        passed: "passed";
-    }>;
-    retried: z.ZodBoolean;
-    unattributed: z.ZodBoolean;
-    results: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        state: z.ZodEnum<{
-            failed: "failed";
-            passed: "passed";
-            skipped: "skipped";
-        }>;
-    }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"upgrade-inventory">;
-    versions: z.ZodArray<z.ZodString>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"upgrade-version">;
-    version: z.ZodString;
-    state: z.ZodEnum<{
-        failed: "failed";
-        "not-run": "not-run";
-        passed: "passed";
-    }>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"upgrade-end">;
-}, z.core.$strict>], "kind">;

package/dist/contracts/release-terms.d.ts

@@ -1,107 +0,0 @@
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** The carry rules this runtime knows (release-carry.ts CARRY_RULES). A sealed policy naming any other refuses. */
-export declare const CARRY_RULES_VERSION = 1;
-export declare const releasePolicySchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    rules: z.ZodLiteral<1>;
-    carry: z.ZodBoolean;
-    protectProject: z.ZodBoolean;
-    protectedPaths: z.ZodArray<z.ZodString>;
-    limits: z.ZodObject<{
-        lines: z.ZodInt;
-        files: z.ZodInt;
-        churn: z.ZodInt;
-    }, z.core.$strict>;
-    unsandboxedCarry: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type ReleasePolicy = z.infer<typeof releasePolicySchema>;
-export declare const releaseTermsSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    repo: z.ZodString;
-    packageVersion: z.ZodString;
-    branch: z.ZodString;
-    pr: z.ZodInt;
-    base: z.ZodLiteral<"main">;
-    approvedSha: z.ZodString;
-    approvedTree: z.ZodString;
-    policy: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        rules: z.ZodLiteral<1>;
-        carry: z.ZodBoolean;
-        protectProject: z.ZodBoolean;
-        protectedPaths: z.ZodArray<z.ZodString>;
-        limits: z.ZodObject<{
-            lines: z.ZodInt;
-            files: z.ZodInt;
-            churn: z.ZodInt;
-        }, z.core.$strict>;
-        unsandboxedCarry: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>;
-    grant: z.ZodObject<{
-        id: z.ZodInt;
-        digest: z.ZodString;
-    }, z.core.$strict>;
-    access: z.ZodEnum<{
-        sandboxed: "sandboxed";
-        "sign-ins": "sign-ins";
-        unsandboxed: "unsandboxed";
-    }>;
-    expiresAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type ReleaseTerms = z.infer<typeof releaseTermsSchema>;
-export declare function readReleaseTerms(input: unknown): ContractResult<ReleaseTerms>;
-export declare function readReleasePolicy(input: unknown): ContractResult<ReleasePolicy>;
-/** The digest a scope binds for its release terms, domain-separated from every other digest input. */
-export declare function releaseTermsDigest(terms: ReleaseTerms): string;
-/** The digest of an effective policy, as release_authority.policy_digest holds it. */
-export declare function releasePolicyDigest(policy: ReleasePolicy): string;
-/** Strict stored terms: null column → null; anything that isn't exactly terms → a problem. */
-export declare function storedReleaseTerms(raw: unknown): {
-    ok: true;
-    terms: ReleaseTerms | null;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * A release check's purpose (docs/plans/pipeline-speed.md, P0): what a person agrees to when they approve a release
- * whose later commits can't carry (its checks run outside the sandbox, or carrying is off) — this exact candidate is a
- * release's check. It never carries a later commit, never lets CI stand in for the check's units and never approves
- * itself; it lets the plane hold the check to the release's strict report rules and rerun it, on this identical
- * candidate under this same approval, after a failure the plane itself confirmed as infrastructure. Part of the scope
- * digest when present; read strictly. A scope carries terms or this purpose, never both.
- */
-export declare const releaseCheckPurposeSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    purpose: z.ZodLiteral<"release-check">;
-    repo: z.ZodString;
-    packageVersion: z.ZodString;
-    branch: z.ZodString;
-    pr: z.ZodInt;
-    base: z.ZodLiteral<"main">;
-    approvedSha: z.ZodString;
-    approvedTree: z.ZodString;
-    grant: z.ZodObject<{
-        id: z.ZodInt;
-        digest: z.ZodString;
-    }, z.core.$strict>;
-    access: z.ZodEnum<{
-        sandboxed: "sandboxed";
-        "sign-ins": "sign-ins";
-        unsandboxed: "unsandboxed";
-    }>;
-}, z.core.$strict>;
-export type ReleaseCheckPurpose = z.infer<typeof releaseCheckPurposeSchema>;
-export declare function readReleaseCheckPurpose(input: unknown): ContractResult<ReleaseCheckPurpose>;
-/** The digest a scope binds for its release check purpose, domain-separated from the terms' and every other input. */
-export declare function releaseCheckPurposeDigest(purpose: ReleaseCheckPurpose): string;
-/** Strict stored purpose: null column → null; anything that isn't exactly a purpose, as written → a problem. */
-export declare function storedReleaseCheckPurpose(raw: unknown): {
-    ok: true;
-    purpose: ReleaseCheckPurpose | null;
-} | {
-    ok: false;
-    problem: string;
-};
-export declare function serializeReleaseCheckPurpose(purpose: ReleaseCheckPurpose): string;

package/dist/contracts/retention.d.ts

@@ -1,42 +0,0 @@
-/**
- * Retention settings (retention.ts): which kinds of data have a period, and how long each is kept — a whole number of
- * days from 1 to 3650, or null for forever. One schema for the kind, the period and the full set of periods; the
- * types retention.ts exports are derived from them.
- *
- * `retention_setting` rows are read by the store (`retentionChosen`, item 18's to move onto `retentionRowSchema`): a
- * row's kind and days as SQLite's CHECK constraint keeps them, unknown columns ignored. Text a person types ("90d",
- * "1y", "forever") is turned into days in plain code (retention.ts `parsePeriod`) and then checked by this schema.
- */
-import { z } from "zod";
-export declare const RETENTION_KIND_VALUES: readonly ["evidence", "checkouts", "chat", "notifications"];
-export declare const retentionKindSchema: z.ZodEnum<{
-    chat: "chat";
-    checkouts: "checkouts";
-    evidence: "evidence";
-    notifications: "notifications";
-}>;
-export declare const RETENTION_DAYS: {
-    readonly min: 1;
-    readonly max: 3650;
-};
-/** A period: whole days from 1 to 3650, or null for forever. */
-export declare const retentionDaysSchema: z.ZodNullable<z.ZodInt>;
-/** Every kind's period, as the sweep and the settings page read them. */
-export declare const retentionPeriodsSchema: z.ZodObject<{
-    evidence: z.ZodNullable<z.ZodInt>;
-    checkouts: z.ZodNullable<z.ZodInt>;
-    chat: z.ZodNullable<z.ZodInt>;
-    notifications: z.ZodNullable<z.ZodInt>;
-}, z.core.$strip>;
-/** A saved `retention_setting` row: only a kind someone chose has one. */
-export declare const retentionRowSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        chat: "chat";
-        checkouts: "checkouts";
-        evidence: "evidence";
-        notifications: "notifications";
-    }>;
-    days: z.ZodNullable<z.ZodInt>;
-}, z.core.$strip>;
-export type RetentionKind = z.infer<typeof retentionKindSchema>;
-export type RetentionPeriods = z.infer<typeof retentionPeriodsSchema>;

package/dist/contracts/review-findings.d.ts

@@ -1,46 +0,0 @@
-/**
- * The automatic build review's findings (build-review.ts): one schema for the reply a reviewer gives, the `findings`
- * a Claude reviewer's `--json-schema` describes (provider.ts, inside the review channel it shares with evidence
- * reviews), and what `build_review.findings_json` keeps. `parseBuildFindings` (reviewer.ts) reads a reply through it;
- * a saved row is the same payload, written by `settle` after that read.
- *
- * As before, controls and runs of whitespace collapse to one space before text limits are checked. Unknown keys
- * are ignored in both the review envelope and each finding.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const FINDING_SEVERITIES: readonly ["HIGH", "MEDIUM", "LOW"];
-export type FindingSeverity = (typeof FINDING_SEVERITIES)[number];
-/** How many findings one review may raise. */
-export declare const FINDINGS_MAX = 40;
-/** One finding: how bad, where (a path and the closest line), and how it fails, in one sentence. */
-export declare const buildFindingSchema: z.ZodObject<{
-    severity: z.ZodEnum<{
-        HIGH: "HIGH";
-        LOW: "LOW";
-        MEDIUM: "MEDIUM";
-    }>;
-    file: z.ZodString;
-    line: z.ZodNumber;
-    scenario: z.ZodString;
-}, z.core.$strip>;
-export type BuildFinding = z.infer<typeof buildFindingSchema>;
-export declare const FINDINGS_VERSION = 1;
-export declare const buildFindingsSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    findings: z.ZodArray<z.ZodObject<{
-        severity: z.ZodEnum<{
-            HIGH: "HIGH";
-            LOW: "LOW";
-            MEDIUM: "MEDIUM";
-        }>;
-        file: z.ZodString;
-        line: z.ZodNumber;
-        scenario: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type BuildFindings = z.infer<typeof buildFindingsSchema>;
-/** The `findings` a reviewer's structured reply may carry (provider.ts's review channel), from the same schema. */
-export declare const FINDINGS_MODEL_SCHEMA: Readonly<Record<string, unknown>>;
-/** Read a findings payload: version 1 as itself, a newer one refused plainly, anything else by path. */
-export declare function readBuildFindings(input: unknown): ContractResult<BuildFindings>;