toolroll 0.9.6 → 0.9.7

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" }],
@@ -289,7 +310,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 +330,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"),
@@ -340,8 +362,9 @@ export const COMMAND_GUIDE = [
     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";
@@ -45,6 +47,10 @@ 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 +85,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[];

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",
@@ -11,7 +14,13 @@ export function headlineOf(facts) {
         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 "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";
@@ -31,8 +40,10 @@ function sentenceOf(headline, facts) {
         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 +55,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 +69,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 } });
     }
@@ -231,14 +248,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 +264,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 ?? [],

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,6 +2,7 @@
  * 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";
@@ -98,6 +99,7 @@ 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);

package/dist/workspace-ui.d.ts

@@ -43,6 +43,9 @@ export type ResultFacts = {
     /** A no-change conclusion's two presence facts (handoff + sealed diff);
      * undefined when the caller did not read them. */
     recordComplete?: boolean;
+    /** The check level this result now stands at (check-levels.ts): Off reads
+     * Ready for review, saying no check ran, until a follow-up check passes. */
+    checkLevel?: "quick" | "full" | "off" | null;
     /** This exact run's independent review (v50 retry projection), read
      * per run so an older selected result keeps its own words; undefined
      * when the caller did not read it, null when never requested. */

package/dist/workspace-ui.js

@@ -327,9 +327,11 @@ export function workStatusOf(facts, resultDisplay) {
     const read = done ? RESULT_NEEDS_YOU.has(status.token) ? { stage: "needs-you", need: "other" } : stageOfCode(status.token, { needsPerson: false })
         : stageOfCode(status.token, { needsPerson: status.views.includes("needs-you"), planning: facts.dispatch?.code === "running" && facts.dispatch.role === "planner", operatorHold: facts.dispatch?.action === "unhold" });
     const stage = done && read.stage !== "needs-you" && read.stage !== "failed" ? "finished" : read.stage;
+    const level = facts.result?.checkLevel ?? null;
     const shared = taskStatusOf({ stage, ...(read.need === undefined ? {} : { need: read.need }), reason: plainReasonOf(stage, status.token, status.detail),
-        report: facts.result?.role === "scout", checks: stage === "finished" && VERIFIED_RESULT.has(status.token) ? { status: "passed", exitCode: null, head: null } : null });
-    return { ...status, label: shared.headline, tone: workToneOf(shared.headline), detail: stage === "finished" ? status.detail : shared.sentence };
+        report: facts.result?.role === "scout", checks: stage !== "finished" ? null : VERIFIED_RESULT.has(status.token) ? { status: "passed", exitCode: null, head: null, level }
+            : level === "off" ? { status: "not-run", exitCode: null, head: null, level } : null });
+    return { ...status, label: shared.headline, tone: workToneOf(shared.headline), detail: stage === "finished" && level !== "off" ? status.detail : shared.sentence };
 }
 function workStatusWordsOf(facts, resultDisplay) {
     const dispatch = facts.dispatch;
@@ -372,7 +374,7 @@ function workStatusWordsOf(facts, resultDisplay) {
         return { ...result, views, rank: needs ? 0 : 3 };
     }
     if (facts.state === "cancelled") {
-        return { token: "cancelled", label: "Cancelled", detail: dispatch?.detail ?? "Nothing else will run for this task.", tone: "muted", action: null, views, rank: 4 };
+        return { token: "cancelled", label: dispatch?.summary.startsWith("Replaced by ") ? dispatch.summary : "Cancelled", detail: dispatch?.detail ?? "Nothing else will run for this task.", tone: "muted", action: null, views, rank: 4 };
     }
     if (question !== null && facts.state !== "failed" && dispatch !== null && QUESTION_FIRST.has(dispatch.code)) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"