toolroll 0.9.8 → 0.9.10

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.9.10 — 2026-10-02
+
+- **Chat reads like a teammate.** Short messages, outcome first, with real
+  choices: Merge or Mark complete, and Look first. Updates within two minutes
+  arrive as one message. You're never told about your own actions, release
+  checks and replaced tasks stay quiet, and a release sends one "is live" line.
+  The Telegram bot is named Toolroll.
+
+## 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

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

@@ -3,6 +3,7 @@ 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";
@@ -99,6 +100,14 @@ export type AssignmentSnapshot = {
     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. */

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";
@@ -17,6 +17,8 @@ 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) {
@@ -183,7 +185,9 @@ 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.
@@ -205,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) &&
@@ -252,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.`);
@@ -266,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);
@@ -307,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 },
-        review, deployment: { status: "not-recorded" } };
+        review, deployment: { status: "not-recorded" }, ...(need === null ? {} : { need }) };
 }
 function admittedOwner(store, taskId, owner, now, root) {
     if (owner.kind !== "coordinator")
@@ -377,8 +409,10 @@ function acknowledgeCurrent(store, current, receiptDigest, actor, now, root, acc
         store.recordAction({ at: now.toISOString(), actor, repo: current.repo,
             taskId: current.rootId, runId: receipt.runId, action: CHECK_ACTION, outcome: receiptDigest, source: "work" });
         const ref = store.lookupRef(current.rootId);
+        // Whose act this is, even outside a command that named its person: the operator who marked it.
+        const by = currentActor() ?? (actor.startsWith("operator:") ? { account: actor.slice("operator:".length), lead: false } : null);
         if (ref !== null)
-            store.noteTaskAct(ref.id, "completed", now);
+            store.noteTaskAct(ref.id, "completed", now, undefined, by);
         store.bumpWake();
     }
     const assignment = assignmentOf(store, current.rootId, now, access, root);