toolroll 0.9.103 → 0.9.105

package/dist/reviewer.js

@@ -1,24 +1,12 @@
 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
- * run (no rubric) writes exactly what it always has, byte for byte. */
 export const REVIEW_PATCH_NAME = "REVIEW-DIFF.patch";
 export const REVIEW_LIMITS = {
     ...REVIEW_OUTPUT_LIMITS,
-    /** The mailbox read cap: 40 maximal comments plus 12 judgements fit with headroom. */
     payload: 64 * 1024,
-    /** Initial encoded delivery budget; remaining declared text is available by range. */
     inlineText: 1024 * 1024,
 };
-/**
- * Every path the patch names — new side, old side, and both halves of a
- * rename — so a comment can be proven patch-local (the brief admits the
- * reviewer saw ONLY the patch; a path it never saw is not a comment, it
- * is a guess).
- */
 export function diffPathsOf(patch) {
     const paths = new Set();
     for (const line of patch.split("\n")) {
@@ -31,7 +19,6 @@ export function diffPathsOf(patch) {
         else if (line.startsWith("rename from "))
             paths.add(line.slice(12).trim());
         else if (line.startsWith("diff --git a/")) {
-            // `diff --git a/<old> b/<new>` — the b/ half begins at the last ` b/`.
             const split = line.lastIndexOf(" b/");
             if (split > 13) {
                 paths.add(line.slice(13, split).trim());
@@ -55,11 +42,6 @@ export function parseReview(raw, patchPaths, approvedCriteriaIds = new Set(), pr
         return { ok: false, problems: [{ reason: "not an object" }] };
     }
     const payload = parsed;
-    // Run 1638: claude's structured-output floor is ONE flat object shared
-    // with the evidence read channel (a top-level union is refused by the
-    // API), so a reply can carry `readEvidence` beside review fields. That
-    // is neither a read request (exact keys only, review-evidence.ts) nor a
-    // review — refused whole, by name, so the correction turn says which.
     if (payload["readEvidence"] !== undefined) {
         return { ok: false, problems: [{ reason: 'readEvidence must be sent alone as {"version":1,"readEvidence":{...}}; a reply mixing an evidence request with review fields is neither' }] };
     }
@@ -152,10 +134,6 @@ export function parseReview(raw, patchPaths, approvedCriteriaIds = new Set(), pr
                     problems.push({ reason: `criterion ${index}: note must be a string of 1..${REVIEW_LIMITS.note} UTF-16 units` });
                     return;
                 }
-                // v51: a criterion outside this run's own patch is settled only by
-                // supplied provenance — an `upholds` or `contradicts` whose note
-                // cites none of it is a guess dressed as a judgement, and the whole
-                // payload is refused (the correction turn says exactly which id).
                 if (provenance !== undefined &&
                     judgement !== "cannot-tell" &&
                     provenance.provenanceRequired.has(id) &&
@@ -168,11 +146,6 @@ export function parseReview(raw, patchPaths, approvedCriteriaIds = new Set(), pr
             });
         }
     }
-    // Full coverage (audit hardening): a signed rubric admits no partial
-    // review. Every id in `approvedCriteriaIds` needs exactly one judgement
-    // — an omitted id (including every id, when "criteria" is absent
-    // entirely) is refused the same way an unsigned id is: the whole
-    // payload, comments included, never a silent partial pass.
     if (approvedCriteriaIds.size > 0) {
         const missing = [...approvedCriteriaIds].filter(id => !seenCriteriaIds.has(id));
         if (missing.length > 0) {
@@ -183,14 +156,6 @@ 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"] }) };
 }
-/**
- * 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;
     try {

package/dist/route-change-check.js

@@ -1,6 +1,4 @@
-/** The approval's one question about a "what changed" line (route-change.ts), apart so scope.ts loads it without the rest. */
 import { routeDigestOf, routeFromJson } from "./phase-routing.js";
-/** Whether a line on record for this exact plan describes some other route. An Approve under it is a yes to the wrong words. */
 export function routeChangeProblem(store, taskId, scope) {
     const ref = store.lookupRef(taskId);
     if (ref === null)

package/dist/route-change.js

@@ -1,11 +1,3 @@
-/**
- * One step to approve a new route (docs/plans/plain-toolroll.md P2.5). There are no route classes: an approval stays
- * bound to its exact route, and dispatch runs on no other bytes. When the route a task would dispatch on differs from the
- * sealed one, Toolroll files the same words again on today's route (nothing is sealed) and keeps one "what changed" line,
- * bound to that route's digest, for the one Approve. A legacy row with no route gets the same.
- *
- * approve() reads routeChangeProblem: a line that doesn't describe the route being approved refuses "changed".
- */
 import { providerName } from "./provider-auth.js";
 import { legOf, routeDigestOf, routeFromJson } from "./phase-routing.js";
 import { deployGateScope, releaseCheckScope } from "./scope.js";
@@ -13,7 +5,6 @@ import { BUILT_IN } from "./store.js";
 const ROLE = { plan: "planner", build: "builder", repair: "repair agent", review: "reviewer" };
 const named = (one) => `${providerName(one.provider)} ${one.model ?? "(its default model)"}`;
 const billing = (mode) => mode === "api-key" ? "API key" : mode === "subscription" ? "subscription" : null;
-/** The sentence for what changed between the seal and the proposal. */
 export function routeChangeWords(sealed, next) {
     const changes = [];
     for (const phase of ["build", "plan", "repair", "review"]) {
@@ -27,7 +18,6 @@ export function routeChangeWords(sealed, next) {
         if (was.provider === now.provider && was.model === now.model)
             continue;
         const line = `changes from ${named(was)} to ${named(now)}`;
-        // The repair agent is the builder's usual twin: one change is one sentence.
         if (changes.some(one => one.endsWith(line)))
             continue;
         changes.push(`${changes.length === 0 ? "The" : "the"} ${ROLE[phase]} ${line}`);
@@ -38,8 +28,6 @@ export function routeChangeWords(sealed, next) {
         return "The agents' settings changed since you approved this. Approve to continue.";
     return `${changes.join("; ")}${paid}. Approve to continue.`;
 }
-/** File the same words on today's route, and keep the line. Null: nothing to propose (a release, nothing changed, or no
- * route Toolroll can name), and the task stays as it is. It seals nothing. */
 export function proposeNewRoute(store, taskRef, taskId, now) {
     return store.transact(() => {
         const before = store.getScope(taskId);
@@ -54,7 +42,6 @@ export function proposeNewRoute(store, taskRef, taskId, now) {
             return null;
         if (refiled.approvedDigest === refiled.digest)
             return null;
-        // How the last attempt billed, against how the new builder would: said when they differ.
         const lastBilled = store.runsFor(taskRef).find(one => one.role === "builder")?.authMode ?? null;
         const billed = store.agentsFor([legOf(route, "build").provider])[0]?.billing ?? null;
         const words = routeChangeWords({ route: sealedRoute, profile: before.approvedProfile ?? null, authMode: lastBilled }, { route, authMode: billed });
@@ -64,7 +51,6 @@ export function proposeNewRoute(store, taskRef, taskId, now) {
         return { words };
     });
 }
-/** The line for this task's waiting plan, or null. Only while it describes exactly the plan up for approval. */
 export function routeChangeOf(store, taskId) {
     const ref = store.lookupRef(taskId);
     if (ref === null)
@@ -76,8 +62,6 @@ export function routeChangeOf(store, taskId) {
     const route = routeFromJson(scope.proposedRouteJson ?? null);
     return route !== null && routeDigestOf(route) === row["to_route_digest"] ? String(row["words"]) : null;
 }
-/** Each sweep: an unapproved row from before routing gets its route, and the same one Approve. A standing old approval
- * is left alone (the stale check reaches it if its route ever differs). */
 export function routeLegacyPlans(store, now) {
     const rows = store.handle.prepare(`SELECT r.id AS ref, r.external_id AS task FROM task_scope s JOIN task_ref r ON r.external_id = s.task_id AND r.backend = ? JOIN task t ON t.id = r.external_id
     WHERE s.route_era IS NULL AND t.state = 'queued' AND (s.approved_digest IS NULL OR s.approved_digest <> s.digest) LIMIT 20`).all(BUILT_IN);

package/dist/route-hooks.js

@@ -2,7 +2,6 @@ import { createRequire } from "node:module";
 import { evalHookProblem } from "./eval-hooks.js";
 let compiler;
 const typescript = () => compiler ??= createRequire(import.meta.url)("typescript-parser");
-/** Where a revision is created from: each caller's arguments (and so the origin it passes) are held as the base has them. */
 const REVISION_CALLERS = [
     { file: "src/flow-engine.ts", inside: "revisionWithNote", calls: "requestResultChanges", from: "./result-actions.js", args: true, why: "a flow's revision says it came from a flow" },
     { file: "src/build-review.ts", inside: "sendBack", calls: "requestResultChanges", from: "./result-actions.js", args: true, why: "the automatic review's revision is never a person's" },
@@ -21,18 +20,14 @@ export const ROUTING_HOOKS = Object.freeze([
     { file: "src/operate.ts", inside: "reconcileCommand", calls: "reevaluateResultRecords", from: "./route-results.js", why: "records are evaluated again as their inputs change" },
     { file: "src/project-delete.ts", inside: "deleteRows", calls: "forgetProjectModels", from: "./store.js", why: "a deleted project's Models rows go through the counter" },
     { file: "src/release-auto.ts", inside: "changeProblem", calls: "routingHookProblem", from: "./route-hooks.js", why: "this check itself" },
-    // Slice 2: each live rule is checked against its sealed terms every pass, and a held task never starts.
     { file: "src/operate.ts", inside: "reconcileCommand", calls: "routeRulesPass", from: "./route-rules.js", why: "a rule switches itself off on its sealed terms" },
     { file: "src/operate.ts", inside: "tickCommand", calls: "ruleHoldOf", from: "./route-store.js", why: "a task approved under a rule that switched itself off never starts on it" },
     ...REVISION_CALLERS,
 ]);
 export const ROUTING_PINNED = Object.freeze([
-    // What a route is and how it's read.
     { file: "src/phase-routing.ts", fn: "recommendRoute", why: "which agent a task is routed to" },
-    // Slice 2: the one precedence order (pin > override > trial > earned rule > configured > headroom) and who is eligible.
     { file: "src/phase-routing.ts", fn: "selectBuildLeg", why: "the build leg's one precedence order" },
     { file: "src/phase-routing.ts", fn: "earnedRuleFor", why: "which tasks an earned rule may build" },
-    // Slice 3: which tasks a trial may build, and that only a person's own yes seals or dispatches one.
     { file: "src/phase-routing.ts", fn: "trialFor", why: "which tasks a trial may build" },
     { file: "src/approval-authority.ts", fn: "authorityStandsSql", why: "which approvals dispatch, a trial task's only on a person's yes" },
     { file: "src/approval-authority.ts", fn: "trialSealStandsSql", why: "a trial task stands only on a person's own approval" },
@@ -42,16 +37,13 @@ export const ROUTING_PINNED = Object.freeze([
     { file: "src/store.ts", fn: "Store#sealedRouteOf", why: "the sealed route a run's cohort is decided from" },
     { file: "src/model-choices.ts", fn: "checkScope", why: "what a Models setting may say" },
     { file: "src/model-choices.ts", fn: "effectiveRoutes", why: "the routes the Models page previews" },
-    // The evidence a record reads.
     { file: "src/assignment.ts", fn: "assignmentChecksForRun", why: "a result's effective check" },
     { file: "src/result-completion.ts", fn: "changedFilesOf", why: "what a result changed" },
     { file: "src/assignment.ts", fn: "acknowledgeCurrent", why: "a completion's person or machine mark" },
-    // Its inputs.
     { file: "src/store.ts", fn: "Store#finishRun", why: "how a run ends" },
     { file: "src/store.ts", fn: "Store#recordRunCheck", why: "a run's own check" },
     { file: "src/store.ts", fn: "Store#writeRunRoute", why: "a run's route stamp" },
     { file: "src/result-actions.ts", fn: "createResultRevision", why: "every revision and its origin" },
-    // Its consumers and the Models writers, which move the configuration generations.
     { file: "src/store.ts", fn: "Store#saveScope", why: "filing a task's route" },
     { file: "src/store.ts", fn: "Store#sealScopeApproval", why: "approving a task's route" },
     { file: "src/store.ts", fn: "Store#admitRun", why: "a run's admission, its cohort snapshot, and the switched-off rule's hold" },
@@ -64,13 +56,9 @@ export const ROUTING_PINNED = Object.freeze([
     { file: "src/store.ts", fn: "Store#clearPhaseTierAlternates", why: "a Models row write moves its generation" },
     { file: "src/store.ts", fn: "forgetProjectModels", why: "a deleted project's Models rows move their generations" },
 ]);
-/** Every file the manifest reads, for one verified read of each tree. */
 export const ROUTING_HOOK_FILES = Object.freeze([...new Set([...ROUTING_HOOKS.map(hook => hook.file), ...ROUTING_PINNED.map(pin => pin.file)])]);
-/** The tables only route-store.ts writes, and the Models tables only the named store.ts writers write. */
 export const ROUTING_TABLES = Object.freeze(["route_record", "route_rule", "route_exposure", "route_exposure_event", "route_trial_reservation", "run_cohort", "models_generation"]);
 export const MODELS_TABLES = Object.freeze(["phase_config", "phase_tier_config", "phase_tier_alternate"]);
-/** The one writer module, and the store.ts functions (`Class#method` or top-level) that may write the Models tables:
- * the six row writers, a deleted project's rows, and the migration that rebuilt one. */
 export const ROUTING_WRITER = "src/route-store.ts";
 export const MODELS_WRITERS = Object.freeze({
     "src/store.ts": Object.freeze(["Store#setPhaseConfig", "Store#clearPhaseConfig", "Store#setPhaseTierConfig", "Store#clearPhaseTierConfig",
@@ -80,11 +68,7 @@ const VERB = String.raw `(?:INSERT(?:\s+OR\s+\w+)?\s+INTO|REPLACE\s+INTO|UPDATE(
 const writes = (tables) => new RegExp(String.raw `\b${VERB}\s+(?:main\s*\.\s*)?["\`\[]?(?:${tables.join("|")})["\`\]]?(?![\w])`, "i");
 const ROUTING_WRITE = writes([...ROUTING_TABLES, "route_rule_one_winner"]);
 const MODELS_WRITE = writes(MODELS_TABLES);
-/** The two columns only route-store.ts writes: any write statement that names one. A lesson note keeps its own copy of
- * how a revision was asked for: that one INSERT into its own table is not this column, and only it is left out. */
 const COLUMN_WRITE = /\b(?:INSERT(?!\s+INTO\s+lesson_note\b)|REPLACE|UPDATE)\b[^]*\b(?:exec_class|revision_origin)\b/i;
-/** Each string or template text in the file that writes a protected row, with the function it's in ("" at the top
- * level): `Class#method`, or the top-level function. */
 export function protectedWrites(file, source) {
     const compiler = typescript();
     const found = [];
@@ -120,16 +104,11 @@ export function protectedWrites(file, source) {
     void file;
     return found;
 }
-/** Whether this write may stand where it is: route-store.ts writes anything; the named store.ts writers write the
- * Models tables only. */
 function allowed(file, write) {
     if (file === ROUTING_WRITER)
         return true;
     return write.models && (MODELS_WRITERS[file] ?? []).includes(write.inside);
 }
-/** Why a changed file writes a protected row from a place that may not, or null. A construct the base's copy of the
- * file already had (the same text in the same function, counted) is kept; a file that can't be read or parsed needs a
- * person. Test files are not scanned: they never ship as the plane. */
 export function sqlWriteProblem(paths, candidate, base) {
     const scanned = paths.filter(path => /\.(?:[cm]?[jt]sx?)$/.test(path) && !/\.test\.[cm]?[jt]sx?$/.test(path) && !path.startsWith("test/")
         && !path.startsWith("node_modules/") && !path.includes("/node_modules/"));
@@ -169,12 +148,6 @@ export function sqlWriteProblem(paths, candidate, base) {
     }
     return null;
 }
-/**
- * Why a candidate needs a person for results routing, or null: a required call dropped, a pinned body changed (its
- * manifest files read through `manifest`), or a changed file that writes a protected row outside its writers
- * (`changed`). With `manifest.base` (the plane's own record of where the release started), only what the base holds
- * is required, as eval-hooks.ts does.
- */
 export function routingHookProblem(manifest, changed) {
     return evalHookProblem(manifest.candidate, manifest.base, ROUTING_HOOKS, ROUTING_PINNED) ?? sqlWriteProblem(changed.paths, changed.candidate, changed.base);
 }

package/dist/route-results.js

@@ -1,13 +1,3 @@
-/**
- * Result records (docs/plans/results-routing.md, slice 1): what each finished task family shows about the model that
- * built it, read only from Toolroll's own rows (runs, their cohort snapshots, checks, completions, merges, review
- * findings and revision origins) — never worktree files, park payloads, agent reports or lead tool calls.
- *
- * A policy path (release-auto.ts EVAL_POLICY): the execution-class table, eligibility and the lifecycle decide what
- * counts as a cheaper model's evidence, so a change here needs a person. The only writer is route-store.ts.
- *
- * Read-only in slice 1: nothing here suggests, routes or switches anything.
- */
 import { protectedChanges } from "./approval-policy.js";
 import { assignmentChecksForRun } from "./assignment.js";
 import { INELIGIBLE_REASONS, REASON_WORDS, selectionSchema, } from "./contracts/route-results.js";
@@ -15,16 +5,9 @@ import { changedFilesOf, COMPLETION_ACTION } from "./result-completion.js";
 import { runAccounting } from "./store.js";
 import { INFRASTRUCTURE_TERMINALS, saveResultRecord } from "./route-store.js";
 import { wasInterrupted } from "./run-ending.js";
-// The execution class and the cohort snapshot live with their writer (route-store.ts), which store.ts imports: kept
-// light so the store's module graph doesn't reach the evaluator's readers.
 export { cohortOf, EXEC_CLASS_OF_REASON, execClassOf } from "./route-store.js";
-// ---- the record ---------------------------------------------------------------------------------------------------
-/** How long an accepted result waits before it counts, and how long a result may wait for an answer. */
 export const MATURE_AFTER_MS = 14 * 24 * 60 * 60_000;
 export const UNANSWERED_AFTER_MS = 30 * 24 * 60 * 60_000;
-/** The explicit cutoff for a family's spending and counts: they keep accumulating through later revision and repair
- * runs (a verdict, once final, never moves) until the family is quiet — every version ended and no run open — or
- * this long after its first run, whichever is first. */
 export const ACCUMULATE_FOR_MS = 90 * 24 * 60 * 60_000;
 function cohortsFor(store, runs) {
     const rows = store.handle.prepare("SELECT * FROM run_cohort WHERE run IN (SELECT value FROM json_each(?))").all(JSON.stringify(runs));
@@ -43,8 +26,6 @@ function cohortsFor(store, runs) {
                 provider: String(row["provider"]), selection, startedAt: String(row["started_at"]) }];
     }));
 }
-/** A failed code-writing run's class: its kept class; otherwise a provider terminal or an interruption before the
- * provider started is infrastructure; anything else (a missing write included) is the model's. */
 function classOfRun(run, kept) {
     if (kept === "model" || kept === "infrastructure")
         return kept;
@@ -55,22 +36,14 @@ function classOfRun(run, kept) {
     return "model";
 }
 const FAILED_OUTCOMES = new Set(["failed", "interrupted"]);
-/** Whether the first built run among `runs` passed its own check; null when none is recorded. The code map's report reads
- * this too, so the two never disagree on what a first check is. */
 export function firstCheckPassedOf(store, runs) {
     const first = runs.find(run => run.outcome === "built");
     const status = first === undefined ? null : store.runCheckFor(first.id)?.status ?? null;
     return status === "passed" ? true : status === "failed" ? false : null;
 }
-/** How many of these task versions are a person's revision. */
 export function personRevisionsOf(store, refs) {
     return Number(store.handle.prepare("SELECT COUNT(*) AS n FROM task_ref WHERE id IN (SELECT value FROM json_each(?)) AND revision_origin = 'person'").get(JSON.stringify(refs))?.["n"] ?? 0);
 }
-/**
- * A task family's record, evaluated now from its rows (null: no code-writing run, or a family whose lineage can't be
- * proved). The order is the plan's: what can't be attributed to one model and one cohort first, then a live attempt
- * (pending), then every rejection, then what isn't counted, then acceptance and maturity.
- */
 export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
     const family = store.taskFamilyOf(rootTaskId, null, true);
     if (family === null || family.problem !== null || family.root.id !== rootTaskId)
@@ -92,7 +65,6 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
     const cohorts = cohortsFor(store, ids);
     const kept = new Map(store.handle.prepare("SELECT id, exec_class FROM run WHERE id IN (SELECT value FROM json_each(?))").all(JSON.stringify(ids))
         .map(row => [Number(row["id"]), row["exec_class"] == null ? null : String(row["exec_class"])]));
-    // Spending, kept apart by kind and never added across kinds.
     let apiMicrousd = 0, subscriptionRuns = 0, subscriptionTokens = 0, unknownRuns = 0, remediationRuns = 0;
     for (const run of runs) {
         if (run.role === "repair" || versionOf.get(run.id) !== family.root.id)
@@ -145,11 +117,8 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
     };
     const reject = (reason) => ({ ...value, state: "rejected", reason, decidedAt: now.toISOString(), settled: true });
     const notCounted = (reason, settled) => ({ ...value, state: "not-counted", reason, decidedAt: settled ? now.toISOString() : null, settled });
-    // 1. One cohort and one model, or the record can't say anything about a model.
     if (attributed.length !== runs.length)
         return notCounted("before-records", true);
-    // A family whose runs disagree (a revision re-sized large, one run under strict) is mixed; one whose runs all agree
-    // on not being eligible is not eligible.
     if (new Set(attributed.map(one => `${one.repo ?? ""}\u0000${one.cohortSize ?? "not-eligible"}`)).size > 1)
         return notCounted("mixed-cohort", true);
     if (attributed.some(one => one.cohortSize === null))
@@ -164,13 +133,10 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
         if (run.modelReported !== cohorts.get(run.id).model)
             return notCounted("mixed-models", true);
     }
-    // 2. A person who asked for changes, or a HIGH finding, rejected a result already: that stands whatever the family
-    //    does next (its later runs still add to its spending).
     if (value.personRevisions > 0)
         return reject("person-revision");
     if (highFinding(store, ids))
         return reject("high-finding");
-    // 3. Still running: nothing to say yet.
     if (runs.some(run => run.outcome === null))
         return value;
     const current = family.current;
@@ -183,7 +149,6 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
         return value;
     }
     value.resultRun = result.id;
-    // 4. Rejections, checked first among what a result can be.
     if (modelFailures >= 2)
         return reject("model-failures");
     if (family.versions.some(one => one.state === "failed"))
@@ -195,14 +160,12 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
     const checks = evidenceRoot === undefined ? null : assignmentChecksForRun(store, evidenceRoot, result.id, now);
     if (checks?.status === "failed")
         return reject("check-failed");
-    // 5. Not counted.
     const answerBy = Date.parse(result.finishedAt ?? result.startedAt) + UNANSWERED_AFTER_MS;
     if (checks === null || checks.status === "unavailable")
         return notCounted("check-unavailable", now.getTime() >= answerBy);
     if (checks.status === "not-run")
         return notCounted("no-check", now.getTime() >= answerBy);
     const rules = value.repo === null ? null : store.approvalRules(value.repo);
-    // Post-build: each built run's own diff inventory; one that can't be read whole (or was never saved) is unknown.
     for (const run of runs) {
         if (run.outcome !== "built")
             continue;
@@ -212,7 +175,6 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
         if (rules !== null && protectedChanges(rules, changed).length > 0)
             return notCounted("touched-protected", true);
     }
-    // 6. Accepted by a person's completion of this result, or by its merge; then mature after 14 days.
     const acceptedAt = acceptanceOf(store, family.root.id, current.id, result.id);
     if (acceptedAt === null)
         return now.getTime() >= answerBy ? notCounted("unanswered", true) : value;
@@ -221,7 +183,6 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
         return { ...value, state: "provisional", acceptedAt };
     return { ...value, state: "mature", acceptedAt, decidedAt: new Date(matureAt).toISOString(), settled: true };
 }
-/** Whether the automatic review graded any of these runs' results HIGH. */
 function highFinding(store, runs) {
     const rows = store.handle.prepare("SELECT findings_json FROM build_review WHERE run IN (SELECT value FROM json_each(?)) AND findings_json IS NOT NULL").all(JSON.stringify(runs));
     return rows.some(row => {
@@ -230,12 +191,10 @@ function highFinding(store, runs) {
             return Array.isArray(findings) && findings.some(one => one?.severity === "HIGH");
         }
         catch {
-            return true; /* an unreadable review counts against, never for */
+            return true;
         }
     });
 }
-/** When a person accepted this result: the earliest person-proved completion of exactly this run (a machine's
- * completion, a lead's, or Toolroll's own `system:landed` is not acceptance), or its merge. */
 function acceptanceOf(store, rootId, currentId, runId) {
     const completed = store.handle.prepare(`SELECT MIN(at) AS at FROM action_ledger WHERE action = ? AND source = 'work' AND task_id IN (?, ?)
     AND run_id = ? AND detail = 'proof person' AND actor LIKE 'operator:%'`).get(COMPLETION_ACTION, rootId, currentId, runId)?.["at"];
@@ -244,8 +203,6 @@ function acceptanceOf(store, rootId, currentId, runId) {
     const times = [completed, merged].filter((one) => typeof one === "string" && Number.isFinite(Date.parse(one)));
     return times.length === 0 ? null : times.sort()[0];
 }
-// ---- reading and re-evaluating ------------------------------------------------------------------------------------
-/** The record in plain words, as the task page and `models results` say it. */
 export function recordWords(record) {
     const model = record.model ?? "this model";
     if (record.state === "pending")
@@ -257,7 +214,6 @@ export function recordWords(record) {
     const words = record.reason === null ? "" : REASON_WORDS[record.reason];
     return record.state === "rejected" ? `Counts against ${model}: ${words}` : `Not counted: ${words}`;
 }
-/** A record row as saved, in the shape `models results --json` and the task page read. */
 export function recordView(row, task) {
     const n = (key) => Number(row[key] ?? 0);
     const s = (key) => row[key] == null ? null : String(row[key]);
@@ -282,7 +238,6 @@ export function recordView(row, task) {
         turns: { known: n("agent_turns"), unknownRuns: n("turns_unknown_runs") }, closed: n("closed") === 1,
     };
 }
-/** The value as a view, for a record evaluated now and not (yet) saved. */
 export function valueView(value) {
     return recordView({ repo: value.repo, cohort_size: value.cohortSize, provider: value.provider, model: value.model, state: value.state, reason: value.reason,
         result_run: value.resultRun, accepted_at: value.acceptedAt, decided_at: value.decidedAt, model_failures: value.modelFailures, infra_failures: value.infraFailures,
@@ -291,13 +246,11 @@ export function valueView(value) {
         first_check_passed: value.firstCheckPassed === null ? null : value.firstCheckPassed ? 1 : 0, agent_turns: value.agentTurns,
         turns_unknown_runs: value.turnsUnknownRuns, closed: value.settled && value.accumulationEnded ? 1 : 0 }, value.task);
 }
-/** The saved records of these projects, newest first (by their family's first run). */
 export function resultRecords(store, repos, limit = 200) {
     return store.handle.prepare(`SELECT r.*, t.external_id AS task FROM route_record r JOIN task_ref t ON t.id = r.task_ref
     WHERE r.repo IN (SELECT value FROM json_each(?)) ORDER BY r.first_started_at DESC, t.external_id DESC LIMIT ?`).all(JSON.stringify(repos), limit)
         .map(row => recordView(row, String(row["task"])));
 }
-/** A task's record: its family root's saved record, or, before the first pass saves one, the record evaluated now. */
 export function resultRecordOf(store, taskId, evidenceRoot, now) {
     const family = store.taskFamilyOf(taskId, null, true);
     if (family === null || family.problem !== null)
@@ -308,8 +261,6 @@ export function resultRecordOf(store, taskId, evidenceRoot, now) {
     const value = evaluateFamily(store, family.root.id, evidenceRoot, now);
     return value === null ? null : valueView(value);
 }
-/** The task page's "Result record" line: the record's words, or null when the task has none (or it can't be read:
- * a record never fails the page). */
 export function resultRecordWordsOf(store, taskId, evidenceRoot, now) {
     try {
         return resultRecordOf(store, taskId, evidenceRoot, now)?.words ?? null;
@@ -318,9 +269,6 @@ export function resultRecordWordsOf(store, taskId, evidenceRoot, now) {
         return null;
     }
 }
-/** The families the re-evaluation pass looks at: a root task with a code-writing run that has a cohort snapshot, whose
- * record is missing or not closed (a final verdict still gathers its family's later spending until it closes); the
- * least recently evaluated first. */
 export function familiesToEvaluate(store, repo, limit) {
     return store.handle.prepare(`SELECT root.external_id AS task FROM run_cohort c JOIN task_ref root ON root.id = c.root_ref
     LEFT JOIN route_record rec ON rec.task_ref = c.root_ref
@@ -328,10 +276,6 @@ export function familiesToEvaluate(store, repo, limit) {
     GROUP BY c.root_ref ORDER BY COALESCE(MIN(rec.evaluated_at), ''), c.root_ref LIMIT ?`).all(repo, limit).map(row => String(row["task"]));
 }
 export { INELIGIBLE_REASONS };
-/** The re-evaluation pass (the reconcile pass of each project, operate.ts): every family with a cohort snapshot whose
- * record is missing or not closed is evaluated again from its rows, oldest evaluation first, at most `limit` a pass,
- * and saved through route-store.ts. Each family is its own transaction, so one unreadable family never holds the others
- * back. */
 export function reevaluateResultRecords(store, repo, evidenceRoot, now, limit = 100) {
     let saved = 0;
     for (const task of familiesToEvaluate(store, repo, limit)) {
@@ -344,7 +288,7 @@ export function reevaluateResultRecords(store, repo, evidenceRoot, now, limit =
                 }
             });
         }
-        catch { /* the next pass tries again */ }
+        catch { }
     }
     return saved;
 }