toolroll 0.9.7 → 0.9.9

package/dist/work-index.d.ts

@@ -66,3 +66,14 @@ export declare class WorkIndexCursorError extends Error {
  * Cursors bind the admitted scope, project and view, never broaden access. */
 export declare function workIndexPage(store: Store, now: Date, access: WorkSummaryAccess, options?: WorkIndexOptions): WorkIndexPage;
 export declare function workCountsByProject(store: Store, now: Date, access: WorkSummaryAccess): WorkProjectCounts[];
+/** Families whose headline is Ready for review, newest first: the Tasks
+ * list's own rows, so a completed family (root or any revision), a failed
+ * check and a superseded version never count. */
+export declare function workReadyForReview(store: Store, now: Date, access: WorkSummaryAccess, limit?: number): {
+    count: number;
+    results: {
+        rootId: string;
+        taskId: string;
+        run: number | null;
+    }[];
+};

package/dist/work-index.js

@@ -1,12 +1,17 @@
 /** Paginated, permission-bound summaries of saved task facts. These reads do
- * not verify artifacts, inspect processes, or authorize task operations. */
+ * 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 { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { readProjectAccess } from './project-access.js';
 import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
-import { scopeTermsProblem } from './store.js';
+import { scopeTermsProblem, stopFactOf } from './store.js';
 import { plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
 import { isCheckLevel } from './check-levels.js';
+import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
+import { NEEDS, processNeedOf } from './needs-you.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 };
@@ -20,6 +25,8 @@ const s = (row, key) => row[key] == null ? null : String(row[key]);
  * 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');
+/** A row whose build may still be running (the store's reading, custodyReadings): Waiting, not Needs you. */
+const CUSTODY_WAITS = `(custody_unresolved AND code IN ('process-needs-attention','result-needs-attention') AND ref_id IN (SELECT value FROM json_each($waitingCustody)))`;
 const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   SELECT t.id, t.title, t.state, t.created_at, t.updated_at, r.id ref_id, r.repo,
     r.revision_of, r.revision_brief_artifact, r.assigned_runner, r.plan,
@@ -55,7 +62,8 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     (SELECT id FROM run WHERE task_ref=a.ref_id AND outcome IS NULL ORDER BY id DESC LIMIT 1) unfinished,
     CASE WHEN a.state='done' THEN (SELECT id FROM run WHERE task_ref=a.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1) END result_id,
     (SELECT h.id FROM hold h WHERE h.task_ref=a.ref_id AND (h.until IS NULL OR h.until>$now) ORDER BY h.held_at,h.id LIMIT 1) hold_id,
-    q.decision_id,cu.task_ref IS NOT NULL custody_unresolved
+    q.decision_id,(cu.task_ref IS NOT NULL OR a.ref_id IN (SELECT value FROM json_each($workspaceCustody)))
+      AND a.ref_id NOT IN (SELECT value FROM json_each($settledCustody)) custody_unresolved
   FROM admitted a LEFT JOIN lineage l ON l.ref_id=a.ref_id
   LEFT JOIN questions q ON q.task_ref=a.ref_id LEFT JOIN custody cu ON cu.task_ref=a.ref_id
 ), family_heads AS MATERIALIZED (
@@ -197,9 +205,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','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') AND NOT ${CUSTODY_WAITS} 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','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
+      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,
     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))
@@ -235,8 +243,38 @@ function registerValidators(store) {
     registered.set(db, projection);
     return projection;
 }
-function parameters(now, access, options) {
-    return { $now: now.toISOString(), $alive: new Date(now.getTime() - 180_000).toISOString(),
+/** The list can't see processes: each task whose build Toolroll can't yet
+ * confirm stopped, as the store reads it now (the task page's own reading).
+ * Null when it has since settled; `open` runs are the classification's own.
+ * `workspace`: a finished task whose last build's workspace note is still
+ * there, which only the store can read (a held or unreadable workspace). */
+function custodyReadings(store) {
+    const refs = store.handle.prepare(`SELECT r.task_ref FROM held_session h JOIN run r ON r.id=h.run WHERE h.ended_at IS NULL
+    UNION SELECT r.task_ref FROM run r WHERE r.provider_started_at IS NOT NULL AND NOT EXISTS(SELECT 1 FROM run_process p WHERE p.run=r.id)
+    UNION SELECT r.task_ref FROM run_process p JOIN run r ON r.id=p.run WHERE p.exited_at IS NULL AND p.container_empty_at IS NULL`).all().map(row => Number(row['task_ref']));
+    const noted = store.handle.prepare(`SELECT r.task_ref,r.worktree FROM task t JOIN task_ref tr ON tr.external_id=t.id
+    JOIN run r ON r.id=(SELECT MAX(id) FROM run WHERE task_ref=tr.id AND role IN ('builder','scout') AND finished_at IS NOT NULL)
+    WHERE t.state='done' AND r.worktree IS NOT NULL`).all()
+        .filter(row => existsSync(join(String(row['worktree']), MARKER))).map(row => Number(row['task_ref']));
+    const readings = new Map();
+    for (const ref of new Set([...refs, ...noted])) {
+        let found = null;
+        for (const run of store.runsFor(ref)) {
+            const fact = stopFactOf(store, run.id);
+            if (fact !== null && fact.kind !== 'open') {
+                found = fact;
+                break;
+            }
+        }
+        readings.set(ref, found);
+    }
+    return { readings, workspace: new Set(noted) };
+}
+function parameters(now, access, options, custody) {
+    const ids = (keep) => JSON.stringify([...custody.readings].filter(([ref, fact]) => keep(ref, fact)).map(([ref]) => ref));
+    return { $settledCustody: ids((_, fact) => fact === null), $waitingCustody: ids((_, fact) => fact !== null && 'wait' in (processNeedOf(fact) ?? {})),
+        $workspaceCustody: ids((ref, fact) => fact !== null && custody.workspace.has(ref)),
+        $now: now.toISOString(), $alive: new Date(now.getTime() - 180_000).toISOString(),
         $all: access.repos === null ? 1 : 0, $repos: JSON.stringify(access.repos ?? []),
         $unplaced: access.principal === 'operator' && access.includeUnplaced === true ? 1 : 0,
         $projectSet: options.project != null ? 1 : 0, $project: options.project ?? null, $state: options.state ?? null, $leadId: options.leadId ?? null };
@@ -279,6 +317,7 @@ function readCursor(value, scope) {
  * Cursors bind the admitted scope, project and view, never broaden access. */
 export function workIndexPage(store, now, access, options = {}) {
     const projection = registerValidators(store);
+    const custody = custodyReadings(store);
     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);
@@ -309,21 +348,39 @@ export function workIndexPage(store, now, access, options = {}) {
     '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() });
+        .all({ ...parameters(now, access, options, custody), $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'])));
     const page = selected.slice(0, limit), last = page.at(-1);
     const nextCursor = selected.length > limit && last !== undefined ? Buffer.from(JSON.stringify({ version: 1, scope,
         rank: n(last, 'rank'), at: s(last, 'sort_at'), root: n(last, 'root_ref') })).toString('base64url') : null;
     const projects = JSON.parse(String(rows[0]?.['row_json'] ?? '[]')).map(row => ({ repo: s(row, 'repo'), totals: counts(row), queued: n(row, 'queued'), doneRecently: n(row, 'done_recently') }));
-    return { items: page.map(row => itemOf(row, access.principal)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]), nextCursor, limit, view };
+    // A row whose build Toolroll can't confirm stopped reads the store's own answer, as the task page does.
+    const probe = (taskId) => {
+        const ref = store.lookupRef(taskId);
+        return ref === null ? null : custody.readings.get(ref.id) ?? null;
+    };
+    return { items: page.map(row => itemOf(row, access.principal, probe)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
     const projection = registerValidators(store);
     return store.handle.prepare(`${projection} SELECT repo,${TOTALS},SUM(state='queued' AND family_running=0) queued,
     SUM(state='done' AND family_running=0 AND updated_at>=$recent) done_recently FROM ranked GROUP BY repo ORDER BY repo`)
-        .all({ ...parameters(now, access, {}), $recent: new Date(now.getTime() - 86_400_000).toISOString() })
+        .all({ ...parameters(now, access, {}, custodyReadings(store)), $recent: new Date(now.getTime() - 86_400_000).toISOString() })
         .map(row => ({ repo: s(row, 'repo'), totals: counts(row), queued: n(row, 'queued'), doneRecently: n(row, 'done_recently') }));
 }
+/** Families whose headline is Ready for review, newest first: the Tasks
+ * list's own rows, so a completed family (root or any revision), a failed
+ * check and a superseded version never count. */
+export function workReadyForReview(store, now, access, limit = 5) {
+    const ready = [];
+    let cursor = null;
+    do {
+        const page = workIndexPage(store, now, access, { view: 'needs-you', limit: WORK_INDEX_MAX_LIMIT, cursor });
+        ready.push(...page.items.filter(one => one.status.label === 'Ready for review'));
+        cursor = page.nextCursor;
+    } while (cursor !== null);
+    return { count: ready.length, results: ready.slice(0, Math.max(0, limit)).map(one => ({ rootId: one.rootId, taskId: one.activeTaskId, run: one.resultRunId })) };
+}
 /** 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). */
@@ -347,9 +404,16 @@ function listChecksOf(own, level, follows) {
         return null;
     return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
 }
-function itemOf(row, principal) {
+/** 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',
+};
+function itemOf(row, principal, probe) {
     const code = String(row['code']), id = String(row['id']);
-    const need = n(row, 'needs') === 1, running = n(row, 'family_running') === 1;
+    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 need = n(row, 'needs') === 1 && !waiting, running = n(row, 'family_running') === 1;
     const assignmentState = code === 'complete' ? 'complete' : code === 'ready-to-check' ? 'ready-to-check'
         : code === 'cancelled' ? 'cancelled' : need ? 'needs-decision' : 'working';
     const words = {
@@ -375,7 +439,7 @@ function itemOf(row, principal) {
         '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', 'Review plan'],
+        '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'],
@@ -409,6 +473,18 @@ function itemOf(row, principal) {
         actionCode = 'open-result';
         actionLabel = 'Open result';
     }
+    if (process !== null && 'need' in process) {
+        actionCode = 'confirm-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;
+    }
     if (actionCode === null) {
         actionCode = code === 'running' ? 'inspect-run' : 'inspect-task';
         actionLabel = code === 'running' ? 'Watch the build' : 'View task details';
@@ -417,21 +493,32 @@ function itemOf(row, principal) {
     const primaryAction = actionCode === null ? null : { code: actionCode, label: actionLabel,
         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,
+                : 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,
             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 coded = stageOfCode(code, { needsPerson: need, 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' }
+            : 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';
     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 }),
+    const shared = taskStatusOf({ stage: reading.stage, ...(reading.need === undefined ? {} : { need: reading.need }), ...(reading.wait === undefined ? {} : { wait: reading.wait }),
+        ...(process === null ? {} : { needContext: { build: process.build } }),
         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;
+    // Every Needs you action wears its need's own words.
+    if (shared.need != null && shared.need.key !== 'other' && shared.need.key !== 'review-result' && primaryAction !== null) {
+        actionLabel = shared.need.action.label;
+        primaryAction.label = actionLabel;
+    }
     const views = ['all'];
     if (need)
         views.push('needs-you');

package/dist/work-summary.d.ts

@@ -8,7 +8,9 @@ export type WorkTarget = {
     decisionId: number | null;
 };
 export type WorkAction = {
-    code: DispatchAction | "inspect-task" | "inspect-run" | "inspect-stop" | "inspect-decisions" | "reconcile-run" | "open-pr";
+    /** `confirm-stopped`: an approver confirms a finished build stopped (behind the password);
+     * `sign-in`: the agent's sign-in, in Settings. */
+    code: DispatchAction | "inspect-task" | "inspect-run" | "inspect-stop" | "inspect-decisions" | "reconcile-run" | "open-pr" | "confirm-stopped" | "sign-in";
     label: string;
     target: WorkTarget;
     access: "read" | "operator-control" | "proposal-only" | "operator-handoff";

package/dist/work-summary.js

@@ -6,6 +6,7 @@ import { resultCheckLevel } from "./result-follow-ups.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
 import { isAlive } from "./runner.js";
 import { taskControlOf } from "./task-control.js";
+import { buildReviewOf } from "./review-switch.js";
 import { reviewFactsOf, workStatusOf } from "./workspace-ui.js";
 /** Call only after admitting the task's project. Keep the question's
  * exact run and id; never substitute a family's newest attempt. Expiry
@@ -103,7 +104,7 @@ export function taskWorkSummaryOf(store, taskId, now, access) {
             review: reviewFactsOf(store.reviewRetryStateOf(result.id), name => {
                 const runner = store.getRunner(name)?.runner;
                 return runner !== undefined && isAlive(runner, now);
-            }),
+            }, buildReviewOf(store, result.id)?.state === "pending"),
             ...(result.outcome !== "no-change" ? {} : { recordComplete: (() => {
                     const kinds = new Set(store.artifactsFor(result.id).map(one => one.kind));
                     return kinds.has("handoff") && kinds.has("terminal-diff");

package/dist/workspace-ui.d.ts

@@ -68,11 +68,13 @@ export type ReviewFacts = {
     queuedOrigin?: "operator" | "automatic" | null;
     /** Whether the live attempt's reviewer worker is answering. */
     reviewerAlive: boolean;
+    /** The build's one automatic review is still pending (build-review.ts). */
+    automaticPending?: boolean;
 };
 /** The review facts from the store's bounded retry projection — the same
  * reading `diagnoseTaskDispatch` makes, so every surface starts from one
  * record. `reviewerAlive` answers for the live attempt's runner. */
-export declare function reviewFactsOf(retry: ReviewRetryState | null, reviewerAlive: (runner: string) => boolean): ReviewFacts | null;
+export declare function reviewFactsOf(retry: ReviewRetryState | null, reviewerAlive: (runner: string) => boolean, automaticPending?: boolean): ReviewFacts | null;
 /** The tokens a review in flight wears — the dispatch codes, unchanged. */
 export declare const REVIEW_TOKENS: ReadonlySet<string>;
 /**

package/dist/workspace-ui.js

@@ -30,7 +30,7 @@ export function parseWorkView(raw) {
 /** The review facts from the store's bounded retry projection — the same
  * reading `diagnoseTaskDispatch` makes, so every surface starts from one
  * record. `reviewerAlive` answers for the live attempt's runner. */
-export function reviewFactsOf(retry, reviewerAlive) {
+export function reviewFactsOf(retry, reviewerAlive, automaticPending = false) {
     if (retry === null || retry.state === "unrequested")
         return null;
     const current = retry.live ?? (retry.state === "queued" ? null : retry.latest);
@@ -45,6 +45,7 @@ export function reviewFactsOf(retry, reviewerAlive) {
         queuedBy: retry.openRequest?.requestedBy ?? null,
         queuedOrigin: retry.openRequest?.origin ?? null,
         reviewerAlive: retry.live !== null && reviewerAlive(retry.live.runner),
+        automaticPending,
     };
 }
 /** The tokens a review in flight wears — the dispatch codes, unchanged. */
@@ -59,12 +60,12 @@ const retriesLeft = (count, explicit = true) => `${count}${explicit ? " explicit
  * the v50 dispatch contract; nothing here changes the lifecycle.
  */
 export function reviewStatusOf(review) {
-    // Model review is retired (2026-09-21): nothing schedules, retries or
-    // waits for a reviewer, so a recorded review request or attempt is
-    // history and never the result's primary status. The stored verdict and
-    // the assignment's Ready/Complete state speak instead.
-    void review;
-    return null;
+    // The one automatic review (build-review.ts) holds the result only while it
+    // is queued or running. A failed review never blocks: the result reads as
+    // it would unreviewed, marked "not reviewed" by the result itself.
+    if (review === null || review.automaticPending !== true || (review.state !== "queued" && review.state !== "running"))
+        return null;
+    return { token: "reviewing", label: "Reviewing", detail: "An automatic review is reading this result before it reaches you.", tone: "live", action: { label: "Open the result", kind: "open-result" } };
 }
 const FAILED_CHECK = /^the repository's approved verification command exited (-?[0-9]+)/;
 export function evidenceProblemOf(verdict, reasons) {
@@ -123,7 +124,7 @@ export function publicationStatusOf(publication) {
  * the detail).
  */
 export function resultStatusOf(result, publication = null) {
-    return storedResultStatusOf(result, publication);
+    return (result?.role === "builder" ? reviewStatusOf(result.review ?? null) : null) ?? storedResultStatusOf(result, publication);
 }
 /** What the machine itself recorded about a result, in a clause. */
 function machineVerdictWords(result) {
@@ -290,7 +291,7 @@ const DISPATCH_ACTION_LABELS = {
     "place-task": "Choose a project",
     "write-scope": "Define the task",
     "select-agent": "Choose an agent",
-    "approve-scope": "Review plan",
+    "approve-scope": "Approve plan",
     "answer-decision": "Answer the question",
     unhold: "Review hold",
     "inspect-hold": "Review hold",

package/dist/worktree.d.ts

@@ -76,6 +76,8 @@ export type KeptWhy = "has changes" | "has commits" | "unreadable" | "git refuse
  * something is in there.
  */
 export declare const MARKER = ".standing-orders-lease";
+/** What a kept checkout drops once its run ends (only where .gitignore hides it): dependencies and build output. */
+export declare const SLIM_NAMES: readonly string[];
 /** Creating a worktree copies a tree; it is local work but not instant. */
 export declare const WORKTREE_TIMEOUT_MS = 60000;
 /**
@@ -251,6 +253,20 @@ export declare class WorktreePool {
             why: KeptWhy;
         }[];
     }>;
+    /**
+     * Drop a let-go, idle checkout's dependencies and build output: the folders .gitignore hides that are named like
+     * them (SLIM_NAMES). Its work, tracked or untracked, is untouched. The setup stamp goes first, so the next lease
+     * runs the project's setup again and restores them. `wanted` is asked again right before anything goes; `deps`
+     * false keeps node_modules (no setup would restore it).
+     */
+    slim(row: WorktreeRow, wanted: (row: WorktreeRow) => boolean, deps?: boolean): Promise<{
+        ok: true;
+        dropped: string[];
+        bytes: number;
+    } | {
+        ok: false;
+        message: string;
+    }>;
     /**
      * Throw away a let-go checkout kept for its changes, on purpose: the working copy and what is uncommitted in it
      * go; its branch, and every commit on it, stays. Refused while anything holds it.

package/dist/worktree.js

@@ -30,6 +30,7 @@ import { run } from "./exec.js";
 import { currentBootId, provenDeadByBootChange } from "./boot-identity.js";
 import { HANDOFF_PREFIX, MAILBOX_SUFFIX, looksLikeProtocolFile, readMailbox } from "./evidence.js";
 import { parseHandoff } from "./decision.js";
+import { diskBytes } from "./storage.js";
 /**
  * The note a lease leaves in the checkout, naming the process holding it.
  *
@@ -40,6 +41,8 @@ import { parseHandoff } from "./decision.js";
 export const MARKER = ".standing-orders-lease";
 /** Checkouts this process is leasing or removing right now: a lease and storage retention never overlap on one. */
 const busy = new Map();
+/** What a kept checkout drops once its run ends (only where .gitignore hides it): dependencies and build output. */
+export const SLIM_NAMES = ["node_modules", "dist", "build", "out", ".next", ".nuxt", ".svelte-kit", ".turbo", ".parcel-cache", "coverage", "target"];
 /** Creating a worktree copies a tree; it is local work but not instant. */
 export const WORKTREE_TIMEOUT_MS = 60_000;
 const GIT = "git";
@@ -706,6 +709,50 @@ export class WorktreePool {
         }
         return { removed, kept };
     }
+    /**
+     * Drop a let-go, idle checkout's dependencies and build output: the folders .gitignore hides that are named like
+     * them (SLIM_NAMES). Its work, tracked or untracked, is untouched. The setup stamp goes first, so the next lease
+     * runs the project's setup again and restores them. `wanted` is asked again right before anything goes; `deps`
+     * false keeps node_modules (no setup would restore it).
+     */
+    async slim(row, wanted, deps = true) {
+        const idle = (now) => now !== null && now.runner === null && now.releasedAt !== null && now.releasedAt === row.releasedAt && !this.inUse(row.path).held;
+        if (busy.has(row.path) || !existsSync(row.path) || !idle(this.store.getWorktree(row.path)))
+            return { ok: false, message: `${row.path} is in use` };
+        const listed = await this.runner(GIT, [...READ_ONLY, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"], { cwd: row.path, timeoutMs: WORKTREE_TIMEOUT_MS });
+        if (listed.code !== 0)
+            return { ok: false, message: `git couldn't list ${row.path}` };
+        const drop = listed.stdout.split("\0").filter(one => one.endsWith("/")).map(one => one.slice(0, -1))
+            .filter(one => { const name = one.split("/").at(-1); return SLIM_NAMES.includes(name) && (deps || name !== "node_modules"); });
+        if (drop.length === 0)
+            return { ok: true, dropped: [], bytes: 0 };
+        busy.set(row.path, "removing");
+        const note = join(row.path, MARKER);
+        let held = false;
+        try {
+            const now = this.store.getWorktree(row.path);
+            if (!idle(now) || !wanted(now))
+                return { ok: false, message: `${row.path} is in use` };
+            // Held while it slims: another process's lease sees this process in it.
+            try {
+                writeFileSync(note, `${process.pid} storage-retention slimming ${currentBootId() ?? "unknown"} ${hostname()}\n`, "utf8");
+                held = true;
+            }
+            catch {
+                return { ok: false, message: `${row.path} couldn't be held` };
+            }
+            const sizes = diskBytes(drop.map(one => join(row.path, one)));
+            this.store.forgetWorktreeSetup(row.path);
+            for (const one of drop)
+                rmSync(join(row.path, one), { recursive: true, force: true, maxRetries: 3 });
+            return { ok: true, dropped: drop, bytes: [...sizes.values()].reduce((sum, one) => sum + one, 0) };
+        }
+        finally {
+            if (held)
+                rmSync(note, { force: true });
+            busy.delete(row.path);
+        }
+    }
     /**
      * Throw away a let-go checkout kept for its changes, on purpose: the working copy and what is uncommitted in it
      * go; its branch, and every commit on it, stays. Refused while anything holds it.

package/package.json

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