toolroll 0.9.93 → 0.9.94

package/dist/server/welcome.js

@@ -87,7 +87,7 @@ ${listed.length === 0 ? "" : html `<div class="welcome-rows">${listed}</div>`}${
     const taskLeads = lead === "task";
     if (taskLeads)
         primary = btn("Write a task", { variant: "primary", href: "/tasks/new" });
-    const taskBody = model.task.done ? html `<p class="k-note">Filed. Its plan waits for your approval in <a class="k-link" href="/work">Tasks</a>.</p>`
+    const taskBody = model.task.done ? html `<p class="k-note">Filed. Its plan waits for your approval in <a class="k-link" href="/tasks">Tasks</a>.</p>`
         : !model.task.open ? html `<p class="k-note">Add a project first.</p>`
             : html `<p class="k-note">Describe a change in a sentence or two. Nothing starts until you approve its plan.</p>\
 ${model.task.starters.length === 0 ? "" : html `<div class="k-ideas" aria-label="Ideas to start from" data-starters>${model.task.starters.map(one => html `<a class="k-btn k-btn-outline k-idea" href="${one.href}">${one.label}</a>`)}</div>`}\

package/dist/settings-groups-ui.js

@@ -465,7 +465,7 @@ export function systemGroup(facts, flags) {
     const links = facts.operator ? settingsLinks("In this group", [
         settingsLink({ href: "/settings/updates", title: "Updates", status: facts.updates === null ? "Toolroll’s own version" : `Toolroll ${facts.updates.current}` }),
         settingsLink({ href: "/settings/backups", title: "Backups", status: facts.backup?.words ?? "When and where the database is copied", needs: facts.backup?.failed ? 1 : 0 }),
-        settingsLink({ href: "/settings/storage", title: "Storage", status: "Checkouts on this computer, and cleaning them up" }),
+        settingsLink({ href: "/settings/storage", title: "Storage", status: "Task folders on this computer, and cleaning them up" }),
         settingsLink({ href: "/settings/retention", title: "Retention", status: "How long run logs and chats are kept" }),
         settingsLink({ href: "/settings/monitoring", title: "Monitoring", status: "Send the audit stream and traces to your own systems" }),
         settingsLink({ href: "/settings/data", title: "Data export", status: "Everything except secrets, as one download" }),

package/dist/setup-guide.d.ts

@@ -18,9 +18,9 @@ export declare function previewProjectInstructions(repo: string): {
     ok: false;
     message: string;
     plan?: never;
-    content?: never;
     fingerprint?: never;
     installed?: never;
+    content?: never;
 } | {
     message?: never;
     ok: true;
@@ -33,7 +33,7 @@ export declare function addProjectInstructions(repo: string, fingerprint: string
     ok: false;
     message: string;
     plan?: never;
-    content?: never;
     fingerprint?: never;
     installed?: never;
+    content?: never;
 } | import("./skills.js").InstallResult;

package/dist/stop-proof.js

@@ -26,7 +26,7 @@ import { hostname } from "node:os";
 import { sep } from "node:path";
 import { ownedProcessCount, runOwnerTag } from "./exec.js";
 import { closeoutTargets, processCensus, protectedProcesses, stopProcesses, stoppedWords } from "./run-closeout.js";
-import { recordStopProofBlocked, settleRunStopByObservation } from "./store.js";
+import { localWitnessSql, recordStopProofBlocked, settleRunStopByObservation } from "./store.js";
 import { worktreeProcessOccupancy } from "./worktree.js";
 /** How long after a run finished its processes have to go on their own before Toolroll looks. */
 export const STOP_PROOF_GRACE_MS = 60_000;
@@ -223,7 +223,8 @@ export async function proveRunStopped(store, runId, clock, options = {}) {
             return { run: subject, outcome: "waiting", words: "a process of it is still tracked here" };
         if (process.platform === "win32")
             return block(store, subject, "can't be checked on this computer: Windows processes can't be listed by folder", "no folder listing on Windows", now);
-        const foreign = store.handle.prepare("SELECT host FROM run_process WHERE run = ? AND exited_at IS NULL AND host <> ? LIMIT 1").get(subject, hostname());
+        const local = localWitnessSql(store.handle);
+        const foreign = store.handle.prepare(`SELECT host FROM run_process WHERE run = ? AND exited_at IS NULL AND NOT ${local.sql} LIMIT 1`).get(subject, ...local.params);
         if (foreign !== undefined)
             return block(store, subject, `ran on another computer (${String(foreign["host"])}); only that computer can check it stopped`, `an open witness belongs to ${String(foreign["host"])}`, now);
         if (run.worktree !== null) {
@@ -277,10 +278,11 @@ function block(store, runId, words, detail, now) {
 export async function proveFinishedRunsStopped(store, clock, options = {}) {
     const grace = options.afterFinishMs ?? STOP_PROOF_GRACE_MS;
     const before = new Date(clock().getTime() - grace).toISOString();
+    const local = localWitnessSql(store.handle, "p");
     const runs = store.handle.prepare(`SELECT id FROM run r WHERE r.outcome IS NOT NULL AND r.finished_at IS NOT NULL AND r.finished_at <= ? AND (
-      EXISTS (SELECT 1 FROM run_process p WHERE p.run = r.id AND p.exited_at IS NULL AND p.pid IS NULL AND p.containment IS NULL AND p.container IS NULL AND p.host = ?)
+      EXISTS (SELECT 1 FROM run_process p WHERE p.run = r.id AND p.exited_at IS NULL AND p.pid IS NULL AND p.containment IS NULL AND p.container IS NULL AND ${local.sql})
       OR (r.provider_started_at IS NOT NULL AND NOT EXISTS (SELECT 1 FROM run_process p WHERE p.run = r.id) AND NOT EXISTS (SELECT 1 FROM run_process_summary s WHERE s.run = r.id)))
-    ORDER BY r.id LIMIT ?`).all(before, hostname(), options.batch ?? 50).map(row => Number(row["id"]));
+    ORDER BY r.id LIMIT ?`).all(before, ...local.params, options.batch ?? 50).map(row => Number(row["id"]));
     const out = [];
     const shared = sharedLook(options);
     for (const runId of runs) {

package/dist/storage-sweep-process.js

@@ -15,7 +15,7 @@ export function sweepResponse(value, request) {
     if (!object(value) || value.version !== 1 || !object(value.record))
         return false;
     const record = value.record;
-    const kinds = ["test temp", "orphans", ...(request.poolRoot === null ? [] : ["checkouts"]), "runtimes", "dependencies"];
+    const kinds = ["test temp", "orphans", ...(request.poolRoot === null ? [] : ["checkouts"]), "runtimes", "dependencies", "check history"];
     if (!date(record.at) || record.source !== "automatic" || record.actor !== request.actor || !Array.isArray(record.parts) || record.parts.length !== kinds.length)
         return false;
     return record.parts.every((part, index) => object(part) && part.kind === kinds[index] &&

package/dist/storage-sweep.d.ts

@@ -1,13 +1,13 @@
 import { type Located } from "./orphan-sweep.js";
 import { type ProcessRow } from "./run-closeout.js";
-import type { Store } from "./store.js";
+import { type Store } from "./store.js";
 import { type WorktreePool } from "./worktree.js";
 import { type SweepCompletion, type SweepExecutor } from "./storage-sweep-process.js";
 export declare const SWEEP_CURSOR = "storage-sweep";
 export declare const SWEEP_EVERY_MS = 86400000;
 /** A sweep that failed somewhere, or left work for later, runs again this soon. */
 export declare const RETRY_MS: number;
-export type SweepKind = "test temp" | "orphans" | "checkouts" | "runtimes" | "dependencies";
+export type SweepKind = "test temp" | "orphans" | "checkouts" | "runtimes" | "dependencies" | "check history";
 export type SweepPart = {
     kind: SweepKind;
     count: number;
@@ -35,6 +35,8 @@ export type SweepDeps = {
     inUse?: () => string[];
     scripts?: (pids: readonly number[]) => string[];
     graceMs?: number;
+    /** Which processes run from inside each path. */
+    cwds?: (paths: readonly string[]) => Map<string, number[]>;
 };
 export declare function storageSweepOff(env?: NodeJS.ProcessEnv): boolean;
 export declare function sweepFailure(at: string, actor: string, withPool: boolean, reason: Exclude<SweepCompletion, {
@@ -69,7 +71,7 @@ export declare function lastSweep(store: Store, source?: SweepRecord["source"]):
 /** When the next automatic sweep is due, or null when it is off. */
 export declare function nextSweepAt(store: Store): string | null;
 export declare function partWords(one: Pick<SweepPart, "kind" | "count">): string;
-/** "Removed 120 test temp folders and 2 finished checkouts, about 1.2 GB. Stopped 1 leftover process. 3 couldn't be removed." */
+/** "Removed 120 test temp folders and 2 task folders, about 1.2 GB. Stopped 1 leftover process. 3 couldn't be removed." */
 export declare function sweepWords(parts: readonly SweepPart[]): string;
 /** The details a disclosure shows: each part's paths, problems and what's left for later, one line each. */
 export declare function sweepDetails(parts: readonly SweepPart[]): string[];

package/dist/storage-sweep.js

@@ -2,7 +2,7 @@
  * The storage sweep: the plane cleans up after itself without anyone running a command. About once a day, when nothing
  * is running or waiting (storage-sweep-schedule.ts: one service takes it, the cursor moves in the same transaction),
  * it removes test temp folders nothing touched for a day (test-temp.ts), stops orphans Toolroll left running (orphan-sweep.ts), removes finished checkouts the cleanup
- * setting lets go (checkout-cleanup.ts), keeps the current, previous and newest staged runtimes (staged-runtimes.ts)
+ * setting lets go and idle ones past the idle limit (checkout-cleanup.ts), keeps the current, previous and newest staged runtimes (staged-runtimes.ts)
  * and removes shared dependency installs no checkout has used for a week (shared-deps.ts).
  *
  * Nothing live work uses goes (`liveWork`): while a run is open, a lease current or a checkout in use, each removal
@@ -15,6 +15,8 @@
  * The everyday work stays where it happens: suites remove their own temp roots and processes, a run's processes stop
  * when it ends and a finished checkout goes on the worker's next pass. This is the net for what slipped through.
  *
+ * The last part is rows, not disk: test results and flaky-test observations past their 180 days (check history).
+ *
  * What each sweep did is saved (the latest few) and in the ledger: `toolroll storage` and Settings → Storage show it.
  * A clean-up by hand (`storage clean --yes`) is saved the same way. A part that failed, or had more than one pass
  * takes, brings the next sweep forward to an hour later; it still waits for nothing to be running.
@@ -22,14 +24,18 @@
  * it runs on).
  */
 import { realpathSync } from "node:fs";
-import { hostname } from "node:os";
 import { dirname, join, resolve, sep } from "node:path";
+import { pruneCheckResults } from "./check-facts.js";
 import { cleanCheckouts } from "./checkout-cleanup.js";
+import { pruneCiObservations } from "./flaky-ci.js";
+import { pruneObservations } from "./flaky.js";
 import { durationWords, locateProcesses, sweepOrphans, ownerRunning } from "./orphan-sweep.js";
 import { processCensus } from "./run-closeout.js";
 import { linkedKey, pruneUnusedShared, sharedDepsRoot, sharedUse, SHARED_UNUSED_MS } from "./shared-deps.js";
 import { pruneStagedRuntimes, runtimesInUse, runtimeScriptPaths, stagePlan } from "./staged-runtimes.js";
 import { bytesWords, diskBytes } from "./storage.js";
+import { localWitnessSql } from "./store.js";
+import { processesInStrict } from "./stop-proof.js";
 import { removeStaleTestTemp } from "./test-temp.js";
 import { worktreeProcessOccupancy } from "./worktree.js";
 import { runSweepChild } from "./storage-sweep-process.js";
@@ -80,8 +86,9 @@ export function liveWork(store, depsRoot, now, where) {
     }
     if (tasks.size === 0 && paths.length === 0)
         return { live: false, paths: [], blind: false };
+    const local = localWitnessSql(db, "p");
     const witnessed = db.prepare(`SELECT p.pid AS pid FROM run_process p JOIN run r ON r.id = p.run
-    WHERE r.finished_at IS NULL AND p.exited_at IS NULL AND p.pid IS NOT NULL AND p.host = ?`).all(hostname());
+    WHERE r.finished_at IS NULL AND p.exited_at IS NULL AND p.pid IS NOT NULL AND ${local.sql}`).all(...local.params);
     for (const row of witnessed)
         pids.add(Number(row["pid"]));
     const from = pids.size === 0 ? [] : where([...pids].sort((a, b) => a - b));
@@ -181,7 +188,7 @@ export async function sweepStorage(store, deps, now, execute = runSweepChild) {
     return saveSweep(store, record);
 }
 export function sweepKinds(withPool) {
-    return ["test temp", "orphans", ...(withPool ? ["checkouts"] : []), "runtimes", "dependencies"];
+    return ["test temp", "orphans", ...(withPool ? ["checkouts"] : []), "runtimes", "dependencies", "check history"];
 }
 /** Child side (also a focused unit-test seam): every scan and removal, without saving the parent's result. */
 export async function executeSweep(store, deps, now) {
@@ -221,8 +228,15 @@ export async function executeSweep(store, deps, now) {
     if (deps.pool !== null) {
         const pool = deps.pool;
         await part("checkouts", async () => {
-            const done = await cleanCheckouts(store, pool, now, { manual: false, actor, spare });
-            return { count: done.removed.length, bytes: done.freed, failed: done.kept.filter(one => one.why === "git refused").length, items: capped(done.removed.map(one => one.path)) };
+            // Idle folders go here only: nothing records a person's shell or editor in one, so the OS is asked. Unreadable keeps it.
+            const occupied = (path) => { try {
+                return (deps.cwds ?? processesInStrict)([path]).size > 0;
+            }
+            catch {
+                return true;
+            } };
+            const done = await cleanCheckouts(store, pool, now, { manual: false, actor, spare, idle: { occupied } });
+            return { count: done.removed.length, bytes: done.freed, failed: done.kept.filter(one => one.why === "git refused").length, ...(done.more ? { more: true } : {}), items: capped(done.removed.map(one => one.path)) };
         });
     }
     const stateDir = dirname(deps.databaseFile);
@@ -244,6 +258,12 @@ export async function executeSweep(store, deps, now) {
         const done = await pruneUnusedShared(root, checkouts, now(), SHARED_UNUSED_MS, { spare });
         return { count: done.removed.length, bytes: done.removed.reduce((sum, one) => sum + (sizes.get(one.dir) ?? 0), 0), failed: done.failed.length, items: capped(done.removed.map(one => one.dir)) };
     });
+    // Learning rows past their retention (docs/plans/learning-loops.md): the only DELETE on them. A lesson note's tallies
+    // are written with each check and never pruned, so what they say doesn't change here.
+    await part("check history", async () => {
+        const count = store.transact(() => pruneCheckResults(store, now()) + pruneObservations(store, now()) + pruneCiObservations(store, now()));
+        return { count, bytes: 0, failed: 0, items: [] };
+    });
     return { at: now().toISOString(), source: "automatic", actor, parts };
 }
 /** Save what a sweep or a clean-up by hand did (the latest few are kept), with one ledger entry saying it. */
@@ -285,19 +305,20 @@ export function nextSweepAt(store) {
 const NOUNS = {
     "test temp": ["test temp folder", "test temp folders"],
     orphans: ["leftover process", "leftover processes"],
-    checkouts: ["finished checkout", "finished checkouts"],
+    checkouts: ["task folder", "task folders"],
     runtimes: ["staged runtime", "staged runtimes"],
     dependencies: ["unused dependency install", "unused dependency installs"],
+    "check history": ["old test result", "old test results"],
 };
 /** What a part looks at, for "Couldn't check …". */
-const CHECKED = { "test temp": "test temp folders", orphans: "processes", checkouts: "checkouts", runtimes: "staged runtimes", dependencies: "dependency installs" };
+const CHECKED = { "test temp": "test temp folders", orphans: "processes", checkouts: "task folders", runtimes: "staged runtimes", dependencies: "dependency installs", "check history": "old test results" };
 export function partWords(one) {
     return `${one.count.toLocaleString("en-US")} ${NOUNS[one.kind][one.count === 1 ? 0 : 1]}`;
 }
 function list(items) {
     return items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
 }
-/** "Removed 120 test temp folders and 2 finished checkouts, about 1.2 GB. Stopped 1 leftover process. 3 couldn't be removed." */
+/** "Removed 120 test temp folders and 2 task folders, about 1.2 GB. Stopped 1 leftover process. 3 couldn't be removed." */
 export function sweepWords(parts) {
     const removed = parts.filter(one => one.kind !== "orphans" && one.count > 0);
     const stopped = parts.find(one => one.kind === "orphans" && one.count > 0);

package/dist/storage-ui.js

@@ -1,15 +1,16 @@
 /**
- * Settings → Storage: how much space task checkouts use, what a clean-up would free now, the clean-up's preview (what
+ * Settings → Storage: how much space task folders (checkouts) use, what a clean-up would free now, what the next sweep's
+ * idle cleanup takes and when, the folders with uncommitted changes a person decides about, the clean-up's preview (what
  * goes, what stays and why, with paths) and its Remove behind the password, what the last storage sweep removed and
  * when (its paths in a disclosure) and why the next one waits, what landed work's teardown did and still waits on (in a
- * disclosure, with the one-time command for older work), and when a finished task's clean checkout goes by itself. An
- * instance operator's page, built from the revamp kit; the Settings frame adds the title.
+ * disclosure, with the one-time command for older work), and when a task's clean folder goes by itself. An instance
+ * operator's page, built from the revamp kit; the Settings frame adds the title.
  */
 import { homedir } from "node:os";
 import { basename } from "node:path";
 import { html, joinHtml } from "./html.js";
 import { previewDigest, whyWords } from "./checkout-cleanup.js";
-import { CLEANUP_CHOICES, bytesWords } from "./storage.js";
+import { CLEANUP_CHOICES, IDLE_CHOICES, bytesWords, idleCleanupWords } from "./storage.js";
 import { sweepDetails, sweepWords } from "./storage-sweep.js";
 import { sweepScheduleWords } from "./storage-sweep-schedule.js";
 import { codeLine, disclose, formRow, icon, infoLine, note, notice, select, settingsRecord, settingsSection } from "./server/kit.js";
@@ -48,17 +49,18 @@ function sweepHtml(sweep) {
 /** Landed work, on demand: what its teardown did, what it waits on and why, and the one-time command for older work. */
 function landedHtml(landed) {
     const done = landed.completed + landed.checkouts + landed.branches === 0 ? "No landed work cleaned up yet."
-        : `${plural(landed.completed, "task")} marked complete; ${plural(landed.checkouts, "checkout")} and ${plural(landed.branches, "local branch", "local branches")} removed.`;
+        : `${plural(landed.completed, "task")} marked complete; ${plural(landed.checkouts, "task folder")} and ${plural(landed.branches, "local branch", "local branches")} removed.`;
     const waiting = landed.waiting.length === 0 ? "" : html `<div data-landed-waiting>${note(`Waiting (${landed.waiting.length}):`)}${landed.waiting.map(one => settingsRecord({ title: html `<span class="k-mono">${tilde(one.target)}</span>`, sub: one.why ?? "" }))}</div>`;
     return html `<div data-landed>${disclose("Landed work", joinHtml([note(done), waiting,
         note(html `For work that landed before this: <code class="k-mono">toolroll storage clean --landed</code> shows what would go; add <code class="k-mono">--yes</code> to do it.`)]))}</div>`;
 }
-/** One checkout: the task it was for, its size, where it is (the home folder as ~), why it stays, and Discard when it has changes. */
+/** One task folder: the task it was for, its size, where it is (the home folder as ~), why it stays, and Discard when it has changes. */
 function item(one) {
-    const why = one.why === null ? "" : `${whyWords(one)[0].toUpperCase()}${whyWords(one).slice(1)}`;
+    // Under "Uncommitted changes" the heading already says why it stays.
+    const why = one.why === null || one.why === "has changes" ? "" : `${whyWords(one)[0].toUpperCase()}${whyWords(one).slice(1)}`;
     const discard = one.why === "has changes"
         ? disclose("Discard", kitSectionForm({ proof: "storage-discard", action: "/settings/storage/discard", id: `discard-${previewId(one.path)}`, hidden: { path: one.path },
-            save: { label: "Discard changes", variant: "danger" }, body: note("Throws away this checkout and its uncommitted changes. Its branch stays.") }))
+            save: { label: "Discard changes", variant: "danger" }, body: note("Throws away this folder and its uncommitted changes. Its branch stays.") }))
         : "";
     return settingsRecord({ title: one.taskId ?? basename(one.path), attrs: { "data-checkout": one.path }, when: bytesWords(one.bytes),
         sub: html `<span class="k-mono">${tilde(one.path)}</span>${why === "" ? "" : ` · ${why}`}`, more: discard });
@@ -67,29 +69,38 @@ function item(one) {
 const previewId = (path) => path.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").slice(-48) || "checkout";
 export function storageHtml(view, said) {
     const { plan } = view;
-    const facts = [plural(plan.count, "checkout"), `${plan.waitingReview} waiting for review`, `${plan.withChanges} kept for their changes`].join(" · ");
+    const facts = [plural(plan.count, "task folder"), `${plan.waitingReview} waiting for review`, `${plan.withChanges} with uncommitted changes`].join(" · ");
     const frees = plan.go.length === 0 ? "Nothing to clean up now." : `Cleaning up now frees about ${bytesWords(plan.freeBytes)}.`;
-    const checkouts = settingsSection({ id: "checkouts", title: `Checkouts use ${bytesWords(plan.totalBytes)}`,
+    const checkouts = settingsSection({ id: "checkouts", title: `Task folders use ${bytesWords(plan.totalBytes)}`,
         body: joinHtml([
             said.problem ? notice(said.problem) : said.said ? infoLine(said.said) : "",
             html `<p class="k-note" data-checkout-bytes="${plan.totalBytes}">${facts}</p>`,
             view.measured ?? "",
             html `<p class="k-note" data-clean-bytes="${plan.freeBytes}">${frees}</p>`,
+            html `<p class="k-note" data-idle-bytes="${plan.idleBytes}">${idleCleanupWords(plan)}</p>`,
             view.sweep === undefined ? "" : sweepHtml(view.sweep),
             view.landed === undefined ? "" : landedHtml(view.landed),
         ]) });
     const remove = plan.go.length === 0 ? "" : kitSectionForm({ proof: "storage-clean", action: "/settings/storage/clean", id: "clean-form", hidden: { preview: previewDigest(plan) },
-        save: { label: `Remove ${plural(plan.go.length, "checkout")}`, variant: "danger" }, body: html `` });
+        save: { label: `Remove ${plural(plan.go.length, "task folder")}`, variant: "danger" }, body: html `` });
     const goes = plan.go.length === 0 ? note("Nothing to remove now.")
         : html `<div data-goes>${plan.go.map(one => item(one))}</div>`;
-    const stays = plan.stay.length === 0 ? "" : disclose(`Stays (${plan.stay.length})`, html `<div data-stays>${plan.stay.map(one => item(one))}</div>`);
+    const changed = plan.stay.filter(one => one.why === "has changes");
+    const others = plan.stay.filter(one => one.why !== "has changes");
+    const stays = others.length === 0 ? "" : disclose(`Stays (${others.length})`, html `<div data-stays>${others.map(one => item(one))}</div>`);
+    // Never removed by itself: a person looks at each and keeps it or discards it.
+    const changes = changed.length === 0 ? "" : settingsSection({ id: "uncommitted", title: `Uncommitted changes (${changed.length})`,
+        lead: `${changed.length === 1 ? "This folder has" : "These folders have"} work that isn't on any branch, about ${bytesWords(changed.reduce((sum, one) => sum + one.bytes, 0))}. Toolroll never removes ${changed.length === 1 ? "it" : "them"} by itself.`,
+        body: html `<div data-uncommitted>${changed.map(one => item(one))}</div>` });
     const cleanUp = settingsSection({ id: "clean-up", title: "Clean up now",
-        lead: plan.go.length === 0 ? "Nothing to remove now." : `Removes ${plural(plan.go.length, "checkout")}, about ${bytesWords(plan.freeBytes)}. Their branches stay, so nothing committed is lost.`,
+        lead: plan.go.length === 0 ? "Nothing to remove now." : `Removes ${plural(plan.go.length, "task folder")}, about ${bytesWords(plan.freeBytes)}. Their branches stay, so nothing committed is lost.`,
         body: html `<div data-clean-up>${joinHtml([plan.go.length === 0 ? "" : goes, remove, stays])}</div>` });
     const automatic = settingsSection({ id: "automatic-cleanup", title: "Automatic cleanup",
-        lead: "Its branch stays. Checkouts with changes, commits on no branch, in use, or waiting for review are kept. When a task's work is already in main, Toolroll marks it complete and removes its checkout and local branches.",
+        lead: "Branches stay, so a later run, revision or retry makes a new folder. Folders with uncommitted changes, commits on no branch, or in use are kept. When a task's work is already in main, Toolroll marks it complete and removes its folder and local branches.",
         body: kitSectionForm({ proof: "storage-cleanup", action: "/settings/storage", id: "cleanup-form", gate: true,
-            body: formRow("Remove a finished task's clean checkout", null, select({ id: "storage-cleanup", name: "cleanup", label: "Remove a finished task's clean checkout", current: plan.cleanup,
-                items: CLEANUP_CHOICES.map(one => [one.value, one.label]) }), "inline") }) });
-    return joinHtml([checkouts, cleanUp, automatic]);
+            body: joinHtml([formRow("Remove a finished task's clean folder", null, select({ id: "storage-cleanup", name: "cleanup", label: "Remove a finished task's clean folder", current: plan.cleanup,
+                    items: CLEANUP_CHOICES.map(one => [one.value, one.label]) }), "inline"),
+                formRow("Remove an idle task's clean folder", "Even with its result waiting for review or the task unfinished. Idle means no run, no one acting on it and no open lease.", select({ id: "storage-idle", name: "idle", label: "Remove an idle task's clean folder", current: plan.idle,
+                    items: IDLE_CHOICES.map(one => [one.value, one.label]) }), "inline")]) }) });
+    return joinHtml([checkouts, changes, cleanUp, automatic]);
 }

package/dist/storage.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "./store.js";
-import { type CheckoutCleanup } from "./contracts/storage.js";
+import { type CheckoutCleanup, type CheckoutIdle } from "./contracts/storage.js";
 /** Settings → Storage: when a finished task's clean checkout is removed. One row, or none (the default). */
 export declare const CHECKOUT_CLEANUP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS checkout_cleanup_setting (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  cleanup    TEXT NOT NULL CHECK (cleanup IN ('finished', '2d', '7d', 'never')),\n  updated_by TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n";
 /**
@@ -10,7 +10,7 @@ export declare const CHECKOUT_CLEANUP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS che
 export declare const LANDED_CLEANUP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS landed_cleanup (\n  id          INTEGER PRIMARY KEY,\n  repo        TEXT NOT NULL,\n  task_id     TEXT,\n  run_id      INTEGER,\n  receipt     TEXT,\n  head        TEXT NOT NULL,\n  how         TEXT NOT NULL CHECK (how IN ('merged', 'in-main', 'content-in-main')),\n  reason      TEXT NOT NULL,\n  completed   INTEGER NOT NULL DEFAULT 0 CHECK (completed IN (0, 1)),\n  actor       TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  finished_at TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS landed_cleanup_result ON landed_cleanup(run_id) WHERE run_id IS NOT NULL;\nCREATE TABLE IF NOT EXISTS landed_cleanup_item (\n  id      INTEGER PRIMARY KEY,\n  cleanup INTEGER NOT NULL REFERENCES landed_cleanup(id) ON DELETE CASCADE,\n  kind    TEXT NOT NULL CHECK (kind IN ('checkout', 'branch')),\n  repo    TEXT NOT NULL,\n  target  TEXT NOT NULL,\n  expect  TEXT NOT NULL,\n  state   TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending', 'done', 'kept')),\n  why     TEXT,\n  done_at TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS landed_cleanup_pending ON landed_cleanup_item(kind, repo, target) WHERE state = 'pending';\nCREATE INDEX IF NOT EXISTS landed_cleanup_item_of ON landed_cleanup_item(cleanup, state);\n";
 /** What each storage sweep or clean-up by hand did (storage-sweep.ts): the latest few. */
 export declare const STORAGE_SWEEP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS storage_sweep (\n  id     INTEGER PRIMARY KEY,\n  at     TEXT NOT NULL,\n  source TEXT NOT NULL CHECK (source IN ('automatic', 'manual')),\n  actor  TEXT NOT NULL,\n  result TEXT NOT NULL\n);\n";
-export type { CheckoutCleanup } from "./contracts/storage.js";
+export type { CheckoutCleanup, CheckoutIdle } from "./contracts/storage.js";
 export declare const DEFAULT_CLEANUP: CheckoutCleanup;
 export declare const CLEANUP_CHOICES: readonly {
     value: CheckoutCleanup;
@@ -20,6 +20,31 @@ export declare const CLEANUP_CHOICES: readonly {
 /** `finished` (or complete, cancelled), `2d`, `7d` (or week, 1w), `never` (or off); undefined when it's none of those. */
 export declare function parseCleanup(text: string): CheckoutCleanup | undefined;
 export declare function cleanupWords(cleanup: CheckoutCleanup): string;
+/**
+ * v151: how long a task stays idle (no run, no person's act, no open lease) before its clean folder goes, even with its
+ * result waiting for review or the task unfinished (checkout-cleanup.ts). Saved rows read NULL: the default.
+ */
+export declare const V151_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+export declare const DEFAULT_IDLE: CheckoutIdle;
+export declare const IDLE_CHOICES: readonly {
+    value: CheckoutIdle;
+    label: string;
+    days: number | null;
+}[];
+/** `7`, `14d`, `30 days`, `never` (or off); undefined when it's none of those. */
+export declare function parseIdle(text: string): CheckoutIdle | undefined;
+/** After "A task's clean folder is removed ". */
+export declare function idleWords(idle: CheckoutIdle): string;
+/** What the next sweep's idle cleanup takes, for `toolroll storage` and Settings → Storage. The sweep's own line says when. */
+export declare function idleCleanupWords(plan: {
+    cleanup: CheckoutCleanup;
+    idle: CheckoutIdle;
+    idleCount: number;
+    idleBytes: number;
+}): string;
 /** Bytes each path holds on disk: one `du` for them all (fast on a 300 MB checkout), a walk where it can't answer. */
 export declare function diskBytes(paths: readonly string[]): Map<string, number>;
 export type StorageLine = {

package/dist/storage.js

@@ -4,14 +4,14 @@
  * Build checkouts and staged releases are the big ones; the worker removes a
  * finished task's clean checkout as the checkout cleanup setting says
  * (checkout-cleanup.ts), and the daily storage sweep (storage-sweep.ts) takes
- * what slips through: stale test temp folders, leftover processes, extra
+ * idle tasks' clean checkouts and what slips through: stale test temp folders, leftover processes, extra
  * staged runtimes and dependency installs unused for a week.
  */
 import { execFile, spawnSync } from "node:child_process";
 import { lstatSync, readdirSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { DEPS_FOLDER, sharedCopies } from "./shared-deps.js";
-import { checkoutCleanupSchema } from "./contracts/storage.js";
+import { checkoutCleanupSchema, checkoutIdleSchema } from "./contracts/storage.js";
 /** Settings → Storage: when a finished task's clean checkout is removed. One row, or none (the default). */
 export const CHECKOUT_CLEANUP_SCHEMA = `
 CREATE TABLE IF NOT EXISTS checkout_cleanup_setting (
@@ -93,6 +93,43 @@ export function cleanupWords(cleanup) {
         : cleanup === "never" ? "never (only when you clean up)"
             : `${cleanup === "2d" ? "2 days" : "a week"} after its task is complete or cancelled`;
 }
+/**
+ * v151: how long a task stays idle (no run, no person's act, no open lease) before its clean folder goes, even with its
+ * result waiting for review or the task unfinished (checkout-cleanup.ts). Saved rows read NULL: the default.
+ */
+export const V151_ADDED_COLUMNS = Object.freeze({
+    checkout_cleanup_setting: { idle: { definition: "TEXT CHECK (idle IN ('7d', '14d', '30d', 'never'))", saved: "NULL" } },
+});
+export const DEFAULT_IDLE = "14d";
+export const IDLE_CHOICES = [
+    { value: "7d", label: "After 7 days idle", days: 7 },
+    { value: "14d", label: "After 14 days idle", days: 14 },
+    { value: "30d", label: "After 30 days idle", days: 30 },
+    { value: "never", label: "Never", days: null },
+];
+/** `7`, `14d`, `30 days`, `never` (or off); undefined when it's none of those. */
+export function parseIdle(text) {
+    const value = text.trim().toLowerCase().replace(/\s+/g, " ");
+    if (value === "off")
+        return "never";
+    const days = /^(\d+)( ?d| days?)?$/.exec(value)?.[1];
+    const parsed = checkoutIdleSchema.safeParse(days === undefined ? value : `${days}d`);
+    return parsed.success ? parsed.data : undefined;
+}
+/** After "A task's clean folder is removed ". */
+export function idleWords(idle) {
+    const days = IDLE_CHOICES.find(one => one.value === idle).days;
+    return days === null ? "never for being idle" : `after ${days} days idle`;
+}
+/** What the next sweep's idle cleanup takes, for `toolroll storage` and Settings → Storage. The sweep's own line says when. */
+export function idleCleanupWords(plan) {
+    if (plan.cleanup === "never" || plan.idle === "never")
+        return "Idle cleanup is off.";
+    const limit = `${idleWords(plan.idle)[0].toUpperCase()}${idleWords(plan.idle).slice(1)}`;
+    if (plan.idleCount === 0)
+        return `${limit}, a task's clean folder goes. None are due.`;
+    return `${limit}, a task's clean folder goes: the next sweep frees about ${bytesWords(plan.idleBytes)} (${plan.idleCount} folder${plan.idleCount === 1 ? "" : "s"}).`;
+}
 /** Bytes each path holds on disk: one `du` for them all (fast on a 300 MB checkout), a walk where it can't answer. */
 export function diskBytes(paths) {
     const sizes = new Map();

package/dist/store.d.ts

@@ -5,6 +5,7 @@ import { type ProjectSandbox } from "./project-sandbox.js";
 import type { FencePolicy } from "./agent-fence.js";
 import { type NetworkProfile, type ProjectNetwork, type RunNetworkRecord } from "./egress.js";
 import { type AcpLaunch } from "./acp-attest.js";
+import { type CheckStamp, type StampReading } from "./check-stamp.js";
 export { refArchived, taskArchived } from "./task-archive.js";
 import { type ChatBinding } from "./chat-core.js";
 import { ChatMessages, TELEGRAM_HOLD_REASONS, TELEGRAM_SKIPPED_ELSEWHERE, TELEGRAM_SKIPPED_OTHER_CHAT, TELEGRAM_SKIPPED_QUIET } from "./chat-messages.js";
@@ -16,6 +17,7 @@ import type { FlowCardChange, FlowCardFields } from "./contracts/flow-card.js";
 import { type Actor } from "./actor.js";
 import { type LiveActivityKind } from "./live.js";
 import { type CredentialKind, type TokenPurpose } from "./api-tokens.js";
+import { type ThisMachine } from "./machine-identity.js";
 import { type CriterionMatrixRow, type CriterionJudgementWord } from "./proof.js";
 import { type Authority, type LocalMode } from "./local-owner.js";
 import { type ScopeAuthor, type ExecutionProfile, type UnattendedPermissionMode, type AcceptanceCriterion } from "./scope.js";
@@ -29,6 +31,7 @@ import type { Scope } from "./scope.js";
 import type { QualityMode } from "./quality.js";
 import type { ProgressSnapshot } from "./plan.js";
 import { type CheckProgressSnapshot } from "./check-progress.js";
+export { V153_ADDED_COLUMNS } from "./plain-schema.js";
 import { type ReleaseCheckPurpose, type ReleaseTerms } from "./contracts/release-terms.js";
 import { type ProjectAccess } from "./project-access.js";
 import { type LedgerEntry } from "./action-ledger.js";
@@ -37,7 +40,7 @@ import { underCeiling, type OrgPolicy, type SavedPolicy } from "./policy.js";
 import { type ReviewSwitch } from "./review-switch.js";
 import { type Billing, type Budget, type BudgetAgent, type BudgetHold, type BudgetScope, type BudgetState, type SpendItem } from "./spend.js";
 import { type RetentionKind, type RetentionPeriods } from "./retention.js";
-import { type CheckoutCleanup } from "./storage.js";
+import { type CheckoutCleanup, type CheckoutIdle } from "./storage.js";
 import { type LedgerChainReport } from "./ledger-chain.js";
 import { type ApprovalGate, type ApprovalRules, type ApproverKind, type Filer } from "./approval-policy.js";
 import { type ReportedAmount } from "./reported-usage.js";
@@ -243,7 +246,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 149;
+export declare const SCHEMA_VERSION = 154;
 /** v118: the tables merged into `credential`, in the order they move (a person's API tokens keep their ids first). */
 export declare const V118_MERGED_TABLES: Readonly<Record<string, CredentialKind>>;
 /**
@@ -435,7 +438,7 @@ export declare const V147_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
 }>>>>;
 /** The v147 migration's steps after the epoch, in order: a test seam (OpenOptions.migrationStep) may stop after each. */
 export declare const V147_STEPS: readonly ["epoch", "local-mode", "password-set", "web-session", "console-instance"];
-export type MigrationStep = (typeof V147_STEPS)[number] | (typeof V148_STEPS)[number] | (typeof V149_STEPS)[number];
+export type MigrationStep = (typeof V147_STEPS)[number] | (typeof V148_STEPS)[number] | (typeof V149_STEPS)[number] | (typeof V150_STEPS)[number] | (typeof V151_STEPS)[number] | (typeof V152_STEPS)[number] | (typeof V153_STEPS)[number] | (typeof V154_STEPS)[number];
 /**
  * v148 (docs/plans/results-routing.md): every table the results-routing arc uses, landed at once because a current
  * store runs no DDL. Slice 1 writes run_cohort, route_record and models_generation; route_rule, route_exposure* and
@@ -494,6 +497,33 @@ export declare const V149_TABLES: readonly ["check_result", "check_fact", "local
 export declare const V149_REPO_TABLES: readonly ["check_fact", "local_observation", "ci_flaky_observation", "learning_watch", "lesson_note", "memory_use", "memory_tidy_proposal"];
 /** The v149 migration's steps after v148's, in order (OpenOptions.migrationStep may stop after each). */
 export declare const V149_STEPS: readonly ["learning-tables"];
+/**
+ * v150 (machine-identity.ts): which computer a process witness belongs to, by the machine's stable id rather than its
+ * network hostname (which follows the network on a Mac with no HostName set). machine_host_alias records each
+ * hostname this machine read while it knew its own id, written only by a process on that machine, beside the id it
+ * read; a witness with no id (every saved one) is this machine's when its host is one of them. Never read for any
+ * other machine's id.
+ */
+export declare const V150_SCHEMA = "\nCREATE TABLE IF NOT EXISTS machine_host_alias (\n  machine_id    TEXT NOT NULL CHECK (length(machine_id) = 32),\n  host          TEXT NOT NULL CHECK (host <> ''),\n  first_seen_at TEXT NOT NULL,\n  PRIMARY KEY (machine_id, host)\n);\n";
+/** The tables V150_SCHEMA adds. */
+export declare const V150_TABLES: readonly ["machine_host_alias"];
+/** v150: a process witness's machine id (saved witnesses read NULL: matched by host name, as before). */
+export declare const V150_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** The v150 migration's steps after v149's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V150_STEPS: readonly ["machine-aliases", "witness-machine"];
+/** The v151 migration's steps after v150's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V151_STEPS: readonly ["checkout-idle"];
+/** The v152 migration's steps after v151's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V152_STEPS: readonly ["code-map-tables", "code-map-switch", "code-map-watermark"];
+/** v153 (plain-toolroll.md Phase 2): the tables each slice owns. */
+export declare const V153_SCHEMA: string;
+/** The v153 migration's steps after v152's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V153_STEPS: readonly ["plain-tables", "plain-columns"];
+/** The v154 migration's steps after v153's, in order (OpenOptions.migrationStep may stop after each). */
+export declare const V154_STEPS: readonly ["check-stamps"];
 /**
  * v135: one approval per release (docs/plans/release-once.md). `release_authority` is the single source of truth for a
  * release a person approved: one row per generation, changed only by compare-and-swap on `rev`, with a lease whose
@@ -7425,7 +7455,8 @@ export declare class Store {
     stampRunCheckAccess(runId: number, level: CheckAccess, network?: NetworkProfile | null): void;
     /** The network a run's sign-ins checks ran under (null: none sealed; such a run's later checks run sandboxed). */
     runCheckNetwork(runId: number): NetworkProfile | null;
-    /** The level a run's checks ran at: missing or unreadable reads as sandboxed. */
+    /** The level a later check of this run may run at, at most: missing or unreadable reads as sandboxed, the narrowest.
+     * Never an account of how its checks DID run: that is runCheckStamp (check-stamp.ts). */
     runCheckAccess(runId: number): CheckAccess;
     /** A project's check access changed: saved, and in the ledger as before → after. `may` is what the caller proved:
      * "widen" only after an instance operator's password typed now; anything else may only narrow. The level is read again
@@ -8291,6 +8322,12 @@ export type ReleaseProgress = {
         message: string;
         at: string;
     } | null;
+    /** The release's task moved on since its last recorded failure: this build started after it and is running now, so
+     * the release isn't stopped there, even though `toolroll release` hasn't recorded a step since. */
+    building: {
+        run: number;
+        startedAt: string;
+    } | null;
 };
 /** What a release coordinator says about one step. */
 export type ReleaseStepEntry = {
@@ -8310,7 +8347,8 @@ export type ReleaseStepEntry = {
  */
 export declare function recordReleaseStep(store: Store, entry: ReleaseStepEntry): void;
 /** A release's steps, for the release task: the newest tag recorded for it, its steps in the order they ran, and the
- * step it stopped at when the last thing recorded was a failure. Null: no step recorded. */
+ * step it stopped at when the last thing recorded was a failure and no build of the task has started since. Null: no
+ * step recorded. */
 export declare function releaseProgressFor(store: Store, taskId: string): ReleaseProgress | null;
 /** The release task whose steps were recorded most recently (v146), or null when none was. */
 export declare function latestReleaseStepTask(store: Store): string | null;
@@ -8439,3 +8477,40 @@ export declare function settleRunStopByObservation(store: Store, args: {
     cause: StopProofCause;
     evidence: string;
 }, now: Date): boolean;
+/**
+ * This machine as the store knows it (v150, machine-identity.ts): its stable id and every name it is known by, the
+ * hostnames recorded beside its own id included. Read fresh each time, so a name recorded by another process on this
+ * machine counts at once.
+ */
+export declare function storeMachine(db: Database): ThisMachine;
+/** Load this machine's recorded names for the checks that hold no store; a store that can't read them loads none. */
+export declare function rememberStoredHostAliases(db: Database): void;
+/** Record the names this machine is known by right now beside its own id, read here at this moment (never a name a
+ * witness, a note or another computer supplied). Nothing when this machine's id is unknown. */
+export declare function recordMachineHostAliases(db: Database, now: Date): void;
+/** Whether a run_process row is this machine's (machine-identity.ts isThisMachine). */
+export declare function witnessIsLocal(row: Record<string, unknown>, here: ThisMachine): boolean;
+/** The same rule as witnessIsLocal, as SQL over run_process (optionally aliased): its id is ours, or it has none and
+ * its host is one of our names. With our id unknown, `machine_id = NULL` matches nothing: an id-bearing witness is
+ * never taken for ours. */
+export declare function localWitnessSql(db: Database, alias?: string): {
+    sql: string;
+    params: (string | null)[];
+};
+/** Whether this database has v150's run_process.machine_id. An update settles leftover records on the database it is
+ * about to back up, still at the older schema (toolroll-update.ts drain), so no query it reaches may assume the column:
+ * there every witness has no id, and the host-name rule above is the whole rule. */
+export declare function witnessesCarryMachine(db: Database): boolean;
+/** Settings → Storage: how long a task stays idle before its clean folder goes (the default until someone chooses). */
+export declare function checkoutIdle(store: Store): CheckoutIdle;
+/** Choose how long a task stays idle before its clean folder goes; the ledger keeps before → after. */
+export declare function setCheckoutIdle(store: Store, idle: CheckoutIdle, by: string, now: Date): CheckoutIdle;
+/** A check launch's execution stamp (check-stamp.ts), written by the code that launched it. One row per distinct launch. */
+export declare function recordCheckStamp(store: Store, runId: number, stamp: CheckStamp, now: Date): void;
+/** How a run's checks actually ran, by every launch it stamped: `unknown` when none is there or one can't be read. */
+export declare function runCheckStamp(store: Store, runId: number): StampReading;
+/** The newest run of a task whose checks ran (it saved a check log), and how they ran; null when none has. */
+export declare function taskCheckStamp(store: Store, repo: string, taskId: string): {
+    runId: number;
+    reading: StampReading;
+} | null;