toolroll 0.9.6 → 0.9.8

package/dist/surface.js

@@ -135,8 +135,27 @@ export const COMMAND_GUIDE = [
         flags: [jsonFlag, dbFlag, keyFlag,
             { name: "id", takesValue: true, meaning: "choose the task id" },
             { name: "repo", takesValue: true, meaning: "which repository the task belongs to" },
-            { name: "report", takesValue: false, meaning: "a scout task: the deliverable is a report, never a branch" }],
-        notableReasons: ["duplicate", "usage"] },
+            { name: "report", takesValue: false, meaning: "a scout task: the deliverable is a report, never a branch" },
+            { name: "replaces", takesValue: true, meaning: "the task this one replaces: it is cancelled and reads \"Replaced by <id>\"" },
+            { name: "token", takesValue: true, meaning: "a lead token: filed as the lead, so it pings nobody" },
+            { name: "checks", takesValue: true, meaning: "quick|full|off: this task's checks, overriding the project's level (\"skip the tests\" is off)" }],
+        notableReasons: ["duplicate", "usage", "unknown-task", "unauthenticated"] },
+    { invocation: "task ask", synopsis: "hand a task to a person: one message saying why, and the task is theirs", audience: "agent", agentMayInvoke: true, mutation: "unkeyed",
+        positionals: [{ name: "id", required: true, meaning: "the task" }],
+        flags: [jsonFlag, dbFlag,
+            { name: "person", takesValue: true, meaning: "who to ask (someone who can see the task's project)" },
+            { name: "why", takesValue: true, meaning: "what they need to do, one line" },
+            { name: "token", takesValue: true, meaning: "the lead token (or TOOLROLL_LEAD_TOKEN)" }],
+        notableReasons: ["unknown-task", "unknown-person", "unplaced", "unauthenticated"] },
+    { invocation: "task checks", synopsis: "run checks on the task's latest result, on its exact commit, now; a pass upgrades its status and a failure stays visible",
+        audience: "agent", agentMayInvoke: true, mutation: "identity-idempotent",
+        positionals: [{ name: "task", required: true, meaning: "any version of the task" }],
+        flags: [jsonFlag, dbFlag, { name: "level", takesValue: true, meaning: "quick (default) or full" }],
+        notableReasons: ["no-result", "no-check", "checks-failed"] },
+    { invocation: "task add-tests", synopsis: "file a small task to write tests for the task's latest change; it waits for approval like any task",
+        audience: "agent", agentMayInvoke: true, mutation: "identity-idempotent",
+        positionals: [{ name: "task", required: true, meaning: "any version of the task" }], flags: [jsonFlag, dbFlag],
+        notableReasons: ["no-result"] },
     { invocation: "task list", synopsis: "a page of saved task status", audience: "agent", agentMayInvoke: true, mutation: "none",
         flags: [jsonFlag, dbFlag, { name: "state", takesValue: true, meaning: "queued|running|done|failed|cancelled" },
             { name: "view", takesValue: true, meaning: "all|needs-you|running|completed" },
@@ -168,8 +187,9 @@ export const COMMAND_GUIDE = [
     { invocation: "task merge", synopsis: "merge the task's pull request once its checks pass — the console's Merge, behind the approver's password; the project's method (squash by default), branch deleted, recorded in the ledger",
         audience: "operator", agentMayInvoke: false, mutation: "identity-idempotent",
         positionals: [{ name: "task", required: true, meaning: "any version of the task" }],
-        flags: [jsonFlag, dbFlag, { name: "as", takesValue: true, meaning: "the approver merging" }, { name: "token", takesValue: true, meaning: "their password" }],
-        notableReasons: ["usage", "not-an-approver"] },
+        flags: [jsonFlag, dbFlag, { name: "as", takesValue: true, meaning: "the approver merging" }, { name: "token", takesValue: true, meaning: "their password" },
+            { name: "anyway", takesValue: false, meaning: "merge a Quick or Off result without waiting for its full check" }],
+        notableReasons: ["usage", "not-an-approver", "full-checks"] },
     ...["show", "updates", "claim", "check", "brief", "inbox", "ack"].map(action => ({
         invocation: `assignment ${action}`,
         synopsis: action === "show" ? "read the root, current work, owner and exact receipt"
@@ -193,7 +213,8 @@ export const COMMAND_GUIDE = [
             ...(action === "ack" ? [{ name: "batch", takesValue: true, meaning: "exact batch ID returned by assignment inbox" }] : []),
         ],
     })),
-    operator("task state", "set a task's state by hand — an operator correction, not a workflow step"),
+    operator("task state", "set a task's state by hand — an operator correction, not a workflow step (--replaced-by <id> with cancelled)"),
+    operator("lead token", "mint the lead's credential behind your password (--revoke ends it): its own work pings nobody"),
     { invocation: "task block", synopsis: "make one task wait for another", audience: "agent", agentMayInvoke: true, mutation: "keyed",
         positionals: [{ name: "id", required: true, meaning: "the waiting task" }],
         flags: [jsonFlag, dbFlag, keyFlag, { name: "on", takesValue: true, meaning: "the blocker's id" }],
@@ -244,12 +265,13 @@ export const COMMAND_GUIDE = [
     operator("task approve", "the yes — nothing builds without one; binds to the scope digest"),
     operator("task requeue", "exit a stall: incidents resolved, strikes cleared, queued again"),
     operator("task regate", "explicitly rerun the approved check on the last exact commit — no agent or automatic retry"),
-    operator("task review", "retired compatibility command; inspect the saved result and explicitly complete or revise it"),
+    operator("task review", "show a run's automatic review: HIGH findings, suggested follow-ups, or why it was not reviewed"),
     operator("task accept", "record an explicit acceptance with limitations; does not change checks or prove deployment"),
     operator("task repair", "inspect or approve an existing historical repair draft; use task revise for new feedback"),
     operator("task route", "which configured agents plan, build and repair this task; phase and risk changes require renewed approval"),
     operator("task reopen", "resume external work its tracker closed and has been SEEN open again"),
     operator("task stop", "stop ONE exact live attempt (--run <id>): durable before any process is signalled, answers 'stopping' until its own processes are established gone; work, branch, and evidence preserved; no strike, no retry"),
+    operator("run settle", "last resort for a finished run whose process witness can't be proven either way: records your --why in the ledger; refuses while any of the run's processes is alive"),
     operator("task resume", "resume the exact stopped attempt (--run <id>): refuses until it is quiescent, lifts only that stop's hold, approves nothing — the next pass re-proves the scope and inherits the draft with fresh proof"),
     // ---- leases (runner surface) ----
     { invocation: "claim", synopsis: "take one ready, approved task; answers with a lease", audience: "agent", agentMayInvoke: true, mutation: "keyed",
@@ -289,7 +311,7 @@ export const COMMAND_GUIDE = [
         positionals: [{ name: "id", required: true, meaning: "the routine" }], flags: [jsonFlag, dbFlag] },
     { invocation: "config show", synopsis: "phase and spend configuration", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag, repoFlag] },
     { invocation: "setup show", synopsis: "installation setup", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
-    { invocation: "verify show", synopsis: "the repository's approved verification command, if one exists", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag, repoFlag] },
+    { invocation: "verify show", synopsis: "the repository's check level, its approved full and quick commands, and a suggested quick command", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag, repoFlag] },
     { invocation: "intake show", synopsis: "intake configuration", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
     { invocation: "providers", synopsis: "which agent providers this binary can drive, and their transports; --report records this machine's readiness under its runner", audience: "agent", agentMayInvoke: true, mutation: "none",
         flags: [jsonFlag,
@@ -309,6 +331,7 @@ export const COMMAND_GUIDE = [
     operator("runner retire", "retire a worker"),
     operator("runner bind", "replace which repositories a worker may build in"),
     operator("runner capacity", "set how many tasks a worker runs at once; running work carries on, the new number applies at the next claim"),
+    operator("project concurrency", "set how many of a project's tasks build at once (default 2, never past the worker's capacity); running work carries on"),
     operator("coordinator mint", "mint the MCP filing credential — repo-bound, rate-limited, token shown once"),
     operator("coordinator revoke", "revoke an MCP filing credential"),
     operator("mcp", "serve the MCP gateway over stdio — the coordinator credential is the only key it accepts"),
@@ -336,12 +359,16 @@ export const COMMAND_GUIDE = [
     operator("mode set", "sign a per-repository operating mode (password ceremony; standard or hands-off, always expiring)"),
     operator("publish merge", "say yes to ONE waiting merge — it fires only when CI is seen green on the exact commit you authorized"),
     operator("publish refire", "recover a merge whose issued call went silent — re-enters the full merge road, never auto-retried"),
+    operatorRead("review show", "whether a project's finished builds get one automatic review"),
+    operator("review on", "one automatic review of each finished build whose check passes; only HIGH findings send it back, once"),
+    operator("review off", "finished builds go straight to the person, unreviewed"),
     operator("mode revoke", "revoke a repository's mode — one click, every act it covered falls back to its own ceremony"),
     operator("config set", "set phase or spend configuration"),
     operator("config clear", "clear phase or spend configuration"),
     operator("setup clear", "clear installation setup"),
-    operator("verify set", "approve the one shell command the plane re-runs after every future commit; --self-heal binds one approved-setup replay when a required project executable is missing"),
-    operator("verify clear", "revoke a repository's approved verification command"),
+    operator("verify set", "approve the one shell command the plane re-runs after every future commit (--quick \"<cmd>\" approves the fast check Quick runs); --self-heal binds one approved-setup replay when a required project executable is missing"),
+    operator("verify clear", "revoke a repository's approved verification command; --level quick revokes only the quick command"),
+    operator("verify level", "set a project's checks after each build: quick (the approved quick command), full, or off — an approver's act, in the ledger"),
     operator("intake grant", "grant an intake source"),
     operator("intake run", "run intake now"),
     operator("intake preview", "preview what intake would file"),

package/dist/tailnet.d.ts

@@ -0,0 +1,11 @@
+type Runner = (file: string, args: readonly string[], options: {
+    timeoutMs: number;
+}) => Promise<{
+    code: number | null;
+    stdout: string;
+    notFound?: boolean;
+}>;
+/** The full MagicDNS name first (machine.tailnet.ts.net), then its short form (machine). Empty when Tailscale isn't running. */
+export declare function tailnetNamesOf(statusJson: string): string[];
+export declare function readTailnetNames(runner?: Runner, platform?: NodeJS.Platform): Promise<string[]>;
+export {};

package/dist/tailnet.js

@@ -0,0 +1,47 @@
+/**
+ * This computer's own names on its tailnet, when Tailscale is up: the console
+ * answers to them on its port without an --allow-host, and the phone card
+ * names the address to type. Read with `tailscale status --json`, which
+ * spends nothing and changes nothing; any failure means no tailnet.
+ */
+import { existsSync } from "node:fs";
+import { run } from "./exec.js";
+/** The Mac app ships its command line inside the app bundle. */
+const MAC_APP_CLI = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
+const NAME = /^[a-z0-9]([a-z0-9-]{0,62})(\.[a-z0-9]([a-z0-9-]{0,62}))*$/;
+/** The full MagicDNS name first (machine.tailnet.ts.net), then its short form (machine). Empty when Tailscale isn't running. */
+export function tailnetNamesOf(statusJson) {
+    let status;
+    try {
+        status = JSON.parse(statusJson);
+    }
+    catch {
+        return [];
+    }
+    if (typeof status !== "object" || status === null)
+        return [];
+    const body = status;
+    if (body.BackendState !== "Running" || typeof body.Self?.DNSName !== "string")
+        return [];
+    const full = body.Self.DNSName.replace(/\.$/, "").toLowerCase();
+    if (!NAME.test(full) || full.length > 253)
+        return [];
+    const short = full.split(".")[0];
+    return short === full ? [full] : [full, short];
+}
+export async function readTailnetNames(runner = run, platform = process.platform) {
+    const candidates = ["tailscale", ...(platform === "darwin" && existsSync(MAC_APP_CLI) ? [MAC_APP_CLI] : [])];
+    for (const file of candidates) {
+        try {
+            const answer = await runner(file, ["status", "--json"], { timeoutMs: 3_000 });
+            if (answer.notFound === true)
+                continue;
+            if (answer.code === 0)
+                return tailnetNamesOf(answer.stdout);
+        }
+        catch {
+            // No Tailscale here: no tailnet names.
+        }
+    }
+    return [];
+}

package/dist/task-outcome-cli.js

@@ -126,7 +126,7 @@ export async function runTaskMergeCommand(positional, flags, context) {
         return result.ok ? 0 : result.reason === 'usage' ? 2 : 3;
     };
     const fail = (reason, message) => emit({ ok: false, reason, message });
-    const allowed = new Set(['json', 'db', 'as', 'token']);
+    const allowed = new Set(['json', 'db', 'as', 'token', 'anyway']);
     for (const key of flags.keys())
         if (!allowed.has(key))
             return fail('usage', `--${key} is not a task merge option.`);
@@ -147,7 +147,7 @@ export async function runTaskMergeCommand(positional, flags, context) {
     const view = newestPullRequestOf(store, family.versions.map(one => one.id));
     if (view === null)
         return fail('no-pr', 'This task has no pull request. Open one with task complete --pull-request.');
-    const merged = await mergeAsPerson(store, { runId: view.runId, name: acting.name, password: acting.token, ...(context.exec === undefined ? {} : { exec: context.exec }), clock: context.clock });
+    const merged = await mergeAsPerson(store, { runId: view.runId, name: acting.name, password: acting.token, ...(flags.get('anyway') === true ? { anyway: true } : {}), ...(context.exec === undefined ? {} : { exec: context.exec }), clock: context.clock });
     if (!merged.ok)
         return emit({ ...merged, reason: merged.reason === 'password' ? 'not-an-approver' : merged.reason, pullRequest: view });
     const after = newestPullRequestOf(store, family.versions.map(one => one.id));

package/dist/task-status.d.ts

@@ -11,6 +11,8 @@
  * output) is an amber note on its own row with one action; the exact
  * technical reason stays one tap away in `why`. */
 import type { AssignmentSnapshot } from "./assignment.js";
+/** A cancelled task with a successor reads "Replaced by <id>" everywhere, never "Cancelled". */
+export declare const replacedWords: (successor: string) => string;
 export declare const HEADLINES: readonly ["Queued", "Planning", "Needs you", "Building", "Ready for review", "Complete", "Failed", "Stopped"];
 export type Headline = (typeof HEADLINES)[number];
 export type HeadlineTone = "neutral" | "live" | "attention" | "ready" | "success" | "danger";
@@ -40,11 +42,16 @@ export type TaskStatus = {
     primaryAction: StatusAction | null;
     why: string[];
 };
-export type TaskStage = "queued" | "planning" | "needs-you" | "building" | "checking" | "finished" | "complete" | "failed" | "stopped";
+/** `reviewing`: the one automatic review (build-review.ts) is reading a finished build; it reads Building, not a headline of its own. */
+export type TaskStage = "queued" | "planning" | "needs-you" | "building" | "checking" | "reviewing" | "finished" | "complete" | "failed" | "stopped";
 export type ChecksFact = {
     status: "passed" | "failed" | "running" | "not-run" | "unavailable";
     exitCode: number | null;
     head: string | null;
+    /** The check level that ran (check-levels.ts). Off never reads Ready; a quick pass says so. */
+    level?: "quick" | "full" | "off" | null;
+    /** A follow-up check (Run checks) waiting or running on this commit. */
+    running?: "quick" | "full" | null;
 };
 export type PullRequestFact = {
     state: "none" | "opening" | "open" | "merged" | "closed" | "failed";
@@ -79,11 +86,12 @@ export type TaskStatusFacts = {
     } | null;
     completedBy?: string | null;
     action?: StatusAction | null;
-    /** Where a row's one action leads: the result (and its Checks tab), the task's pull request. */
+    /** Where a row's one action leads: the result (and its Checks tab), the task's pull request, Run checks. */
     links?: {
         result?: string | null;
         checks?: string | null;
         pullRequest?: string | null;
+        runChecks?: string | null;
     };
     /** Exact technical reasons, shown only on request. */
     why?: readonly string[];
@@ -114,7 +122,9 @@ export declare function pullRequestFactOf(publication: {
 } | null): PullRequestFact | null;
 /** The assignment's stage. The work status, when the caller read one, names
  * the exact reason (a running planner, a pause, a failed attempt, a sign-in). */
-export declare function assignmentStageOf(assignment: Pick<AssignmentSnapshot, "state" | "primaryAction">, work?: {
+export declare function assignmentStageOf(assignment: Pick<AssignmentSnapshot, "state" | "primaryAction"> & {
+    review?: AssignmentSnapshot["review"];
+}, work?: {
     token: string;
     views?: readonly string[];
 } | null, planning?: boolean): {

package/dist/task-status.js

@@ -1,3 +1,6 @@
+/** A cancelled task with a successor reads "Replaced by <id>" everywhere, never "Cancelled". */
+export const replacedWords = (successor) => `Replaced by ${successor}`;
+const REPLACED = /^Replaced by \S+/;
 export const HEADLINES = ["Queued", "Planning", "Needs you", "Building", "Ready for review", "Complete", "Failed", "Stopped"];
 export const HEADLINE_TONE = {
     Queued: "neutral", Planning: "live", "Needs you": "attention", Building: "live",
@@ -10,8 +13,15 @@ export function headlineOf(facts) {
         case "planning": return "Planning";
         case "needs-you": return "Needs you";
         case "building":
-        case "checking": return "Building";
-        case "finished": return !facts.report && facts.checks?.status === "failed" ? "Failed" : "Ready for review";
+        case "checking":
+        case "reviewing": return "Building";
+        case "finished":
+            if (facts.report)
+                return "Ready for review";
+            if (facts.checks?.status === "failed")
+                return "Failed";
+            // Off: ready like any build; the sentence and the Checks row say no check ran.
+            return "Ready for review";
         case "complete": return "Complete";
         case "failed": return "Failed";
         case "stopped": return "Stopped";
@@ -27,12 +37,15 @@ function sentenceOf(headline, facts) {
         case "Needs you": return facts.need === "approval" ? "Review the plan and approve it to start." : reason ?? (facts.need === "answer" ? "Answer the question so the work can continue."
             : facts.need === "sign-in" ? "Sign in again; the task starts on its own after."
                 : "Something needs your decision before the work can continue.");
-        case "Building": return facts.stage === "checking" ? "Checks are running on the change." : reason ?? "An agent is working on it.";
+        case "Building": return facts.stage === "checking" ? "Checks are running on the change."
+            : facts.stage === "reviewing" ? "Reviewing the change before it reaches you." : reason ?? "An agent is working on it.";
         case "Ready for review":
             if (facts.report)
                 return "The report is ready to read. Read it, then mark it complete.";
+            if (facts.checks?.level === "off" && facts.checks.status !== "passed")
+                return "Checks are off for this project. Review the change, then mark it complete.";
             if (facts.checks?.status === "passed")
-                return `Checks passed${sha === null ? "" : ` on ${sha}`}. Review the change, then mark it complete.`;
+                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} passed${sha === null ? "" : ` on ${sha}`}. Review the change, then mark it complete.`;
             // Never claim a check that isn't known to have passed.
             if (facts.checks == null)
                 return "Review the change, then mark it complete.";
@@ -44,7 +57,7 @@ function sentenceOf(headline, facts) {
         }
         case "Failed":
             if (facts.checks?.status === "failed")
-                return `Checks failed${sha === null ? "" : ` on ${sha}`}. See what broke, then retry or ask for changes.`;
+                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. See what broke, then retry or ask for changes.`;
             return reason ?? "The last attempt stopped before it finished. Review it, then retry.";
         case "Stopped": return reason ?? "Stopped by a person. The work so far is kept.";
     }
@@ -58,14 +71,20 @@ function detailsOf(headline, facts) {
     if (checks != null && !facts.report) {
         const sha = short(checks.head);
         const checksHref = facts.links?.checks ?? facts.links?.result ?? null;
-        if (checks.status === "passed")
-            row("checks", "Checks", `Passed${sha === null ? "" : ` on ${sha}`}`, "ok", { href: checksHref });
+        const runChecks = facts.links?.runChecks === undefined ? null : { label: "Run checks", href: facts.links.runChecks };
+        const quick = checks.level === "quick";
+        if (checks.running != null)
+            row("checks", "Checks", `${checks.running === "quick" ? "Quick" : "Full"} checks running`, "running", { href: checksHref });
+        else if (checks.status === "passed")
+            row("checks", "Checks", `${quick ? "Quick checks passed" : "Passed"}${sha === null ? "" : ` on ${sha}`}`, "ok", quick && runChecks !== null && headline !== "Complete" ? { href: checksHref, action: { label: "Run full checks", href: runChecks.href } } : { href: checksHref });
         else if (checks.status === "failed")
-            row("checks", "Checks", `Failed${checks.exitCode === null ? "" : ` (exit ${checks.exitCode})`}`, problem(headline), headline === "Failed" ? { href: checksHref } : { action: { label: "See what failed", href: checksHref } });
+            row("checks", "Checks", `${quick ? "Quick checks failed" : "Failed"}${checks.exitCode === null ? "" : ` (exit ${checks.exitCode})`}`, problem(headline), headline === "Failed" ? { href: checksHref } : { action: { label: "See what failed", href: checksHref } });
         else if (checks.status === "running")
             row("checks", "Checks", "Running", "running");
+        else if (checks.level === "off")
+            row("checks", "Checks", "Off for this project", "none", runChecks === null ? {} : { action: runChecks });
         else if (checks.status === "not-run")
-            row("checks", "Checks", "Didn't run", "none");
+            row("checks", "Checks", "Didn't run", "none", runChecks === null ? {} : { action: runChecks });
         else
             row("checks", "Checks", "Couldn't be read", "note", { action: { label: "Open the result", href: facts.links?.result ?? null } });
     }
@@ -123,7 +142,7 @@ export function taskStatusOf(facts) {
 const CODE_STAGE = {
     queued: ["queued"], ready: ["queued"], "worker-at-capacity": ["queued"], "retry-scheduled": ["queued"], updating: ["queued"],
     "waiting-dependency": ["queued"], "scouting-ready": ["queued"], "planning-ready": ["queued"], "provider-quota": ["queued"], "planner-source": ["queued"],
-    running: ["building"], reviewing: ["building"], "review-pending": ["building"],
+    running: ["building"], reviewing: ["reviewing"], "review-pending": ["building"],
     "signed-out": ["needs-you", "sign-in"],
     "needs-approval": ["needs-you", "approval"],
     "waiting-decision": ["needs-you", "answer"], "decision-queue": ["needs-you", "answer"],
@@ -137,7 +156,7 @@ const CODE_STAGE = {
  * building reason is scheduler wording, and the default sentence is plainer. */
 const QUEUED_REASONS = new Set(["worker-at-capacity", "waiting-dependency", "retry-scheduled", "updating", "planning-ready", "scouting-ready", "provider-quota"]);
 export function plainReasonOf(stage, code, detail) {
-    if (stage === "building" || stage === "checking" || stage === "planning")
+    if (stage === "building" || stage === "checking" || stage === "reviewing" || stage === "planning")
         return null;
     if (stage === "queued")
         return QUEUED_REASONS.has(code) ? detail ?? null : null;
@@ -182,7 +201,7 @@ export function assignmentStageOf(assignment, work, planning = false) {
         case "cancelled": return { stage: "stopped" };
         case "complete": return { stage: "complete" };
         case "ready-to-check": return { stage: "finished" };
-        case "checking": return { stage: "checking" };
+        case "checking": return { stage: assignment.review?.state === "pending" ? "reviewing" : "checking" };
         case "working": {
             const token = work?.token ?? "running";
             const read = stageOfCode(token, { needsPerson: work?.views?.includes("needs-you") ?? false, planning });
@@ -231,14 +250,15 @@ export function assignmentStatusFacts(assignment, options = {}) {
     const withResult = finished || stage === "failed" || (stage === "needs-you" && receipt !== null);
     const report = receipt?.completionKind === "research-report";
     const checks = receipt === null || !withResult ? null
-        : { status: receipt.checks.status, exitCode: receipt.checks.exitCode, head: receipt.head };
+        : { status: receipt.checks.status, exitCode: receipt.checks.exitCode, head: receipt.head,
+            ...(receipt.checks.level == null ? {} : { level: receipt.checks.level }), ...(receipt.checks.running == null ? {} : { running: receipt.checks.running }) };
     const publication = assignment.publication;
     const pullRequest = options.pullRequest !== undefined ? options.pullRequest
         : publication === null ? (withResult && !report ? { state: "none", number: null, url: null, ci: null, error: null } : null)
             : pullRequestFactOf(publication);
     // Ready, Complete and Failed speak for themselves; every other stage keeps its recorded reason.
     const reason = stage === "needs-you" || stage === "stopped" || stage === "queued" || (stage === "failed" && checks?.status !== "failed")
-        ? stage === "stopped" && assignment.state === "cancelled" ? "Cancelled. Nothing else will run." : plainReasonOf(stage, options.work?.token ?? "", options.work?.detail ?? assignment.detail)
+        ? stage === "stopped" && assignment.state === "cancelled" ? REPLACED.test(assignment.detail) ? assignment.detail : "Cancelled. Nothing else will run." : plainReasonOf(stage, options.work?.token ?? "", options.work?.detail ?? assignment.detail)
         : null;
     return {
         stage, ...(need === undefined ? {} : { need }), reason, report,
@@ -246,7 +266,7 @@ export function assignmentStatusFacts(assignment, options = {}) {
         pullRequest: withResult ? pullRequest : null,
         requirements: withResult ? requirementsOf(receipt?.proof?.matrix) : null,
         evidence: withResult ? options.evidence ?? evidenceOf(receipt, [...(receipt?.caveats ?? []), ...assignment.attention]) : null,
-        completedBy: assignment.completion === null ? null : assignment.completion.actor.replace(/^(?:operator|coordinator|lead):/, ""),
+        completedBy: assignment.completion === null ? null : assignment.completion.lead === true ? "the lead" : assignment.completion.actor.replace(/^(?:operator|coordinator|lead):/, ""),
         action: options.action ?? null,
         ...(options.links === undefined ? {} : { links: options.links }),
         why: options.why ?? [],
@@ -307,7 +327,9 @@ export const TASK_STATUS_CSS = `.status-headline{display:flex;align-items:center
  * no assignment. A done task is Complete once a person marked its result;
  * a refuted result whose project check failed is Failed. */
 export function stageOfDispatch(d, options = {}) {
-    if (d.code === "complete" || d.code.startsWith("review-") || d.code === "reviewing")
+    if (d.code === "reviewing")
+        return { stage: "reviewing" };
+    if (d.code === "complete" || d.code.startsWith("review-"))
         return { stage: options.completed ? "complete" : "finished" };
     if (d.code === "proof-refuted")
         return /approved check failed|checks failed/i.test(d.detail ?? "") ? { stage: "failed" } : { stage: "needs-you", need: "other" };

package/dist/team-cli.js

@@ -305,6 +305,9 @@ function render(reply, listing) {
 /** null means preserve the existing local command path. Nothing here opens a database. */
 export async function maybeRunTeamCommand(argv, write, options = {}) {
     const command = argv[0];
+    // `lead token` is local: the credential a lead agent acts with on this computer.
+    if (command === 'lead' && argv[1] === 'token')
+        return null;
     if (!['connect', 'lead', 'conversation', 'chat', 'brief'].includes(command ?? '') && !argv.includes('--profile'))
         return null;
     const json = argv.includes('--json');

package/dist/telegram-status.js

@@ -65,7 +65,7 @@ function groupOf(d) {
     if (d.condition === "running")
         return "Working";
     if (d.code === "cancelled")
-        return "Cancelled";
+        return d.summary.startsWith("Replaced by ") ? "Replaced" : "Cancelled";
     if (d.code === "complete")
         return "Finished";
     if (d.code === "review-pending" || d.action === null)
@@ -105,7 +105,7 @@ export function phoneStatus(store, repos, now, focused = null) {
             lines.push("Newest 60 tasks only — older work may still need attention.", "");
         if (snapshot.tasks.length === 0)
             lines.push("No tasks are recorded in these projects.");
-        for (const group of ["Needs attention", "Working", "Waiting / next up", "Finished", "Cancelled"]) {
+        for (const group of ["Needs attention", "Working", "Waiting / next up", "Finished", "Replaced", "Cancelled"]) {
             const rows = snapshot.tasks.filter(t => t.dispatch !== null && t.dispatch !== undefined && groupOf(t.dispatch) === group);
             if (rows.length === 0)
                 continue;

package/dist/verification-evidence.js

@@ -7,6 +7,7 @@ import { createHash } from "node:crypto";
 import { adjudicate } from "./proof.js";
 import { parseReviewContext, reviewContextCustodyProblem } from "./review-context.js";
 import { readVerifiedArtifact, storeEvidence, scanForSecrets, redactSecretLines } from "./evidence.js";
+import { liveQuickCommand, quickVerifyKey, runCheckLevel } from "./check-levels.js";
 export const VERIFICATION_RECEIPT_CAPTURE = "machine verification receipt v1";
 export const REVIEW_GATE_NAME = "REVIEW-VERIFICATION.json";
 const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
@@ -36,11 +37,15 @@ export function verificationEvidence(store, root, runId) {
     if (!source)
         return fail("The verification source run is missing.");
     const repo = store.refById(source.taskRef)?.repo;
-    const command = repo ? store.liveVerifyCommand(repo) : null;
     const artifacts = store.artifactsFor(runId);
     const receipts = artifacts.filter(isVerificationReceipt);
     const machine = store.proofVerdictFor(runId);
     const verified = (machine?.machineVerdict ?? machine?.verdict) === "verified";
+    // A run whose checks were Off recorded no check; that is not a gap.
+    if (!receipts.length && !verified && runCheckLevel(store, runId) === "off")
+        return { ok: true, bytes: null, digest: hash(null) };
+    // A Quick run is bound to the project's approved quick command, a Full one to the full command.
+    const command = repo ? sealedCommandKey(root, receipts) === quickVerifyKey(repo) ? liveQuickCommand(store, repo) : store.liveVerifyCommand(repo) : null;
     if (!command && !receipts.length && !verified)
         return { ok: true, bytes: null, digest: hash(null) };
     if (!command || command.approvedAt > source.startedAt)
@@ -129,6 +134,21 @@ export function verificationEvidence(store, root, runId) {
     const bytes = JSON.stringify(receipt);
     return { ok: true, bytes, digest: hash({ receipt, receipts }) };
 }
+/** The grant key a run's single sealed receipt names, read without trusting it further. */
+function sealedCommandKey(root, receipts) {
+    if (receipts.length !== 1)
+        return null;
+    const sealed = readVerifiedArtifact(root, receipts[0]);
+    if (!sealed.ok)
+        return null;
+    try {
+        const repo = JSON.parse(sealed.content.toString("utf8")).command?.repo;
+        return typeof repo === "string" ? repo : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Only a sealed failed check can start unattended diagnosis. Lost custody,
  * changed approvals/trees and incomplete evidence still need attention; they
  * must not become another code-writing attempt. Keep the log out of the small

package/dist/webhooks.js

@@ -267,6 +267,11 @@ export async function webhookPass(store, options) {
         return report;
     const claimed = store.claimDeliveries(owner, DELIVERY_CLAIM_MS, clock());
     for (const row of claimed) {
+        // The lead's own work posts to no channel; the console keeps it.
+        if (store.leadQuiet(row)) {
+            store.finalizeDelivery(row.id, owner, { ok: true, receipt: "skipped:quiet" }, clock());
+            continue;
+        }
         const link = linkFor(options.consoleUrl, row);
         const outcomes = await Promise.all(options.targets.map(target => postWebhook(target, row, link, options.fetcher ?? fetch)));
         const failed = outcomes.filter(one => !one.ok);

package/dist/work-index.js

@@ -4,7 +4,9 @@ import { createHash } from 'node:crypto';
 import { readProjectAccess } from './project-access.js';
 import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
 import { scopeTermsProblem } from './store.js';
-import { plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
+import { plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
+import { isCheckLevel } from './check-levels.js';
+import { withFollowUps } from './result-follow-ups.js';
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
 const EMPTY = { all: 0, 'needs-you': 0, running: 0, completed: 0 };
@@ -297,11 +299,15 @@ export function workIndexPage(store, now, access, options = {}) {
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
     'result_role',(SELECT role FROM run WHERE id=page_result_id),'live_role',(SELECT role FROM run WHERE id=page.live_run),
     'check_status',(SELECT status FROM run_check WHERE run=page_result_id),
+    'check_level',(SELECT outcome FROM action_ledger WHERE repo IS page.repo AND run_id=page_result_id AND action='checks used' ORDER BY id DESC LIMIT 1),
+    'check_follows',(SELECT json_group_array(q.outcome||' '||COALESCE((SELECT substr(f.outcome,instr(f.outcome,':')+1) FROM action_ledger f WHERE f.repo IS page.repo AND f.run_id=page_result_id
+      AND f.action='checks finished' AND f.outcome LIKE q.id||':%' LIMIT 1),'open')) FROM (SELECT id,outcome FROM action_ledger WHERE repo IS page.repo AND run_id=page_result_id AND action='checks requested' ORDER BY id) q),
     'proof_verdict',(SELECT COALESCE(machine_verdict,verdict) FROM proof_verdict WHERE run=page_result_id),
     'proof_failed_check',(SELECT verdict='refuted' AND reasons_json LIKE '%approved verification command exited%' FROM proof_verdict WHERE run=page_result_id),'code',code,'needs',needs,'family_running',family_running,'rank',rank,'sort_at',sort_at,
     'checked_actor',checked_actor,'checked_at',checked_at,'checked_digest',checked_digest,'question_id',question_id,
     'dependency_id',dependency_id,'dependency_state',dependency_state,'custody_unresolved',custody_unresolved,'hold_kind',hold_kind,'hold_reason',substr(hold_reason,1,300),'stop_run',stop_run,'unfinished',unfinished,'signed_out',signed_out,
-    'question_run',(SELECT run FROM decision WHERE id=page.question_id),
+    'question_run',(SELECT run FROM decision WHERE id=page.question_id),'replaced_by',(SELECT successor FROM task_replacement WHERE task_ref=page.ref_id),
+    'completed_by_lead',(SELECT lead FROM task_act WHERE task_ref=page.root_ref AND act='completed' ORDER BY id DESC LIMIT 1),
     'question_task',(SELECT r.external_id FROM decision d JOIN run ON run.id=d.run JOIN task_ref r ON r.id=run.task_ref WHERE d.id=page.question_id)) FROM page`)
         .all({ ...parameters(now, access, options), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
     const selected = rows.slice(1).map(row => JSON.parse(String(row['row_json'])));
@@ -320,6 +326,27 @@ export function workCountsByProject(store, now, access) {
 }
 /** Labels stay navigation, never an authorization to mutate. Full task
  * opening re-proves process custody, receipt bytes and approval terms. */
+/** The list's Checks: the build's own result, its level, and follow-up checks on the same commit (result-follow-ups.ts). */
+function listChecksOf(own, level, follows) {
+    let done = [];
+    try {
+        // The row's JSON already holds the list; an older reader may hand over its text.
+        done = (typeof follows === 'string' ? JSON.parse(follows) : Array.isArray(follows) ? follows : []).flatMap(one => {
+            const [ask, said] = String(one).split(' ');
+            if (ask !== 'quick' && ask !== 'full')
+                return [];
+            return [{ level: ask, state: said === 'passed' || said === 'failed' ? said : said === 'open' ? 'waiting' : 'not-run', head: '', exitCode: null }];
+        });
+    }
+    catch {
+        done = [];
+    }
+    const ran = isCheckLevel(level) ? level : null;
+    const read = withFollowUps({ status: own ?? 'not-run', level: ran, exitCode: null, head: null }, done);
+    if (own === null && read.status === 'not-run' && ran !== 'off' && read.running === null)
+        return null;
+    return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
+}
 function itemOf(row, principal) {
     const code = String(row['code']), id = String(row['id']);
     const need = n(row, 'needs') === 1, running = n(row, 'family_running') === 1;
@@ -368,6 +395,12 @@ function itemOf(row, principal) {
     }
     if (code === 'running' && n(row, 'version_count') > 1)
         label = 'Revising';
+    // Replaced, never "Cancelled": the successor is one tap away.
+    const successor = code === 'cancelled' ? s(row, 'replaced_by') : null;
+    if (successor !== null) {
+        detail = `${replacedWords(successor)}.`;
+        actionLabel = `Open ${successor}`;
+    }
     if (code === 'terminal-dependency' && s(row, 'dependency_id') !== null)
         detail = `${s(row, 'dependency_id')} ${s(row, 'dependency_state') === 'cancelled' ? 'was cancelled' : 'failed'} before it finished.`;
     if (code === 'result-needs-attention' && n(row, 'custody_unresolved'))
@@ -382,7 +415,7 @@ function itemOf(row, principal) {
     }
     const read = actionCode !== null && ['inspect-task', 'inspect-run', 'inspect-stop', 'inspect-decisions', 'open-result'].includes(actionCode);
     const primaryAction = actionCode === null ? null : { code: actionCode, label: actionLabel,
-        target: { taskId: code === 'earlier-active' ? s(row, 'earlier_id') ?? id : actionCode === 'answer-decision' ? s(row, 'question_task') ?? id : id,
+        target: { taskId: successor ?? (code === 'earlier-active' ? s(row, 'earlier_id') ?? id : actionCode === 'answer-decision' ? s(row, 'question_task') ?? id : id),
             runId: actionCode === 'answer-decision' ? n(row, 'question_run') || null : actionCode === 'inspect-run' && code === 'running' ? n(row, 'live_run') || null : actionCode === 'open-result' || actionCode === 'inspect-run' ? n(row, 'result_id') || null
                 : actionCode === 'reconcile-run' ? n(row, 'unfinished') || null : ['resume-run', 'inspect-stop'].includes(actionCode) ? n(row, 'stop_run') || null : null,
             decisionId: actionCode === 'answer-decision' ? n(row, 'question_id') || null : null },
@@ -392,11 +425,11 @@ function itemOf(row, principal) {
     const reading = stageOfCode(code, { needsPerson: need, planning: s(row, 'live_role') === 'planner', operatorHold: s(row, 'hold_kind') === 'operator' });
     const checkStatus = s(row, 'check_status'), verdict = s(row, 'proof_verdict');
     const finished = reading.stage === 'finished' || reading.stage === 'complete';
+    const own = checkStatus === 'failed' || n(row, 'proof_failed_check') === 1 ? 'failed' : checkStatus === 'passed' || verdict === 'verified' ? 'passed' : null;
     const shared = taskStatusOf({ stage: reading.stage, ...(reading.need === undefined ? {} : { need: reading.need }),
         reason: finished ? null : plainReasonOf(reading.stage, code, detail || null), report: s(row, 'result_role') === 'scout',
-        checks: !finished ? null : checkStatus === 'failed' || n(row, 'proof_failed_check') === 1 ? { status: 'failed', exitCode: null, head: null }
-            : checkStatus === 'passed' || verdict === 'verified' ? { status: 'passed', exitCode: null, head: null } : null,
-        completedBy: code === 'complete' ? String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, '') : null });
+        checks: !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']),
+        completedBy: code !== 'complete' ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, '') });
     label = shared.headline;
     detail = shared.sentence;
     const views = ['all'];

package/dist/work-summary.d.ts

@@ -1,7 +1,3 @@
-/** Read-only work context shared by console, CLI, and agent adapters.
- * State, decisions, approval, process custody and proof still belong to
- * their existing owners. Action hints are navigation/proposal guidance,
- * never credentials or permission to bypass an owning operation. */
 import { type DispatchAction } from "./dispatch.js";
 import type { Store } from "./store.js";
 import { type DisplayStatus, type WorkFacts, type WorkStatus } from "./workspace-ui.js";

package/dist/work-summary.js

@@ -2,9 +2,11 @@
  * State, decisions, approval, process custody and proof still belong to
  * their existing owners. Action hints are navigation/proposal guidance,
  * never credentials or permission to bypass an owning operation. */
+import { resultCheckLevel } from "./result-follow-ups.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
 import { isAlive } from "./runner.js";
 import { taskControlOf } from "./task-control.js";
+import { buildReviewOf } from "./review-switch.js";
 import { reviewFactsOf, workStatusOf } from "./workspace-ui.js";
 /** Call only after admitting the task's project. Keep the question's
  * exact run and id; never substitute a family's newest attempt. Expiry
@@ -98,10 +100,11 @@ export function taskWorkSummaryOf(store, taskId, now, access) {
         result: result === null ? null : {
             runId: result.id, role: result.role, outcome: result.outcome,
             verdict: proof?.verdict ?? null, reasons: proof?.reasons ?? [], accepted: store.proofAcceptance(result.id) !== null,
+            checkLevel: resultCheckLevel(store, result.id, now),
             review: reviewFactsOf(store.reviewRetryStateOf(result.id), name => {
                 const runner = store.getRunner(name)?.runner;
                 return runner !== undefined && isAlive(runner, now);
-            }),
+            }, buildReviewOf(store, result.id)?.state === "pending"),
             ...(result.outcome !== "no-change" ? {} : { recordComplete: (() => {
                     const kinds = new Set(store.artifactsFor(result.id).map(one => one.kind));
                     return kinds.has("handoff") && kinds.has("terminal-diff");