toolroll 0.9.104 → 0.9.105

package/dist/server/render-results.js

@@ -31,15 +31,6 @@ import { attributes, html, htmlString, joinHtml, postForm, reauth } from "../htm
 import { chip, facts } from "./kit.js";
 import { publicationFactsOf, statusActionHref, statusLineHtml } from "./render-tasks.js";
 export const RUNS_PAGE = 50;
-/**
- * A vscode://file href, or null (arc 6, finding 2): the link exists only
- * when every part is provably tame — an absolute, control-free worktree;
- * a relative, single-line path whose segments contain no empty, dot,
- * dot-dot, or backslash components (so lexical resolution stays below the
- * worktree); a line inside the same 1..1,000,000 range the comment form
- * enforces. Encoding failures return null — a file row degrades to plain
- * text, never to a 500. The scheme is a constant, never data.
- */
 export function editorFileHref(worktree, path, line) {
     if (!worktree.startsWith("/") || /[\u0000-\u001f\u007f]/.test(worktree))
         return null;
@@ -61,23 +52,10 @@ export function editorFileHref(worktree, path, line) {
         return null;
     }
 }
-/** The execution profile in plain words (v24): what the password signs
- * says WHAT RUNS — provider, exact model, permissions, and the real
- * bounds — or says honestly that it cannot yet. */
-/** The state badges the criterion-to-evidence matrix renders with — one
- * shared vocabulary, so a "failed" row reads the same shade of trouble on
- * the task page, the run page, the board, done, builds, the inbox, and
- * chat (v39, extending Priority 2's "one surface, six places" rule from
- * the verdict word to the per-criterion state). */
 export function matrixStateBadge(state) {
-    // Red belongs to a Failed headline alone (task-status.ts); an unmet requirement is an ink note.
     const cls = state === "pass" ? "badge-done" : state === "failed" ? "badge-note" : state === "missing" ? "badge-note" : "badge-manual-review";
-    // The same words as the Checks tab and the card's Requirements row (task-status.ts).
     return html `<span class="badge ${cls}" data-matrix-state="${state}">${requirementWordOf({ state })}</span>`;
 }
-/** v40: the bounded repair chain's own line — presented as the user-facing
- * recovery it represents, without exposing the internal workflow name.
- * Renders on the task page and the run page identically. */
 export function repairChainHtml(chain) {
     if (chain === null)
         return html ``;
@@ -97,26 +75,12 @@ export function repairChainHtml(chain) {
         : html `<details><summary>What it is fixing</summary><p class="meta">${chain.unresolved.join(", ")}</p></details>`;
     return html `<div class="card repair-chain" data-repair-outcome="${chain.outcome}"><p class="row"><strong>Automatic recovery</strong> — ${outcomeWords}${link}</p>${details}</div>`;
 }
-/**
- * The bounded review-retry panel (v50), shared by the task page and the
- * result cockpit so both say the same thing: which attempt is running or
- * queued, how the latest one ended, every root attempt on record, and the
- * ONE explicit act — a Retry review form — rendered only while the store's
- * allowance admits it and this session may ask (an approver's cookie
- * session). Every other state shows the same control disabled, in words,
- * so a person always sees why nothing more will happen by itself. Empty
- * when no review was ever asked for.
- */
 export function reviewRetryPanel(_taskId, _sourceRun, retry, _options) {
     if (retry === null || retry.state === "unrequested")
         return html ``;
     const attempts = retry.attempts.map(one => html `<li data-review-attempt="${one.attempt}" data-review-outcome="${one.outcome ?? "open"}"><a href="/r/${one.runId}">Run #${one.runId}</a> · ${one.outcome ?? "unfinished"}${one.reason === null ? "" : html ` · ${one.reason}`}</li>`);
     return html `<details class="review-history" data-review-state="${retry.state}"><summary>Previous assessments</summary><p class="meta">Saved history; no separate review will be started.</p>${attempts.length === 0 ? "" : html `<ol aria-label="previous assessments">${attempts}</ol>`}</details>`;
 }
-/** A one-line summary of the matrix for list rows too dense for the full
- * table (done, builds, board, inbox) — "2/3 criteria", plus a worst-state
- * badge so trouble is visible without opening the row. `[]` renders
- * nothing. */
 export function criterionMatrixSummary(matrix) {
     if (matrix.length === 0)
         return html ``;
@@ -150,9 +114,6 @@ export function evidenceLinksFor(artifacts) {
     }
     return map;
 }
-/** Read the approved requirement first; inspect its saved evidence on demand.
- * Machine results, reviewer judgements and missing context remain separate.
- * Warnings stay outside the disclosure, including on compact surfaces. */
 export function criterionMatrixHtml(matrix, options = {}) {
     if (matrix.length === 0)
         return html ``;
@@ -173,15 +134,10 @@ export function criterionMatrixHtml(matrix, options = {}) {
         const state = row.state;
         const awaitingAssessment = row.assessment?.evidenceState === "pass" && row.review === null;
         const confirmed = row.assessment !== undefined && state === "pass";
-        // Plain words (task-status brief): the retired assessment step is not a state a person acts on.
-        // The card's Requirements row reads the same words from the same source (task-status.ts), so they agree.
         const label = requirementWordOf(row, options.verdict, options.release);
         const cls = label === "Met" ? "badge-done" : label === "You check" ? "badge-manual-review" : "badge-note";
         const warnings = [];
-        // Only replace the known boilerplate. Other recorded failure details
-        // remain verbatim, so concision cannot hide a different problem.
         const detail = row.detail.filter(line => !(row.assessment && row.review && line === `${row.review.author} ${row.review.judgement === "contradicts" ? "contradicts" : "needs more evidence for"} criterion "${row.id}": ${row.review.note}`) && !(state === "manual-review" && /^criterion "[^"\n]+" requires manual-review evidence — an operator must accept it before this can verify$/.test(line)));
-        // A requirement a release check covers, or that waits only on one, has nothing wrong to say.
         if (!awaitingAssessment && state !== "pass" && label !== "Met" && label !== CHECKED_AT_RELEASE && detail.length > 0)
             warnings.push(html `<ul class="requirement-issues">${detail.map(line => html `<li>${line}</li>`)}</ul>`);
         const review = row.review;
@@ -215,31 +171,19 @@ export function criterionMatrixHtml(matrix, options = {}) {
     });
     return html `<div class="result-section criterion-matrix"><strong>Requirements · ${matrix.length}</strong><ol class="requirement-list">${rows}</ol></div>`;
 }
-/** One policy summary beneath the requirements. Per-requirement concerns
- * are already visible in the matrix; do not repeat their full text here. */
 export function semanticCoverageHtml(matrix, qualityMode) {
     if (!matrix.some(row => row.review != null || row.assessment !== undefined))
         return html ``;
     const coverage = semanticCoverage(matrix, qualityMode);
     return html `<details class="result-section semantic-coverage" data-semantic-coverage="${coverage.satisfied === true ? "satisfied" : coverage.satisfied === null ? "unsettled" : "unsatisfied"}" data-coverage-policy="${coverage.policy}"><summary>Previous assessment</summary><p class="meta">The saved assessment confirmed ${coverage.upheld.length} of ${coverage.total} requirements.</p></details>`;
 }
-/** A same-site path or "/": never a scheme, a host, or a protocol-relative road. */
-/** The words a result page shows for a refusal its own form led to, by the fixed code a redirect carries. */
 export const ACCEPT_ANYWAY_NEEDS_REASON = "Accepting anyway needs a reason.";
 export const RESULT_REFUSALS = { reason: ACCEPT_ANYWAY_NEEDS_REASON };
-/** A same-site page address with a refusal code added, before any fragment. */
 export function withRefusal(href, code) {
     const at = href.indexOf("#");
     const [path, hash] = at === -1 ? [href, ""] : [href.slice(0, at), href.slice(at)];
     return `${path}${path.includes("?") ? "&" : "?"}refused=${code}${hash}`;
 }
-// ---- the review cockpit (Priority 5) ----------------------------------------
-// The field parallelizes generation and lets review pile up (M8.19); this
-// page compresses it. Read-only by design — ranked advice and deep links,
-// no merge button, because the PR is the terminus and the person merges
-// on GitHub.
-/** The queue reads at most this many completed tasks — the store's own
- * page ceiling, admission bound before it. */
 export const REVIEW_QUEUE_CAP = 100;
 export const PRIORITY_LABELS = { 0: "needs action", 1: "review", 2: "no flags" };
 export function reviewPriorityOf(row) {
@@ -287,8 +231,6 @@ export function reviewPriorityOf(row) {
         raise(1, "no verification result");
     return { band, label: PRIORITY_LABELS[band], reasons };
 }
-/** Ranked, stable: band first, then newest completion, then task id — the
- * same input always yields the same queue, whoever loads it. */
 export function rankReviewQueue(rows) {
     return rows
         .map(row => ({ ...row, priority: reviewPriorityOf(row) }))
@@ -300,10 +242,6 @@ export function rankReviewQueue(rows) {
                 ? b.completedAt.localeCompare(a.completedAt)
                 : a.taskId.localeCompare(b.taskId));
 }
-/** Whether a changed path sits inside the scope's signed "touches" — an
- * exact file, a directory prefix (with or without its slash), or a plain
- * `*` / `**` glob. Touches are advisory in the scope; here they only
- * decide which files wear the "outside the signed touches" flag. */
 export function withinSignedTouches(path, touches) {
     return touches.some(raw => {
         const touch = raw.trim().replace(/^\.\//, "");
@@ -315,13 +253,7 @@ export function withinSignedTouches(path, touches) {
         return path === touch || path.startsWith(dir);
     });
 }
-/** A signed touch's glob as a regular expression, gitignore-style: `*`
- * stays inside one segment; `**` followed by `/` spans zero or more
- * directories, so `src/**` followed by `/*.ts` matches `src/a.ts` as well
- * as `src/nested/a.ts` (v2 review, comment 2); a bare `**` spans anything.
- * Whatever the glob names, its contents are inside it too. */
 export function touchGlob(raw) {
-    // A trailing slash names a directory; the contents clause below covers it.
     const touch = raw.replace(/\/+$/, "");
     let pattern = "";
     for (let at = 0; at < touch.length;) {
@@ -344,26 +276,11 @@ export function touchGlob(raw) {
     }
     return new RegExp(`^${pattern}(?:/.*)?$`);
 }
-/** A stable, attribute-safe anchor for one file of the sealed patch —
- * derived from the path's bytes, never from the path's characters, so a
- * hostile file name can neither break the id nor escape the attribute. */
 export function diffFileAnchor(path) {
     return `diff-file-${createHash("sha256").update(path, "utf8").digest("hex").slice(0, 16)}`;
 }
-/** Paths whose churn a reviewer reads first — dependency manifests and
- * locks, CI workflows, container and schema definitions, migrations, the
- * environment files secrets live in, and files NAMED for credentials.
- * The credential words match only as whole `-`/`_`/`.`-delimited pieces
- * of the file name (v2 review, comment 4): `auth.ts`, `api-token.ts`,
- * `secrets.json` count; `author.ts`, `tokenizer.ts`, and `.envelope.ts`
- * are ordinary names and do not. `permission` is not a credential word
- * at all — `permissions-ui.tsx` is a screen, not a secret. */
 export const SENSITIVE_PATH = /(^|\/)(\.github|migrations?)\/|(^|\/)(package(-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|Dockerfile|\.env(\.[^/]+)?|schema[^/]*\.(sql|prisma)|(?:[^/]*[-_.])?(auth|secrets?|tokens?|credentials?)(?:[-_.][^/]*)?)$/i;
 export const LARGE_CHANGE_LINES = 200;
-/** The changed-file list's own review priority: outside the signed
- * touches first, then files a machine cannot diff or a criterion never
- * cited, then the rest by churn. Presentation only — the sealed patch
- * keeps its own order beneath, byte for byte. */
 export function reviewFilePriority(file, proofCitesPaths) {
     const reasons = [];
     let band = 2;
@@ -396,17 +313,7 @@ export function orderChangedFiles(files, proofCitesPaths) {
             ? churn(b) - churn(a)
             : a.path.localeCompare(b.path));
 }
-/** The receipt's own proof-state word, so the cockpit and the task page
- * never disagree on the state's name or its precedence: the stored
- * verdict decides, whatever the run's outcome — a no-change run with a
- * refuted proof reads as refuted, never as "no change needed". The one
- * word the receipt never needs is "No build record": a manual completion
- * has no receipt to share it with. */
-/** The cockpit's headline status: the shared projection over the same
- * verdict, acceptance, and publication rows the task page reads. */
 export function cockpitStatusOf(view) {
-    // The receipt's own status (package 3): the same projection the chat
-    // receipt and the run page print, read from the shared detail.
     if (view.run === null || view.detail === null)
         return view.assignment === null ? resultHeadlineOf(resultStatusOf(null, null)) : assignmentPresentationOf(view.assignment).status;
     const receiptStatus = receiptStatusOf(view.detail.receipt);
@@ -414,9 +321,6 @@ export function cockpitStatusOf(view) {
         return assignmentStatusOf(assignmentWithEvidence(view.assignment, receiptStatus, view.run.id));
     return resultHeadlineOf(receiptStatus);
 }
-/** Turn verifier records into one sentence a project owner can act on.
- * A command-not-found result means the check could not start, not that the
- * product itself failed. The stored record remains unchanged. */
 export function verificationExplanation(verdict, reasons) {
     const plain = reasons.map(reason => {
         if (reason === "the approved verification command passed after the approved setup command ran"
@@ -500,9 +404,6 @@ export function verificationRecovered(reasons) {
     return reasons.some(reason => reason === "the approved verification command passed after the approved setup command ran"
         || reason === "the approved verification command passed after the approved setup command restored project dependencies");
 }
-/** Whether a reviewer can annotate this result's diff here: the shared
- * detail's own answer (a verified, non-empty sealed patch read by a
- * session that holds a CSRF token) — decided once, in `resultDetailOf`. */
 export function canAnnotateDiff(view, csrf) {
     return view !== null && view.detail !== null && csrf !== "" && view.detail.canAnnotate;
 }
@@ -535,8 +436,6 @@ export function reviewCockpitPage(chrome, data) {
         : html `<p class="meta cockpit-beyond" data-cockpit-beyond="1">This result is not in the current review list.</p>`;
     const detailParts = selected === null ? null : reviewCockpitDetailParts(selected, csrf, data.noted, data.canRetryReview, data.tab, data.user);
     const detail = detailParts === null ? html `<section class="cockpit-detail"><p class="meta">Nothing to review yet.</p></section>` : detailParts.html;
-    // The rebuilt page (shadcn/ui): the selected result at full width, the
-    // list one tap away in the header.
     const view = {
         kind: "result",
         results: queue.map(row => {
@@ -575,8 +474,6 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
     const accepted = proof?.accepted !== null && proof?.accepted !== undefined;
     const canAnnotate = canAnnotateDiff(view, csrf);
     const status = cockpitStatusOf(view);
-    // Header: what this is, its verdict word, and why it sits where it does. On a task page the task's own header says
-    // all of it, once.
     if (host.kind === "review")
         parts.push(joinHtml([
             html `<header class="cockpit-head" data-review-task="${view.taskId}">`,
@@ -587,16 +484,13 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         ]));
     if (view.detail === null && view.historyProblem !== null)
         parts.push(html `<p class="problem" data-history-problem>${view.historyProblem} <a href="${taskHref(view.taskId)}">Open task</a></p>`);
-    // The primary next act — exactly one road, chosen from the state.
     parts.push(reviewNextAction(view, csrf, accepted, canAnnotate));
-    // Approved intent: the signed scope's words, the plan's approach.
     const intent = view.intent;
     let intentView = null;
     if (intent === null) {
         parts.push(html `<section class="card cockpit-section" data-cockpit-section="intent"><h3>Approved plan</h3><p class="meta">No plan was filed for this task, so there is no approved goal or boundary to review.</p></section>`);
     }
     else {
-        // The time itself goes to the page as a stamp: the one formatter words it in the viewer's zone.
         const approvalWords = intent.approval.approved
             ? `Approved by ${intent.approvedBy ?? "an approver"}`
             : intent.approval.reason === "changed"
@@ -629,7 +523,6 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         network: view.network ?? null,
         timing: view.timing ?? null,
         acts: { primary: null, secondary: null, line: null }, runChecks: null, mismatch: null,
-        // The raw run record lives under Details now (2026-10-02): /r/<id> for this result redirects here.
         record: run === null ? null : { build: run.id, href: `/r/${run.id}?record=1`, facts: [
                 { label: "Agent", value: [run.provider, run.model].filter(Boolean).join(" · ") },
                 { label: "Builder", value: run.runner },
@@ -643,19 +536,13 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         parts.push(html `<section class="card cockpit-section" id="verification" data-cockpit-section="proof"><h3>Verification</h3><p class="meta">This task has no finished build record, so there are no captured changes or checks to review.</p><p class="row"><a href="${taskHref(view.taskId)}">Open the task →</a></p></section>`);
         return { html: html `<section class="cockpit-detail">${joinHtml(parts, "\n")}</section>`, selected: { ...selected, noRun: "This task has no finished build record, so there are no captured changes or checks to review." } };
     }
-    // The result itself (package 3): the same panel the run page and the
-    // chat's result view render — Summary / Changes / Checks with Request
-    // changes beside it. The cockpit adds its own acts under Checks: the
-    // v50 review-retry panel and the accept-with-exception form.
     const extraChecks = reviewRetryPanel(view.taskId, run.id, view.reviewRetry, { csrf, canAct: false, returnTo: null });
     const here = reviewHref(view.taskId);
-    /** This result's own address on its host, at one of its views (summary when none). */
     const at = (section = "summary") => host.kind === "task"
         ? `${host.base}&run=${run.id}${section === "summary" ? "" : `&section=${section}`}`
         : `${here}&run=${run.id}${section === "summary" ? "" : `&tab=${section}`}`;
     const assignment = view.assignment === null ? null : assignmentWithEvidence(view.assignment, receiptStatusOf(view.detail.receipt), run.id);
     const saved = assignment?.receipt?.checks;
-    // The approved check as the task page reads it (task-status.ts approvedCheckOf): one answer for this whole page.
     const checks = saved === undefined || assignment?.receipt == null ? undefined
         : { ...saved, ...(receiptChecksOf(assignment.receipt) ?? {}), detail: saved.detail };
     if (checks !== undefined)
@@ -676,50 +563,38 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         headStatus: false,
         action: false,
     });
-    // On a task page the result script keeps the result's own view in `section=` (the page's `tab` is the task's).
     if (host.kind === "task")
         panel.panel.attributes = { ...panel.panel.attributes, "data-result-param": "section" };
     parts.push(html `<div id="verification" data-cockpit-section="result">${panel.html}</div>`);
-    // What no acceptance resolves (a failed check, a HIGH finding): Complete is refused, so no Accept is offered and
-    // the one line says the next step.
-    const hardStop = hardBlockerOf(assignment);
+    const hardStop = hardBlockerOf(assignment) ?? view.detail.completeRefusal ?? null;
     const blocked = hardStop ?? cantAcceptYetOf(proof?.verdict ?? null, proof?.reasons ?? [], accepted);
     const youCheck = panel.panel.youCheck;
-    // Accept and finish posts the completion; when an acceptance is owed (the person's own checks, or a reason a
-    // report that doesn't match its changes asks for), the same request records it first.
     const owed = accepted ? null : youCheck?.accept != null ? { note: null } : panel.panel.need?.accept != null ? { note: panel.panel.need.accept.note }
         : blocked === ACCEPT_NEEDS_REASON ? { note: "Why is this safe to accept?" } : null;
     const complete = hardStop === null && assignment?.state === "ready-to-check" && assignment.receipt !== null && canRetryReview && csrf !== ""
         ? { action: `${taskHref(view.taskId)}/complete`, receipt: assignment.receipt.digest, run: run.id, accept: owed, ...(host.kind === "task" ? { returnTo: at() } : {}) } : null;
     if (complete !== null)
         parts.push(completionForm(view.taskId, run.id, complete.receipt, view.detail?.pullRequestTo ?? null, owed));
-    // The one decision, after the evidence: Accept and finish only when every requirement is met and the checks passed.
     const acceptsHere = complete !== null || panel.panel.need?.accept != null || youCheck?.accept != null;
     const matrix = proof === null || proof.proofProblem !== null ? [] : proof.matrix;
     const unanswered = accepted || youCheck == null ? [] : youCheck.items.length > 0 ? youCheck.items.map(one => one.statement === "" ? one.words : one.statement) : youCheck.lines;
     const base = !acceptsHere ? null : acceptWordsOf({
-        // Checks Off that a release check already covers read as passed (release-coverage.ts).
         checks: checks === undefined ? null : { passed: "passed", failed: "failed", running: "running", "not-run": "not-run", off: "off", unreadable: "unavailable" }[approvedCheckStateOf(checks)],
-        // Release-aware words (task-status.ts): a requirement waiting only on a release check, or covered by one, isn't unmet.
         unmet: matrix.filter(row => !["Met", "You check", CHECKED_AT_RELEASE].includes(requirementWordOf(row, null, checks === undefined ? undefined : checkBackingOf(checks)))).length,
         action: complete !== null ? "complete" : "accept",
         publishing: view.detail?.publishing ?? "other",
-        proof: proof !== null && proof.proof !== null && proof.proofProblem === null,
+        proof: proof !== null && proof.proofProblem === null && (proof.proof !== null || proof.matrix.length > 0),
     });
-    // Refuted: plain Accept and finish stays as allowed, in outline, and the one line before the acts (acts.line) says why.
     const settled = base === null || blocked === null ? base : { ...base, label: "Accept", ready: false };
     const decision = settled === null ? null : { sentence: RESULT_DECISION_SENTENCE, ...settled, ...acceptWithChecksOf(settled, { unanswered, notRight: [] }),
         base: { label: settled.label, ready: settled.ready, why: settled.why } };
-    // Run checks: no check ran on this result (or its saved one can't be read), the project has one, and an approver may run it.
     const followUps = view.detail.followUps ?? null;
     const checksRunning = checks?.running != null || (followUps?.checks.some(one => one.state === "waiting" || one.state === "running") ?? false);
     const runChecks = canRetryReview && csrf !== "" && followUps !== null && (followUps.full || followUps.quick) && !checksRunning &&
         (checks === undefined || ((checks.status === "not-run" || checks.status === "unavailable") && checks.release == null))
-        // Back on this result's Checks tab, where #follow-ups shows the run it started.
         ? { action: `/r/${run.id}/checks`, level: followUps.full ? "full" : "quick", returnTo: at("checks") } : null;
     const need = panel.panel.need;
     const nextKind = selected.next?.kind;
-    // A failed build: what went wrong is the card, Retry the act; a link to this same page goes nowhere, so it isn't one.
     const failure = view.failure == null ? null : { line: view.failure.line, evidence: view.failure.evidence, suggestion: view.failure.suggestion, retry: view.failure.retry,
         link: view.failure.link === null || (view.failure.link.href.startsWith(`${here}&run=${run.id}`) && !view.failure.link.href.includes("#")) ? null
             : host.kind === "task" && view.failure.link.href.startsWith(`${here}&run=${run.id}&tab=`) ? { ...view.failure.link, href: view.failure.link.href.replace(`${here}&run=${run.id}&tab=`, `${host.base}&run=${run.id}&section=`) } : view.failure.link,
@@ -738,12 +613,9 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
             notRight: 0,
         };
     const acts = resultActsOf(actFacts);
-    // A refuted result's card lists every recorded disagreement, each tied to its lines; when the report itself doesn't
-    // match the changes (not a failed check), that is the headline.
     const mismatch = failure !== null || proof === null || accepted || proof.verdict !== "refuted" ? null : (() => {
         const patch = view.detail?.terminal?.patch ?? null;
         const files = patch === null || "problem" in patch ? [] : parseReviewDiff(patch.text).files;
-        // Each file's first change: the lines it added (else every line it shows), and where that change starts (its link target).
         const hunkStart = new Map();
         const changes = new Map(files.map(file => {
             const shown = file.hunks[0]?.lines.filter(line => line.newLine !== null && line.kind !== "meta") ?? [];
@@ -755,7 +627,6 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         }));
         const changesHref = at("changes");
         const found = reportMismatchesOf(proof.reasons, proof.proofProblem === null ? proof.matrix : [], changes);
-        // The saved report itself can't be read: that is the evidence problem, said once.
         if (proof.proofProblem !== null)
             found.push({ text: `The saved report can't be read: ${proof.proofProblem}`, path: null, lines: null, inChanges: null, note: null, reason: proof.proofProblem });
         if (found.length === 0)
@@ -779,10 +650,7 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         html: html `<section class="cockpit-detail">${joinHtml(parts, "\n")}</section>`,
         selected: {
             ...selected, complete: failure === null ? complete : null, decision: failure === null ? decision : null, acts, actFacts, runChecks, mismatch, failure,
-            // A failed build reads Failed, whatever its task has done since; its outcome is what went wrong.
-            // Run checks is the decision's own act on this page; a status row never sends the person to Chat for it.
             panel: (() => {
-                // A Chat link to this same result would lead back here: it isn't one.
                 const elsewhere = (href) => href !== null && !href.endsWith("#follow-ups") && !new RegExp(`^/chat\\?task=[^&]+&result=${run.id}(?:&|$)`).test(href);
                 const shown = panel.panel.status === null ? null : view.demo === true ? demoChecksOf(panel.panel.status) : panel.panel.status;
                 const missed = proof === null || proof.proofProblem !== null ? 0 : requirementsOf(proof.matrix)?.missed ?? 0;
@@ -790,9 +658,7 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
                         href: elsewhere(one.href) ? one.href : null, action: one.action !== null && elsewhere(one.action.href) ? one.action : null })) };
                 return failure === null ? { ...panel.panel, status }
                     : { ...panel.panel, outcome: failure.line, need: null, youCheck: null, status: status === null ? null : { ...status, headline: "Failed", tone: "danger", sentence: failure.line, need: null,
-                            // Read as Failed, the Requirements row counts what it missed, as the task's card does.
                             details: status.details.map(one => one.key !== "requirements" || missed === 0 ? one : { ...one, text: `${missed} missed`, mark: "failed", action: null }) },
-                        // What it missed is said once, in plain words above; the recorded wording stays under Details.
                         attention: panel.panel.attention.filter(one => !(proof?.reasons ?? []).includes(one) && !(proof?.matrix ?? []).some(row => row.detail.includes(one))) };
             })(),
             ...(failure === null ? {} : { status: { label: "Failed", tone: "problem", token: "failed" } }),
@@ -800,25 +666,18 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         },
     };
 }
-/** What Accept and finish owes before it completes, as the form asks for it: the server's own rule
- * (owedAcceptance), so the form asks for exactly what the completion requires. */
 export function owedAcceptanceOf(receipt) {
     const owed = owedAcceptance(receipt);
     return owed === null ? null : owed === "person-check" ? { note: null } : { note: "Why is this safe to accept?" };
 }
 export function completionForm(taskId, runId, digest, pullRequestTo = null, accept = null) {
-    // Accept and finish, in one request: with an acceptance owed (the person's own checks, or an exception and
-    // its reason, asked for right here), the same post records it first.
     const reason = accept?.note == null ? "" : html `<label class="meta" for="complete-reason-${runId}">${ACCEPT_NEEDS_REASON}</label><input type="text" id="complete-reason-${runId}" name="note" maxlength="500" required placeholder="${accept.note}">`;
     const options = { attrs: { class: "card result-complete" }, hidden: { receipt: digest, run: runId, accept: accept === null ? null : "1" } };
     if (pullRequestTo !== null) {
-        // With pull requests set up: the PR is the primary road, a bare finish the quiet one beside it.
         return postForm(`${taskHref(taskId)}/complete`, html `${reason}<p class="meta">Finishes the task. A pull request opens on ${pullRequestTo} from this exact commit when you ask for one.</p><div class="result-complete-actions"><button type="submit" name="publish" value="1" style="min-height:44px">Accept and open a pull request</button><button type="submit" class="secondary" style="min-height:44px">Accept</button></div>`, options);
     }
     return postForm(`${taskHref(taskId)}/complete`, html `${reason}<p class="meta">Finishes the task. Checks stay unchanged; nothing is published or deployed.</p><button type="submit" style="min-height:44px">Accept</button>`, options);
 }
-/** The pull request, in one card: its state and link, one line of detail, and the one action it needs — Merge
- * behind the password when checks passed, or Open a pull request for a result completed without one. */
 export function pullRequestCardHtml(pr, csrf) {
     if (pr.view === null) {
         if (pr.offer === null || csrf === "")
@@ -828,7 +687,6 @@ export function pullRequestCardHtml(pr, csrf) {
     const view = pr.view;
     const url = safePrUrl(view.prUrl);
     const link = view.prNumber === null ? "" : url === null ? html `<span class="mono">PR #${view.prNumber}</span>` : html `<a href="${url}" class="mono" rel="noreferrer" target="_blank">PR #${view.prNumber}</a>`;
-    // A pull request's trouble never undoes the result: an ink note, never red.
     const tone = view.state === "ready" || view.state === "merged" ? "ok" : view.state === "failing" || view.state === "failed" ? "problem" : "waiting";
     const revision = view.revisionTask === null || view.state !== "failing" ? "" : html ` <a href="${taskHref(view.revisionTask)}">Open revision</a>`;
     const merged = view.mergeCommit === null ? "" : html `<p class="meta">Merge commit <span class="mono">${view.mergeCommit.slice(0, 12)}</span></p>`;
@@ -837,15 +695,10 @@ export function pullRequestCardHtml(pr, csrf) {
         postForm(`${taskHref(pr.taskId)}/merge`, html `<p class="meta">${view.mergeMethod === "squash" ? "Squash-merges" : view.mergeMethod === "rebase" ? "Rebase-merges" : "Merges"} PR #${view.prNumber} into ${target} and deletes its branch.</p>${reauth(html `<label>Password<input type="password" name="token" autocomplete="current-password" required></label>`)}${view.fullCheck === null ? html `<button type="submit">Merge</button>` : html `<input type="hidden" name="anyway" value="1"><button type="submit" class="secondary">Merge anyway</button>`}`, { attrs: { class: "pull-request-act", "data-merge-form": true }, hidden: { run: view.runId } });
     return html `<section class="card pull-request pull-request--${tone}" id="merge" data-pull-request="${view.state}"><div class="pull-request-head"><strong>${view.label}</strong>${link}</div><p class="meta">${view.detail}${revision}</p>${merged}${act}</section>`;
 }
-/** Exactly one primary road per result, chosen from its state; the
- * others stay reachable from their own sections. Every form posts to the
- * endpoint that already owns the act, with the session's CSRF token; a
- * bearer session (no token) sees the road named, never a form. */
 export function reviewNextAction(view, csrf, _accepted, _canAnnotate) {
     const next = reviewNextActionParts(view, csrf);
     return next === null ? html `` : html `<div class="card cockpit-next" data-next-action="${next.kind}"><div><strong>${next.title}</strong><span class="meta">${next.detail}</span></div>${next.control}</div>`;
 }
-/** The next action for the browser workspace's JSON: its control as markup text. */
 export function reviewNextActionOf(view, csrf, back) {
     const next = reviewNextActionParts(view, csrf, back);
     return next === null ? null : { ...next, control: htmlString(next.control) };
@@ -865,11 +718,6 @@ function reviewNextActionParts(view, csrf, back) {
     }
     return null;
 }
-/**
- * Plain words for the machine's own vocabulary — no internal token ever
- * reaches a page. Every map here has a generic fallback: a kind a newer
- * daemon invents degrades to honest generic prose, never to its raw name.
- */
 export const PHASE_WORDS = {
     "agent-running": "agent working",
     "validating-handoff": "checking the handoff",
@@ -877,7 +725,6 @@ export const PHASE_WORDS = {
     "capturing-evidence": "saving its files",
     committing: "committing",
 };
-/** An agent's phase on the home card, from the machine's own vocabulary. */
 export function homePhaseWords(run) {
     if (run.role === "planner")
         return "Planning";
@@ -892,7 +739,6 @@ export function homePhaseWords(run) {
 export function phaseWords(phase) {
     return PHASE_WORDS[phase] ?? "the agent is working";
 }
-/** A recorded reason in one plain line; machine output (a stack trace, a path, "Error:" text) waits on the run record. */
 export function reasonWords(reason) {
     return isInternalErrorReason(reason) ? "stopped with an internal error" : oneLineOf(runReasonWords(reason.trim().split(/\r?\n/, 1)[0] ?? ""), 140);
 }
@@ -925,7 +771,6 @@ export const EVIDENCE_WORDS = {
     "plan-contract": "Your request",
     "review-context": "Review context",
 };
-/** Byte counts as people read them. */
 export function humanBytes(bytes) {
     if (bytes < 1024)
         return `${bytes} B`;
@@ -936,9 +781,6 @@ export function humanBytes(bytes) {
 export function evidenceWords(kind) {
     return EVIDENCE_WORDS[kind] ?? "a stored record";
 }
-/** The badge for a run's outcome. A null outcome reads "running" ONLY when
- * the caller proved the run's lease is the task's current live claim — an
- * orphaned run keeps saying what actually became of it. */
 export function runOutcomeBadge(run, live) {
     if (!live && run.role === "planner" && run.reason === "plan-drafted") {
         return html `<span class="badge">Planned</span>`;
@@ -950,8 +792,6 @@ export function runOutcomeBadge(run, live) {
         : html `<span class="badge badge-${run.outcome ?? "cut"}">${sentenceCase(run.outcome ?? "never finished")}</span>`;
 }
 export const runNoun = (run) => run.role === "planner" ? "plan" : run.role === "reviewer" ? "review" : run.role === "scout" ? "report" : "build";
-/** What a scout found, each with its link and picture, then any screenshot no item shows. Every link is the cited
- * http(s) address the report parser admitted; every picture is served from verified evidence. */
 export function reportItemsHtml(items, shots, runId) {
     const picture = (shot) => shot.artifactId === null
         ? html `<p class="meta">Screenshot unavailable: ${shot.problem ?? "it can't be shown"}</p>`
@@ -985,11 +825,6 @@ export function runReportView(artifacts, root) {
     return { ok: true, artifactId: artifact.id, title: parsed.report.title, summary: parsed.report.summary, document: parsed.report.report, followUps: parsed.report.followUps.length, truncated: artifact.truncated,
         items: parsed.report.items, shots: reportShotsOf(artifacts, root, artifact.run, parsed.report.images) };
 }
-/** The shared facts (package 3), computed ONCE from the same verified
- * records every surface reads: the head from the sealed diff summary when
- * it verifies (else the run record, and the source is named), the signed
- * criteria passed from the machine's matrix, the proof's caveats, every
- * evidence problem in words, and the observed publication state. */
 export function sharedResultFactsOf(run, proof, terminal, handoff, report, publication) {
     const stat = terminal?.stat ?? null;
     const statOk = stat !== null && !("problem" in stat);
@@ -1037,9 +872,6 @@ export function proofBundleView(store, run, artifacts, root) {
         const path = SCREENSHOT_CAPTURE.exec(artifact.capture)?.[1];
         if (path === undefined)
             return [];
-        // The bytes are re-verified at render (workspace package 3): a shot
-        // whose file is gone or altered is named as unavailable, never shown
-        // as validated visual proof.
         let problem = null;
         try {
             const read = readVerifiedArtifact(root, artifact);
@@ -1055,8 +887,6 @@ export function proofBundleView(store, run, artifacts, root) {
     const uncapturedScreenshots = (proof?.screenshots ?? []).map(one => one.path).filter(path => !stored.has(path));
     let checkLog = null;
     if (checkLogArtifact !== null) {
-        // Re-verified at render: a log whose bytes no longer hash to their
-        // record is a named evidence problem, never shown as output.
         let read;
         try {
             read = readVerifiedArtifact(root, checkLogArtifact);
@@ -1086,9 +916,6 @@ export function proofBundleView(store, run, artifacts, root) {
         screenshots,
         uncapturedScreenshots,
         matrix: verdictRow?.matrix ?? [],
-        // A matrix row links only to records that still verify (repair
-        // 2026-09-14): a damaged screenshot or check log is named as a
-        // problem above, never offered as a download.
         matrixLinks: (() => {
             const damaged = new Set([...screenshots.filter(one => one.problem !== null).map(one => one.artifactId), ...(checkLog !== null && checkLog.problem !== null ? [checkLog.artifactId] : [])]);
             return new Map([...evidenceLinksFor(artifacts)].filter(([, id]) => !damaged.has(id)));
@@ -1101,8 +928,6 @@ export function proofBundleView(store, run, artifacts, root) {
         })(),
     };
 }
-/** What the verdict recorded when the build finished, said beside what holds now: a recorded pass is restated only
- * when the check read now passed; unread, it points to the result; unreadable or failed since, it says so. */
 export function completionWords(verdict, reasons, checks) {
     const recorded = verificationExplanation(verdict, reasons);
     if (verdict !== "verified")
@@ -1116,8 +941,6 @@ export function completionWords(verdict, reasons, checks) {
         : checks?.cause === "command-changed" ? "the check command changed since this check." : `${CHECK_UNREADABLE.charAt(0).toLowerCase()}${CHECK_UNREADABLE.slice(1)}`;
     return `At completion: ${recorded} Now: ${said} It doesn't count as passed.`;
 }
-/** A result's saved approved check as the assignment reads it (assignment.ts): the receipt, follow-ups on its commit,
- * and with checks Off the passing release check that contains it. */
 function savedChecksOf(store, root, run, now) {
     const own = checksFactOf(assignmentChecksForRun(store, root, run.id, now), run.headRevision);
     if (own.level !== "off" || own.status === "passed" || own.status === "failed")
@@ -1161,14 +984,10 @@ export function completionReceiptView(store, run, artifacts, root, review = null
         coverageSecondary: coverage.contextGaps.length === 0 && (coverage.satisfied === true || (coverage.satisfied === null && !coverage.required)),
         report,
         facts: sharedResultFactsOf(run, proof, terminal, handoff, report, publication),
-        // The same reading the task page's Project checks row shows (assignment.ts), never the verdict alone.
         ...(run.role === "scout" ? {} : { checks: savedChecksOf(store, root, run, now) }),
     };
 }
 export const REVIEW_DIFF_LINE_CAP = 4_000;
-/** Parse only the stable structure Git's unified patch format guarantees.
- * Unknown metadata remains visible, and a patch that cannot be structured
- * falls back to the sealed raw record—presentation never becomes proof. */
 export function parseReviewDiff(text) {
     const files = [];
     let file = null;
@@ -1265,7 +1084,6 @@ export function reviewDiffHtml(patch, stat, runId, commentable, anchors = new Ma
                 ? html `<span class="diff-file-counts">binary</span>`
                 : html `<span class="diff-file-counts"><b>+${counts.additions}</b><i>−${counts.deletions}</i></span>`;
         const fileAnchor = anchors.get(one.path);
-        // Each change is a link target of its own (#<file anchor>-L<first new line>): a result names the exact lines.
         const hunks = one.hunks.map(hunk => {
             const first = hunk.lines.find(line => line.newLine !== null && line.kind !== "meta")?.newLine ?? null;
             return html `<section class="diff-hunk"${fileAnchor === undefined || first === null ? "" : html ` id="${fileAnchor}-L${first}"`}><div class="diff-hunk-head">${hunk.header}</div><div class="diff-lines">${hunk.lines.map(line => {
@@ -1275,7 +1093,6 @@ export function reviewDiffHtml(patch, stat, runId, commentable, anchors = new Ma
                     ? html `<span class="diff-annotate-space"></span>`
                     : html `<button type="button" class="diff-annotate pick-line" data-path="${one.path}" data-line="${lineNumber}" data-side="${side}" aria-label="Annotate ${one.path}, ${side} line ${lineNumber}" title="Annotate this line">${annotateIcon}</button>`;
                 const marker = line.kind === "addition" ? "+" : line.kind === "deletion" ? "−" : line.kind === "context" ? " " : "·";
-                // Each real line names its file and line, so a comment (or a test) can find the exact row.
                 const named = lineNumber === null || line.kind === "meta" ? "" : html ` data-diff-file="${one.path}" data-diff-line="${lineNumber}"`;
                 return html `<div class="diff-line diff-${line.kind}"${named}>${annotate}<span class="diff-gutter">${line.oldLine ?? ""}</span><span class="diff-gutter">${line.newLine ?? ""}</span><code><b aria-hidden="true">${marker}</b>${line.text}</code></div>`;
             })}</div></section>`;
@@ -1289,29 +1106,15 @@ export function reviewDiffHtml(patch, stat, runId, commentable, anchors = new Ma
         ? html `<p class="diff-cut">The saved diff was shortened when it was stored: the rest of the change was never captured, here or in the download.</p>`
         : parsed.linesTruncated ? html `<p class="diff-cut">This visual diff is shortened. Review the saved patch before approving.</p>` : ""}</div>${storedDownloadLink(runId, patch.artifactId, "diff", patch.truncated)}`;
 }
-/** The check log as stored (repair 2026-09-14): its output behind a
- * disclosure when the bytes verify — a shortened log says so in the
- * summary and its download is the stored part; a log that no longer
- * verifies is a named problem with no output and no download. */
 export function checkLogHtml(log, runId, extra) {
     if (log.problem !== null) {
         return html `<p class="problem" data-check-log="damaged"${extra}>The check log no longer verifies (${log.problem}). Its output is not shown, and there is nothing to download.</p>`;
     }
-    return html `<details data-check-log="${log.truncated ? "shortened" : "ok"}"${extra}><summary>Check output${log.truncated ? ` (shortened — ${log.bytesStored} of ${log.bytesOriginal} bytes stored)` : ""}</summary><pre class="mono" style="overflow-x:auto;max-height:18rem">${
-    // Each line is a link target (#check-log-L<n>): a failed task names the exact line its check ended on.
-    joinHtml(log.text.split("\n").map((line, index) => html `<span id="check-log-L${index + 1}">${line}</span>`), "\n")}</pre></details>${storedDownloadLink(runId, log.artifactId, "check log", log.truncated)}`;
+    return html `<details data-check-log="${log.truncated ? "shortened" : "ok"}"${extra}><summary>Check output${log.truncated ? ` (shortened — ${log.bytesStored} of ${log.bytesOriginal} bytes stored)` : ""}</summary><pre class="mono" style="overflow-x:auto;max-height:18rem">${joinHtml(log.text.split("\n").map((line, index) => html `<span id="check-log-L${index + 1}">${line}</span>`), "\n")}</pre></details>${storedDownloadLink(runId, log.artifactId, "check log", log.truncated)}`;
 }
-/** The download link for a stored record (repair 2026-09-14): a shortened
- * record's link says it holds the stored part only — never "the full"
- * bytes that were cut at storage and exist nowhere. */
 export function storedDownloadLink(runId, artifactId, what, truncated) {
     return html `<p class="meta"><a href="/r/${runId}/evidence/${artifactId}">${truncated ? `Download the stored part of the ${what} (shortened at storage — not the full ${what})` : `Download the ${what}`}</a></p>`;
 }
-/** Render the terminal diff card: stat and capture health first, the bounded
- * patch beneath a fold. `editor` (arc 6) links file rows to vscode:// on the
- * reviewing device; `commentable` adds a per-file "comment" button the
- * page's prefill script reads — a real button, keyboard-reachable, separate
- * from the link so the two never fight over one click (finding 4). */
 export function terminalDiffCard(view, runId, editor = null, commentable = false) {
     const parts = [html `<h2>What changed</h2>`];
     if (view.stat === null) {
@@ -1355,22 +1158,12 @@ export function terminalDiffCard(view, runId, editor = null, commentable = false
     }
     return joinHtml(parts, "\n");
 }
-/**
- * The evidence bundle (Priority 2): the closed verdict first — the one
- * sentence every other surface agrees with — then criteria, the agent's
- * declared checks, the plane's own re-run (labeled "re-run here", never
- * confused with the agent's own claim), caveats, and every validated
- * screenshot as a thumbnail linking to the full image. Renders nothing
- * when the run predates the proof system.
- */
 export function evidenceBundleCard(view, run, publication = null, review = null) {
     if (view === null)
         return html ``;
     const runId = run.id;
     const parts = [html `<h2>Checks and saved files</h2>`];
     if (view.verdict !== null) {
-        // The same status line every other surface renders for this run
-        // (workspace package 1), beside the verdict's own explanation.
         const status = resultStatusOf({ runId, role: run.role, outcome: run.outcome, verdict: view.verdict, reasons: view.reasons, accepted: view.accepted !== null, review,
             ...(view.checks === undefined ? {} : { checks: view.checks }) }, publication);
         parts.push(html `<p class="row" data-proof-verdict="${dispatchStatusToken(view.verdict)}">${statusLineHtml(status)} <span class="meta">${completionWords(view.verdict, view.reasons, view.checks)}</span></p>`);
@@ -1407,14 +1200,6 @@ export function evidenceBundleCard(view, run, publication = null, review = null)
     }
     return parts.length === 1 ? html `` : joinHtml(parts, "\n");
 }
-/** A calm, scan-first result receipt for the task and its focused chat.
- * The full ledger remains one click away; this card carries only the facts
- * needed to decide whether to inspect, discuss, or move on. */
-/** The receipt's proof-state word and tone, from the stored verdict and
- * the operator's acceptance alone — shared with the review cockpit's
- * header chip so the two surfaces never name one state differently. */
-/** The receipt's facts as the shared projection reads them. */
-/** A result's follow-ups: checks run on its commit since it finished, and its tests task. */
 export function followUpsFor(store, evidenceRoot, run, now) {
     if (run.role !== "builder" || run.finishedAt === null || run.headRevision === null)
         return null;
@@ -1424,9 +1209,7 @@ export function followUpsFor(store, evidenceRoot, run, now) {
         quick: repo !== null && liveQuickCommand(store, repo) !== null, full: repo !== null && store.liveVerifyCommand(repo) !== null };
 }
 export const FOLLOW_UP_WORDS = { waiting: "waiting for a builder", running: "running", passed: "passed", failed: "failed", "not-run": "didn't run" };
-/** Run checks and Add tests, under the result's Checks: what ran since, then the two acts. */
 export function followUpsHtml(followUps, runId, o) {
-    // A batch check names every result it ran with and the exact commit it tested (batch-checks.ts).
     const batchHow = (one) => {
         const peers = one.batch?.members.filter(member => member.run !== runId).map(member => member.task) ?? [];
         return one.batch?.mode === "together" && peers.length > 0 ? ` together with ${peers.join(", ")}`
@@ -1441,9 +1224,6 @@ export function followUpsHtml(followUps, runId, o) {
     return html `<section class="result-section follow-ups" id="follow-ups" data-follow-ups><strong>Follow-ups</strong>${rows.length === 0 ? "" : html `<ul class="follow-up-list">${rows}</ul>`}${canCheck || followUps.repo === null ? "" : html `<p class="meta">No approved check to run. <a href="/settings/checks?repo=${encodeURIComponent(followUps.repo)}">Set one up</a>.</p>`}${checkActs === null && tests === null ? "" : html `<div class="follow-up-acts">${checkActs}${tests}</div>`}</section>`;
 }
 export function receiptStatusOf(view, review = view.review) {
-    // The evidence health rides the status (repair 2026-09-14): a result
-    // whose stored records are damaged is never called ready on the strength
-    // of a verdict recorded before the damage.
     return evidenceResultStatusOf({ runId: view.runId, role: view.role, outcome: view.outcome, verdict: view.verdict, reasons: view.reasons, accepted: view.accepted, recordComplete: view.recordComplete, review,
         ...(view.checks === undefined ? {} : { checks: view.checks }) }, view.publication, view.facts.evidenceHealth);
 }
@@ -1451,8 +1231,6 @@ export function completionReceiptCard(view, taskId, place, standing = receiptSta
     const current = assignment?.receipt?.runId === view.runId ? assignment : null;
     const presentation = current === null ? null : assignmentPresentationOf(current);
     const status = presentation?.status ?? standing;
-    // The verdict on record, whatever review is in flight: the criteria
-    // count's source label reads from it, never from the review's tone.
     const stored = receiptStatusOf(view, null);
     const inReview = REVIEW_TOKENS.has(status.token);
     const facts = view.facts;
@@ -1470,9 +1248,6 @@ export function completionReceiptCard(view, taskId, place, standing = receiptSta
     const criteria = facts.checks === null
         ? "No requirements set"
         : `${facts.checks.passed}/${facts.checks.total} requirements met`;
-    // The deliverable leads (package 3): a scout's report by its title, UI
-    // work by its validated screenshots. Unverifiable shots are counted as
-    // unavailable, never shown, never called validated.
     const lead = view.report !== null
         ? view.report.ok
             ? html `<p class="receipt-report"><strong>${view.report.title}</strong> <span class="meta">${oneLineOf(view.report.summary, 240)}</span></p>`
@@ -1482,16 +1257,10 @@ export function completionReceiptCard(view, taskId, place, standing = receiptSta
             : html `<div class="receipt-visuals" aria-label="validated screenshots">${shown
                 .slice(0, 4)
                 .map(shot => html `<a class="receipt-shot" href="/r/${view.runId}/evidence/${shot.artifactId}"><img src="/r/${view.runId}/evidence/${shot.artifactId}" alt="${shot.caption}"><span>${shot.caption}</span></a>`)}</div>`;
-    // Caveats and evidence problems stay in the open, ahead of the counts
-    // and any readiness words below them.
     const attention = current === null ? [...facts.evidenceProblems, ...view.caveats] : [];
     const caveats = attention.length === 0
         ? ""
         : html `<div class="receipt-caveats" data-result-attention="${attention.length}"><strong>Before you move on</strong><ul>${attention.map(one => html `<li>${plainReasonWords(one)}</li>`)}</ul></div>`;
-    // v51: semantic coverage, distinct from the machine proof word above —
-    // the same lines the CLI prints, so chat and terminal cannot disagree.
-    // Nothing owed (optional and unsettled, or satisfied) folds behind a
-    // disclosure; a strict shortfall or a context gap stays in the open.
     const coverage = view.coverage.length === 0
         ? ""
         : current !== null || view.coverageSecondary
@@ -1502,25 +1271,16 @@ export function completionReceiptCard(view, taskId, place, standing = receiptSta
         html `<section class="card completion-receipt" data-card-kind="result-receipt"${attributes(resultFactsAttributeMap(facts))}>`,
         html `<div class="receipt-head"><div><h2>${receiptHeadingOf(view.outcome, view.publication, view.role)}</h2></div>`,
         html `${headline ? statusLineHtml(status) : ""}</div>`,
-        // The agent's handoff is its narrative, labeled as such; the
-        // publication line is the observed record — never "shipped".
         lead,
         html `<p class="receipt-summary">${conciseOutcomeOf(view.summary ?? (view.outcome === "no-change" ? "The agent found that no repository change was needed." : "The build finished without a concise handoff."))}</p>`,
         headline ? html `<div class="receipt-actions"><a class="button-link" href="${resultHref}" data-open-result data-primary-action>${status.action?.label ?? "Open result"}</a></div>` : "",
-        // A pull request that couldn't open never undoes the result: an ink note, not red.
         view.publication?.state === "failed" ? html `<p class="receipt-note">${statusIconSvg("note")} Pull request couldn't open. The commit is safe locally.</p>` : "",
         caveats,
         coverage,
         html `<details class="receipt-details"><summary>${STATUS_MORE}</summary>`,
         view.summary !== null && view.summary !== conciseOutcomeOf(view.summary) ? html `<p class="recap">${view.summary}</p>` : "",
         html `<p class="receipt-publication" data-receipt-publication="${facts.publicationState}">${facts.publicationWords}</p>`,
-        // A review in flight is the receipt's primary status too (its chip
-        // above); the detail — the earlier verdict as history (review fixes,
-        // finding 4) — is secondary, behind a native disclosure that reads the
-        // same words on the task page and in chat.
         inReview ? html `<details class="receipt-history"><summary>Review history</summary><p class="receipt-review meta" data-receipt-review="${status.token}">${status.detail}</p></details>` : "",
-        // The matrix count is the proof's own citation; it reads as verified
-        // only when the machine verified the result (workspace package 1).
         html `<div class="receipt-facts"><span><strong>${criteria}</strong><small>${stored.tone === "problem" ? html `the agent's own word — not checked` : stored.token === "agent-attested" ? html `the agent's own word, no project check` : "against the approved plan"}</small></span>`,
         html `<span><strong>${diff}</strong><small>${facts.head === null ? "no commit recorded" : `head ${facts.head.slice(0, 7)} · ${facts.headSource ?? ""}`}</small></span>`,
         html `<span><strong>${view.screenshots.length} screenshot${view.screenshots.length === 1 ? "" : "s"}</strong><small>${view.screenshots.length === 0 ? "none required or captured" : unavailable === 0 ? "checked screenshots" : `${unavailable} unavailable — not validated`}</small></span></div>`,
@@ -1528,19 +1288,13 @@ export function completionReceiptCard(view, taskId, place, standing = receiptSta
         place === "task"
             ? html `<a href="${taskChatHref(taskId)}">Discuss in chat →</a>`
             : html `<a href="/r/${view.runId}">Full build record →</a>`,
-        // The cockpit (Priority 5): the same records, arranged for a reviewer.
         html `<a href="${reviewHref(taskId)}">Open result →</a>`,
         html `</div></details></section>`,
     ]);
 }
-/** The revision form's binding (repair 2026-09-14): the exact ids of the
- * notes this page displays and the source terms it was rendered against.
- * The server seals these ids and no others. */
 export function revisionSealFields(comments, sourceDigest) {
     return html `<input type="hidden" name="batch" value="${revisionBatchOf(comments)}"><input type="hidden" name="source" value="${revisionSourceOf(sourceDigest)}">`;
 }
-/** Older machine-checked results saved a mechanical sentence; say the same
- * facts in plain words (the version id stays, shortened). */
 export function plainConclusionOf(conclusion) {
     const prepared = /^Prepared candidate ([0-9a-f]{7,40}) was checked out by the machine; no agent ran\. (The branch already matched it\.|The sealed diff spans this task's base to that candidate\.)/.exec(conclusion);
     if (prepared === null)
@@ -1551,7 +1305,6 @@ export function plainConclusionOf(conclusion) {
 export function resultPanelHtml(detail, o) {
     return resultPanelParts(detail, o).html;
 }
-/** The panel's HTML and the same panel in parts, for the rebuilt result page. */
 export function resultPanelParts(detail, o) {
     const { run, receipt, proof, terminal, handoff } = detail;
     const facts = receipt.facts;
@@ -1566,11 +1319,8 @@ export function resultPanelParts(detail, o) {
     const status = presentation?.status ?? resultHeadlineOf(receiptStatusOf(receipt));
     const stored = receiptStatusOf(receipt, null);
     const humanReview = manualReviewOnly(proof === null ? null : { ...proof, verdict: proof.verdict ?? "" });
-    // Needs you: the action that resolves it comes first; Request changes stays beside it, never alone.
-    // On the result itself, "Review result" would link here: accepting it is what resolves it.
     const need = needActionOf(current, taskStatus, o.csrf, o.returnTo, {
         accepted: proof?.accepted != null, humanReview, run: run.id, action: `${taskHref(detail.taskId)}/accept-proof`, refuted: proof?.verdict === "refuted",
-        // What Store.finalResultReason refuses: a verified, attested, accepted or published result.
         rebuildable: proof?.accepted == null && proof?.verdict !== "verified" && proof?.verdict !== "attested" && !(detail.publication !== null && ["pushed", "opened"].includes(detail.publication.state))
     });
     const directAssessment = proof?.matrix.some(row => row.assessment !== undefined) === true;
@@ -1588,34 +1338,22 @@ export function resultPanelParts(detail, o) {
     const patchOk = patch !== null && !("problem" in patch);
     const lead = resultLeadOf({ role: run.role, report: receipt.report !== null, screenshots: shown.length, diff: (patchOk && patch.text.trim() !== "") || (statOk && stat.fileCount > 0) });
     const tabHref = (tab) => o.hrefFor(tab);
-    // ---- attention: problems and caveats, ahead of every readiness word ----
     const publication = detail.publication;
     const prUrl = publication === null ? null : safePrUrl(publication.prUrl);
     const attention = [];
-    // The visible status already says verification is needed. Only omit the
-    // generic repeat; failed checks, specific reasons and damaged evidence stay.
     const missingVerdictNamed = o.headStatus !== false && status.token === "verification-needed" && receipt.verdict === null && receipt.reasons.length === 0;
     if (current == null && !humanReview && !awaitingGoalReview && (!directAssessment || physicalReasons.length > 0) && !missingVerdictNamed && stored.token !== "evidence-damaged" && (stored.tone === "problem" || stored.tone === "attention")) {
-        // A recorded pass whose check can't be read now is said as what holds now, never as the verdict's pass.
-        // A recorded pass the check read now can't stand behind (unreadable, or failed since) is said as what holds now.
         attention.push(stored.token === "check-unreadable" || (receipt.verdict === "verified" && stored.token === "checks-failed") ? stored.detail : verificationExplanation(receipt.verdict, physicalReasons));
     }
-    // Exact criterion assessment notes are already shown in Requirements;
-    // do not repeat them as a second current attention message.
     if (presentation !== null)
         attention.push(...presentation.attention.map(one => one.detail).filter(detail => !assessmentReasons.has(detail)));
     if (current == null)
         attention.push(...facts.evidenceProblems);
     if (detail.outsideTouches.length > 0)
         attention.push(`${detail.outsideTouches.length} changed file${detail.outsideTouches.length === 1 ? "" : "s"} outside the approved paths: ${detail.outsideTouches.join(", ")}.`);
-    // A failed caveat can already be quoted in full by its verification
-    // reason. Keep that explanation once and retain every other caveat.
     if (current == null)
         attention.push(...receipt.caveats.filter(caveat => !historicalAssessmentReason(caveat) && !attention.some(problem => problem.includes(caveat))));
     attention.push(...(handoff?.followUps ?? []).map(one => `Follow-up: ${one}`));
-    // The automatic review: a HIGH that did not send the work back, or a review
-    // that could not finish, is the person's to see. (Said once when the
-    // current assignment already carries it.)
     const automatic = detail.automaticReview ?? null;
     if (automatic !== null && automatic.sentBackAs === null) {
         const reviewed = [...(automatic.state === "not-reviewed" ? [`Not reviewed: ${automatic.reason ?? "the automatic review did not finish"}.`] : []), ...automatic.high.map(one => `Review: ${findingWords(one)}`)];
@@ -1623,17 +1361,11 @@ export function resultPanelParts(detail, o) {
             if (!attention.includes(line))
                 attention.push(line);
     }
-    // Publication risks stay in the open (repair 2026-09-14); the routine
-    // publication fact lives with the build details below.
-    // With the shared status, the pull request is its own quiet row (its reason under Details).
     if (publication !== null && publication.state === "failed" && taskStatus === null) {
         attention.push(`Publication failed after ${publication.attempts} attempt${publication.attempts === 1 ? "" : "s"}${publication.lastError === null ? "" : ` — ${oneLineOf(publication.lastError, 200)}`}. No pull request or merge is recorded.`);
     }
     if (detail.ciFailing && publication !== null && taskStatus === null)
         attention.push(`CI is failing on PR #${publication.prNumber} at the last check.`);
-    // Requirements only a person can confirm: plain words and one Accept,
-    // in neutral ink — nothing failed. Accepting records the person's
-    // decision and leaves the recorded checks as they are.
     const personChecks = proof === null || proof.accepted !== null ? [] : [
         ...proof.matrix.filter(row => row.state === "manual-review").map(row => personCheckWords(row.statement)),
         ...(proof.matrix.length > 0 ? [] : proof.reasons.filter(reason => manualReviewCriterionOf(reason) !== null).map(() => personCheckWords(null))),
@@ -1650,14 +1382,9 @@ export function resultPanelParts(detail, o) {
     const attentionHtml = attention.length === 0
         ? ""
         : html `<div class="result-attention" data-result-attention="${attention.length}"><ul>${attention.map(one => html `<li>${plainReasonWords(one)}</li>`)}</ul></div>`;
-    // ---- one outcome, one action (repair 2026-09-14) ------------------------
-    // The outcome is the handoff's first sentence, bounded; the agent's full
-    // account waits behind a disclosure in Summary so nothing is said twice.
     const conclusion = plainConclusionOf(receipt.summary ?? (run.outcome === "no-change" ? "The agent found that no repository change was needed." : "The build finished without a concise handoff."));
     const outcome = conciseOutcomeOf(conclusion);
-    // A failing pull request keeps its repair draft beside the need's action.
     const action = o.action === false ? "" : need !== null ? html `${resultNeedAction(need, o, detail.canAnnotate)}${detail.ciFailing && o.csrf !== "" ? resultPrimaryAction(detail, o, prUrl) : ""}` : resultPrimaryAction(detail, o, prUrl);
-    // ---- summary: the deliverable first ----------------------------------
     const summaryParts = [];
     const report = receipt.report;
     if (lead === "report") {
@@ -1668,10 +1395,6 @@ export function resultPanelParts(detail, o) {
             summaryParts.push(html `<p class="problem" data-result-report="problem">The report cannot be shown: ${report.problem}.</p>`);
         }
         else {
-            // Escaped text in a fenced block, never markup, never a page: the
-            // download serves the exact stored bytes as text. The summary is
-            // already the outcome line above (and, when shortened there, waits
-            // in "What the agent reported"), so the article never repeats it.
             summaryParts.push(html `<article class="result-report" data-result-report="ok"><h3>${report.title}</h3>${reportItemsHtml(report.items, report.shots, runId)}<pre class="recap plan-doc">${report.document}</pre><p class="meta"><a href="/r/${runId}/evidence/${report.artifactId}">${report.truncated ? "Download the stored part of the report (shortened at storage — not the full report)" : "Download the report"}</a>${report.followUps === 0 ? "" : html ` · ${report.followUps} proposed follow-up${report.followUps === 1 ? "" : "s"} on <a href="${taskHref(detail.rootId ?? detail.taskId)}">the task</a>`}</p></article>`);
         }
     }
@@ -1681,23 +1404,18 @@ export function resultPanelParts(detail, o) {
     }
     const unavailableShots = shots.filter(one => one.problem !== null);
     if (lead === "changes") {
-        // Code work: the changed files ARE the deliverable; the diff is one tap away.
         summaryParts.push(html `<p class="result-files-lead">${detail.files.length === 0 ? "" : html `${joinHtml(detail.files.slice(0, 6).map(one => html `<span class="mono">${one.path}</span>`), ", ")}${detail.files.length > 6 ? ` and ${detail.files.length - 6} more` : ""} — `}<a href="${tabHref("changes")}" data-result-goto="changes">see the diff</a></p>`);
     }
     if (lead === "summary" && run.outcome === "no-change")
         summaryParts.push(html `<p class="meta">The agent found that no repository change was needed${statOk && stat.fileCount === 0 ? "; the saved diff is empty" : ""}.</p>`);
-    // The agent's own account — its full conclusion (when the outcome line
-    // shortened it), what it says it changed, and how it checked — on demand.
     const agentAccount = [
         ...(conclusion !== outcome ? [html `<p class="recap">${conclusion}</p>`] : []),
         ...(handoff !== null && handoff.changes.length > 0 ? [html `<ul class="result-changes">${handoff.changes.map(one => html `<li>${one}</li>`)}</ul>`] : []),
         ...(handoff !== null && handoff.verification.length > 0 ? [html `<p class="meta">Checked by the agent:</p><ul class="result-changes" data-cockpit-source="agent-words">${handoff.verification.map(one => html `<li>${one}</li>`)}</ul>`] : []),
-        // The report's own notes, each a link target (#report-note-<n>) a mismatch can point at.
         ...(proof?.proof == null || proof.proof.caveats.length === 0 ? [] : [html `<p class="meta">Its notes:</p><ol class="result-changes" data-report-notes>${proof.proof.caveats.map((one, index) => html `<li id="report-note-${index + 1}">${one}</li>`)}</ol>`]),
     ];
     if (agentAccount.length > 0)
         summaryParts.push(html `<details class="result-notes" data-result-notes-agent><summary>What the agent reported</summary>${agentAccount}</details>`);
-    // MEDIUM and LOW never block: suggested follow-ups, on request.
     if (automatic !== null && automatic.followUps.length > 0) {
         summaryParts.push(html `<details class="result-notes" data-review-followups="${automatic.followUps.length}"><summary>Suggested follow-ups · ${automatic.followUps.length}</summary><ul class="result-changes">${automatic.followUps.map((one, index) => html `<li><span class="badge">${one.severity === "MEDIUM" ? "Medium" : "Low"}</span> <span class="mono">${`${one.file}:${one.line}`}</span> ${one.scenario}${o.csrf === "" ? "" : postForm(`${taskHref(detail.taskId)}/follow-through`, html `<input type="hidden" name="act" value="send"><input type="hidden" name="pointer" value="${`${automatic.run}:${automatic.high.length + index + 1}`}"><button type="submit" class="secondary">Send to the agent</button>`)}</li>`)}</ul></details>`);
     }
@@ -1720,8 +1438,6 @@ export function resultPanelParts(detail, o) {
     if (o.place !== "chat")
         links.push(html `<a href="${taskChatHref(detail.rootId ?? detail.taskId)}">Discuss in chat →</a>`);
     links.push(html `<a href="${taskHref(detail.rootId ?? detail.taskId)}">Task overview →</a>`);
-    // Technical facts on demand: build, agent, exact commits, evidence
-    // sources, the publication record, and the other pages for this result.
     summaryParts.push(joinHtml([
         html `<details class="result-details" data-result-details><summary>Build details</summary>`,
         unavailableShots.length === 0 ? "" : html `<ul class="result-unavailable meta" data-result-unavailable="${unavailableShots.length}">${unavailableShots.map(one => html `<li>Screenshot unavailable — <span class="mono">${one.path}</span>: ${one.problem ?? ""}</li>`)}</ul>`,
@@ -1737,7 +1453,6 @@ export function resultPanelParts(detail, o) {
         html `<p class="result-links meta">${links}</p>`,
         html `</details>`,
     ]));
-    // ---- changes -----------------------------------------------------------
     const changeParts = [];
     if (terminal === null) {
         changeParts.push(html `<p class="meta">No final diff or change summary was captured for this build${run.role === "scout" ? " — an investigation changes nothing in the repository" : ""}.</p>`);
@@ -1779,7 +1494,6 @@ export function resultPanelParts(detail, o) {
         else
             changeParts.push(reviewDiffHtml(patch, stat, runId, detail.canAnnotate, detail.fileAnchors));
     }
-    // ---- checks --------------------------------------------------------------
     const checkParts = [];
     const reviewerNotes = detail.reviewerFindings.map(one => html `<li><span class="badge${one.severity === "problem" ? " badge-failed" : ""}">${one.severity ?? "note"}</span> ${one.path === null ? "" : html `<span class="mono">${one.path}${one.line === null ? "" : `:${one.line}`}</span> `}${one.note} <span class="meta">— ${one.author}</span>${!isRevisionFeedback(one) && detail.canAnnotate && o.csrf !== "" ? html ` <button type="button" class="pick-file" data-path="${one.path ?? ""}" data-line="${one.line ?? ""}" data-review-note="${one.note}">Request change</button>` : ""}</li>`);
     if (proof === null && reviewerNotes.length > 0)
@@ -1792,12 +1506,8 @@ export function resultPanelParts(detail, o) {
     }
     else {
         if (proof.verdict !== null && !directAssessment) {
-            // The same status line the panel leads with (one status per surface,
-            // workspace package 1), beside the machine verdict's own explanation.
-            // A recorded pass the saved check can't show now is said so here too (task-status.ts approvedCheckOf).
             const shown = current?.receipt != null ? receiptChecksOf(current.receipt) : receipt.checks === undefined ? undefined : approvedCheckOf(proof.verdict, proof.reasons, receipt.checks);
             const unreadNow = proof.verdict === "verified" && shown !== undefined && shown?.status !== "passed" && !humanReview;
-            // completionWords: the verdict at completion, and what holds now when they differ.
             const words = humanReview ? "At completion: Human review required for the requirements below." : unreadNow ? completionWords(proof.verdict, proof.reasons, shown) : `At completion: ${verificationExplanation(proof.verdict, proof.reasons)}`;
             checkParts.push(html `<p class="row result-verdict" data-proof-verdict="${dispatchStatusToken(proof.verdict)}"${unreadNow ? html ` data-check-now="${approvedCheckStateOf(shown) ?? "unreadable"}"` : ""}><span class="meta">${words}</span></p>`);
         }
@@ -1838,19 +1548,15 @@ export function resultPanelParts(detail, o) {
     }
     if (followUps !== null && run.role === "builder")
         checkParts.push(followUpsHtml(followUps, runId, o));
-    // The handoff's own account of its checks — the agent's words, labeled
-    // as such, whether or not a proof exists.
     if (!directAssessment && handoff !== null && handoff.verification.length > 0)
         checkParts.push(html `<div class="result-section" data-cockpit-source="agent-words"><strong>The agent's own account</strong><ul>${handoff.verification.map(one => html `<li>${one}</li>`)}</ul></div>`);
     if (o.extraChecks !== undefined)
         checkParts.push(o.extraChecks);
-    // ---- request changes: both feedback styles, one sealed road ------------
     const requestParts = [html `<h3 class="so-sr-only">What should change?</h3>`];
     const imageNote = (one) => {
         if (one.image == null)
             return html ``;
         const shot = shots.find(shot => shot.artifactId === one.image.artifact && shot.sha256 === one.image.sha256 && one.image.run === runId && shot.problem === null);
-        // A live saved note whose screenshot no longer verifies can be kept without it, so it never blocks a revision.
         const drop = o.csrf === "" || !(detail.unusableImageNotes ?? []).includes(one.id) ? html ``
             : postForm(`/r/${runId}/comment`, html `<input type="hidden" name="intent" value="drop-image"><input type="hidden" name="comment" value="${String(one.id)}"><button type="submit" class="quiet">Keep note without screenshot</button>`, { attrs: { class: "feedback-image-drop" }, returnTo: o.returnTo, hidden: { tab: o.tab } });
         return html `<figure class="feedback-image">${shot === undefined ? html `<figcaption>Screenshot ${one.image.artifact} is unavailable.</figcaption>`
@@ -1871,8 +1577,6 @@ export function resultPanelParts(detail, o) {
         requestParts.push(html `<details class="result-feedback-history"><summary>Earlier feedback</summary><div class="diff-comments" data-past-feedback>${detail.pastComments.map(one => html `<div class="diff-comment">${imageNote(one)}<p>${one.path === null ? "" : pathWords(one.path, one.line)}${one.note}</p><span class="meta">${one.author} · ${whenTime(one.createdAt)}</span></div>`)}</div></details>`);
     }
     for (const revision of detail.revisions) {
-        // The child's standing is the shared status projection's own words
-        // (repair 2026-09-14): current exact approval and actual activity.
         requestParts.push(html `<p class="result-revision" data-result-revision="${revision.id}" data-result-revision-approved="${revision.approved ? "1" : "0"}" data-tone="${revision.tone}"><strong>Revision</strong> <a href="${taskHref(revision.id)}">${revision.title}</a> <span class="meta">· ${revision.standing}</span></p>`);
     }
     if (o.csrf === "") {
@@ -1894,7 +1598,6 @@ export function resultPanelParts(detail, o) {
             html `<div class="result-feedback-actions"><button type="submit" name="intent" value="revise" data-request-changes>Send back</button><button type="submit" name="intent" value="note" class="quiet" data-save-feedback>Save for later</button></div>`,
         ]), { attrs: { class: "diff-comment-form", id: "comment-form" }, returnTo: o.returnTo, hidden: { tab: o.tab, request: o.requestToken } })}</details>`);
     }
-    // ---- the panel ---------------------------------------------------------
     const tabCounts = {
         summary: "",
         changes: statOk ? (stat.fileCount === 0 ? "none" : `${stat.fileCount} file${stat.fileCount === 1 ? "" : "s"}`) : terminal === null ? "none" : "",
@@ -1907,7 +1610,6 @@ export function resultPanelParts(detail, o) {
         html `<section class="card result-panel" id="result" data-result-panel data-result-place="${o.place}" data-result-lead="${lead}" data-result-task="${detail.rootId ?? detail.taskId}" data-result-user="${o.user}"${attributes(resultFactsAttributeMap(facts))}>`,
         o.back === null ? "" : html `<p class="result-back"><a href="${o.back.href}" data-result-back>← ${o.back.label}</a></p>`,
         (detail.history ?? ""),
-        // One headline: with the shared status, its words lead (task-status.ts); "Changes saved" would compete with them.
         taskStatus !== null && o.headStatus !== false
             ? html `<header class="result-head"><div data-headline-tone="${taskStatus.tone}"><h2 class="status-headline" data-work-status="${status.token}"><i aria-hidden="true"></i>${taskStatus.headline}</h2><p class="status-sentence">${taskStatus.sentence}</p></div></header>`
             : html `<header class="result-head"><div><h2>${heading}</h2></div>${o.headStatus === false ? "" : statusLineHtml(status)}</header>`,
@@ -1933,7 +1635,6 @@ export function resultPanelParts(detail, o) {
         reviewHistory: REVIEW_TOKENS.has(status.token) ? status.detail : null,
         attention: attention.filter(one => !shortenedMaterialReason(one)).map(plainReasonWords),
         youCheck,
-        // The same counts as the Requirements row (a refuted report verifies none of them, and says Unverified).
         requirements: proof === null || proof.verdict === "refuted" ? null : requirementsOf(proof.matrix),
         limits: attention.filter(one => shortenedMaterialReason(one)),
         tabs: RESULT_TABS.map(tab => ({ key: tab.key, label: tab.key === "checks" && proof?.matrix.some(row => row.assessment !== undefined) ? "Requirements" : tab.label, count: tabCounts[tab.key], href: o.hrefFor(tab.key), active: tab.key === o.tab })),
@@ -1947,12 +1648,7 @@ export function resultPanelParts(detail, o) {
     };
     return { html: panelHtml, panel };
 }
-/** Changed lines shown beside one "You check this one" item: at most this many per file, three files. */
 export const CHECK_EXCERPT_LINES = 12;
-/** Each requirement only a person can confirm, with the evidence to judge
- * it by, inline: the changed lines in the files it cites (citing none, the
- * change's first file, labelled as not cited), the screenshots it cites
- * (none cited: every validated one), and the agent's own note. */
 export function personCheckItems(proof, patchText, shots, runId) {
     const rows = proof.matrix.filter(row => row.state === "manual-review");
     if (rows.length === 0)
@@ -1978,35 +1674,27 @@ export function personCheckItems(proof, patchText, shots, runId) {
         };
     });
 }
-/** The completion blocker no acceptance resolves (a failed check, an unresolved HIGH finding), in words, or null. */
 export function hardBlockerOf(assignment) {
     return assignment?.readiness?.blockers.find(one => one.key === "check-failed" || one.key === "high")?.message ?? null;
 }
-/** A Needs you result's one action (needs-you.ts): a link to the act that resolves it, or Confirm it
- * stopped behind the password. Null under every other headline. */
 export function needActionOf(assignment, status, csrf, returnTo, result) {
     if (assignment === null || status === null || status.headline !== "Needs you" || status.need == null)
         return null;
-    // Accepting can't resolve it: Request changes is the way on, beside the reason.
     if (result !== undefined && hardBlockerOf(assignment) !== null)
         return null;
     const action = assignment.primaryAction;
     const rebuild = { href: null, confirm: null, rebuild: { action: `${taskHref(assignment.rootId)}/requeue` } };
-    // Built to an earlier plan: Build again, in place (the task page's requeue).
     if (action?.code === "retry-task" && status.need.key === "rebuild" && csrf !== "")
         return { label: status.need.action.label, ...rebuild };
     if (result !== undefined) {
         if ((status.need.key === "review-result" || result.refuted === true) && !result.accepted && csrf !== "")
             return { label: result.humanReview ? "Accept result" : "Accept with exception", href: null, confirm: null,
                 accept: { action: result.action, run: result.run, returnTo, note: result.humanReview ? null : "Why is this safe to accept?" } };
-        // The task page sends the person here: never back to it. What this page can do leads — Accept
-        // a check only a person can make, or Build again a result that may run again.
         const here = (action?.code === "open-result" || action?.code === "inspect-run") && action.target.runId === result.run;
         if (here && csrf !== "" && !result.accepted && result.humanReview)
             return { label: "Accept result", href: null, confirm: null, accept: { action: result.action, run: result.run, returnTo, note: null } };
         if (here && csrf !== "" && result.rebuildable === true)
             return { label: NEEDS.rebuild.action.label, ...rebuild };
-        // Nothing here resolves it: no act at all, never a link back to the task (which sends the person here).
         if (status.need.key === "review-result" || here)
             return null;
     }
@@ -2014,7 +1702,6 @@ export function needActionOf(assignment, status, csrf, returnTo, result) {
         ? { action: `${taskHref(assignment.rootId)}/recheck-stopped`, run: action.target.runId, returnTo } : null;
     return { label: status.need.action.label, href: assignmentActionHref(assignment) ?? taskHref(assignment.rootId), confirm };
 }
-/** The server page's form of the same: the need's action first, Request changes as the quiet second. */
 export function resultNeedAction(need, o, canRequest) {
     const control = need.accept != null
         ? postForm(need.accept.action, html `${need.accept.note === null ? "" : html `<input type="text" name="note" maxlength="500" required placeholder="${need.accept.note}" aria-label="${need.accept.note}">`}<button type="submit" data-primary-action data-accept-result style="min-height:44px">${need.label}</button>`, { attrs: { class: "accept-result" }, returnTo: need.accept.returnTo, hidden: { run: need.accept.run } })
@@ -2025,20 +1712,12 @@ export function resultNeedAction(need, o, canRequest) {
                 : html `<a class="button-link" href="${need.href ?? "#"}" data-primary-action>${need.label}</a>`;
     return html `<div class="result-action" data-result-action="need">${control}${canRequest && o.csrf !== "" ? html `<a class="result-feedback-link" href="#request-changes">Send back</a>` : ""}</div>`;
 }
-/** The outcome in one bounded sentence (repair 2026-09-14): the handoff's
- * first sentence, cut at a word when it runs past 180 characters. The
- * full conclusion stays available behind the Summary's disclosure. */
 export function conciseOutcomeOf(conclusion) {
     const flat = oneLineOf(conclusion, 2_000);
     const sentence = /^[\s\S]*?[.!?](?=\s|$)/.exec(flat)?.[0] ?? flat;
     const bounded = sentence.length <= 140 ? sentence : `${sentence.slice(0, 140).replace(/\s+\S*$/, "")}…`;
     return bounded.trim();
 }
-/** Exactly one primary act for the result (repair 2026-09-14), chosen from
- * its state: draft the CI repair, create the revision the notes are
- * waiting for, open the pull request, or request changes. A bearer session
- * (no token) gets no control; the cockpit renders its own next-action
- * card instead (`action: false`). */
 export function resultPrimaryAction(detail, o, prUrl) {
     const wrap = (kind, control) => html `<div class="result-action" data-result-action="${kind}">${control}</div>`;
     if (detail.ciFailing && o.csrf !== "") {
@@ -2056,10 +1735,6 @@ export function resultPrimaryAction(detail, o, prUrl) {
         return wrap("request-changes", html `<a class="result-feedback-link" href="#request-changes">Send back</a>`);
     return html ``;
 }
-/** The run's facts as rows — one renderer for the page and its live
- * fragment (A4). Elapsed ticks client-side while the run is open. */
-/** The run's route provenance in plain words (v47): the exact agent it
- * spent as, in which role, and how that agent was chosen. */
 export function runAgentWords(route) {
     if (route === null || route === undefined)
         return null;
@@ -2075,7 +1750,6 @@ export function runAgentWords(route) {
                     : "recommended";
     return `${route.provider}${route.model === null ? "" : ` · ${route.model}`} as the ${role} — ${how}`;
 }
-/** A run's outcome in the kit's tones: built or no change finished, failed or refused failed, anything else neutral. */
 export function runOutcomeChip(run, live) {
     if (live)
         return chip("Running", "live");
@@ -2086,7 +1760,6 @@ export function runOutcomeChip(run, live) {
     const word = sentenceCase(run.outcome ?? "never finished");
     return chip(word, run.outcome === "built" || run.outcome === "no-change" ? "done" : run.outcome === "failed" || run.outcome === "refused" ? "failed" : "");
 }
-/** How long a finished run ran, in whole minutes (seconds under one). */
 function ranWords(run) {
     if (run.startedAt === null || run.finishedAt === null)
         return null;
@@ -2095,8 +1768,6 @@ function ranWords(run) {
         return null;
     return ms < 60_000 ? `${Math.max(1, Math.round(ms / 1000))} s` : ms < 3_600_000 ? `${Math.round(ms / 60_000)} min` : `${Math.floor(ms / 3_600_000)} h ${Math.round((ms % 3_600_000) / 60_000)} min`;
 }
-/** A run's facts as the kit's facts list: how it ended, who ran it where, when, what it cost and where it ended. The
- * live poll (`?fragment=facts`) swaps the same list in place. (The page's header names the run and its task.) */
 export function runFactsRows(run, _taskId, live, route = null) {
     const mono = (value) => html `<span class="k-mono">${value}</span>`;
     const rows = [
@@ -2114,27 +1785,13 @@ export function runFactsRows(run, _taskId, live, route = null) {
         ["Starting point", run.baseRevision === null ? null : mono(run.baseRevision.slice(0, 12))],
         ["Commit", run.headRevision === null ? null : mono(run.headRevision.slice(0, 12))],
         ["Tokens", run.tokensIn === null && run.tokensOut === null ? null : html `<span class="k-num">${(run.tokensIn ?? 0).toLocaleString()} in · ${(run.tokensOut ?? 0).toLocaleString()} out</span>`],
-        // Auth is part of the economic fact: Claude's subscription harness reports an API-price equivalent, not a separate
-        // API-key charge.
         ["Spend", run.providerStartedAt === null && run.tokensIn === null && run.tokensOut === null && run.costUsd === null ? null : runCostWords(run, live)],
     ];
     const shown = rows.filter((row) => row[1] !== null && row[1] !== "");
-    return html `${facts(shown)}${
-    // Machine output (a stack trace, a path, "Error:" text) reads as an internal error everywhere else; its detail is here, as recorded.
-    run.reason !== null && isInternalErrorReason(run.reason)
+    return html `${facts(shown)}${run.reason !== null && isInternalErrorReason(run.reason)
         ? html `<p class="k-note">Recorded error</p><pre class="k-mono h-pre" id="run-reason-detail">${run.reason}</pre>`
         : ""}`;
 }
-/**
- * Click-to-prefill (arc 6, finding 4): client-side FORM mutation, named as
- * such — normal viewing stays the default; "Annotate" reveals line pins.
- * A pin or file button copies its target into the comment form and focuses
- * the note field. No fetch, endpoint, or submit: comments still leave
- * through the same CSRF'd form POST. Reads data attributes, writes input
- * values, and flips presentational state — never markup. The note counter
- * (follow-up on build 1540) reads the textarea's own maxlength — the
- * server's LIMITS.note — into the helper text, so the two cannot drift.
- */
 export function prefillScript() {
     return (`(function(){var form=document.getElementById("comment-form");if(!form)return;var review=document.querySelector("[data-review-diff]");` +
         `var noteBox=form.querySelector("[name=note]"),limit=document.getElementById("comment-note-limit");if(noteBox&&limit&&noteBox.maxLength>0){` +
@@ -2150,18 +1807,10 @@ export function prefillScript() {
         `if(line)line.value=button.getAttribute("data-line")||"";` +
         `form.scrollIntoView({behavior:"smooth",block:"center"});if(note)note.focus();});})();`);
 }
-/** The primary review act opens the Checks view it names. The anchor
- * still lands on the result without JavaScript (the server honours
- * `?tab=checks`); this only removes the reload. */
 export function reviewEvidenceScript() {
     return (`(function(){var link=document.querySelector("[data-open-evidence]"),tab=document.querySelector('[data-result-tab="checks"]'),panel=document.getElementById("result");` +
         `if(!link||!tab||!panel)return;link.addEventListener("click",function(ev){ev.preventDefault();tab.click();panel.scrollIntoView({behavior:"smooth",block:"start"});});})();`);
 }
-/** The facts region alone, for the open-run poll (A4). A finished run's
- * fragment says so instead of quietly growing forms (finding 5), and a run
- * that stopped being the task's live claim says so too — both carry the
- * stop marker, so an open tab quits refetching a dead build (round-4
- * finding 15). */
 export function runFactsFragment(run, taskId, live, route = null) {
     if (run.outcome !== null) {
         return html `<p class="k-note" data-region-stop>It finished. <a class="k-link" href="/r/${run.id}">Reload for the final record</a></p>`;