toolroll 0.9.104 → 0.9.105

package/CHANGELOG.md

@@ -1,12 +1,69 @@
 # Changelog
 
+Each release opens with one line on its theme, then **New**, **Changed**, **Fixed** and **Action needed** (only
+the ones it has). Each item is at most two lines and says where to find it. Notes for maintainers (CI, the release
+tooling) go on the GitHub release, not here. Entries before 0.9.104 use the older format.
+
+## 0.9.105 — 2026-11-13
+
+A first run that works without help: one way in, plain words, and results that say what's true.
+
+### New
+
+- **Help fits on one screen.** `toolroll --help` shows the main loop; every other command is under
+  `toolroll internals`, and the scan options under `toolroll scan --help`.
+- **The demo opens signed in.** `toolroll demo` opens your browser already signed in, no typed password.
+- **Settings → Advanced.** Flows, other computers, spend, operating modes and the rest are one switch away. New
+  accounts start with it off; existing accounts keep everything. Active safety settings always stay visible.
+
+### Changed
+
+- **No agent signed in? It says so.** A task filed before Claude Code or Codex is signed in says "No coding agent is
+  signed in. Run `claude auth login`", and starts by itself once you do, with no restart.
+- **Password-free from the first command.** Running `toolroll repos add` (or any command) before the first `toolroll`
+  no longer turns password-free mode off. Only a person at the terminal can turn it on.
+- **A Ready result has one clear button.** Plain Accept when its checks passed and its requirements are met; otherwise
+  the page says what's missing. With no project check set, it tells you how to set one.
+- **The installer starts in your repository** and checks for git 2.41 or newer up front. Pressing Enter at the quit
+  question no longer adds a login item.
+- **Smaller install.** The package is 4.2 MB instead of 6.8 MB.
+- **Plainer words.** Task, approve, Ready, accept or send back; "Toolroll" everywhere, including file names
+  (`toolroll-*` backups, exports and logs).
+
+### Fixed
+
+- **Every real build read "Accept without checks".** A result whose checks passed and whose requirements were met
+  now reads plain Accept.
+- **Slack on Node 22.13–22.18.** Global installs get the tested undici again.
+- **`toolroll --port <n>` works,** and a password-free start picks the next free port.
+- **Tasks on a phone** no longer squash the demo banner; row buttons fit at a desk; form fields have a visible edge.
+
+### Action needed
+
+- The daily audit log is now `toolroll-audit-<day>.jsonl`. Update any log shipper that watches
+  `standing-orders-audit-*`.
+
 ## 0.9.104 — 2026-11-12
 
-- **Accept, plan and retry from the terminal, without a password.** On your own computer (laptop mode), pressing `c` on a Ready result opens "Accept this result?": the summary, the changed files, each requirement and the real check status. You answer "Did you check it yourself?", give a reason for an exception, or just say yes. The answer is tied to the result you read; if it changed meanwhile, you're shown the new one. A bigger first task now asks for its plan straight away, and `p` asks for one; you still approve the plan before anything is built. After a crash or a model error, `r` retries your own approved build, up to 3 times per approval, with the same plan, agent and limits. Merging, releasing, hands-off modes and settings still need your password; API tokens, the lead and chat bots can't do any of this.
-- **Password-free mode is tighter.** The password-free session now has to come from this computer on every request, not only when it starts. It can no longer accept release, protected or coordinator results, or open pull requests; those need your password.
-- **The release page says why it couldn't read what changed.** "What changed couldn't be read" now gives the reason, and a slow machine no longer drops the list after 15 seconds.
-- **No security warning on first start.** discord.js is updated to 14.28.1, so `npx toolroll` no longer opens with npm's deprecation warning.
-- **Docs match the app.** The getting-started guide, CONTRIBUTING and the README describe the terminal's first run as it is (`b` sends back, `r` retries), and Ready is described as showing the check status.
+Finish a task from the terminal: accept, plan and retry without a password on your own computer.
+
+### New
+
+- **Accept a result in the terminal.** Press `c` on a Ready result to read its summary, changed files, requirements
+  and check status, then accept it. If the result changed while you read, you're shown the new one.
+- **Plan and retry in the terminal.** `p` asks for a plan, and a bigger first task asks straight away; you still
+  approve it. After a crash, `r` retries your approved build, up to 3 times.
+
+### Changed
+
+- **Password-free mode is stricter.** Every request must come from this computer. Merging, releasing, pull requests,
+  protected work, hands-off modes and settings still need your password.
+
+### Fixed
+
+- **The release page says why it couldn't read what changed.** A slow machine no longer loses the list.
+- **No npm warning on first start.** `npx toolroll` no longer opens with a deprecation warning.
+- **The guides match the app.** In the terminal, `b` sends a result back and `r` retries.
 
 ## 0.9.103 — 2026-11-11
 

package/README.md

@@ -8,7 +8,7 @@
 ### Your agents build. You decide.
 
 For Claude Code, Codex and Gemini, on your own machine.<br>
-Approve the exact scope once. Get results back Ready with the diff, the check status and screenshots.
+Approve each plan once. Get results back Ready with the diff, the check status and screenshots.
 
 [![npm](https://img.shields.io/npm/v/toolroll?color=171717)](https://www.npmjs.com/package/toolroll)
 [![CI](https://github.com/ap9000/toolroll/actions/workflows/ci.yml/badge.svg)](https://github.com/ap9000/toolroll/actions/workflows/ci.yml)
@@ -20,7 +20,7 @@ Approve the exact scope once. Get results back Ready with the diff, the check st
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="docs/media/ui/tasks-dark.png">
-  <img src="docs/media/ui/tasks-light.png" alt="The Toolroll console's Tasks view: plan windows and budget at the top, then every task with what it needs from you and the one action that settles it." width="920">
+  <img src="docs/media/ui/tasks-light.png" alt="The Toolroll console's Tasks view: every task with what it needs from you and the one action that settles it." width="920">
 </picture>
 
 <sub>Every task across every project, and the one thing each needs from you. (Demo workspace.)</sub>
@@ -50,34 +50,35 @@ task, approve the plan, and the result comes back **Ready**. Elsewhere, add a
 project with `toolroll repos add <folder>`, or open the browser (press `w`, or
 run `toolroll --web`), which also offers a sample project. To look around
 first, `toolroll demo` opens a seeded sandbox with no model calls and no spend.
-
-**Letting agents work on their own.** Approving work you start on this
-computer needs no password. Hands-off modes, merging, releasing and most
-settings ask you to set one first: `toolroll password set`. More: [Getting started](docs/guide/getting-started.md).
+More: [Getting started](docs/guide/getting-started.md).
 
 ## How it works
 
 ```
- describe ─▶ scope ─▶ approve ─▶ build ─▶ check ─▶ Ready ─▶ you decide
-                        you       agent   exact     diff     Complete,
-                                          commit    + proof  revise or merge
+ describe ─▶ plan ─▶ approve ─▶ build ─▶ check ─▶ Ready ─▶ you decide
+                       you       agent   exact     diff     Complete,
+                                         commit    + checks send back or merge
 ```
 
 1. **Describe** the outcome in Chat, the terminal or your phone.
-2. **Scope.** The lead reads the repository and drafts the goal, what's out of
-   bounds, acceptance criteria, and the exact agent and model.
+2. **Plan.** Toolroll reads the repository and drafts the goal, what's out of
+   bounds, the requirements, and the exact agent and model.
 3. **Approve** once. Nothing spends until you do; changing the terms asks again.
-4. **Build.** An agent works in its own worktree and branch. A judgement call
+4. **Build.** An agent works on its own branch. A judgement call
    becomes a question for you, not a guess.
-5. **Check.** Your project's own check runs on the exact commit.
-6. **Ready.** The diff, the check log and screenshots. Mark it Complete, ask
-   for a revision, or merge through the pull request.
+5. **Check.** Once you set your project's check, it runs on the exact commit.
+6. **Ready.** The diff, the check log and screenshots. Mark it Complete, send
+   it back with what to change, or merge through the pull request.
+
+Approving work you start on this computer needs no password. Hands-off modes,
+merging, releasing and most settings ask you to set one first: `toolroll password set`.
 
 ## Use cases
 
 **Clear the backlog overnight.** Queue the tasks you never get to. Each builds
-under its approved scope, in parallel, and recovers by itself after a
-restart. You wake up to results, not transcripts.
+under its approved scope, in parallel, while Toolroll keeps running. If it
+stops, run `toolroll` again and each task continues from its saved work. You
+wake up to results, not transcripts.
 
 **Ship behind a real check.** Your project's command decides what passes, on
 the exact commit being released. A deploy refuses anything that wasn't
@@ -149,9 +150,6 @@ docs for language models.
 - [A team server](docs/team-server.md) · [Linux](docs/guide/linux.md)
 - [All docs](docs/guide/README.md)
 
-Coming from Standing Orders? Same product, renamed. The `standing-orders`
-command and your data keep working.
-
 ## Contributing
 
 Provider adapters are the most useful place to start. See

package/dist/accent-colors.js

@@ -1,28 +1,5 @@
-/**
- * The accent a person can choose (Settings → Appearance): the signal colour
- * that marks what waits on a person. Any colour from the picker, with
- * Pantone's Colours of the Year as presets. The default is ink — no hue, like Vercel, Linear and GitHub:
- * the page is black, white and grey, and colour is left to status (building, complete, warning, danger).
- * Chart magenta (the default until 2026-09-30) and violet stay presets. The default's tokens are set by
- * hand in serve.ts (ink and near-white), not derived: derivation would stop at a mid grey in dark.
- * A per-browser preference, like the theme: it lives in the person's
- * `so-accent` cookie (six hex digits) and never in the database.
- *
- * Pure and shared: the server derives the tokens it prints for the cookie's
- * colour, and the picker derives the same tokens to preview a colour live.
- *
- * Each colour keeps its hue and gives up only lightness (and, when needed,
- * chroma to stay in sRGB) until it reads: in light, its text passes 4.5:1 on
- * its own soft wash; in dark, 6:1 on the dark paper. The swatch is the chosen
- * colour; the page uses the readable one.
- *
- * Preset names are Pantone LLC's; the hex values are the published screen
- * approximations. Pantone is not affiliated with Toolroll.
- */
 export const DEFAULT_ACCENT = "#171717";
 const PAPER_LIGHT = "#ffffff", FRAME_LIGHT = "#efefef", PAPER_DARK = "#161616", INK_DARK = "#0a0a0a";
-/** Ink (the default), violet, chart magenta, then Pantone's colours of the year, newest first. The greys and whites (Sand Dollar 2006,
- * Ultimate Gray 2021, Cloud Dancer 2026) are left out: a grey can't mark what needs a person here. */
 export const ACCENT_PRESETS = [
     [null, "Ink", DEFAULT_ACCENT],
     [null, "Violet", "#6e56cf"],
@@ -59,7 +36,6 @@ function fromOklch(L, C, H) {
     const rgb = [4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s, -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s, -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s];
     return rgb.every(c => c >= -0.0001 && c <= 1.0001) ? rgb.map(gam) : null;
 }
-/** The colour at lightness L with its hue kept, giving up chroma only to stay in sRGB. */
 function atLightness(L, C, H) {
     for (let c = C; c >= 0; c -= 0.002) {
         const rgb = fromOklch(L, c, H);
@@ -74,7 +50,6 @@ export function contrast(a, b) {
     return (x + 0.05) / (y + 0.05);
 }
 const mix = (a, b, weight) => { const [p, q] = [toRgb(a), toRgb(b)]; return toHex(p.map((c, i) => c * weight + q[i] * (1 - weight))); };
-/** "#rrggbb" from "#rgb", "rgb", "#rrggbb" or "rrggbb" (any case); null otherwise. */
 export function normalHex(raw) {
     const value = raw.trim().replace(/^#/, "").toLowerCase();
     if (/^[0-9a-f]{6}$/.test(value))
@@ -83,7 +58,6 @@ export function normalHex(raw) {
         return `#${[...value].map(c => c + c).join("")}`;
     return null;
 }
-/** The readable tokens a colour resolves to, light and dark. */
 export function accentTokens(hex) {
     const [L0, C, H] = toOklch(hex);
     let light = hex;
@@ -102,7 +76,6 @@ export function accentTokens(hex) {
             soft: mix(dark, PAPER_DARK, 0.13), selection: mix(dark, PAPER_DARK, 0.32) },
     };
 }
-/** What a person should know before keeping a colour: a grey won't stand out, and a status hue can be mistaken. */
 const STATUS = [
     ["#c4320a", "red", "failures", "a failed one"],
     ["#218358", "green", "passed checks", "a passed one"], ["#0d74ce", "blue", "running work", "a running one"],
@@ -114,12 +87,10 @@ export function accentNote(hex) {
     const near = STATUS.find(([one]) => { const d = Math.abs(toOklch(one)[2] - hue); return Math.min(d, 360 - d) < 25; });
     return near === undefined ? null : `Close to the ${near[1]} used for ${near[2]}, so a task waiting on you can look like ${near[3]}.`;
 }
-/** The person's chosen colour from their own cookie ("#rrggbb"); null is chart magenta. */
 export function pinnedAccent(cookieHeader) {
     const value = /(?:^|;\s*)so-accent=([0-9a-f]{6})(?:;|$)/.exec(cookieHeader ?? "")?.[1];
     return value === undefined || `#${value}` === DEFAULT_ACCENT ? null : `#${value}`;
 }
-/** The token overrides for a chosen colour, light and dark, for the page head. */
 export function accentStyle(hex) {
     const { light, dark } = accentTokens(hex);
     const block = (t) => `--so-signal:${t.signal};--so-signal-hover:${t.hover};--so-on-signal:${t.on};--so-signal-soft:${t.soft};--so-selection:${t.selection}`;

package/dist/acp-agents.js

@@ -3,7 +3,6 @@ export const ACP_AGENTS = {
     opencode: {
         name: "OpenCode",
         binary: "opencode",
-        // --pure: "run without external plugins" (opencode 1.18 `acp --help`).
         argv: ["acp", "--pure"],
         signIn: "opencode auth login",
         home: [".config/opencode", ".local/share/opencode"],
@@ -46,14 +45,12 @@ const ACP = new Set(ACP_PROVIDER_IDS);
 export function isAcpProvider(provider) {
     return ACP.has(provider);
 }
-/** Whether a profile (or anything carrying a provider) is an ACP agent's: narrows the union. */
 export function isAcpProfile(profile) {
     return ACP.has(profile.provider);
 }
 export function isKeyedProvider(provider) {
     return !ACP.has(provider);
 }
-/** Build a per-provider record whose ACP entries all come from one function of the agent's row. */
 export function withAcp(keyed, acp) {
     const out = { ...keyed };
     for (const provider of ACP_PROVIDER_IDS)

package/dist/acp-attest.js

@@ -1,33 +1,14 @@
-/**
- * An ACP agent's admission (docs/plans/acp-adapter.md § Admission): it runs only on a passed conformance check of the
- * exact binary on this runner, recorded as an attestation. Absence is denial.
- *
- * The record says how to launch that binary — a native launcher directly, a script through the interpreter its
- * shebang named, resolved once at the check and pinned (the child's PATH never chooses it) — and binds every file
- * that launch depends on: the launcher, the interpreter, and for a package its package.json and entry. Each binding
- * keeps the file's stat tuple and sha256. At spawn, after all asynchronous setup, every binding is checked again: a
- * changed stat is re-hashed, and the spawn refuses unless every hash still matches.
- *
- * What it proves, exactly: the bytes of those files are the bytes that passed the check, as of the re-check
- * immediately before spawn. Not an exclusive lock on the paths: a writer racing the narrow window between that re-check
- * and exec is not excluded (Node has no exec-by-descriptor), the same residual the version attestation states. Nor the
- * agent's other files (a bundle's chunks, its plugins): those are its configuration surface. The environment
- * variables that make an interpreter load other code are shed at every ACP launch (INTERPRETER_INJECTION_ENV).
- */
 import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync, statSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { delimiter, dirname, isAbsolute, join } from "node:path";
-/** What makes an interpreter load code beside the script it was given: never passed to an ACP launch. */
 export const INTERPRETER_INJECTION_ENV = [
     "NODE_OPTIONS", "NODE_PATH", "NODE_REPL_EXTERNAL_MODULE", "PYTHONPATH", "PYTHONSTARTUP", "PYTHONHOME", "PYTHONINSPECT",
     "RUBYOPT", "RUBYLIB", "PERL5OPT", "PERL5LIB", "PERLLIB", "BUN_OPTIONS", "DENO_DIR", "LD_PRELOAD", "LD_LIBRARY_PATH",
     "DYLD_INSERT_LIBRARIES", "DYLD_LIBRARY_PATH", "DYLD_FRAMEWORK_PATH",
 ];
-/** Bumped whenever the conformance probe changes what it proves: every attestation made under another version is void. */
 export const ACP_CONFORMANCE_VERSION = 2;
 const READ_CAP = 64 * 1024;
 const HASH_CHUNK = 1024 * 1024;
-/** sha256 of a regular file, read without following a final symlink. */
 export function hashFile(path) {
     let fd = null;
     try {
@@ -89,7 +70,6 @@ function isNative(bytes) {
     const magic = bytes.readUInt32BE(0);
     return magic === 0x7f454c46 || [0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe, 0xcafebabe, 0xbebafeca].includes(magic);
 }
-/** A name found on a PATH, by realpath; only absolute PATH entries count. */
 function onPath(name, path) {
     for (const folder of path.split(delimiter)) {
         if (folder === "" || !isAbsolute(folder))
@@ -106,7 +86,6 @@ function onPath(name, path) {
     }
     return null;
 }
-/** The interpreter and its arguments a shebang line names — `#!/abs/interp [arg]` or `#!/usr/bin/env [-S] name [args]` — or null. */
 export function parseShebang(line, path) {
     if (!line.startsWith("#!"))
         return null;
@@ -131,7 +110,6 @@ export function parseShebang(line, path) {
         return null;
     }
 }
-/** The nearest package.json above a script and the file its `bin`/`main` names, when that is not the launcher. */
 function packageBindings(launcher) {
     let folder = dirname(launcher);
     for (let depth = 0; depth < 6; depth += 1) {
@@ -174,10 +152,6 @@ function packageBindings(launcher) {
     }
     return [];
 }
-/**
- * How to launch a binary found at `launcher` (a realpath), with every file bound — or why it can't be. `path` is the
- * PATH a `#!/usr/bin/env name` shebang is resolved on, once, here.
- */
 export function launchOf(launcher, path) {
     const bytes = head(launcher, 4096);
     if (bytes === null)
@@ -200,7 +174,6 @@ export function launchOf(launcher, path) {
         return { problem: `the files ${launcher} runs from can't all be read` };
     return { file: shebang.interpreter, prefix: [...shebang.args, launcher], bindings: [self, interpreter, ...pkg] };
 }
-/** Whether every bound file is still the one that passed: same stat, or on any change the same sha256. */
 export function verifyLaunch(launch) {
     for (const binding of launch.bindings) {
         let stat;
@@ -219,7 +192,6 @@ export function verifyLaunch(launch) {
     }
     return { ok: true };
 }
-/** A stored launch, read strictly: anything this code never writes reads as null. */
 export function launchFromJson(json) {
     let parsed;
     try {
@@ -252,8 +224,6 @@ export function launchFromJson(json) {
     }
     if (bindings[0]?.role !== "launcher")
         return null;
-    // What is executed is a bound file — the launcher itself, or the bound interpreter with the launcher as its script
-    // — and nothing a stored row could point elsewhere.
     const launcher = bindings[0].path;
     const prefix = value["prefix"];
     if (value["file"] === launcher) {

package/dist/acp-check.js

@@ -1,20 +1,3 @@
-/**
- * An ACP agent's conformance check (docs/plans/acp-adapter.md § Layer E): what admits an agent to run on this runner.
- *
- * A person asks for it (`toolroll agents check`, with a password); a watch of the named runner runs it, under that
- * watch's own lease and custody, as a real task of the watch's project with two real runs through the one gateway —
- * the same fence, environment shedding, containment, stop watch and spend as any build. Each run is admitted by the
- * check request (never by an attestation), and graded only on evidence the plane observed itself:
- *
- * 1. session-ok: the plane's own isolation probes inside the exact fence and environment the agent gets (a canary
- *    file in the fenced state unreadable, a canary key absent); a tool call the runner saw complete; the prompt's
- *    `end_turn`; the agent leaving on stdin's end with nothing of its group left; and done.txt saying ok.
- * 2. session-stop: a live descendant of the agent, seen by the plane's own reading, before the cancel; the
- *    `cancelled` answer; and every process alive at the cancel gone after.
- *
- * Only when both passed is the attestation recorded — in the same transaction that marks the request passed, while
- * it is unexpired and its watch still holds its lease. Anything else fails the request, in words, and admits nothing.
- */
 import { randomBytes } from "node:crypto";
 import { closeSync, constants, fstatSync, openSync, readSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -28,30 +11,15 @@ export const CHECK_PROMPTS = {
     ok: "Create a file named done.txt in the current folder containing exactly the word ok. Then stop. Do nothing else.",
     stop: "Run the shell command `sleep 120` and wait for it to finish.",
 };
-/** How long the stop step waits for the agent to start its command, and for the cancel to be answered. Every product
- * path waits exactly this: runAcpChecks takes no other value (src/acp-check-timing.test.ts holds it). */
 export const STOP_WAIT_MS = 60_000;
-/** How long the agent has to answer the cancel. */
 const CANCEL_ANSWER_MS = 15_000;
-/** Close what no live watch holds any more, let go of what finished checks still hold, then run this runner's next
- * check, if one is waiting. */
 export async function runAcpChecks(job) {
     return runChecks(job, STOP_WAIT_MS);
 }
-/**
- * Let go of what finished checks hold — their checkout, their task, their claim — once nothing of theirs can still be
- * running. The whole teardown happens under a live claim of the check's own on its task (its first, or a fresh one
- * recorded in its place when that expired), so no one else can take the task while its checkout goes; ownership is
- * re-read before every step that destroys anything. A check is settled only when all of it is let go; anything that
- * can't be yet (a run still open, a process not proved gone, a checkout that wouldn't discard, someone else holding
- * the task) is retried on the next pass, and never touched.
- */
-/** How long one cleanup attempt, and its claim on the task, last between renewals. */
 const SETTLE_HOLD_MS = 10 * 60_000;
 async function settleChecks(job, clock) {
     const { store } = job;
     for (const request of store.unsettledAcpChecks(job.runner)) {
-        // One attempt at a time per check, across every watch of the runner: another attempt in flight is left alone.
         const attempt = randomBytes(8).toString("hex");
         if (!store.holdAcpSettle(request.id, attempt, clock(), SETTLE_HOLD_MS))
             continue;
@@ -68,14 +36,10 @@ async function settleChecks(job, clock) {
                 continue;
             const lease = store.currentLiveLease(ref, clock());
             if (lease !== null && lease !== request.leaseId)
-                continue; // someone else holds the task now: not ours to touch
-            // Teardown runs under a fresh claim of this watch's own — never the check's earlier one, which carries the
-            // incarnation of a watch whose recovery may release it mid-way. Someone taking the task in between wins.
+                continue;
             if (lease !== null)
                 release(store, lease, clock());
             const fresh = `agent-check-${request.id}-settle-${randomBytes(4).toString("hex")}`;
-            // Cleanup's own door: it may claim the check's task even when that task is done, failed or cancelled, proved
-            // against this check row, this runner and this attempt (claim.ts acquireForCheckCleanup).
             const took = acquireForCheckCleanup(store, request.id, attempt, job.runner, { now: clock(), token: job.token, newLeaseId: () => fresh, ttlMs: SETTLE_HOLD_MS, incarnation: job.watch.owner });
             if (!took.ok || !store.setAcpCheckLease(request.id, fresh)) {
                 if (took.ok)
@@ -84,8 +48,6 @@ async function settleChecks(job, clock) {
             }
             held = fresh;
             const claim = held;
-            // Still this attempt's, the claim still live and the task still quiet — then both are renewed in full, so
-            // neither lapses during the step about to run.
             const ours = () => {
                 if (!store.holdsAcpSettle(request.id, attempt, clock()) || store.currentLiveLease(ref, clock()) !== claim || !quiet())
                     return false;
@@ -114,7 +76,6 @@ async function settleChecks(job, clock) {
             store.settleAcpCheck(request.id, attempt, branch, clock());
         }
         catch {
-            // Retried on the next pass.
         }
         finally {
             if (held !== null && store.currentLiveLease(request.taskRef ?? -1, clock()) === held)
@@ -123,11 +84,6 @@ async function settleChecks(job, clock) {
         }
     }
 }
-/**
- * Tests only: runAcpChecks with a shorter stop-step window, so a test whose agent never starts its command doesn't
- * wait out the product's minute. No product code may import it (src/acp-check-timing.test.ts fails if any does); the
- * job carries no wait of its own, so no CLI, environment or config value can change the product's.
- */
 export async function runAcpChecksForTests(job, stopWaitMs) {
     return runChecks(job, stopWaitMs);
 }
@@ -153,21 +109,18 @@ async function runChecks(job, stopWaitMs) {
     }
     await settleChecks(job, clock);
 }
-/** Run one claimed check; null when it passed (and was published), else why not. */
 async function check(job, request, clock, stopWaitMs) {
     const { store } = job;
     const fail = (words) => { store.failAcpCheck(request.id, words, clock()); return words; };
     if (!isAcpProvider(request.provider))
         return fail("not an ACP agent");
     const env = job.env ?? process.env;
-    // What runs: the binary on this runner's PATH, its launch pinned and every file it depends on bound.
     const seen = inspectAcpAgent(request.provider, env);
     if (!seen.found)
         return fail(`${ACP_AGENTS[request.provider].binary} isn't installed on ${job.runner}`);
     const launch = launchOf(seen.realpath, env["PATH"] ?? "");
     if ("problem" in launch)
         return fail(launch.problem);
-    // A task of the watch's own project, placed and claimed like any other, bound to the request.
     const taskId = `agent-check-${request.id}`;
     store.createTask({ id: taskId, title: `Check ${ACP_AGENTS[request.provider].name} (${request.model})` }, clock());
     const ref = store.refFor(BUILT_IN, taskId).id;
@@ -183,19 +136,15 @@ async function check(job, request, clock, stopWaitMs) {
         store.setTaskState(taskId, "failed", clock());
         return fail("the check lost its watch before it began");
     }
-    // From here on, what the check holds is let go by settleChecks, whatever happens.
     const leased = await job.pool.lease({ repo: job.watch.repo, branch: `toolroll/${taskId}`, base: "HEAD", runner: job.runner, taskRef: ref, now: clock() });
     if (!leased.ok)
         return fail(`the check's checkout couldn't be made: ${leased.message}`);
-    // Recovery may have closed — even settled — the check while its checkout was being made: what landed late reopens
-    // cleanup, so the next pass lets it go.
     if (store.acpCheck(request.id)?.state !== "running") {
         store.unsettleAcpCheck(request.id);
         return fail("the check was closed while its checkout was being made");
     }
     const worktree = leased.worktree.path;
     const stateDir = dirname(realpathSync(store.databaseFile() ?? "."));
-    // Named as a secret is, beside the database: fenced whether the state folder is Toolroll's own or shared.
     const canaryFile = join(stateDir, `acp-check-secret-${request.id}`);
     let verdict = null;
     try {
@@ -208,12 +157,10 @@ async function check(job, request, clock, stopWaitMs) {
         store.failAcpCheck(request.id, verdict, clock());
     return verdict;
 }
-/** A check step's run, finished as the check's own refusal — once, if it is still open. */
 function finishCheckRun(store, run, clock) {
     if (store.getRun(run)?.outcome === null)
         store.finishRun(run, { outcome: "refused", reason: "agent-check", now: clock() });
 }
-/** The two steps; whatever throws, the step's run in flight is finished (cleanup still waits for its processes). */
 async function steps(job, request, at, clock, stopWaitMs) {
     let current = null;
     try {
@@ -245,7 +192,6 @@ async function runSteps(job, request, at, clock, track, stopWaitMs) {
         ...(job.agent === undefined ? {} : { runner: job.agent }),
         ...extra,
     });
-    // Step 1: session-ok.
     const held1 = budget();
     if (held1 !== null)
         return held1;
@@ -258,10 +204,7 @@ async function runSteps(job, request, at, clock, track, stopWaitMs) {
     const fileCanary = randomBytes(18).toString("hex");
     const envValue = `sk-ant-canary-${randomBytes(18).toString("hex")}`;
     writeFileSync(at.canaryFile, fileCanary, { mode: 0o600 });
-    // The checkout carries the project's HEAD: anything already named done.txt goes first, so only the agent's own
-    // write can make it say ok.
     rmSync(join(at.worktree, "done.txt"), { force: true, recursive: true });
-    /** The tool calls the runner saw, by id: their kind, and whether they completed. */
     const calls = new Map();
     const first = await invokeAgent(store, run1, spec, ask(CHECK_PROMPTS.ok), options({
         env: { ANTHROPIC_API_KEY: envValue },
@@ -276,14 +219,12 @@ async function runSteps(job, request, at, clock, track, stopWaitMs) {
         },
     }));
     finish(run1);
-    // An edit (or a command) the runner saw complete: a read can't make done.txt.
     const wrote = [...calls.values()].some(one => one.done && (one.kind === "edit" || one.kind === "execute"));
     const one = gradeOk(first, at.worktree, wrote);
     if (one.verdict !== null)
         return `session-ok: ${one.verdict}`;
     if (!store.passAcpCheckStep(request.id, 1, run1, clock()))
         return "the check stopped admitting its first step's result";
-    // Step 2: session-stop.
     const held2 = budget();
     if (held2 !== null)
         return held2;
@@ -303,7 +244,6 @@ async function runSteps(job, request, at, clock, track, stopWaitMs) {
                 started = true;
         },
         acp: { prompt: "", model: "", expect: null, onControl: (control) => {
-                // The agent's word only times the cancel: what the plane itself sees alive is what is graded.
                 const until = Date.now() + stopWaitMs;
                 const poll = setInterval(() => {
                     if (Date.now() > until) {
@@ -329,7 +269,6 @@ async function runSteps(job, request, at, clock, track, stopWaitMs) {
         return `session-stop: ${two}`;
     if (!store.passAcpCheckStep(request.id, 2, run2, clock()))
         return "the check stopped admitting its second step's result";
-    // Both passed: publish, in one transaction with the attestation.
     const facts = first.kind === "ran" ? first.outcome.acp : undefined;
     if (facts?.agent == null)
         return "the agent never said who it is";
@@ -372,8 +311,6 @@ function gradeStop(result, witnessed) {
         return "no command the agent started was seen alive before the cancel";
     if (facts === undefined)
         return "the runner recorded no conversation";
-    // The expected end, and only it: answered cancelled in time (the runner stops an unanswered cancel and the
-    // conversation fails), no protocol breach, no timeout, and an ending the runner itself saw.
     if (facts.protocolError !== null)
         return `the agent broke the protocol: ${facts.protocolError}`;
     if (facts.stop !== "cancelled")
@@ -382,28 +319,24 @@ function gradeStop(result, witnessed) {
         return "the agent's process didn't end cleanly after the cancel";
     if (result.kind === "refused" && result.reason !== "provider-protocol")
         return `the run was refused: ${result.diagnostic ?? result.reason}`;
-    // Its whole process tree ended with it, proved: nothing left for the runner to kill, and no containment in doubt.
     if (facts.exit.leftover)
         return "the agent left processes running after the cancel";
     if (result.kind === "ran" && result.outcome.code === 126)
         return "the runner couldn't prove the agent's processes all ended";
-    // Every process alive at the cancel is gone — and so is every process group it was in: a leader that exited after
-    // forking leaves its group behind, which is no stop at all.
     for (const { pid, group } of witnessed) {
         try {
             process.kill(pid, 0);
             return `process ${pid}, alive at the cancel, is still running`;
         }
-        catch { /* gone */ }
+        catch { }
         try {
             process.kill(-group, 0);
             return `process group ${group}, alive at the cancel, still has members`;
         }
-        catch { /* gone */ }
+        catch { }
     }
     return null;
 }
-/** A file the agent wrote, read only if it is a plain file (no link followed, no FIFO or device) and tiny. */
 function smallFile(path) {
     let fd = null;
     try {