toolroll 0.9.56 → 0.9.57

package/dist/server/render-results.d.ts

@@ -12,7 +12,7 @@ import { type BuildReviewView } from "../review-switch.js";
 import { type AcceptanceCriterion, type approvalOf } from "../scope.js";
 import { type ReportItem } from "../scout-report.js";
 import { type Artifact, type DiffComment, type Publication, type RepairChainRow, type ReviewRetryState, type Run, type Store, type TaskState } from "../store.js";
-import { type PullRequestFact, type TaskStatus } from "../task-status.js";
+import { type ReleaseState, type PullRequestFact, type TaskStatus } from "../task-status.js";
 import { type DisplayStatus, type PublicationFacts, type ReviewFacts } from "../workspace-ui.js";
 import { type Chrome, type Screen } from "./chrome.js";
 import { type Html } from "../html.js";
@@ -78,6 +78,7 @@ export declare function criterionMatrixHtml(matrix: readonly CriterionMatrixRow[
     links?: EvidenceLinkMap;
     fileAnchors?: ReadonlyMap<string, string>;
     verdict?: string | null;
+    release?: ReleaseState | undefined;
 }): Html;
 /** One policy summary beneath the requirements. Per-requirement concerns
  * are already visible in the matrix; do not repeat their full text here. */
@@ -674,6 +675,8 @@ export declare const CHECK_EXCERPT_LINES = 12;
  * change's first file, labelled as not cited), the screenshots it cites
  * (none cited: every validated one), and the agent's own note. */
 export declare function personCheckItems(proof: ProofBundleView, patchText: string | null, shots: readonly ResultScreenshot[], runId: number): BrowserCheckItem[];
+/** The completion blocker no acceptance resolves (a failed check, an unresolved HIGH finding), in words, or null. */
+export declare function hardBlockerOf(assignment: AssignmentSnapshot | null | undefined): string | null;
 /** A Needs you result's one action (needs-you.ts): a link to the act that resolves it, or Confirm it
  * stopped behind the password. Null under every other headline. */
 export declare function needActionOf(assignment: AssignmentSnapshot | null, status: TaskStatus | null, csrf: string, returnTo: string, result?: {

package/dist/server/render-results.js

@@ -21,7 +21,7 @@ import {} from "../scope.js";
 import { parseReport } from "../scout-report.js";
 import {} from "../store.js";
 import { runCostWords } from "../summary.js";
-import { demoChecksOf, pullRequestFactOf, requirementsOf, requirementWordOf, STATUS_MORE, statusDetailsHtml, statusIconSvg, statusWhyHtml } from "../task-status.js";
+import { checkBackingOf, CHECKED_AT_RELEASE, demoChecksOf, pullRequestFactOf, requirementsOf, requirementWordOf, STATUS_MORE, statusDetailsHtml, statusIconSvg, statusWhyHtml } from "../task-status.js";
 import { ACCEPT_NEEDS_REASON, acceptWordsOf, cantAcceptYetOf, evidenceProblemOf, MISMATCH_HEADLINE, receiptHeadingOf, receiptPublicationWords, reportMismatchesOf, RESULT_DECISION_SENTENCE, resultHeadlineOf, resultStatusOf, REVIEW_TOKENS } from "../workspace-ui.js";
 import { createHash, randomBytes } from "node:crypto";
 import { buildsViews, oneLineOf, projectChip, safePrUrl, screen, sentenceCase, strokeIcon, when, whenTime } from "./chrome.js";
@@ -173,13 +173,14 @@ export function criterionMatrixHtml(matrix, options = {}) {
         const confirmed = row.assessment !== undefined && state === "pass";
         // Plain words (task-status brief): the retired assessment step is not a state a person acts on.
         // The card's Requirements row reads the same words from the same source (task-status.ts), so they agree.
-        const label = requirementWordOf(row, options.verdict);
+        const label = requirementWordOf(row, options.verdict, options.release);
         const cls = label === "Met" ? "badge-done" : label === "You check" ? "badge-manual-review" : "badge-note";
         const warnings = [];
         // Only replace the known boilerplate. Other recorded failure details
         // remain verbatim, so concision cannot hide a different problem.
         const detail = row.detail.filter(line => !(row.assessment && row.review && line === `${row.review.author} ${row.review.judgement === "contradicts" ? "contradicts" : "needs more evidence for"} criterion "${row.id}": ${row.review.note}`) && !(state === "manual-review" && /^criterion "[^"\n]+" requires manual-review evidence — an operator must accept it before this can verify$/.test(line)));
-        if (!awaitingAssessment && state !== "pass" && detail.length > 0)
+        // A requirement a release check covers, or that waits only on one, has nothing wrong to say.
+        if (!awaitingAssessment && state !== "pass" && label !== "Met" && label !== CHECKED_AT_RELEASE && detail.length > 0)
             warnings.push(html `<ul class="requirement-issues">${detail.map(line => html `<li>${line}</li>`)}</ul>`);
         const review = row.review;
         if (review !== null && review.judgement !== "upholds") {
@@ -671,13 +672,16 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         action: false,
     });
     parts.push(html `<div id="verification" data-cockpit-section="result">${panel.html}</div>`);
-    const blocked = cantAcceptYetOf(proof?.verdict ?? null, proof?.reasons ?? [], accepted);
+    // What no acceptance resolves (a failed check, a HIGH finding): Complete is refused, so no Accept is offered and
+    // the one line says the next step.
+    const hardStop = hardBlockerOf(assignment);
+    const blocked = hardStop ?? cantAcceptYetOf(proof?.verdict ?? null, proof?.reasons ?? [], accepted);
     const youCheck = panel.panel.youCheck;
     // Accept and finish posts the completion; when an acceptance is owed (the person's own checks, or a reason a
     // report that doesn't match its changes asks for), the same request records it first.
     const owed = accepted ? null : youCheck?.accept != null ? { note: null } : panel.panel.need?.accept != null ? { note: panel.panel.need.accept.note }
         : blocked === ACCEPT_NEEDS_REASON ? { note: "Why is this safe to accept?" } : null;
-    const complete = assignment?.state === "ready-to-check" && assignment.receipt !== null && canRetryReview && csrf !== ""
+    const complete = hardStop === null && assignment?.state === "ready-to-check" && assignment.receipt !== null && canRetryReview && csrf !== ""
         ? { action: `${taskHref(view.taskId)}/complete`, receipt: assignment.receipt.digest, run: run.id, accept: owed } : null;
     if (complete !== null)
         parts.push(completionForm(view.taskId, run.id, complete.receipt, view.detail?.pullRequestTo ?? null, owed));
@@ -686,8 +690,10 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
     const matrix = proof === null || proof.proofProblem !== null ? [] : proof.matrix;
     const unanswered = accepted || youCheck == null ? [] : youCheck.items.length > 0 ? youCheck.items.map(one => one.statement === "" ? one.words : one.statement) : youCheck.lines;
     const base = !acceptsHere ? null : acceptWordsOf({
-        checks: checks === undefined ? null : checks.running != null ? "running" : checks.level === "off" && checks.status !== "passed" ? "off" : checks.status,
-        unmet: matrix.filter(row => row.state !== "pass" && row.state !== "manual-review").length,
+        // Checks Off that a release check already covers read as passed (release-coverage.ts).
+        checks: checks === undefined ? null : checks.running != null ? "running" : checks.level === "off" && checks.status !== "passed" ? checks.release != null ? "passed" : "off" : checks.status,
+        // Release-aware words (task-status.ts): a requirement waiting only on a release check, or covered by one, isn't unmet.
+        unmet: matrix.filter(row => !["Met", "You check", CHECKED_AT_RELEASE].includes(requirementWordOf(row, null, checks === undefined ? undefined : checkBackingOf(checks)))).length,
         action: complete !== null ? "complete" : "accept",
         publishing: view.detail?.publishing ?? "other",
         proof: proof !== null && proof.proof !== null && proof.proofProblem === null,
@@ -700,7 +706,7 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
     const followUps = view.detail.followUps ?? null;
     const checksRunning = checks?.running != null || (followUps?.checks.some(one => one.state === "waiting" || one.state === "running") ?? false);
     const runChecks = canRetryReview && csrf !== "" && followUps !== null && (followUps.full || followUps.quick) && !checksRunning &&
-        (checks === undefined || checks.status === "not-run" || checks.status === "unavailable")
+        (checks === undefined || ((checks.status === "not-run" || checks.status === "unavailable") && checks.release == null))
         // Back on this result's Checks tab, where #follow-ups shows the run it started.
         ? { action: `/r/${run.id}/checks`, level: followUps.full ? "full" : "quick", returnTo: `${here}&run=${run.id}&tab=checks` } : null;
     const need = panel.panel.need;
@@ -1774,7 +1780,8 @@ export function resultPanelParts(detail, o) {
             checkParts.push(detail.signedCriteria > 0 ? html `<p class="meta">The approved scope has ${detail.signedCriteria} requirement${detail.signedCriteria === 1 ? "" : "s"}, but this build has no requirement-by-requirement verification.</p>` : html `<p class="meta">This scope signed no acceptance checks.</p>`);
         }
         else {
-            checkParts.push(criterionMatrixHtml(proof.matrix, { runId, links: proof.matrixLinks, fileAnchors: detail.fileAnchors, verdict: proof.verdict }));
+            checkParts.push(criterionMatrixHtml(proof.matrix, { runId, links: proof.matrixLinks, fileAnchors: detail.fileAnchors, verdict: proof.verdict,
+                release: current?.receipt == null ? undefined : checkBackingOf(current.receipt.checks) }));
         }
         checkParts.push(semanticCoverageHtml(proof.matrix, proof.qualityMode));
         if (reviewConflict(proof.matrix, proof.machineVerdict, proof.verdict))
@@ -1930,11 +1937,18 @@ export function personCheckItems(proof, patchText, shots, runId) {
         };
     });
 }
+/** The completion blocker no acceptance resolves (a failed check, an unresolved HIGH finding), in words, or null. */
+export function hardBlockerOf(assignment) {
+    return assignment?.readiness?.blockers.find(one => one.key === "check-failed" || one.key === "high")?.message ?? null;
+}
 /** A Needs you result's one action (needs-you.ts): a link to the act that resolves it, or Confirm it
  * stopped behind the password. Null under every other headline. */
 export function needActionOf(assignment, status, csrf, returnTo, result) {
     if (assignment === null || status === null || status.headline !== "Needs you" || status.need == null)
         return null;
+    // Accepting can't resolve it: Request changes is the way on, beside the reason.
+    if (result !== undefined && hardBlockerOf(assignment) !== null)
+        return null;
     const action = assignment.primaryAction;
     const rebuild = { href: null, confirm: null, rebuild: { action: `${taskHref(assignment.rootId)}/requeue` } };
     // Built to an earlier plan: Build again, in place (the task page's requeue).

package/dist/server/tasks.js

@@ -165,8 +165,8 @@ export function createTasksHandlers(runtime) {
             // Console v2: results ready to review and work running now, from the same admitted work index.
             ...(() => {
                 const row = (one) => ({ taskId: one.rootId, title: one.title, detail: one.status.detail, repo: one.repo });
-                const needsYou = workIndexPage(store, now, workAccess(), { view: "needs-you", limit: 40, project });
-                const runningNow = workIndexPage(store, now, workAccess(), { view: "running", limit: 40, project });
+                const needsYou = workIndexPage(store, now, workAccess(), { view: "needs-you", limit: 40, project, root: evidenceRoot });
+                const runningNow = workIndexPage(store, now, workAccess(), { view: "running", limit: 40, project, root: evidenceRoot });
                 return { ready: needsYou.items.filter(one => one.assignmentState === "ready-to-check").map(row), running: runningNow.items.map(row) };
             })(),
         };
@@ -195,7 +195,7 @@ export function createTasksHandlers(runtime) {
         const rollup = project === null && !unscopedMode;
         let work;
         try {
-            work = workIndexPage(store, now, workAccess(), { view, limit: 40, cursor: url.searchParams.get('cursor'), project });
+            work = workIndexPage(store, now, workAccess(), { view, limit: 40, cursor: url.searchParams.get('cursor'), project, root: evidenceRoot });
             const facts = requestContext.getStore();
             if (facts !== undefined) {
                 // These counts cover the exact admitted project lens, including
@@ -1382,7 +1382,7 @@ export function createTasksHandlers(runtime) {
         // CI repair, suggestion-first (M8.18): a red episode never spawns an
         // agent by itself — it EARNS a button, and the button creates one
         // unapproved task through the same revision machinery as review
-        // comments. Deterministic id = one draft per task/PR, ever.
+        // comments. One draft per task/PR, ever: the merge blocker records it.
         const id = Number(draftRepair[1]);
         const found = store.getRun(id);
         if (found === null || !visible(taskRepoOf(found.taskRef))) {
@@ -1401,10 +1401,6 @@ export function createTasksHandlers(runtime) {
         // failure was SEEN on and when (audit C-2) — a PR that advanced since
         // is a different failure, and the click time is not an observation.
         const episode = store.latestOpenCiEpisode(publication.githubRepo, publication.prNumber);
-        // Suffixes survive truncation (audit C-7): the prefix gives way, the
-        // identity-bearing tail never does.
-        const suffix = `-ci-${publication.prNumber}`;
-        const draftId = `${sourceTaskId.slice(0, 64 - suffix.length)}${suffix}`;
         const brief = {
             schema: 1,
             kind: "ci-repair",
@@ -1425,25 +1421,32 @@ export function createTasksHandlers(runtime) {
         // repair use (contract handoff task 2): the inherited terms come from
         // the source rows inside the seal; the scope read above only names
         // the digest this draft was composed against.
-        const sealed = store.sealRevision({
-            source: { task: sourceTaskId, run: id, scopeDigest: sourceScope?.digest ?? null },
-            brief: { evidenceRoot, key, sha256: createHash("sha256").update(briefBytes).digest("hex"), bytes: briefBytes.length, capture: "machine-authored ci-repair brief (exit 0)" },
-            child: {
-                id: draftId,
-                title: `repair ${sourceTaskId}: CI failing on PR #${publication.prNumber}`,
-                repair: `repair the failing CI on PR #${publication.prNumber} (failing head ${(episode?.headSha ?? publication.headSha).slice(0, 12)}). ` +
-                    `Read the failing checks on GitHub before approving; this draft carries no log content.`,
-            },
-            commentIds: null,
-            requestedBy: who.name,
-        }, now);
+        // One draft per task/PR, ever: the PR's merge blocker names it, lifted or not, and is written in the seal's transaction.
+        const sealed = store.transact(() => {
+            const prior = store.raw().prepare("SELECT task_id FROM merge_blocker WHERE publication = ? AND task_id IS NOT NULL ORDER BY rowid LIMIT 1").get(publication.id);
+            if (prior !== undefined)
+                return { ok: false, reason: "duplicate", detail: String(prior["task_id"]) };
+            const result = store.sealRevision({
+                source: { task: sourceTaskId, run: id, scopeDigest: sourceScope?.digest ?? null },
+                brief: { evidenceRoot, key, sha256: createHash("sha256").update(briefBytes).digest("hex"), bytes: briefBytes.length, capture: "machine-authored ci-repair brief (exit 0)" },
+                child: {
+                    title: `repair ${sourceTaskId}: CI failing on PR #${publication.prNumber}`,
+                    repair: `repair the failing CI on PR #${publication.prNumber} (failing head ${(episode?.headSha ?? publication.headSha).slice(0, 12)}). ` +
+                        `Read the failing checks on GitHub before approving; this draft carries no log content.`,
+                },
+                commentIds: null,
+                requestedBy: who.name,
+            }, now);
+            // The merge blocker rides the SAME breath as the draft (merge grant,
+            // findings 3/12/13): while this repair exists, the source PR merges
+            // NOTHING — sticky until the operator's unblock act or the PR closes.
+            if (result.ok)
+                store.createMergeBlocker(publication.id, result.id, now);
+            return result;
+        });
         if (!sealed.ok) {
-            return refuse(response, who, sealed.reason === "duplicate" ? 409 : sealed.reason === "stale-source" || sealed.reason === "comments-taken" ? 409 : 400, sealed.reason === "duplicate" ? `already drafted as ${draftId}` : `could not draft: ${sealed.detail}`, `/r/${id}`);
+            return refuse(response, who, sealed.reason === "duplicate" ? 409 : sealed.reason === "stale-source" || sealed.reason === "comments-taken" ? 409 : 400, sealed.reason === "duplicate" ? `already drafted as ${sealed.detail}` : `could not draft: ${sealed.detail}`, `/r/${id}`);
         }
-        // The merge blocker rides the SAME breath as the draft (merge grant,
-        // findings 3/12/13): while this repair exists, the source PR merges
-        // NOTHING — sticky until the operator's unblock act or the PR closes.
-        store.createMergeBlocker(publication.id, sealed.id, now);
         return redirect(response, taskHref(sealed.id));
     }
     async function resolveIncident(ctx) {

package/dist/store.d.ts

@@ -3018,7 +3018,7 @@ export declare class Store {
      * transaction can never commit half a seal). A brief FILE whose seal
      * failed is an orphan on disk, not authority — no artifact row points at
      * it. Two concurrent seals race on the comment consumption count, the
-     * deterministic child id, or the repair chain's `source_run UNIQUE`, and
+     * family's next version id, or the repair chain's `source_run UNIQUE`, and
      * exactly one wins; the loser refuses in words with zero rows.
      *
      * The child is filed UNAPPROVED, always: this method never stamps an
@@ -3044,10 +3044,9 @@ export declare class Store {
             bytes: number;
             capture: string;
         };
-        /** The child's own words: an optional deterministic id, its title,
-         * and the explicitly described repair appended to the SOURCE goal. */
+        /** The child's own words: its title and the explicitly described repair
+         * appended to the SOURCE goal. Its id is the family's next version. */
         child: {
-            id?: string;
             title: string;
             repair: string;
         };
@@ -3169,7 +3168,6 @@ export declare class Store {
             capture: string;
         };
         child: {
-            id: string;
             title: string;
             repair: string;
         };

package/dist/store.js

@@ -8756,7 +8756,7 @@ export class Store {
      * transaction can never commit half a seal). A brief FILE whose seal
      * failed is an orphan on disk, not authority — no artifact row points at
      * it. Two concurrent seals race on the comment consumption count, the
-     * deterministic child id, or the repair chain's `source_run UNIQUE`, and
+     * family's next version id, or the repair chain's `source_run UNIQUE`, and
      * exactly one wins; the loser refuses in words with zero rows.
      *
      * The child is filed UNAPPROVED, always: this method never stamps an
@@ -8848,8 +8848,9 @@ export class Store {
                 const badText = validateTaskText({ title: args.child.title, goal: args.child.repair });
                 if (badText !== null)
                     return refuse(badText.reason, badText.message);
+                // Every road names its child the same way: the family root and the next version, `<root>-v2`, `-v3`.
                 const made = this.#insertConsoleTask({
-                    ...(args.child.id === undefined ? {} : { id: args.child.id }),
+                    id: this.#nextRevisionId(ancestry.chain.at(-1) ?? args.source.task),
                     title: args.child.title,
                     ...(sourceRef.repo === null ? {} : { repo: sourceRef.repo }),
                     goal,
@@ -8926,6 +8927,20 @@ export class Store {
         }
         return { chain, problem: null };
     }
+    /** The next free `<root>-vN` id inside the caller's transaction: N counts the family's versions (the root is v1),
+     * skipping any id already taken. The suffix survives truncation to the 64-character id bound. */
+    #nextRevisionId(root) {
+        const family = this.db.prepare(`WITH RECURSIVE fam(id, depth) AS (
+        SELECT external_id, 0 FROM task_ref WHERE backend = ? AND external_id = ?
+        UNION SELECT r.external_id, fam.depth + 1 FROM task_ref r JOIN fam ON r.revision_of = fam.id WHERE r.backend = ? AND fam.depth < 64)
+      SELECT COUNT(DISTINCT id) AS n FROM fam`).get(BUILT_IN, root, BUILT_IN);
+        const taken = (id) => this.db.prepare("SELECT 1 AS hit FROM task WHERE id = ? UNION ALL SELECT 1 FROM task_ref WHERE backend = ? AND external_id = ?").get(id, BUILT_IN, id) !== undefined;
+        const named = (n) => `${root.slice(0, 64 - `-v${n}`.length)}-v${n}`;
+        let n = Math.max(2, Number(family?.["n"] ?? 1) + 1);
+        while (taken(named(n)))
+            n++;
+        return named(n);
+    }
     revisionAncestryOf(taskId) {
         return this.revisionAncestryStatus(taskId).chain;
     }

package/dist/task-outcome-cli.js

@@ -82,7 +82,9 @@ export async function runTaskOutcomeCommand(action, positional, flags, context)
             if (!changed.ok)
                 return emit(changed);
             const assignment = 'body' in changed ? changed.body : changed.assignment;
-            return emit({ ok: true, result: assignment }, [`${current.rootId} · Complete`, `Result: ${current.activeTaskId} · run ${current.receipt.runId} · ${current.receipt.head ?? 'no commit'}`, current.receipt.checks.detail]);
+            // Checks deliberately Off: nothing to say about them here.
+            return emit({ ok: true, result: assignment }, [`${current.rootId} · Complete`, `Result: ${current.activeTaskId} · run ${current.receipt.runId} · ${current.receipt.head ?? 'no commit'}`,
+                ...(current.readiness?.checksOff ? [] : [current.receipt.checks.detail])]);
         }
         const feedback = flags.get('feedback'), runFlag = flags.get('run'), sourceFlag = flags.get('source'), keyFlag = flags.get('key');
         if (typeof feedback !== 'string' || !feedback.trim())

package/dist/task-status.d.ts

@@ -56,6 +56,24 @@ export type ChecksFact = {
     running?: "quick" | "full" | null;
     /** A batch check (batch-checks.ts): waiting for its batch, or how it was checked. */
     batch?: ChecksBatch | null;
+    /** Off: the passing full release check whose commit contains this one (release-coverage.ts), read at read time. */
+    release?: {
+        run: number;
+        head: string;
+    } | null;
+};
+/** What checks Off leaves for a release: `pending` until a passing full release check contains the commit, then
+ * `covered`. `running`: a check is waiting for its batch or running on this commit. */
+export type ReleaseState = "pending" | "covered" | "running";
+export declare const CHECKED_AT_RELEASE = "Checked at release";
+export declare function releaseStateOf(checks: Pick<ChecksFact, "status" | "level" | "release"> | null | undefined): ReleaseState | undefined;
+/** How the project check stands for requirements that rest on it, read now: `covered` once a check passed on this
+ * commit (its own, a follow-up, or a release check containing it), `pending` while checks Off wait for a release. */
+export declare function checkBackingOf(checks: Pick<ChecksFact, "status" | "level" | "release" | "running" | "batch"> | null | undefined): ReleaseState | undefined;
+/** What stands between a finished result and Complete (`completionBlockersOf`): each with the exact next step. */
+export type CompletionBlocker = {
+    key: "check-failed" | "check-missing" | "criteria" | "high";
+    message: string;
 };
 /** `waiting`: the result waits to be checked with others. Otherwise how its check ran: `together` on the
  * temporary batch commit `tested` with `peers`; `split` (its batch failed), `conflict` or `alone` on its own commit. */
@@ -94,14 +112,22 @@ export type TaskStatusFacts = {
     checks?: ChecksFact | null;
     pullRequest?: PullRequestFact | null;
     /** `unverified`: the report is refuted, so no requirement counts as met however it was marked. `missed`: the ones it
-     * failed or left unanswered. */
+     * failed or left unanswered. `atRelease`: checks Off, waiting for a release check. `unshown`: a required screenshot
+     * is missing. `ask`: what a person is asked to look at first (a requirement they check, or a missing screenshot). */
     requirements?: {
         met: number;
         total: number;
         yours: number;
         missed?: number;
         unverified?: boolean;
+        atRelease?: number;
+        unshown?: number;
+        ask?: string | null;
     } | null;
+    /** A person accepted this result's proof: their own check and a recorded exception need nothing more. */
+    accepted?: boolean;
+    /** What refuses Complete (`completionBlockersOf`); the first one is the sentence when it holds the result back. */
+    blockers?: readonly CompletionBlocker[];
     evidence?: {
         shortened: number;
         missing: number;
@@ -124,11 +150,14 @@ export type TaskStatusFacts = {
     /** What the person calls their lead (Settings → Lead); "Lead" when unnamed. */
     leadName?: string;
 };
-export declare function headlineOf(facts: Pick<TaskStatusFacts, "stage" | "checks" | "report">): Headline;
+export declare function headlineOf(facts: Pick<TaskStatusFacts, "stage" | "checks" | "report" | "requirements" | "accepted" | "blockers">): Headline;
 /** What the lead's claim says, in place of "waits for you" (lead-voice.ts). */
 export declare const leadOnIt: (name?: string) => string;
 export declare const leadLapsed: (name?: string) => string;
-export declare function taskStatusOf(facts: TaskStatusFacts): TaskStatus;
+/** The one status every surface shows (console list, task and result pages, CLI, chat, phone, `status`). */
+export declare function statusOf(facts: TaskStatusFacts): TaskStatus;
+/** The name most surfaces already import. */
+export declare const taskStatusOf: typeof statusOf;
 export declare function plainReasonOf(stage: TaskStage, code: string, detail: string | null | undefined): string | null;
 export declare function stageOfCode(code: string, options?: {
     needsPerson?: boolean;
@@ -165,18 +194,41 @@ export declare function assignmentStageOf(assignment: Pick<AssignmentSnapshot, "
     wait?: WaitKey;
 };
 type RequirementRow = {
+    id?: string;
+    statement?: string;
     state: string;
+    requiredEvidence?: readonly string[];
+    answered?: readonly {
+        kind: string;
+    }[];
+    detail?: readonly string[];
     assessment?: {
         evidenceState?: string;
+        detail?: readonly string[];
     } | undefined;
     review?: unknown;
 };
 /** One requirement's state in words: the card's Requirements row and the Checks tab read this one source, so they
- * can't disagree. A refuted report verifies none of its requirements, so each reads Unverified, as the card does. */
-export type RequirementWord = "Met" | "You check" | "Not shown yet" | "Not met" | "Unverified";
-export declare function requirementWordOf(row: RequirementRow, verdict?: string | null): RequirementWord;
+ * can't disagree. A refuted report verifies none of its requirements, so each reads Unverified, as the card does.
+ * With checks Off, a requirement that waits only on the check reads Checked at release, then Met once a passing full
+ * release check contains the commit. */
+export type RequirementWord = "Met" | "You check" | "Not shown yet" | "Checked at release" | "Waiting for checks" | "Not met" | "Unverified";
+export declare function requirementWordOf(row: RequirementRow, verdict?: string | null, release?: ReleaseState): RequirementWord;
 /** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
-export declare function requirementsOf(matrix: readonly RequirementRow[] | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
+export declare function requirementsOf(matrix: readonly RequirementRow[] | null | undefined, release?: ReleaseState): NonNullable<TaskStatusFacts["requirements"]> | null;
+/** What refuses Complete, for `task complete`, the console and chat completion and deploy-candidate alike: a failed
+ * check; a required check that is missing (checks deliberately Off are not missing: they are checked at release);
+ * an unresolved requirement (a person's own check is theirs to give by completing; a recorded acceptance resolves
+ * the rest); an unresolved HIGH review finding. A release check that covers the commit counts as passed. */
+export declare function completionBlockersOf(f: {
+    report: boolean;
+    checks: Pick<ChecksFact, "status" | "exitCode" | "level" | "release" | "running" | "batch"> | null;
+    checkRequired: boolean;
+    matrix: readonly RequirementRow[] | null | undefined;
+    verdict: string | null | undefined;
+    accepted: boolean;
+    high: number;
+}): CompletionBlocker[];
 /** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */
 export declare function unverifiedWhenRefuted(requirements: NonNullable<TaskStatusFacts["requirements"]> | null, verdict: string | null | undefined): NonNullable<TaskStatusFacts["requirements"]> | null;
 /** Saved evidence health from the receipt's artifact list and its caveats. */