toolroll 0.9.5 → 0.9.7

package/dist/telegram-status.js

@@ -3,6 +3,8 @@ import { manualReviewOnly } from "./proof.js";
 /** Read-only phone views over the same dispatch and proof records as chat.
  * No provider calls, repository access, new workflow state, or inferred success. */
 import { diagnoseTaskDispatch, withDispatchDiagnoses } from "./dispatch.js";
+import { COMPLETION_ACTION } from "./result-completion.js";
+import { plainReasonOf, stageOfDispatch, taskStatusOf } from "./task-status.js";
 import { CHAT_CONTROLS, chatControlHref, chatResultHref } from "./chat-controls.js";
 export function phoneCommand(text) {
     // Slash forms everywhere; the bare words too, because Slack and Discord
@@ -50,11 +52,20 @@ export const phoneText = plain;
 export function projectLabel(repo) {
     return plain(repo.split(/[\\/]/).filter(Boolean).pop() ?? "project", 48);
 }
+/** The shared headline (task-status.ts) for a dispatch diagnosis on the phone. */
+function headlineFor(store, id, d) {
+    const completed = d.code === "complete" && store.handle.prepare("SELECT 1 FROM action_ledger WHERE task_id = ? AND action = ? AND source = 'work' LIMIT 1")
+        .get(store.taskFamilyOf(id, null, true)?.root.id ?? id, COMPLETION_ACTION) !== undefined;
+    const read = stageOfDispatch(d, { completed });
+    const finished = read.stage === "finished" || read.stage === "complete" || read.stage === "failed";
+    return taskStatusOf({ stage: read.stage, ...(read.need === undefined ? {} : { need: read.need }), reason: finished ? null : plainReasonOf(read.stage, d.code, d.detail),
+        checks: read.stage === "failed" && d.code === "proof-refuted" ? { status: "failed", exitCode: null, head: null } : null });
+}
 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)
@@ -94,13 +105,13 @@ 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;
             lines.push(`${group} · ${rows.length}${snapshot.tasksSaturated ? " in this snapshot" : ""}`);
             for (const task of rows.slice(0, 2)) {
-                lines.push(`${plain(task.id, 64)} · ${projectLabel(repos[task.repoIndex])}`, `  ${plain(task.title, 64)} — ${plain(task.dispatch.summary, 80)}`);
+                lines.push(`${plain(task.id, 64)} · ${projectLabel(repos[task.repoIndex])}`, `  ${plain(task.title, 64)} — ${headlineFor(store, task.id, task.dispatch).headline}`);
             }
             if (rows.length > 2)
                 lines.push(`  +${rows.length - 2} more in the console`);
@@ -131,7 +142,7 @@ export function phoneTaskChoices(store, repos, now, query = null, limit = 8) {
             if (seen.has(id) || !words.every(word => `${id} ${row.title}`.toLowerCase().includes(word)))
                 continue;
             seen.add(id);
-            choices.push({ id, title: plain(row.title, 64), label: plain(row.dispatch.summary, 48), group: groupOf(row.dispatch) });
+            choices.push({ id, title: plain(row.title, 64), label: headlineFor(store, row.id, row.dispatch).headline, group: groupOf(row.dispatch) });
             if (choices.length >= limit)
                 break;
         }
@@ -214,10 +225,11 @@ export function phoneTaskView(store, repos, id, now) {
         const d = diagnoseTaskDispatch(store, id, now);
         if (d === null)
             return { text: "This task's status is unavailable. Open it in the console before retrying.", link: null, run: null };
-        const lines = [plain(task.title, 140), `${plain(id, 64)} · ${projectLabel(ref.repo)}`, `As of ${now.toISOString().replace("T", " ").slice(0, 19)} UTC`, "", plain(d.summary, 160)];
+        const shared = headlineFor(store, id, d);
+        const lines = [plain(task.title, 140), `${plain(id, 64)} · ${projectLabel(ref.repo)}`, `As of ${now.toISOString().replace("T", " ").slice(0, 19)} UTC`, "", shared.headline];
         const blocker = d.blockerTaskId === null ? null : store.lookupRef(d.blockerTaskId);
         const hiddenDependency = blocker !== null && (blocker.repo === null || !repos.includes(blocker.repo));
-        lines.push(hiddenDependency ? "A required task outside this phone view has not finished. Open the dependency in the console." : plain(d.detail, 650));
+        lines.push(hiddenDependency ? "A required task outside this phone view has not finished. Open the dependency in the console." : plain(shared.sentence, 650));
         if (d.nextAt !== null)
             lines.push(`Earliest recorded wake: ${plain(d.nextAt, 40)} (a connected worker is still required).`);
         const runs = store.runsFor(ref.id);
@@ -247,8 +259,9 @@ export function phoneTaskView(store, repos, id, now) {
             if (accepted && !manualReviewOnly(proof))
                 lines.push("An operator accepted this result; that does not change its recorded checks.");
             const publication = store.publicationForRun(result.id);
-            const delivery = publication?.remoteState === "MERGED" ? "Merge observed on GitHub" : publication?.remoteState === "CLOSED" ? "Pull request closed, not merged" : publication?.state === "opened" ? `Pull request #${publication.prNumber ?? "?"} opened; not recorded as merged` : publication?.state === "pushed" ? "Branch pushed; pull request not yet recorded" : publication?.state === "intended" ? "Publication queued; not yet confirmed" : publication?.state === "failed" ? "Publication failed; the local result is preserved" : result.role === "scout" ? "Report saved locally" : "Result saved locally; no publication recorded";
-            lines.push(`Delivery: ${delivery}.`);
+            const delivery = publication?.remoteState === "MERGED" ? `#${publication.prNumber ?? "?"} merged` : publication?.remoteState === "CLOSED" ? `#${publication.prNumber ?? "?"} closed without merging` : publication?.state === "opened" ? `#${publication.prNumber ?? "?"} open` : publication?.state === "pushed" || publication?.state === "intended" ? "Opening…" : publication?.state === "failed" ? "Couldn't open; the commit is safe locally" : null;
+            if (delivery !== null)
+                lines.push(`Pull request: ${delivery}.`);
         }
         if (result === undefined)
             link = taskLinkFor(id, d, null);

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,6 +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, 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 };
@@ -194,9 +197,9 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     ELSE 'queued' END code
   FROM checked f
 ), ranked AS MATERIALIZED (
-  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','signed-out','planning-ready','scouting-ready','queued') needs,
+  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') needs,
     CASE WHEN code='complete' THEN 3 WHEN code='cancelled' THEN 4 WHEN code='running' THEN 1
-      WHEN code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','signed-out','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
+      WHEN code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
     CASE WHEN code='complete' THEN completed.at ELSE family_updated END sort_at,
     completed.actor checked_actor,completed.at checked_at,completed.outcome checked_digest
   FROM classified c LEFT JOIN action_ledger completed ON completed.id=c.checked_id WHERE ($state IS NULL OR c.state=$state) AND ($leadId IS NULL OR EXISTS(SELECT 1 FROM team_task_owner own WHERE own.task_ref=c.root_ref AND own.lead=$leadId))
@@ -293,10 +296,18 @@ export function workIndexPage(store, now, access, options = {}) {
   UNION ALL SELECT 1,0,0,0,0,json_object('root_ref',root_ref,'root_id',root_id,'id',id,'root_title',root_title,'repo',repo,
     'state',state,'created_at',created_at,'family_updated',family_updated,'version_count',version_count,'earlier_active',earlier_active,
     'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),
-    'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),'code',code,'needs',needs,'family_running',family_running,'rank',rank,'sort_at',sort_at,
+    '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'])));
@@ -315,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;
@@ -326,15 +358,15 @@ function itemOf(row, principal) {
         'ready-to-check': ['Ready', 'The saved result is ready to review.', 'open-result', 'Open result'],
         complete: ['Complete', 'Completion is recorded for this result. Open it to inspect the saved evidence.', 'open-result', 'Open result'],
         cancelled: ['Cancelled', 'This assignment was cancelled.', 'inspect-task', 'View assignment'],
-        running: ['Running now', 'A worker owns a current live claim.', null, ''],
+        running: ['Running now', '', null, ''],
         'waiting-decision': ['Needs your decision', 'An unanswered question is waiting.', n(row, 'question_id') ? 'answer-decision' : 'inspect-decisions', 'Answer question'],
         'decision-queue': ['Needs your decision', 'The decision queue is full.', 'inspect-decisions', 'Review open questions'],
         'result-needs-attention': ['Needs your decision', 'Inspect the saved result and resolve its remaining execution or scope issue.', 'inspect-run', 'Inspect run'],
         'process-needs-attention': ['Needs your decision', 'A process exit is not recorded. Open the attempt to check whether its work has stopped.', 'inspect-run', 'Inspect run'],
         failed: ['Needs your decision', 'The last attempt stopped; review its incident before retrying.', 'retry-task', 'Review and retry'],
         'vanished-run': ['Needs your decision', 'An unfinished attempt has no current live claim.', 'reconcile-run', 'Check the unfinished attempt'],
-        stopping: ['Needs your decision', 'The stop is waiting for recorded settlement.', 'inspect-stop', 'View stop details'],
-        stopped: ['Needs your decision', 'The stopped attempt is preserved.', 'resume-run', 'Review pause'],
+        stopping: ['Needs your decision', 'Stopping. The work so far is kept.', 'inspect-stop', 'View stop details'],
+        stopped: ['Needs your decision', 'Paused by a person. The work so far is kept.', 'resume-run', 'Review pause'],
         held: ['Needs your decision', s(row, 'hold_reason') ?? 'This task is on hold.', s(row, 'hold_kind') === 'operator' ? 'unhold' : 'inspect-hold', 'Review hold'],
         'waiting-incident': ['Needs your decision', 'An unresolved incident holds the next attempt.', 'retry-task', 'Review and retry'],
         'terminal-dependency': ['Needs your decision', 'A required task did not finish.', 'repair-dependency', 'Review required task'],
@@ -353,16 +385,22 @@ function itemOf(row, principal) {
         updating: ['Waiting for app update', 'New work resumes after the update.', null, ''],
         'planning-ready': ['Planner ready', 'A connected worker can draft the plan.', null, ''],
         'scouting-ready': ['Scout ready', 'A connected worker can produce the report.', null, ''],
-        queued: ['Ready to run', 'A connected worker can claim this task.', null, ''],
+        queued: ['Queued', '', null, ''],
     };
     let [label, detail, actionCode, actionLabel] = words[code];
     if (code === 'signed-out') {
         const [provider = '', authMode = 'subscription'] = (s(row, 'signed_out') ?? '').split(':');
         label = signInReason({ provider: provider, authMode: authMode === 'api-key' ? 'api-key' : 'subscription' });
-        detail = `It starts again on its own once ${providerName(provider)} works.`;
+        detail = `${label}. It starts again on its own once ${providerName(provider)} works.`;
     }
     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'))
@@ -377,12 +415,23 @@ 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 },
         access: read ? 'read' : principal === 'operator' ? 'operator-control' : ['answer-decision', 'write-scope', 'unhold'].includes(actionCode) ? 'proposal-only' : 'operator-handoff',
         retry: actionCode === 'reconcile-run' ? 'reconcile-before-retry' : read ? 'read-again' : 'refresh-before-acting' };
+    // The one shared status: the headline and sentence every surface uses.
+    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 : 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'];
     if (need)
         views.push('needs-you');
@@ -395,7 +444,7 @@ function itemOf(row, principal) {
         versionCount: n(row, 'version_count'), earlierActiveCount: n(row, 'earlier_active'), familyProblem: n(row, 'broken') ? FAMILY_PROBLEM : null,
         liveRunId: n(row, 'live_run') || null, unfinishedRunId: n(row, 'unfinished') || null, resultRunId: n(row, 'result_id') || null, resultTaskId: n(row, 'result_id') ? id : null,
         resultOutcome: s(row, 'result_outcome'), publicationUrl: s(row, 'publication_url'),
-        status: { token: `assignment-${assignmentState}`, label, detail, tone: code === 'complete' ? 'done' : code === 'ready-to-check' ? 'ready' : need ? 'attention' : running ? 'live' : 'muted',
+        status: { token: `assignment-${assignmentState}`, label, detail, tone: workToneOf(shared.headline),
             action: primaryAction === null ? null : { label: actionLabel, kind: actionCode === 'open-result' ? 'open-result' : 'open-task' }, views, rank: n(row, 'rank') },
         primaryAction, completion: code === 'complete' ? { actor: String(row['checked_actor']), at: String(row['checked_at']), digest: String(row['checked_digest']) } : null,
         evidence: 'recorded' };

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. */
@@ -182,6 +185,13 @@ export type WorkStatus = DisplayStatus & {
  * concrete act — never every queued task indiscriminately. */
 export declare function needsPerson(dispatch: DispatchDiagnosis | null): boolean;
 export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null): string;
+/** A finished result's display status in the shared headline's words: a
+ * failed project check is Failed, a result missing its record needs a
+ * person, every other saved result is Ready for review. Token and action stay. */
+export declare function resultHeadlineOf<T extends DisplayStatus>(status: T): T;
+/** The one shared headline (task-status.ts) over the work status below: the
+ * token, views, rank, action and diagnostics stay; the words and tone are
+ * the eight headlines'. */
 export declare function workStatusOf(facts: WorkFacts, resultDisplay?: DisplayStatus): WorkStatus;
 /** The counts each view tab wears — from the same rows the page lists. */
 export declare function workCounts(rows: readonly {

package/dist/workspace-ui.js

@@ -17,10 +17,11 @@
  * claimed without one.
  */
 import { GOAL_ASSESSMENT_PENDING, manualReviewOnly } from "./proof.js";
+import { plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from "./task-status.js";
 export const WORK_VIEWS = [
     { key: "all", label: "All", hint: "Every task in view, most urgent first.", empty: "Nothing is in progress. Describe work in chat or add a task, and it appears here." },
     { key: "needs-you", label: "Needs you", hint: "Tasks waiting on an answer, approval, or your inspection.", empty: "Nothing needs you right now. Queued and running work continues on its own." },
-    { key: "running", label: "Running", hint: "Attempts a builder owns right now.", empty: "Nothing is building right now. Approved tasks start when a builder with capacity is connected." },
+    { key: "running", label: "Building", hint: "Attempts a builder owns right now.", empty: "Nothing is building right now. Approved tasks start when a builder with capacity is connected." },
     { key: "completed", label: "Complete", hint: "Tasks the lead or user has marked complete. Recorded check results remain available.", empty: "No tasks have been marked complete in this view." },
 ];
 export function parseWorkView(raw) {
@@ -302,7 +303,37 @@ const DISPATCH_ACTION_LABELS = {
 export function dispatchActionLabel(dispatch) {
     return dispatch?.action == null ? "View task details" : DISPATCH_ACTION_LABELS[dispatch.action];
 }
+/** Result tokens a done task can wear, as the shared stage they mean. A
+ * result that is missing its record waits on a person; a failed check fails. */
+const RESULT_NEEDS_YOU = new Set(["no-build-record", "verification-needed", "evidence-mismatch", "record-incomplete", "evidence-damaged"]);
+/** Result tokens that only follow a passing project check. */
+const VERIFIED_RESULT = new Set(["ready-to-review", "pr-opened", "merge-observed", "pr-closed"]);
+/** A finished result's display status in the shared headline's words: a
+ * failed project check is Failed, a result missing its record needs a
+ * person, every other saved result is Ready for review. Token and action stay. */
+export function resultHeadlineOf(status) {
+    const read = RESULT_NEEDS_YOU.has(status.token) ? { stage: "needs-you", need: "other" }
+        : status.token === "checks-failed" ? { stage: "failed" } : { stage: "finished" };
+    const shared = taskStatusOf({ ...read, reason: status.detail, checks: read.stage === "failed" ? { status: "failed", exitCode: null, head: null }
+            : VERIFIED_RESULT.has(status.token) ? { status: "passed", exitCode: null, head: null } : null });
+    return { ...status, label: shared.headline, tone: workToneOf(shared.headline) };
+}
+/** The one shared headline (task-status.ts) over the work status below: the
+ * token, views, rank, action and diagnostics stay; the words and tone are
+ * the eight headlines'. */
 export function workStatusOf(facts, resultDisplay) {
+    const status = workStatusWordsOf(facts, resultDisplay);
+    const done = facts.state === "done" && status.token !== "waiting-decision";
+    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" ? 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;
     const result = facts.state === "done" ? resultDisplay ?? resultStatusOf(facts.result, facts.publication) : null;
     const running = facts.liveRunId !== null || (dispatch?.condition === "running" && !REVIEW_TOKENS.has(dispatch.code));
@@ -343,7 +374,7 @@ export function workStatusOf(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.5",
+  "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"