toolroll 0.9.13 → 0.9.15

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.9.15 — 2026-10-02
+
+- **Accept finishes the task.** One step, Accept and finish, after the
+  evidence. Your own checks come first, and the count updates as you answer.
+- **Failures say what failed.** A failed task names the requirement or check
+  it missed and suggests what to change, prefilled in Retry. Failed builds get
+  a real result page. Builds show "Step 2 of 6" and say when they're stuck.
+- **One set of words.** The same state names in the list, task page, result
+  page and Crew. Project checks and PR CI are labelled apart, and every time
+  shows in your own time zone.
+- **Approving says what you allow.** A plain "You're allowing" line sits above
+  Approve, your password says what it signs, and Edit plan edits in place.
+- **Safer deploys.** An interrupted deploy puts the old service and its coding
+  store back.
+
+## 0.9.14 — 2026-10-02
+
+- **Results and failures say what went wrong.** A result whose report doesn't
+  match its saved changes says so in its headline and lists each mismatch,
+  with its requirements shown as unverified; accepting it asks for a reason. A
+  failed task shows its latest attempt's reason in one plain line (or that
+  none was recorded), linked to the log, with Retry as its one action.
+
 ## 0.9.13 — 2026-10-02
 
 - **One page per result.** Every build's result has one page, titled with its

package/dist/assignment-ui.d.ts

@@ -60,6 +60,7 @@ export type AssignmentCard = {
 export declare function assignmentCardOf(assignment: AssignmentSnapshot, options?: AssignmentCardOptions): AssignmentCard;
 export declare function assignmentSummaryHtml(assignment: AssignmentSnapshot, options?: AssignmentCardOptions & {
     compact?: boolean;
+    sentence?: string | undefined;
 }): string;
 /** Shared assignment layout; actions remain comfortable on touch screens. */
 export declare const ASSIGNMENT_CSS = ".assignment-summary{min-width:0;overflow-wrap:anywhere}.assignment-summary .assignment-state{font-weight:600;margin:0}.assignment-summary h2.assignment-state{font-size:1.125rem;color:var(--foreground)}.assignment-summary>.assignment-attempts,.assignment-summary>.assignment-notices{border:0;box-shadow:none;padding:0;margin:.25rem 0 0;background:transparent}.assignment-summary>.button-link{margin-top:.7rem;min-height:44px}.assignment-summary>.work-action{display:inline-flex;margin-inline-start:.6rem;min-height:44px;align-items:center}.assignment-detail{margin:.55rem 0}.assignment-attempts summary,.assignment-notices summary{min-height:44px;display:list-item;align-content:center;cursor:pointer}.assignment-notices summary{font-size:.8125rem;color:var(--foreground)}.assignment-notices p{margin:.25rem 0 .5rem}.assignment-attempts ol{padding-left:1.4rem}.assignment-attempts li{margin:.4rem 0}.assignment-attempts li a{display:inline-flex;align-items:center;min-height:44px;margin-right:.7rem}.assignment-attempts li p{margin:0 0 .4rem}";

package/dist/assignment-ui.js

@@ -41,7 +41,8 @@ export function assignmentActionHref(assignment) {
         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' : '';
@@ -71,10 +72,12 @@ function savedMaterialNotice(detail, assignment) {
 }
 export function assignmentCardOf(assignment, options = {}) {
     const receipt = assignment.receipt;
-    const links = receipt === null ? {} : { result: options.resultHref ?? chatResultHref(receipt.taskId, receipt.runId), checks: chatResultHref(receipt.taskId, receipt.runId, 'checks'),
+    // The checks live on the one result page (a failed build has one too), where Run checks runs in place; never Chat,
+    // which would only lead back to this card.
+    const checksPage = receipt === null ? null : `/review?result=${encodeURIComponent(receipt.taskId)}&run=${receipt.runId}&tab=checks`;
+    const links = receipt === null ? {} : { result: options.resultHref ?? chatResultHref(receipt.taskId, receipt.runId), checks: checksPage,
         pullRequest: `/t/${encodeURIComponent(assignment.rootId)}#merge`,
-        // Run checks lives with the result's checks; the row's action leads there.
-        ...(receipt.completionKind === 'research-report' ? {} : { runChecks: `${chatResultHref(receipt.taskId, receipt.runId, 'checks')}#follow-ups` }) };
+        ...(receipt.completionKind === 'research-report' ? {} : { runChecks: `${checksPage}#follow-ups` }) };
     const presentation = assignmentPresentationOf(assignment, { ...options, links });
     const { status, diagnostics, taskStatus } = presentation;
     const href = assignment.primaryAction?.code === 'open-result' && options.resultHref !== undefined ? options.resultHref : assignmentActionHref(assignment);
@@ -99,7 +102,7 @@ export function assignmentSummaryHtml(assignment, options = {}) {
     const tone = card.status.tone;
     return `<section class="${options.compact ? 'assignment-summary' : 'card assignment-summary'}" aria-label="assignment progress" data-assignment="${escape(assignment.rootId)}" data-work-status="${card.token}" data-tone="${card.tone}" data-headline="${escape(card.status.headline)}" data-headline-tone="${tone}"${options.compact ? '' : ' data-task-status'}>` +
         (options.compact ? `<span class="status-line" data-work-status="${card.token}" data-tone="${card.tone}"><i class="status-dot" aria-hidden="true"></i><span class="status-label">${card.label}</span></span>` : `<h2 class="assignment-state status-headline"><i aria-hidden="true"></i>${escape(card.label)}</h2>`) +
-        `<p class="meta assignment-detail status-sentence">${escape(card.status.sentence)}</p>` +
+        `<p class="meta assignment-detail status-sentence">${escape(options.sentence ?? card.status.sentence)}</p>` +
         (card.action === null ? '' : `<a class="${options.compact ? 'work-action' : 'button-link'}" href="${escape(card.action.href)}"${card.action.openResult ? ' data-open-result' : ''}${options.compact ? '' : ' data-primary-action'}>${escape(card.action.label)}${options.compact ? ' →' : ''}</a>`) +
         (options.compact ? '' : statusDetailsHtml(card.status)) +
         statusWhyHtml(card.status, card.reasons, card.diagnostics) +

package/dist/assignment.d.ts

@@ -111,6 +111,10 @@ export type AssignmentSnapshot = {
     } | null;
     /** The person's lead took it on (lead-voice.ts): "Your lead is on it" until done, handed on, or two quiet hours. */
     lead?: LeadClaim | null;
+    /** How many earlier versions of this task are still queued or running; absent when none. */
+    earlierActive?: number;
+    /** Of those, how many are running rather than only queued; present with earlierActive. */
+    earlierRunning?: number;
 };
 /** Status-first handoff for routine reads. Fetch get_assignment only when
  * inspecting its exact evidence; do not repeat a full proof in every poll. */
@@ -180,6 +184,34 @@ export declare function checkAssignment(store: Store, taskId: string, receiptDig
 /** The signed-in user can mark the same exact receipt handled without taking
  * lead ownership. This records review, never check success or new authority. */
 export declare function checkAssignmentAsOperator(store: Store, taskId: string, receiptDigest: string, who: VerifiedApprover, now: Date, root?: string): MutationResult;
+/** The acceptance's own ledger act, as a separate Accept request records it. */
+export declare const ACCEPT_ACTION = "task accept-proof";
+/** Only a person's check stands between this result and done: its proof is short for that alone, and nobody accepted it. */
+export declare function personCheckPending(receipt: AssignmentReceipt | null): boolean;
+type Finished = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+    message: string;
+};
+/** An acceptance this receipt owes before it finishes: the person's own check (no reason needed), or an
+ * exception the proof needs and the person gave a reason for. Null when Accept and finish is a plain
+ * completion: nothing is owed, it was already accepted, or an exception came without its reason. */
+export declare function owedAcceptance(receipt: AssignmentReceipt | null, note: string | null): "person-check" | "exception" | null;
+/** Accept and finish: the person's acceptance of the exact result they read and its completion, in one
+ * transaction. Whether an acceptance is owed is decided here, against the receipt as it stands: only a
+ * person's own check or a reasoned exception records one (with its ledger act); anything else is the plain
+ * completion Mark complete always was. The completion names the receipt the acceptance produced, under the
+ * same digest a separate Accept then Mark complete leave. `receiptDigest` is the receipt as read, before
+ * accepting (`runId`, when named, must be its run); any other change refuses both, and a refused completion
+ * keeps no acceptance. `finish` completes the receipt (Mark complete by default; Complete and open a pull
+ * request passes its own). */
+export declare function acceptAndCompleteAsOperator(store: Store, taskId: string, input: {
+    runId: number | null;
+    receiptDigest: string;
+    note: string | null;
+}, who: VerifiedApprover, now: Date, root?: string, finish?: (digest: string) => Finished): Finished;
 /** The ordinary worker reconciles at most 50 owned roots per pass. A lost
  * wakeup is recovered after restart; immutable notification keys dedupe it. */
 export declare function syncAssignmentHandoffs(store: Store, now: Date, repos: readonly string[], root?: string): void;

package/dist/assignment.js

@@ -14,10 +14,11 @@ import { verificationEvidence } from "./verification-evidence.js";
 import { reproveApprover } from "./principal.js";
 import { noteAssignmentStatus } from "./assignment-status.js";
 import { historicalAssessmentReason } from "./assignment-presentation.js";
+import { manualReviewOnly } from "./proof.js";
 import { runCheckLevel } from "./check-levels.js";
 import { followUpChecksOf, withFollowUps } from "./result-follow-ups.js";
 import { buildReviewOf, findingWords } from "./review-switch.js";
-import { NEEDS, WAITS, processNeedOf } from "./needs-you.js";
+import { NEEDS, WAITS, processNeedOf, resultHoldUpSentence } from "./needs-you.js";
 import { assignmentStageOf } from "./task-status.js";
 import { leadClaimOf } from "./lead-voice.js";
 /** Status-first handoff for routine reads. Fetch get_assignment only when
@@ -140,9 +141,11 @@ export function assignmentOf(store, taskId, now, access, root) {
         return decision === null ? [] : [{ taskId: version.id, decision }];
     });
     // A finished task label cannot hide a lease or an unfinished process record.
-    const earlierActive = family.versions.filter(version => version.id !== current.id &&
-        (version.state === "queued" || version.state === "running" || store.currentLiveLease(version.refId, now) !== null ||
-            store.runsFor(version.refId).some(run => run.outcome === null || store.stopQuiescenceProblem(run.id) !== null)));
+    const busy = (version) => version.state === "running" || store.currentLiveLease(version.refId, now) !== null ||
+        store.runsFor(version.refId).some(run => run.outcome === null || store.stopQuiescenceProblem(run.id) !== null);
+    const earlierActive = family.versions.filter(version => version.id !== current.id && (version.state === "queued" || busy(version)));
+    // Of those, how many have work under way (the rest only wait in the queue).
+    const earlierRunning = earlierActive.filter(busy).length;
     const unfinished = store.runsFor(current.refId).find(run => run.outcome === null) ?? null;
     const attempts = family.versions.map(version => {
         const summary = version.id === current.id ? work : taskWorkSummaryOf(store, version.id, now, access);
@@ -246,7 +249,7 @@ export function assignmentOf(store, taskId, now, access, root) {
         detail = completionKind === "research-report" ? "The research report is ready for the lead to read."
             : completionKind === "accepted-exception" ? "An operator accepted this result with its recorded limitations. The lead can inspect that decision; the recorded checks are unchanged."
                 : receipt.checks.detail;
-        primaryAction = { code: "open-result", label: completionKind === "research-report" ? "Read report" : receipt.checks.status === "failed" ? "Inspect failed check" : completionKind === "accepted-exception" ? "Review acceptance" : "Open result", target: { taskId: current.id, runId: result.id, decisionId: null }, access: "read", retry: "read-again" };
+        primaryAction = { code: "open-result", label: completionKind === "research-report" ? "Read report" : "Open result", target: { taskId: current.id, runId: result.id, decisionId: null }, access: "read", retry: "read-again" };
         const checked = store.handle.prepare("SELECT actor,at FROM action_ledger WHERE task_id = ? AND run_id = ? AND action = ? AND outcome = ? AND source = 'work' ORDER BY id DESC")
             .all(family.root.id, result.id, CHECK_ACTION, receipt.digest).find(row => /^(operator|coordinator|lead):.+/.test(String(row["actor"])));
         // This ledger fact was authorized when written. Credential rotation,
@@ -269,7 +272,11 @@ export function assignmentOf(store, taskId, now, access, root) {
             detail = result?.role === "scout"
                 ? completionKind === null ? "The research report is missing or incomplete. Inspect the saved report before checking this handoff."
                     : "The saved report is awaiting resolution of its current scope or hold."
-                : "Inspect the saved result and resolve its remaining execution or scope issue.";
+                : resultHoldUpSentence({ hold: store.activeHolds(current.refId, now)[0]?.reason ?? null,
+                    planChanged: result !== null && scope !== null && !!result.scopeDigest && scope.digest !== result.scopeDigest,
+                    unapproved: scope === null || scope.termsProblem != null || !approvalOf(scope).approved, question: questions.length > 0,
+                    running: store.currentLiveLease(current.refId, now) !== null, unfinished: unfinished !== null,
+                    noCommit: result === null || completionKind === null });
         // Built to an earlier plan: the result page can't resolve it (accepting would leave it stuck), building again can.
         if (current.state === "done" && result !== null && scope !== null && scope.termsProblem == null && approvalOf(scope).approved && !!result.scopeDigest && scope.digest !== result.scopeDigest &&
             store.activeHolds(current.refId, now).length === 0 && unfinished === null && store.currentLiveLease(current.refId, now) === null && store.finalResultReason(result.id) === null) {
@@ -341,7 +348,7 @@ export function assignmentOf(store, taskId, now, access, root) {
     return { version: 1, rootId: family.root.id, activeTaskId: current.id, repo: current.repo, title: family.root.title,
         state, detail, primaryAction, attention: [...new Set(attention)], attempts, owner, receipt, savedContext, completion, handoff,
         publication: publication === null ? null : { state: publication.state, prUrl: publication.prUrl, remoteState: publication.remoteState },
-        review, deployment: { status: "not-recorded" }, ...(need === null ? {} : { need }), ...(lead === null ? {} : { lead }) };
+        review, deployment: { status: "not-recorded" }, ...(need === null ? {} : { need }), ...(lead === null ? {} : { lead }), ...(earlierActive.length === 0 ? {} : { earlierActive: earlierActive.length, earlierRunning }) };
 }
 function admittedOwner(store, taskId, owner, now, root) {
     if (owner.kind !== "coordinator")
@@ -445,6 +452,73 @@ export function checkAssignmentAsOperator(store, taskId, receiptDigest, who, now
         return acknowledgeCurrent(store, current, receiptDigest, `operator:${who.name}`, now, root, access);
     }));
 }
+/** The acceptance's own ledger act, as a separate Accept request records it. */
+export const ACCEPT_ACTION = "task accept-proof";
+/** Only a person's check stands between this result and done: its proof is short for that alone, and nobody accepted it. */
+export function personCheckPending(receipt) {
+    return receipt !== null && receipt.proofAcceptance === null && manualReviewOnly(receipt.proof === null ? null : { verdict: receipt.proof.verdict, reasons: receipt.proof.reasons, matrix: receipt.proof.matrix });
+}
+class Undone extends Error {
+    result;
+    constructor(result) {
+        super(result.message);
+        this.result = result;
+    }
+}
+/** An acceptance this receipt owes before it finishes: the person's own check (no reason needed), or an
+ * exception the proof needs and the person gave a reason for. Null when Accept and finish is a plain
+ * completion: nothing is owed, it was already accepted, or an exception came without its reason. */
+export function owedAcceptance(receipt, note) {
+    if (receipt === null || receipt.proofAcceptance !== null)
+        return null;
+    if (personCheckPending(receipt))
+        return "person-check";
+    return note !== null && receipt.proof?.verdict !== "verified" && receipt.proof?.verdict !== "attested" ? "exception" : null;
+}
+/** Accept and finish: the person's acceptance of the exact result they read and its completion, in one
+ * transaction. Whether an acceptance is owed is decided here, against the receipt as it stands: only a
+ * person's own check or a reasoned exception records one (with its ledger act); anything else is the plain
+ * completion Mark complete always was. The completion names the receipt the acceptance produced, under the
+ * same digest a separate Accept then Mark complete leave. `receiptDigest` is the receipt as read, before
+ * accepting (`runId`, when named, must be its run); any other change refuses both, and a refused completion
+ * keeps no acceptance. `finish` completes the receipt (Mark complete by default; Complete and open a pull
+ * request passes its own). */
+export function acceptAndCompleteAsOperator(store, taskId, input, who, now, root = evidenceRoot(homedir()), finish = digest => checkAssignmentAsOperator(store, taskId, digest, who, now, root)) {
+    try {
+        return withActor(currentActor() ?? { account: who.name, lead: false }, () => store.transact(() => {
+            if (!reproveApprover(store, who).ok)
+                return { ok: false, reason: "unauthenticated", message: "Sign in again before accepting this result." };
+            const access = { principal: "operator", repos: who.repos };
+            const before = assignmentOf(store, taskId, now, access, root);
+            if (before === null || !store.accountCanAccess(who.name, before.repo))
+                return { ok: false, reason: "not-found", message: "No assignment is available in your projects." };
+            const receipt = before.receipt;
+            if (receipt === null || (input.runId !== null && receipt.runId !== input.runId) || !/^[a-f0-9]{64}$/.test(input.receiptDigest) || receipt.digest !== input.receiptDigest) {
+                return { ok: false, reason: "stale", message: "This result changed. Open the current result before accepting it." };
+            }
+            // Already complete, or nothing owed: the plain completion of the receipt as read.
+            const owed = before.state === "ready-to-check" ? owedAcceptance(receipt, input.note) : null;
+            let digest = receipt.digest;
+            if (owed !== null) {
+                store.acceptProof(receipt.runId, who.name, input.note, now);
+                store.recordAction({ at: now.toISOString(), actor: who.name, repo: before.repo, taskId, runId: null, action: ACCEPT_ACTION, outcome: "accepted", source: "request" });
+                const accepted = assignmentOf(store, taskId, now, access, root)?.receipt ?? null;
+                if (accepted === null || accepted.runId !== receipt.runId)
+                    throw new Undone({ ok: false, reason: "stale", message: "This result changed. Open the current result before accepting it." });
+                digest = accepted.digest;
+            }
+            const done = finish(digest);
+            if (!done.ok)
+                throw new Undone(done);
+            return done;
+        }));
+    }
+    catch (error) {
+        if (error instanceof Undone)
+            return error.result;
+        throw error;
+    }
+}
 function noteAssignmentHandoff(store, assignment, now) {
     if (!assignment.owner?.active || assignment.handoff === null || assignment.handoff.acknowledged)
         return;