toolroll 0.9.56 → 0.9.58

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.9.58 — 2026-10-09
+
+- **One token kind.** Personal, lead and coordinator tokens now live in one
+  table with one check. Existing tokens keep working.
+- **Sessions join the CLI API.** The sessions API is now part of the CLI API.
+- **Passwords as tokens warn.** Sending your password as a token still works
+  this release but warns. Create a token with `toolroll tokens create`.
+
+## 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

package/dist/action-ledger.js

@@ -63,10 +63,6 @@ CREATE TRIGGER IF NOT EXISTS ledger_task_placed AFTER UPDATE OF repo ON task_ref
 WHEN OLD.repo IS NOT NEW.repo BEGIN
   ${event("strftime('%Y-%m-%dT%H:%M:%fZ','now')", "'system'", "NEW.repo", "NEW.external_id", "NULL", "task placed", "'recorded'")}
 END;
-CREATE TRIGGER IF NOT EXISTS ledger_coordinator_minted AFTER INSERT ON coordinator_credential BEGIN
-  INSERT INTO action_ledger(at,actor,repo,task_id,run_id,action,outcome,source,detail) VALUES (NEW.created_at, NEW.created_by, NULL, NULL, NULL,
-    'coordinator minted: ' || NEW.name, 'minted', 'access', 'projects: ' || NEW.repos);
-END;
 CREATE TRIGGER IF NOT EXISTS ledger_task_registered AFTER INSERT ON task_ref BEGIN
   ${event("strftime('%Y-%m-%dT%H:%M:%fZ','now')", "'system'", "NEW.repo", "NEW.external_id", "NULL", "task registered", "'recorded'")}
 END;

package/dist/actor.d.ts

@@ -9,13 +9,3 @@ export declare function currentActor(): Actor | null;
 export declare function claimActor(account: string): void;
 /** How the ledger names an actor. */
 export declare function actorLabel(actor: Actor): string;
-export declare function mintLeadToken(): {
-    id: string;
-    token: string;
-    hash: string;
-};
-export declare function parseLeadToken(presented: string): {
-    id: string;
-    secret: string;
-} | null;
-export declare function leadSecretMatches(secret: string, keptHash: string): boolean;

package/dist/actor.js

@@ -2,7 +2,7 @@
  * Who is acting right now, for pings that follow responsibility.
  *
  * A lead is an agent acting for one person under a lead token (`toolroll lead
- * token`): it signs in as that person, and its acts are recorded as "lead for
+ * token`, a `credential` row of kind 'lead', api-tokens.ts): it signs in as that person, and its acts are recorded as "lead for
  * <owner>". A person acting for themselves is recorded by name. Work whose
  * actor is the lead pings nobody, and nobody is pinged about their own act.
  *
@@ -10,7 +10,6 @@
  * long-running service: a worker's facts are nobody's act.
  */
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 /** The slot is mutable so a command can name its person after it has verified their password. */
 const slot = new AsyncLocalStorage();
 /** Run `fn` with this actor (or an empty slot a verified sign-in may fill). */
@@ -30,19 +29,3 @@ export function claimActor(account) {
 export function actorLabel(actor) {
     return actor.lead ? `lead for ${actor.account}` : actor.account;
 }
-// ---- the lead token ---------------------------------------------------------
-/** `lt_<id>_<secret>`: shown once, only its hash kept. */
-const SHAPE = /^lt_([a-f0-9]{12})_([A-Za-z0-9_-]{43})$/;
-export function mintLeadToken() {
-    const id = randomBytes(6).toString("hex"), secret = randomBytes(32).toString("base64url");
-    return { id, token: `lt_${id}_${secret}`, hash: hashLeadSecret(secret) };
-}
-const hashLeadSecret = (secret) => createHash("sha256").update(secret, "utf8").digest("hex");
-export function parseLeadToken(presented) {
-    const match = SHAPE.exec(presented.trim());
-    return match === null ? null : { id: match[1], secret: match[2] };
-}
-export function leadSecretMatches(secret, keptHash) {
-    const a = Buffer.from(hashLeadSecret(secret), "hex"), b = Buffer.from(keptHash, "hex");
-    return a.length === b.length && timingSafeEqual(a, b);
-}

package/dist/api-tokens.d.ts

@@ -1,5 +1,7 @@
 export type TokenAccess = "read" | "act";
 export type TokenPurpose = "api" | "mcp";
+/** Who a credential stands for: a person (their API token), a person's lead, or a coordinator. */
+export type CredentialKind = "person" | "lead" | "coordinator";
 export declare const MCP_ROTATION_REFUSAL = "Reconnect the MCP client to renew this token. You can still revoke it here.";
 /** Missing purpose is an old ordinary token; an unrecognised stored purpose is never treated as ordinary. */
 export declare const tokenPurpose: (value: unknown) => TokenPurpose;
@@ -7,18 +9,47 @@ export declare const tokenRotationProblem: (token: {
     purpose: TokenPurpose;
 }) => string | null;
 export declare const TOKEN_DAYS: readonly [30, 90, 365];
-export declare function mintApiToken(): {
+/** What a presented secret says it is, before any check. A coordinator's secret has no prefix and is hashed whole. */
+export type PresentedCredential = {
+    kind: "person" | "lead";
+    id: string;
+    secret: string;
+} | {
+    kind: "coordinator";
+    secret: string;
+};
+/** A new credential of `kind`: its id, the secret shown once, and the only thing kept, its hash. */
+export declare function mintCredential(kind: CredentialKind): {
     id: string;
     secret: string;
     token: string;
     hash: string;
 };
 export declare const hashSecret: (secret: string) => string;
-/** The id and secret of something shaped like a token, or null. */
+/** Read a presented credential's kind and parts; null for nothing at all. A lead token may carry surrounding space. */
+export declare function parseCredential(presented: string): PresentedCredential | null;
+export declare const mintApiToken: () => {
+    id: string;
+    secret: string;
+    token: string;
+    hash: string;
+};
+export declare const mintLeadToken: () => {
+    id: string;
+    secret: string;
+    token: string;
+    hash: string;
+};
+/** The id and secret of something shaped like an API token, or null. */
 export declare function parseApiToken(presented: string): {
     id: string;
     secret: string;
 } | null;
+/** The id and secret of something shaped like a lead token, or null. */
+export declare function parseLeadToken(presented: string): {
+    id: string;
+    secret: string;
+} | null;
 /** Whether the secret is the one whose hash was kept, in constant time. */
 export declare function secretMatches(secret: string, keptHash: string): boolean;
 /** v111: how long a rotated token keeps working beside its replacement, by default and at most. */

package/dist/api-tokens.js

@@ -1,8 +1,9 @@
 /**
- * API tokens (v101): what scripts and CI use instead of a password on each
- * request. A token belongs to one person, reads or acts (never more than the
- * person may), always expires (a year at most), is shown once, and only its
- * hash is kept. `Authorization: Bearer so_<id>_<secret>`.
+ * Machine credentials (D7, v118): one codec and one table (`credential`) for every kind. A person's API token is
+ * what scripts and CI use instead of a password on each request: it belongs to one person, reads or acts (never
+ * more than the person may), always expires (a year at most), is shown once, and only its hash is kept.
+ * `Authorization: Bearer so_<id>_<secret>`. A lead token (`lt_<id>_<secret>`) is an agent acting for its owner; a
+ * coordinator's secret (no prefix, hashed whole) files proposals over MCP. Each kind keeps its own policy.
  *
  * A token never passes a step-up: approvals and other password ceremonies
  * stay a person's act in the console.
@@ -13,16 +14,43 @@ export const MCP_ROTATION_REFUSAL = "Reconnect the MCP client to renew this toke
 export const tokenPurpose = (value) => value === undefined || value === "api" ? "api" : "mcp";
 export const tokenRotationProblem = (token) => token.purpose === "api" ? null : MCP_ROTATION_REFUSAL;
 export const TOKEN_DAYS = [30, 90, 365];
-const SHAPE = /^so_([a-f0-9]{12})_([A-Za-z0-9_-]{43})$/;
-export function mintApiToken() {
-    const id = randomBytes(6).toString("hex"), secret = randomBytes(32).toString("base64url");
-    return { id, secret, token: `so_${id}_${secret}`, hash: hashSecret(secret) };
+/** The prefixed shapes: so_ (a person's API token) and lt_ (a lead token), each `<prefix>_<12 hex>_<43 base64url>`. */
+const PRESENTED = /^(so|lt)_([a-f0-9]{12})_([A-Za-z0-9_-]{43})$/;
+const PREFIX = { person: "so", lead: "lt" };
+const CID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+/** A new credential of `kind`: its id, the secret shown once, and the only thing kept, its hash. */
+export function mintCredential(kind) {
+    const secret = randomBytes(32).toString("base64url");
+    if (kind === "coordinator") {
+        let id = "";
+        for (const byte of randomBytes(12))
+            id += CID_ALPHABET[byte % CID_ALPHABET.length];
+        return { id, secret, token: secret, hash: hashSecret(secret) };
+    }
+    const id = randomBytes(6).toString("hex");
+    return { id, secret, token: `${PREFIX[kind]}_${id}_${secret}`, hash: hashSecret(secret) };
 }
 export const hashSecret = (secret) => createHash("sha256").update(secret, "utf8").digest("hex");
-/** The id and secret of something shaped like a token, or null. */
+/** Read a presented credential's kind and parts; null for nothing at all. A lead token may carry surrounding space. */
+export function parseCredential(presented) {
+    if (presented === "")
+        return null;
+    const match = PRESENTED.exec(presented) ?? (/^lt_/.test(presented.trim()) ? PRESENTED.exec(presented.trim()) : null);
+    if (match !== null)
+        return { kind: match[1] === "so" ? "person" : "lead", id: match[2], secret: match[3] };
+    return { kind: "coordinator", secret: presented };
+}
+export const mintApiToken = () => mintCredential("person");
+export const mintLeadToken = () => mintCredential("lead");
+/** The id and secret of something shaped like an API token, or null. */
 export function parseApiToken(presented) {
-    const match = SHAPE.exec(presented);
-    return match === null ? null : { id: match[1], secret: match[2] };
+    const parsed = parseCredential(presented);
+    return parsed?.kind === "person" && PRESENTED.test(presented) ? { id: parsed.id, secret: parsed.secret } : null;
+}
+/** The id and secret of something shaped like a lead token, or null. */
+export function parseLeadToken(presented) {
+    const parsed = parseCredential(presented);
+    return parsed?.kind === "lead" ? { id: parsed.id, secret: parsed.secret } : null;
 }
 /** Whether the secret is the one whose hash was kept, in constant time. */
 export function secretMatches(secret, keptHash) {

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-delivery.js

@@ -14,7 +14,7 @@ const ownerSql = `COALESCE((SELECT 'lead:'||o.lead FROM team_task_owner o WHERE
 function admittedRepos(store, owner) {
     if (owner.kind !== "coordinator" || typeof owner.id !== "string" || owner.id.length === 0)
         return null;
-    const row = store.handle.prepare("SELECT repos,revoked_at FROM coordinator_credential WHERE cid = ?").get(owner.id);
+    const row = store.handle.prepare("SELECT projects_json AS repos,revoked_at FROM credential WHERE id = ? AND kind = 'coordinator'").get(owner.id);
     if (!row || row["revoked_at"] !== null)
         return null;
     try {

package/dist/assignment-status.js

@@ -92,7 +92,7 @@ export function noteAssignmentStatus(store, snapshot, now) {
             const claimed = store.handle.prepare("SELECT actor FROM action_ledger WHERE task_id=? AND action='assignment claimed' AND source='work' ORDER BY id DESC LIMIT 1").get(snapshot.rootId);
             if ((claimed === undefined ? ref.coordinatorCid : String(claimed["actor"]).replace(/^coordinator:/, "")) !== owner.id)
                 return null;
-            const credential = store.handle.prepare("SELECT repos FROM coordinator_credential WHERE cid=? AND revoked_at IS NULL").get(owner.id);
+            const credential = store.handle.prepare("SELECT projects_json AS repos FROM credential WHERE id=? AND kind='coordinator' AND revoked_at IS NULL").get(owner.id);
             let repos;
             try {
                 repos = JSON.parse(String(credential?.["repos"] ?? "null"));

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}`;
@@ -72,7 +73,8 @@ function ownerOf(store, rootId, repo) {
     const id = claim === undefined ? origin : String(claim["actor"]).replace(/^coordinator:/, "");
     if (!id)
         return null;
-    const credential = store.handle.prepare("SELECT name,repos,revoked_at FROM coordinator_credential WHERE cid = ?").get(id);
+    // A ledger actor names a coordinator by the id it had when it acted (v118 keeps that as public_id).
+    const credential = store.handle.prepare("SELECT name,projects_json AS repos,revoked_at FROM credential WHERE kind = 'coordinator' AND (id = ? OR public_id = ?) ORDER BY id = ? DESC LIMIT 1").get(id, id, id);
     let repos = [];
     try {
         repos = JSON.parse(String(credential?.["repos"] ?? "[]"));
@@ -127,7 +129,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 +165,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 +344,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,12 +361,26 @@ 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")
         return null; // A stable lead is identity, not a bearer credential.
-    const row = store.handle.prepare("SELECT repos, revoked_at FROM coordinator_credential WHERE cid = ?").get(owner.id);
+    const row = store.handle.prepare("SELECT projects_json AS repos, revoked_at FROM credential WHERE id = ? AND kind = 'coordinator'").get(owner.id);
     if (row === undefined || row["revoked_at"] !== null)
         return null;
     let repos;
@@ -417,6 +437,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 +500,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 +532,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}.` };

package/dist/browser-workspace.js

@@ -19,7 +19,7 @@ export function browserCrewOf(store, now, access, options = {}) {
         return { crew: [], crewTruncated: false };
     const limit = Number.isFinite(options.limit)
         ? Math.max(1, Math.min(BROWSER_CREW_LIMIT, Math.floor(options.limit))) : BROWSER_CREW_LIMIT;
-    const page = workIndexPage(store, now, access, { limit, project });
+    const page = workIndexPage(store, now, access, { limit, project, ...(options.evidenceRoot === undefined ? {} : { root: options.evidenceRoot }) });
     return browserCrewFromIndex(page);
 }
 /** Navigation input must already be admitted by the caller. No extra project

package/dist/chat-delivery.js

@@ -232,9 +232,9 @@ export async function processChatEvent(options) {
             if (command.kind === "help")
                 state.plan(event.id, [{ text: PHONE_HELP }], now_);
             else if (command.kind === "status")
-                state.plan(event.id, [{ text: phoneStatus(store, repos, now_, focusedTitle) }], now_);
+                state.plan(event.id, [{ text: phoneStatus(store, repos, now_, focusedTitle, options.evidenceRoot) }], now_);
             else if (command.kind === "tasks")
-                state.plan(event.id, [{ text: phoneTaskListText(phoneTaskChoices(store, repos, now_), focusedTitle) }], now_);
+                state.plan(event.id, [{ text: phoneTaskListText(phoneTaskChoices(store, repos, now_, null, 8, options.evidenceRoot), focusedTitle) }], now_);
             else if (command.kind === "lead") {
                 store.setChatFocus(surface, binding.id, null, now_);
                 state.plan(event.id, [{ text: PHONE_BACK_TO_LEAD }], now_);
@@ -243,7 +243,7 @@ export async function processChatEvent(options) {
                 const pick = resolvePhoneTask(store, repos, now_, command.id);
                 if (pick.kind === "one") {
                     store.setChatFocus(surface, binding.id, pick.id, now_);
-                    const view = phoneTaskView(store, repos, pick.view, now_);
+                    const view = phoneTaskView(store, repos, pick.view, now_, options.evidenceRoot);
                     // The status names its task (and result): a reply to it is about that task.
                     state.plan(event.id, [{ text: phoneFocusText(view.text), ...(view.link === null ? {} : { link: view.link }), task: pick.view, ...(view.run === null ? {} : { run: view.run }) }], now_);
                 }

package/dist/chat-voice.js

@@ -69,7 +69,7 @@ export function finishedLine(fact) {
             if (fact.checks === "passed")
                 return `${ready}. Your tests passed. ${fact.pullRequest === true ? "Merge it?" : "Accept and finish it?"}`;
             if (fact.checks === "off")
-                return `${ready}. Checks are off for this project, so look it over first.`;
+                return `${ready}. Its checks run at release, so look it over first.`;
             return `${ready}, but no tests ran. Look it over first.`;
         case "Failed":
             if (fact.leadOnIt === true)

package/dist/check-levels.d.ts

@@ -52,6 +52,9 @@ export declare function checkCommandFor(store: Store, repo: string, level: Check
     level: CheckLevel;
     command: VerifyCommand | null;
 };
+/** Readiness uses the result's level, falling back to the task/project for legacy
+ * runs. Quick's approved command (or its Full fallback) is required; Off is not. */
+export declare function requiredCheckCommandFor(store: Store, repo: string | null, taskId: string, level: CheckLevel | null | undefined): VerifyCommand | null;
 /** The builder records which level a run used, so its result says it honestly. */
 export declare function recordRunCheckLevel(store: Store, run: {
     id: number;

package/dist/check-levels.js

@@ -118,6 +118,11 @@ export function checkCommandFor(store, repo, level) {
     }
     return { level: "full", command: store.liveVerifyCommand(repo) };
 }
+/** Readiness uses the result's level, falling back to the task/project for legacy
+ * runs. Quick's approved command (or its Full fallback) is required; Off is not. */
+export function requiredCheckCommandFor(store, repo, taskId, level) {
+    return repo === null ? null : checkCommandFor(store, repo, level ?? effectiveCheckLevel(store, repo, taskId).level).command;
+}
 /** The builder records which level a run used, so its result says it honestly. */
 export function recordRunCheckLevel(store, run, level, from, now) {
     store.recordAction({ at: now.toISOString(), actor: "system", repo: run.repo, taskId: run.taskId, runId: run.id, action: RUN_LEVEL_ACTION, outcome: level, source: "work",

package/dist/cli-http.d.ts

@@ -3,6 +3,7 @@ import type { Store } from './store.js';
 import type { Principal } from './operate.js';
 import { type RemoteCommandLookup } from './remote-command.js';
 import { type Admission, type BudgetLimit } from './request-budget.js';
+import type { SessionRunner } from './session-remote.js';
 /**
  * `POST /api/cli` (remote CLI, Phase 1): a teammate's laptop sends the argv it would have run locally, and the central
  * server runs that same command as that person. There is no per-resource API here and no second policy: the transport
@@ -11,6 +12,10 @@ import { type Admission, type BudgetLimit } from './request-budget.js';
  *
  * Only `Authorization: Bearer so_…` is accepted — never a password, cookie or the owner's saved login — and a request
  * carrying a browser Origin is refused, so a page can never drive it.
+ *
+ * `session …` (D7) is the one command the server answers through its own owner rather than runOperateAs: native
+ * session operations need the server's live coding workspace (session-remote.ts). They are admitted, budgeted and
+ * refused here exactly like every other command.
  */
 /** Who a remote command runs as, and the runner: operate.ts's own types, so a change there breaks this build instead of
  * drifting. Type-only: the value is loaded lazily through `run` (operate.ts imports the server that imports this). */
@@ -45,6 +50,8 @@ export type CliHttpOptions = {
     modeOf?: RemoteCommandLookup | undefined;
     /** The token's request budget (request-budget.ts), charged once per request before its body is read. */
     admit?: ((principal: Principal) => Admission) | undefined;
+    /** Native session operations (`session …`), run by the server's session owner; absent where none is ready. */
+    session?: SessionRunner | undefined;
     store: Store;
 };
 /** Decode the request's shape and byte limits. The endpoint checks file references against its command policy. */

package/dist/cli-http.js

@@ -1,6 +1,7 @@
 import { adapterPolicy } from "./server/route-policy.js";
 import { contractRow, fileArguments, STEP_UP_MESSAGE } from './remote-command.js';
 import { limitWords } from './request-budget.js';
+import { TOKEN_REPLACEMENT } from './password-bearer.js';
 /** Inlined file contents, summed as UTF-8 bytes. */
 export const CLI_FILES_BYTES = 256 * 1024;
 /** The whole JSON body: the files plus argv and JSON escaping headroom. */
@@ -8,11 +9,15 @@ export const CLI_REQUEST_BYTES = 2 * CLI_FILES_BYTES;
 const ARGV_MAX = 256;
 const ARG_BYTES = 16 * 1024;
 const FILES_MAX = 16;
+/** What a missing or unusable token hears: how to get one, and how to save it. */
+const SIGN_IN = `Sign in with an API token: ${TOKEN_REPLACEMENT.charAt(0).toLowerCase()}${TOKEN_REPLACEMENT.slice(1)}, then toolroll connect <origin> --token-stdin.`;
 function send(response, status, value, headers = {}) {
     if (response.destroyed || response.writableEnded)
         return;
-    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff', ...headers });
-    response.end(JSON.stringify(value));
+    // A declared length: the client can tell a complete answer from a cut-off one.
+    const text = JSON.stringify(value);
+    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'content-length': String(Buffer.byteLength(text)), 'cache-control': 'no-store', 'x-content-type-options': 'nosniff', ...headers });
+    response.end(text);
 }
 async function body(request) {
     const chunks = [];
@@ -83,7 +88,7 @@ export async function handleCliHttp(request, response, options) {
     if (names.includes('cookie'))
         return reject(400, 'cookie-refused', 'Remote commands sign in with an API token only.');
     if (!/^Bearer so_\S+$/.test(request.headers.authorization ?? ''))
-        return reject(401, 'unauthenticated', 'Sign in with your API token: toolroll connect <origin> --token-stdin.');
+        return reject(401, 'unauthenticated', SIGN_IN);
     if (request.headers['content-type']?.split(';')[0]?.trim() !== 'application/json')
         return reject(415, 'invalid-content-type', 'Send application/json.');
     if (Number(request.headers['content-length'] ?? 0) > CLI_REQUEST_BYTES)
@@ -96,7 +101,7 @@ export async function handleCliHttp(request, response, options) {
         return reject(503, 'authentication-unavailable', 'Sign-in could not be checked.');
     }
     if (!principal)
-        return reject(401, 'unauthenticated', 'This API token is not valid (expired, revoked or its person removed).');
+        return reject(401, 'unauthenticated', `This API token is not valid (expired, revoked or its person removed). ${TOKEN_REPLACEMENT}.`);
     // Counted once here, however long the command then holds the request (a task wait is one request).
     const admitted = options.admit === undefined ? { ok: true } : options.admit(principal);
     if (!admitted.ok && admitted.status === 503)
@@ -118,6 +123,8 @@ export async function handleCliHttp(request, response, options) {
     const parsed = cliRequest(value);
     if ('problem' in parsed)
         return reject(parsed.tooLarge ? 413 : 400, 'invalid-request', parsed.problem);
+    if (parsed.argv[0] === 'session')
+        return runSession(response, options, principal, parsed);
     const row = (options.modeOf ?? contractRow)(parsed.argv);
     if (row?.mode === 'step-up')
         return reject(403, 'step-up', STEP_UP_MESSAGE);
@@ -154,3 +161,22 @@ export async function handleCliHttp(request, response, options) {
     send(response, 200, { exitCode, stdout: out.join(''), stderr: '' });
     return true;
 }
+/** `session …`: the prompt is the request's one file; the session owner answers one session envelope on stdout. */
+async function runSession(response, options, principal, parsed) {
+    const refuse = (status, code, message) => { send(response, status, { ok: false, code, message }); return true; };
+    if (options.session === undefined)
+        return refuse(501, 'remote-unavailable', 'This server cannot run session commands. Update it, or use the console.');
+    const at = parsed.argv.indexOf('--file'), file = at < 0 ? undefined : parsed.argv[at + 1];
+    if (Object.keys(parsed.files).some(path => path !== file))
+        return refuse(400, 'invalid-request', 'Each file must name a declared input file argument.');
+    const out = [];
+    let exitCode;
+    try {
+        exitCode = await options.session(principal, parsed.argv, parsed.files, line => { out.push(`${line}\n`); });
+    }
+    catch {
+        return refuse(500, 'command-failed', 'The command stopped unexpectedly on the server. Check its state before running it again.');
+    }
+    send(response, 200, { exitCode, stdout: out.join(''), stderr: '' });
+    return true;
+}