toolroll 0.9.34 → 0.9.37

package/dist/reviewer.js

@@ -1,5 +1,6 @@
 import { citesSuppliedProvenance } from "./review-context.js";
 import { normalizeStructuredJson, REVIEW_OUTPUT_LIMITS } from "./structured-output.js";
+import { readBuildFindings } from "./contracts/review-findings.js";
 /** The files the pass writes INTO the scratch directory for the agent —
  * the patch always; the rubric, re-serialized proof, check log, and
  * screenshots only when this run actually has one (v40) — a grandfathered
@@ -200,13 +201,13 @@ export function parseReview(raw, patchPaths, approvedCriteriaIds = new Set(), pr
         return { ok: false, problems };
     return { ok: true, comments, criteria, ...(payload["learning"] === undefined ? {} : { learning: payload["learning"] }), ...(payload["learningAssessment"] === undefined ? {} : { learningAssessment: payload["learningAssessment"] }) };
 }
-export const FINDING_LIMITS = { findings: 40, file: REVIEW_OUTPUT_LIMITS.path, scenario: REVIEW_OUTPUT_LIMITS.note };
 /**
- * The automatic build review's reply, strict and wholesale like parseReview:
- * `{"version":1,"findings":[{"severity","file","line","scenario"}]}`. Any
- * invalid finding refuses the whole reply — a review that did not answer
- * what it was asked is "not reviewed", never a partial pass. Text is kept
- * to one line so it can travel in a revision note and a terminal.
+ * The automatic build review's reply, read through its contract (src/contracts/review-findings.ts), with all findings
+ * checked together: `{"version":1,"findings":[{"severity","file","line","scenario"}]}`. Any invalid
+ * finding refuses the whole reply — a review that did not answer what it was asked is "not reviewed", never a partial
+ * pass — and the refusal names each path (`findings[0].line: at least 1`). The reply shares Claude's review channel
+ * (provider.ts), so only its version and findings are read, as always. Text is kept to one line so it can travel in a
+ * revision note and a terminal; its limits are checked after whitespace collapses, as before.
  */
 export function parseBuildFindings(raw) {
     let parsed;
@@ -218,33 +219,8 @@ export function parseBuildFindings(raw) {
     }
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
         return { ok: false, problem: "the reply is not an object" };
-    const payload = parsed;
-    if (payload["version"] !== 1)
-        return { ok: false, problem: "version must be 1" };
-    const list = payload["findings"];
-    if (!Array.isArray(list))
-        return { ok: false, problem: "findings must be an array" };
-    if (list.length > FINDING_LIMITS.findings)
-        return { ok: false, problem: `at most ${FINDING_LIMITS.findings} findings` };
-    const findings = [];
-    const oneLine = (text) => text.replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]+/g, " ").replace(/\s+/g, " ").trim();
-    for (const [index, one] of list.entries()) {
-        if (one === null || typeof one !== "object" || Array.isArray(one))
-            return { ok: false, problem: `finding ${index}: not an object` };
-        const finding = one;
-        const severity = finding["severity"];
-        if (severity !== "HIGH" && severity !== "MEDIUM" && severity !== "LOW")
-            return { ok: false, problem: `finding ${index}: severity must be HIGH, MEDIUM or LOW` };
-        const file = typeof finding["file"] === "string" ? oneLine(finding["file"]) : "";
-        if (file.length === 0 || file.length > FINDING_LIMITS.file)
-            return { ok: false, problem: `finding ${index}: file must be a path of 1..${FINDING_LIMITS.file} characters` };
-        const line = finding["line"];
-        if (typeof line !== "number" || !Number.isInteger(line) || line < 1)
-            return { ok: false, problem: `finding ${index}: line must be a positive whole number` };
-        const scenario = typeof finding["scenario"] === "string" ? oneLine(finding["scenario"]) : "";
-        if (scenario.length === 0 || scenario.length > FINDING_LIMITS.scenario)
-            return { ok: false, problem: `finding ${index}: scenario must be one sentence of 1..${FINDING_LIMITS.scenario} characters` };
-        findings.push({ severity, file, line, scenario });
-    }
-    return { ok: true, findings };
+    const read = readBuildFindings(parsed);
+    if (!read.ok)
+        return { ok: false, problem: read.issues.map(issue => issue.line).join("; ") };
+    return { ok: true, findings: read.value.findings };
 }

package/dist/scope.d.ts

@@ -1,4 +1,7 @@
+export { ACCEPTANCE_LIMITS, EVIDENCE_KINDS, type EvidenceKind } from "./contracts/acceptance-terms.js";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { type EvidenceKind } from "./contracts/acceptance-terms.js";
+import { type AcceptanceCriterion, type AcceptanceProblem, type ScopeTerms } from "./contracts/scope.js";
 import type { Store, Mutation } from "./store.js";
 import type { QualityMode } from "./quality.js";
 import type { AuthMode } from "./keys.js";
@@ -176,40 +179,14 @@ export declare function exactKeys(value: object, required: readonly string[], op
 /** Strict re-hydration of a stored snapshot — every field type-proved;
  * anything unexpected is null, never a guess. */
 export declare function profileFromJson(json: string | null): ExecutionProfile | null;
-export type EvidenceKind = "check" | "screenshot" | "changed-path" | "manual-review";
-export declare const EVIDENCE_KINDS: readonly EvidenceKind[];
-export type AcceptanceCriterion = {
-    id: string;
-    /** The signed outcome statement. Restating it differently in a proof is
-     * refuted, not short — the same severity as any other altered term. */
-    statement: string;
-    /** Advisory guidance for HOW to satisfy the statement. Never enters the
-     * digest and is never a term the approval binds — an operator can leave
-     * it, change it, or ignore it without touching what was signed. */
-    how: string | null;
-    /** SIGNED: the evidence kinds a proof must reference, by exact id, to
-     * answer this criterion. Never empty. */
-    evidence: EvidenceKind[];
-};
-export declare const ACCEPTANCE_LIMITS: {
-    readonly criteria: 12;
-    readonly id: 40;
-    readonly statement: 1000;
-    readonly how: 500;
-    readonly evidenceKinds: number;
-};
-export type AcceptanceProblem = {
-    reason: string;
-    message: string;
-};
+export type { AcceptanceCriterion, AcceptanceProblem };
 /**
  * Parse a rubric from already-JSON-parsed input (the planner's handoff, a
  * console form, a routine or template definition): fail closed, every
- * problem reported at once, stable reasons — the same discipline as every
- * other quoted-data parser in this codebase (`plan.ts`, `proof.ts`). An
- * absent or empty `value` parses to `[]` with no problems: whether that is
- * ALLOWED is a question for the caller (`propose` says yes; every authoring
- * road says no), never for this parser.
+ * problem reported at once, each naming its path — the acceptance contract
+ * (contracts/scope.ts) reads it. An absent or empty `value` parses to `[]`
+ * with no problems: whether that is ALLOWED is a question for the caller
+ * (`propose` says yes; every authoring road says no), never for this parser.
  */
 export declare function parseAcceptanceCriteria(value: unknown): {
     criteria: AcceptanceCriterion[];
@@ -257,19 +234,20 @@ export declare function canonicalAcceptance(criteria: readonly AcceptanceCriteri
     statement: string;
     evidence: EvidenceKind[];
 }[];
-export type Scope = {
+/**
+ * A scope's terms, from the scope contract (contracts/scope.ts): what
+ * success looks like in the operator's words (`goal`), what the task is
+ * explicitly not allowed to turn into (`outOfScope`), the paths it expects
+ * to touch (advisory, and worth stating), and the signed acceptance rubric
+ * — `[]` on every scope proposed before v39 and on any legacy road that
+ * still calls `propose` directly: a scope-producing ROAD enforces
+ * non-emptiness, never this type, never `propose`, never the digest.
+ */
+export type SavedScopeTerms = {
+    [K in keyof ScopeTerms]-?: Exclude<ScopeTerms[K], undefined>;
+};
+export type Scope = SavedScopeTerms & {
     taskId: string;
-    /** What success looks like, in the operator's words. */
-    goal: string;
-    /** What this task is explicitly not allowed to turn into. */
-    outOfScope: string | null;
-    /** Paths the work is expected to touch. Advisory, and worth stating. */
-    touches: string[];
-    /** v39: the signed acceptance rubric. `[]` on every scope proposed before
-     * this migration and on any legacy road that still calls `propose`
-     * directly — a scope-producing ROAD enforces non-emptiness, never this
-     * type, never `propose`, never the digest. */
-    acceptance: AcceptanceCriterion[];
     /** v41: evidence policy, signed with the scope. Default is omitted from
      * the digest so every pre-v41 approval remains byte-for-byte valid. */
     qualityMode?: QualityMode;

package/dist/scope.js

@@ -1,3 +1,5 @@
+// The rubric's vocabulary loads before anything that reaches the plan contract (see contracts/acceptance-terms.ts).
+export { ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./contracts/acceptance-terms.js";
 import { passwordGuardOf } from "./sign-in-guard.js";
 import { validateScopeText } from "./task-text.js";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -29,9 +31,11 @@ import { claimActor, currentActor, parseLeadToken } from "./actor.js";
  * glance is the whole safety property.
  */
 import { createHash, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
-import { hasForbiddenControls } from "./decision.js";
-import { TEXT_LIMITS } from "./text-limits.js";
-import { NO_READINESS, exactModelId, isRiskLevel, legOf, projectRoute, routeDigestOf, routeFromJson, routeWords, } from "./phase-routing.js";
+import { z } from "zod";
+import {} from "./contracts/acceptance-terms.js";
+import { parseContract } from "./contracts/contract.js";
+import { readAcceptance, readScopeTerms, storedRubricSchema } from "./contracts/scope.js";
+import { NO_READINESS, exactModelId, isRiskLevel, legOf, projectRoute, routeDigestOf, routeFromJson, routeJsonProblem, routeWords, } from "./phase-routing.js";
 /** Same shape as a runner's credential, for the same reasons. */
 function mintToken() {
     return randomBytes(32).toString("base64url");
@@ -248,13 +252,18 @@ export function exactAcceptance(value) {
     }
     if (!Array.isArray(parsed))
         return { ok: false, problem: "the rubric is not a JSON list" };
-    for (const [index, entry] of parsed.entries()) {
-        if (entry === null || typeof entry !== "object" || Array.isArray(entry))
-            return { ok: false, problem: `rubric entry ${index + 1} is not an object` };
-        if (!exactKeys(entry, ["id", "statement", "evidence"], ["how"]))
-            return { ok: false, problem: `rubric entry ${index + 1} carries a key this code never writes` };
+    // Stored, a criterion carries exactly the keys this code writes: the saved rubric schema is strict about them.
+    const strict = parseContract(z.object({ acceptance: storedRubricSchema }), { acceptance: parsed });
+    for (const issue of strict.ok ? [] : strict.issues) {
+        const entry = /^acceptance\[(\d+)\]$/.exec(issue.path);
+        if (entry === null)
+            continue;
+        if (issue.kind === "wrong-type" || issue.kind === "required")
+            return { ok: false, problem: `rubric entry ${Number(entry[1]) + 1} is not an object` };
+        if (issue.kind === "unknown-key")
+            return { ok: false, problem: `rubric entry ${Number(entry[1]) + 1} carries a key this code never writes` };
     }
-    const read = parseAcceptanceCriteria(parsed);
+    const read = readAcceptance(parsed);
     if (read.problems.length > 0)
         return { ok: false, problem: `the rubric does not parse: ${read.problems.map(one => one.message).join("; ")}` };
     return { ok: true, criteria: read.criteria };
@@ -397,126 +406,28 @@ export function profileFromJson(json) {
     }
     return null;
 }
-export const EVIDENCE_KINDS = ["check", "screenshot", "changed-path", "manual-review"];
-export const ACCEPTANCE_LIMITS = {
-    criteria: 12,
-    id: TEXT_LIMITS.acceptanceIdBytes,
-    // A statement is one testable outcome; three hundred bytes forced people to
-    // drop the qualifying clause that made it testable.
-    statement: TEXT_LIMITS.acceptanceStatementBytes,
-    how: TEXT_LIMITS.acceptanceHowBytes,
-    evidenceKinds: EVIDENCE_KINDS.length,
-};
-function acceptanceDescribe(value) {
-    if (value === undefined)
-        return "nothing";
-    if (value === null)
-        return "null";
-    if (typeof value === "string")
-        return `a ${value.length}-char string`;
-    return `a ${Array.isArray(value) ? "array" : typeof value}`;
-}
-function acceptanceProse(value, field, cap, required, problems) {
-    if (value === undefined || value === null || value === "") {
-        if (required)
-            problems.push({ reason: `missing-${field}`, message: `${field} is required` });
-        return null;
-    }
-    if (typeof value !== "string") {
-        problems.push({ reason: `bad-${field}`, message: `${field} must be a string (got ${acceptanceDescribe(value)})` });
-        return null;
-    }
-    if (Buffer.byteLength(value, "utf8") > cap) {
-        problems.push({ reason: `${field}-too-long`, message: `${field} is over ${cap} bytes` });
-        return null;
-    }
-    if (hasForbiddenControls(value)) {
-        problems.push({ reason: `${field}-controls`, message: `${field} carries control characters that could become terminal escapes` });
-        return null;
-    }
-    return value;
-}
 /**
  * Parse a rubric from already-JSON-parsed input (the planner's handoff, a
  * console form, a routine or template definition): fail closed, every
- * problem reported at once, stable reasons — the same discipline as every
- * other quoted-data parser in this codebase (`plan.ts`, `proof.ts`). An
- * absent or empty `value` parses to `[]` with no problems: whether that is
- * ALLOWED is a question for the caller (`propose` says yes; every authoring
- * road says no), never for this parser.
+ * problem reported at once, each naming its path — the acceptance contract
+ * (contracts/scope.ts) reads it. An absent or empty `value` parses to `[]`
+ * with no problems: whether that is ALLOWED is a question for the caller
+ * (`propose` says yes; every authoring road says no), never for this parser.
  */
 export function parseAcceptanceCriteria(value) {
-    const problems = [];
-    if (value === undefined || value === null)
-        return { criteria: [], problems };
-    if (!Array.isArray(value)) {
-        problems.push({ reason: "bad-acceptance", message: `acceptance must be an array (got ${acceptanceDescribe(value)})` });
-        return { criteria: [], problems };
-    }
-    if (value.length > ACCEPTANCE_LIMITS.criteria) {
-        problems.push({ reason: "acceptance-too-many", message: `acceptance lists ${value.length} — cap is ${ACCEPTANCE_LIMITS.criteria}` });
-        return { criteria: [], problems };
-    }
-    const criteria = [];
-    const seen = new Set();
-    for (const [index, entry] of value.entries()) {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-            problems.push({ reason: `acceptance[${index}]-shape`, message: `acceptance[${index}] must be an object` });
-            continue;
-        }
-        const one = entry;
-        const id = acceptanceProse(one["id"], `acceptance[${index}].id`, ACCEPTANCE_LIMITS.id, true, problems);
-        if (id !== null && seen.has(id)) {
-            problems.push({ reason: `acceptance[${index}]-duplicate-id`, message: `criterion id "${id}" appears twice` });
-        }
-        else if (id !== null) {
-            seen.add(id);
-        }
-        const statement = acceptanceProse(one["statement"], `acceptance[${index}].statement`, ACCEPTANCE_LIMITS.statement, true, problems);
-        const how = acceptanceProse(one["how"], `acceptance[${index}].how`, ACCEPTANCE_LIMITS.how, false, problems);
-        const rawEvidence = one["evidence"];
-        let evidence = null;
-        if (!Array.isArray(rawEvidence)) {
-            problems.push({
-                reason: `acceptance[${index}]-bad-evidence`,
-                message: `acceptance[${index}].evidence must be a non-empty array of evidence kinds (got ${acceptanceDescribe(rawEvidence)})`,
-            });
-        }
-        else if (rawEvidence.length === 0 || rawEvidence.length > ACCEPTANCE_LIMITS.evidenceKinds) {
-            problems.push({
-                reason: `acceptance[${index}]-evidence-count`,
-                message: `acceptance[${index}].evidence must name 1-${ACCEPTANCE_LIMITS.evidenceKinds} evidence kinds`,
-            });
-        }
-        else {
-            const kinds = [];
-            const seenKinds = new Set();
-            let bad = false;
-            for (const k of rawEvidence) {
-                if (typeof k !== "string" || !EVIDENCE_KINDS.includes(k)) {
-                    problems.push({
-                        reason: `acceptance[${index}]-bad-evidence-kind`,
-                        message: `acceptance[${index}].evidence must draw from ${EVIDENCE_KINDS.join(", ")} (got ${acceptanceDescribe(k)})`,
-                    });
-                    bad = true;
-                    continue;
-                }
-                if (seenKinds.has(k)) {
-                    problems.push({ reason: `acceptance[${index}]-duplicate-evidence-kind`, message: `evidence kind "${k}" appears twice` });
-                    bad = true;
-                    continue;
-                }
-                seenKinds.add(k);
-                kinds.push(k);
-            }
-            if (!bad)
-                evidence = kinds;
-        }
-        if (id === null || statement === null || evidence === null)
-            continue;
-        criteria.push({ id, statement, how, evidence });
-    }
-    return { criteria, problems };
+    const read = readAcceptance(value);
+    // Keep the prose shape plan.ts's existing acceptanceLine consumes. Validation stays in the contract; only this
+    // compatibility boundary formats messages. That mapping takes a field followed by a space, not a colon, and
+    // evidence-array indices belong in the detail because it recognizes only the criterion's index.
+    return {
+        ...read,
+        problems: read.problems.map(problem => ({
+            ...problem,
+            message: problem.message
+                .replace(/^(acceptance\[\d+\]\.evidence)\[(\d+)\]: /, (_, path, index) => `${path} entry ${Number(index) + 1}: `)
+                .replace(/^(acceptance(?:\[\d+\])?(?:\.[A-Za-z]+)?): /, "$1 "),
+        })),
+    };
 }
 /** The exact bytes a rubric's SIGNED terms reduce to for the digest: sorted
  * by id, `how` dropped (advisory, never signed), evidence kinds sorted so
@@ -710,15 +621,18 @@ export function propose(store, input) {
  */
 export function proposeGuarded(store, input) {
     const touches = [...(input.touches ?? [])].map(one => one.trim()).filter(one => one !== "");
+    // Plain words first for what a person typed (lengths, bytes, hidden text), then the scope contract.
     const badText = validateScopeText({ goal: input.goal, outOfScope: input.outOfScope ?? null, touches });
     if (badText !== null)
         return badText;
     const goal = input.goal.trim();
     const outOfScope = input.outOfScope?.trim() || null;
-    const acceptanceParse = parseAcceptanceCriteria(input.acceptance);
-    if (acceptanceParse.problems.length > 0) {
-        return { ok: false, reason: "bad-acceptance" };
+    const terms = readScopeTerms({ goal, outOfScope, touches, acceptance: input.acceptance });
+    if (!terms.ok) {
+        const reason = terms.field === "acceptance" ? "bad-acceptance" : terms.field === "touches" ? "bad-touches" : terms.field === "outOfScope" ? "bad-out-of-scope" : "bad-goal";
+        return { ok: false, reason, message: terms.problems.map(one => one.message).join("; ") };
     }
+    const acceptanceParse = { criteria: terms.terms.acceptance };
     if (acceptanceParse.criteria.length === 0) {
         return { ok: false, reason: "acceptance-required" };
     }
@@ -1070,7 +984,7 @@ export function scopeAuthorityOf(scope, env = {}) {
     const routeJson = scope.proposedRouteJson ?? null;
     const route = routeFromJson(routeJson);
     if (route === null) {
-        return { ok: false, reason: "route", problem: routeJson === null ? "the scope was filed under agent routing but carries no route" : "the scope's agent route cannot be read exactly" };
+        return { ok: false, reason: "route", problem: routeJson === null ? "the scope was filed under agent routing but carries no route" : `the scope's agent route cannot be read exactly (${routeJsonProblem(routeJson)})` };
     }
     const parity = routeParityProblem(route, profile, { riskLevel: scope.riskLevel ?? "routine", qualityMode: scope.qualityMode ?? "default" });
     if (parity !== null)

package/dist/scout-report.d.ts

@@ -1,44 +1,14 @@
 /**
- * The scout's terminal handoff (mate arc §10), parsed with the 422 rule:
- * fail closed, every problem reported at once, stable reasons, caps and
- * control-character rejection on every string. A report reaches the task
- * page, the ledger, the terminal, and — through mateView — the mate; and
- * each follow-up becomes a filing's title and goal at one tap, so it gets
- * the park discipline exactly as the plan does.
+ * The scout's terminal handoff (mate arc §10), read against the report contract (src/contracts/scout-report.ts) with
+ * the 422 rule: fail closed, every problem reported at once, each naming its path (`items[0].url: must be an http or
+ * https address`), stable reasons, caps and control-character rejection on every string. A report reaches the task
+ * page, the ledger, the terminal, and — through mateView — the mate; and each follow-up becomes a filing's title and
+ * goal at one tap, so it gets the park discipline exactly as the plan does.
  */
-export type ReportProblem = {
-    reason: string;
-    message: string;
-};
-export type ParsedReport = {
-    title: string;
-    summary: string;
-    /** The report document, markdown, rendered fenced-inert everywhere. */
-    report: string;
-    /** Proposed follow-ups: each files as a task in the same repository. */
-    followUps: {
-        title: string;
-        goal: string;
-    }[];
-    /** What the scout found, as a short list later steps can read: each cites its URL, and may show one of `images`. */
-    items: ReportItem[];
-    /** Screenshots the scout saved during the run. From the scout, `file` names a file in its output folder; once
-     * stored, the runner adds the bytes' sha256 and the evidence row that holds them. */
-    images: ReportImage[];
-};
-export type ReportItem = {
-    title: string;
-    why: string;
-    url: string;
-    image: string | null;
-};
-export type ReportImage = {
-    file: string;
-    caption: string;
-    url: string;
-    sha256?: string;
-    artifact?: number;
-};
+import { type ContractProblem } from "./contracts/contract.js";
+import { type ParsedReport } from "./contracts/scout-report.js";
+export { REPORT_IMAGE_FILE, REPORT_LIMITS, REPORT_VERSION, SCOUT_OUTPUT_JSON_SCHEMA, type ParsedReport, type ReportImage, type ReportItem, } from "./contracts/scout-report.js";
+export type ReportProblem = ContractProblem;
 export type ReportParseResult = {
     ok: true;
     report: ParsedReport;
@@ -46,161 +16,6 @@ export type ReportParseResult = {
     ok: false;
     problems: ReportProblem[];
 };
-/** Caps are BYTES of UTF-8 (v4 review, finding 11): a 64 KiB report is
- * 64 KiB whatever script it is written in. They hold what a scout writes;
- * a stored report is read without them (parseReport's `stored`). */
-export declare const REPORT_LIMITS: {
-    readonly payload: number;
-    readonly title: 200;
-    readonly summary: 2500;
-    readonly document: number;
-    readonly followUps: 5;
-    readonly followUpTitle: 200;
-    /** A follow-up files as a task: its goal is held to the task goal limit, in bytes of the same count. */
-    readonly followUpGoal: 8000;
-    readonly items: 6;
-    readonly itemTitle: 200;
-    readonly itemWhy: 1000;
-    readonly url: 2000;
-    readonly images: 8;
-    readonly caption: 300;
-};
-/** A screenshot's name in the scout's output folder: one plain file name, PNG or JPEG, never a path. */
-export declare const REPORT_IMAGE_FILE: RegExp;
-/**
- * The scout's handback for Claude's `--json-schema` (run 2334's fix): plan
- * mode only lets a session write its own plan file, so a Claude scout
- * returns a report — or a question for the operator — as structured output
- * on the terminal result event. Shape only, never the validator: byte caps,
- * one-line titles and control characters stay `parseReport`'s and
- * `parseDecision`'s, applied to the re-serialized body.
- */
-export declare const SCOUT_OUTPUT_JSON_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly kind: {
-            readonly type: "string";
-            readonly enum: readonly ["report", "question"];
-        };
-        readonly report: {
-            readonly type: "object";
-            readonly properties: {
-                readonly title: {
-                    readonly type: "string";
-                };
-                readonly summary: {
-                    readonly type: "string";
-                };
-                readonly report: {
-                    readonly type: "string";
-                };
-                readonly followUps: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly title: {
-                                readonly type: "string";
-                            };
-                            readonly goal: {
-                                readonly type: "string";
-                            };
-                        };
-                        readonly required: readonly ["title", "goal"];
-                        readonly additionalProperties: false;
-                    };
-                };
-                readonly items: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly title: {
-                                readonly type: "string";
-                            };
-                            readonly why: {
-                                readonly type: "string";
-                            };
-                            readonly url: {
-                                readonly type: "string";
-                            };
-                            readonly image: {
-                                readonly type: "string";
-                            };
-                        };
-                        readonly required: readonly ["title", "why", "url"];
-                        readonly additionalProperties: false;
-                    };
-                };
-                readonly images: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly file: {
-                                readonly type: "string";
-                            };
-                            readonly caption: {
-                                readonly type: "string";
-                            };
-                            readonly url: {
-                                readonly type: "string";
-                            };
-                        };
-                        readonly required: readonly ["file", "caption", "url"];
-                        readonly additionalProperties: false;
-                    };
-                };
-            };
-            readonly required: readonly ["title", "summary", "report"];
-            readonly additionalProperties: false;
-        };
-        readonly decision: {
-            readonly type: "object";
-            readonly properties: {
-                readonly urgency: {
-                    readonly type: "string";
-                    readonly enum: readonly ["blocking"];
-                };
-                readonly recap: {
-                    readonly type: "string";
-                };
-                readonly question: {
-                    readonly type: "string";
-                };
-                readonly options: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly id: {
-                                readonly type: "string";
-                            };
-                            readonly label: {
-                                readonly type: "string";
-                            };
-                            readonly consequence: {
-                                readonly type: "string";
-                            };
-                            readonly reversible: {
-                                readonly type: "boolean";
-                            };
-                        };
-                        readonly required: readonly ["id", "label", "consequence", "reversible"];
-                        readonly additionalProperties: false;
-                    };
-                };
-                readonly recommendation: {
-                    readonly type: "string";
-                };
-            };
-            readonly required: readonly ["urgency", "recap", "question", "options", "recommendation"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly required: readonly ["kind"];
-    readonly additionalProperties: false;
-};
 /** A report, checked. `stored`: one already kept as evidence, read without the length caps (a report written under
  * higher limits stays readable); every other check still holds. */
 export declare function parseReport(raw: string, options?: {