toolroll 0.9.31 → 0.9.32

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.32",
   "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"