toolroll 0.9.55 → 0.9.57

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.9.57 — 2026-10-09
+
+- **Truthful status.** Finished tasks read Complete everywhere. With checks
+  off, criteria read "checked at release" instead of Needs you.
+- **No false finish.** Completing or deploying refuses a failed or missing
+  check, an unmet criterion, a serious review finding, or missing evidence.
+- **Clear revisions.** Revisions are named after their task: -v2, -v3.
+
+## 0.9.56 — 2026-10-09
+
+- **One lead.** Your assistant in the console, on your phone, in chat and in
+  the CLI is the same lead. Teammates are now its subagents, with their
+  personalities and rules: "ask Rosa to…", or from a flow step.
+- **Retiring soon.** The central team service and native coding sessions are
+  hidden and warn when used; they are removed next release.
+- **Fresh baseline.** New installs start from a baseline schema. Databases
+  older than 0.5.0 are asked to update through 0.9.x first.
+
 ## 0.9.55 — 2026-10-09
 
 - **One door per route.** Every page's access comes from one table with one

package/README.md

@@ -366,7 +366,7 @@ for people splitting those parts across machines.
 Specialized views remain in **Tools** and **Settings**: the activity ledger, the review cockpit,
 the fleet,
 people (invite a second approver), the operating mode (a signed, expiring
-envelope that pre-approves your own filings), and **chat** — the mate, one
+envelope that pre-approves your own filings), and **chat** — your lead, one
 conversation across every project, which only ever proposes.
 
 ### In the terminal
@@ -383,7 +383,7 @@ toolroll decide <id> --choose <option>      # answer a parked decision
 toolroll task show retries                  # attempts, outcome, where the branch is
 
 toolroll task add "Why does the login test flake?" --id flaky --report   # a scout
-toolroll chat --say "what is waiting on me across every project?"       # the mate
+toolroll chat --say "what is waiting on me across every project?"       # your lead
 ```
 
 Every command takes `--json` and answers with one envelope; every mutation
@@ -808,21 +808,37 @@ contents or command lines, with credential-shaped lines redacted at
 write. Digits focus one pane, `a` shows them all, `q` leaves. Outside a
 terminal, or with `--json`, it prints one snapshot and exits.
 
-## The mate, and the gateway
+## The lead, its subagents, and the gateway
 
-`/chat` in the console (or `toolroll chat` in the terminal) is one
-conversation across every project you serve. The mate reads the fleet
+`/chat` in the console (or `toolroll chat` in the terminal, or your chat app on
+the phone) is one conversation with your lead across every project you serve.
+The console, the terminal, Telegram, Slack, Discord and Teams all talk to the
+same lead with the same tools. The lead reads the fleet
 and **only proposes**: file a task (or a scout), move one to the front,
 reserve it for a worker, hold it, rewrite a scope, retry/replace/unlink a
 terminal dependency, guide a task's next attempt, cancel, or suggest an answer to a parked decision. Every
 proposal is a card you confirm, with
 every consequence and the builder's recommendation shown beside the
-mate's pick; a scope the mate wrote never seals under an operating mode.
+lead's pick; a scope the lead wrote never seals under an operating mode.
 Absolute paths, internal digests and account names are redacted; source context includes relative file citations. Direct API use spends
 against a ceiling you set per conversation. The console keeps a live pulse for every
 admitted project beside that shared thread, with one-click fleet questions
 and a direct road to each project's board.
 
+The lead has **subagents**: named helpers, each with its own personality,
+instructions and rules (what it does on its own, what it asks first, what it
+never does). Say "ask Maya to draft the refund reply" and the lead shows a card
+with exactly what goes to Maya; once you confirm, Maya works it within her rules
+and her answer comes back to you. A flow step can call a subagent by name too.
+They live in **Settings → Lead → Subagents** ([guide](docs/guide/subagents.md)).
+Subagents used to be called AI teammates; each carried over unchanged.
+
+The central team service (`toolroll connect`, the central `toolroll lead
+list|create|update|member|transfer`, `toolroll conversation …`, team chat) and
+native coding sessions (`toolroll session …`, the `/code` page) are deprecated:
+they still work for this release, hidden from help and the console, print one warning
+when used, and are removed in the next minor release.
+
 Every task has an **Overview / Ask** switch. **Ask** opens a focused companion
 to that task without creating another conversation: Toolroll attaches
 the current task to each new message, keeps the live status beside the thread,
@@ -831,7 +847,7 @@ result inspection. Proposed guidance is inert until you confirm its card, then i
 reaches the next attempt without interrupting work already running.
 
 New work starts the same way: describe the outcome once in ordinary language.
-The mate infers a concise title, narrow scope, safe non-goals, and proof
+The lead infers a concise title, narrow scope, safe non-goals, and proof
 criteria; it asks only when the project or outcome is genuinely ambiguous, or
 when an irreversible or compatibility tradeoff changes what should be built.
 Questions are grouped, carry a recommended default, and stop for reversible
@@ -985,7 +1001,7 @@ Everything below ships in 0.4.0:
   sessions, invites, and every mode they signed end together, while
   history stays attributed forever.
 - **Scout tasks** — `task add … --report` (or the "scout" checkbox, or
-  the mate's `propose_task` with `report: true`) files a task whose
+  the lead's `propose_task` with `report: true`) files a task whose
   deliverable is a report, never a branch: once its scope is approved,
   a read-only session investigates the goal as a question and hands
   back a title, a summary, a document, and up to five follow-ups, each

package/dist/action-ledger.d.ts

@@ -16,11 +16,9 @@ export type LedgerEntry = {
     /** v99: what changed, in a short line (a policy's "before → after"); never a secret, prompt or body. */
     detail: string | null;
 };
-/** The table as v54 made it: the one earlier shape the v99 rebuild accepts. */
-export declare const LEDGER_V54_TABLE: (name: string) => string;
-export declare const LEDGER_V54_COLUMNS: readonly ["id", "at", "actor", "repo", "task_id", "run_id", "action", "outcome", "source"];
-/** The table as v99 made it: the v110 rebuild accepts this shape and v54's. */
+/** The table as v99 made it (v107 has it): the one earlier shape the v110 rebuild accepts. */
 export declare const LEDGER_V99_TABLE: (name: string) => string;
+export declare const LEDGER_COLUMNS: readonly ["id", "at", "actor", "repo", "task_id", "run_id", "action", "outcome", "source", "detail"];
 export declare const LEDGER_TABLE: (name: string) => string;
 export declare const LEDGER_SCHEMA: string;
 /** Installed after all table migrations. Work events commit with the work,

package/dist/action-ledger.js

@@ -1,16 +1,7 @@
 /** v99: sign-ins (and refusals, lockouts, sign-outs) and policy changes are their own kinds of event.
  * v110: commands a person ran on this server with their API token, from the CLI ('api') or their agent ('mcp'). */
 export const LEDGER_SOURCES = ["work", "request", "access", "sign-in", "policy", "api", "mcp"];
-/** The table as v54 made it: the one earlier shape the v99 rebuild accepts. */
-export const LEDGER_V54_TABLE = (name) => `CREATE TABLE ${name} (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  at TEXT NOT NULL, actor TEXT NOT NULL, repo TEXT,
-  task_id TEXT, run_id INTEGER,
-  action TEXT NOT NULL, outcome TEXT NOT NULL,
-  source TEXT NOT NULL CHECK (source IN ('work','request','access'))
-)`;
-export const LEDGER_V54_COLUMNS = ["id", "at", "actor", "repo", "task_id", "run_id", "action", "outcome", "source"];
-/** The table as v99 made it: the v110 rebuild accepts this shape and v54's. */
+/** The table as v99 made it (v107 has it): the one earlier shape the v110 rebuild accepts. */
 export const LEDGER_V99_TABLE = (name) => `CREATE TABLE ${name} (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   at TEXT NOT NULL, actor TEXT NOT NULL, repo TEXT,
@@ -19,6 +10,7 @@ export const LEDGER_V99_TABLE = (name) => `CREATE TABLE ${name} (
   source TEXT NOT NULL CHECK (source IN ('work','request','access','sign-in','policy')),
   detail TEXT
 )`;
+export const LEDGER_COLUMNS = ["id", "at", "actor", "repo", "task_id", "run_id", "action", "outcome", "source", "detail"];
 export const LEDGER_TABLE = (name) => `CREATE TABLE ${name} (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   at TEXT NOT NULL, actor TEXT NOT NULL, repo TEXT,

package/dist/approval-policy.d.ts

@@ -5,21 +5,21 @@
  * - The person who filed a task can't approve it ("not the requester").
  * - Protected work (the whole project, or tasks that touch protected paths)
  *   needs two different people to approve the same exact scope, and an AI
- *   teammate or an operating mode can never decide it.
+ *   subagent or an operating mode can never decide it.
  *
  * The store enforces these at the one place every approval is sealed
  * (`Store.sealScopeApproval`); this module holds the pure parts.
  */
 /** Who filed a task, as far as anyone can tell: a person (browser, chat, a
  * revision), a coordinator acting for the person who made it, an AI
- * teammate, or automation that names no person (a schedule, the CLI, a flow
+ * subagent, or automation that names no person (a schedule, the CLI, a flow
  * with no owner). The requester rule binds only a named person. */
-export type FilerKind = "person" | "coordinator" | "teammate" | "automation";
+export type FilerKind = "person" | "coordinator" | "subagent" | "automation";
 export type Filer = {
     name: string | null;
     kind: FilerKind;
 };
-/** A filer from a name as the ledger writes it: an AI teammate's ends " (AI)"; a coordinator's starts "coordinator:"; none is automation. */
+/** A filer from a name as the ledger writes it: a subagent's ends " (AI)"; a coordinator's starts "coordinator:"; none is automation. */
 export declare function filerFor(name: string | null | undefined): Filer;
 export type ApprovalRules = {
     notRequester: boolean;
@@ -27,7 +27,7 @@ export type ApprovalRules = {
     protectedPaths: string[];
 };
 export declare const NO_RULES: ApprovalRules;
-/** Who is sealing: a person at a ceremony, an operating mode, an AI teammate, or automation. */
+/** Who is sealing: a person at a ceremony, an operating mode, a subagent, or automation. */
 export type ApproverKind = "person" | "mode" | "ai" | "automation";
 export type ApprovalGate = {
     verdict: "seal";

package/dist/approval-policy.js

@@ -5,17 +5,17 @@
  * - The person who filed a task can't approve it ("not the requester").
  * - Protected work (the whole project, or tasks that touch protected paths)
  *   needs two different people to approve the same exact scope, and an AI
- *   teammate or an operating mode can never decide it.
+ *   subagent or an operating mode can never decide it.
  *
  * The store enforces these at the one place every approval is sealed
  * (`Store.sealScopeApproval`); this module holds the pure parts.
  */
-/** A filer from a name as the ledger writes it: an AI teammate's ends " (AI)"; a coordinator's starts "coordinator:"; none is automation. */
+/** A filer from a name as the ledger writes it: a subagent's ends " (AI)"; a coordinator's starts "coordinator:"; none is automation. */
 export function filerFor(name) {
     if (name == null || name === "")
         return { name: null, kind: "automation" };
     if (name.endsWith(" (AI)"))
-        return { name, kind: "teammate" };
+        return { name, kind: "subagent" };
     if (name.startsWith("coordinator:"))
         return { name, kind: "coordinator" };
     return { name, kind: "person" };
@@ -133,5 +133,5 @@ export function gateWords(gate) {
             : `Your approval is recorded (${gate.have} of ${gate.need}). This work is protected, so a second person needs to approve it.`;
     return gate.reason === "requester"
         ? "You filed this task, and this project needs someone else to approve it."
-        : "This work is protected: a person has to approve it, not an operating mode, a schedule or an AI teammate.";
+        : "This work is protected: a person has to approve it, not an operating mode, a schedule or a subagent.";
 }

package/dist/approval-rules-ui.js

@@ -16,9 +16,9 @@ export function rulesSummary(rules) {
     if (rules.notRequester)
         parts.push("The person who filed a task can't approve it.");
     if (rules.protectProject)
-        parts.push("All work here is protected: two people approve it, never an AI teammate or an operating mode.");
+        parts.push("All work here is protected: two people approve it, never a subagent or an operating mode.");
     else if (rules.protectedPaths.length > 0)
-        parts.push(`Work touching ${rules.protectedPaths.join(", ")} is protected: two people approve it, never an AI teammate or an operating mode.`);
+        parts.push(`Work touching ${rules.protectedPaths.join(", ")} is protected: two people approve it, never a subagent or an operating mode.`);
     return parts.length === 0 ? "No approval rules: anyone who can approve on this project can approve its work, including their own." : parts.join(" ");
 }
 export function approvalRulesHtml(view, notice) {

package/dist/assignment-adapters.d.ts

@@ -109,6 +109,11 @@ export declare function assignmentForCoordinator(store: Store, token: string, op
                 deployment: {
                     status: "not-recorded";
                 };
+                readiness: {
+                    verdict: import("./proof.js").ProofVerdict | null;
+                    checksOff: boolean;
+                    blockers: import("./task-status.js").CompletionBlocker[];
+                } | null;
             };
         }[];
         nextCursor: number;

package/dist/assignment.d.ts

@@ -1,10 +1,12 @@
 import { type Store, type ProofVerdictRow, type ProofAcceptanceRow } from "./store.js";
 import { type WorkAction, type WorkSummaryAccess } from "./work-summary.js";
 import { type VerifiedApprover } from "./principal.js";
+import { type ProofVerdict } from "./proof.js";
 import { type CheckLevel } from "./check-levels.js";
 import { type BuildReviewView } from "./review-switch.js";
 import { type NeedKey, type WaitKey } from "./needs-you.js";
-import { type ChecksBatch } from "./task-status.js";
+import { type ChecksBatch, type CompletionBlocker } from "./task-status.js";
+import { type ReleaseCoverage, type ReleaseMemo } from "./release-coverage.js";
 import { type LeadClaim } from "./lead-voice.js";
 export type AssignmentAccess = WorkSummaryAccess;
 export type AssignmentOwner = {
@@ -24,6 +26,8 @@ export type AssignmentChecks = {
     running?: "quick" | "full" | null;
     /** A batch check (batch-checks.ts): waiting for its batch, or how it was checked. */
     batch?: ChecksBatch | null;
+    /** Checks Off: the passing full release check that contains this commit (release-coverage.ts), read now, never sealed. */
+    release?: ReleaseCoverage | null;
 };
 export type AssignmentReceipt = {
     digest: string;
@@ -118,6 +122,13 @@ export type AssignmentSnapshot = {
     earlierActive?: number;
     /** Of those, how many are running rather than only queued; present with earlierActive. */
     earlierRunning?: number;
+    /** The result as it reads today (task-status.ts): the verdict it shows, whether its checks were deliberately Off, and
+     * what refuses Complete. Derived at read time; never part of the sealed receipt. Null without a result. */
+    readiness?: {
+        verdict: ProofVerdict | null;
+        checksOff: boolean;
+        blockers: CompletionBlocker[];
+    } | null;
 };
 /** Status-first handoff for routine reads. Fetch get_assignment only when
  * inspecting its exact evidence; do not repeat a full proof in every poll. */
@@ -169,9 +180,14 @@ export declare function assignmentBrief(assignment: AssignmentSnapshot | null):
     deployment: {
         status: "not-recorded";
     };
+    readiness: {
+        verdict: ProofVerdict | null;
+        checksOff: boolean;
+        blockers: CompletionBlocker[];
+    } | null;
 } | null;
 export declare function assignmentChecksForRun(store: Store, root: string | undefined, runId: number, now: Date): AssignmentChecks;
-export declare function assignmentOf(store: Store, taskId: string, now: Date, access: AssignmentAccess, root?: string): AssignmentSnapshot | null;
+export declare function assignmentOf(store: Store, taskId: string, now: Date, access: AssignmentAccess, root?: string, memo?: ReleaseMemo): AssignmentSnapshot | null;
 type MutationResult = {
     ok: true;
     assignment: AssignmentSnapshot;
@@ -203,7 +219,7 @@ type Finished = {
  * (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;
+export declare function owedAcceptance(receipt: AssignmentReceipt | null, blockers?: readonly CompletionBlocker[]): "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
@@ -278,6 +294,11 @@ export declare function assignmentUpdates(store: Store, now: Date, access: Assig
             deployment: {
                 status: "not-recorded";
             };
+            readiness: {
+                verdict: ProofVerdict | null;
+                checksOff: boolean;
+                blockers: CompletionBlocker[];
+            } | null;
         };
     }[];
     nextCursor: number;

package/dist/assignment.js

@@ -14,13 +14,14 @@ 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 { manualReviewOnly, shownVerdictOf } from "./proof.js";
 import { ACCEPT_NEEDS_REASON, cantAcceptYetOf } from "./result-acts.js";
-import { runCheckLevel } from "./check-levels.js";
+import { requiredCheckCommandFor, runCheckLevel } from "./check-levels.js";
 import { followUpChecksOf, withFollowUps } from "./result-follow-ups.js";
 import { buildReviewOf, findingWords } from "./review-switch.js";
 import { NEEDS, WAITS, processNeedOf, resultHoldUpSentence } from "./needs-you.js";
-import { assignmentStageOf } from "./task-status.js";
+import { assignmentStageOf, checkBackingOf, completionBlockersOf, requirementWordOf } from "./task-status.js";
+import { releaseCoverageOf } from "./release-coverage.js";
 import { leadClaimOf } from "./lead-voice.js";
 /** Status-first handoff for routine reads. Fetch get_assignment only when
  * inspecting its exact evidence; do not repeat a full proof in every poll. */
@@ -35,7 +36,7 @@ export function assignmentBrief(assignment) {
             base: receipt.base, head: receipt.head, completionKind: receipt.completionKind,
             checks: receipt.checks, proofAcceptance: receipt.proofAcceptance, verdict: receipt.proof?.verdict ?? null,
             criteria: { passed: receipt.proof?.matrix.filter(row => row.state === "pass").length ?? 0, total: receipt.proof?.matrix.length ?? 0 }, evidence: receipt.evidence },
-        publication: assignment.publication, review: assignment.review, deployment: assignment.deployment };
+        publication: assignment.publication, review: assignment.review, deployment: assignment.deployment, readiness: assignment.readiness ?? null };
 }
 const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 /** A lookup added with lead-quiet, read safely: a deploy proves completion with this code over the INSTALLED runtime's
@@ -51,7 +52,7 @@ function olderStoreSafe(read, absent) {
     }
 }
 /** A check as the receipt digest seals it: presentation-only fields (check-levels.ts) left out. */
-const sealedChecks = ({ level: _level, running: _running, batch: _batch, ...proof }) => proof;
+const sealedChecks = ({ level: _level, running: _running, batch: _batch, release: _release, ...proof }) => proof;
 const OWNER_ACTION = "assignment claimed";
 const CHECK_ACTION = COMPLETION_ACTION;
 const actorOf = (owner) => `${owner.kind}:${owner.id}`;
@@ -127,7 +128,7 @@ function buildChecks(store, root, runId) {
         return unavailable("Saved checks could not be read.");
     }
 }
-export function assignmentOf(store, taskId, now, access, root) {
+export function assignmentOf(store, taskId, now, access, root, memo) {
     const family = store.taskFamilyOf(taskId, access.repos, access.principal === "operator" && access.includeUnplaced === true);
     if (family === null)
         return null;
@@ -163,7 +164,10 @@ export function assignmentOf(store, taskId, now, access, root) {
     const reports = artifacts.filter(a => a.kind === "report");
     const unavailable = family.versions.flatMap(version => store.runsFor(version.refId).flatMap(run => store.artifactsFor(run.id).filter(artifact => root === undefined || !readVerifiedArtifact(root, artifact).ok)
         .map(artifact => `Saved ${artifact.kind} #${artifact.id} (run ${run.id}) is unavailable or changed.`)));
-    const checks = result === null ? null : assignmentChecksForRun(store, root, result.id, now);
+    const ownChecks = result === null ? null : assignmentChecksForRun(store, root, result.id, now);
+    // Checks Off: a passing full release check that contains this commit covers it, read now from the existing receipts.
+    const checks = ownChecks === null || ownChecks.level !== "off" || ownChecks.status === "passed" || ownChecks.status === "failed" ? ownChecks
+        : { ...ownChecks, release: releaseCoverageOf(store, root, current.repo, result.headRevision, memo === undefined ? {} : { memo }) };
     const finishedBuild = result?.role === "builder" && (result.outcome === "built" || result.outcome === "no-change") &&
         result.finishedAt !== null && /^[a-f0-9]{40}$/.test(result.headRevision ?? "");
     // Finished work returns to its lead or user. Strict terms and previous model
@@ -339,6 +343,7 @@ export function assignmentOf(store, taskId, now, access, root) {
                     attention, receipt: receipt?.digest ?? null }), acknowledged: false } : null;
     const publication = result === null ? null : store.publicationForRun(result.id);
     const lead = state === "complete" || state === "cancelled" || access.principal !== "operator" ? null : leadClaimOf(store, family.root.id, now, access.viewer);
+    const readiness = receipt === null ? null : readinessOf(store, receipt, current.repo, review);
     // Existing saved inputs and output, read only after family admission. Keep
     // polling briefs small; full reads disclose exactly which excerpts are shortened.
     const planId = result?.planRevision == null ? null : store.getPlanRevision(result.planRevision)?.artifact;
@@ -355,7 +360,21 @@ 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 }), ...(earlierActive.length === 0 ? {} : { earlierActive: earlierActive.length, earlierRunning }) };
+        review, deployment: { status: "not-recorded" }, readiness, ...(need === null ? {} : { need }), ...(lead === null ? {} : { lead }), ...(earlierActive.length === 0 ? {} : { earlierActive: earlierActive.length, earlierRunning }) };
+}
+/** The result's shown verdict and completion blockers (task-status.ts), from the receipt, the project's approved check
+ * and the automatic review. A HIGH finding a revision already took is resolved there. */
+function readinessOf(store, receipt, repo, review) {
+    const report = receipt.completionKind === "research-report";
+    const high = review === null || review.sentBackAs !== null || review.state !== "reviewed" ? 0 : review.high.length;
+    const checkRequired = olderStoreSafe(() => requiredCheckCommandFor(store, repo, receipt.taskId, receipt.checks.level), null) !== null;
+    const matrix = receipt.proof?.matrix ?? [];
+    const backing = checkBackingOf(receipt.checks);
+    const verdict = shownVerdictOf(receipt.proof?.verdict ?? null, { checkFailed: !report && receipt.checks.status === "failed", highFindings: high,
+        reviewPending: review?.state === "pending", criteriaPassed: matrix.every(row => requirementWordOf(row, null, backing) === "Met") });
+    const blockers = completionBlockersOf({ report, checks: receipt.checks, checkRequired, matrix, verdict: receipt.proof?.verdict ?? null,
+        accepted: receipt.proofAcceptance !== null, high });
+    return { verdict, checksOff: !report && receipt.checks.level === "off", blockers };
 }
 function admittedOwner(store, taskId, owner, now, root) {
     if (owner.kind !== "coordinator")
@@ -417,6 +436,10 @@ function acknowledgeCurrent(store, current, receiptDigest, actor, now, root, acc
     if (current.state !== "ready-to-check" && current.state !== "complete")
         return { ok: false, reason: "not-ready", message: "This assignment still has unresolved execution, scope or decisions." };
     if (current.state !== "complete") {
+        // The one readiness guard: a failed or missing required check, an unresolved requirement or HIGH finding refuses.
+        const blockers = current.readiness?.blockers ?? [];
+        if (blockers.length > 0)
+            return { ok: false, reason: "not-ready", message: blockers.map(one => one.message).join(" ") };
         // v102: declared paths are only a promise. A result whose actual diff reaches protected files, on a
         // scope one person approved, completes only by someone else — two people have then seen the work.
         const problem = store.protectedResultProblem(receipt.taskId, familyChangedFiles(store, receipt.taskId, receipt.runId, root), actor.startsWith("operator:") ? actor.slice("operator:".length) : null);
@@ -476,11 +499,14 @@ class Undone extends Error {
  * (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) {
+export function owedAcceptance(receipt, blockers = []) {
     if (receipt === null || receipt.proofAcceptance !== null)
         return null;
     if (personCheckPending(receipt))
         return "person-check";
+    // An unresolved requirement is resolved only by an acceptance that says why.
+    if (blockers.some(one => one.key === "criteria"))
+        return "exception";
     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
@@ -505,7 +531,7 @@ export function acceptAndCompleteAsOperator(store, taskId, input, who, now, root
                 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;
+            const owed = before.state === "ready-to-check" ? owedAcceptance(receipt, before.readiness?.blockers ?? []) : 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}.` };