toolroll 0.9.103 → 0.9.105

package/dist/workspace-ui.js

@@ -1,21 +1,3 @@
-/**
- * The workspace's ONE display projection (package 1, 2026-09-13): the
- * words, tone, and next action a task or result wears on every surface —
- * Work rows, the task page's status box, the focused chat's journey card,
- * the review cockpit's chip, and the completion receipt's heading. Pure
- * functions over facts the store already records (task state, the dispatch
- * diagnosis, the machine's proof verdict and its reasons, an operator's
- * acceptance, the publication row); nothing here is a second lifecycle,
- * and nothing here reads the agent's narrative as evidence of success.
- *
- * The vocabulary is the truthful-status contract from the workspace plan:
- * a saved result with a failed check says "Changes saved, but checks
- * failed"; a missing proof says "verification needed"; agent-reported
- * checks say so; an accepted exception stays an exception; and nothing
- * local is ever called shipped or deployed — "PR opened" and "Merge
- * observed" name observed publication records, and deployment is never
- * claimed without one.
- */
 import { lastIncludedWords } from './memory-use.js';
 import { ACCEPT_NEEDS_REASON, FAILED_CHECK, cantAcceptYetOf, evidenceProblemOf } from "./result-acts.js";
 export { ACCEPT_NEEDS_REASON, cantAcceptYetOf, evidenceProblemOf };
@@ -37,9 +19,6 @@ export const WORK_VIEWS = [
 export function parseWorkView(raw) {
     return raw === "needs-you" || raw === "ready" || raw === "running" || raw === "queued" || raw === "completed" || raw === "archived" ? raw : "all";
 }
-/** The review facts from the store's bounded retry projection — the same
- * reading `diagnoseTaskDispatch` makes, so every surface starts from one
- * record. `reviewerAlive` answers for the live attempt's runner. */
 export function reviewFactsOf(retry, reviewerAlive, automaticPending = false) {
     if (retry === null || retry.state === "unrequested")
         return null;
@@ -58,25 +37,12 @@ export function reviewFactsOf(retry, reviewerAlive, automaticPending = false) {
         automaticPending,
     };
 }
-/** The tokens a review in flight wears — the dispatch codes, unchanged. */
 export const REVIEW_TOKENS = new Set(["reviewing", "review-pending", "review-failed", "review-exhausted"]);
-/**
- * A review that is queued, running, failed with a retry left, or
- * exhausted is the result's PRIMARY status — the machine is still
- * deciding, and every surface must say so with the same words. A review
- * never requested, or one that succeeded, adds nothing: the stored verdict
- * (folded by the review where one landed) speaks. Words and tokens are
- * the v50 dispatch contract; nothing here changes the lifecycle.
- */
 export function reviewStatusOf(review) {
-    // The one automatic review (build-review.ts) holds the result only while it
-    // is queued or running. A failed review never blocks: the result reads as
-    // it would unreviewed, marked "not reviewed" by the result itself.
     if (review === null || review.automaticPending !== true || (review.state !== "queued" && review.state !== "running"))
         return null;
     return { token: "reviewing", label: "Reviewing", detail: "An automatic review is reading this result before it reaches you.", tone: "live", action: { label: OPEN_RESULT, kind: "open-result" } };
 }
-/** The exit code of the failed check, when the recorded reason names one. */
 export function failedCheckExit(reasons) {
     for (const reason of reasons) {
         const found = FAILED_CHECK.exec(reason);
@@ -85,13 +51,6 @@ export function failedCheckExit(reasons) {
     }
     return null;
 }
-/** The observed publication record in words. Each state is a distinct
- * fact: a pushed branch is not a PR, an open PR is not a merge, and a
- * merge is not a deployment — no record here ever says "deployed". The
- * words name what was recorded or last observed and what stays
- * unconfirmed; a missing or stale observation never proves that nothing
- * merged or deployed, and merging is never called manual-only — an
- * authorized mode may merge on green. */
 export function publicationStatusOf(publication) {
     if (publication === null)
         return null;
@@ -114,27 +73,15 @@ export function publicationStatusOf(publication) {
     }
     return { token: "publication-pending", label: "Publication requested", detail: "Publishing was authorized and has not completed; no pull request or merge is recorded yet." };
 }
-/**
- * The finished result's status — the one place the done words are chosen.
- * Precedence: no record → scout report → operator acceptance → the machine
- * verdict's problems (a refuted or short verdict is never masked by a
- * no-change outcome) → a no-change conclusion, which owes no proof beyond
- * its handoff and sealed diff → agent-attested → verified, where an
- * observed publication names itself (a published but unverified result
- * keeps its evidence problem as the main wording; the publication rides
- * the detail).
- */
 export function resultStatusOf(result, publication = null) {
     return (result?.role === "builder" ? reviewStatusOf(result.review ?? null) : null) ?? storedResultStatusOf(result, publication);
 }
-/** What the machine itself recorded about a result, in a clause. */
 function machineVerdictWords(result, check) {
     if (check !== undefined && check?.status === "failed" && evidenceProblemOf(result.verdict, result.reasons) !== "checks-failed") {
         return `the approved check failed against it${check.exitCode === null ? "" : ` (exit ${check.exitCode})`}`;
     }
     if (result.verdict === "verified" && passedNow(check))
         return "it verified the result before the acceptance";
-    // Unread here, or unreadable now: never restated as a pass.
     if (result.verdict === "verified")
         return check === undefined ? "open the result for its checks" : "its check result couldn't be read";
     if (result.verdict === "attested")
@@ -148,13 +95,11 @@ function machineVerdictWords(result, check) {
         return "its saved files didn't match the record";
     return "its required files were missing";
 }
-/** The approved check passed (task-status.ts approvedCheckStateOf): its own pass, or checks Off covered by a passing
- * release check. A re-run underway keeps the pass it had. */
 const passedNow = (check) => {
     const state = approvedCheckStateOf(check);
     return state === "passed" || (state === "running" && check?.status === "passed");
 };
-/** A result whose check this surface didn't read: no pass is claimed, the result page says. */
+export const SET_A_CHECK = "Set one in Settings → Projects → Checks.";
 const UNREAD_CHECK = "Open the result to see its checks.";
 function storedResultStatusOf(result, publication) {
     if (result === null || result.runId === null) {
@@ -171,7 +116,6 @@ function storedResultStatusOf(result, publication) {
     }
     const published = publicationStatusOf(publication);
     const withPublication = (detail) => (published === null ? detail : `${detail} ${published.detail}`);
-    // Did the approved check pass for this result (task-status.ts): the one answer the Checks row and the road read.
     const check = result.checks === undefined ? undefined : approvedCheckOf(result.verdict, result.reasons, result.checks);
     const humanReview = manualReviewOnly({ verdict: result.verdict ?? "", reasons: result.reasons });
     if (result.accepted && humanReview) {
@@ -181,17 +125,12 @@ function storedResultStatusOf(result, publication) {
         return {
             token: "accepted-exception",
             label: "Accepted with an exception",
-            // Acceptance records a person's decision; it neither proves nor
-            // disproves anything about the checks. The machine's own verdict is
-            // restated as recorded.
             detail: withPublication(`An approver accepted this result by hand, and their reason says why. The checks are unchanged: ${machineVerdictWords(result, check)}.`),
             tone: "done",
             action: { label: "Open the recorded exception", kind: "open-review" },
         };
     }
     const recordedProblem = evidenceProblemOf(result.verdict, result.reasons);
-    // A failed check that a later check on the same commit passed no longer fails the result; a check that failed
-    // since a passing verdict does.
     const problem = recordedProblem === "checks-failed" && passedNow(check) ? "none"
         : recordedProblem !== "mismatched" && check?.status === "failed" ? "checks-failed" : recordedProblem;
     if (problem === "checks-failed") {
@@ -208,8 +147,6 @@ function storedResultStatusOf(result, publication) {
         return {
             token: "evidence-mismatch",
             label: "Result saved, but its record does not match",
-            // A structural refutation is settled before the approved check is
-            // weighed, so it says nothing about whether that check passed.
             detail: withPublication("What the agent reported doesn't match the changes it saved."),
             tone: "problem",
             action: { label: OPEN_RESULT, kind: "open-review" },
@@ -228,9 +165,6 @@ function storedResultStatusOf(result, publication) {
         };
     }
     if (result.outcome === "no-change") {
-        // A machine verdict (attested or verified) already proved the record
-        // at adjudication; only a verdict-less no-change reads its two
-        // presence facts here.
         return result.recordComplete === false && result.verdict === null
             ? { token: "record-incomplete", label: "No-change result, record incomplete", detail: "The build concluded nothing needed to change, but its handoff or saved diff is missing.", tone: "problem", action: { label: "Open the record", kind: "open-run" } }
             : { token: "no-change", label: "No changes were needed", detail: withPublication("The build concluded nothing needed to change; its handoff and saved diff are on record."), tone: "done", action: { label: OPEN_RESULT, kind: "open-result" } };
@@ -244,7 +178,6 @@ function storedResultStatusOf(result, publication) {
             action: { label: "Run checks", kind: "open-review" },
         };
     }
-    // Any verdict short of a pass the check confirms: never "passed" when the check can't be read now.
     if (check !== undefined && !passedNow(check) && result.verdict === "verified") {
         return check?.status === "running"
             ? { token: "checks-running", label: "Checks running", detail: withPublication("The approved check is running on this result."), tone: "live", action: { label: OPEN_RESULT, kind: "open-result" } }
@@ -252,10 +185,21 @@ function storedResultStatusOf(result, publication) {
                 tone: "problem", action: { label: "Open the check", kind: "open-review" } };
     }
     if (result.verdict === "attested" && !passedNow(check)) {
+        if (result.checkSet === true && result.checkLevel !== "off") {
+            return {
+                token: "agent-attested",
+                label: "Ready · checks didn't run",
+                detail: withPublication("No project check was set when this was built, so the checks listed are the agent's own report. A check is set now: run it on this result."),
+                tone: "neutral",
+                action: { label: "Run checks", kind: "open-review" },
+            };
+        }
         return {
             token: "agent-attested",
             label: "Ready · no project check set up",
-            detail: withPublication("No project check is set up, so the checks listed are the agent's own report."),
+            detail: withPublication(result.checkSet === false && result.checkLevel !== "off"
+                ? `No project check is set up, so the checks listed are the agent's own report. ${SET_A_CHECK}`
+                : "No project check is set up, so the checks listed are the agent's own report."),
             tone: "neutral",
             action: { label: OPEN_RESULT, kind: "open-result" },
         };
@@ -272,15 +216,11 @@ function storedResultStatusOf(result, publication) {
     return {
         token: "ready-to-review",
         label: "Ready",
-        // Only a check read here may be called passed; a surface that read none says where to see it.
         detail: withPublication(check === undefined ? UNREAD_CHECK : "The approved check passed against this result."),
         tone: "ready",
         action: { label: OPEN_RESULT, kind: "open-result" },
     };
 }
-/** The completion receipt's heading: what the record actually supports.
- * Never "shipped" — local changes are saved; a PR or merge is named only
- * from its observed record. */
 export function receiptHeadingOf(outcome, publication, role) {
     const published = publicationStatusOf(publication);
     if (published !== null && (published.token === "merge-observed" || published.token === "pr-opened"))
@@ -291,29 +231,19 @@ export function receiptHeadingOf(outcome, publication, role) {
         return "No changes were needed";
     return "Changes saved";
 }
-/** The receipt's one-line publication fact under the heading. */
 export function receiptPublicationWords(publication) {
     const published = publicationStatusOf(publication);
     return published === null ? "Saved on the build branch. No publication, merge, or deployment is recorded here." : published.detail;
 }
-/** These dispatch states may yield the headline to an unanswered
- * question. Failure, uncertain process ownership, holds, approvals and
- * stop settlement deliberately do not yield. This never alters dispatch. */
 const QUESTION_FIRST = new Set([
     "running", "waiting-decision", "no-worker-online", "no-worker-registered",
     "worker-at-capacity", "ready", "planning-ready", "scouting-ready",
 ]);
-/** Needs you: the existing diagnosis semantics — waiting on a person with a
- * concrete act — never every queued task indiscriminately. */
 export function needsPerson(dispatch) {
     if (dispatch === null || dispatch.action === null)
         return false;
-    // A failed task is terminal for the scheduler and still a person's act
-    // (retry); every other terminal answer (complete, cancelled) is not.
     return dispatch.condition === "waiting" || dispatch.code === "failed";
 }
-/** Navigation labels describe the available help, not a mutation: opening
- * a hold or pause must never promise that the task has already resumed. */
 const DISPATCH_ACTION_LABELS = {
     "open-result": OPEN_RESULT,
     "retry-task": "Review and retry",
@@ -331,30 +261,18 @@ const DISPATCH_ACTION_LABELS = {
     "resume-run": "Review pause",
 };
 export function dispatchActionLabel(dispatch) {
-    // One label everywhere for the builder (needs-you.ts NEEDS): Connect a builder, or Start the builder.
     if (dispatch?.action === "start-worker")
         return dispatch.code === "no-worker-registered" ? NEEDS["connect-builder"].action.label : NEEDS["start-builder"].action.label;
     return dispatch?.action == null ? "View task details" : DISPATCH_ACTION_LABELS[dispatch.action];
 }
-/** Result tokens a done task can wear, as the shared stage they mean. A
- * result that is missing its record waits on a person; a failed check fails. */
 const RESULT_NEEDS_YOU = new Set(["no-build-record", "verification-needed", "evidence-mismatch", "record-incomplete", "evidence-damaged", "check-unreadable"]);
-/** Result tokens that only follow a passing project check. */
 const VERIFIED_RESULT = new Set(["ready-to-review", "pr-opened", "merge-observed", "pr-closed"]);
-/** A finished result's display status in the shared headline's words: a
- * failed project check is Failed, a result missing its record needs a
- * person, every other saved result is Ready for review. Token and action stay. */
-/** The result's headline while its report disagrees with its saved changes. */
 export const MISMATCH_HEADLINE = "The report doesn't match the changes";
 const OVERCLAIMED = /^claimed changed paths? not in the sealed diff: ([\s\S]+)$/;
 const RESTATED = /^criterion "([^"]+)" was signed as "[\s\S]*" and the proof restates it as "([\s\S]*)"$/;
 const CONTRADICTED_BY_CAVEAT = /^criterion "([^"]+)" is marked met, but caveat [0-9]+ admits an exception to it: ([\s\S]*)$/;
 const NOTE_NUMBER = /^caveat ([0-9]+) /;
 const CONTRADICTED_BY_REVIEW = /^(?:reviewer:)?[^\s"]+ contradicts criterion "([^"]+)": [\s\S]*$/i;
-/** Each recorded way a refuted report disagrees with its saved changes, said
- * plainly and tied to the changed lines it concerns. `changes` maps each
- * changed file to the lines of its first change (null when it has no line
- * changes, a binary file say). Presentation only: the verdict is unchanged. */
 export function reportMismatchesOf(reasons, criteria, changes) {
     const named = (id) => {
         const statement = criteria.find(one => one.id === id)?.statement.trim() ?? "";
@@ -362,7 +280,6 @@ export function reportMismatchesOf(reasons, criteria, changes) {
             return `requirement ${id}`;
         return `“${statement.length > 90 ? `${statement.slice(0, 90).replace(/\s+\S*$/, "")}…` : statement}”`;
     };
-    // The first file the requirement cites that the saved changes have.
     const place = (id) => {
         const path = criteria.find(one => one.id === id)?.answered.find(ref => ref.kind === "changed-path" && changes.has(ref.ref))?.ref ?? null;
         return path === null ? { path: null, lines: null, inChanges: null } : { path, lines: changes.get(path) ?? null, inChanges: true };
@@ -388,7 +305,6 @@ export function reportMismatchesOf(reasons, criteria, changes) {
             return [];
         return [{ text: sentenceOf(plainReasonWords(reason)), path: null, lines: null, inChanges: null, note: note === null ? null : Number(note), reason }];
     });
-    // Evidence a requirement cites that doesn't hold, unless a reason above already says so.
     const evidence = criteria.flatMap(one => one.state !== "failed" && one.state !== "missing" ? [] : (one.detail ?? [])
         .filter(detail => !reasons.includes(detail) && !/is waiting for the final check|requires manual-review evidence|is marked met, but caveat|was signed as/.test(detail))
         .map((detail) => {
@@ -399,17 +315,12 @@ export function reportMismatchesOf(reasons, criteria, changes) {
     return [...rows, ...evidence];
 }
 const UNSIGNED_NOTE = /^caveat ([0-9]+) names ("[^"]*"(?:, "[^"]*")*), (?:a criterion the proof authored|which is no signed)[\s\S]*?: ([\s\S]*)$/;
-/** A sentence starts with a capital letter. */
 function sentenceOf(text) {
     return text === "" ? text : `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
 }
-/** The line a failing check ended on: the last line of its error output that
- * names an error, else the last line it printed, with its 1-based number in
- * the saved log. Null when the log printed nothing. */
 export function lastErrorLineOf(log) {
     const lines = log.split("\n");
     const printed = (text) => text.trim() !== "" && !/^\$ /.test(text) && !/^\(exit -?[0-9]+\)$/.test(text.trim()) && !/^--- (stdout|stderr) ---$/.test(text.trim())
-        // A section's own header ("=== Project check · attempt 1 ===") is the log's, never the check's output.
         && !/^=== .* ===$/.test(text.trim());
     const stderr = lines.findIndex(text => text.trim() === "--- stderr ---");
     const pick = (from, to) => {
@@ -425,13 +336,11 @@ export function lastErrorLineOf(log) {
     };
     return (stderr >= 0 ? pick(stderr + 1, lines.length) : null) ?? pick(0, stderr >= 0 ? stderr : lines.length);
 }
-/** The result page's own sentence when the decision is on it. */
 export const RESULT_DECISION_SENTENCE = "Review the change, then accept it or send it back.";
 export function acceptWordsOf(facts) {
     const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
     const parts = [
         ...(facts.proof ? [] : ["nothing on record says what was met"]),
-        // Checks deliberately Off are checked at release (task-status.ts): not a gap here.
         ...(facts.checks === "passed" || facts.checks === "off" ? [] : [facts.checks === "failed" ? "checks failed"
                 : facts.checks === "running" ? "checks are still running" : facts.checks === "unavailable" ? "saved checks can't be read" : "checks didn't run"]),
         ...(facts.unmet > 0 ? [`${plural(facts.unmet, "requirement isn't", "requirements aren't")} met`] : []),
@@ -442,7 +351,8 @@ export function acceptWordsOf(facts) {
         : facts.publishing === "pull-request" ? "Finishes the task. No pull request opens; you can open one from the task after."
             : facts.publishing === "off" ? "Finishes the task. The branch stays; publishing isn't set up."
                 : "Finishes the task. Nothing is published.";
-    return { label: ready ? "Accept" : "Accept without checks", ready, why: ready ? null : `${joined.charAt(0).toUpperCase()}${joined.slice(1)}.`, effect };
+    const checksGap = facts.checks !== "passed" && facts.checks !== "off";
+    return { label: ready ? "Accept" : checksGap ? "Accept without checks" : "Accept anyway", ready, why: ready ? null : `${joined.charAt(0).toUpperCase()}${joined.slice(1)}.`, effect };
 }
 export function resultHeadlineOf(status) {
     const read = RESULT_NEEDS_YOU.has(status.token) ? { stage: "needs-you", need: "other" }
@@ -451,9 +361,6 @@ export function resultHeadlineOf(status) {
             : VERIFIED_RESULT.has(status.token) ? { status: "passed", exitCode: null, head: null } : null });
     return { ...status, label: shared.headline, tone: workToneOf(shared.headline) };
 }
-/** The one shared headline (task-status.ts) over the work status below: the
- * token, views, rank, action and diagnostics stay; the words and tone are
- * the eight headlines'. */
 export function workStatusOf(facts, resultDisplay) {
     const status = workStatusWordsOf(facts, resultDisplay);
     const done = facts.state === "done" && status.token !== "waiting-decision";
@@ -495,8 +402,6 @@ function workStatusWordsOf(facts, resultDisplay) {
         views,
         rank,
     });
-    // The control projection knows whether a stop has actually settled.
-    // A still-live claim alone cannot distinguish Running from Stopping.
     if (facts.control?.kind === "stopping") {
         return { token: "stopping", label: "Stopping…", detail: facts.control.detail ?? "The attempt is ending. Its work is preserved; resume becomes available after its processes exit.", tone: "attention", action: { label: "View stop details", kind: "open-task" }, views, rank: 1 };
     }
@@ -504,8 +409,6 @@ function workStatusWordsOf(facts, resultDisplay) {
         return { token: "stopped", label: "Paused", detail: "The stopped attempt's work is preserved. Resuming requires confirmation and checks the current approval again.", tone: "attention", action: { label: "Review pause", kind: "open-task" }, views, rank: 0 };
     }
     if (facts.state === "done" && result !== null) {
-        // A saved result or an ongoing review cannot answer a question. Keep
-        // failures primary; the shared summary retains the answer action too.
         if (question !== null && result.tone !== "problem") {
             return { token: "waiting-decision", label: "Waiting on your answer", detail: question.question,
                 tone: "attention", action: { label: "Answer question", kind: "open-task" }, views, rank: 0,
@@ -543,7 +446,6 @@ function workStatusWordsOf(facts, resultDisplay) {
         return dispatchWords("neutral", 2, details);
     return dispatchWords(dispatch.condition === "retrying" ? "neutral" : "muted", 2, details);
 }
-/** The counts each view tab wears — from the same rows the page lists. */
 export function workCounts(rows) {
     const counts = { all: 0, "needs-you": 0, ready: 0, running: 0, queued: 0, completed: 0, archived: 0 };
     for (const row of rows)
@@ -566,8 +468,6 @@ export function primaryDestinationOf(active) {
         return "settings";
     return null;
 }
-/** Learning stays in Settings and a useful, closed result disclosure. `csrf` gates the management forms (a cookie
- * session has one); postForm adds the request's own CSRF field. */
 export function learningHtml(view, csrf, canManage, source) {
     const base = { repo: view.repo, identity: view.identity, revision: view.revision };
     const act = (action, label, lesson) => canManage && csrf ? postForm('/settings/learning/change', html `<button type="submit">${label}</button>`, { hidden: { ...base, action, ...(lesson ? { lesson: lesson.id, version: lesson.version, sha: lesson.sha } : {}) } }) : '';
@@ -579,8 +479,6 @@ export function learningHtml(view, csrf, canManage, source) {
     const history = view.events.map(ev => html `<article class="card" data-learning-event="${ev.action}"><p><strong>${{ assessment: { propose: 'Learning suggested', none: 'No lesson needed', unassessed: 'Learning not assessed', invalid: 'Learning assessment invalid' }[ev.after] ?? 'Learning not assessed', proposal: 'Suggestion recorded', adopt: 'Lesson adopted', disable: 'Lesson disabled', reset: 'Learning reset', enable: 'Reuse enabled', pause: 'Reuse paused', reuse: 'Run context saved', failure: 'Learning issue', capture: 'Capture finished' }[ev.action] ?? ev.action}</strong>${ev.action === "reuse" ? ` · ${ev.after}` : ""}</p><p class="meta">${whenUtc(ev.at)} · ${ev.actor}${ev.run === null ? '' : html ` · <a href="/r/${ev.run}">Run #${ev.run}</a>${ev.outcome === null ? "" : ` · ${ev.outcome}`}`}</p><details><summary>Details</summary><p>${ev.before} → ${ev.after}</p><p>${ev.reason}</p>${ev.lesson === null ? '' : html `<p>Lesson #${ev.lesson}</p>`}<ul>${evidence(ev.evidence, ev.run)}</ul>${ev.snapshot === null ? "" : html `<details><summary>Exact context</summary><pre>${ev.snapshot}</pre></details>`}</details></article>`);
     return html `<section class="learning">${view.damaged ? html `<p class="problem" role="alert">Some lessons no longer verify and are excluded from reuse.</p>` : ''}<p>${view.enabled ? 'Use adopted lessons: on' : 'Use adopted lessons: off'}</p>${act(view.enabled ? 'pause' : 'enable', view.enabled ? 'Pause reuse' : 'Enable reuse')}${cards.length ? cards : html `<p>No lessons yet. Reviews may suggest useful advice here.</p>`}<details><summary>Reset learning</summary><p>Disable all adopted lessons and future reuse. Keep history, code, approvals and active run snapshots.</p>${act('reset', 'Reset learning')}</details><h2>Changes</h2>${history.length ? history : html `<p>No learning changes yet.</p>`}${view.next === null ? '' : html `<a class="button-link" href="/settings/learning?repo=${encodeURIComponent(view.repo)}&before=${view.next}">Older changes</a>`}</section>`;
 }
-/** The first signed requirement a finished attempt missed (failed or unanswered; a person's own check is not a miss),
- * with the evidence line behind it in plain words. Null when every requirement held. */
 export function missedRequirementOf(matrix) {
     const missed = matrix.find(row => row.state === "failed") ?? matrix.find(row => row.state === "missing") ?? null;
     if (missed === null)
@@ -588,10 +486,8 @@ export function missedRequirementOf(matrix) {
     const detail = missed.detail.find(one => !/is waiting for the final check/.test(one)) ?? missed.detail[0] ?? null;
     return { id: missed.id, statement: missed.statement, evidence: detail === null ? (missed.state === "missing" ? "The agent's report doesn't answer it." : null) : requirementEvidenceWords(missed.id, detail) };
 }
-/** A matrix row's recorded detail as a sentence a person reads: the agent's own note when one admits the miss. */
 function requirementEvidenceWords(id, detail) {
     const caveat = CONTRADICTED_BY_CAVEAT.exec(detail);
-    // The note often names its requirement first ("c1: …"); the line already says which requirement it is.
     if (caveat !== null && caveat[1] === id)
         return sentenceOf(`The agent's own note says: ${caveat[2].trim().replace(new RegExp(`^${id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*[:—-]\\s*`), "")}`);
     const lead = [`criterion "${id}"'s `, `criterion "${id}" `].find(prefix => detail.startsWith(prefix));
@@ -601,8 +497,6 @@ const stepWords = (text) => {
     const plain = text?.trim().replace(/\s+/g, " ").replace(/[.\s]+$/, "") ?? "";
     return plain === "" ? null : plain;
 };
-/** A live build's progress: the step in progress (else the first one not done) as "Step N of M: <step>"; a blocked
- * step replaces it as "Stuck on step N of M: <why>" (its note, else the step itself). Null with no plan steps. */
 export function buildProgressOf(steps) {
     if (steps == null || steps.length === 0)
         return null;
@@ -620,12 +514,9 @@ export function buildProgressOf(steps) {
     const words = stepWords(steps[at].description);
     return { step: at + 1, total, line: `Step ${at + 1} of ${total}${words === null ? "" : `: ${words}`}.`, stuck: null };
 }
-/** Earlier attempts that stopped before the one now running, in one quiet line. */
 export function earlierAttemptsWords(count) {
     return `${count} earlier attempt${count === 1 ? "" : "s"} stopped`;
 }
-/** The task page's rows, from its road (first-run.ts taskRoad) and the facts beside it. Null when the task has no road
- * (cancelled, or no status): the page keeps its status block then. Pure: no clock, no store. */
 export function stepRowsOf(view) {
     const road = view.journey ?? null;
     if (road === null || road.length === 0)
@@ -634,11 +525,9 @@ export function stepRowsOf(view) {
     const runs = headline === "Planning" || headline === "Building";
     const approvalOpen = view.approve != null || road.some(step => step.key === "approve" && step.state === "current");
     const hasResult = view.result != null;
-    // Earlier versions or stopped builds: the Build row holds them, and opens for them before the next build starts.
     const hasHistory = (view.status?.attempts.length ?? 0) > 1 || (view.earlier?.attempts.length ?? 0) > 0;
     const lastResult = [...(view.thread ?? [])].filter(one => one.kind === "result").map(one => one.at).sort().at(-1) ?? null;
     const checksStuck = road.some(step => step.key === "checks" && step.state === "stuck");
-    // A step stopped there, in a word (its box under it says why).
     const stoppedWord = headline === "Failed" ? "Failed" : headline === "Stopped" ? "Stopped" : headline === "Waiting" || headline === "Queued" ? "Waiting" : "Stopped here";
     const words = (step) => {
         const here = step.state === "current" || step.state === "stuck";
@@ -650,7 +539,6 @@ export function stepRowsOf(view) {
                         return { sentence: by === null ? "Shown below" : `Written by ${by} · shown below`, at: view.plan?.at ?? null };
                     return { sentence: view.plan?.lead ?? (by === null ? "Plan written" : `Written by ${by}`), at: view.plan?.at ?? null };
                 }
-                // Stopped at Plan with a plan already written (a held task whose plan waits for approval): it says it stopped, never "No plan yet".
                 if (here)
                     return { sentence: view.plan?.updating === true ? "Updating the plan" : view.plan?.planning === true || headline === "Planning" ? "Writing the plan" : step.needsYou ? ""
                             : step.state === "stuck" && view.approve != null ? stoppedWord : "No plan yet", at: null };
@@ -670,7 +558,6 @@ export function stepRowsOf(view) {
                     return { sentence: view.scout ? "The investigation finished" : "The build finished", at: lastResult };
                 if (step.state === "skipped")
                     return { sentence: "Didn't run", at: null };
-                // The open row's box says the rest: its head says only how the step stands.
                 if (here)
                     return { sentence: step.needsYou ? "" : runs ? "Working now" : step.state === "stuck" ? stoppedWord : "Waiting to start", at: null };
                 return { sentence: `${approvalOpen ? "Starts when you approve" : "Starts after approval"}${hasHistory ? ". Earlier attempts are here." : ""}`, at: null };
@@ -701,25 +588,18 @@ export function stepRowsOf(view) {
         const here = step.state === "current" || step.state === "stuck";
         const needsYou = step.needsYou === true && here;
         const mark = step.state === "done" ? "done" : step.state === "skipped" ? "skipped" : step.state === "todo" ? "todo"
-            // Vermilion only for a failure: a stopped or held step waits, in grey.
             : needsYou ? "needs" : step.state === "stuck" ? (headline === "Failed" || step.say === "Checks failed" || step.say === "Checks unreadable" ? "stuck" : "wait")
                 : runs || step.say === "Checks running" ? "live" : "wait";
-        // A step not reached opens only when it holds something already there: a result before Ready was reached, or
-        // earlier attempts before the next build starts.
-        // An approval this person can give is always on the page, open, wherever the road stands (a held task stops at
-        // Plan with its plan still waiting for a yes): the Approval row holds its form.
         const approvalHere = step.key === "approve" && view.approve != null;
         const opens = step.state !== "todo" || (step.key === "ready" && hasResult) || (step.key === "build" && hasHistory) || approvalHere;
         return { key: step.key, label: step.label, state: step.state, mark, sentence: said.sentence, at: said.at, needsYou, opens, open: here || approvalHere };
     });
-    // A finished road whose task still waits on this person (a result to review): the last step it reached is theirs.
     const waitsOnViewer = headline === "Ready for review" || headline === "Needs you";
     if (waitsOnViewer && !rows.some(row => row.state === "current" || row.state === "stuck")) {
         const last = [...rows].reverse().find(row => row.state === "done");
         if (last !== undefined)
             Object.assign(last, { state: "current", mark: "needs", needsYou: true, sentence: "", at: null, open: true, opens: true });
     }
-    // Nothing happening (a finished task): the last step it reached is the one open.
     if (!rows.some(row => row.open)) {
         const last = [...rows].reverse().find(row => row.opens && row.state !== "todo");
         if (last !== undefined)

package/dist/worktree-notices.js

@@ -1,7 +1,4 @@
 import { createHash } from "node:crypto";
-/** One announcement for a reconciliation batch. The complete path inventory
- * stays in worktree rows and reconcile's result; this grants no reuse/deletion
- * authority and performs no filesystem or database changes. */
 export function worktreeAdoptionNotice(repo, adopted, now) {
     const paths = [...new Set(adopted)].sort();
     if (paths.length === 0)