toolroll 0.9.31 → 0.9.33

package/dist/task-status.js

@@ -26,6 +26,21 @@ export const CHECKS_LABEL = "Project checks";
 export const PR_CI_LABEL = "PR CI";
 /** The one verb for opening a saved result, on every surface. */
 export const OPEN_RESULT = "Open result";
+/** "T2", "T2 and T3", "T2, T3 and 2 more": short enough for one line. The full list is on the result. */
+export function peerWords(peers, shown = 2) {
+    if (peers.length <= shown)
+        return peers.length <= 1 ? peers.join("") : `${peers.slice(0, -1).join(", ")} and ${peers.at(-1)}`;
+    return `${peers.slice(0, shown).join(", ")} and ${peers.length - shown} more`;
+}
+/** "Checked together with T2 on 1a2b3c4": every surface says a shared check the same way, naming the commit it tested. */
+export function checkedTogetherWords(batch) {
+    const sha = short(batch.tested);
+    return batch.state === "together" && batch.peers.length > 0 && sha !== null ? `Checked together with ${peerWords(batch.peers)} on ${sha}` : null;
+}
+const BATCH_WHY = {
+    split: "Its batch check failed, so it was checked on its own.",
+    conflict: "It conflicted with another result when merged for a batch check, so it was checked on its own.",
+};
 const short = (sha) => sha !== null && /^[a-f0-9]{7,40}$/.test(sha) ? sha.slice(0, 7) : null;
 export function headlineOf(facts) {
     switch (facts.stage) {
@@ -64,8 +79,15 @@ function sentenceOf(headline, facts) {
                 return "The report is ready to read. Read it, then mark it complete.";
             if (facts.checks?.level === "off" && facts.checks.status !== "passed")
                 return "Checks are off for this project. Review the change, then mark it complete.";
-            if (facts.checks?.status === "passed")
+            if (facts.checks?.status === "passed") {
+                // The Checks row names the others and the batch commit; the sentence doesn't repeat them.
+                const peers = facts.checks.batch?.state === "together" ? facts.checks.batch.peers.length : 0;
+                if (peers > 0)
+                    return `Checks passed together with ${peers === 1 ? "1 other result" : `${peers} other results`}. Review the change, then mark it complete.`;
                 return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} passed${sha === null ? "" : ` on ${sha}`}. Review the change, then mark it complete.`;
+            }
+            if (facts.checks?.batch?.state === "waiting")
+                return "Its full check runs with other results within 10 minutes. Review the change, then mark it complete.";
             // Never claim a check that isn't known to have passed.
             if (facts.checks == null)
                 return "Review the change, then mark it complete.";
@@ -93,8 +115,19 @@ function detailsOf(headline, facts) {
         const checksHref = facts.links?.checks ?? facts.links?.result ?? null;
         const runChecks = facts.links?.runChecks === undefined ? null : { label: "Run checks", href: facts.links.runChecks };
         const quick = checks.level === "quick";
-        if (checks.running != null)
+        const batch = checks.batch ?? null;
+        const together = batch === null ? null : checkedTogetherWords(batch);
+        const batchWhy = batch === null ? null : BATCH_WHY[batch.state] ?? null;
+        if (batch?.state === "waiting")
+            row("checks", CHECKS_LABEL, "Waiting to check with other results", "running", { href: checksHref });
+        else if (checks.running != null)
             row("checks", CHECKS_LABEL, `${checks.running === "quick" ? "Quick" : "Full"} checks running`, "running", { href: checksHref });
+        else if (checks.status === "passed" && together !== null)
+            row("checks", CHECKS_LABEL, together, "ok", { href: checksHref });
+        else if (checks.status === "passed" && batchWhy !== null)
+            row("checks", CHECKS_LABEL, `Passed on its own${sha === null ? "" : ` on ${sha}`}`, "ok", { href: checksHref, why: batchWhy });
+        else if (checks.status === "failed" && batchWhy !== null)
+            row("checks", CHECKS_LABEL, `Failed on its own${checks.exitCode === null ? "" : ` (exit ${checks.exitCode})`}`, problem(headline), headline === "Failed" ? { href: checksHref, why: batchWhy } : { action: { label: "See what failed", href: checksHref }, why: batchWhy });
         else if (checks.status === "passed")
             row("checks", CHECKS_LABEL, `${quick ? "Quick checks passed" : "Passed"}${sha === null ? "" : ` on ${sha}`}`, "ok", quick && runChecks !== null && headline !== "Complete" ? { href: checksHref, action: { label: "Run full checks", href: runChecks.href } } : { href: checksHref });
         else if (checks.status === "failed")
@@ -320,7 +353,8 @@ export function assignmentStatusFacts(assignment, options = {}) {
     const report = receipt?.completionKind === "research-report";
     const checks = receipt === null || !withResult ? null
         : { status: receipt.checks.status, exitCode: receipt.checks.exitCode, head: receipt.head,
-            ...(receipt.checks.level == null ? {} : { level: receipt.checks.level }), ...(receipt.checks.running == null ? {} : { running: receipt.checks.running }) };
+            ...(receipt.checks.level == null ? {} : { level: receipt.checks.level }), ...(receipt.checks.running == null ? {} : { running: receipt.checks.running }),
+            ...(receipt.checks.batch == null ? {} : { batch: receipt.checks.batch }) };
     const publication = assignment.publication;
     const pullRequest = options.pullRequest !== undefined ? options.pullRequest
         : publication === null ? (withResult && !report ? { state: "none", number: null, url: null, ci: null, error: null } : null)

package/dist/team-leads.js

@@ -32,6 +32,10 @@ function role(value) {
         refuse('invalid', 'Choose Viewer, Contributor or Manager.');
     return value;
 }
+/** A failed turn's words for its message: none when the turn said why in the thread itself (it stopped at its deadline). */
+function savedFailure(reason) {
+    return reason === 'timeout' || reason === 'crashed' ? null : String(reason ?? 'The saved turn failed.');
+}
 function hash(value) { return createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
 function stable(value) {
     if (Array.isArray(value))
@@ -461,7 +465,7 @@ export class TeamLeads {
                 const uncertain = this.deliveryUncertain(Number(row['turn_id']));
                 const cancelled = Number(row['stop_requested']) === 1 || !this.authorStillAllowed(row);
                 const status = uncertain ? 'uncertain' : cancelled ? 'cancelled' : row['turn_state'] === 'answered' ? 'answered' : 'failed';
-                const error = uncertain ? 'Delivery could not be confirmed. Inspect saved activity before continuing.' : cancelled ? 'Stopped or conversation access changed.' : status === 'failed' ? String(row['failure_reason'] ?? 'The saved turn failed.') : null;
+                const error = uncertain ? 'Delivery could not be confirmed. Inspect saved activity before continuing.' : cancelled ? 'Stopped or conversation access changed.' : status === 'failed' ? savedFailure(row['failure_reason']) : null;
                 const result = this.db.prepare("UPDATE team_message SET status=?,error=?,generation=generation+1,revision=revision+1 WHERE message=? AND status='running' AND generation=?").run(status, error, Number(row['message']), Number(row['generation']));
                 if (Number(result.changes) === 1) {
                     changed++;
@@ -480,7 +484,7 @@ export class TeamLeads {
             for (const row of rows) {
                 const turn = row['turn_id'] === null ? null : this.store.getMateTurn(Number(row['turn_id']));
                 const status = turn?.state === 'answered' ? 'answered' : turn?.state === 'failed' && !this.deliveryUncertain(turn.id) ? 'failed' : 'uncertain';
-                const error = status === 'uncertain' ? 'Delivery unconfirmed after the previous worker stopped. Inspect activity before continuing.' : status === 'failed' ? (turn?.failureReason ?? 'The saved turn failed.') : null;
+                const error = status === 'uncertain' ? 'Delivery unconfirmed after the previous worker stopped. Inspect activity before continuing.' : status === 'failed' ? savedFailure(turn?.failureReason) : null;
                 this.db.prepare('UPDATE team_message SET status=?,generation=generation+1,revision=revision+1,error=? WHERE message=?').run(status, error, Number(row['message']));
                 this.event(String(row['lead']), String(row['conversation']), status === 'uncertain' ? 'delivery-unconfirmed' : 'message-reconciled', String(row['author']), now);
             }

package/dist/team-runtime.js

@@ -166,9 +166,10 @@ export function createTeamRuntime(options) {
                 const state = admission(claim.actor, claim.conversationId);
                 if (domain.defer(claim, result.message, clock()))
                     waiting.set(claim.messageId, state.stamp);
+                // A turn that saved its outcome in the thread (stopped at its deadline) is said there, not again on the message.
             }
             else
-                domain.finish(claim, { status: 'unknownSpend' in result && result.unknownSpend ? 'uncertain' : 'failed', error: result.message, ...('turn' in result ? { turnId: result.turn } : {}) }, clock());
+                domain.finish(claim, { status: 'unknownSpend' in result && result.unknownSpend ? 'uncertain' : 'failed', ...('saved' in result && result.saved ? {} : { error: result.message }), ...('turn' in result ? { turnId: result.turn } : {}) }, clock());
         }
         catch {
             // An exception may have followed native admission. Preserve an explicit

package/dist/test-temp.d.ts

@@ -1,5 +1,13 @@
+/** In a suite's temp root: who made it (scripts/suite-lifecycle.mjs). */
+export declare const OWNER_FILE = ".toolroll-temp-owner";
+export type TempOwner = {
+    pid: number;
+    startedAt: number;
+};
 /** Name prefixes of what tests, journeys and scripts leave in the temp folder. */
 export declare const TEST_TEMP_PREFIXES: readonly string[];
+/** Who made a temp root, from its owner file; null when it has none (older suites, scripts, Playwright). */
+export declare function tempOwner(path: string): TempOwner | null;
 export declare function isTestTemp(name: string): boolean;
 /** Where they collect: the temp folder (and /tmp, where some scripts write). */
 export declare function tempRoots(): string[];
@@ -12,8 +20,18 @@ export declare function testTempFolders(roots: readonly string[], now: Date): {
     all: TempLeftover[];
     stale: TempLeftover[];
 };
-/** Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes. */
-export declare function removeStaleTestTemp(roots: readonly string[], now: Date): {
+export type RemoveOptions = {
+    /** Whether a temp root's owner (by its owner file) is still running: its root stays, however old it looks. */
+    ownerAlive?: (owner: TempOwner) => boolean;
+    /** At most this many go in one pass (a sweep after weeks can find 100,000); `more` says some were left. */
+    max?: number;
+};
+/**
+ * Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes (still a
+ * folder of its own, not a link, still directly in its temp folder, still a day untouched, its owner gone).
+ */
+export declare function removeStaleTestTemp(roots: readonly string[], now: Date, options?: RemoveOptions): {
     removed: string[];
     failed: string[];
+    more: boolean;
 };

package/dist/test-temp.js

@@ -1,16 +1,20 @@
 /**
- * Test temp folders (`toolroll storage`, `storage clean`): what the unit tests, journeys and scripts make in the
- * system temp folder. The tests delete their own (each run gets one temp root that its global teardown removes:
- * test/temp-root.ts); a run that was killed, and older versions, leave folders behind. `toolroll storage` counts them
- * and `storage clean` removes the ones nothing has touched for a day.
+ * Test temp folders (`toolroll storage`, `storage clean`, the plane's daily storage sweep): what the unit tests,
+ * journeys and scripts make in the system temp folder. The suites delete their own on pass, failure, timeout and
+ * interrupt (scripts/suite-lifecycle.mjs, test/temp-root.ts); a run killed outright, a proof that keeps its output and
+ * older versions leave folders behind. `toolroll storage` counts them; the daily sweep (storage-sweep.ts) and
+ * `storage clean` remove the ones nothing has touched for a day, never one whose owner is still running.
  *
  * Every prefix the tests and scripts give tmpdir() is covered here (test-temp.test.ts reads the sources to keep it
  * so), and Playwright's own browser profiles.
  */
-import { lstatSync, readdirSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { lstatSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 const DAY_MS = 86_400_000;
+/** In a suite's temp root: who made it (scripts/suite-lifecycle.mjs). */
+export const OWNER_FILE = ".toolroll-temp-owner";
 /** Name prefixes of what tests, journeys and scripts leave in the temp folder. */
 export const TEST_TEMP_PREFIXES = [
     "so-", "standing-orders-", "toolroll-", "no-wt", "epoch", "cancel-floor",
@@ -18,10 +22,21 @@ export const TEST_TEMP_PREFIXES = [
     "flow-goal-", "flow-scratch", "flows-chat-", "invoke-attest-", "knowledge-test-", "learning-", "peek-", "phone-origin-",
     "proposal-repo-", "race-", "refresh-migration-", "refresh-refusal-", "release-check-", "shared-chat-", "skills-test-",
     "task-status-surfaces-", "template-repo-", "template-test-", "v14-migrate-", "v17-migrate-", "watch-anchor-",
-    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-", "one-result-page-", "deploy-before-swap-", "one-vocabulary-", "accept-finishes-", "lead-promises-", "lead-people-", "sizing-repo-",
+    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-", "one-result-page-", "deploy-before-swap-", "one-vocabulary-", "accept-finishes-", "lead-promises-", "lead-people-", "sizing-repo-", "batch-checks-", "deps-identity-",
     // Playwright's browser profiles and artifacts.
     "playwright_chromiumdev_profile-", "playwright_firefoxdev_profile-", "playwright-artifacts-",
 ];
+/** Who made a temp root, from its owner file; null when it has none (older suites, scripts, Playwright). */
+export function tempOwner(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(path, OWNER_FILE), "utf8"));
+        const startedAt = typeof parsed.startedAt === "string" ? Date.parse(parsed.startedAt) : NaN;
+        return Number.isSafeInteger(parsed.pid) && Number(parsed.pid) > 1 && Number.isFinite(startedAt) ? { pid: Number(parsed.pid), startedAt } : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function isTestTemp(name) {
     return TEST_TEMP_PREFIXES.some(prefix => name.startsWith(prefix));
 }
@@ -79,20 +94,45 @@ export function testTempFolders(roots, now) {
     }
     return { all, stale: all.filter(one => now.getTime() - one.touchedAt > DAY_MS) };
 }
-/** Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes. */
-export function removeStaleTestTemp(roots, now) {
+/**
+ * Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes (still a
+ * folder of its own, not a link, still directly in its temp folder, still a day untouched, its owner gone).
+ */
+export function removeStaleTestTemp(roots, now, options = {}) {
     const removed = [];
     const failed = [];
-    for (const one of testTempFolders(roots, now).stale) {
+    const stale = testTempFolders(roots, now).stale;
+    const max = options.max ?? Infinity;
+    const inside = new Set(roots.map(root => resolve(root)));
+    for (const one of stale) {
+        if (removed.length + failed.length >= max)
+            return { removed, failed, more: true };
         try {
-            if (now.getTime() - (lstatSync(one.path).isDirectory() ? touchedAt(one.path) : lstatSync(one.path).mtimeMs) <= DAY_MS)
+            const stat = lstatSync(one.path);
+            if (stat.isSymbolicLink() || !inside.has(resolve(dirname(one.path))))
+                continue;
+            if (now.getTime() - (stat.isDirectory() ? touchedAt(one.path) : stat.mtimeMs) <= DAY_MS)
+                continue;
+            const owner = stat.isDirectory() ? tempOwner(one.path) : null;
+            if (owner !== null && (options.ownerAlive ?? (() => false))(owner))
                 continue;
-            rmSync(one.path, { recursive: true, force: true, maxRetries: 3 });
+            removeTree(one.path);
             removed.push(one.path);
         }
         catch {
             failed.push(one.path);
         }
     }
-    return { removed, failed };
+    return { removed, failed, more: false };
+}
+/** rm -r; a tree a test made read-only (a shared dependency copy, a locked fixture) is made writable first. */
+function removeTree(path) {
+    try {
+        rmSync(path, { recursive: true, force: true, maxRetries: 3 });
+        return;
+    }
+    catch { /* read-only inside */ }
+    if (process.platform !== "win32")
+        spawnSync("chmod", ["-R", "u+w", path], { timeout: 120_000 });
+    rmSync(path, { recursive: true, force: true, maxRetries: 3 });
 }

package/dist/toolroll-update.js

@@ -36,6 +36,7 @@ import { assertCodingUpdateStopped, backupCodingCatalog, codingCatalogExists, re
 import { installLaunchdService, launchdPlist, stopLaunchdService, writeFileDurably } from "./daemon.js";
 import { NAME } from "./names.js";
 import { isNewer, REGISTRY } from "./releases.js";
+import { markNeverIndex } from "./never-index.js";
 /** Loaded on first use (as backup.ts and store.ts do), so modules that only import this one (the console,
  * and tests that load it in a browser-like environment) never need `node:sqlite` itself. */
 function sqlite() {
@@ -699,6 +700,7 @@ function newJournal(kind, o, now) {
     const id = randomUUID(), stageDir = join(resolve(o.stateDir), "staged-upgrades", `${kind === "update" ? "release" : "rollback"}-${o.to.version}-${id.slice(0, 8)}`);
     mkdirSync(stageDir, { recursive: true, mode: 0o700 });
     chmodSync(stageDir, 0o700);
+    markNeverIndex(dirname(stageDir));
     return { version: 1, id, kind, stateDir: resolve(o.stateDir), databaseFile: o.databaseFile, stageDir, from: o.from, to: o.to, when: o.when, at: o.at, actor: o.actor, phase: "scheduled", detail: "", steps: [], startedAt: now.toISOString(), updatedAt: now.toISOString() };
 }
 function assertNoneActive(stateDir) {

package/dist/workspace-ui.js

@@ -371,7 +371,9 @@ function sentenceOf(text) {
  * the saved log. Null when the log printed nothing. */
 export function lastErrorLineOf(log) {
     const lines = log.split("\n");
-    const printed = (text) => text.trim() !== "" && !/^\$ /.test(text) && !/^\(exit -?[0-9]+\)$/.test(text.trim()) && !/^--- (stdout|stderr) ---$/.test(text.trim());
+    const printed = (text) => text.trim() !== "" && !/^\$ /.test(text) && !/^\(exit -?[0-9]+\)$/.test(text.trim()) && !/^--- (stdout|stderr) ---$/.test(text.trim())
+        // A section's own header ("=== Project check · attempt 1 ===") is the log's, never the check's output.
+        && !/^=== .* ===$/.test(text.trim());
     const stderr = lines.findIndex(text => text.trim() === "--- stderr ---");
     const pick = (from, to) => {
         let last = null;

package/dist/worktree.js

@@ -31,6 +31,7 @@ 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";
+import { markNeverIndex } from "./never-index.js";
 /**
  * The note a lease leaves in the checkout, naming the process holding it.
  *
@@ -337,6 +338,14 @@ export class WorktreePool {
             const branchExists = request.base !== undefined && request.reuseBranch === true &&
                 (await this.git(request.repo, ["rev-parse", "--verify", "--quiet", `refs/heads/${request.branch}`], READ_ONLY)).code === 0;
             const fromBase = request.base !== undefined && !branchExists;
+            // Spotlight leaves the checkouts alone: the marker sits in the pool and the project's folder, never inside a
+            // checkout, where a build's `git add -A` would commit it (never-index.ts).
+            try {
+                mkdirSync(dirname(path), { recursive: true });
+            }
+            catch { /* git reports it */ }
+            markNeverIndex(this.options.root);
+            markNeverIndex(dirname(path));
             const add = await this.git(request.repo, [
                 "worktree",
                 "add",

package/package.json

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