toolroll 0.9.14 → 0.9.16

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 0.9.16 — 2026-10-03
+
+- **Name your lead.** Settings → Lead takes a name and a short persona. The
+  lead uses them wherever it speaks.
+- **The lead knows who it's talking to.** Every turn it sees your first name,
+  today's date, the channel it's on, what needs you, and your projects by name
+  with their decisions.
+- **It checks before it speaks.** It says what it checked and marks guesses.
+  It searches project memory before recommending anything, and it checks an
+  integration before promising work that needs it.
+- **Questions with buttons.** When it needs an answer, it asks one question
+  with tap-to-answer options in the console, Telegram, Slack, Discord and
+  Teams.
+- **It keeps its promises.** "I'll tell you when the checks pass" is recorded
+  and reported once, on the chat where you asked. Corrections become a card
+  you confirm, and it remembers them from the next reply.
+- Accepting a result that doesn't match its report needs a reason, enforced by
+  the server. Every time on a page shows in your time zone.
+
+## 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

package/dist/assignment-brief.d.ts

@@ -53,6 +53,7 @@ export type AssignmentCatchUp = {
             decisions: {
                 id: number;
                 claim: string;
+                why: string;
             }[];
         };
     }[];
@@ -65,6 +66,15 @@ export type AssignmentCatchUp = {
         notes: string[];
     };
 };
+/** A reason's first sentence, or its first line. */
+export declare function firstSentenceOf(text: string): string;
+/** A project's active decisions, newest first: each one's title and its reason in one line (first sentence or
+ * line). Memory absent on an older database reads as no decisions. */
+export declare function activeDecisionsOf(store: Store, repo: string, text?: (value: string, cap: number) => string): {
+    id: number;
+    claim: string;
+    why: string;
+}[];
 /** A current snapshot, never a receipt to acknowledge. Full assignment reads
  * remain the place to inspect exact saved work and obtain its current digest. */
 export declare function assignmentCatchUp(store: Store, now: Date, access: AssignmentAccess, query?: {

package/dist/assignment-brief.js

@@ -7,6 +7,26 @@ import { publicChatText } from "./chat-display.js";
 const sha = (value) => createHash("sha256").update(value).digest("hex");
 const MAX_BYTES = 16_000;
 const RECENT_MS = 7 * 24 * 60 * 60_000;
+/** A sentence's end: not an abbreviation's full stop ("e.g.", "i.e.", "etc."), and followed by a new sentence. */
+const SENTENCE_END = /(?<!\b(?:e\.g|i\.e|etc|vs|cf|approx|incl|Mr|Mrs|Ms|Dr|St|No))[.!?](?=\s+["'“(]?[\p{Lu}\p{N}])/u;
+/** A reason's first sentence, or its first line. */
+export function firstSentenceOf(text) {
+    const line = text.split("\n")[0].trim();
+    const end = SENTENCE_END.exec(line);
+    return end === null ? line : line.slice(0, end.index + 1);
+}
+/** A project's active decisions, newest first: each one's title and its reason in one line (first sentence or
+ * line). Memory absent on an older database reads as no decisions. */
+export function activeDecisionsOf(store, repo, text = publicChatText) {
+    try {
+        return store.handle.prepare("SELECT id,claim,why FROM project_decision WHERE repo=? AND status='active' ORDER BY id DESC LIMIT 8").all(repo).map(row => ({
+            id: Number(row["id"]), claim: text(String(row["claim"]), 160), why: text(firstSentenceOf(String(row["why"])), 160)
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 /** A current snapshot, never a receipt to acknowledge. Full assignment reads
  * remain the place to inspect exact saved work and obtain its current digest. */
 export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot) {
@@ -26,7 +46,7 @@ export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot)
         return result;
     const repos = query.repo === undefined ? access.repos : [query.repo];
     const includeUnplaced = query.repo === undefined && access.principal === "operator" && access.includeUnplaced === true;
-    const scopedAccess = access.principal === "operator" ? { principal: "operator", repos, includeUnplaced } : { principal: "coordinator", repos: repos ?? [] };
+    const scopedAccess = access.principal === "operator" ? { principal: "operator", repos, includeUnplaced, ...(access.viewer == null ? {} : { viewer: access.viewer }) } : { principal: "coordinator", repos: repos ?? [] };
     const text = (value, cap) => {
         const rendered = publicChatText(value, cap);
         if (rendered !== value)
@@ -86,37 +106,40 @@ export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot)
                 result.omissions.decisions += Math.max(0, count - decisions.length);
         }
         // Project knowledge is admitted in SQL before any payload or title read.
-        const projectRows = store.handle.prepare(`SELECT repo FROM project_knowledge WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?)) ORDER BY repo LIMIT 9`)
+        // A project with settled decisions but no saved instructions yet still has knowledge to bring.
+        const known = store.handle.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='project_decision'").get() === undefined ? "SELECT repo FROM project_knowledge"
+            : "SELECT repo FROM project_knowledge UNION SELECT repo FROM project_decision WHERE status='active'";
+        const projectRows = store.handle.prepare(`SELECT repo FROM (${known}) WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?)) ORDER BY repo LIMIT 9`)
             .all(repos === null ? 1 : 0, JSON.stringify(repos ?? []));
-        const projectCount = Number(store.handle.prepare('SELECT COUNT(*) AS n FROM project_knowledge WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?))').get(repos === null ? 1 : 0, JSON.stringify(repos ?? []))?.["n"] ?? 0);
+        const projectCount = Number(store.handle.prepare(`SELECT COUNT(*) AS n FROM (${known}) WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?))`).get(repos === null ? 1 : 0, JSON.stringify(repos ?? []))?.["n"] ?? 0);
         result.omissions.projects = Math.max(0, projectCount - 8);
         for (const project of projectRows.slice(0, 8)) {
             const repo = String(project["repo"]);
             const knowledge = { status: "unavailable", revision: null, identity: null, sha256: null, instructions: "", sources: [], decisions: [] };
             const row = store.handle.prepare('SELECT * FROM project_knowledge WHERE repo=?').get(repo);
-            try {
-                const payload = String(row["payload"]), revision = Number(row["revision"]), identity = String(row["identity"]);
-                const history = store.handle.prepare('SELECT sha FROM knowledge_change WHERE repo=? AND identity=? AND revision=?').get(repo, identity, revision);
-                if (Buffer.byteLength(payload) > 160_000 || !Number.isSafeInteger(revision) || revision < 1 || sha(payload) !== row["sha"] || history?.["sha"] !== row["sha"])
-                    throw Error("invalid stored context");
-                const saved = JSON.parse(payload);
-                if (typeof saved.instructions !== "string" || !Array.isArray(saved.references) || saved.references.length > 12)
-                    throw Error("invalid stored context");
-                const sources = saved.references.map((one) => {
-                    if (typeof one.id !== "string" || typeof one.title !== "string" || typeof one.content !== "string")
-                        throw Error("invalid stored source");
-                    const id = text(one.id, 80), path = typeof one.path === "string" ? text(one.path, 160) : null;
-                    return { id, title: text(one.title, 120), kind: path === null ? "saved-note" : "repository-document", path,
-                        sourceRevision: typeof one.sourceRevision === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceRevision) ? one.sourceRevision : null,
-                        sourceSha: typeof one.sourceSha === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceSha) ? one.sourceSha : null };
-                });
-                Object.assign(knowledge, { status: "stored", revision, identity: /^[a-f0-9]{64}$/.test(identity) ? identity : null, sha256: String(row["sha"]), instructions: text(saved.instructions, 600), sources });
-            }
-            catch { /* Integrity failures are explicit; never replay an older version as current. */ }
-            try {
-                knowledge.decisions = store.handle.prepare("SELECT id,claim FROM project_decision WHERE repo=? AND status='active' ORDER BY id DESC LIMIT 8").all(repo).map(row => ({ id: Number(row["id"]), claim: text(String(row["claim"]), 160) }));
-            }
-            catch { /* memory absent on an older database reads as no decisions */ }
+            if (row === undefined)
+                knowledge.status = "none";
+            else
+                try {
+                    const payload = String(row["payload"]), revision = Number(row["revision"]), identity = String(row["identity"]);
+                    const history = store.handle.prepare('SELECT sha FROM knowledge_change WHERE repo=? AND identity=? AND revision=?').get(repo, identity, revision);
+                    if (Buffer.byteLength(payload) > 160_000 || !Number.isSafeInteger(revision) || revision < 1 || sha(payload) !== row["sha"] || history?.["sha"] !== row["sha"])
+                        throw Error("invalid stored context");
+                    const saved = JSON.parse(payload);
+                    if (typeof saved.instructions !== "string" || !Array.isArray(saved.references) || saved.references.length > 12)
+                        throw Error("invalid stored context");
+                    const sources = saved.references.map((one) => {
+                        if (typeof one.id !== "string" || typeof one.title !== "string" || typeof one.content !== "string")
+                            throw Error("invalid stored source");
+                        const id = text(one.id, 80), path = typeof one.path === "string" ? text(one.path, 160) : null;
+                        return { id, title: text(one.title, 120), kind: path === null ? "saved-note" : "repository-document", path,
+                            sourceRevision: typeof one.sourceRevision === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceRevision) ? one.sourceRevision : null,
+                            sourceSha: typeof one.sourceSha === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceSha) ? one.sourceSha : null };
+                    });
+                    Object.assign(knowledge, { status: "stored", revision, identity: /^[a-f0-9]{64}$/.test(identity) ? identity : null, sha256: String(row["sha"]), instructions: text(saved.instructions, 600), sources });
+                }
+                catch { /* Integrity failures are explicit; never replay an older version as current. */ }
+            knowledge.decisions = activeDecisionsOf(store, repo, text);
             result.projects.push({ repo, knowledge });
             if (!fits()) {
                 result.projects.pop();

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

@@ -72,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);
@@ -100,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

@@ -109,8 +109,12 @@ export type AssignmentSnapshot = {
         wait: WaitKey;
         build: number | null;
     } | null;
-    /** The person's lead took it on (lead-voice.ts): "Your lead is on it" until done, handed on, or two quiet hours. */
+    /** The person's lead took it on (lead-voice.ts): "<name> 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,35 @@ 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, by the result page's own rule: the person's own check
+ * (no reason needed), or an exception a report that doesn't match its changes needs a reason for. Null when
+ * Accept and finish is a plain completion: nothing is owed (no proof, a failed check, or a verified result),
+ * or it was already accepted. */
+export declare function owedAcceptance(receipt: AssignmentReceipt | 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); an exception without its
+ * reason is refused; 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,12 @@ 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 { ACCEPT_NEEDS_REASON, cantAcceptYetOf } from "./result-acts.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 +142,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 +250,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 +273,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 +349,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 +453,77 @@ 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, by the result page's own rule: the person's own check
+ * (no reason needed), or an exception a report that doesn't match its changes needs a reason for. Null when
+ * Accept and finish is a plain completion: nothing is owed (no proof, a failed check, or a verified result),
+ * or it was already accepted. */
+export function owedAcceptance(receipt) {
+    if (receipt === null || receipt.proofAcceptance !== null)
+        return null;
+    if (personCheckPending(receipt))
+        return "person-check";
+    return cantAcceptYetOf(receipt.proof?.verdict ?? null, receipt.proof?.reasons ?? [], false) === ACCEPT_NEEDS_REASON ? "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); an exception without its
+ * reason is refused; 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) : null;
+            // An exception is accepted only with its reason: never a completion that skips it.
+            if (owed === "exception" && input.note === null)
+                return { ok: false, reason: "needs-reason", message: `${ACCEPT_NEEDS_REASON}.` };
+            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;