toolroll 0.9.7 → 0.9.9

package/CHANGELOG.md

@@ -1,6 +1,53 @@
 # Changelog
 
-## Unreleased
+## 0.9.9 — 2026-10-02
+
+- **Faster, lighter tests.** The unit suite runs about three times faster
+  (the biggest test files are split by area), tests use at most 4 workers,
+  and a project's Quick check can be a typecheck plus the tests for the
+  changed files.
+- **Toolroll cleans up after itself.** When a run ends, it stops what the run
+  left running. Tests delete their temp folders, and `toolroll storage clean`
+  removes leftovers. Replaced release checks give up their checkouts, and
+  kept checkouts drop their dependencies until they're needed.
+- **Checkouts share dependencies.** One install per lockfile, linked into
+  each checkout: about 1,900 files instead of 20,000, set up in under a second.
+- **Every "Needs you" says what it needs, with the button that does it.**
+  Anything you can't act on shows as Waiting instead.
+- **Finished tasks read Complete everywhere.** Status, the console and chat
+  agree, and old "process exit not recorded" entries clear themselves.
+- **Updates never hang.** The updater settles leftover records itself, stops
+  waiting after 2 minutes otherwise, and says the one command that clears it.
+  Release checks now test upgrading from the last three releases.
+- **Screenshots stay out of the repository.** Images under `evidence/` are
+  left out of commits and show as one line in the review.
+
+## 0.9.8 — 2026-10-01
+
+- **One automatic review per build.** When a build's checks pass (or it
+  finishes, with checks Off) in a project with review on, one read-only
+  reviewer reads the scope, acceptance and diff and grades each finding HIGH,
+  MEDIUM or LOW. Any HIGH sends the task back once, with the findings as its
+  note; a HIGH on that revision comes to you. MEDIUM and LOW never block: they
+  show on the result as suggested follow-ups. A review that fails or times
+  out never blocks: the result reaches you marked Not reviewed. Turn it on or
+  off per project in Settings or with `toolroll review on|off --repo <path>`;
+  it's on by default under a hands-off mode. Release candidate checks are
+  never reviewed.
+- **Evidence is kept 1, 7, 14 or 28 days, or forever.** Settings →
+  Retention and `toolroll retention set evidence 1d` take any of them. Until
+  someone chooses, evidence is kept 28 days: **after upgrading, the daily
+  sweep starts removing finished tasks' evidence older than 28 days.** A
+  period chosen before stays as it was; one the page no longer offers shows
+  as "30 days (custom)".
+  Nothing a task still needs is removed: unfinished tasks, results Ready for
+  review, anything on hold, live runs and release candidates.
+- **A run whose process never started no longer blocks updates.** A spawn
+  that fails now settles its own record, and Toolroll settles a finished run's
+  leftover record once its processes are provably gone, noting it in the
+  ledger. For the rare record that can't be proven either way, an approver
+  can run `toolroll run settle <run> --why "<reason>"`; it refuses while
+  anything of the run is alive.
 
 ## 0.9.7 — 2026-10-01
 

package/dist/assignment-adapters.d.ts

@@ -140,6 +140,7 @@ export declare function assignmentForCoordinator(store: Store, token: string, op
                     prUrl: string | null;
                     remoteState: string | null;
                 } | null;
+                review: import("./review-switch.js").BuildReviewView | null;
                 deployment: {
                     status: "not-recorded";
                 };

package/dist/assignment-adapters.js

@@ -1,5 +1,6 @@
 /** Assignment reads and delivery acknowledgments. These adapters never start
  * work, answer a decision, accept proof, or change an approval. */
+import { buildReviewLines } from "./review-switch.js";
 import { readFileSync, statSync } from "node:fs";
 import { authenticateCoordinator } from "./coordinator.js";
 import { assignmentOf, assignmentUpdates, claimAssignment, checkAssignment } from "./assignment.js";
@@ -113,6 +114,7 @@ function assignmentLines(assignment) {
             ...(receipt.agentReport === null ? [] : [`Agent report: ${receipt.agentReport}`]),
             `Receipt: ${receipt.digest}`,
         ]),
+        ...buildReviewLines(assignment.review ?? null).map(line => line.trimStart().replace(/^review: /, "Review: ")),
         ...(assignment.savedContext === undefined ? [] : [
             ...(assignment.savedContext.goal === null ? [] : [`Goal: ${assignment.savedContext.goal}`]),
             ...(assignment.savedContext.outOfScope === null ? [] : [`Out of scope: ${assignment.savedContext.outOfScope}`]),

package/dist/assignment-brief.d.ts

@@ -23,6 +23,8 @@ export type AssignmentCatchUp = {
         } | null;
         nextAction: AssignmentSnapshot["primaryAction"];
         attention: string[];
+        /** Where the next action leads in the console (navigation only). */
+        nextHref?: string | null;
         decisions: {
             id: number;
             runId: number;

package/dist/assignment-brief.js

@@ -1,5 +1,6 @@
 /** A bounded catch-up over saved project/task records, not conversation memory.
  * Callers authenticate first and pass their current project ceiling. */
+import { browserWorkActionHref } from './browser-crew.js';
 import { createHash } from "node:crypto";
 import { workIndexPage } from "./work-index.js";
 import { publicChatText } from "./chat-display.js";
@@ -72,7 +73,7 @@ export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot)
                 runId: item.liveRunId ?? item.unfinishedRunId ?? item.resultRunId, resultRunId: item.resultRunId,
                 outcome: saved?.["handoff"] == null ? null : text(String(saved["handoff"]), 400),
                 checks: item.resultRunId === null ? null : { status: "not-read", exitCode: null, detail: "Saved checks were not revalidated. Use assignment show to inspect them." },
-                nextAction: item.primaryAction, attention: attention.slice(0, 3).map(one => text(one, 160)),
+                nextAction: item.primaryAction, nextHref: browserWorkActionHref(item), attention: attention.slice(0, 3).map(one => text(one, 160)),
                 decisions: decisions.map(row => ({ id: Number(row["id"]), runId: Number(row["run"]), question: text(String(row["question"]), 240), state: String(row["state"]),
                     overdue: row["state"] !== "answered" && row["deadline"] !== null && String(row["deadline"]) <= now.toISOString(), choice: row["choice"] == null ? null : text(String(row["choice"]), 80) })),
             };

package/dist/assignment-presentation.js

@@ -35,9 +35,11 @@ export function assignmentPresentationOf(assignment, options = {}) {
     // rank stay the existing projection's (pages and tests key off them).
     const shared = { label: taskStatus.headline, tone: workToneOf(taskStatus.headline), detail: taskStatus.sentence, action: null };
     const needsYou = taskStatus.headline === 'Needs you';
+    // Waiting needs no one: never listed under Needs you.
+    const waiting = taskStatus.headline === 'Waiting';
     const status = state === 'working'
         ? { ...shared, token: `assignment-${state}`,
-            views: [...new Set([...(work?.views?.filter(view => view !== 'completed') ?? ['all']), ...(needsYou ? ['needs-you'] : [])])], rank: needsYou ? 0 : work?.rank ?? 2 }
+            views: [...new Set([...(work?.views?.filter(view => view !== 'completed' && !(waiting && view === 'needs-you')) ?? ['all']), ...(needsYou ? ['needs-you'] : [])])], rank: needsYou ? 0 : waiting ? 2 : work?.rank ?? 2 }
         : { ...shared, token: `assignment-${state}`,
             views: state === 'ready-to-check' || state === 'needs-decision' ? ['all', 'needs-you'] : state === 'complete' ? ['all', 'completed']
                 : state === 'checking' && work?.views?.includes('running') ? ['all', 'running'] : ['all'],

package/dist/assignment-status.d.ts

@@ -17,7 +17,7 @@ export declare function assignmentStatusBrief(assignment: AssignmentSnapshot): {
     } | null;
     runId: number | null;
     primaryAction: {
-        code: "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "reconcile-run" | import("./dispatch.js").DispatchAction;
+        code: "confirm-stopped" | "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "reconcile-run" | "sign-in" | import("./dispatch.js").DispatchAction;
         label: string;
         target: import("./work-summary.js").WorkTarget;
     } | null;

package/dist/assignment-ui.js

@@ -27,6 +27,11 @@ export function assignmentActionHref(assignment) {
         return `/d/${decisionId}`;
     if (action.code === 'inspect-decisions')
         return '/';
+    if (action.code === 'sign-in')
+        return '/settings#providers';
+    // The confirmation sits on the task page, behind the password.
+    if (action.code === 'confirm-stopped')
+        return `/t/${encodeURIComponent(assignment.rootId)}#confirm-stopped`;
     if (action.code === 'open-pr' && /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(assignment.publication?.prUrl ?? ''))
         return assignment.publication.prUrl;
     if (runId !== null && (action.code === 'open-result' || action.code === 'open-pr' || action.code === 'retry-review')) {

package/dist/assignment.d.ts

@@ -2,6 +2,8 @@ import { type Store, type ProofVerdictRow, type ProofAcceptanceRow } from "./sto
 import { type WorkAction, type WorkSummaryAccess } from "./work-summary.js";
 import { type VerifiedApprover } from "./principal.js";
 import { type CheckLevel } from "./check-levels.js";
+import { type BuildReviewView } from "./review-switch.js";
+import { type NeedKey, type WaitKey } from "./needs-you.js";
 export type AssignmentAccess = WorkSummaryAccess;
 export type AssignmentOwner = {
     kind: "coordinator" | "lead";
@@ -92,9 +94,20 @@ export type AssignmentSnapshot = {
         prUrl: string | null;
         remoteState: string | null;
     } | null;
+    /** The result's one automatic review, when its project had review on:
+     * pending, HIGH findings, suggested follow-ups (MEDIUM/LOW), or not reviewed. */
+    review: BuildReviewView | null;
     deployment: {
         status: "not-recorded";
     };
+    /** What this assignment asks of a person, or waits for when no person can act (needs-you.ts). */
+    need?: {
+        key: NeedKey;
+        build: number | null;
+    } | {
+        wait: WaitKey;
+        build: number | null;
+    } | null;
 };
 /** Status-first handoff for routine reads. Fetch get_assignment only when
  * inspecting its exact evidence; do not repeat a full proof in every poll. */
@@ -142,6 +155,7 @@ export declare function assignmentBrief(assignment: AssignmentSnapshot | null):
         prUrl: string | null;
         remoteState: string | null;
     } | null;
+    review: BuildReviewView | null;
     deployment: {
         status: "not-recorded";
     };
@@ -220,6 +234,7 @@ export declare function assignmentUpdates(store: Store, now: Date, access: Assig
                 prUrl: string | null;
                 remoteState: string | null;
             } | null;
+            review: BuildReviewView | null;
             deployment: {
                 status: "not-recorded";
             };

package/dist/assignment.js

@@ -6,7 +6,7 @@ import { currentActor, withActor } from "./actor.js";
 import { replacedWords } from "./task-status.js";
 import { COMPLETION_ACTION, familyChangedFiles } from "./result-completion.js";
 import { homedir } from "node:os";
-import { readSchemaVersion } from "./store.js";
+import { readSchemaVersion, stopFactOf } from "./store.js";
 import { approvalOf } from "./scope.js";
 import { openWorkDecisionOf, taskWorkSummaryOf, workDecisionAction } from "./work-summary.js";
 import { evidenceRoot, readVerifiedArtifact, readVerifiedReport } from "./evidence.js";
@@ -16,6 +16,9 @@ import { noteAssignmentStatus } from "./assignment-status.js";
 import { historicalAssessmentReason } from "./assignment-presentation.js";
 import { runCheckLevel } from "./check-levels.js";
 import { followUpChecksOf, withFollowUps } from "./result-follow-ups.js";
+import { buildReviewOf, findingWords } from "./review-switch.js";
+import { NEEDS, WAITS, processNeedOf } from "./needs-you.js";
+import { assignmentStageOf } from "./task-status.js";
 /** Status-first handoff for routine reads. Fetch get_assignment only when
  * inspecting its exact evidence; do not repeat a full proof in every poll. */
 export function assignmentBrief(assignment) {
@@ -29,7 +32,7 @@ export function assignmentBrief(assignment) {
             base: receipt.base, head: receipt.head, completionKind: receipt.completionKind,
             checks: receipt.checks, proofAcceptance: receipt.proofAcceptance, verdict: receipt.proof?.verdict ?? null,
             criteria: { passed: receipt.proof?.matrix.filter(row => row.state === "pass").length ?? 0, total: receipt.proof?.matrix.length ?? 0 }, evidence: receipt.evidence },
-        publication: assignment.publication, deployment: assignment.deployment };
+        publication: assignment.publication, review: assignment.review, deployment: assignment.deployment };
 }
 const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 /** A lookup added with lead-quiet, read safely: a deploy proves completion with this code over the INSTALLED runtime's
@@ -182,11 +185,17 @@ export function assignmentOf(store, taskId, now, access, root) {
     let detail = work.status.detail;
     let primaryAction = work.primaryAction;
     const live = work.liveRunId !== null || work.status.token === "running";
-    const processProblem = result === null ? null : store.stopQuiescenceProblem(result.id);
+    const processFact = result === null ? null : stopFactOf(store, result.id);
+    const processProblem = processFact?.problem ?? null;
+    let need = null;
     // The exact completed result, scope, family and custody fences apply to
     // every deliverable. Human acceptance remains its own recorded authority;
     // it never changes a machine verdict or supplies a missing report.
-    const ready = current.state === "done" && result !== null && completionKind !== null &&
+    // Kept out of the sealed receipt (sealedChecks): the review never changes the result's digest.
+    const review = result === null ? null : olderStoreSafe(() => buildReviewOf(store, result.id), null);
+    // A result under its one automatic review has not reached the person yet.
+    const reviewing = review?.state === "pending" && current.state === "done";
+    const ready = !reviewing && current.state === "done" && result !== null && completionKind !== null &&
         scope !== null && scope.termsProblem == null && approvalOf(scope).approved && scope.digest === result.scopeDigest &&
         store.activeHolds(current.refId, now).length === 0 && store.applicableStopFor(result.id) === null &&
         processProblem === null &&
@@ -200,10 +209,23 @@ export function assignmentOf(store, taskId, now, access, root) {
         primaryAction = successor === null ? { code: "inspect-task", label: "View assignment", target: { taskId: current.id, runId: null, decisionId: null }, access: "read", retry: "read-again" }
             : { code: "inspect-task", label: `Open ${successor}`, target: { taskId: successor, runId: null, decisionId: null }, access: "read", retry: "read-again" };
     }
-    else if (!live && processProblem !== null && result !== null) {
-        state = "needs-decision";
-        detail = processProblem;
-        primaryAction = { code: "inspect-run", label: "Inspect run", target: { taskId: current.id, runId: result.id, decisionId: null }, access: "read", retry: "read-again" };
+    else if (!live && processFact !== null && result !== null) {
+        // Toolroll can't confirm the build stopped. A person confirms it when
+        // nothing of it may still run; otherwise the work waits, needing no one.
+        const process = processNeedOf(processFact);
+        if ("need" in process) {
+            state = "needs-decision";
+            detail = NEEDS[process.need].sentence({ build: process.build });
+            primaryAction = { code: "confirm-stopped", label: NEEDS[process.need].action.label, target: { taskId: current.id, runId: process.build, decisionId: null },
+                access: access.principal === "operator" ? "operator-control" : "operator-handoff", retry: "refresh-before-acting" };
+            need = { key: process.need, build: process.build };
+        }
+        else {
+            state = "working";
+            detail = WAITS[process.wait]({ build: process.build });
+            primaryAction = { code: "inspect-run", label: "View the build", target: { taskId: current.id, runId: process.build, decisionId: null }, access: "read", retry: "read-again" };
+            need = { wait: process.wait, build: process.build };
+        }
     }
     else if (current.state === "done" && questions.length > 0 && work.status.tone !== "problem" &&
         !["stopping", "stopped", "review-failed", "review-exhausted"].includes(work.status.token) &&
@@ -213,6 +235,11 @@ export function assignmentOf(store, taskId, now, access, root) {
         detail = question.decision.question;
         primaryAction = workDecisionAction(question.taskId, question.decision, access.principal);
     }
+    else if (reviewing && result !== null) {
+        state = "checking";
+        detail = "An automatic review is reading this result before it reaches you.";
+        primaryAction = { code: "inspect-run", label: "Open result", target: { taskId: current.id, runId: result.id, decisionId: null }, access: "read", retry: "read-again" };
+    }
     else if (ready && receipt !== null) {
         state = "ready-to-check";
         detail = completionKind === "research-report" ? "The research report is ready for the lead to read."
@@ -242,6 +269,14 @@ export function assignmentOf(store, taskId, now, access, root) {
                 ? completionKind === null ? "The research report is missing or incomplete. Inspect the saved report before checking this handoff."
                     : "The saved report is awaiting resolution of its current scope or hold."
                 : "Inspect the saved result and resolve its remaining execution or scope issue.";
+        // Built to an earlier plan: the result page can't resolve it (accepting would leave it stuck), building again can.
+        if (current.state === "done" && result !== null && scope !== null && scope.termsProblem == null && approvalOf(scope).approved && !!result.scopeDigest && scope.digest !== result.scopeDigest &&
+            store.activeHolds(current.refId, now).length === 0 && unfinished === null && store.currentLiveLease(current.refId, now) === null && store.finalResultReason(result.id) === null) {
+            detail = NEEDS.rebuild.sentence({ build: result.id });
+            primaryAction = { code: "retry-task", label: NEEDS.rebuild.action.label, target: { taskId: current.id, runId: result.id, decisionId: null },
+                access: access.principal === "operator" ? "operator-control" : "operator-handoff", retry: "refresh-before-acting" };
+            need = { key: "rebuild", build: result.id };
+        }
     }
     if (earlierActive.length > 0) {
         attention.push(`${earlierActive.length} earlier task version${earlierActive.length === 1 ? " is" : "s are"} still active.`);
@@ -256,6 +291,13 @@ export function assignmentOf(store, taskId, now, access, root) {
     }
     if (state === "needs-decision")
         attention.push(detail);
+    // Every Needs you action wears its need's own words (needs-you.ts), on every surface.
+    if (state === "needs-decision" && primaryAction !== null && need === null) {
+        const read = assignmentStageOf({ state, primaryAction, review }, { token: work.status.token, views: work.status.views });
+        // A result review keeps its own, more specific words (See what is missing, Open the failed check).
+        if (read.stage === "needs-you" && read.need !== undefined && read.need !== "other" && read.need !== "review-result")
+            primaryAction = { ...primaryAction, label: NEEDS[read.need].action.label };
+    }
     if (receipt !== null) {
         if (finishedBuild && receipt.checks.status !== "passed")
             attention.push(receipt.checks.detail);
@@ -263,6 +305,11 @@ export function assignmentOf(store, taskId, now, access, root) {
             attention.push(...(proof?.reasons ?? []).filter(reason => !historicalAssessmentReason(reason)));
         attention.push(...receipt.caveats.filter(reason => !proof?.reasons.includes(reason)));
     }
+    if (review !== null && review.sentBackAs === null) {
+        if (review.state === "not-reviewed")
+            attention.push(`Not reviewed: ${review.reason ?? "the automatic review did not finish"}.`);
+        attention.push(...review.high.map(one => `Review: ${findingWords(one)}`));
+    }
     if (state !== "complete")
         completion = null;
     if (current.state !== "cancelled")
@@ -292,7 +339,7 @@ export function assignmentOf(store, taskId, now, access, root) {
     return { version: 1, rootId: family.root.id, activeTaskId: current.id, repo: current.repo, title: family.root.title,
         state, detail, primaryAction, attention: [...new Set(attention)], attempts, owner, receipt, savedContext, completion, handoff,
         publication: publication === null ? null : { state: publication.state, prUrl: publication.prUrl, remoteState: publication.remoteState },
-        deployment: { status: "not-recorded" } };
+        review, deployment: { status: "not-recorded" }, ...(need === null ? {} : { need }) };
 }
 function admittedOwner(store, taskId, owner, now, root) {
     if (owner.kind !== "coordinator")