toolroll 0.9.30 → 0.9.32

package/dist/staged-runtimes.d.ts

@@ -0,0 +1,42 @@
+/** A deploy or update that never finished keeps its stage this long (it may be resumed). */
+export declare const UNFINISHED_KEEP_MS: number;
+export declare const STAGED_FOLDER = "staged-upgrades";
+export type Stage = {
+    path: string;
+    name: string;
+    at: number;
+    finished: boolean;
+    prior: string | null;
+    keptAside: boolean;
+};
+export type StageKeep = "current" | "previous" | "newest" | "under way" | "kept-aside database";
+export type StagePlan = {
+    keep: {
+        path: string;
+        why: StageKeep;
+    }[];
+    go: Stage[];
+    refused: string | null;
+};
+/** The `browser-*` and `release-*` stages: real folders directly in staged-upgrades, newest first. */
+export declare function stagedRuntimes(stateDir: string): Stage[];
+/**
+ * Paths a runtime may be running from: the launchd services' definitions, every `toolroll` (or older
+ * `standing-orders`) command on PATH or under nvm, this process, and `extra`.
+ */
+export declare function runtimesInUse(extra?: readonly string[], home?: string, path?: string): string[];
+/** What stays and what goes now, and why. */
+export declare function stagePlan(stateDir: string, inUse: readonly string[], now: Date): StagePlan;
+export type StagePrune = {
+    removed: string[];
+    failed: string[];
+    refused: string | null;
+};
+/**
+ * Remove the stages that go. Right before each goes, the plan is made again (what's in use now) and the stage must
+ * still be a real folder directly in staged-upgrades.
+ */
+export declare function pruneStagedRuntimes(stateDir: string, now: Date, options?: {
+    inUse?: () => string[];
+    remove?: (path: string) => void;
+}): StagePrune;

package/dist/staged-runtimes.js

@@ -0,0 +1,191 @@
+/**
+ * Staged runtimes (`staged-upgrades/`): each deploy (scripts/deploy-browser.mjs, `browser-*`) and each `toolroll
+ * update` (`release-*`) stages a whole runtime, a few hundred MB with its database backup. Oct 4: 9 of them, 2.2 GB.
+ *
+ * Kept: the current runtime (one the service, a `toolroll` command or this process runs from), the one before it
+ * (its journal's way back), the newest stage, a deploy or update still under way (no finished journal) for a week,
+ * and a stage holding a database a failed update kept aside. Everything else of those two kinds goes — after a deploy
+ * and in the plane's daily storage sweep. `rollback-*` records and anything else in the folder are never touched.
+ * With no current runtime found, nothing goes: which one is safe to remove is then unknown.
+ */
+import { lstatSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+const DAY_MS = 86_400_000;
+/** A deploy or update that never finished keeps its stage this long (it may be resumed). */
+export const UNFINISHED_KEEP_MS = 7 * DAY_MS;
+export const STAGED_FOLDER = "staged-upgrades";
+/** The canonical path, even of something that doesn't exist (yet): its nearest existing folder, resolved, plus the rest. */
+function real(path) {
+    let at = resolve(path);
+    const rest = [];
+    for (let hops = 0; hops < 256; hops++) {
+        try {
+            return join(realpathSync(at), ...rest.reverse());
+        }
+        catch { /* not there */ }
+        const up = dirname(at);
+        if (up === at)
+            break;
+        rest.push(basename(at));
+        at = up;
+    }
+    return resolve(path);
+}
+const readJson = (file) => {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return parsed !== null && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+/** The `browser-*` and `release-*` stages: real folders directly in staged-upgrades, newest first. */
+export function stagedRuntimes(stateDir) {
+    const root = real(join(stateDir, STAGED_FOLDER));
+    let names = [];
+    try {
+        names = readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    const stages = [];
+    for (const name of names) {
+        if (!/^(browser|release)-/.test(name))
+            continue;
+        const path = join(root, name);
+        try {
+            if (!lstatSync(path).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const deploy = name.startsWith("browser-") ? readJson(join(path, "deployment.json")) : null;
+        const update = name.startsWith("release-") ? readJson(join(path, "update.json")) : null;
+        const journal = deploy ?? update;
+        const stamp = String(journal?.["deployedAt"] ?? journal?.["startedAt"] ?? journal?.["createdAt"] ?? "");
+        let at = Date.parse(stamp);
+        if (!Number.isFinite(at)) {
+            try {
+                at = statSync(path).mtimeMs;
+            }
+            catch {
+                at = 0;
+            }
+        }
+        const finished = deploy !== null ? deploy["phase"] === "deployed" : update !== null ? typeof update["finishedAt"] === "string" : false;
+        const from = update?.["from"];
+        const prior = typeof deploy?.["priorRuntime"] === "string" ? deploy["priorRuntime"] : typeof from?.dist === "string" ? from.dist : null;
+        let keptAside = false;
+        try {
+            keptAside = readdirSync(path).some(one => /^orders\.(?:kept|unreadable)\./.test(one));
+        }
+        catch {
+            keptAside = true;
+        }
+        stages.push({ path, name, at, finished, prior, keptAside });
+    }
+    return stages.sort((a, b) => b.at - a.at);
+}
+/**
+ * Paths a runtime may be running from: the launchd services' definitions, every `toolroll` (or older
+ * `standing-orders`) command on PATH or under nvm, this process, and `extra`.
+ */
+export function runtimesInUse(extra = [], home = homedir(), path = process.env["PATH"] ?? "") {
+    const found = [...extra];
+    const agents = join(home, "Library", "LaunchAgents");
+    try {
+        for (const name of readdirSync(agents).filter(one => one.startsWith("com.toolroll.") || one.startsWith("com.standing-orders."))) {
+            for (const match of readFileSync(join(agents, name), "utf8").matchAll(/<string>([^<]*staged-upgrades[^<]*)<\/string>/g))
+                found.push(match[1]);
+        }
+    }
+    catch { /* no launch agents here */ }
+    const commands = path.split(":").filter(Boolean).flatMap(dir => ["toolroll", "standing-orders"].map(bin => join(dir, bin)));
+    try {
+        for (const version of readdirSync(join(home, ".nvm", "versions", "node")))
+            for (const bin of ["toolroll", "standing-orders"])
+                commands.push(join(home, ".nvm", "versions", "node", version, "bin", bin));
+    }
+    catch { /* no nvm */ }
+    for (const command of commands) {
+        try {
+            lstatSync(command);
+            found.push(command);
+        }
+        catch { /* not there */ }
+    }
+    if (process.argv[1] !== undefined)
+        found.push(process.argv[1]);
+    return found;
+}
+/** The stage `path` lies in, or null. */
+function stageOf(stages, path) {
+    if (path === null || path === undefined || path === "")
+        return null;
+    for (const at of new Set([resolve(path), real(path)])) {
+        for (const stage of stages)
+            for (const base of new Set([stage.path, real(stage.path)])) {
+                if (at === base || at.startsWith(base + sep))
+                    return stage;
+            }
+    }
+    return null;
+}
+/** What stays and what goes now, and why. */
+export function stagePlan(stateDir, inUse, now) {
+    const stages = stagedRuntimes(stateDir);
+    const keep = new Map();
+    const current = inUse.map(path => stageOf(stages, path)).filter((one) => one !== null);
+    if (stages.length > 0 && current.length === 0)
+        return { keep: [], go: [], refused: "no staged runtime is in use, so which one runs now is unknown" };
+    for (const one of current)
+        keep.set(one.path, "current");
+    for (const one of current) {
+        const prior = stageOf(stages, one.prior) ?? stages.find(other => other.finished && other.path !== one.path && other.at < one.at) ?? null;
+        if (prior !== null && !keep.has(prior.path))
+            keep.set(prior.path, "previous");
+    }
+    if (stages[0] !== undefined && !keep.has(stages[0].path))
+        keep.set(stages[0].path, "newest");
+    for (const one of stages) {
+        if (keep.has(one.path))
+            continue;
+        if (one.keptAside)
+            keep.set(one.path, "kept-aside database");
+        else if (!one.finished && now.getTime() - one.at < UNFINISHED_KEEP_MS)
+            keep.set(one.path, "under way");
+    }
+    return { keep: [...keep].map(([path, why]) => ({ path, why })), go: stages.filter(one => !keep.has(one.path)), refused: null };
+}
+/**
+ * Remove the stages that go. Right before each goes, the plan is made again (what's in use now) and the stage must
+ * still be a real folder directly in staged-upgrades.
+ */
+export function pruneStagedRuntimes(stateDir, now, options = {}) {
+    const inUse = options.inUse ?? (() => runtimesInUse());
+    const first = stagePlan(stateDir, inUse(), now);
+    if (first.refused !== null)
+        return { removed: [], failed: [], refused: first.refused };
+    const root = real(join(stateDir, STAGED_FOLDER));
+    const removed = [];
+    const failed = [];
+    for (const one of first.go) {
+        const again = stagePlan(stateDir, inUse(), now);
+        if (again.refused !== null || !again.go.some(other => other.path === one.path))
+            continue;
+        try {
+            if (lstatSync(one.path).isSymbolicLink() || dirname(one.path) !== root)
+                continue;
+            (options.remove ?? (path => rmSync(path, { recursive: true, force: true, maxRetries: 3 })))(one.path);
+            removed.push(one.path);
+        }
+        catch {
+            failed.push(one.path);
+        }
+    }
+    return { removed, failed, refused: null };
+}

package/dist/storage-sweep.d.ts

@@ -0,0 +1,50 @@
+import { type Located } from "./orphan-sweep.js";
+import { type ProcessRow } from "./run-closeout.js";
+import type { Store } from "./store.js";
+import type { WorktreePool } from "./worktree.js";
+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 SweepPart = {
+    kind: SweepKind;
+    count: number;
+    bytes: number;
+    failed: number;
+    more?: boolean;
+    problem?: string;
+    items: string[];
+};
+export type SweepRecord = {
+    at: string;
+    source: "automatic" | "manual";
+    actor: string;
+    parts: SweepPart[];
+};
+export type SweepDeps = {
+    databaseFile: string;
+    pool: WorktreePool | null;
+    tempRoots: readonly string[];
+    actor?: string;
+    census?: () => ProcessRow[];
+    locate?: (pids: readonly number[]) => Map<number, Located>;
+    inUse?: () => string[];
+    graceMs?: number;
+};
+export declare function storageSweepOff(env?: NodeJS.ProcessEnv): boolean;
+export declare function storageSweepDue(store: Store, now: Date): boolean;
+/** The daily sweep, when it's due and on: one worker takes it. Null when it wasn't this pass's to run. */
+export declare function dailyStorageSweep(store: Store, deps: SweepDeps, now: () => Date): Promise<SweepRecord | null>;
+/** One sweep, now, every part; saved and in the ledger. Each part's failure is its own: the others still run. */
+export declare function sweepStorage(store: Store, deps: SweepDeps, now: () => Date): Promise<SweepRecord>;
+/** Save what a sweep or a clean-up by hand did (the latest few are kept), with one ledger entry saying it. */
+export declare function saveSweep(store: Store, record: SweepRecord): SweepRecord;
+/** The latest sweep (of `source`, or either), or null when there has been none. */
+export declare function lastSweep(store: Store, source?: SweepRecord["source"]): SweepRecord | null;
+/** 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." */
+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

@@ -0,0 +1,203 @@
+/**
+ * The daily storage sweep: the plane cleans up after itself without anyone running a command. Once a day (one worker
+ * takes the day: 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)
+ * and removes shared dependency installs no checkout has used for a week (shared-deps.ts).
+ *
+ * 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.
+ *
+ * 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. `TOOLROLL_STORAGE_SWEEP=off` turns the automatic sweep off
+ * (the unit tests do, so a test never sweeps the machine it runs on).
+ */
+import { dirname } from "node:path";
+import { cleanCheckouts } from "./checkout-cleanup.js";
+import { durationWords, sweepOrphans, ownerRunning } from "./orphan-sweep.js";
+import { processCensus } from "./run-closeout.js";
+import { pruneUnusedShared, sharedDepsRoot, sharedUse, SHARED_UNUSED_MS } from "./shared-deps.js";
+import { pruneStagedRuntimes, runtimesInUse, stagePlan } from "./staged-runtimes.js";
+import { bytesWords, diskBytes } from "./storage.js";
+import { removeStaleTestTemp } from "./test-temp.js";
+const CURSOR = "storage-sweep";
+export const SWEEP_EVERY_MS = 86_400_000;
+/** A sweep that failed somewhere, or left work for later, runs again this soon. */
+export const RETRY_MS = 60 * 60_000;
+/** Sweeps kept. */
+const KEEP = 30;
+/** Test temp folders one sweep removes at most (Oct 4 found 107,418). */
+const TEMP_MAX = 20_000;
+/** Paths saved per part, for the disclosure. */
+const ITEMS_MAX = 20;
+export function storageSweepOff(env = process.env) {
+    return (env["TOOLROLL_STORAGE_SWEEP"] ?? "").trim().toLowerCase() === "off";
+}
+export function storageSweepDue(store, now) {
+    return now.getTime() - store.serviceCursor(CURSOR) >= SWEEP_EVERY_MS;
+}
+/** The daily sweep, when it's due and on: one worker takes it. Null when it wasn't this pass's to run. */
+export async function dailyStorageSweep(store, deps, now) {
+    if (storageSweepOff())
+        return null;
+    const at = now();
+    const mine = store.transact(() => {
+        if (!storageSweepDue(store, at))
+            return false;
+        store.setServiceCursor(CURSOR, at.getTime(), at);
+        return true;
+    });
+    if (!mine)
+        return null;
+    const record = await sweepStorage(store, deps, now);
+    // Something failed or was left for later: the next sweep comes an hour from now, not tomorrow.
+    if (record.parts.some(one => one.failed > 0 || one.more === true || one.problem !== undefined)) {
+        store.setServiceCursor(CURSOR, Math.max(0, at.getTime() - SWEEP_EVERY_MS + RETRY_MS), now());
+    }
+    return record;
+}
+const capped = (items) => items.slice(0, ITEMS_MAX);
+const failure = (error) => error instanceof Error ? error.message : String(error);
+/** One sweep, now, every part; saved and in the ledger. Each part's failure is its own: the others still run. */
+export async function sweepStorage(store, deps, now) {
+    const actor = deps.actor ?? "worker";
+    const read = deps.census ?? (() => processCensus());
+    const parts = [];
+    const part = async (kind, work) => {
+        try {
+            parts.push({ kind, ...await work() });
+        }
+        catch (error) {
+            parts.push({ kind, count: 0, bytes: 0, failed: 0, problem: failure(error), items: [] });
+        }
+    };
+    await part("test temp", async () => {
+        // A root whose owner still runs stays, however old it looks; with no process list, every owned root stays.
+        let alive = () => true;
+        try {
+            alive = ownerRunning(read());
+        }
+        catch { /* owned roots stay */ }
+        const done = removeStaleTestTemp(deps.tempRoots, now(), { ownerAlive: alive, max: TEMP_MAX });
+        return { count: done.removed.length, bytes: 0, failed: done.failed.length, ...(done.more ? { more: true } : {}), items: capped(done.removed) };
+    });
+    await part("orphans", async () => {
+        const done = await sweepOrphans(store, now, {
+            actor, pool: deps.pool, tempRoots: deps.tempRoots, census: read,
+            ...(deps.locate === undefined ? {} : { locate: deps.locate }), ...(deps.graceMs === undefined ? {} : { graceMs: deps.graceMs }),
+        });
+        return {
+            count: done.stopped.length, bytes: 0, failed: 0, ...(done.failed.length === 0 ? {} : { problem: done.failed.join("; ") }),
+            items: capped(done.stopped.map(one => `${one.name} (${one.pid}), ${durationWords(one.ranMs)}, in ${one.where}`)),
+        };
+    });
+    if (deps.pool !== null) {
+        const pool = deps.pool;
+        await part("checkouts", async () => {
+            const done = await cleanCheckouts(store, pool, now, { manual: false, actor });
+            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)) };
+        });
+    }
+    const stateDir = dirname(deps.databaseFile);
+    await part("runtimes", async () => {
+        const inUse = deps.inUse ?? (() => runtimesInUse());
+        const plan = stagePlan(stateDir, inUse(), now());
+        const sizes = diskBytes(plan.go.map(one => one.path));
+        const done = pruneStagedRuntimes(stateDir, now(), { inUse });
+        return {
+            count: done.removed.length, bytes: done.removed.reduce((sum, path) => sum + (sizes.get(path) ?? 0), 0), failed: done.failed.length,
+            ...(done.refused === null ? {} : { problem: `kept every staged runtime: ${done.refused}` }), items: capped(done.removed),
+        };
+    });
+    await part("dependencies", async () => {
+        const root = sharedDepsRoot(deps.databaseFile);
+        const checkouts = () => store.listWorktrees().map(row => ({ path: row.path, repo: row.repo }));
+        const candidates = sharedUse(root, checkouts()).filter(one => one.checkouts.length === 0 && now().getTime() - Date.parse(one.usedAt) > SHARED_UNUSED_MS);
+        const sizes = diskBytes(candidates.map(one => one.dir));
+        const done = pruneUnusedShared(root, checkouts, now());
+        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)) };
+    });
+    return saveSweep(store, { 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. */
+export function saveSweep(store, record) {
+    store.transact(() => {
+        store.handle.prepare("INSERT INTO storage_sweep (at, source, actor, result) VALUES (?, ?, ?, ?)").run(record.at, record.source, record.actor, JSON.stringify(record.parts));
+        store.handle.prepare("DELETE FROM storage_sweep WHERE id NOT IN (SELECT id FROM storage_sweep ORDER BY id DESC LIMIT ?)").run(KEEP);
+    });
+    const did = record.parts.some(one => one.count > 0);
+    const failed = record.parts.some(one => one.failed > 0 || one.problem !== undefined);
+    store.recordAction({ at: record.at, actor: record.actor, repo: null, taskId: null, runId: null, action: "storage sweep",
+        outcome: failed ? "partial" : did ? "removed" : "nothing due", source: record.source === "automatic" ? "policy" : "request", detail: sweepWords(record.parts) });
+    return record;
+}
+function parseParts(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return Array.isArray(parsed) ? parsed.filter((one) => typeof one === "object" && one !== null && typeof one.kind === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** The latest sweep (of `source`, or either), or null when there has been none. */
+export function lastSweep(store, source) {
+    const row = store.handle.prepare(`SELECT at, source, actor, result FROM storage_sweep${source === undefined ? "" : " WHERE source = ?"} ORDER BY id DESC LIMIT 1`)
+        .get(...(source === undefined ? [] : [source]));
+    if (row === undefined)
+        return null;
+    return { at: String(row["at"]), source: row["source"] === "manual" ? "manual" : "automatic", actor: String(row["actor"]), parts: parseParts(String(row["result"])) };
+}
+/** When the next automatic sweep is due, or null when it is off. */
+export function nextSweepAt(store) {
+    if (storageSweepOff())
+        return null;
+    const last = store.serviceCursor(CURSOR);
+    return last === 0 ? null : new Date(last + SWEEP_EVERY_MS).toISOString();
+}
+const NOUNS = {
+    "test temp": ["test temp folder", "test temp folders"],
+    orphans: ["leftover process", "leftover processes"],
+    checkouts: ["finished checkout", "finished checkouts"],
+    runtimes: ["staged runtime", "staged runtimes"],
+    dependencies: ["unused dependency install", "unused dependency installs"],
+};
+/** 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" };
+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." */
+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);
+    const bytes = removed.reduce((sum, one) => sum + one.bytes, 0);
+    const failed = parts.reduce((sum, one) => sum + one.failed, 0);
+    const problems = parts.filter(one => one.problem !== undefined).map(one => one.kind);
+    const said = [
+        ...(removed.length === 0 ? [] : [`Removed ${list(removed.map(partWords))}${bytes > 0 ? `, about ${bytesWords(bytes)}` : ""}.`]),
+        ...(stopped === undefined ? [] : [`Stopped ${partWords(stopped)}.`]),
+        ...(failed === 0 ? [] : [`${failed} couldn't be removed.`]),
+        ...(problems.length === 0 ? [] : [`Couldn't check ${list(problems.map(kind => CHECKED[kind]))}.`]),
+    ];
+    return said.length === 0 ? "Nothing was due." : said.join(" ");
+}
+/** The details a disclosure shows: each part's paths, problems and what's left for later, one line each. */
+export function sweepDetails(parts) {
+    const lines = [];
+    for (const one of parts) {
+        if (one.problem !== undefined)
+            lines.push(`${NOUNS[one.kind][1][0].toUpperCase()}${NOUNS[one.kind][1].slice(1)}: ${one.problem}`);
+        if (one.more === true)
+            lines.push(`More ${NOUNS[one.kind][1]} are left for the next sweep.`);
+        for (const item of one.items)
+            lines.push(item);
+        if (one.items.length > 0 && one.count > one.items.length)
+            lines.push(`… and ${(one.count - one.items.length).toLocaleString("en-US")} more ${NOUNS[one.kind][1]}`);
+    }
+    return lines;
+}

package/dist/storage-ui.d.ts

@@ -1,8 +1,13 @@
 import { type CheckoutPlan } from "./checkout-cleanup.js";
+import { type SweepRecord } from "./storage-sweep.js";
 export declare const STORAGE_CSS: string;
 export type StorageView = {
     plan: CheckoutPlan;
     csrf: string;
+    sweep?: {
+        last: SweepRecord | null;
+        off: boolean;
+    };
 };
 export declare function storageHtml(view: StorageView, notice: {
     said?: string | null;

package/dist/storage-ui.js

@@ -1,12 +1,14 @@
 /**
  * Settings → Storage: how much space task checkouts use, what a clean-up would free now, a Clean up button whose
- * preview (what goes, what stays and why, with paths) sits behind the password, and when a finished task's clean
- * checkout goes by itself. An instance operator's page.
+ * preview (what goes, what stays and why, with paths) sits behind the password, what the last storage sweep removed
+ * and when (its paths in a disclosure), and when a finished task's clean checkout goes by itself. An instance
+ * operator's page.
  */
 import { homedir } from "node:os";
 import { basename } from "node:path";
 import { previewDigest, whyWords } from "./checkout-cleanup.js";
 import { CLEANUP_CHOICES, bytesWords } from "./storage.js";
+import { sweepDetails, sweepWords } from "./storage-sweep.js";
 const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 const plural = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
 export const STORAGE_CSS = `.storage{max-width:720px;min-width:0;overflow-wrap:anywhere}.storage h2{font-size:1.0625rem;margin:24px 0 4px}` +
@@ -25,7 +27,31 @@ export const STORAGE_CSS = `.storage{max-width:720px;min-width:0;overflow-wrap:a
     `.storage form{display:grid;gap:10px;margin:0}.storage label{display:grid;gap:4px;font-size:.8125rem;font-weight:500;max-width:20rem}` +
     `.storage select,.storage input[type=password]{width:100%;box-sizing:border-box;min-height:2.125rem}.storage form button{justify-self:start;white-space:nowrap}` +
     `.storage form.setting button[type=submit],.storage .preview form.remove button[type=submit]{background:var(--primary);color:var(--primary-foreground);border-color:var(--primary);font-weight:600}` +
-    `@media (max-width:900px){.storage details.clean-up>summary,.storage form button{min-height:44px}.storage label{max-width:none}.storage select,.storage input[type=password]{min-height:44px;font-size:16px}.storage .preview form.remove button{width:100%}}`;
+    `.storage .sweep{display:grid;gap:4px}.storage .sweep p{margin:0}.storage .sweep .problem{color:var(--destructive)}` +
+    `.storage details.sweep-details>summary{cursor:pointer;min-height:2.25rem;display:inline-flex;align-items:center;font-size:.8125rem;color:var(--muted-foreground)}` +
+    `.storage details.sweep-details ul{margin:4px 0 0;padding-left:18px;font-family:var(--font-mono, ui-monospace, monospace);font-size:.6875rem;color:var(--muted-foreground);overflow-wrap:anywhere}` +
+    `@media (max-width:900px){.storage details.sweep-details>summary{min-height:44px}.storage details.clean-up>summary,.storage form button{min-height:44px}.storage label{max-width:none}.storage select,.storage input[type=password]{min-height:44px;font-size:16px}.storage .preview form.remove button{width:100%}}`;
+/** Paths under the home folder as ~/…, as the checkout list shows them. */
+function homeAsTilde(line) {
+    const home = homedir();
+    return home === "" || home === "/" ? line : line.split(`${home}/`).join("~/");
+}
+/** "Oct 4, 3:12 AM" in this computer's time. */
+function whenWords(at) {
+    const date = new Date(at);
+    return Number.isNaN(date.getTime()) ? at : date.toLocaleString("en-US", { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+}
+/** One line: when the last sweep ran and what it did; its paths and problems behind Details. */
+function sweepHtml(sweep) {
+    const last = sweep.last;
+    if (last === null)
+        return `<p class="meta" data-last-sweep="">${sweep.off ? "Automatic sweep is off." : "Toolroll sweeps leftovers once a day. It hasn't run yet."}</p>`;
+    const who = last.source === "manual" ? `Cleaned up by ${e(last.actor)}` : "Swept";
+    const details = sweepDetails(last.parts);
+    const problem = last.parts.some(one => one.failed > 0 || one.problem !== undefined);
+    return `<div class="sweep" data-last-sweep="${e(last.at)}"><p${problem ? ' class="problem"' : ""}>${who} <time datetime="${e(last.at)}">${e(whenWords(last.at))}</time>. ${e(sweepWords(last.parts))}</p>` +
+        (details.length === 0 ? "" : `<details class="sweep-details"><summary>Details</summary><ul>${details.map(line => `<li>${e(homeAsTilde(line))}</li>`).join("")}</ul></details>`) + `</div>`;
+}
 function item(one, csrf) {
     const discard = one.why === "has changes"
         ? `<details class="discard"><summary>Discard</summary><form method="post" action="/settings/storage/discard"><input type="hidden" name="csrf" value="${e(csrf)}"><input type="hidden" name="path" value="${e(one.path)}">` +
@@ -58,7 +84,7 @@ export function storageHtml(view, notice) {
     const options = CLEANUP_CHOICES.map(one => `<option value="${one.value}"${one.value === plan.cleanup ? " selected" : ""}>${e(one.label)}</option>`).join("");
     return `<section class="storage">${note}` +
         `<div class="card storage-state"><h2 data-checkout-bytes="${plan.totalBytes}">Checkouts use ${e(bytesWords(plan.totalBytes))}</h2><p class="meta">${e(facts)}</p>` +
-        `<p data-clean-bytes="${plan.freeBytes}">${e(frees)}</p>${preview}</div>` +
+        `<p data-clean-bytes="${plan.freeBytes}">${e(frees)}</p>${view.sweep === undefined ? "" : sweepHtml(view.sweep)}${preview}</div>` +
         `<h2>Automatic cleanup</h2>` +
         `<form method="post" action="/settings/storage" class="setting">${hidden}` +
         `<label>Remove a finished task's clean checkout<select name="cleanup">${options}</select></label>` +

package/dist/storage.d.ts

@@ -1,6 +1,8 @@
 import type { Store } from "./store.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";
+/** 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 = "finished" | "2d" | "7d" | "never";
 export declare const DEFAULT_CLEANUP: CheckoutCleanup;
 export declare const CLEANUP_CHOICES: readonly {

package/dist/storage.js

@@ -3,7 +3,9 @@
  * beside the database, by kind, and what storage retention takes care of.
  * 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 a deploy keeps its last few releases.
+ * (checkout-cleanup.ts), and the daily storage sweep (storage-sweep.ts) takes
+ * what slips through: stale test temp folders, leftover processes, extra
+ * staged runtimes and dependency installs unused for a week.
  */
 import { spawnSync } from "node:child_process";
 import { lstatSync, readdirSync } from "node:fs";
@@ -18,6 +20,16 @@ CREATE TABLE IF NOT EXISTS checkout_cleanup_setting (
   updated_at TEXT NOT NULL
 );
 `;
+/** What each storage sweep or clean-up by hand did (storage-sweep.ts): the latest few. */
+export const STORAGE_SWEEP_SCHEMA = `
+CREATE TABLE IF NOT EXISTS storage_sweep (
+  id     INTEGER PRIMARY KEY,
+  at     TEXT NOT NULL,
+  source TEXT NOT NULL CHECK (source IN ('automatic', 'manual')),
+  actor  TEXT NOT NULL,
+  result TEXT NOT NULL
+);
+`;
 export const DEFAULT_CLEANUP = "finished";
 export const CLEANUP_CHOICES = [
     { value: "finished", label: "When its task is complete or cancelled", days: 0 },
@@ -124,8 +136,8 @@ export function storageReport(store, databaseFile, checkoutNote) {
     const lines = [
         { what: "Database", bytes: take(name => name.startsWith(base)) },
         { what: "Build checkouts", bytes: take(name => name === "worktrees"), count: checkouts.length, ...(checkoutNote === undefined ? {} : { note: checkoutNote }) },
-        { what: "Shared dependencies", bytes: take(name => name === DEPS_FOLDER), count: sharedCopies(join(folder, DEPS_FOLDER)).length, note: "one install per lockfile, linked into checkouts" },
-        { what: "Staged releases", bytes: take(name => name === "staged-upgrades"), count: staged, note: "a deploy keeps the release it installed, the one before and the newest few" },
+        { what: "Shared dependencies", bytes: take(name => name === DEPS_FOLDER), count: sharedCopies(join(folder, DEPS_FOLDER)).length, note: "one install per lockfile, linked into checkouts; one unused for a week goes" },
+        { what: "Staged releases", bytes: take(name => name === "staged-upgrades"), count: staged, note: "kept: the one running, the one before it and the newest" },
         { what: "Evidence", bytes: take(name => name === "evidence"), note: "the audit record of every run; kept" },
         { what: "Backups", bytes: take(name => name === "backups") },
     ];