toolroll 0.9.5 → 0.9.6

package/dist/telegram-progress.js

@@ -1,12 +1,15 @@
 /** A compact projection of saved work, never a percentage or an ETA. The
- * words come from the same assignment record the console and the CLI show:
- * a finished build is Ready once its saved result can be inspected, and
- * Complete once the lead or a person has marked that exact result. No model
- * reviewer is waited for or announced. */
-import { manualReviewOnly } from "./proof.js";
+ * headline, sentence and detail rows come from the shared task status
+ * (task-status.ts), read from the same assignment record the console and the
+ * CLI show: Ready for review once the saved result can be inspected, Complete
+ * once the lead or a person has marked that exact result. Slack, Discord and
+ * Teams send this same card. */
 import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
+import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, taskStatusOf } from "./task-status.js";
+import { manualReviewOnly } from "./proof.js";
+import { failedCheckExit } from "./workspace-ui.js";
 /** The saved assignment for this exact result, or null when the run is not
  * the family's current result (an older attempt keeps its own plain words). */
 function assignmentFor(store, run, taskId, project, now, root) {
@@ -19,111 +22,70 @@ function assignmentFor(store, run, taskId, project, now, root) {
     }
 }
 export function telegramProgressCard(store, run, taskId, project, now = new Date(), root) {
-    const proof = store.proofVerdictFor(run.id);
-    const rows = proof?.matrix ?? [];
-    const direct = rows.length > 0 && rows.every(row => row.assessment !== undefined);
-    const passed = rows.filter(row => row.state === "pass").length;
-    const human = manualReviewOnly(proof);
-    const accepted = store.proofAcceptance(run.id) !== null;
     const built = run.finishedAt !== null && (run.outcome === "built" || run.outcome === "no-change");
     const assignment = built ? assignmentFor(store, run, taskId, project, now, root) : null;
-    const checksFailed = assignment?.receipt?.checks.status === "failed";
-    let status = "Working";
-    let icon = "⏳";
-    let next = "";
-    let build = built ? "✓ Build saved" : "● Build in progress";
-    let checks = rows.length ? `${passed === rows.length ? "✓" : "○"} Checks · ${passed}/${rows.length} requirements` : "○ Checks pending";
-    if (direct)
-        checks = proof?.machineVerdict === "verified" ? "✓ Checks passed" : proof?.machineVerdict === "attested" ? "○ Checks not configured" : "! Checks need attention";
-    let label = built ? "Open result" : "Open task";
-    if (run.outcome === null && run.phase !== null && run.phase !== "agent-running") {
-        status = "Checking the result";
-        build = "✓ Draft prepared";
-        checks = "● Checks in progress";
-    }
-    if (built) {
-        status = run.committed === false ? "Finished without a commit" : "Result saved";
-        if (proof === null)
-            checks = "○ Checks not recorded";
-        const recorded = assignment?.receipt?.checks;
-        if (recorded !== undefined && recorded.status !== "unavailable") {
-            checks = recorded.status === "passed" ? "✓ Checks passed"
-                : recorded.status === "failed" ? `! Checks failed${recorded.exitCode === null ? "" : ` (exit ${recorded.exitCode})`}`
-                    : "○ Checks did not run";
-        }
-        if (assignment?.state === "ready-to-check") {
-            status = "Ready";
-            icon = checksFailed ? "⚠️" : "✅";
-            next = checksFailed ? "Next: inspect the failed check, then mark it complete or request changes." : "Next: open the result, then mark it complete or request changes.";
-        }
-        else if (assignment?.state === "complete") {
-            status = "Complete";
-            icon = "✅";
-            next = phoneText(assignment.detail, 200);
-        }
-        else if (assignment?.state === "needs-decision") {
-            status = "Needs your decision";
-            icon = "💬";
-            next = phoneText(assignment.detail, 200);
-        }
-        else if (assignment?.state === "cancelled") {
-            status = "Cancelled";
-            icon = "⏹";
-        }
-        else if (assignment !== null) {
-            next = phoneText(assignment.detail, 200);
-        }
-        else if (run.committed !== false) {
-            next = "Open the task for its current status.";
-        }
-    }
-    else if (run.outcome !== null) {
-        status = run.outcome === "parked" ? "Decision needed" : run.outcome === "interrupted" || run.reason === "interrupted" ? "Stopped" : "Build needs attention";
-        icon = run.outcome === "parked" ? "💬" : "⏸";
-        build = "! Build unfinished";
-        next = "Next: inspect the blocker.";
-        label = "Open task";
-    }
+    const publication = store.publicationForRun(run.id);
+    const pullRequest = publication === null ? undefined : pullRequestFactOf(publication);
     const stop = store.stopOf(run.id);
-    if (run.outcome === null && stop !== null && stop.resumedAt === null) {
-        status = stop.settledAt === null ? "Stopping" : "Stopped";
-        icon = "⏸";
-        build = stop.settledAt === null ? "● Build stopping" : "! Build stopped";
-        next = stop.settledAt === null ? "Waiting for the running process to stop." : "Next: inspect the saved work, then resume.";
-    }
     const holds = store.activeHolds(run.taskRef, now);
     const operatorHold = holds.find(hold => hold.ownerKind === "operator");
     const accessBlocked = run.reason === "retryable-infra" && /^could not re-read (?:the branch|HEAD) in /i.test(run.handoff ?? "");
-    if (accessBlocked) {
-        status = "Worker needs project access";
-        icon = "⏸";
-        next = "Next: restore the worker’s folder access, then resume.";
-        label = "Open task";
+    // The one shared status: the same headline, sentence and rows as the console.
+    let facts;
+    if (assignment !== null && assignment.state !== "working" && assignment.state !== "checking") {
+        facts = assignmentStatusFacts(assignment, pullRequest === undefined ? {} : { pullRequest });
     }
-    if (operatorHold) {
-        icon = "⏸";
-        if (!accessBlocked) {
-            status = run.outcome === null ? "Working · Next attempt paused" : "Paused";
-            next = phoneText(operatorHold.reason, 150);
-        }
-        label = "Open task";
+    else if (built) {
+        // A saved result is Ready even in the moment before its worker lets go of
+        // the task. Without its receipt yet, the stored machine verdict speaks.
+        const recorded = assignment?.receipt?.checks ?? null;
+        const proof = store.proofVerdictFor(run.id);
+        const machine = proof?.machineVerdict ?? proof?.verdict ?? null;
+        const exit = failedCheckExit(proof?.reasons ?? []);
+        const checks = recorded !== null ? { status: recorded.status, exitCode: recorded.exitCode, head: run.headRevision }
+            : exit !== null ? { status: "failed", exitCode: exit, head: run.headRevision }
+                : machine === "verified" ? { status: "passed", exitCode: null, head: run.headRevision }
+                    : machine === "attested" ? { status: "not-run", exitCode: null, head: null } : null;
+        facts = { stage: "finished", report: run.role === "scout", checks, requirements: requirementsOf(proof?.matrix),
+            ...(pullRequest === undefined ? {} : { pullRequest }) };
     }
-    else if (accessBlocked && holds.some(hold => hold.ownerKind === "backoff")) {
-        next = "The worker will retry after a short pause. Check its folder access.";
+    else if (accessBlocked) {
+        facts = { stage: "needs-you", need: "other", reason: holds.some(hold => hold.ownerKind === "backoff")
+                ? "The worker can't read the project folder. It retries after a short pause; check its folder access."
+                : "The worker can't read the project folder. Restore its access, then resume." };
     }
+    else if (run.outcome === null && stop !== null && stop.resumedAt === null) {
+        facts = { stage: "stopped", reason: stop.settledAt === null ? "Stopping. Waiting for the running process to end." : "Paused by a person. Inspect the saved work, then resume." };
+    }
+    else if (operatorHold) {
+        facts = { stage: "stopped", reason: `On hold: ${phoneText(operatorHold.reason, 150)}` };
+    }
+    else if (run.outcome === null) {
+        facts = { stage: run.phase !== null && run.phase !== "agent-running" ? "checking" : run.role === "planner" ? "planning" : "building" };
+    }
+    else if (run.outcome === "parked") {
+        facts = { stage: "needs-you", need: "answer" };
+    }
+    else if (run.outcome === "interrupted" || run.reason === "interrupted") {
+        facts = { stage: "stopped", reason: "The attempt was interrupted. Inspect the saved work, then resume." };
+    }
+    else {
+        facts = { stage: "failed", reason: "The build stopped before it finished. Inspect the blocker, then retry." };
+    }
+    const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
-    if (checkProgress !== null)
-        checks = checkProgress.line;
-    const publication = store.publicationForRun(run.id);
-    const delivery = publication?.remoteState === "MERGED" ? "Merged · Installation not confirmed" : publication?.remoteState === "CLOSED" ? "Pull request closed without merging" : publication?.state === "opened" ? "Pull request open · Not merged" : publication?.state === "pushed" ? "Branch pushed · Pull request pending" : publication?.state === "intended" ? "Publication queued" : publication?.state === "failed" ? "Publication failed · Local result preserved" : built ? "Saved locally · Not published" : null;
-    const acceptance = accepted ? (human ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged") : null;
+    const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];
     const title = phoneText(store.getTask(taskId)?.title ?? taskId, 88);
-    const heading = `${icon} ${status}`;
-    const text = [title, heading, "", build, checks,
-        ...(next ? ["", next] : []),
-        ...(acceptance === null ? [] : [acceptance]),
-        ...(delivery === null ? [] : ["", delivery]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
+    const heading = `${headlineEmoji(status.headline)} ${status.headline}`;
+    const next = phoneText(status.sentence, 200);
+    // A person's acceptance is its own recorded decision; it never changes a check.
+    const acceptance = store.proofAcceptance(run.id) === null ? [] : [manualReviewOnly(store.proofVerdictFor(run.id))
+            ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged"];
+    const rows = [...statusDetailLines(status), ...progress, ...acceptance];
+    const text = [title, heading, next, ...(rows.length === 0 ? [] : ["", ...rows]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
+    const failedChecks = status.details.some(one => one.key === "checks" && (one.mark === "failed" || one.mark === "note"));
+    const recovery = operatorHold !== undefined || accessBlocked || (!built && run.outcome !== null);
     return { text, next, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
-        link: { label, path: operatorHold || accessBlocked || (!built && run.outcome !== null)
-                ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, checksFailed ? "checks" : "summary") : chatControlHref("task", taskId) } };
+        link: { label: built ? "Open result" : "Open task", path: recovery
+                ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, failedChecks ? "checks" : "summary") : chatControlHref("task", taskId) } };
 }

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,6 +52,15 @@ 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";
@@ -100,7 +111,7 @@ export function phoneStatus(store, repos, now, focused = null) {
                 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/work-index.js

@@ -4,6 +4,7 @@ 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';
 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 +195,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,7 +294,11 @@ 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),
+    '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),
@@ -326,15 +331,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,13 +358,13 @@ 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';
@@ -383,6 +388,17 @@ function itemOf(row, principal) {
             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 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 });
+    label = shared.headline;
+    detail = shared.sentence;
     const views = ['all'];
     if (need)
         views.push('needs-you');
@@ -395,7 +411,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/workspace-ui.d.ts

@@ -182,6 +182,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,35 @@ 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 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 };
+}
+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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "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"