toolroll 0.9.13 → 0.9.14

package/dist/browser-crew.js

@@ -25,7 +25,8 @@ export function browserWorkActionHref(item) {
         return `/r/${runId}`;
     const anchor = action.code === 'approve-scope' ? '#approve'
         : action.code === 'inspect-stop' || action.code === 'resume-run' ? '#task-control'
-            : action.code === 'unhold' || action.code === 'retry-task' ? '#task-actions'
+            // Retry (and Build again) is the task's status card itself, at the top: no anchor to its options.
+            : action.code === 'unhold' ? '#task-actions'
                 : action.code === 'write-scope' || action.code === 'select-agent' ? '#scope'
                     : action.code === 'inspect-hold' ? '#holds'
                         : action.code === 'start-worker' || action.code === 'repair-dependency' ? '#run-status' : '';

package/dist/browser-workspace.d.ts

@@ -367,6 +367,18 @@ export type BrowserTaskView = {
     rebuild?: {
         action: string;
     } | null;
+    /** A failed task's recorded reason in one line (the run's reason, the failing check's last error line, or that none was
+     * recorded) and where its log lines are; and Retry itself, with an optional note. */
+    failure?: {
+        line: string;
+        link: {
+            label: string;
+            href: string;
+        } | null;
+    } | null;
+    retry?: {
+        action: string;
+    } | null;
     /** Server cards that may need a person now (stop/resume, scope prompt, plan, live attempt). */
     lead: {
         key: string;
@@ -587,6 +599,22 @@ export type BrowserResultView = {
             problem: boolean;
             logHref: string | null;
         } | null;
+        /** A refuted result's recorded disagreements: the headline when the report doesn't match the changes (null when a
+         * failed check is the blocker, so the status keeps its own), each disagreement in plain words with the changed lines
+         * it concerns (`absent`: a file the changes don't have), and the recorded words they already say, so no caveat
+         * repeats them. Null otherwise. */
+        mismatch: {
+            headline: string | null;
+            rows: {
+                text: string;
+                path: string | null;
+                lines: string | null;
+                href: string | null;
+                absent: boolean;
+                noteLabel: string | null;
+            }[];
+            said: string[];
+        } | null;
         /** The one ink act that resolves the result, the one outline act beside it, and why it can't be accepted yet (result-acts.ts). */
         acts: ResultActs;
         /** Run checks on this result's commit: the project's check, when it didn't run. */

package/dist/dispatch.js

@@ -13,6 +13,7 @@ import { plannerSourceProblemOf } from "./planner-source.js";
 import { authPauseOf, authWaitOf, providerName, signInReason } from "./provider-auth.js";
 import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js";
 import { replacedWords } from "./task-status.js";
+import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
 import { buildReviewOf } from "./review-switch.js";
 import { BUILT_IN, parseCapabilityKey } from "./store.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
@@ -218,8 +219,12 @@ export function diagnoseTaskDispatch(store, taskId, now) {
         return successor === null ? answer("cancelled", "terminal", "Cancelled", "Nothing else will run for this task.")
             : answer("cancelled", "terminal", replacedWords(successor), `${replacedWords(successor)}. Nothing else will run for this task.`);
     }
-    if (task.state === "failed")
-        return answer("failed", "terminal", "Needs a retry", "The last attempt stopped; review its incident, then retry it.", { action: "retry-task" });
+    if (task.state === "failed") {
+        // The family's latest finished attempt's own recorded reason, or that none was recorded: never "review its incident".
+        const family = store.taskFamilyOf(taskId, ref.repo === null ? [] : [ref.repo], ref.repo === null);
+        const runs = family === null || family.problem !== null ? store.runsFor(ref.id) : family.versions.flatMap(version => store.runsFor(version.refId));
+        return answer("failed", "terminal", "Needs a retry", failedAttemptSentence(latestFinishedAttempt(runs)?.reason), { action: "retry-task" });
+    }
     if (store.hasLiveClaim(ref.id, now))
         return answer("running", "running", "Running now", "A worker owns the current live claim.");
     if (task.state === "running")

package/dist/needs-you.d.ts

@@ -59,4 +59,28 @@ export declare function processNeedOf(fact: {
 } | null;
 /** Dispatch and work-index codes that wait on a person, as their need. */
 export declare const CODE_NEED: Readonly<Record<string, NeedKey>>;
+/** A stopped run's recorded reason code, in words (the run record, the thread, a failed task's status). */
+export declare const RUN_REASON_WORDS: Readonly<Record<string, string>>;
+/** A run's recorded reason in words. A recorded code is never shown as it is
+ * stored: one with no words of its own reads as an unexpected stop; a reason
+ * already written as words (it has a space) is said as written. */
+export declare function runReasonWords(reason: string): string;
+/** The latest finished build attempt among a task's runs (any order), whatever its outcome: planning and reviewing
+ * are not attempts, and an older failure never stands in for a newer attempt. */
+export declare function latestFinishedAttempt<T extends {
+    id: number;
+    role: string;
+    finishedAt: string | null;
+    outcome?: string | null;
+}>(runs: readonly T[]): T | null;
+export declare const NO_REASON_RECORDED = "No reason was recorded for this attempt.";
+export declare const INTERNAL_ERROR = "The attempt stopped with an internal error.";
+/** About as long as one plain line reads. */
+export declare const REASON_LINE_LIMIT = 140;
+/** A recorded reason that is machine output, not words: a stack trace, a file path or "Error:" text. Its detail
+ * belongs behind a link, never in the line itself. */
+export declare function isInternalErrorReason(reason: string | null | undefined): boolean;
+/** A failed attempt in one plain line: its recorded reason in words (first line only, about 140 characters at most),
+ * that it stopped with an internal error when the reason is machine output, or that none was recorded. */
+export declare function failedAttemptSentence(reason: string | null | undefined): string;
 export {};

package/dist/needs-you.js

@@ -90,3 +90,103 @@ export const CODE_NEED = {
     "no-build-record": "review-result", "verification-needed": "review-result", "evidence-mismatch": "review-result",
     "record-incomplete": "review-result", "evidence-damaged": "review-result",
 };
+/** A stopped run's recorded reason code, in words (the run record, the thread, a failed task's status). */
+export const RUN_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",
+    acceptance: "the result didn't meet its signed requirements",
+    evidence: "its evidence could not be saved",
+    interrupted: "the attempt was interrupted",
+    orphaned: "the attempt lost its worker",
+    "retryable-infra": "a temporary problem on the machine stopped it",
+    unknown: "the attempt stopped unexpectedly",
+    "spawn-failed": "the agent process could not start",
+    "provider-protocol": "the agent's reply could not be read",
+    "auth-expired": "the agent's sign-in expired",
+    "budget-unenforceable": "its spending limit could not be enforced",
+    "stale-source": "the request changed while the plan was being made",
+    "stale-approval": "the approval no longer matched the scope",
+    "source-invalid": "the plan's source could not be recorded",
+    "external-closed": "the linked issue was closed while it was being built",
+    "repair-admission": "the repair could not start",
+    "reviewer-error": "the review failed",
+    "malformed-report": "the scout's report was malformed",
+    "attempts-exhausted": "it failed too many times in a row",
+};
+/** A run's recorded reason in words. A recorded code is never shown as it is
+ * stored: one with no words of its own reads as an unexpected stop; a reason
+ * already written as words (it has a space) is said as written. */
+export function runReasonWords(reason) {
+    const known = RUN_REASON_WORDS[reason];
+    if (known !== undefined)
+        return known;
+    if (reason.startsWith("decision:"))
+        return "the agent asked a question";
+    return /\s/.test(reason.trim()) ? reason.trim() : "the attempt stopped unexpectedly";
+}
+/** The latest finished build attempt among a task's runs (any order), whatever its outcome: planning and reviewing
+ * are not attempts, and an older failure never stands in for a newer attempt. */
+export function latestFinishedAttempt(runs) {
+    let latest = null;
+    // Ended means a finish time or an outcome: a reconcile can mark a run failed without stamping finished_at.
+    for (const run of runs)
+        if ((run.finishedAt !== null || (run.outcome ?? null) !== null) && run.role !== "planner" && run.role !== "reviewer" && (latest === null || run.id > latest.id))
+            latest = run;
+    return latest;
+}
+export const NO_REASON_RECORDED = "No reason was recorded for this attempt.";
+export const INTERNAL_ERROR = "The attempt stopped with an internal error.";
+/** About as long as one plain line reads. */
+export const REASON_LINE_LIMIT = 140;
+/** A recorded reason that is machine output, not words: a stack trace, a file path or "Error:" text. Its detail
+ * belongs behind a link, never in the line itself. */
+export function isInternalErrorReason(reason) {
+    const text = reason?.trim() ?? "";
+    if (text === "" || RUN_REASON_WORDS[text] !== undefined)
+        return false;
+    return /\b[A-Za-z]*(?:Error|Exception):/.test(text) // Error:, TypeError:, SomeException:
+        || /^\s*at\s+\S+/m.test(text) && /\n/.test(text) // a stack frame below the first line
+        // An absolute path of two or more segments (/Users/…, ~/x/y): plain sentences may name a project file (src/ledger.ts).
+        || /(?:^|[\s(“"'])~?\/(?:[\w.@-]+\/)+[\w.@-]+/.test(text)
+        || /[A-Za-z]:\\/.test(text) // C:\…
+        || /\.[cm]?[jt]sx?:\d+/.test(text); // ledger.ts:14
+}
+/** A failed attempt in one plain line: its recorded reason in words (first line only, about 140 characters at most),
+ * that it stopped with an internal error when the reason is machine output, or that none was recorded. */
+export function failedAttemptSentence(reason) {
+    const code = reason?.trim() ?? "";
+    if (code === "")
+        return NO_REASON_RECORDED;
+    if (isInternalErrorReason(code))
+        return INTERNAL_ERROR;
+    const words = runReasonWords(code.split(/\r?\n/, 1)[0].trim()).replace(/\s+/g, " ").replace(/[.\s]+$/, "");
+    const line = words.length <= REASON_LINE_LIMIT ? words
+        : `${words.slice(0, REASON_LINE_LIMIT - 1).replace(/\s+\S*$/, "").replace(/[,;:\s]+$/, "")}…`;
+    return `${line.charAt(0).toUpperCase()}${line.slice(1)}${line.endsWith("…") ? "" : "."}`;
+}

package/dist/result-acts.d.ts

@@ -14,6 +14,8 @@
  *
  * Accepting means what it always meant: the same forms post to the same
  * endpoints. This only decides which one is ink. */
+/** The words over the reason field an Accept of a refuted result requires. */
+export declare const ACCEPT_NEEDS_REASON = "Accepting needs a reason";
 export type ResultActKind = "accept" | "checks-running" | "run-checks" | "request-changes" | "rebuild" | "confirm-stopped" | "revise" | "draft-repair";
 export type ResultActFacts = {
     /** An Accept this page can post (Mark complete, or the person's acceptance); `ready`: every requirement met and checks passed. */

package/dist/result-acts.js

@@ -14,6 +14,8 @@
  *
  * Accepting means what it always meant: the same forms post to the same
  * endpoints. This only decides which one is ink. */
+/** The words over the reason field an Accept of a refuted result requires. */
+export const ACCEPT_NEEDS_REASON = "Accepting needs a reason";
 export function resultActsOf(facts) {
     const request = facts.canRequest ? "request-changes" : null;
     const accept = facts.accept === null ? null : "accept";

package/dist/serve.js

@@ -75,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";
@@ -164,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, cantAcceptYetOf, 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";
@@ -5895,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)
@@ -5917,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")
@@ -10446,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));
             }
@@ -19828,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
@@ -19871,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";
@@ -20569,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"
@@ -20581,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">`,
@@ -20598,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
@@ -20791,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 });
     }
@@ -20886,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,
@@ -20897,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 },
@@ -21393,7 +21455,7 @@ 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,
+        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(" · ") },
@@ -21473,6 +21535,40 @@ function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab, user)
         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") +
@@ -21481,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, acts, runChecks,
+            ...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}` },
         },
     };
@@ -21576,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",
@@ -22057,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>` +
@@ -22096,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
@@ -22512,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>`);
@@ -22901,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],
@@ -22927,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);