toolroll 0.9.103 → 0.9.105

package/dist/proof.js

@@ -1,28 +1,7 @@
-/**
- * The build's own claim, adjudicated against evidence the plane captured
- * itself (`docs/PRIORITIES.md` Priority 2). Modelled line-for-line on the
- * scout's report (`scout-report.ts`): fail closed, every problem reported at
- * once, stable reasons, byte caps, control-character rejection on every
- * string.
- *
- * The proof is a distinct deliverable from the terminal handoff every
- * attempt writes (including `failed` ones, whose lists are deliberately
- * compacted prose) — only a `completed` attempt owes one, and the plane
- * judges it. A missing or malformed proof never fails the attempt or
- * touches the commit; it only keeps the verdict off "verified".
- *
- * `adjudicate` is pure and does no I/O: every fact it reasons over — whether
- * the proof artifact exists, whether the handoff and terminal diff exist,
- * what the sealed diff-stat says, whether a screenshot's bytes actually are
- * a PNG or JPEG, whether an approved verification command ran and what it
- * returned — is gathered by the caller (`builder.ts`) and handed in as data,
- * so the review itself stays testable without a filesystem or a database.
- */
 import { hasForbiddenControls } from "./decision.js";
 import { contractProblemOf } from "./contracts/contract.js";
 import { PROOF_LIMITS, proofPayloadBody, readProofPayload } from "./contracts/proof.js";
 export { PROOF_LIMITS } from "./contracts/proof.js";
-/** Shared by preflight and final adjudication; presentation text is never a rubric. */
 function criterionContractProblems(approved, answer) {
     if (answer === undefined)
         return [{ kind: "missing", message: `the proof does not answer approved criterion "${approved.id}"` }];
@@ -37,7 +16,6 @@ function criterionContractProblems(approved, answer) {
     }
     return problems;
 }
-/** Only submission defects. A truthful not-met answer is not malformed. */
 export function proofSubmissionProblems(proof, rubric) {
     const answers = new Map(proof.criteria.map(one => [one.id, one]));
     const problems = rubric.flatMap(one => criterionContractProblems(one, answers.get(one.id)).map(problem => problem.message));
@@ -62,7 +40,6 @@ export function proofSubmissionProblems(proof, rubric) {
 function refuse(reason, message) {
     return { ok: false, problems: [{ reason, message }] };
 }
-/** Every text field of a proof body (version 2 shape) that the schema saw as a string. */
 function textFields(body) {
     const out = [];
     const text = (path, value, bytes, relative) => {
@@ -100,12 +77,6 @@ function textFields(body) {
     }
     return out;
 }
-/**
- * The rules JSON Schema cannot state, in plain code with path-named errors: blank text, UTF-8 byte limits, control
- * characters, normalized repository-relative screenshot paths (no leading slash, `.`/`..` segment or backslash — the
- * shape `readVerifiedArtifact` enforces on an evidence key), and unique criterion ids and screenshot paths. A field
- * the schema already refused is not reported twice.
- */
 function proofRuleProblems(body, contract) {
     const named = (path) => contract.some(problem => problem.message.startsWith(`${path}:`));
     const problems = [];
@@ -141,11 +112,6 @@ function proofRuleProblems(body, contract) {
     unique("screenshots", "path", "screenshot path");
     return problems;
 }
-/**
- * Read a proof: the payload byte cap and JSON first, then the proof schema (version 2 as itself, the version 1 a
- * builder writes upgraded, a newer one refused plainly), then the plain-code rules. Every problem names its path and
- * is reported at once; fail closed.
- */
 export function parseProof(raw) {
     if (Buffer.byteLength(raw, "utf8") > PROOF_LIMITS.payload) {
         return refuse("too-large", `payload: over ${PROOF_LIMITS.payload.toLocaleString("en-US")} bytes`);
@@ -169,8 +135,6 @@ export function parseProof(raw) {
         return { ok: false, problems };
     return { ok: true, proof: read.value };
 }
-/** Serialize the validated shape, never the agent's raw bytes (the scout report's rule, `scout.ts`): what is stored
- * and later hash-verified is exactly what the schema admitted, in its key order. */
 export function serializeProof(proof) {
     return JSON.stringify(proof, null, 2);
 }
@@ -178,10 +142,6 @@ function caveatNames(caveat, id) {
     const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     return new RegExp(`(^|[^\\p{L}\\p{N}_-])${escaped}(?![\\p{L}\\p{N}_-])`, "u").test(caveat);
 }
-/** Every (caveat, criterion) pair where the caveat names a criterion the
- * proof marks `met` — the proof contradicts itself and cannot verify. In
- * caveat order, then criterion order; `[]` for a proof at peace with its
- * own caveats. */
 export function blockingCaveats(proof) {
     const met = proof.criteria.filter(one => one.verdict === "met" || one.verdict === "pending-verification");
     const out = [];
@@ -192,17 +152,6 @@ export function blockingCaveats(proof) {
     });
     return out;
 }
-/**
- * Every check a criterion marked `met` cites that the proof's own `checks`
- * list says exited nonzero (proof preflight closure): a met criterion
- * resting on a failing command is not evidence, it is a contradiction the
- * adjudicator fails the row for. A not-met or not-checked criterion may
- * cite a failed check honestly — it is reporting, not claiming — so only
- * `met` and `pending-verification` count here: pending asserts the agent's
- * own checks already passed. A ref that resolves to no check is a different
- * problem (an unresolved ref), not this one. In criterion order, then
- * evidence order.
- */
 export function failedMetChecks(proof) {
     const checksByCommand = new Map(proof.checks.map(c => [c.command, c]));
     const out = [];
@@ -219,16 +168,9 @@ export function failedMetChecks(proof) {
     }
     return out;
 }
-/** The one actionable fact a failed check citation is reported as — the
- * adjudicator's matrix detail and the agent's exit preflight say exactly
- * this, so what the preflight refuses is what the plane would have said. */
 export function failedCheckWords(one) {
     return `criterion "${one.criterionId}"'s check "${one.ref}" exited ${one.exitCode}`;
 }
-/** The leading tag list of a caveat — `c1: …`, `c1, c4: …`, `(c2) …` — as
- * the tokens it names before its first colon or after its parentheses.
- * A caveat with no such prefix has no tags; its attribution rests on any
- * known id appearing as a standalone token anywhere in it. */
 function leadingTags(caveat) {
     const separator = String.raw `(?:\s*[,/&+]\s*(?:and\s+)?|\s+and\s+)`;
     const prefixed = new RegExp(String.raw `^\s*\(?\s*([\p{L}\p{N}_-]+(?:${separator}[\p{L}\p{N}_-]+)*)\s*\)?\s*:`, "u").exec(caveat);
@@ -252,8 +194,6 @@ export function caveatAttributionProblems(proof, signedIds = []) {
     });
     return out;
 }
-/** The words one attribution problem refuses in — shared by the plane's
- * adjudication and the agent's exit preflight so both say the same thing. */
 export function caveatAttributionWords(problem) {
     if (problem.kind !== "unknown") {
         return `caveat ${problem.index + 1} names no criterion — every caveat is an exception to exactly one signed criterion, named by its exact id (an unrelated idea belongs in the handoff's follow-ups): ${problem.caveat}`;
@@ -264,9 +204,6 @@ export function caveatAttributionWords(problem) {
         ? `caveat ${problem.index + 1} names ${quoted}, a criterion the proof authored for itself that nobody signed — a proof-only id is no signed authority; every caveat names a signed criterion's exact id: ${problem.caveat}`
         : `caveat ${problem.index + 1} names ${quoted}, which is no signed or answered criterion — every caveat names an exact criterion id: ${problem.caveat}`;
 }
-/** v39: the floor a criterion's screenshot evidence must clear — "real,
- * not placeholder-sized" in exact numbers (scope: "meaningful byte size
- * and at least 320 by 200 dimensions"). */
 export const SCREENSHOT_EVIDENCE_MIN_BYTES = 1024;
 export const SCREENSHOT_EVIDENCE_MIN_WIDTH = 320;
 export const SCREENSHOT_EVIDENCE_MIN_HEIGHT = 200;
@@ -295,13 +232,6 @@ export function changedListProblems(changed, stat) {
     const sealed = [...stat.paths].sort();
     return { problems, recoverable: problems.length > 0 && !unexplained, sealed };
 }
-/** What a receipt-only correction may never touch: the exact criterion
- * id/verdict pairs the agent submitted (comment 397, run 1648). A
- * correction restates a signed statement or repairs an evidence reference
- * against the exact rubric; it cannot move an answer (not-met or
- * not-checked becoming pending-verification, or any other change of
- * word), drop a criterion — an extra negative answer is a finding, not a
- * formatting defect — or add one. One line per frozen pair broken. */
 export function frozenCriterionProblems(submitted, corrected) {
     const problems = [];
     const after = new Map(corrected.criteria.map(one => [one.id, one.verdict]));
@@ -321,11 +251,6 @@ export function frozenCriterionProblems(submitted, corrected) {
     }
     return problems;
 }
-/** Whether two readings of the sealed diff-stat state the same facts:
- * the same capture standing, the same paths and the same rename
- * provenance. Settlement reads the stat once before the receipt
- * correction and re-reads it after that correction and after the final
- * gate; a reading that differs is never adjudicated from the cached one. */
 export function sameDiffStatFacts(a, b) {
     if (a === null || b === null)
         return a === b;
@@ -338,28 +263,19 @@ export function sameDiffStatFacts(a, b) {
     return restate(a) === restate(b);
 }
 export const GOAL_ASSESSMENT_PENDING = "The saved evidence is awaiting independent goal assessment.";
-/** Legacy folds could only lower a verdict. Direct assessment also records an
- * ordinary wait between green machine checks and the goal judgement. */
 export function reviewConflict(matrix, machine, verdict) {
     return matrix.some(row => row.assessment !== undefined) ? matrix.some(row => row.review?.judgement === "contradicts")
         : machine !== null && machine !== verdict;
 }
-/** Human sign-off is owed, with no other recorded evidence failure. This is
- * presentation only; it never changes a verdict or grants acceptance. */
 export function manualReviewOnly(proof) {
     return proof?.verdict === "short" && (proof.matrix === undefined || (proof.matrix.some(row => row.state === "manual-review")
         && proof.matrix.every(row => row.state === "pass" || row.state === "manual-review")))
         && proof.reasons.length > 0
         && proof.reasons.every(reason => manualReviewCriterionOf(reason) !== null);
 }
-/** The criterion id a stored "needs a person's check" reason names, or null
- * for any other reason. The stored words stay as recorded; pages say them
- * through `personCheckWords`. */
 export function manualReviewCriterionOf(reason) {
     return /^criterion "([^"]+)" requires manual-review evidence — an operator must accept it before this can verify$/.exec(reason)?.[1] ?? null;
 }
-/** A stored verification reason as a person would say it, for pages and
- * cards. The record keeps its exact words; unknown reasons pass through. */
 export function plainReasonWords(reason) {
     if (manualReviewCriterionOf(reason) !== null)
         return "A requirement needs your own check.";
@@ -376,11 +292,8 @@ export function plainReasonWords(reason) {
     }
     return reason;
 }
-/** The kinds a requirement is shown by, in a few words. */
 const KIND_WORDS = { check: "the project check", screenshot: "a screenshot", "changed-path": "the changed files", "manual-review": "your own check" };
 const kindWords = (kind) => KIND_WORDS[kind ?? ""] ?? kind ?? "";
-/** Toolroll's own verification reasons as a person reads them (the one mapper over this file's strings; the record
- * keeps the exact words, and anything not listed passes through as written). */
 const REASON_WORDS = [
     [/^the proof does not answer approved criterion "([^"]+)"$/, m => `The agent didn't answer requirement ${m[1]}.`],
     [/^criterion "([^"]+)" was signed as "([\s\S]*)" and the proof restates it as "([\s\S]*)"$/, m => `The agent restated requirement ${m[1]} as "${m[3]}" (approved as "${m[2]}").`],
@@ -396,14 +309,10 @@ const REASON_WORDS = [
     [/^the sealed diff is unavailable or truncated; ([\s\S]*)$/, () => "The saved diff is missing or cut short, so the change can't be checked."],
     [/^the repository's approved verification command exited (-?\d+)$/, m => `The project check exited ${m[1]}.`],
 ];
-/** A requirement only a person can confirm, as a person would say it. */
 export function personCheckWords(statement) {
     const plain = statement?.trim() ?? "";
     return plain === "" ? "You check this one yourself." : `You check this one: ${plain}`;
 }
-/** Set equality, exactly — the "must equal the complete sealed git diff
- * exactly" rule (v39) needs both directions, unlike the legacy subset
- * check. */
 function setEquals(a, b) {
     if (a.size !== b.size)
         return false;
@@ -412,14 +321,6 @@ function setEquals(a, b) {
             return false;
     return true;
 }
-/**
- * The criterion-to-evidence matrix, computed once and shared by every
- * surface (v39) — best-effort from whatever is available: `proof` is null
- * when no proof parsed at all, in which case every approved criterion is
- * simply unanswered. `[]` whenever no rubric was signed, so a
- * grandfathered run renders no matrix at all rather than a wall of
- * "missing" rows nobody signed up for.
- */
 function criterionMatrix(approvedCriteria, proof, diffStat, screenshots) {
     if (approvedCriteria.length === 0)
         return [];
@@ -427,8 +328,6 @@ function criterionMatrix(approvedCriteria, proof, diffStat, screenshots) {
     const screenshotsByPath = new Map(screenshots.map(s => [s.path, s]));
     const checksByCommand = new Map((proof?.checks ?? []).map(c => [c.command, c]));
     const changedSet = new Set(proof?.changed ?? []);
-    // null = cannot know either way (diff unavailable or truncated) — never
-    // treated as agreement, per "an unavailable or truncated diff cannot verify".
     const diffExact = diffStat !== null && diffStat.captured && !diffStat.truncated ? setEquals(changedSet, diffStat.paths) : null;
     return approvedCriteria.map((approved) => {
         const base = { id: approved.id, statement: approved.statement, requiredEvidence: approved.evidence, review: null };
@@ -449,14 +348,10 @@ function criterionMatrix(approvedCriteria, proof, diffStat, screenshots) {
         let anyMissing = false;
         let anyFailed = false;
         let anyManual = false;
-        // Only adjudicate's trusted successful final check resolves this state.
-        // Until then the shared row must not misleadingly read as passed.
         if (answer.verdict === "pending-verification") {
             anyMissing = true;
             detail.push(`criterion "${approved.id}" is waiting for the final check`);
         }
-        // The proof's own caveats outrank its verdict word: a criterion marked
-        // `met` that a caveat names is not met by the proof's own admission.
         for (const blocking of proof === null ? [] : blockingCaveats(proof)) {
             if (blocking.criterionId !== approved.id)
                 continue;
@@ -502,7 +397,6 @@ function criterionMatrix(approvedCriteria, proof, diffStat, screenshots) {
                 }
                 continue;
             }
-            // changed-path
             if (!changedSet.has(ref.ref)) {
                 anyFailed = true;
                 detail.push(`criterion "${approved.id}"'s changed-path evidence "${ref.ref}" is not among the proof's claimed changed paths`);
@@ -518,8 +412,6 @@ function criterionMatrix(approvedCriteria, proof, diffStat, screenshots) {
         return { ...base, state, detail, answered: answer.evidence };
     });
 }
-/** Evidence readiness only. The signed criteria are copied from the scope,
- * never restated by the builder; an independent assessment must settle them. */
 function assessCapturedEvidence(input) {
     const completeDiff = input.diffStat !== null && input.diffStat.captured && !input.diffStat.truncated;
     const check = input.verifyCommand;
@@ -565,8 +457,6 @@ function assessCapturedEvidence(input) {
                 }
             }
             else if (kind === "screenshot") {
-                // Screenshots must have been explicitly captured and validated, never
-                // guessed from arbitrary files or inferred from a passing test.
                 const shots = input.screenshots.filter(shot => shot.ok && (shot.bytes ?? 0) >= SCREENSHOT_EVIDENCE_MIN_BYTES &&
                     shot.dims != null && shot.dims.width >= SCREENSHOT_EVIDENCE_MIN_WIDTH && shot.dims.height >= SCREENSHOT_EVIDENCE_MIN_HEIGHT);
                 if (shots.length === 0) {
@@ -594,8 +484,6 @@ function assessCapturedEvidence(input) {
     return { machineVerdict, verdict: machineVerdict === "refuted" ? "refuted" : "short", matrix,
         reasons: problems.length > 0 ? problems : [GOAL_ASSESSMENT_PENDING] };
 }
-/** Only direct assessments can settle a pending goal. Machine failures and
- * required evidence remain authoritative; this never upgrades a legacy proof. */
 function foldGoalAssessment(base, judgements) {
     const byId = new Map(judgements.map(one => [one.id, one]));
     const matrix = base.matrix.map((row) => {
@@ -661,32 +549,6 @@ function verificationFailureWords(failure) {
         }
     })();
 }
-/**
- * Ordered rules; the first that fires wins. Every reason is a sentence the
- * surfaces print verbatim — this function is the only place that decides
- * wording, so the task page, run page, board, CLI, and chat cards cannot
- * drift from each other (Priority 2, the "one surface, six places" rule).
- *
- * v39: `input.approvedCriteria` empty runs the rules below byte for byte —
- * the grandfathering promise. Non-empty inserts the rubric rules AFTER the
- * diff-stat and verify-command rules and BEFORE the legacy unmet check,
- * exactly as approved in the v2 plan: a proof that alters a signed
- * criterion's statement is REFUTED (the same severity as any other
- * altered term); an unanswered criterion, an evidence reference that does
- * not resolve, or a criterion capped at manual-review is SHORT (a gap, or
- * a review a machine cannot finish, never a lie). The legacy self-declared
- * `verdict` field still runs afterward and can only downgrade further,
- * never upgrade past what the evidence proved.
- *
- * The changed[] vs. sealed-diff exactness check (review finding, post-v39)
- * runs GLOBALLY, ahead of the rubric rules and independent of whether any
- * criterion cites changed-path evidence at all — a rubric with none of
- * those must not let an untruthful or incomplete changed[] through
- * unchecked. An unavailable or truncated diff-stat cannot prove either
- * direction, so it can only ever produce SHORT, never REFUTED.
- */
-/** An optional screenshot inventory carries no builder-authored completion
- * claims. The existing bounded parser still validates every supplied field. */
 export function artifactManifestOnly(proof) {
     return proof.criteria.length === 0 && proof.checks.length === 0 && proof.changed.length === 0 && proof.caveats.length === 0;
 }
@@ -700,8 +562,6 @@ export function adjudicate(input) {
         if (input.reviewContext === undefined)
             return row;
         const found = coverageById.get(row.id);
-        // A criterion the inventory never covered is a gap the surfaces
-        // must show, never a silent "judged from the patch".
         const coverage = found === undefined
             ? { state: "gap", inherited: false, items: [], gaps: ["the sealed review context carries no coverage entry for this criterion"], priorSupport: "none" }
             : { state: found.state, inherited: found.inherited, items: [...found.items], gaps: [...found.gaps], priorSupport: found.priorSupport, ...(found.assets === undefined ? {} : { assets: found.assets }) };
@@ -719,10 +579,6 @@ export function adjudicate(input) {
     const submitted = input.proofParse.proof;
     const finalCheckPassed = input.verifyCommand.configured && input.verifyCommand.ran && input.verifyCommand.exitCode === 0;
     const pendingContractValid = proofSubmissionProblems(submitted, approvedCriteria).length === 0;
-    // Resolve only an explicit conditional claim, against THIS run's machine
-    // facts. Never infer intent from prose, modify the sealed receipt, or turn
-    // a genuine not-met/not-checked answer into success. All evidence, caveat,
-    // manual-review and artifact checks below still apply to the resolved copy.
     const proof = {
         ...submitted,
         criteria: submitted.criteria.map(one => one.verdict === "pending-verification" && finalCheckPassed && pendingContractValid &&
@@ -736,13 +592,6 @@ export function adjudicate(input) {
     if (!input.terminalDiffPresent || input.terminalDiffCaptureStatus === "failed") {
         return { verdict: "short", reasons: ["the machine-captured diff is missing or failed to capture"], matrix };
     }
-    // The claimed changed[] must equal the COMPLETE sealed diff exactly —
-    // globally, whether or not any signed criterion cites changed-path
-    // evidence at all (a rubric with none of those would otherwise let an
-    // untruthful or incomplete changed[] through unchecked). An unavailable
-    // or truncated stat cannot prove either direction, so it cannot verify:
-    // short, never refuted — "we could not check" is not "the claim is
-    // false" (the same ruling the verify-command facts make below).
     if (input.diffStat === null || !input.diffStat.captured || input.diffStat.truncated) {
         return {
             verdict: "short",
@@ -770,21 +619,12 @@ export function adjudicate(input) {
             };
         }
     }
-    // Altering a signed requirement is an integrity contradiction, not an
-    // evidence gap. It outranks an environment failure: an unavailable check
-    // must never downgrade changed authority from refuted to short.
     if (approvedCriteria.length > 0) {
         const restated = matrix.filter(row => row.detail.some(d => d.includes("was signed as")));
         if (restated.length > 0) {
             return { verdict: "refuted", reasons: restated.flatMap(row => row.detail), matrix };
         }
     }
-    // A proof whose caveat admits an exception to a criterion it marks met
-    // contradicts itself (atomic authority closure): the verdict must agree
-    // with the caveats, and a self-disagreeing proof is conflicting
-    // evidence — refuted, never verified, whether or not a rubric was
-    // signed. It ranks with the altered-statement rule above: an
-    // environment failure must never soften a contradiction to short.
     {
         const blocking = blockingCaveats(proof);
         if (blocking.length > 0) {
@@ -794,21 +634,11 @@ export function adjudicate(input) {
                 matrix,
             };
         }
-        // EVERY caveat is attributed (final authority closure): one that names
-        // no known criterion, or a tag nobody signed, is an exception the
-        // verdict cannot be reconciled with — the proof's own words do not
-        // say which criterion they qualify, and the plane refutes rather than
-        // guesses. Known ids are the signed rubric's alone when one was
-        // signed (a proof-authored extra id is no authority); the proof's own
-        // only when nothing was signed.
         const unattributed = caveatAttributionProblems(proof, approvedCriteria.map(one => one.id));
         if (unattributed.length > 0) {
             return { verdict: "refuted", reasons: unattributed.map(caveatAttributionWords), matrix };
         }
     }
-    // A command that could not exercise the product is missing evidence, not
-    // contradictory evidence. This precedes criterion-state checks so the
-    // actionable environment cause is never buried under a generic gap.
     if (input.verifyCommand.configured && !input.verifyCommand.ran) {
         const reason = verificationFailureWords(input.verifyCommand.failure);
         return { verdict: "short", reasons: [reason], matrix };
@@ -825,11 +655,6 @@ export function adjudicate(input) {
         };
     }
     if (approvedCriteria.length > 0) {
-        // manual-review folds in here too (v39 review finding): a row that
-        // needs a human's eyes is never machine-verifiable, so it must never
-        // reach "verified" or "attested" on its own — it stays "short" until
-        // an operator explicitly accepts the proof (the same act that already
-        // lets a short/refuted run read as done).
         const unresolved = matrix.filter(row => row.state === "missing" || row.state === "failed" || row.state === "manual-review");
         if (unresolved.length > 0) {
             return { verdict: "short", reasons: unresolved.flatMap(row => row.detail), matrix };
@@ -864,30 +689,6 @@ export function adjudicate(input) {
     }
     return { verdict: "attested", reasons: ["the proof agrees with the sealed diff; no verification command is configured to re-run"], matrix };
 }
-/**
- * Folds an independent reviewer's per-criterion judgements into an ALREADY
- * ADJUDICATED result (v40, evidence-review-v1) — pure, and never re-derives
- * verdict facts that were not persisted (verify-command outcome, screenshot
- * bytes): it folds over the STORED result, it does not re-run `adjudicate`.
- *
- * Three rules, and they are the whole contract:
- *  - `contradicts` -> refuted. A second reader saying a signed term is not
- *    met is the same severity as a proof that altered the term: the
- *    matching row becomes `failed`, with the reviewer's note as an
- *    attributed `detail` line.
- *  - `cannot-tell` changes nothing. Recorded and rendered, never moves the
- *    verdict — "we could not check" is not "the claim is false" (the same
- *    maxim `adjudicate` already lives by for an unavailable diff or a
- *    failed verify-command attempt).
- *  - `upholds` never upgrades. A `short` (or `attested`) run stays exactly
- *    what it was — this is the law that stops a second model laundering a
- *    bad proof, and the reason `foldReview` can only LOWER a verdict, never
- *    raise one.
- *
- * A judgement naming a criterion absent from `base.matrix` is ignored —
- * `parseReview` already refuses a payload naming an unsigned id, so this is
- * belt and suspenders, never a live path.
- */
 export function foldReview(base, judgements) {
     if (judgements.length === 0)
         return base;
@@ -926,8 +727,6 @@ export function semanticCoverage(matrix, policy) {
     const contradicted = judged("contradicts");
     const uncertain = judged("cannot-tell");
     const unreviewed = matrix.filter(row => row.review === null).map(row => row.id);
-    // Every named gap is listed, including one on a row the patch still
-    // judges: what could not be sealed is said, whatever else was.
     const contextGaps = matrix.flatMap(row => (row.coverage !== undefined && row.coverage.gaps.length > 0 ? [{ id: row.id, gaps: [...row.coverage.gaps] }] : []));
     const reviewed = matrix.length - unreviewed.length;
     return {
@@ -942,14 +741,10 @@ export function semanticCoverage(matrix, policy) {
         satisfied: matrix.length === 0 || reviewed === 0 ? null : upheld.length === matrix.length,
     };
 }
-/** The coverage in plain words — one line every surface prints the same
- * way. `[]` for a run with no rubric: nothing to cover. */
 export function coverageWords(coverage) {
     if (coverage.total === 0)
         return [];
     const lines = [];
-    // No review has folded: nothing is waited for (model review is retired),
-    // so only sealed context gaps are worth a line.
     if (coverage.satisfied === null) {
         for (const gap of coverage.contextGaps)
             lines.push(`context gap ${gap.id}: ${gap.gaps.join("; ")}`);
@@ -967,15 +762,9 @@ export function coverageWords(coverage) {
         lines.push(`context gap ${gap.id}: ${gap.gaps.join("; ")}`);
     return lines;
 }
-/** The pass fraction of a criterion matrix — the one number every list
- * surface (board, chat) needs, shared so "N/M criteria" is computed in
- * exactly one place (v40 closes the two hand-rolled copies). */
 export function passFraction(matrix) {
     return { passed: matrix.filter(row => row.state === "pass").length, total: matrix.length };
 }
-/** The matrix in plain lines, for a text surface (the CLI, `brief`) — the
- * same shared vocabulary `criterionMatrixHtml` renders in the console, so
- * the words never drift between the two (Priority 2's rule, extended). */
 export function matrixWords(matrix) {
     if (matrix.length === 0)
         return [];
@@ -996,8 +785,6 @@ export function matrixWords(matrix) {
     }
     return lines;
 }
-/** One criterion's context standing in words — shared by the CLI matrix
- * and the console badge title so the two never drift. */
 export function coverageStateWords(coverage) {
     const prior = coverage.priorSupport === "eligible" ? "; an earlier review of the source may be weighed as context (never as this run's verdict)" : coverage.priorSupport === "invalid" ? "; the earlier source review no longer supports it" : "";
     switch (coverage.state) {
@@ -1009,9 +796,6 @@ export function coverageStateWords(coverage) {
             return `GAP — inherited context is missing: ${coverage.gaps.join("; ")}${coverage.items.length > 0 ? ` (partial: ${coverage.items.join(", ")})` : ""}${prior}`;
     }
 }
-/** The verdict a result shows today, read from the stored one and the facts recorded since, never written back: a
- * failed check or an unresolved HIGH review finding refutes; a pending review, or any acceptance criterion that has
- * not passed, keeps it short. It only ever lowers the stored verdict. */
 export function shownVerdictOf(stored, facts) {
     if (facts.checkFailed || facts.highFindings > 0 || stored === "refuted")
         return "refuted";
@@ -1021,9 +805,6 @@ export function shownVerdictOf(stored, facts) {
         return "short";
     return stored;
 }
-/** Plain words for a verdict, shared by every surface (the `summary.ts`
- * pattern) so the task page, run page, board, CLI, and chat cannot say
- * three different things about the same run. */
 export function verdictWords(verdict, reasons) {
     const detail = reasons.length > 0 ? reasons.map(plainReasonWords).join("; ") : "";
     switch (verdict) {
@@ -1037,7 +818,6 @@ export function verdictWords(verdict, reasons) {
             return { word: "the report doesn't match the changes", detail };
     }
 }
-/** The `data-dispatch-status` token a page's CSS and tests key off. */
 export function dispatchStatusToken(verdict) {
     switch (verdict) {
         case "verified":

package/dist/proposal.js

@@ -1,50 +1,13 @@
 import { validateTaskText } from "./task-text.js";
 export { validateTaskText } from "./task-text.js";
-/**
- * The one door work enters through (Codex adoption review, finding 7).
- *
- * Before this module, each filing surface — CLI, console, intake — validated
- * what it happened to think of: createConsoleTask checked title and goal but
- * not disguised text, nothing checked a repo against the caller's ceiling,
- * and nothing stamped who filed what. The
- * review's ruling: one canonical service that every filer calls, with an
- * exact field allowlist, so a careless caller CANNOT spread a template or
- * model object into scope rows and smuggle approval metadata.
- *
- * The contract, in order:
- *   - every text field is validated here, identically for every caller:
- *     length bounds, control characters, and DISGUISED text (invisibles,
- *     bidi overrides) on the fields an approver reads;
- *   - the repo is canonicalized, and when the caller has a ceiling the
- *     canonical repo must be inside it — an absent ceiling is the CLI's
- *     honest "no ceiling", never a wildcard for surfaces that have one;
- *   - approval fields are hardcoded null by the store methods this calls;
- *     nothing a caller passes can reach them (exact allowlist, no spread);
- *   - the digest is computed HERE, never accepted from the caller;
- *   - provenance (filedVia) is stamped in the same transaction and is
- *     immutable — there is no API to change it, anywhere.
- *
- * Filing carries NO authority. Everything this module creates is unapproved
- * and stays inert until the operator's own ceremony says otherwise.
- */
 import { resolve } from "node:path";
 import { canonicalProject } from "./project.js";
 import { heuristicSizing, planningSignals, refineFiledSizing } from "./task-sizing.js";
 import { FolderUnavailable } from "./folder-gate.js";
-/** Provenance tokens are part of the audit surface: lowercase, bounded,
- * nothing that could render as anything but itself. */
 const FILED_VIA = /^[a-z][a-z0-9:-]{0,63}$/;
-/** One deterministic planning policy for console, chat, MCP, and sync
- * filings. A planner needs a repository to inspect; report/scout work is
- * already the discovery phase and never recursively plans itself. With a
- * size (v2 routing), a small change is not planned and a large or risky
- * one is; a medium one keeps the description's signals. */
 export function shouldPlanTask(input, sizing) {
     if (input.deliverable === "report" || input.planning === "skip")
         return false;
-    // Remote coordinators only propose work. Keep their submissions quarantined
-    // until an operator has restated the scope; automatic planning must not turn
-    // an untrusted MCP filing into executable workflow state.
     if (input.proposedVia === "coordinator" || input.filedVia?.startsWith("mcp:"))
         return false;
     if (input.repo === undefined || input.repo.trim() === "")
@@ -64,20 +27,12 @@ function refuse(reason, message) {
 }
 function checkRepo(given, admitted) {
     if (given === undefined || given === "") {
-        // A ceiling names the ONLY repos this surface may file into. Filing
-        // repo-less under a ceiling would bypass it wholesale (MCP spec v2,
-        // Codex round 2 finding 2) — a bounded surface must say where.
         if (admitted !== undefined) {
             return refuse("outside-ceiling", "this surface must name a repository — it is limited to specific ones");
         }
         return { ok: true, repo: undefined };
     }
-    // Best-effort canonicalization, the codebase's one convention: a real
-    // directory resolves through symlinks; a path that does not exist yet
-    // still normalizes, because filing must not depend on this machine
-    // seeing every repo the plane knows about.
     let canonical;
-    // A folder the console's gate holds back (folder-gate.ts) is unavailable: refused, never filed by its spelling.
     try {
         canonical = canonicalProject(given) ?? resolve(given);
     }
@@ -98,14 +53,12 @@ export function fileTaskProposal(store, input, now) {
     const badText = validateTaskText(input);
     if (badText !== null)
         return badText;
-    // Sized at once from the description; filing never waits for a model.
     const sizing = input.sizing ?? heuristicSizing(input);
     const outOfScope = input.outOfScope ?? null;
     const touches = input.touches ?? [];
     const repo = checkRepo(input.repo, input.admittedRepos);
     if (!repo.ok)
         return repo;
-    // Exact allowlist — built field by field, never spread from the input.
     const made = store.createConsoleTask({
         ...(input.id === undefined ? {} : { id: input.id }),
         title: input.title,
@@ -139,9 +92,6 @@ export function fileTaskProposal(store, input, now) {
         if (ref !== null)
             planning = store.requestPlan(ref.id, now).ok;
     }
-    // The classifier (when this process has one) answers within five seconds
-    // and re-files the still-unapproved scope with its size. Never for work
-    // that builds nothing, or for an untrusted remote proposal.
     if (input.sizing === undefined && repo.repo !== undefined && input.goal !== undefined && input.deliverable !== "report" &&
         input.proposedVia !== "coordinator" && !input.filedVia.startsWith("mcp:")) {
         void refineFiledSizing(store, made.id, placed, input.planning === undefined || input.planning === "auto");

package/dist/protected-storage-look.js

@@ -1,9 +1,3 @@
-/**
- * The storage check's child process (protected-storage.ts prepareProtectedStorage): it finds the protected roots, reads
- * Firefox's profiles.ini and walks every present root here, where a listing that waits on a macOS privacy prompt holds
- * up only this process. It writes `at\t<root>` before each walk and `done\t<answer>` at the end; the parent kills it at
- * its limit and refuses the launch.
- */
 import { protectedStorageHere } from "./protected-storage.js";
 const request = JSON.parse(process.argv[2] ?? "{}");
 if (typeof request.home !== "string" || typeof request.platform !== "string" || request.env === null || typeof request.env !== "object")