toolroll 0.9.5 → 0.9.7

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 ## Unreleased
 
+## 0.9.7 — 2026-10-01
+
+- **Onboarding without a password or a form.** `toolroll up` prints three
+  lines and opens the console already signed in, through a one-time link that
+  works once, for ten minutes, from this computer only. The lead turns on by
+  itself with the agent that's signed in (Claude Code, else Codex); the old
+  setup form moved to Settings → Lead → Advanced. With no agent signed in,
+  Chat shows the command to install and sign in, and checks again on its own.
+  A short "how it works", a live Plan → Ready timeline on your first task, a
+  card for pairing your phone, and a "wrong host" page that says what to run.
+- **The task page is one conversation.** The status stays on top; below it
+  the plan, the agent's notes and results, questions and your replies, in
+  order, ending in a box to message the agent (Build, Plan only, or Just
+  answer). Details (scope, attempts, audit) moved to a side panel, or a sheet
+  on phones. The Chat home shows who is working now and four counts, and
+  Catch up and the Inbox have tabs: Needs you, Ready, Running, All.
+- **Checks: quick while building, easy to turn off.** Each project has a
+  check level: Quick (the default for new projects), Full or Off, and a task
+  can override it ("skip the tests"). With checks Off a result is still
+  Ready for review, and says no check ran. Any result can run its checks again or file a task to add tests.
+- **A flow gallery, and flows as files.** Flows → New is a gallery of
+  templates grouped by what they're for, with new ones for developers
+  (Overnight bug bash, Flaky test hunter, Release notes writer, Docs follow
+  the code, Error to fix, PR second opinion and more). Export any flow as a
+  `.toolroll-flow.json` file and import one from a file or a link, with a
+  preview; secrets never leave, and imported triggers start switched off.
+- **Several builds at once on one project.** The service builds up to two
+  tasks of a project at a time (Settings → Projects, `toolroll project
+  concurrency`), within the machine's limit. Stopping the service mid-build
+  saves the work and resumes it next time.
+- **The lead's housekeeping stays quiet.** An agent acting as your lead gets
+  its own credential (`toolroll lead token`); its work pings nobody unless it
+  hands something to you. Your own actions never ping you, a replaced task
+  reads "Replaced by", and a whole project can be muted.
+- **A faster release check.** Flow journeys run in parallel groups, browser
+  journeys are rebalanced, and a version-only bump no longer forces every
+  test.
+
+## 0.9.6 — 2026-10-01
+
+- **Every task's status, clear at a glance.** One headline from a fixed set
+  (Queued, Planning, Needs you, Building, Ready for review, Complete, Failed,
+  Stopped) and one plain sentence, the same words on the Tasks list, the task
+  page, the result, Crew, the Telegram/Slack/Discord/Teams card and
+  `toolroll status`. Checks, the pull request, requirements and saved
+  evidence sit underneath as quiet rows. A pull request that couldn't open
+  is an amber note with one action, never a red chip beside Complete: red
+  now means only Failed. The exact technical reason stays under Details.
+
 ## 0.9.5 — 2026-10-01
 
 - **A demo you can feel in 90 seconds.** In `npx toolroll demo`, Chat has a

package/dist/actor.d.ts

@@ -0,0 +1,21 @@
+export type Actor = {
+    account: string;
+    lead: boolean;
+};
+/** Run `fn` with this actor (or an empty slot a verified sign-in may fill). */
+export declare function withActor<T>(actor: Actor | null, fn: () => T): T;
+export declare function currentActor(): Actor | null;
+/** A person verified their password inside this command: their acts are now theirs. A lead keeps its own label. */
+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

@@ -0,0 +1,48 @@
+/**
+ * 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
+ * <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.
+ *
+ * The actor is held for one command or one console request, never for a
+ * 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). */
+export function withActor(actor, fn) {
+    return slot.run({ actor }, fn);
+}
+export function currentActor() {
+    return slot.getStore()?.actor ?? null;
+}
+/** A person verified their password inside this command: their acts are now theirs. A lead keeps its own label. */
+export function claimActor(account) {
+    const held = slot.getStore();
+    if (held !== undefined && held.actor === null)
+        held.actor = { account, lead: false };
+}
+/** How the ledger names an actor. */
+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/assignment-adapters.d.ts

@@ -117,6 +117,7 @@ export declare function assignmentForCoordinator(store: Store, token: string, op
                     actor: string;
                     at: string;
                     digest: string;
+                    lead?: true;
                 } | null;
                 result: {
                     digest: string;

package/dist/assignment-presentation.d.ts

@@ -3,6 +3,7 @@
  * checks, approvals, ownership, or the exact completion identity. */
 import type { AssignmentSnapshot } from './assignment.js';
 import { type DisplayStatus, type WorkStatus } from './workspace-ui.js';
+import { type PullRequestFact, type StatusAction, type TaskStatus, type TaskStatusFacts } from './task-status.js';
 export type AssignmentWorkStatus = DisplayStatus & Partial<Pick<WorkStatus, 'views' | 'rank'>>;
 export type AssignmentAttention = {
     id: string;
@@ -14,12 +15,22 @@ export type AssignmentAttention = {
 export declare function historicalAssessmentReason(reason: string): boolean;
 /** Known storage-cap notices do not mean the retained bytes are damaged. */
 export declare function shortenedMaterialReason(detail: string): boolean;
-export declare function assignmentPresentationOf(assignment: AssignmentSnapshot, options?: {
+export type AssignmentStatusOptions = {
     workStatus?: AssignmentWorkStatus;
     diagnostics?: WorkStatus['diagnostics'];
     additionalAttention?: readonly string[];
-}): {
+    /** A live planner rather than a builder holds the work. */
+    planning?: boolean;
+    pullRequest?: PullRequestFact | null;
+    action?: StatusAction | null;
+    links?: TaskStatusFacts['links'];
+    evidence?: TaskStatusFacts['evidence'];
+};
+/** The one shared status (task-status.ts) for this assignment. */
+export declare function assignmentTaskStatusOf(assignment: AssignmentSnapshot, options?: AssignmentStatusOptions): TaskStatus;
+export declare function assignmentPresentationOf(assignment: AssignmentSnapshot, options?: AssignmentStatusOptions): {
     status: WorkStatus;
+    taskStatus: TaskStatus;
     primaryAction: import("./work-summary.js").WorkAction | null;
     attention: AssignmentAttention[];
     diagnostics: Pick<DisplayStatus, "detail" | "label" | "token" | "tone">[];

package/dist/assignment-presentation.js

@@ -1,9 +1,6 @@
 import { GOAL_ASSESSMENT_PENDING, manualReviewCriterionOf } from './proof.js';
 import { failedCheckExit } from './workspace-ui.js';
-const LABELS = {
-    working: 'Working', checking: 'Checking', 'needs-decision': 'Needs your decision',
-    'ready-to-check': 'Ready', complete: 'Complete', cancelled: 'Cancelled',
-};
+import { assignmentStatusFacts, taskStatusOf, workToneOf } from './task-status.js';
 /** Only the retired assessment requirement is history-only. Specific missing
  * material, defects and failed checks remain visible, including reviewer findings. */
 export function historicalAssessmentReason(reason) {
@@ -19,13 +16,29 @@ export function shortenedMaterialReason(detail) {
         detail === 'The changed-file list was cut short; the counts are complete.' ||
         /^Saved (?:terminal-diff|report) #\d+ is incomplete\.$/.test(detail);
 }
+/** The one shared status (task-status.ts) for this assignment. */
+export function assignmentTaskStatusOf(assignment, options = {}) {
+    const work = options.workStatus;
+    return taskStatusOf(assignmentStatusFacts(assignment, {
+        work: work === undefined ? null : { token: work.token, ...(work.views === undefined ? {} : { views: work.views }), detail: work.detail },
+        ...(options.planning === undefined ? {} : { planning: options.planning }),
+        ...(options.pullRequest === undefined ? {} : { pullRequest: options.pullRequest }),
+        ...(options.action === undefined ? {} : { action: options.action }),
+        ...(options.links === undefined ? {} : { links: options.links }),
+        ...(options.evidence === undefined ? {} : { evidence: options.evidence }),
+    }));
+}
 export function assignmentPresentationOf(assignment, options = {}) {
     const { state } = assignment, work = options.workStatus;
+    const taskStatus = assignmentTaskStatusOf(assignment, options);
+    // The headline and its sentence are the shared words; the token, views and
+    // rank stay the existing projection's (pages and tests key off them).
+    const shared = { label: taskStatus.headline, tone: workToneOf(taskStatus.headline), detail: taskStatus.sentence, action: null };
+    const needsYou = taskStatus.headline === 'Needs you';
     const status = state === 'working'
-        ? { ...(work ?? { label: LABELS[state], tone: 'muted' }), token: `assignment-${state}`,
-            detail: assignment.detail, action: null, views: work?.views?.filter(view => view !== 'completed') ?? ['all'], rank: work?.rank ?? 2 }
-        : { token: `assignment-${state}`, label: state === 'checking' ? work?.label ?? LABELS[state] : LABELS[state], detail: assignment.detail,
-            action: null, tone: state === 'needs-decision' ? 'attention' : state === 'checking' ? work?.tone ?? 'live' : state === 'ready-to-check' ? 'ready' : state === 'complete' ? 'done' : 'muted',
+        ? { ...shared, token: `assignment-${state}`,
+            views: [...new Set([...(work?.views?.filter(view => view !== 'completed') ?? ['all']), ...(needsYou ? ['needs-you'] : [])])], rank: needsYou ? 0 : work?.rank ?? 2 }
+        : { ...shared, token: `assignment-${state}`,
             views: state === 'ready-to-check' || state === 'needs-decision' ? ['all', 'needs-you'] : state === 'complete' ? ['all', 'completed']
                 : state === 'checking' && work?.views?.includes('running') ? ['all', 'running'] : ['all'],
             rank: state === 'needs-decision' || state === 'ready-to-check' ? 0 : state === 'checking' ? 1 : state === 'complete' ? 3 : 4 };
@@ -78,5 +91,5 @@ export function assignmentPresentationOf(assignment, options = {}) {
             return false;
         return true;
     });
-    return { status, primaryAction: assignment.primaryAction, attention: [...attention.values()], diagnostics };
+    return { status, taskStatus, primaryAction: assignment.primaryAction, attention: [...attention.values()], diagnostics };
 }

package/dist/assignment-ui.d.ts

@@ -2,7 +2,8 @@
  * existing projections and signed operating-mode terms, never this renderer. */
 import type { AssignmentSnapshot } from './assignment.js';
 import type { DisplayStatus, StatusTone, WorkStatus } from './workspace-ui.js';
-import { type AssignmentWorkStatus } from './assignment-presentation.js';
+import { type AssignmentStatusOptions, type AssignmentWorkStatus } from './assignment-presentation.js';
+import { type PullRequestFact, type TaskStatus } from './task-status.js';
 /** The existing verified receipt reader may discover damage after a verdict
  * was saved. Keep the limitation visible without inventing another work stage. */
 export declare function assignmentWithEvidence(assignment: AssignmentSnapshot, resultStatus: DisplayStatus | null, resultRunId?: number | null): AssignmentSnapshot;
@@ -19,38 +20,32 @@ export type AssignmentAttemptRow = {
 /** Every version of the assignment, oldest first, as the card lists them. */
 export declare function assignmentAttemptsOf(assignment: AssignmentSnapshot): AssignmentAttemptRow[];
 export declare function assignmentAttemptsHtml(assignment: AssignmentSnapshot): string;
-type AssignmentCardOptions = {
+type AssignmentCardOptions = Omit<AssignmentStatusOptions, 'links'> & {
     hideAction?: boolean;
     problem?: boolean;
-    diagnostics?: WorkStatus['diagnostics'];
-    workStatus?: AssignmentWorkStatus;
     resultHref?: string;
+    pullRequest?: PullRequestFact | null;
 };
 /** The status card's content: one projection for the server HTML and the
- * rebuilt task page, so the two never word the same state differently. */
+ * rebuilt task page, so the two never word the same state differently. The
+ * headline, sentence and detail rows are the shared task status; the exact
+ * recorded reasons stay one tap away under Details, never as red text. */
 export type AssignmentCard = {
     token: string;
     tone: StatusTone;
     label: string;
+    status: TaskStatus;
     action: {
         label: string;
         href: string;
         openResult: boolean;
     } | null;
-    /** Ready with passing checks: a verdict chip replaces the detail sentence. */
-    passed: {
-        by: string | null;
-    } | null;
-    detail: {
-        text: string;
-        problem: boolean;
-    };
-    problems: string[];
+    /** Exact technical reasons and diagnostics, shown on request. */
+    reasons: string[];
     diagnostics: {
         token: string;
         label: string;
         detail: string;
-        problem: boolean;
     }[];
     notices: {
         summary: string;

package/dist/assignment-ui.js

@@ -1,5 +1,7 @@
 import { assignmentPresentationOf, shortenedMaterialReason } from './assignment-presentation.js';
 import { plainReasonWords } from './proof.js';
+import { chatResultHref } from './chat-controls.js';
+import { statusDetailsHtml, statusWhyHtml } from './task-status.js';
 const escape = (value) => value.replace(/[&<>"']/g, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[char]);
 /** The existing verified receipt reader may discover damage after a verdict
  * was saved. Keep the limitation visible without inventing another work stage. */
@@ -63,25 +65,25 @@ function savedMaterialNotice(detail, assignment) {
         !assignment.receipt.artifacts.some(one => one.id === Number(earlier[1])) ? 'history' : null;
 }
 export function assignmentCardOf(assignment, options = {}) {
-    const presentation = assignmentPresentationOf(assignment, options);
-    const { status, diagnostics } = presentation;
+    const receipt = assignment.receipt;
+    const links = receipt === null ? {} : { result: options.resultHref ?? chatResultHref(receipt.taskId, receipt.runId), checks: chatResultHref(receipt.taskId, receipt.runId, 'checks'),
+        pullRequest: `/t/${encodeURIComponent(assignment.rootId)}#merge`,
+        // Run checks lives with the result's checks; the row's action leads there.
+        ...(receipt.completionKind === 'research-report' ? {} : { runChecks: `${chatResultHref(receipt.taskId, receipt.runId, 'checks')}#follow-ups` }) };
+    const presentation = assignmentPresentationOf(assignment, { ...options, links });
+    const { status, diagnostics, taskStatus } = presentation;
     const href = assignment.primaryAction?.code === 'open-result' && options.resultHref !== undefined ? options.resultHref : assignmentActionHref(assignment);
     const attention = presentation.attention.map(one => one.detail);
     const notices = [...attention, ...diagnostics.map(one => one.detail)].filter(one => savedMaterialNotice(one, assignment) !== null);
     const partial = notices.some(one => savedMaterialNotice(one, assignment) === 'partial');
     const history = notices.some(one => savedMaterialNotice(one, assignment) === 'history');
-    const ready = assignment.state === "ready-to-check" || assignment.state === "complete";
-    const checkProblem = ready && assignment.receipt !== null && assignment.receipt.completionKind !== 'research-report' && assignment.receipt.checks.status !== 'passed';
+    const recorded = assignment.detail === taskStatus.sentence || taskStatus.headline === 'Ready for review' || taskStatus.headline === 'Complete' ? [] : [assignment.detail];
     return {
-        token: status.token, tone: status.tone, label: status.label,
+        token: status.token, tone: status.tone, label: status.label, status: taskStatus,
         action: options.hideAction || href === null ? null : { label: assignment.primaryAction.label, href, openResult: options.resultHref !== undefined },
-        // A good outcome at a glance; the same words stay in the result.
-        passed: ready && !checkProblem && assignment.receipt !== null && assignment.receipt.checks.status === 'passed'
-            ? { by: assignment.completion === null ? null : assignment.completion.actor.replace(/^(?:operator|coordinator|lead):/, '') } : null,
-        detail: { text: assignment.detail, problem: checkProblem || options.problem === true && !ready },
-        problems: attention.filter(one => savedMaterialNotice(one, assignment) === null).map(plainReasonWords),
+        reasons: [...new Set([...recorded, ...attention.filter(one => savedMaterialNotice(one, assignment) === null).map(plainReasonWords)])].filter(one => one !== taskStatus.sentence),
         diagnostics: diagnostics.filter(one => savedMaterialNotice(one.detail, assignment) === null)
-            .map(one => ({ token: one.token, label: one.label, detail: one.detail, problem: one.tone === 'problem' || one.tone === 'attention' })),
+            .map(one => ({ token: one.token, label: one.label, detail: one.detail })),
         notices: notices.length === 0 ? null : { summary: [partial ? 'Saved output is partial' : '', history ? 'Earlier material unavailable' : ''].filter(Boolean).join(' · '), lines: [...new Set(notices)] },
         attempts: assignmentAttemptsOf(assignment),
         lead: assignment.owner === null ? null : { label: assignment.owner.label, active: assignment.owner.active },
@@ -89,14 +91,13 @@ export function assignmentCardOf(assignment, options = {}) {
 }
 export function assignmentSummaryHtml(assignment, options = {}) {
     const card = assignmentCardOf(assignment, options);
-    return `<section class="${options.compact ? 'assignment-summary' : 'card assignment-summary'}" aria-label="assignment progress" data-assignment="${escape(assignment.rootId)}" data-work-status="${card.token}" data-tone="${card.tone}"${options.compact ? '' : ' data-task-status'}>` +
-        (options.compact ? `<span class="status-line" data-work-status="${card.token}" data-tone="${card.tone}"><i class="status-dot" aria-hidden="true"></i><span class="status-label">${card.label}</span></span>` : `<h2 class="assignment-state">${card.label}</h2>`) +
+    const tone = card.status.tone;
+    return `<section class="${options.compact ? 'assignment-summary' : 'card assignment-summary'}" aria-label="assignment progress" data-assignment="${escape(assignment.rootId)}" data-work-status="${card.token}" data-tone="${card.tone}" data-headline="${escape(card.status.headline)}" data-headline-tone="${tone}"${options.compact ? '' : ' data-task-status'}>` +
+        (options.compact ? `<span class="status-line" data-work-status="${card.token}" data-tone="${card.tone}"><i class="status-dot" aria-hidden="true"></i><span class="status-label">${card.label}</span></span>` : `<h2 class="assignment-state status-headline"><i aria-hidden="true"></i>${escape(card.label)}</h2>`) +
+        `<p class="meta assignment-detail status-sentence">${escape(card.status.sentence)}</p>` +
         (card.action === null ? '' : `<a class="${options.compact ? 'work-action' : 'button-link'}" href="${escape(card.action.href)}"${card.action.openResult ? ' data-open-result' : ''}${options.compact ? '' : ' data-primary-action'}>${escape(card.action.label)}${options.compact ? ' →' : ''}</a>`) +
-        (!options.compact && card.passed !== null
-            ? `<p class="meta assignment-detail assignment-verdict"><span class="verdict-chip verdict-chip--success">Checks passed</span>${card.passed.by === null ? '' : ` Completed by ${escape(card.passed.by)}`}</p>`
-            : `<p class="${card.detail.problem ? 'problem' : 'meta'} assignment-detail">${escape(card.detail.text)}</p>`) +
-        card.problems.map(one => `<p class="problem">${escape(one)}</p>`).join('') +
-        card.diagnostics.map(one => `<p class="${one.problem ? 'problem' : 'meta'}" data-work-diagnostic="${escape(one.token)}">${escape(one.label)} · ${escape(one.detail)}</p>`).join('') +
+        (options.compact ? '' : statusDetailsHtml(card.status)) +
+        statusWhyHtml(card.status, card.reasons, card.diagnostics) +
         (card.notices === null ? '' : `<details class="assignment-notices"><summary>${card.notices.summary}</summary>${card.notices.lines.map(one => `<p class="meta">${escape(one)}</p>`).join('')}</details>`) +
         assignmentAttemptsHtml(assignment) + `</section>`;
 }

package/dist/assignment.d.ts

@@ -1,6 +1,7 @@
 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 CheckLevel } from "./check-levels.js";
 export type AssignmentAccess = WorkSummaryAccess;
 export type AssignmentOwner = {
     kind: "coordinator" | "lead";
@@ -13,6 +14,10 @@ export type AssignmentChecks = {
     command: string | null;
     logArtifactId: number | null;
     detail: string;
+    /** Which check this is (check-levels.ts): quick, full, or off; null before levels. */
+    level?: CheckLevel | null;
+    /** A follow-up check waiting or running on this commit. */
+    running?: "quick" | "full" | null;
 };
 export type AssignmentReceipt = {
     digest: string;
@@ -70,10 +75,12 @@ export type AssignmentSnapshot = {
             problem: string | null;
         }[];
     };
+    /** `lead`: marked complete by the person's lead (`toolroll lead token`), shown as "by the lead". */
     completion: {
         actor: string;
         at: string;
         digest: string;
+        lead?: true;
     } | null;
     handoff: {
         kind: "result" | "decision" | "attention";
@@ -112,6 +119,7 @@ export declare function assignmentBrief(assignment: AssignmentSnapshot | null):
         actor: string;
         at: string;
         digest: string;
+        lead?: true;
     } | null;
     result: {
         digest: string;
@@ -189,6 +197,7 @@ export declare function assignmentUpdates(store: Store, now: Date, access: Assig
                 actor: string;
                 at: string;
                 digest: string;
+                lead?: true;
             } | null;
             result: {
                 digest: string;

package/dist/assignment.js

@@ -2,6 +2,8 @@
  * approval or proof state. Lead ownership and exact receipt acknowledgments
  * are append-only actions; handoffs use the existing durable outbox. */
 import { createHash } from "node:crypto";
+import { currentActor, withActor } from "./actor.js";
+import { replacedWords } from "./task-status.js";
 import { COMPLETION_ACTION, familyChangedFiles } from "./result-completion.js";
 import { homedir } from "node:os";
 import { readSchemaVersion } from "./store.js";
@@ -12,6 +14,8 @@ import { verificationEvidence } from "./verification-evidence.js";
 import { reproveApprover } from "./principal.js";
 import { noteAssignmentStatus } from "./assignment-status.js";
 import { historicalAssessmentReason } from "./assignment-presentation.js";
+import { runCheckLevel } from "./check-levels.js";
+import { followUpChecksOf, withFollowUps } from "./result-follow-ups.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. */
 export function assignmentBrief(assignment) {
@@ -28,6 +32,20 @@ export function assignmentBrief(assignment) {
         publication: assignment.publication, deployment: assignment.deployment };
 }
 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
+ * store, before this version's migration, so the method (or its table) may not exist yet. Absent reads as none. */
+function olderStoreSafe(read, absent) {
+    try {
+        return read();
+    }
+    catch (error) {
+        if (error instanceof TypeError || /no such (table|column)/.test(String(error)))
+            return absent;
+        throw error;
+    }
+}
+/** A check as the receipt digest seals it: presentation-only fields (check-levels.ts) left out. */
+const sealedChecks = ({ level: _level, running: _running, ...proof }) => proof;
 const OWNER_ACTION = "assignment claimed";
 const CHECK_ACTION = COMPLETION_ACTION;
 const actorOf = (owner) => `${owner.kind}:${owner.id}`;
@@ -58,8 +76,24 @@ function ownerOf(store, rootId, repo) {
         active: credential !== undefined && credential["revoked_at"] === null && repo !== null && Array.isArray(repos) && repos.includes(repo) };
 }
 // Report the recorded check outcome, never turn a model verdict into a check.
-function nativeChecks(store, root, runId) {
-    const unavailable = (detail) => ({ status: "unavailable", exitCode: null, command: null, logArtifactId: null, detail });
+// Follow-up checks on the same commit (Run checks) upgrade a pass and show a failure.
+function nativeChecks(store, root, runId, now) {
+    const own = buildChecks(store, root, runId);
+    const run = store.getRun(runId);
+    const followUps = followUpChecksOf(store, runId, now, root);
+    if (followUps.length === 0)
+        return own;
+    const read = withFollowUps({ status: own.status, level: own.level ?? null, exitCode: own.exitCode, head: run?.headRevision ?? null }, followUps);
+    const latest = [...followUps].reverse().find(one => one.state === "passed" || one.state === "failed");
+    const changed = read.status !== own.status || read.level !== (own.level ?? null) || read.exitCode !== own.exitCode;
+    const words = read.level === "quick" ? "Quick checks" : "Checks";
+    return { ...own, running: read.running,
+        ...(changed ? { status: read.status, level: read.level, exitCode: read.exitCode, logArtifactId: latest?.logArtifactId ?? own.logArtifactId,
+            detail: read.status === "passed" ? `${words} passed.` : `${words} failed (exit ${read.exitCode}).` } : {}) };
+}
+function buildChecks(store, root, runId) {
+    const level = runCheckLevel(store, runId);
+    const unavailable = (detail) => ({ status: "unavailable", exitCode: null, command: null, logArtifactId: null, detail, level });
     if (root === undefined)
         return unavailable("Saved checks are unavailable.");
     try {
@@ -68,11 +102,14 @@ function nativeChecks(store, root, runId) {
             return unavailable(gate.problem);
         const receipt = gate.bytes === null ? null : JSON.parse(gate.bytes);
         if (receipt === null)
-            return { ...unavailable("No machine check is recorded."), status: "not-run" };
+            return { ...unavailable(level === "off" ? "Checks were off for this build." : "No machine check is recorded."), status: "not-run" };
         const ran = receipt.result.ran === true, exitCode = ran ? receipt.result.exitCode : null;
+        // The sealed receipt names the grant that ran: the quick one, or the full one.
+        const sealedLevel = typeof receipt.command?.repo === "string" && receipt.command.repo.startsWith("quick:") ? "quick" : "full";
+        const words = sealedLevel === "quick" ? "Quick checks" : "Checks";
         return { status: ran ? exitCode === 0 ? "passed" : "failed" : "not-run", exitCode,
-            command: receipt.command.command, logArtifactId: receipt.log.artifactId,
-            detail: ran ? exitCode === 0 ? "Checks passed." : `Checks failed (exit ${exitCode}).` : "Checks did not finish." };
+            command: receipt.command.command, logArtifactId: receipt.log.artifactId, level: level === null ? null : sealedLevel,
+            detail: ran ? exitCode === 0 ? `${words} passed.` : `${words} failed (exit ${exitCode}).` : `${words} did not finish.` };
     }
     catch {
         return unavailable("Saved checks could not be read.");
@@ -112,7 +149,7 @@ 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 : nativeChecks(store, root, result.id);
+    const checks = result === null ? null : nativeChecks(store, root, result.id, now);
     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
@@ -133,7 +170,11 @@ export function assignmentOf(store, taskId, now, access, root) {
             ...artifacts.filter(a => a.kind !== "check-log" && (a.truncated || a.captureStatus === "failed")).map(a => `Saved ${a.kind} #${a.id} is ${a.captureStatus === "failed" ? "a failed capture" : "incomplete"}.`)],
         agentReport: result.handoff, evidence: "recorded",
     };
-    const receipt = receiptBody === null ? null : { ...receiptBody, digest: digest({ receipt: receiptBody,
+    // The digest seals the proof, not how it is shown: the check's `level` (read from its sealed command) and `running`
+    // (a follow-up in flight) stay out of it, so a result completed before check levels keeps its completion, and a
+    // follow-up check that is still running never unseals one.
+    const sealedBody = receiptBody === null ? null : { ...receiptBody, checks: sealedChecks(receiptBody.checks) };
+    const receipt = receiptBody === null ? null : { ...receiptBody, digest: digest({ receipt: sealedBody,
             scope: scope === null ? null : { digest: scope.digest, approved: approvalOf(scope).approved, termsProblem: scope.termsProblem ?? null },
             versions: family.versions.map(v => ({ id: v.id, state: v.state })) }) };
     let completion = null;
@@ -154,8 +195,10 @@ export function assignmentOf(store, taskId, now, access, root) {
         state = "needs-decision";
     else if (current.state === "cancelled") {
         state = "cancelled";
-        detail = "This assignment was cancelled.";
-        primaryAction = { code: "inspect-task", label: "View assignment", target: { taskId: current.id, runId: null, decisionId: null }, access: "read", retry: "read-again" };
+        const successor = olderStoreSafe(() => store.replacementOf(current.id) ?? store.replacementOf(family.root.id), null);
+        detail = successor === null ? "This assignment was cancelled." : `${replacedWords(successor)}.`;
+        primaryAction = successor === null ? { code: "inspect-task", label: "View assignment", target: { taskId: current.id, runId: null, decisionId: null }, access: "read", retry: "read-again" }
+            : { code: "inspect-task", label: `Open ${successor}`, target: { taskId: successor, runId: null, decisionId: null }, access: "read", retry: "read-again" };
     }
     else if (!live && processProblem !== null && result !== null) {
         state = "needs-decision";
@@ -182,10 +225,12 @@ export function assignmentOf(store, taskId, now, access, root) {
         // membership changes and ownership transfer cannot revoke past completion.
         // The exact result digest still fences changes to work, scope and history.
         if (checked !== undefined) {
-            completion = { actor: String(checked["actor"]), at: String(checked["at"]), digest: receipt.digest };
+            const rootRef = store.lookupRef(family.root.id);
+            const byLead = rootRef !== null && olderStoreSafe(() => store.taskActs(rootRef.id), []).filter(one => one.act === "completed").at(-1)?.lead === true;
+            completion = { actor: String(checked["actor"]), at: String(checked["at"]), digest: receipt.digest, ...(byLead ? { lead: true } : {}) };
             state = "complete";
             primaryAction = { ...primaryAction, label: completionKind === "research-report" ? "Read report" : "Open result" };
-            const label = completion.actor.startsWith("operator:") ? completion.actor.slice(9) : owner && completion.actor === actorOf(owner) ? owner.label : "the previous lead";
+            const label = byLead ? "the lead" : completion.actor.startsWith("operator:") ? completion.actor.slice(9) : owner && completion.actor === actorOf(owner) ? owner.label : "the previous lead";
             detail = completionKind === "research-report" ? `Research report checked by ${label}. No deployment is implied.`
                 : `Handled by ${label}. ${receipt.checks.detail} Publication and deployment are separate.`;
         }
@@ -316,6 +361,9 @@ function acknowledgeCurrent(store, current, receiptDigest, actor, now, root, acc
             return { ok: false, reason: "approval-rules", message: problem };
         store.recordAction({ at: now.toISOString(), actor, repo: current.repo,
             taskId: current.rootId, runId: receipt.runId, action: CHECK_ACTION, outcome: receiptDigest, source: "work" });
+        const ref = store.lookupRef(current.rootId);
+        if (ref !== null)
+            store.noteTaskAct(ref.id, "completed", now);
         store.bumpWake();
     }
     const assignment = assignmentOf(store, current.rootId, now, access, root);
@@ -335,7 +383,8 @@ export function checkAssignment(store, taskId, receiptDigest, owner, now, root =
 /** The signed-in user can mark the same exact receipt handled without taking
  * lead ownership. This records review, never check success or new authority. */
 export function checkAssignmentAsOperator(store, taskId, receiptDigest, who, now, root = evidenceRoot(homedir())) {
-    return store.transact(() => {
+    // Completing is this person's act (or their lead's): it never pings them.
+    return withActor(currentActor() ?? { account: who.name, lead: false }, () => store.transact(() => {
         if (!reproveApprover(store, who).ok)
             return { ok: false, reason: "unauthenticated", message: "Sign in again before marking this result complete." };
         const access = { principal: "operator", repos: who.repos };
@@ -343,7 +392,7 @@ export function checkAssignmentAsOperator(store, taskId, receiptDigest, who, now
         if (current === null || !store.accountCanAccess(who.name, current.repo))
             return { ok: false, reason: "not-found", message: "No assignment is available in your projects." };
         return acknowledgeCurrent(store, current, receiptDigest, `operator:${who.name}`, now, root, access);
-    });
+    }));
 }
 function noteAssignmentHandoff(store, assignment, now) {
     if (!assignment.owner?.active || assignment.handoff === null || assignment.handoff.acknowledged)