toolroll 0.9.92 → 0.9.94

package/dist/vanished-retry.d.ts

@@ -0,0 +1,30 @@
+import { type Store } from "./store.js";
+/** The automatic-retry limits, in one place. */
+export declare const RETRY_LIMIT = 3;
+export declare const RETRY_SPEND_TIMES = 2;
+/** claim.ts MAX_STRIKES (store.ts loads this file, so the claim road isn't imported here; a test pins them equal). */
+export declare const VANISHED_MAX_STRIKES = 3;
+/** What recovery did with a task: back in the queue, waiting for its old process to be proven stopped, stopped for a
+ * person, or nothing at all (not a task of ours to move). */
+export type VanishedAnswer = "queued" | "waiting" | "stopped" | "none";
+export type RetryStop = "no-budget" | "attempts" | "spend";
+/**
+ * The one recovery decision, once per run. The caller has proved the runner gone; this re-reads everything else. A
+ * task a tick claimed never left `queued`, so releasing its lease alone would dispatch it again: what stops a retry here
+ * is the state or hold this writes, in this transaction. Safe to call again: the run is charged once, decided once.
+ */
+export declare function settleVanished(store: Store, taskRef: number, now: Date): VanishedAnswer;
+/** Each sweep: a charged run whose old process wasn't yet proven stopped gets its decision now. */
+export declare function retryVanishedWhenStopped(store: Store, now: Date): number;
+/** A person acted, so a new episode starts. The strikes are theirs to clear on their own road. */
+export declare function clearRetryEpisode(store: Store, taskRef: number): void;
+/** Why Toolroll stopped retrying this task, or null: it reads as a need until a person acts. */
+export declare function vanishedStopOf(store: Store, taskRef: number): {
+    why: RetryStop;
+    run: number;
+} | null;
+/** The need's words: the first stop on a plan with no budget, or a limit reached. */
+export declare function vanishedStopSentence(stop: {
+    why: RetryStop;
+    run: number | null;
+}): string;

package/dist/vanished-retry.js

@@ -0,0 +1,174 @@
+/**
+ * A build that vanished: its process died with its runner, so no one settled it (docs/plans/plain-toolroll.md P2.1).
+ *
+ * Every recovery road (a dead runner, a takeover, a superseded watch) ends here, in its own transaction. The vanished
+ * attempt is charged one strike, once, whoever recovers it: `vanished_charge` is keyed by the run, so a second recoverer
+ * or a later pass charges nothing, and restarting can no longer evade MAX_STRIKES.
+ *
+ * Toolroll retries by itself only inside an episode (`retry_episode`: the automatic retries and reserved spend since the
+ * last person act), at most RETRY_LIMIT retries and RETRY_SPEND_TIMES the plan's budget, each claim reserving its whole
+ * budget against that ceiling. A vanished attempt's spend is unknown, so its reservation is never given back. A plan
+ * with no budget bounds nothing and gets no automatic retry. A prepared candidate runs a machine check and no agent, so
+ * it spends nothing and needs no budget; it still counts its attempts.
+ *
+ * Stop, hold, archive and approval standing are re-read here, and each keeps the retry from dispatching: the task stays
+ * in the queue where that gate holds it, as a person's stop always has, reserving nothing, until a person acts. A
+ * process not yet proven stopped holds the task until it is (retryVanishedWhenStopped, every sweep): the retry never
+ * starts beside the old attempt.
+ */
+import { authorityStandsSql } from "./approval-authority.js";
+import { stopFactOf } from "./store.js";
+import { refArchived } from "./task-archive.js";
+/** The automatic-retry limits, in one place. */
+export const RETRY_LIMIT = 3;
+export const RETRY_SPEND_TIMES = 2;
+/** claim.ts MAX_STRIKES (store.ts loads this file, so the claim road isn't imported here; a test pins them equal). */
+export const VANISHED_MAX_STRIKES = 3;
+/** The newest attempt that spends: repair children ride their parent's attempt, and a reviewer has no task claim. */
+function attemptOf(store, taskRef) {
+    const row = store.handle.prepare("SELECT id, role, outcome, reason FROM run WHERE task_ref = ? AND role IN ('builder', 'scout', 'planner') ORDER BY id DESC LIMIT 1").get(taskRef);
+    // A planner spends no approved budget and has its own strikes: it goes back to the queue as it always has.
+    if (row === undefined || String(row["role"]) === "planner")
+        return null;
+    return { id: Number(row["id"]), outcome: row["outcome"] === null ? null : String(row["outcome"]), reason: row["reason"] === null ? null : String(row["reason"]) };
+}
+/** Whether any run of this task still has a process no record proves stopped. */
+function processUnsettled(store, taskRef) {
+    for (const run of store.runsFor(taskRef)) {
+        const fact = stopFactOf(store, run.id);
+        if (fact !== null && fact.kind !== "open")
+            return true;
+    }
+    return false;
+}
+/** dispatch.ts scopeApprovedForDispatch, read here because store.ts loads this file. */
+function approvalStands(store, taskRef, now) {
+    const stamp = now.toISOString();
+    return store.handle.prepare(`SELECT 1 AS hit FROM task_scope JOIN task_ref ON task_ref.id = ? AND task_scope.task_id = task_ref.external_id
+    WHERE task_scope.approved_digest = task_scope.digest AND task_scope.approved_at IS NOT NULL AND ${authorityStandsSql("task_scope", "task_ref.repo", "?")}`).get(taskRef, stamp, stamp, stamp, stamp) !== undefined;
+}
+function requeue(store, taskId, now) {
+    return Number(store.handle.prepare("UPDATE task SET state = 'queued', updated_at = ? WHERE id = ? AND state = 'running'").run(now.toISOString(), taskId).changes) > 0;
+}
+function episodeOf(store, taskRef) {
+    const row = store.handle.prepare("SELECT retries, reserved_microusd FROM retry_episode WHERE task_ref = ?").get(taskRef);
+    return row === undefined ? null : { retries: Number(row["retries"]), reservedMicrousd: Number(row["reserved_microusd"]) };
+}
+function stopFor(store, input) {
+    const stamp = input.now.toISOString();
+    store.handle.prepare(`INSERT INTO retry_episode (task_ref, retries, reserved_microusd, stopped, stopped_run, started_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT (task_ref) DO UPDATE SET stopped = excluded.stopped, stopped_run = excluded.stopped_run, reserved_microusd = excluded.reserved_microusd, updated_at = excluded.updated_at`)
+        .run(input.taskRef, input.retries, input.reservedMicrousd, input.why, input.run, stamp, stamp);
+    store.handle.prepare("UPDATE task SET state = 'failed', updated_at = ? WHERE id = ? AND state IN ('running', 'queued')").run(stamp, input.taskId);
+    store.enqueueNotification({
+        source: { run: input.run },
+        dedupeKey: `vanished:${input.run}`,
+        kind: "build-failed",
+        pushClass: "attention",
+        link: `/r/${input.run}`,
+        subject: `${input.taskId}: ${vanishedStopSentence({ why: input.why, run: input.run })}`,
+        body: "Open the task to retry it or change the plan.",
+    }, input.now);
+    return "stopped";
+}
+/** The custody wait's hold: nothing starts beside a process no record proves stopped, and it never lapses by itself. */
+const waitHold = (taskRef) => `vanished:${taskRef}`;
+/**
+ * The one recovery decision, once per run. The caller has proved the runner gone; this re-reads everything else. A
+ * task a tick claimed never left `queued`, so releasing its lease alone would dispatch it again: what stops a retry here
+ * is the state or hold this writes, in this transaction. Safe to call again: the run is charged once, decided once.
+ */
+export function settleVanished(store, taskRef, now) {
+    return store.transact(() => {
+        if (store.currentLiveLease(taskRef, now) !== null)
+            return "none";
+        const ref = store.refForId(taskRef);
+        if (ref === null || ref.backend !== "built-in")
+            return "none";
+        const taskId = ref.externalId;
+        const task = store.getTask(taskId);
+        if (task === null)
+            return "none";
+        const attempt = attemptOf(store, taskRef);
+        // No attempt, or one a real outcome already settled: nothing vanished here, and recovery only unsticks the task.
+        if (attempt === null || (attempt.outcome !== null && attempt.reason !== "interrupted"))
+            return requeue(store, taskId, now) ? "queued" : "none";
+        // Still open: its recoverer closes it and comes back here, in the same transaction. Nothing is decided on a run that
+        // may not be over.
+        if (attempt.outcome === null)
+            return requeue(store, taskId, now) ? "queued" : "none";
+        // A person's stop isn't a vanish: nothing is charged, and its hold keeps the task where the stop always has.
+        if (store.handle.prepare("SELECT 1 AS hit FROM run_stop WHERE run = ?").get(attempt.id) !== undefined)
+            return requeue(store, taskId, now) ? "queued" : "none";
+        const stamp = now.toISOString();
+        const charged = store.handle.prepare("INSERT INTO vanished_charge (run, task_ref, charged_at) VALUES (?, ?, ?) ON CONFLICT (run) DO NOTHING").run(attempt.id, taskRef, stamp);
+        const strikes = Number(charged.changes) > 0 ? store.addStrike(taskRef) : Number(store.handle.prepare("SELECT strikes FROM task_ref WHERE id = ?").get(taskRef)?.["strikes"] ?? 0);
+        if (store.handle.prepare("SELECT settled_at FROM vanished_charge WHERE run = ?").get(attempt.id)?.["settled_at"] != null)
+            return "none";
+        const settled = () => {
+            store.handle.prepare("UPDATE vanished_charge SET settled_at = ? WHERE run = ?").run(stamp, attempt.id);
+            store.releaseOwnedHold("backoff", waitHold(taskRef));
+        };
+        if (task.state !== "queued" && task.state !== "running") {
+            settled();
+            return "none";
+        }
+        // Blocked by something a person holds: back to the queue, where that gate keeps it. Nothing is reserved, because
+        // nothing starts until that person acts.
+        const held = store.handle.prepare("SELECT 1 AS hit FROM hold WHERE task_ref = ? AND owner_kind <> 'backoff' AND (until IS NULL OR until > ?) LIMIT 1").get(taskRef, stamp);
+        if (held !== undefined || refArchived(store, taskRef) || !approvalStands(store, taskRef, now)) {
+            settled();
+            return requeue(store, taskId, now) || task.state === "queued" ? "queued" : "none";
+        }
+        if (processUnsettled(store, taskRef)) {
+            requeue(store, taskId, now);
+            store.holdOwned({ taskRef, ownerKind: "backoff", ownerId: waitHold(taskRef), reason: `Waiting: Toolroll is making sure build #${attempt.id} stopped.`, until: null }, now);
+            return "waiting";
+        }
+        const scope = store.getScope(taskId);
+        const budget = scope?.budgetMicrousd ?? null;
+        const prepared = (scope?.candidate ?? null) !== null;
+        const episode = episodeOf(store, taskRef) ?? { retries: 0, reservedMicrousd: budget ?? 0 };
+        const stop = (why) => { settled(); return stopFor(store, { taskRef, taskId, run: attempt.id, why, now, reservedMicrousd: episode.reservedMicrousd, retries: episode.retries }); };
+        if (budget === null && !prepared)
+            return stop("no-budget");
+        if (strikes >= VANISHED_MAX_STRIKES || episode.retries >= RETRY_LIMIT)
+            return stop("attempts");
+        const reserved = episode.reservedMicrousd + (budget ?? 0);
+        if (budget !== null && reserved > budget * RETRY_SPEND_TIMES)
+            return stop("spend");
+        store.handle.prepare(`INSERT INTO retry_episode (task_ref, retries, reserved_microusd, started_at, updated_at) VALUES (?, 1, ?, ?, ?)
+      ON CONFLICT (task_ref) DO UPDATE SET retries = retries + 1, reserved_microusd = excluded.reserved_microusd, stopped = NULL, stopped_run = NULL, updated_at = excluded.updated_at`)
+            .run(taskRef, reserved, stamp, stamp);
+        settled();
+        requeue(store, taskId, now);
+        return "queued";
+    });
+}
+/** Each sweep: a charged run whose old process wasn't yet proven stopped gets its decision now. */
+export function retryVanishedWhenStopped(store, now) {
+    const waiting = store.handle.prepare("SELECT DISTINCT task_ref FROM vanished_charge WHERE settled_at IS NULL").all();
+    let moved = 0;
+    for (const row of waiting) {
+        const answer = settleVanished(store, Number(row["task_ref"]), now);
+        if (answer === "queued" || answer === "stopped")
+            moved++;
+    }
+    if (moved > 0)
+        store.bumpWake();
+    return moved;
+}
+/** A person acted, so a new episode starts. The strikes are theirs to clear on their own road. */
+export function clearRetryEpisode(store, taskRef) {
+    store.handle.prepare("DELETE FROM retry_episode WHERE task_ref = ?").run(taskRef);
+}
+/** Why Toolroll stopped retrying this task, or null: it reads as a need until a person acts. */
+export function vanishedStopOf(store, taskRef) {
+    const row = store.handle.prepare("SELECT stopped, stopped_run FROM retry_episode WHERE task_ref = ? AND stopped IS NOT NULL").get(taskRef);
+    return row === undefined ? null : { why: String(row["stopped"]), run: Number(row["stopped_run"]) };
+}
+/** The need's words: the first stop on a plan with no budget, or a limit reached. */
+export function vanishedStopSentence(stop) {
+    const build = stop.run === null ? "This build" : `Build #${stop.run}`;
+    return stop.why === "no-budget" ? `${build} stopped unexpectedly. Retry it.` : `${build} keeps stopping. Retry, or change the plan.`;
+}

package/dist/work-index.d.ts

@@ -77,6 +77,8 @@ export type WorkProjectCounts = {
 };
 export declare const WORK_INDEX_PAGE_LIMIT = 40;
 export declare const WORK_INDEX_MAX_LIMIT = 100;
+/** The index codes that wait on nobody: finished or running work, and every wait (needs-you.ts CODE_READING). */
+export declare const WAITING_CODES: readonly string[];
 /** A code's ask: a saved result is Review (unless its build may still run), otherwise its need's ask. */
 export declare function askOfCode(code: string, custody?: boolean): Ask;
 export declare class WorkIndexCursorError extends Error {

package/dist/work-index.js

@@ -2,6 +2,7 @@
  * not verify artifacts or authorize task operations; a build Toolroll can't
  * yet confirm stopped is read through the store's own read-only probe. */
 import { authorityStandsSql } from "./approval-authority.js";
+import { vanishedStopSentence } from "./vanished-retry.js";
 import { leadNameOf } from './lead-identity.js';
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
@@ -18,14 +19,15 @@ import { isCheckLevel, requiredCheckCommandFor } from './check-levels.js';
 import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
 import { LANDED_ACTOR, landedReasonOf } from './result-completion.js';
-import { ASKS, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, processNeedOf, resultHoldUpSentence } from './needs-you.js';
+import { ASKS, CODE_READING, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, isWaitCode, processNeedOf, resultHoldUpSentence } from './needs-you.js';
+import { retryWhenWords } from './dispatch.js';
 import { LEAD_CLAIM_SQL, LEAD_IDLE_MS } from './lead-voice.js';
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
-const EMPTY = { all: 0, 'needs-you': 0, running: 0, queued: 0, completed: 0, archived: 0 };
+const EMPTY = { all: 0, 'needs-you': 0, ready: 0, running: 0, queued: 0, completed: 0, archived: 0 };
 const NO_GROUPS = { decide: 0, review: 0, unblock: 0, building: 0, rest: 0 };
 const FAMILY_PROBLEM = 'Task history is unavailable or incomplete. This task is shown separately.';
-const VIEWS = ['all', 'needs-you', 'running', 'queued', 'completed', 'archived'];
+const VIEWS = ['all', 'needs-you', 'ready', 'running', 'queued', 'completed', 'archived'];
 /** The family's current version is put away (v145): it waits on nobody and only the Archived view lists it. */
 const ARCHIVED = `EXISTS(SELECT 1 FROM task_archive ta WHERE ta.task_ref=c.ref_id)`;
 const n = (row, key) => Number(row[key] ?? 0);
@@ -39,14 +41,22 @@ const AGENT_ASK = `(SELECT q.id FROM agent_question q JOIN run qr ON qr.id=q.run
  * MATERIALIZED prevents counts + page selection repeating correlated reads. */
 /** A gate note counts only while its pause is on one of the task's current providers. */
 const GATE_PAUSE_ON_TASK = pauseOnTaskProviders('p', 'c.ref_id');
-/** Index codes that wait on a person, as their need (needs-you.ts); dispatch codes come from task-status's own table. */
-const INDEX_NEED = {
-    'earlier-active': 'earlier-version', 'process-needs-attention': 'confirm-stopped', 'invalid-scope': 'define-task', 'decision-queue': 'questions',
-};
-/** Every index code that can wait on a person. */
+/** Index codes that wait on a person, as their need, where the index reads one the dispatch codes don't. */
+const INDEX_NEED = Object.fromEntries(['earlier-active', 'process-needs-attention', 'invalid-scope', 'decision-queue', 'history-problem']
+    .map(code => [code, CODE_READING[code].need]));
+/** Every index code that can wait on a person. A wait (stopping, waiting its turn, a retry later) is never one. */
 const PERSON_CODES = ['history-problem', 'earlier-active', 'ready-to-check', 'waiting-decision', 'decision-queue', 'result-needs-attention',
-    'process-needs-attention', 'failed', 'vanished-run', 'stopping', 'stopped', 'held', 'waiting-incident', 'terminal-dependency', 'needs-project',
+    'process-needs-attention', 'failed', 'vanished-run', 'stopped', 'held', 'waiting-incident', 'terminal-dependency', 'needs-project',
     'needs-scope', 'invalid-scope', 'needs-agent-profile', 'needs-approval', 'missing-requirement', 'no-worker-registered', 'no-worker-online', 'signed-out'];
+/** The index codes that wait on nobody: finished or running work, and every wait (needs-you.ts CODE_READING). */
+export const WAITING_CODES = ['cancelled', 'complete', 'running', 'queued',
+    ...['stopping', 'updating', 'retry-scheduled', 'waiting-dependency', 'worker-at-capacity', 'planning-ready', 'scouting-ready'].filter(code => isWaitCode(code))];
+const WAITING_SQL = WAITING_CODES.map(code => `'${code}'`).join(',');
+/** The words on a state's own act (a need's act wears its need's label). */
+const STATE_ACT_LABEL = {
+    'ready-to-check': 'Open result', complete: 'Open result', cancelled: 'View task details', failed: 'Review and retry', 'waiting-incident': 'Review and retry',
+    stopped: 'Review pause', held: 'Review hold', 'result-needs-attention': 'Open the build', 'process-needs-attention': 'Open the build',
+};
 /** A code's ask: a saved result is Review (unless its build may still run), otherwise its need's ask. */
 export function askOfCode(code, custody = false) {
     if (custody)
@@ -129,6 +139,8 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     (SELECT id FROM run WHERE task_ref=c.ref_id AND lease_id=c.live_lease AND outcome IS NULL ORDER BY id DESC LIMIT 1) live_run,
     h.owner_kind hold_kind,h.reason hold_reason,h.until hold_until,
     sc.task_id scope_id,sc.digest,sc.approved_at,sc.proposed_at,sc.profile_state,
+    -- A prepared candidate: the machine checks out that commit and runs its check; no agent runs (machine-check.ts).
+    (typeof(sc.candidate)='text' AND sc.candidate<>'') machine_check,
     -- The pause the dispatch gate itself left this task waiting on (the provider it resolved, pins,
     -- configuration and planners included) first; the approved terms answer before any gate has looked.
     EXISTS(SELECT 1 FROM provider_auth_pause p WHERE p.id=c.auth_wait_pause AND p.lifted_at IS NULL AND ${GATE_PAUSE_ON_TASK}) gate_signed_out,
@@ -239,11 +251,11 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   SELECT c.*,CASE WHEN code IN ('cancelled','complete') THEN 0 ELSE ${LEAD_CLAIM_SQL} END lead_claim FROM classified c
 ), ranked AS MATERIALIZED (
   -- A task the person's lead is on (lead-voice.ts) waits on nobody: it leaves Needs you until the claim ends or lapses.
-  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} AND lead_claim<>1 AND NOT ${ARCHIVED} needs,
-    code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') AND NOT ${CUSTODY_WAITS} AND NOT ${ARCHIVED} person_need,
+  SELECT c.*,code NOT IN (${WAITING_SQL}) AND NOT ${CUSTODY_WAITS} AND lead_claim<>1 AND NOT ${ARCHIVED} needs,
+    code NOT IN (${WAITING_SQL}) AND NOT ${CUSTODY_WAITS} AND NOT ${ARCHIVED} person_need,
     ${ARCHIVED} archived,
     CASE WHEN code='complete' THEN 3 WHEN code='cancelled' THEN 4 WHEN code='running' THEN 1
-      WHEN ${CUSTODY_WAITS} OR code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
+      WHEN ${CUSTODY_WAITS} OR code IN (${WAITING_SQL.replace(/'(?:cancelled|complete|running)',/g, '')}) THEN 2 ELSE 0 END rank,
     ${ASK_RANK} ask_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,completed.detail checked_detail
@@ -333,12 +345,14 @@ function parameters(now, access, options, custody) {
         $leadOf: access.principal === 'operator' && access.viewer != null && access.viewer !== '' ? `lead for ${access.viewer}` : null };
 }
 function counts(row) {
-    return { all: n(row, 'all_count'), 'needs-you': n(row, 'needs_count'), running: n(row, 'running_count'), queued: n(row, 'queued_count'), completed: n(row, 'completed_count'), archived: n(row, 'archived_count') };
+    return { all: n(row, 'all_count'), 'needs-you': n(row, 'needs_count'), ready: n(row, 'ready_count'), running: n(row, 'running_count'), queued: n(row, 'queued_count'), completed: n(row, 'completed_count'), archived: n(row, 'archived_count') };
 }
 // Put-away families (v145) count only as archived.
 // Queued: waits on someone or something else (rank 2), not a person and not a build of its own family.
 const QUEUED = `rank=2 AND family_running=0 AND archived=0`;
-const TOTALS = `COALESCE(SUM(archived=0),0) all_count,COALESCE(SUM(needs),0) needs_count,COALESCE(SUM(family_running AND archived=0),0) running_count,`
+// Ready (P1.4): what waits on a person to accept or send back, the Needs you rows under Review.
+const READY = `needs AND rank=0 AND ask_rank=1 AND archived=0`;
+const TOTALS = `COALESCE(SUM(archived=0),0) all_count,COALESCE(SUM(needs),0) needs_count,COALESCE(SUM(${READY}),0) ready_count,COALESCE(SUM(family_running AND archived=0),0) running_count,`
     + `COALESCE(SUM(${QUEUED}),0) queued_count,COALESCE(SUM(code='complete' AND archived=0),0) completed_count,COALESCE(SUM(archived),0) archived_count`;
 const GROUP_TOTALS = `COALESCE(SUM(rank=0 AND ask_rank=0 AND archived=0),0) decide_count,COALESCE(SUM(rank=0 AND ask_rank=1 AND archived=0),0) review_count,COALESCE(SUM(rank=0 AND ask_rank=2 AND archived=0),0) unblock_count,`
     + `COALESCE(SUM(rank=1 AND archived=0),0) building_count,COALESCE(SUM(rank>1 AND archived=0),0) rest_count`;
@@ -391,7 +405,7 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     const view = VIEWS.includes(options.view ?? 'all') ? options.view ?? 'all' : 'all';
     const limit = Number.isFinite(options.limit) ? Math.max(1, Math.min(WORK_INDEX_MAX_LIMIT, Math.floor(options.limit))) : WORK_INDEX_PAGE_LIMIT;
     const scope = cursorScope(access, options, view), cursor = readCursor(options.cursor, scope);
-    const filter = view === 'archived' ? 'archived=1' : view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1 AND archived=0' : view === 'queued' ? QUEUED : view === 'completed' ? "code='complete' AND archived=0" : 'archived=0';
+    const filter = view === 'archived' ? 'archived=1' : view === 'needs-you' ? 'needs=1' : view === 'ready' ? READY : view === 'running' ? 'family_running=1 AND archived=0' : view === 'queued' ? QUEUED : view === 'completed' ? "code='complete' AND archived=0" : 'archived=0';
     const rows = prepared(store, `${projection}, selected_page AS MATERIALIZED (
     SELECT * FROM ranked WHERE ($taskId IS NOT NULL OR ${filter}) AND ($taskId IS NULL OR root_ref IN (SELECT root_ref FROM members WHERE id=$taskId)) AND ($roots IS NULL OR root_id IN (SELECT value FROM json_each($roots))) AND ($cursorRoot=0 OR
       ${ORDER}>$cursorRank OR (${ORDER}=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
@@ -400,13 +414,13 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0 AND archived=0) queued,
       SUM(state='done' AND family_running=0 AND archived=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo
   )
-  SELECT 0 record_kind,totals.*,(SELECT json_group_array(json_object('repo',repo,'all_count',all_count,'needs_count',needs_count,
+  SELECT 0 record_kind,totals.*,(SELECT json_group_array(json_object('repo',repo,'all_count',all_count,'needs_count',needs_count,'ready_count',ready_count,
     'running_count',running_count,'queued_count',queued_count,'completed_count',completed_count,'archived_count',archived_count,'queued',queued,'done_recently',done_recently)) FROM project_totals) row_json FROM totals
-  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,0,0,json_object('archived',archived,'archived_by',(SELECT by FROM task_archive WHERE task_ref=page.ref_id),
+  UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,0,0,0,json_object('archived',archived,'archived_by',(SELECT by FROM task_archive WHERE task_ref=page.ref_id),
     'archived_kind',(SELECT by_kind FROM task_archive WHERE task_ref=page.ref_id),'archived_reason',(SELECT reason FROM task_archive WHERE task_ref=page.ref_id),
     'archived_at',(SELECT at FROM task_archive WHERE task_ref=page.ref_id),'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),'attempt_reason',(SELECT substr(reason,1,1000) FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),
+    'earlier_id',earlier_id,'route_change',(SELECT rc.words FROM route_change rc JOIN task_scope rs ON rs.task_id=page.id AND rs.digest=rc.scope_digest AND rs.approved_digest IS NOT rs.digest WHERE rc.task_ref=page.ref_id),'retry_stopped',(SELECT stopped FROM retry_episode WHERE task_ref=page.ref_id),'retry_stopped_run',(SELECT stopped_run FROM retry_episode WHERE task_ref=page.ref_id),'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),'attempt_reason',(SELECT substr(reason,1,1000) FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
     'result_role',(SELECT role FROM run WHERE id=page_result_id),'result_head',(SELECT head_revision 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),
@@ -416,11 +430,11 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     '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,'person_need',person_need,'lead_claim',lead_claim,'family_running',family_running,'rank',rank,'ask_rank',ask_rank,'list_order',${ORDER},'sort_at',sort_at,
     'checked_actor',checked_actor,'checked_at',checked_at,'checked_digest',checked_digest,'checked_detail',checked_detail,'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),'hold_id',hold_id,'live_lease',live_lease IS NOT NULL,'approved',COALESCE(approved,0),
+    'dependency_id',dependency_id,'dependency_state',dependency_state,'hold_until',hold_until,'attempt_run',(SELECT id FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),'custody_unresolved',custody_unresolved,'hold_kind',hold_kind,'hold_reason',substr(hold_reason,1,300),'hold_id',hold_id,'live_lease',live_lease IS NOT NULL,'approved',COALESCE(approved,0),
     'plan_changed',scope_digest IS NOT NULL AND digest IS NOT scope_digest,'head_ok',length(head_revision)=40 AND head_revision NOT GLOB '*[^a-f0-9]*','stop_run',stop_run,'unfinished',unfinished,'signed_out',signed_out,
     'question_run',(SELECT run FROM decision WHERE id=page.question_id),'agent_ask',page.agent_ask,
     'agent_ask_run',(SELECT run FROM agent_question WHERE id=page.agent_ask),'agent_ask_text',(SELECT substr(question,1,300) FROM agent_question WHERE id=page.agent_ask),'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),
+    'completed_by_lead',(SELECT lead FROM task_act WHERE task_ref=page.root_ref AND act='completed' ORDER BY id DESC LIMIT 1),'machine_check',COALESCE(machine_check,0),
     '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, custody), $taskId: taskId, $roots: options.roots === undefined ? null : JSON.stringify(options.roots), $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'])));
@@ -439,7 +453,7 @@ function readWorkIndexPage(store, now, access, options, taskId = null) {
     // automatic review and, with checks Off, the release check that covers it.
     const memo = new Map();
     const readiness = (row, checks) => resultReadinessFacts(store, now, options.root, row, checks, memo);
-    return { items: page.map(row => itemOf(row, access.principal, probe, leadName, readiness, options.root !== undefined)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
+    return { items: page.map(row => itemOf(row, access.principal, probe, leadName, readiness, options.root !== undefined, now)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
         groups: rows[0] === undefined ? { ...NO_GROUPS } : groupCounts(rows[0]), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
@@ -568,61 +582,54 @@ function resultReadinessFacts(store, now, root, row, recorded, memo) {
     const blockers = completionBlockersOf({ report, checks, checkRequired, matrix: proof?.matrix, verdict: proof?.verdict ?? null, accepted, high });
     return { checks, requirements: unverifiedWhenRefuted(requirements, verdict), ...(accepted ? { accepted } : {}), ...(blockers.length === 0 ? {} : { blockers }) };
 }
-function itemOf(row, principal, probe, leadName, readiness, readable = false) {
+function itemOf(row, principal, probe, leadName, readiness, readable = false, now = new Date()) {
     const code = String(row['code']), id = String(row['id']);
     const custody = code === 'process-needs-attention' || (code === 'result-needs-attention' && n(row, 'custody_unresolved') === 1);
     const process = custody && probe !== undefined ? processNeedOf(probe(id)) : null;
-    const waiting = process !== null && 'wait' in process;
+    const waiting = (process !== null && 'wait' in process) || (custody && probe === undefined);
     const need = n(row, 'needs') === 1 && !waiting, running = n(row, 'family_running') === 1;
     // The lead's claim (lead-voice.ts): the row still reads its own stage, worded "<name> is on it".
     const lead = n(row, 'lead_claim') === 1 ? 'on-it' : n(row, 'lead_claim') === 2 ? 'lapsed' : null;
     const personNeed = (n(row, 'person_need') === 1 || need) && !waiting;
     const assignmentState = code === 'complete' ? 'complete' : code === 'ready-to-check' ? 'ready-to-check'
         : code === 'cancelled' ? 'cancelled' : need ? 'needs-decision' : 'working';
-    const words = {
-        'history-problem': ['Needs your decision', FAMILY_PROBLEM, 'inspect-task', 'Review task history'],
-        'earlier-active': ['Needs your decision', 'Earlier work is still active. Resolve it before completing this assignment.', 'inspect-task', 'Review active work'],
-        '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', '', null, ''],
-        'waiting-decision': ['Needs your decision', 'An unanswered question is waiting.', n(row, 'question_id') ? 'answer-decision' : n(row, 'agent_ask') ? 'answer-agent' : 'inspect-decisions', 'Answer question'],
-        'decision-queue': ['Needs your decision', 'The decision queue is full.', 'inspect-decisions', 'Review open questions'],
-        // Its own reason replaces this below (resultHoldUpSentence).
-        'result-needs-attention': ['Needs your decision', '', '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.', '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', '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'],
-        'waiting-dependency': ['Waiting for another task', 'A required task must finish before this task can start.', null, ''],
-        'needs-project': ['Needs your decision', 'Choose a project for this task.', 'place-task', 'Choose a project'],
-        'needs-scope': ['Needs your decision', 'Define the task before a worker can start.', 'write-scope', 'Define the task'],
-        'invalid-scope': ['Needs your decision', 'The saved task scope cannot be read safely.', 'write-scope', 'Review scope'],
-        'needs-agent-profile': ['Needs your decision', 'Choose an available agent for this task.', 'select-agent', 'Choose an agent'],
-        'needs-approval': ['Needs your decision', 'Review the current plan before a worker can start.', 'approve-scope', 'Approve plan'],
-        'missing-requirement': ['Needs your decision', 'A required capability is missing or expired.', 'repair-capability', 'Review missing requirement'],
-        'no-worker-registered': ['Needs your decision', 'No connected builder includes this project.', 'start-worker', 'Check connection'],
-        'no-worker-online': ['Needs your decision', 'The builder has stopped checking in.', 'start-worker', 'Check connection'],
-        'worker-at-capacity': ['Waiting for worker capacity', 'This task starts when an eligible worker has capacity.', null, ''],
-        'signed-out': ['Waiting for a sign-in', 'Its agent needs you to sign in again; it starts on its own once that works.', null, ''],
-        'retry-scheduled': ['Retry scheduled', 'The attempt is backing off before retrying.', null, ''],
-        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: ['Queued', '', null, ''],
-    };
-    let [label, detail, actionCode, actionLabel] = words[code];
+    // What the code means (needs-you.ts CODE_READING, the one table): its act is the one it has always had; a need's
+    // words and label come from NEEDS, a wait's from WAITS. Only facts the row itself holds are added here.
+    const meaning = CODE_READING[code];
+    let label = '';
+    let detail = '';
+    let actionCode = (meaning?.act ?? null);
+    let actionLabel = actionCode === null ? '' : STATE_ACT_LABEL[code] ?? (meaning?.need === undefined ? '' : NEEDS[meaning.need].action.label);
+    if (code === 'waiting-decision')
+        actionCode = n(row, 'question_id') ? 'answer-decision' : n(row, 'agent_ask') ? 'answer-agent' : 'inspect-decisions';
+    if (code === 'held') {
+        actionCode = s(row, 'hold_kind') === 'operator' ? 'unhold' : 'inspect-hold';
+        detail = s(row, 'hold_reason') ?? 'This task is on hold.';
+    }
+    if (code === 'stopping') {
+        actionCode = 'inspect-stop';
+        actionLabel = 'View stop details';
+    }
+    if (code === 'stopped')
+        detail = 'Paused by a person. The work so far is kept.';
+    if (code === 'cancelled')
+        detail = 'This task was cancelled.';
+    // The same failure again and again: what failed, and the two ways on.
+    if (code === 'waiting-incident')
+        detail = `The last attempts failed the same way (${failedAttemptSentence(s(row, 'attempt_reason')).replace(/[.\s]+$/, '').replace(/^./, first => first.toLowerCase())}). Retry, or change the plan.`;
+    /** The build, the task or the time a sentence names. */
+    const context = code === 'stopping' ? { build: n(row, 'stop_run') || null }
+        : code === 'retry-scheduled' ? { build: n(row, 'attempt_run') || null, retry: s(row, 'hold_until') === null ? null : retryWhenWords(s(row, 'hold_until'), now) }
+            : code === 'vanished-run' ? { build: n(row, 'unfinished') || null }
+                : code === 'earlier-active' ? { task: s(row, 'earlier_id') }
+                    : code === 'waiting-dependency' ? { task: s(row, 'dependency_id') } : {};
     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 = `${label}. It starts again on its own once ${providerName(provider)} works.`;
     }
     if (code === 'running' && n(row, 'version_count') > 1)
-        label = 'Revising';
+        label = 'Building again';
     // Replaced, never "Cancelled": the successor is one tap away.
     const successor = code === 'cancelled' ? s(row, 'replaced_by') : null;
     if (successor !== null) {
@@ -633,7 +640,11 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
         detail = `${s(row, 'dependency_id')} ${s(row, 'dependency_state') === 'cancelled' ? 'was cancelled' : 'failed'} before it finished.`;
     // A failed task says the latest finished attempt across its whole family, whatever its outcome: its recorded reason, or that none was recorded.
     if (code === 'failed')
-        detail = failedAttemptSentence(s(row, 'attempt_reason'));
+        detail = s(row, 'retry_stopped') === null ? failedAttemptSentence(s(row, 'attempt_reason'))
+            : vanishedStopSentence({ why: s(row, 'retry_stopped'), run: n(row, 'retry_stopped_run') || null });
+    // A new route waiting for its one Approve says what changed (route-change.ts).
+    if (code === 'needs-approval' && s(row, 'route_change') !== null)
+        detail = s(row, 'route_change');
     // A saved result that can't be accepted yet says its own reason, never one line for every such row.
     const planChanged = code === 'result-needs-attention' && n(row, 'plan_changed') === 1;
     if (code === 'result-needs-attention')
@@ -647,14 +658,11 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
         actionCode = 'open-result';
         actionLabel = 'Open result';
     }
+    // Toolroll proves a build stopped itself; only a stop it can't prove from here offers "Check again", never a vouch.
     if (process !== null && 'need' in process) {
-        actionCode = 'confirm-stopped';
+        actionCode = 'recheck-stopped';
         actionLabel = NEEDS[process.need].action.label;
     }
-    else if (custody && probe === undefined) {
-        actionCode = 'confirm-stopped';
-        actionLabel = NEEDS['confirm-stopped'].action.label;
-    }
     if (code === 'signed-out') {
         actionCode = 'sign-in';
         actionLabel = NEEDS['sign-in'].action.label;
@@ -668,7 +676,7 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
         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 === 'answer-agent' ? n(row, 'agent_ask_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
-                    : actionCode === 'confirm-stopped' ? process?.build ?? (n(row, 'result_id') || null) : null,
+                    : actionCode === 'recheck-stopped' ? process?.build ?? (n(row, 'result_id') || null) : null,
             decisionId: actionCode === 'answer-decision' ? n(row, 'question_id') || null : null },
         access: read ? 'read' : principal === 'operator' ? 'operator-control' : ['answer-decision', 'answer-agent', 'write-scope', 'unhold'].includes(actionCode) ? 'proposal-only' : 'operator-handoff',
         retry: actionCode === 'reconcile-run' ? 'reconcile-before-retry' : read ? 'read-again' : 'refresh-before-acting' };
@@ -676,7 +684,8 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
     const coded = stageOfCode(code, { needsPerson: personNeed, planning: s(row, 'live_role') === 'planner', operatorHold: s(row, 'hold_kind') === 'operator' });
     const reading = process !== null
         ? 'wait' in process ? { stage: 'waiting', wait: process.wait } : { stage: 'needs-you', need: process.need }
-        : custody ? { stage: 'needs-you', need: 'confirm-stopped' }
+        // Not read here (no process probe): Toolroll's own stop check settles it, so it waits on no one.
+        : custody ? { stage: 'waiting', wait: 'build-checking' }
             : coded.stage === 'needs-you' && (coded.need === undefined || coded.need === 'other') && INDEX_NEED[code] !== undefined ? { stage: 'needs-you', need: INDEX_NEED[code] } : coded;
     const checkStatus = s(row, 'check_status'), verdict = s(row, 'proof_verdict');
     const finished = reading.stage === 'finished' || reading.stage === 'complete';
@@ -689,8 +698,9 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
     // Toolroll marked it complete because its work landed: the reason, said once.
     const landed = code === 'complete' ? landedReasonOf(s(row, 'checked_actor'), s(row, 'checked_detail')) : null;
     const shared = taskStatusOf({ stage: reading.stage, ...(reading.need === undefined ? {} : { need: reading.need }), ...(reading.wait === undefined ? {} : { wait: reading.wait }),
-        ...(process === null ? {} : { needContext: { build: process.build } }),
+        ...(process === null ? (Object.keys(context).length === 0 ? {} : { needContext: context }) : { needContext: { build: process.build } }),
         reason: finished ? null : plainReasonOf(reading.stage, code, detail || null), report: s(row, 'result_role') === 'scout',
+        ...(n(row, 'machine_check') === 1 ? { machine: true } : {}),
         checks: ready !== null ? ready.checks : listedChecks,
         ...(ready === null ? {} : { requirements: ready.requirements ?? null, ...(ready.accepted ? { accepted: true } : {}), ...(ready.blockers === undefined ? {} : { blockers: ready.blockers }) }),
         completedBy: code !== 'complete' || landed !== null ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, ''),
@@ -716,6 +726,8 @@ function itemOf(row, principal, probe, leadName, readiness, readable = false) {
     const views = archived !== null ? ['archived'] : ['all'];
     if (archived === null && need)
         views.push('needs-you');
+    if (archived === null && need && n(row, 'rank') === 0 && n(row, 'ask_rank') === 1)
+        views.push('ready');
     if (archived === null && running)
         views.push('running');
     if (archived === null && !need && !running && n(row, 'rank') === 2)

package/dist/work-summary.d.ts

@@ -8,9 +8,9 @@ export type WorkTarget = {
     decisionId: number | null;
 };
 export type WorkAction = {
-    /** `confirm-stopped`: an approver confirms a finished build stopped (behind the password);
+    /** `recheck-stopped`: Toolroll looks again whether a finished build stopped (nobody vouches for it);
      * `sign-in`: the agent's sign-in, in Settings; `answer-agent`: Reply to a running agent's question on the Agents board. */
-    code: DispatchAction | "inspect-task" | "inspect-run" | "inspect-stop" | "inspect-decisions" | "reconcile-run" | "open-pr" | "confirm-stopped" | "sign-in" | "answer-agent";
+    code: DispatchAction | "inspect-task" | "inspect-run" | "inspect-stop" | "inspect-decisions" | "reconcile-run" | "open-pr" | "recheck-stopped" | "sign-in" | "answer-agent";
     label: string;
     target: WorkTarget;
     access: "read" | "operator-control" | "proposal-only" | "operator-handoff";

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 { machineChecked } from "./machine-check.js";
 import { resultCheckLevel } from "./result-follow-ups.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
 import { isAlive } from "./runner.js";
@@ -94,6 +95,7 @@ export function taskWorkSummaryOf(store, taskId, now, access) {
     const publication = result === null ? null : store.publicationForRun(result.id);
     const facts = {
         id: task.id, title: task.title, repo: ref.repo, state: task.state, updatedAt: task.updatedAt,
+        ...(machineChecked(store, task.id) ? { machine: true } : {}),
         dispatch: diagnoseTaskDispatch(store, taskId, now, access.dependencyRepos ?? null), liveRunId: live?.id ?? null,
         unfinishedRunId: runs.find(one => one.outcome === null && one.role !== "reviewer")?.id ?? null,
         control: taskControlOf(store, ref.id, now), openDecision: openWorkDecisionOf(store, ref.id, now),

package/dist/workspace-ui.d.ts

@@ -26,7 +26,7 @@ import { type ChecksFact } from "./task-status.js";
 import { type Html } from "./html.js";
 /** The Work destination's views — shortcuts over the same rows, never a
  * persisted state. All is the default. */
-export type WorkView = "all" | "needs-you" | "running" | "queued" | "completed" | "archived";
+export type WorkView = "all" | "needs-you" | "ready" | "running" | "queued" | "completed" | "archived";
 export declare const WORK_VIEWS: readonly {
     key: WorkView;
     label: string;
@@ -154,6 +154,8 @@ export declare function receiptPublicationWords(publication: PublicationFacts):
  * already reads elsewhere. */
 export type WorkFacts = {
     id: string;
+    /** The machine runs this task's check on a prepared candidate; no agent runs (machine-check.ts). */
+    machine?: boolean;
     title: string;
     repo: string | null;
     state: TaskState;
@@ -233,7 +235,7 @@ export declare function lastErrorLineOf(log: string): {
     text: string;
 } | null;
 /** The result page's own sentence when the decision is on it. */
-export declare const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
+export declare const RESULT_DECISION_SENTENCE = "Review the change, then accept it or send it back.";
 /** What the result page's Accept says, from facts it already shows: the
  * recorded checks, the requirements not met, whether the saved proof reads,
  * and what the button posts. "Accept and finish" only when everything is met