toolroll 0.9.12 → 0.9.14

package/dist/serve.js

@@ -56,6 +56,7 @@ import { knowledgeHtml, knowledgeContextHtml, KNOWLEDGE_CSS, decisionsHtml, memo
 import { listDecisions, recordDecision, retireDecision, searchMemory } from "./project-memory.js";
 import { decideProposal, listProposals, memoryStatus } from "./memory-pass.js";
 import { learningHtml } from "./workspace-ui.js";
+import { resultActsOf } from "./result-acts.js";
 import { createSessionEndpoint } from './session-server.js';
 import { handleTeamHttp } from './team-http.js';
 import { teamWorkspaceHtml } from './team-ui.js';
@@ -74,7 +75,7 @@ import { leadBriefHtml, LEAD_CONTEXT_CSS } from './lead-context.js';
 import { assignmentCatchUp } from './assignment-brief.js';
 import { assignmentActionHref, assignmentCardOf, assignmentStatusOf, assignmentSummaryHtml, assignmentWithEvidence, ASSIGNMENT_CSS } from './assignment-ui.js';
 import { assignmentStageOf, pullRequestFactOf, stageOfCode, stageOfDispatch, statusDetailsHtml, statusIconSvg, statusWhyHtml, taskStatusOf, TASK_STATUS_CSS } from './task-status.js';
-import { ASKS, ASK_LABEL, NEEDS } from './needs-you.js';
+import { ASKS, ASK_LABEL, NEEDS, NO_REASON_RECORDED, failedAttemptSentence, isInternalErrorReason, latestFinishedAttempt, runReasonWords } from './needs-you.js';
 import { assignmentPresentationOf, historicalAssessmentReason, shortenedMaterialReason } from './assignment-presentation.js';
 import { ledgerBody } from "./ledger-view.js";
 import { EVIDENCE_PACK_CSS, evidencePack, evidencePackHtml, exportDay, ledgerExportChunks } from "./evidence-pack.js";
@@ -163,7 +164,7 @@ import { starterRecipes, savedRecipes, findRecipe, importRecipe, exportRecipe, c
 import { recipeFromForm, recipeLibraryHtml, recipeEditorHtml, workflowPreviewHtml, recipeScript, RECIPE_CSS, recipeDefinitionPreviewHtml, recipeRunHtml, recipeAnswersFromForm } from "./recipe-ui.js";
 import { EVIDENCE_CAPS, readVerifiedArtifact, readVerifiedReport, readVerifiedProofForRun, storeEvidence, writeEvidenceFile, scanForSecrets } from "./evidence.js";
 import { GOAL_ASSESSMENT_PENDING, reviewConflict, manualReviewOnly, manualReviewCriterionOf, personCheckWords, plainReasonWords, dispatchStatusToken, passFraction, semanticCoverage, coverageWords, coverageStateWords } from "./proof.js";
-import { WORK_VIEWS, REVIEW_TOKENS, RESULT_DECISION_SENTENCE, acceptWordsOf, parseWorkView, resultStatusOf, resultHeadlineOf, receiptHeadingOf, receiptPublicationWords, reviewFactsOf, workStatusOf, primaryDestinationOf, needsPerson, dispatchActionLabel, } from "./workspace-ui.js";
+import { WORK_VIEWS, REVIEW_TOKENS, RESULT_DECISION_SENTENCE, acceptWordsOf, cantAcceptYetOf, evidenceProblemOf, lastErrorLineOf, reportMismatchesOf, ACCEPT_NEEDS_REASON, MISMATCH_HEADLINE, parseWorkView, resultStatusOf, resultHeadlineOf, receiptHeadingOf, receiptPublicationWords, reviewFactsOf, workStatusOf, primaryDestinationOf, needsPerson, dispatchActionLabel, } from "./workspace-ui.js";
 import { PRICED_BUILD_MODELS } from "./pricing.js";
 import { RESULT_TABS, RESULT_REVIEW_SCRIPT, isRevisionFeedback, evidenceResultStatusOf, evidenceShortenedWords, parseResultTab, resultLeadOf, evidenceProblemDetailsOf, evidenceHealthOf, resultFactsAttributes, resultFactsAttributeMap, resultReturnTarget, commentSourceKey, REQUEST_TOKEN, revisionBatchOf, parseRevisionBatch, revisionSourceOf, } from "./result-review.js";
 import { parseReport } from "./scout-report.js";
@@ -1761,7 +1762,9 @@ export function createDecisionServer(options) {
         }
         // Exact result links carry their own read context. Check the stored
         // placement against both account and instance access before using it;
-        // viewing a result never changes the session's selected project.
+        // viewing a result never changes the session's selected project, and
+        // the page's project switch keeps showing the person's own choice.
+        const chosenProject = project;
         if (url.pathname === "/review" && url.searchParams.has("result")) {
             const wanted = url.searchParams.get("result") ?? "";
             const ref = wanted.length > 0 && wanted.length <= 64 && !hasForbiddenControls(wanted) ? store.lookupRef(wanted) : null;
@@ -2390,11 +2393,14 @@ export function createDecisionServer(options) {
             const selectedRow = wantedId === null ? ranked[0] ?? null : chosen;
             const csrf = who.via === "cookie" ? who.session.csrf : "";
             const expectedRun = url.searchParams.get("run");
+            // An exact link to a result this person can't see (or that never existed) reads the same either way.
+            if (expectedRun !== null && wantedId !== null && chosen === null)
+                return refuse(response, who, 404, "No such result in your projects.", "/work");
             if (expectedRun !== null && (!/^[1-9]\d*$/.test(expectedRun) || selectedRow?.runId !== Number(expectedRun))) {
                 return sendScreen(response, 409, screen("Result changed", '<h1>Result changed</h1><p>This acceptance link no longer matches the current result. Review the current task before accepting.</p><p class="refusal-back"><a class="button-link" href="/review">Review results</a></p>', { chrome: chromeFor(project, "runs") }));
             }
             const selected = selectedRow === null ? null : reviewCockpitViewOf(selectedRow, who, now);
-            const reviewPage = reviewCockpitPage(chromeFor(project, "runs"), {
+            const reviewPage = reviewCockpitPage(chromeFor(wantedId === null ? project : chosenProject, "runs"), {
                 queue: ranked,
                 queueCap: REVIEW_QUEUE_CAP,
                 selected,
@@ -3020,6 +3026,14 @@ export function createDecisionServer(options) {
                 }
                 return respond(response, 200, "application/json", JSON.stringify({ text: window.text, nextOffset: window.nextOffset, final: !live && window.eof }));
             }
+            // One result page (2026-10-02): a builder's finished result opens on
+            // its task's result page, titled with the task. The raw run record
+            // waits there under Details, and here with ?record=1.
+            if (url.searchParams.get("record") === null && !running && found.role === "builder" && (found.outcome === "built" || found.outcome === "no-change") &&
+                completedRowFor(taskId, null)?.runId === found.id) {
+                const tab = parseResultTab(url.searchParams.get("tab"));
+                return redirect(response, `${reviewHref(taskId, found.id)}${tab === "summary" ? "" : `&tab=${tab}`}`);
+            }
             // Pollers exist only for a LIVE run — an orphaned null-outcome run
             // would otherwise be refetched forever (finding 15). The nonce is
             // sendScreen's business now.
@@ -5881,6 +5895,33 @@ export function createDecisionServer(options) {
             return null;
         return { taskId: rootId, view: null, offer: { taskId: receipt.taskId, runId: receipt.runId, digest: receipt.digest }, target };
     }
+    /** What went wrong with the latest finished attempt (whatever its outcome, never an older failure), in one line: a
+     * failing check's last error line (linked to that line in its saved log), else the attempt's recorded reason in plain
+     * words, else that no reason was recorded. A reason that is machine output reads as an internal error, its detail
+     * behind a link to that line of the attempt's record; nothing links to this task's own page. */
+    function failureOf(runs, assignment) {
+        const last = latestFinishedAttempt(runs);
+        if (last === null)
+            return { line: NO_REASON_RECORDED, link: null };
+        const receipt = assignment?.receipt?.runId === last.id ? assignment.receipt : null;
+        if (receipt !== null && receipt.checks.status === "failed" && receipt.checks.logArtifactId !== null) {
+            const artifact = store.artifactsFor(last.id).find(one => one.id === receipt.checks.logArtifactId) ?? null;
+            let read = null;
+            try {
+                read = artifact === null ? null : readVerifiedArtifact(evidenceRoot, artifact);
+            }
+            catch {
+                read = null;
+            }
+            const found = read !== null && read.ok ? lastErrorLineOf(read.content.toString("utf8")) : null;
+            if (found !== null) {
+                return { line: oneLineOf(found.text, 140), link: { label: `Check output, line ${found.line}`,
+                        href: `${reviewHref(receipt.taskId)}&run=${last.id}&tab=checks#check-log-L${found.line}` } };
+            }
+        }
+        return { line: failedAttemptSentence(last.reason),
+            link: isInternalErrorReason(last.reason) ? { label: "The recorded error", href: `/r/${last.id}?record=1#run-reason-detail` } : null };
+    }
     function taskScreen(response, who, taskId, problem, status, scopeDraft, cancelDraft) {
         const admittedFamily = familyOf(taskId);
         if (admittedFamily?.problem != null)
@@ -5903,6 +5944,8 @@ export function createDecisionServer(options) {
                 versions: family.versions.map(one => ({ id: one.id, title: one.title, state: one.state })),
                 runs: family.versions.flatMap(version => version.id === data.task.id ? data.runs.map(run => ({ ...run, taskId: version.id })) : store.runsFor(version.refId).map(run => ({ ...run, taskId: version.id }))) };
         }
+        // What went wrong reads the family's latest finished attempt, as the Tasks row does.
+        presentedData.failure = failureOf(presentedData.family?.runs ?? data.runs, data.assignment ?? null);
         const paneProject = restricted() ? store.lookupRef(taskId)?.repo ?? null : who.via === "cookie" ? who.session.project : null;
         const page = taskPage(paneProject === null && !unscopedMode
             ? chromeFor(paneProject, "tasks")
@@ -10432,10 +10475,21 @@ export function createDecisionServer(options) {
                 return redirect(response, taskHref(taskId));
             }
             case "requeue": {
+                // Retry may carry a note for the next attempt: the same steering note, checked before anything changes.
+                const note = (body.get("note") ?? "").trim();
+                if (note !== "" && who.via !== "cookie")
+                    return refuse(response, who, 403, "steering is a browser session's act");
+                if (note !== "" && !validateNote(note).ok)
+                    return taskScreen(response, who, taskId, "that note will not store, so nothing was retried", 400);
                 const requeued = store.requeueTask(taskId, who.name, now);
                 if (!requeued.ok) {
                     return taskScreen(response, who, taskId, `not requeued: ${requeued.reason}`, 409);
                 }
+                if (note !== "") {
+                    const filed = store.fileSteerNote(taskId, verifiedAuthor(who.name), note, now);
+                    if (!filed.ok)
+                        return taskScreen(response, who, taskId, "Retried. The note wasn't saved; add it under Steering.", 409);
+                }
                 // Allow-listed return only — never an arbitrary URL from the form.
                 return redirect(response, body.get("return") === "inbox" ? "/inbox" : body.get("return") === "next" ? "/next" : taskHref(taskId));
             }
@@ -10975,7 +11029,7 @@ export function createDecisionServer(options) {
                 const completed = checkAssignmentAsOperator(store, taskId, digest, principal, now, evidenceRoot);
                 if (!completed.ok)
                     return taskScreen(response, who, taskId, completed.message, 409);
-                return redirect(response, reviewHref(taskId, Number(namedRun), taskRepoOf(ref.id)));
+                return redirect(response, reviewHref(taskId, Number(namedRun)));
             }
             case "retry-review": {
                 return taskScreen(response, who, taskId, "Separate agent reviews have retired. Open the saved result to mark it complete or request a revision.", 410);
@@ -12708,7 +12762,7 @@ ${THEME_MAPPING}
     --font-mono: "Geist Mono", ui-monospace, "SF Mono", SFMono-Regular, Menlo, Consolas, monospace;
     /* Phone spacing steps (760px and narrower): side gutter, gap under the
        header, gap between page blocks, between rows, and inside a card. */
-    --so-phone-gutter: 14px; --so-phone-gap: 12px; --so-phone-block: 14px; --so-phone-row: 8px; --so-phone-card: 12px;
+    --so-phone-gutter: 16px; --so-phone-gap: 12px; --so-phone-block: 14px; --so-phone-row: 8px; --so-phone-card: 12px;
   }
   @media (prefers-color-scheme: dark) {
     :root:not([data-theme="light"]) {
@@ -18175,9 +18229,9 @@ function statusActionHref(status, taskId, runId, prUrl, repo) {
         return null;
     switch (status.action.kind) {
         case "open-result": return runId === null ? taskHref(taskId) : `/r/${runId}`;
-        case "open-review": return repo === undefined ? reviewHref(taskId) : reviewHref(taskId, runId, repo);
+        case "open-review": return repo === undefined ? reviewHref(taskId) : reviewHref(taskId, runId);
         case "open-run": return runId === null ? taskHref(taskId) : `/r/${runId}`;
-        case "open-pr": return safePrUrl(prUrl) ?? (repo === undefined ? reviewHref(taskId) : reviewHref(taskId, runId, repo));
+        case "open-pr": return safePrUrl(prUrl) ?? (repo === undefined ? reviewHref(taskId) : reviewHref(taskId, runId));
         case "open-task":
         default: return taskHref(taskId);
     }
@@ -18211,7 +18265,7 @@ function workPage(chrome, data) {
     const rowHtml = (row) => {
         const target = row.primaryAction?.target;
         const actionHref = row.primaryAction?.code === 'open-result' && target?.runId != null
-            ? `/review?result=${encodeURIComponent(target.taskId)}&run=${target.runId}${row.repo === null ? '' : '&project=' + encodeURIComponent(row.repo)}`
+            ? `/review?result=${encodeURIComponent(target.taskId)}&run=${target.runId}`
             : browserWorkActionHref(row);
         const action = actionHref === null || row.primaryAction === null ? '' : `<a class="work-action" data-primary-action href="${escape(actionHref)}">${escape(row.primaryAction.label)} →</a>`;
         const project = data.multiProject || row.repo === null ? `<span class="project-label">${row.repo === null ? 'Unplaced' : escape(projectName(row.repo))}</span>` : '';
@@ -18245,7 +18299,7 @@ function workPage(chrome, data) {
         rows: data.work.items.map(row => {
             const target = row.primaryAction?.target;
             const actionHref = row.primaryAction?.code === 'open-result' && target?.runId != null
-                ? `/review?result=${encodeURIComponent(target.taskId)}&run=${target.runId}${row.repo === null ? '' : '&project=' + encodeURIComponent(row.repo)}`
+                ? `/review?result=${encodeURIComponent(target.taskId)}&run=${target.runId}`
                 : browserWorkActionHref(row);
             const needsYouDetail = (row.status.views.includes('needs-you') || row.status.label === 'Failed') && !['write-scope', 'approve-scope'].includes(row.primaryAction?.code ?? '') && row.status.label !== 'Ready for review' && row.status.detail !== row.status.label && row.status.detail !== row.familyProblem;
             return {
@@ -19814,7 +19868,8 @@ function taskBodyParts(data) {
                     case "approve-scope": return ` <a href="#approve">Review and sign the exact scope</a>.`;
                     case "answer-decision": return ` <a href="#decisions">Answer the waiting question</a>.`;
                     case "unhold": return ` Use <strong>Remove hold</strong> when it can continue.`;
-                    case "retry-task": return ` Review the incident, then use <strong>retry</strong> below.`;
+                    // The reason is the detail itself; Retry is the status card's own act, said once.
+                    case "retry-task": return "";
                     case "repair-capability": return ` <a href="/caps">Repair the requirement</a>.`;
                     case "repair-dependency":
                         return blocker?.admitted === true
@@ -19857,7 +19912,8 @@ function taskBodyParts(data) {
                             : `<p class="meta">This task resumes automatically when the builder reconnects. You do not need to file or approve it again.</p>`) +
                         `<p><a href="/system">See connection status →</a></p></div></details>`);
                 }
-                const href = taskRecoveryHref(task.id, diagnosis);
+                // Never a link to this page's own acts: Retry sits on the status card and below.
+                const href = diagnosis.action === "retry-task" ? null : taskRecoveryHref(task.id, diagnosis);
                 return href === null ? "" : `<a class="button-link dispatch-action-link" href="${href}">${escape(dispatchActionLabel(diagnosis))}</a>`;
             })();
             const positive = diagnosis.code === "running" || diagnosis.code === "ready" || diagnosis.code === "planning-ready" || diagnosis.code === "scouting-ready";
@@ -20555,8 +20611,10 @@ function taskBodyParts(data) {
     // hold (the hold governs the NEXT start), and requeue refuses while a
     // claim is live — so the words say exactly when each becomes real.
     const canPlan = data.plan === null && !approval.approved && !data.claimed && task.state === "queued" && (data.coordinator === null || data.coordinator === undefined);
-    const primaryAct = stopControlsActive ? null : stalled && !data.claimed
-        ? { html: act("requeue", "retry — branch and workspace kept"), why: "resolves the incidents, clears the failed attempts, and queues the task again; the preserved branch and workspace are NOT erased", whyClass: "retry" }
+    // A failed task's status card carries Retry itself (the same requeue); here it would be a second ink act.
+    const cardRetries = task.state === "failed" && data.assignment != null && data.csrf !== "";
+    const primaryAct = stopControlsActive || cardRetries ? null : stalled && !data.claimed
+        ? { html: act("requeue", "Retry, keeping the branch and workspace"), why: "Resolves the incidents, clears the failed attempts and queues the task again. The branch and workspace are kept.", whyClass: "retry" }
         : canPlan
             ? { html: act("plan", "plan first"), why: "plan first sends an agent to read the repository, ask you questions, and propose a scope — nothing builds until you approve it", whyClass: "plan" }
             : data.plan === "requested"
@@ -20567,7 +20625,7 @@ function taskBodyParts(data) {
     const holdAct = `<form method="post" action="${taskHref(task.id)}/hold" class="inline act-hold">` +
         `<input type="hidden" name="csrf" value="${escape(data.csrf)}">` +
         `<input type="text" name="reason" class="inline" placeholder="reason (optional)" aria-label="hold reason">` +
-        `<button type="submit">hold next attempt</button></form>`;
+        `<button type="submit">Hold the next attempt</button></form>`;
     const canHold = task.state === "queued" || task.state === "running" || task.state === "failed";
     const actsBar = [
         `<span id="task-actions"></span><div class="acts-bar">`,
@@ -20584,7 +20642,7 @@ function taskBodyParts(data) {
         `</div>`,
         primaryAct === null ? "" : `<p class="meta acts-why acts-why-${primaryAct.whyClass}">${primaryAct.why}</p>`,
         data.claimed && !stopControlsActive
-            ? `<p class="meta acts-why">a worker is building this right now — <em>hold next attempt</em> stops the one after it; cancel waits for the current build to finish${stalled ? "; retry becomes available after this attempt finishes" : ""}</p>`
+            ? `<p class="meta acts-why">a worker is building this right now — <em>Hold the next attempt</em> stops the one after it; cancel waits for the current build to finish${stalled ? "; retry becomes available after this attempt finishes" : ""}</p>`
             : "",
     ].join("\n");
     // Cancel gets the same ceremony as an irreversible answer: armed behind
@@ -20777,7 +20835,7 @@ function taskBodyParts(data) {
                         : run.outcome === null ? "Attempt never finished"
                             : `${noun[0].toUpperCase()}${noun.slice(1)} ${run.outcome}`;
         thread.push({ key: `run-${run.id}`, at: run.finishedAt ?? run.startedAt, kind: "result", who: "agent", author: run.runner,
-            title: `${title}${revision}`, text: run.handoff === null ? (run.reason === null || run.outcome === "built" ? null : reasonWords(run.reason)) : oneLineOf(run.handoff, 600),
+            title: `${title}${revision}`, text: run.handoff === null ? (run.outcome === "failed" ? failedAttemptSentence(run.reason) : run.reason === null || run.outcome === "built" ? null : reasonWords(run.reason)) : oneLineOf(run.handoff, 600),
             link: href, html: "",
             more: previousResult !== null && run.id === newestBuilt?.id && run.taskId === task.id ? { summary: "Result details", html: previousResult.html } : null });
     }
@@ -20872,6 +20930,22 @@ function taskBodyParts(data) {
     // needs a person, then facts, then folds; the mechanics under Manage.
     const MANAGE = new Set(["steering", "waits-for", "holds"]);
     const finished = task.state === "done" || task.state === "cancelled";
+    // Failed: the card says what went wrong in one line, and its one act is Retry itself (the same requeue), never a link to
+    // this page; someone who can't retry here (a viewer, a live claim) gets no act at all.
+    const statusCard = data.assignment != null && assignmentOptions !== null ? assignmentCardOf(data.assignment, assignmentOptions) : null;
+    const failedCard = statusCard?.status.headline === "Failed";
+    // A link to this very page, with no section to open, goes nowhere: a card never offers one.
+    const bareSelfLink = (href) => {
+        if (href.includes("#"))
+            return false;
+        const [path, query = ""] = href.split("?");
+        const version = new URLSearchParams(query).get("version");
+        return [data.assignment?.rootId, data.rootId, task.id].some(id => id != null && path === `/t/${encodeURIComponent(id)}`) && (version === null || version === task.id);
+    };
+    // Build again, in place, names its form after the card's own act.
+    const rebuild = data.csrf !== "" && data.assignment?.primaryAction?.code === "retry-task" && data.assignment.need != null && "key" in data.assignment.need && data.assignment.need.key === "rebuild"
+        ? { action: `${taskHref(data.assignment.rootId)}/requeue` } : null;
+    const retry = failedCard && task.state === "failed" && !data.claimed && !stopControlsActive && data.csrf !== "" ? { action: `${taskHref(task.id)}/requeue` } : null;
     const view = {
         kind: "task",
         id: task.id,
@@ -20883,13 +20957,15 @@ function taskBodyParts(data) {
             { label: "Ask", href: taskChatHref(data.rootId ?? task.id), active: false },
         ],
         version: data.versionLabel == null ? null : { label: data.versionLabel, current: { label: "Current work", href: taskHref(data.rootId ?? task.id) } },
-        status: data.assignment != null && assignmentOptions !== null ? assignmentCardOf(data.assignment, assignmentOptions) : null,
+        status: statusCard === null ? null : failedCard ? { ...statusCard, action: null, status: { ...statusCard.status, sentence: data.failure?.line ?? statusCard.status.sentence } }
+            : statusCard.action !== null && rebuild === null && bareSelfLink(statusCard.action.href) ? { ...statusCard, action: null } : statusCard,
         statusHtml,
+        failure: failedCard ? data.failure ?? null : null,
+        retry,
         approval: approvalHtml,
         confirmStopped: data.csrf !== "" && data.assignment?.primaryAction?.code === "confirm-stopped" && data.assignment.primaryAction.target.runId !== null
             ? { action: `${taskHref(data.assignment.rootId)}/confirm-stopped`, run: data.assignment.primaryAction.target.runId, checked: needsCheck(data.assignment) } : null,
-        rebuild: data.csrf !== "" && data.assignment?.primaryAction?.code === "retry-task" && data.assignment.need != null && "key" in data.assignment.need && data.assignment.need.key === "rebuild"
-            ? { action: `${taskHref(data.assignment.rootId)}/requeue` } : null,
+        rebuild,
         // The plan, progress and plan changes are thread entries now; the rest still needs a person here.
         lead: [
             { key: "history", html: data.history ?? "" }, { key: "control", html: controlHtml }, { key: "problem", html: problemHtml },
@@ -21141,7 +21217,9 @@ export function orderChangedFiles(files, proofCitesPaths) {
             ? churn(b) - churn(a)
             : a.path.localeCompare(b.path));
 }
-const reviewHref = (taskId, runId = null, repo = null) => `/review?result=${encodeURIComponent(taskId)}${runId === null ? "" : `&run=${runId}`}${repo === null ? "" : `&project=${encodeURIComponent(repo)}`}`;
+/** The one result page's address: the task and its run, never a project path
+ * (the page finds the result's project itself and keeps the person's own). */
+const reviewHref = (taskId, runId = null) => `/review?result=${encodeURIComponent(taskId)}${runId === null ? "" : `&run=${runId}`}`;
 /** 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
@@ -21266,7 +21344,7 @@ function reviewCockpitPage(chrome, data) {
                 const why = status === null
                     ? reasons.length === 0 ? "" : `<span class="cockpit-why">${escape(reasons[0])}${reasons.length > 1 ? ` · +${reasons.length - 1} more` : ""}</span>`
                     : `<span class="cockpit-why">${statusLineHtml(status)}</span>`;
-                return (`<li data-review-priority="${row.priority.band}"><a class="cockpit-row${current ? " current" : ""}" href="${escape(reviewHref(row.taskId, row.runId, row.repo))}"${current ? ` aria-current="page"` : ""}>` +
+                return (`<li data-review-priority="${row.priority.band}"><a class="cockpit-row${current ? " current" : ""}" href="${escape(reviewHref(row.taskId, row.runId))}"${current ? ` aria-current="page"` : ""}>` +
                     `<span class="cockpit-row-head"><strong>${escape(row.title)}</strong></span>` +
                     `<span class="cockpit-row-meta">${whenTime(row.completedAt)}${row.runId === null ? " · no build" : row.outcome === "no-change" ? " · no change" : ""}${row.prNumber === null ? "" : ` · PR #${row.prNumber}`}</span>` +
                     (row.historyProblem ? `<span class="cockpit-why" data-history-problem>History unavailable</span>` : why) +
@@ -21295,7 +21373,7 @@ function reviewCockpitPage(chrome, data) {
             const status = row.assignment == null ? null : assignmentPresentationOf(row.assignment).status;
             const reasons = row.priority.reasons;
             return {
-                title: row.title, href: reviewHref(row.taskId, row.runId, row.repo), at: row.completedAt,
+                title: row.title, href: reviewHref(row.taskId, row.runId), at: row.completedAt,
                 status: status === null ? null : { label: status.label, tone: status.tone },
                 notes: [...(row.historyProblem ? ["History unavailable"] : status === null && reasons.length > 0 ? [reasons[0]] : []), ...(status !== null && row.ciFailing ? ["CI is failing"] : [])],
                 current: selected !== null && selected.taskId === row.taskId,
@@ -21377,6 +21455,15 @@ function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user)
         problem: view.detail === null ? view.historyProblem : null,
         next: reviewNextActionOf(view, csrf), complete: null, decision: null, checks: null, intent: intentView, noRun: null, panel: null, contest: "",
         notes: view.notes.map(one => ({ author: one.author, at: one.createdAt, note: one.note })),
+        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: "Worker", value: run.runner },
+                ...(run.branch === null ? [] : [{ label: "Branch", value: run.branch }]),
+                ...(run.finishedAt === null ? [] : [{ label: "Finished", value: when(run.finishedAt) }]),
+                ...(run.ranMinutes === null ? [] : [{ label: "Ran", value: `${run.ranMinutes} min` }]),
+            ] },
     };
     if (run === null || view.detail === null) {
         parts.push(`<section class="card cockpit-section" id="verification" data-cockpit-section="proof"><h3>verification</h3>` +
@@ -21419,7 +21506,8 @@ function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user)
     // The one decision, after the evidence: Accept only when every requirement is met and the checks passed.
     const acceptsHere = complete !== null || panel.panel.need?.accept != null;
     const matrix = proof === null || proof.proofProblem !== null ? [] : proof.matrix;
-    const decision = !acceptsHere ? null : { sentence: RESULT_DECISION_SENTENCE, ...acceptWordsOf({
+    const blocked = cantAcceptYetOf(proof?.verdict ?? null, proof?.reasons ?? [], accepted);
+    const words = !acceptsHere ? null : { sentence: RESULT_DECISION_SENTENCE, ...acceptWordsOf({
             checks: checks === undefined ? null : checks.running != null ? "running" : checks.level === "off" && checks.status !== "passed" ? "off" : checks.status,
             unmet: matrix.filter(row => row.state !== "pass" && row.state !== "manual-review").length,
             yours: complete === null || accepted ? 0 : panel.panel.youCheck?.lines.length ?? 0,
@@ -21427,6 +21515,60 @@ function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user)
             publishing: view.detail?.publishing ?? "other",
             proof: proof !== null && proof.proof !== null && proof.proofProblem === null,
         }) };
+    // Refuted: plain Accept stays as allowed, in outline, and the one line before the acts (acts.line) says why.
+    const decision = words === null || blocked === null ? words : { ...words, label: "Accept", ready: false };
+    // 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")
+        // 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: `${here}&run=${run.id}&tab=checks` } : null;
+    const need = panel.panel.need;
+    const nextKind = selected.next?.kind;
+    const acts = resultActsOf({
+        accept: decision === null ? null : { ready: decision.ready },
+        runChecks: runChecks !== null,
+        checksRunning,
+        blocked,
+        canRequest: panel.panel.canRequest && panel.panel.request !== null,
+        need: need === null || need.accept != null ? null : need.rebuild != null ? "rebuild" : need.confirm !== null ? "confirm-stopped" : null,
+        next: nextKind === "revise" || nextKind === "draft-repair" ? nextKind : null,
+    });
+    // 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 = 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") ?? [];
+            if (shown[0]?.newLine != null)
+                hunkStart.set(file.path, shown[0].newLine);
+            const added = shown.filter(line => line.kind === "addition");
+            const lines = (added.length > 0 ? added : shown).map(line => line.newLine);
+            return [file.path, lines.length === 0 ? null : { from: Math.min(...lines), to: Math.max(...lines) }];
+        }));
+        const changesHref = `${here}&run=${run.id}&tab=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)
+            return null;
+        return {
+            headline: evidenceProblemOf(proof.verdict, proof.reasons) === "mismatched" ? MISMATCH_HEADLINE : null,
+            rows: found.map(one => ({
+                text: one.text, path: one.path, absent: one.inChanges === false,
+                lines: one.lines === null ? null : one.lines.from === one.lines.to ? `line ${one.lines.from}` : `lines ${one.lines.from}–${one.lines.to}`,
+                href: one.path !== null && one.inChanges === true ? `${changesHref}#${diffFileAnchor(one.path)}${hunkStart.has(one.path) ? `-L${hunkStart.get(one.path)}` : ""}`
+                    : one.note !== null && (proof.proof?.caveats.length ?? 0) >= one.note ? `${here}&run=${run.id}#report-note-${one.note}` : null,
+                noteLabel: one.path === null && one.note !== null ? `The report, note ${one.note}` : null,
+            })),
+            said: [...new Set([...proof.reasons, ...found.map(one => one.reason)].flatMap(reason => [reason, plainReasonWords(reason)]))],
+        };
+    })();
     if (view.notes.length > 0) {
         parts.push(`<section class="card cockpit-section" data-cockpit-section="notes"><h3>operator notes</h3>` +
             view.notes.map(one => `<p class="row"><span class="meta">${escape(one.author)} · ${whenTime(one.createdAt)}</span> ${escape(one.note)}</p>`).join("\n") +
@@ -21435,7 +21577,7 @@ function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user)
     return {
         html: `<section class="cockpit-detail">${parts.join("\n")}</section>`,
         selected: {
-            ...selected, complete, decision, panel: panel.panel, contest,
+            ...selected, complete, decision, panel: panel.panel, contest, acts, runChecks, mismatch,
             checks: checks === undefined ? null : { detail: checks.detail, problem: checks.status === "failed" || checks.status === "unavailable", logHref: checks.logArtifactId === null ? null : `/r/${run.id}/evidence/${checks.logArtifactId}` },
         },
     };
@@ -21530,38 +21672,9 @@ function homePhaseWords(run) {
 function phaseWords(phase) {
     return PHASE_WORDS[phase] ?? "the agent is working";
 }
-const REASON_WORDS = {
-    agent: "the agent failed",
-    "agent-reported": "the agent reported it could not finish",
-    "no-op": "nothing changed when something should have",
-    "no-handoff": "the agent stopped before handing off; its work was kept and it is being resumed",
-    "moved-head": "the branch moved underneath the build",
-    "moved-branch": "the branch moved underneath the build",
-    timeout: "ran out of time",
-    git: "a git step failed",
-    "malformed-decision": "the agent's question was malformed",
-    "malformed-plan": "the plan was malformed",
-    fenced: "another worker took the task over",
-    unapproved: "the scope was not approved",
-    "scope-changed": "the scope changed after approval",
-    capability: "a requirement was missing",
-    setup: "the workspace preparation step failed",
-    "provider-init": "the agent could not start",
-    "commit-failure": "the commit failed",
-    "protected-branch": "refused to touch a protected branch",
-    "wrong-branch": "the checkout was on the wrong branch",
-    "not-leased": "the lease was not valid",
-    "no-claim": "the lease was not valid",
-    "not-yours": "the lease was not valid",
-    "no-run-record": "the run record was missing",
-    "missing-mailbox": "the resume mailbox could not be read",
-    "unreadable-mailbox": "the resume mailbox could not be read",
-    "revision-brief": "the revision brief could not be read",
-    "repaired-park": "resumed from a parked question",
-    stopped: "stopped by the operator",
-};
+/** A recorded reason in one plain line; machine output (a stack trace, a path, "Error:" text) waits on the run record. */
 function reasonWords(reason) {
-    return REASON_WORDS[reason] ?? "stopped — the build records have the detail";
+    return isInternalErrorReason(reason) ? "stopped with an internal error" : oneLineOf(runReasonWords(reason.trim().split(/\r?\n/, 1)[0] ?? ""), 140);
 }
 const INCIDENT_WORDS = {
     "malformed-decision": "the agent's question was malformed",
@@ -22011,18 +22124,23 @@ function reviewDiffHtml(patch, stat, runId, commentable, anchors = new Map()) {
             : counts.additions === null || counts.deletions === null
                 ? `<span class="diff-file-counts">binary</span>`
                 : `<span class="diff-file-counts"><b>+${counts.additions}</b><i>−${counts.deletions}</i></span>`;
-        const hunks = one.hunks.map(hunk => `<section class="diff-hunk"><div class="diff-hunk-head">${escape(hunk.header)}</div>` +
-            `<div class="diff-lines">${hunk.lines.map(line => {
-                const lineNumber = line.newLine ?? line.oldLine;
-                const side = line.newLine === null && line.oldLine !== null ? "old" : "new";
-                const annotate = !commentable || lineNumber === null || line.kind === "meta"
-                    ? `<span class="diff-annotate-space"></span>`
-                    : `<button type="button" class="diff-annotate pick-line" data-path="${escape(one.path)}" data-line="${lineNumber}" data-side="${side}" aria-label="Annotate ${escape(one.path)}, ${side} line ${lineNumber}" title="Annotate this line">${annotateIcon}</button>`;
-                const marker = line.kind === "addition" ? "+" : line.kind === "deletion" ? "−" : line.kind === "context" ? " " : "·";
-                return (`<div class="diff-line diff-${line.kind}">${annotate}` +
-                    `<span class="diff-gutter">${line.oldLine ?? ""}</span><span class="diff-gutter">${line.newLine ?? ""}</span>` +
-                    `<code><b aria-hidden="true">${marker}</b>${escape(line.text)}</code></div>`);
-            }).join("")}</div></section>`).join("");
+        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 `<section class="diff-hunk"${fileAnchor === undefined || first === null ? "" : ` id="${fileAnchor}-L${first}"`}><div class="diff-hunk-head">${escape(hunk.header)}</div>` +
+                `<div class="diff-lines">${hunk.lines.map(line => {
+                    const lineNumber = line.newLine ?? line.oldLine;
+                    const side = line.newLine === null && line.oldLine !== null ? "old" : "new";
+                    const annotate = !commentable || lineNumber === null || line.kind === "meta"
+                        ? `<span class="diff-annotate-space"></span>`
+                        : `<button type="button" class="diff-annotate pick-line" data-path="${escape(one.path)}" data-line="${lineNumber}" data-side="${side}" aria-label="Annotate ${escape(one.path)}, ${side} line ${lineNumber}" title="Annotate this line">${annotateIcon}</button>`;
+                    const marker = line.kind === "addition" ? "+" : line.kind === "deletion" ? "−" : line.kind === "context" ? " " : "·";
+                    return (`<div class="diff-line diff-${line.kind}">${annotate}` +
+                        `<span class="diff-gutter">${line.oldLine ?? ""}</span><span class="diff-gutter">${line.newLine ?? ""}</span>` +
+                        `<code><b aria-hidden="true">${marker}</b>${escape(line.text)}</code></div>`);
+                }).join("")}</div></section>`;
+        }).join("");
         const anchor = anchors.get(one.path);
         return (`<details class="diff-file"${fileIndex === 0 ? " open" : ""}${anchor === undefined ? "" : ` id="${anchor}"`}>` +
             `<summary><span class="diff-file-name">${escape(one.path)}</span>${countWords}</summary>` +
@@ -22050,7 +22168,9 @@ function checkLogHtml(log, runId, attributes) {
     if (log.problem !== null) {
         return `<p class="problem" data-check-log="damaged"${attributes}>The check log no longer verifies (${escape(log.problem)}). Its output is not shown, and there is nothing to download.</p>`;
     }
-    return (`<details data-check-log="${log.truncated ? "shortened" : "ok"}"${attributes}><summary>Check output${log.truncated ? ` (shortened — ${log.bytesStored} of ${log.bytesOriginal} bytes stored)` : ""}</summary><pre class="mono" style="overflow-x:auto;max-height:18rem">${escape(log.text)}</pre></details>` +
+    return (`<details data-check-log="${log.truncated ? "shortened" : "ok"}"${attributes}><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.
+    log.text.split("\n").map((line, index) => `<span id="check-log-L${index + 1}">${escape(line)}</span>`).join("\n")}</pre></details>` +
         storedDownloadLink(runId, log.artifactId, "check log", log.truncated));
 }
 /** The download link for a stored record (repair 2026-09-14): a shortened
@@ -22344,7 +22464,7 @@ function resultPanelParts(detail, o) {
     // 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`,
+        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))
     });
@@ -22466,6 +22586,8 @@ function resultPanelParts(detail, o) {
         ...(conclusion !== outcome ? [`<p class="recap">${escape(conclusion)}</p>`] : []),
         ...(handoff !== null && handoff.changes.length > 0 ? [`<ul class="result-changes">${handoff.changes.map(one => `<li>${escape(one)}</li>`).join("")}</ul>`] : []),
         ...(handoff !== null && handoff.verification.length > 0 ? [`<p class="meta">Checked by the agent:</p><ul class="result-changes" data-cockpit-source="agent-words">${handoff.verification.map(one => `<li>${escape(one)}</li>`).join("")}</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 ? [] : [`<p class="meta">Its notes:</p><ol class="result-changes" data-report-notes>${proof.proof.caveats.map((one, index) => `<li id="report-note-${index + 1}">${escape(one)}</li>`).join("")}</ol>`]),
     ];
     if (agentAccount.length > 0)
         summaryParts.push(`<details class="result-notes" data-result-notes-agent><summary>What the agent reported</summary>${agentAccount.join("")}</details>`);
@@ -22762,7 +22884,7 @@ export function needActionOf(assignment, status, csrf, returnTo, result) {
     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.accepted && csrf !== "")
+        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
@@ -22772,8 +22894,9 @@ export function needActionOf(assignment, status, csrf, returnTo, result) {
             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 { label: "Open the task", href: taskHref(assignment.rootId), confirm: null };
+            return null;
     }
     const confirm = action?.code === "confirm-stopped" && action.target.runId !== null && csrf !== ""
         ? { action: `${taskHref(assignment.rootId)}/confirm-stopped`, run: action.target.runId, returnTo, checked: needsCheck(assignment) } : null;
@@ -22802,7 +22925,7 @@ function resultNeedAction(need, o, canRequest) {
 function conciseOutcomeOf(conclusion) {
     const flat = oneLineOf(conclusion, 2_000);
     const sentence = /^[\s\S]*?[.!?](?=\s|$)/.exec(flat)?.[0] ?? flat;
-    const bounded = sentence.length <= 180 ? sentence : `${sentence.slice(0, 180).replace(/\s+\S*$/, "")}…`;
+    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
@@ -22854,7 +22977,7 @@ function runFactsRows(run, taskId, live, route = null) {
         ["quality", qualityModeTitle(run.qualityMode ?? "default")],
         ["outcome", live ? "running" : (run.outcome ?? "never finished")],
         ["phase", live && run.phase !== null ? phaseWords(run.phase) : null],
-        ["reason", run.reason === null ? null : reasonWords(run.reason)],
+        ["reason", run.reason === null ? null : isInternalErrorReason(run.reason) ? "stopped with an internal error (below)" : reasonWords(run.reason)],
         ["runner", run.runner, true],
         ["branch", run.branch, true],
         ["model", run.model, true],
@@ -22880,7 +23003,11 @@ function runFactsRows(run, taskId, live, route = null) {
         .filter((fact) => fact[1] !== null && fact[1] !== "")
         .map(([label, value, mono]) => `<p class="row"><span class="meta" style="min-width:8.5rem">${escape(label)}</span> ` +
         `<span${mono === true ? ` class="mono"` : ""}>${escape(value)}</span></p>`)
-        .join("\n") + elapsed);
+        .join("\n") + elapsed +
+        // 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)
+            ? `<p class="row"><span class="meta" style="min-width:8.5rem">recorded error</span></p><pre class="mono" id="run-reason-detail" style="white-space:pre-wrap;overflow-wrap:anywhere">${escape(run.reason)}</pre>`
+            : ""));
 }
 function runPage(chrome, run, taskId, artifacts, terminal = null, notes = [], csrf = "", comments = [], ciRepair = null, liveScript, peekable = false, running = false, editor = null, editorToggle = null, noted = false, heldTurns = null, continueOffer = null, structuredHandoff = null, proofBundle = null, route = null, publicationRow = null, review = null, result = null, sourceDigest = null) {
     const rows = runFactsRows(run, taskId, running, route);

package/dist/task-status.d.ts

@@ -86,10 +86,12 @@ export type TaskStatusFacts = {
     report?: boolean;
     checks?: ChecksFact | null;
     pullRequest?: PullRequestFact | null;
+    /** `unverified`: the report is refuted, so no requirement counts as met however it was marked. */
     requirements?: {
         met: number;
         total: number;
         yours: number;
+        unverified?: boolean;
     } | null;
     evidence?: {
         shortened: number;
@@ -159,6 +161,8 @@ export declare function requirementsOf(matrix: readonly {
     } | undefined;
     review?: unknown;
 }[] | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
+/** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */
+export declare function unverifiedWhenRefuted(requirements: NonNullable<TaskStatusFacts["requirements"]> | null, verdict: string | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
 /** Saved evidence health from the receipt's artifact list and its caveats. */
 export declare function evidenceOf(receipt: AssignmentSnapshot["receipt"], problems?: readonly string[]): NonNullable<TaskStatusFacts["evidence"]> | null;
 /** The status facts of one assignment, as every surface reads them. */