toolroll 0.9.12 → 0.9.14

package/dist/browser-crew.js

@@ -19,13 +19,14 @@ export function browserWorkActionHref(item) {
     if (action.code === 'open-pr' && /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(item.publicationUrl ?? ''))
         return item.publicationUrl;
     if (runId !== null && (action.code === 'open-pr' || action.code === 'retry-review')) {
-        return `/review?result=${encodeURIComponent(taskId)}&run=${runId}${item.repo === null ? '' : '&project=' + encodeURIComponent(item.repo)}`;
+        return `/review?result=${encodeURIComponent(taskId)}&run=${runId}`;
     }
     if (runId !== null && (action.code === 'inspect-run' || action.code === 'reconcile-run'))
         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

@@ -11,6 +11,7 @@ import type { Ask } from './needs-you.js';
 import type { WorkIndexGroup } from './work-index.js';
 import type { AssignmentCard } from './assignment-ui.js';
 import type { TaskStatus } from './task-status.js';
+import type { ResultActs } from './result-acts.js';
 import type { FirstRunStep, FirstTaskSuggestion, JourneyStep } from './first-run.js';
 export type BrowserProject = {
     name: string;
@@ -366,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;
@@ -586,6 +599,39 @@ 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. */
+        runChecks: {
+            action: string;
+            level: "quick" | "full";
+            returnTo: string;
+        } | null;
+        /** The raw run record, under Details: its facts and the full record. */
+        record: {
+            build: number;
+            href: string;
+            facts: {
+                label: string;
+                value: string;
+            }[];
+        } | null;
         /** The signed scope; null when none was filed. */
         intent: {
             approval: string;

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

@@ -0,0 +1,46 @@
+/** The result page's acts (2026-10-02), chosen in one place: exactly one ink
+ * act, the one that resolves the result's state, and never navigation; at
+ * most one outline act beside it. A result that can't be accepted says why
+ * in one line before them.
+ *
+ *   everything met                      → Accept
+ *   checks queued or running            → Checks running (disabled), then Accept without checks
+ *   checks didn't run, a check exists   → Run checks, then Accept without checks
+ *   report and changes disagree,
+ *   or the proof is refuted             → Request changes, then Accept (as allowed);
+ *                                         never Accept as ink, even with no form here
+ *   a Needs you form resolves it        → that form (Build again, Confirm it stopped)
+ *   saved notes or a failing PR         → Revise / Draft a repair task
+ *
+ * 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. */
+    accept: {
+        ready: boolean;
+    } | null;
+    /** The checks didn't run, the project has one, and this person may run it. */
+    runChecks: boolean;
+    /** Checks on this result are queued or running. */
+    checksRunning: boolean;
+    /** Why it can't be accepted yet (cantAcceptYetOf), or null. */
+    blocked: string | null;
+    /** The feedback form is on this page. */
+    canRequest: boolean;
+    /** A Needs you form that resolves it here. */
+    need: "rebuild" | "confirm-stopped" | null;
+    /** Saved notes ready to become a revision, or a failing pull request's repair. */
+    next: "revise" | "draft-repair" | null;
+};
+export type ResultActs = {
+    /** The one ink act, or null when nothing waits on the person. */
+    primary: ResultActKind | null;
+    /** The one outline act beside it. */
+    secondary: ResultActKind | null;
+    /** The one line before the acts: why it can't be accepted yet. */
+    line: string | null;
+};
+export declare function resultActsOf(facts: ResultActFacts): ResultActs;

package/dist/result-acts.js

@@ -0,0 +1,38 @@
+/** The result page's acts (2026-10-02), chosen in one place: exactly one ink
+ * act, the one that resolves the result's state, and never navigation; at
+ * most one outline act beside it. A result that can't be accepted says why
+ * in one line before them.
+ *
+ *   everything met                      → Accept
+ *   checks queued or running            → Checks running (disabled), then Accept without checks
+ *   checks didn't run, a check exists   → Run checks, then Accept without checks
+ *   report and changes disagree,
+ *   or the proof is refuted             → Request changes, then Accept (as allowed);
+ *                                         never Accept as ink, even with no form here
+ *   a Needs you form resolves it        → that form (Build again, Confirm it stopped)
+ *   saved notes or a failing PR         → Revise / Draft a repair task
+ *
+ * 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";
+    if (facts.need !== null)
+        return { primary: facts.need, secondary: request, line: null };
+    if (facts.next !== null)
+        return { primary: facts.next, secondary: accept ?? request, line: null };
+    // Can't be accepted yet: Accept is never the ink act, even when the feedback form isn't here.
+    if (facts.blocked !== null)
+        return { primary: request, secondary: accept, line: facts.blocked };
+    if (facts.checksRunning)
+        return { primary: "checks-running", secondary: accept ?? request, line: null };
+    if (facts.accept === null)
+        return { primary: null, secondary: request, line: null };
+    if (facts.accept.ready)
+        return { primary: "accept", secondary: request, line: null };
+    if (facts.runChecks)
+        return { primary: "run-checks", secondary: "accept", line: null };
+    return { primary: "accept", secondary: request, line: null };
+}

package/dist/result-review.js

@@ -153,7 +153,7 @@ export function resultFactsFromHtml(html) {
  * lands on the run page. Matched exactly — never a bare open redirect. */
 export function resultReturnTarget(raw, runId) {
     if (raw !== null && raw !== undefined) {
-        const review = /^\/review\?result=[A-Za-z0-9._~%-]{1,200}(?:&run=([0-9]{1,15}))?$/.exec(raw);
+        const review = /^\/review\?result=[A-Za-z0-9._~%-]{1,200}(?:&run=([0-9]{1,15}))?(?:&tab=(?:summary|changes|checks))?$/.exec(raw);
         if (review !== null && (review[1] === undefined || Number(review[1]) === runId))
             return raw;
         const chat = /^\/chat\?task=([A-Za-z0-9._~%-]{1,200})&result=([0-9]{1,15})(?:&conversation=[A-Za-z0-9-]{1,128})?$/.exec(raw);

package/dist/serve.d.ts

@@ -558,6 +558,7 @@ export declare function needActionOf(assignment: AssignmentSnapshot | null, stat
     run: number;
     action: string;
     rebuildable?: boolean;
+    refuted?: boolean;
 }): BrowserNeedAction | null;
 /** The facts region alone, for the open-run poll (A4). A finished run's
  * fragment says so instead of quietly growing forms (finding 5), and a run