@saadnvd1/agent-os 0.3.662 → 0.3.664

package/lib/worktree-sweep/extras.ts

@@ -0,0 +1,188 @@
+/**
+ * The second half of a run: what tasks leave beside their worktrees. Found
+ * by databases.ts and caches.ts, removed here only when the full clean-up is
+ * on; otherwise listed as pending, with sizes, for a dry run's report.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { SPARE_ROOT } from "../worktree-deps/spare";
+import duBytes from "./du";
+import { pgRun } from "../project-config/database";
+import {
+  declaredDatabases,
+  dropTaskDatabase,
+  findTaskDatabases,
+  hashesOf,
+  knownSessionIds,
+  liveHashes,
+  liveSessionIds,
+} from "./databases";
+import { findCacheLeftovers, workspaceFromPlist } from "./caches";
+import type { SweepDeps } from "./runSweep";
+import type {
+  Candidate,
+  SweepRemoved,
+  SweepSkipped,
+  SweepSummary,
+  SweepTotals,
+} from "./types";
+import { WORKTREES_DIR } from "../worktrees";
+
+export interface Extras {
+  candidates: Candidate[];
+  skipped: SweepSkipped[];
+  drop: (c: Candidate) => Promise<boolean>;
+  spares: { count: number; bytes: number };
+}
+
+const dirCount = (root: string) => {
+  try {
+    return fs
+      .readdirSync(root, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
+  } catch {
+    return 0;
+  }
+};
+
+// The size of a whole root (every worktree, every spare) takes minutes of
+// disk reading, so it is measured at most every six hours, or again on a
+// dry run, which is what asks for fresh numbers.
+const ROOT_SIZE_TTL_MS = 6 * 3600_000;
+const rootSizes = new Map<string, { at: number; bytes: number }>();
+
+export async function cachedRootSize(
+  dir: string,
+  size: (dir: string) => Promise<number>,
+  fresh: boolean,
+  now = Date.now()
+): Promise<number> {
+  const hit = rootSizes.get(dir);
+  if (hit && !fresh && now - hit.at < ROOT_SIZE_TTL_MS) return hit.bytes;
+  const bytes = await size(dir);
+  // 0 is what a failed or timed-out du reports: try again next time.
+  if (bytes > 0) rootSizes.set(dir, { at: now, bytes });
+  return bytes;
+}
+
+export const forgetRootSizes = () => rootSizes.clear();
+
+export async function defaultExtras(
+  opts: { fresh?: boolean } = {}
+): Promise<Extras> {
+  const { servers, froms } = declaredDatabases();
+  const ids = liveSessionIds();
+  const size = (dir: string) => duBytes(dir);
+  const dbs = await findTaskDatabases({
+    now: Date.now(),
+    run: pgRun,
+    servers,
+    live: liveHashes(ids),
+    known: hashesOf(knownSessionIds()),
+    froms,
+  });
+  const derivedRoot = path.join(
+    os.homedir(),
+    "Library",
+    "Developer",
+    "Xcode",
+    "DerivedData"
+  );
+  const caches = await findCacheLeftovers({
+    now: Date.now(),
+    spareRoot: SPARE_ROOT,
+    tmpRoot: os.tmpdir(),
+    derivedRoot: process.platform === "darwin" ? derivedRoot : "",
+    worktreesRoot: WORKTREES_DIR,
+    liveIds: ids,
+    workspaceOf: workspaceFromPlist,
+    size,
+  });
+  const roots = [SPARE_ROOT, os.tmpdir(), derivedRoot];
+  return {
+    candidates: [...dbs.candidates, ...caches.candidates],
+    skipped: [...dbs.skipped, ...caches.skipped],
+    spares: {
+      count: dirCount(SPARE_ROOT),
+      bytes: await cachedRootSize(SPARE_ROOT, size, !!opts.fresh),
+    },
+    drop: async (c) => {
+      if (c.kind === "database") return dropTaskDatabase(c, froms);
+      const target = path.resolve(c.path);
+      if (!roots.some((r) => r && path.dirname(target) === path.resolve(r)))
+        return false;
+      await fs.promises.rm(target, { recursive: true, force: true });
+      return !fs.existsSync(target);
+    },
+  };
+}
+
+// Removes (or, off or dry, only lists) what the extras found.
+export async function findExtras(
+  deps: SweepDeps,
+  summary: SweepSummary,
+  opts: { armed: boolean; dryRun: boolean }
+): Promise<{ totals: SweepTotals }> {
+  const x = await deps.extras({ fresh: opts.dryRun });
+  summary.skipped.push(...x.skipped);
+  for (const c of x.candidates) {
+    const item: SweepRemoved = {
+      path: c.path,
+      kind: c.kind,
+      why: c.why ?? "",
+      bytes: c.bytes ?? (await deps.size(c.path)),
+    };
+    if (!opts.armed) {
+      summary.pending!.push(item);
+      continue;
+    }
+    if (deps.busy()) {
+      summary.skipped.push({
+        path: c.path,
+        kind: c.kind,
+        reason: "the machine is busy; left for the next run",
+      });
+      continue;
+    }
+    if (!opts.dryRun && !(await x.drop(c).catch(() => false))) {
+      summary.skipped.push({
+        path: c.path,
+        kind: c.kind,
+        reason: "removing it failed",
+      });
+      continue;
+    }
+    summary.removed.push(item);
+    summary.freedBytes += item.bytes;
+  }
+  const found = (kind: Candidate["kind"]) => {
+    const items = [...summary.removed, ...(summary.pending ?? [])].filter(
+      (i) => i.kind === kind
+    );
+    return {
+      count: items.length,
+      bytes: items.reduce((n, i) => n + i.bytes, 0),
+    };
+  };
+  return {
+    totals: {
+      worktrees: {
+        count: dirCount(deps.root),
+        bytes: await cachedRootSize(deps.root, deps.size, opts.dryRun),
+      },
+      databases: found("database"),
+      spares: x.spares,
+      temp: found("temp"),
+    },
+  };
+}
+
+// For tests, and for a machine without the extras: nothing found.
+export const noExtras = async (): Promise<Extras> => ({
+  candidates: [],
+  skipped: [],
+  drop: async () => false,
+  spares: { count: 0, bytes: 0 },
+});

package/lib/worktree-sweep/findOrphans.ts

@@ -61,8 +61,16 @@ function gitdirOf(dir: string): string | null {
   }
 }
 
+// The server's own temp folder differs from a test run's (launchd, systemd),
+// so the usual system ones count too.
+const TEMP_ROOTS = [
+  /^\/(?:private\/)?tmp(?:\/|$)/,
+  /^\/(?:private\/)?var\/folders\/[^/]+\/[^/]+\/T(?:\/|$)/,
+  /^\/var\/tmp(?:\/|$)/,
+];
 const inTemp = (p: string) =>
-  [os.tmpdir(), real(os.tmpdir())].some((t) => inFolder(p, t));
+  [os.tmpdir(), real(os.tmpdir())].some((t) => inFolder(p, t)) ||
+  TEMP_ROOTS.some((r) => r.test(p));
 
 // Nothing in it but what AgentOS placed or rebuilds: no work to lose.
 export const holdsNothing = (dir: string) =>
@@ -103,7 +111,16 @@ export async function findOrphans(deps: OrphanDeps): Promise<{
     if (mine.has(real(dir))) continue;
     const skip = (reason: string) =>
       skipped.push({ path: dir, kind: "orphan", reason });
-    if (deps.now - newestMs(dir) < days * DAY_MS) {
+    const gitdir = gitdirOf(dir);
+    const registered = !!gitdir && fs.existsSync(gitdir);
+    const leak =
+      TEST_LEAK.test(entry.name) &&
+      !!gitdir &&
+      inTemp(real(path.dirname(gitdir)));
+    // A test's folder whose repository is gone is nobody's, however young:
+    // new ones arrive with every run of an old checkout's tests.
+    const abandoned = leak && !registered;
+    if (!abandoned && deps.now - newestMs(dir) < days * DAY_MS) {
       skip(`touched less than ${days} day${days === 1 ? "" : "s"} ago`);
       continue;
     }
@@ -111,12 +128,6 @@ export async function findOrphans(deps: OrphanDeps): Promise<{
       skip("a terminal is open in it");
       continue;
     }
-    const gitdir = gitdirOf(dir);
-    const registered = !!gitdir && fs.existsSync(gitdir);
-    const leak =
-      TEST_LEAK.test(entry.name) &&
-      !!gitdir &&
-      inTemp(real(path.dirname(gitdir)));
     if (leak) {
       candidates.push({
         path: dir,

package/lib/worktree-sweep/report.ts

@@ -0,0 +1,85 @@
+/**
+ * The list a dry run writes before anything is removed: what would go, what
+ * stays and why, with sizes, for a person to read before turning the full
+ * clean-up on. One file per day under ~/.agent-os/audits/disk-cleanup.
+ */
+
+import fs from "fs";
+import path from "path";
+import { agentosHome } from "../agentos-home";
+import type { SweepKind, SweepRemoved, SweepSummary } from "./types";
+
+export const mb = (b: number) =>
+  b >= 1024 ** 3
+    ? `${(b / 1024 ** 3).toFixed(2)} GB`
+    : `${(b / 1024 ** 2).toFixed(1)} MB`;
+
+const TITLES: Record<SweepKind, string> = {
+  settled: "Worktrees of finished tasks",
+  orphan: "Worktree folders no session owns",
+  "test-leak": "Throwaway repositories left by tests",
+  database: "Task databases",
+  spare: "Dependency spares",
+  temp: "Temp folders",
+  "derived-data": "Xcode build folders of removed worktrees",
+};
+
+function section(kind: SweepKind, items: SweepRemoved[]): string {
+  const bytes = items.reduce((n, i) => n + i.bytes, 0);
+  const rows = items
+    .sort((a, b) => b.bytes - a.bytes)
+    .map((i) => `- \`${i.path}\` · ${mb(i.bytes)} · ${i.why}`);
+  return `## ${TITLES[kind]}: ${items.length} (${mb(bytes)})\n\n${rows.join("\n")}\n`;
+}
+
+export function renderDiskReport(summary: SweepSummary, at: Date): string {
+  const all = [...summary.removed, ...(summary.pending ?? [])];
+  const kinds = Object.keys(TITLES) as SweepKind[];
+  const total = all.reduce((n, i) => n + i.bytes, 0);
+  const why = new Map<string, number>();
+  for (const k of summary.skipped) {
+    const r = k.reason.replace(/\(.*\)/, "").trim();
+    why.set(r, (why.get(r) ?? 0) + 1);
+  }
+  return [
+    `# Disk clean-up dry run, ${at.toISOString()}`,
+    "",
+    `Would remove ${all.length} items, ${mb(total)}. Nothing was removed.`,
+    `Full clean-up is ${summary.armed ? "on" : "off"} on this machine.`,
+    "",
+    ...kinds
+      .map((k) => all.filter((i) => i.kind === k))
+      .filter((items) => items.length)
+      .map((items) => section(items[0].kind, items)),
+    `## Kept: ${summary.skipped.length}`,
+    "",
+    ...[...why].map(([r, n]) => `- ${n} × ${r}`),
+    "",
+    "### Kept, in detail",
+    "",
+    ...summary.skipped
+      .filter((s) => !/less than \d+ day/.test(s.reason))
+      .slice(0, 300)
+      .map((s) => `- \`${s.path}\` · ${s.reason}`),
+    "",
+  ].join("\n");
+}
+
+// A second dry run the same day gets -2, -3, never overwrites the first.
+export function writeDiskReport(
+  summary: SweepSummary,
+  at = new Date(),
+  dir = agentosHome("audits", "disk-cleanup")
+): string {
+  fs.mkdirSync(dir, { recursive: true });
+  const day = [
+    at.getFullYear(),
+    String(at.getMonth() + 1).padStart(2, "0"),
+    String(at.getDate()).padStart(2, "0"),
+  ].join("-");
+  let file = path.join(dir, `${day}.md`);
+  for (let n = 2; fs.existsSync(file); n++)
+    file = path.join(dir, `${day}-${n}.md`);
+  fs.writeFileSync(file, renderDiskReport(summary, at), { mode: 0o600 });
+  return file;
+}

package/lib/worktree-sweep/runSweep.ts

@@ -6,7 +6,6 @@
 
 import fs from "fs";
 import path from "path";
-import { execFile } from "child_process";
 import { db, type Session } from "../db";
 import { git as runGit } from "../git-exec";
 import { run as runCmd } from "../tasks/gh";
@@ -19,10 +18,14 @@ import {
   type SettledDeps,
 } from "./findSettled";
 import { findOrphans, holdsNothing } from "./findOrphans";
+import duBytes from "./du";
+import { findExtras, defaultExtras, type Extras } from "./extras";
+import { reaperArmed } from "./settings";
+import { writeDiskReport } from "./report";
 import { judgeWorktree } from "./judge";
 import { openPaneFolders } from "./panes";
 import { finishRun, recordSwept, startRun } from "./store";
-import type { Candidate, SweepSummary } from "./types";
+import { ARMED_KINDS, type Candidate, type SweepSummary } from "./types";
 
 export interface SweepDeps {
   now: number;
@@ -33,19 +36,15 @@ export interface SweepDeps {
   prHead: (repo: string, number: number) => Promise<string | null>;
   // Stop early when the machine is busy.
   busy: () => boolean;
+  // Task databases, spares, temp folders and build caches.
+  extras: (opts?: { fresh?: boolean }) => Promise<Extras>;
+  // Written by a dry run: where its list goes.
+  report: (summary: SweepSummary) => string | null;
 }
 
 const git = (cwd: string, ...args: string[]) =>
   runGit(cwd, args, { timeout: 30_000 }).then((o) => o.trim());
 
-function duBytes(dir: string): Promise<number> {
-  return new Promise((resolve) =>
-    execFile("du", ["-sk", dir], { timeout: 120_000 }, (error, stdout) =>
-      resolve(error ? 0 : (parseInt(String(stdout), 10) || 0) * 1024)
-    )
-  );
-}
-
 async function prHeadOf(repo: string, number: number): Promise<string | null> {
   try {
     const out = await runCmd(
@@ -73,9 +72,18 @@ export const defaultSweepDeps = (): SweepDeps => ({
   root: WORKTREES_DIR,
   panes: openPaneFolders,
   settled: defaultSettledDeps(),
-  size: duBytes,
+  size: (dir) => duBytes(dir, 120_000),
   prHead: prHeadOf,
   busy: () => currentLevel() === "red",
+  extras: defaultExtras,
+  report: (summary) => {
+    try {
+      return writeDiskReport(summary);
+    } catch (error) {
+      console.error("[worktree-sweep] report not written:", error);
+      return null;
+    }
+  },
 });
 
 // A path under the root, never the root itself or something outside it.
@@ -123,7 +131,14 @@ export async function sweep(
 ): Promise<{ runId: number; summary: SweepSummary }> {
   const dryRun = !!opts.dryRun;
   const runId = startRun(dryRun);
-  const summary: SweepSummary = { removed: [], skipped: [], freedBytes: 0 };
+  const armed = reaperArmed();
+  const summary: SweepSummary = {
+    removed: [],
+    skipped: [],
+    freedBytes: 0,
+    pending: [],
+    armed,
+  };
   let error: string | null = null;
   try {
     const panes = await deps.panes();
@@ -155,6 +170,18 @@ export async function sweep(
           reason,
           sessionId: c.sessionId,
         });
+      if (ARMED_KINDS.has(c.kind) && !armed) {
+        summary.pending!.push({
+          path: c.path,
+          kind: c.kind,
+          why:
+            c.kind === "test-leak"
+              ? "a test's throwaway repository"
+              : "an orphan worktree",
+          bytes: await deps.size(c.path),
+        });
+        continue;
+      }
       const repo = await repoOfSession(c);
       const why =
         c.kind === "test-leak"
@@ -203,9 +230,12 @@ export async function sweep(
       summary.freedBytes += bytes;
     }
     if (!dryRun) await pruneProjects([...pruned]);
+    const extras = await findExtras(deps, summary, { armed, dryRun });
+    summary.totals = extras.totals;
   } catch (e) {
     error = e instanceof Error ? e.message : String(e);
   }
+  if (dryRun) summary.report = deps.report(summary) ?? undefined;
   finishRun(runId, summary, error);
   console.log(describeRun(summary, dryRun, error));
   return { runId, summary };
@@ -239,5 +269,8 @@ export function describeRun(
   }
   const why = [...reasons].map(([r, n]) => `${n} ${r}`).join("; ");
   const leaks = s.removed.filter((r) => r.kind === "test-leak").length;
-  return `[worktree-sweep] ${dryRun ? "would remove" : "removed"} ${s.removed.length} (${gb(s.freedBytes)}${leaks ? `, ${leaks} test leftovers` : ""}), skipped ${s.skipped.length}${why ? `: ${why}` : ""}${error ? `; failed: ${error}` : ""}`;
+  const pending = s.pending?.length
+    ? `, ${s.pending.length} more (${gb(s.pending.reduce((n, p) => n + p.bytes, 0))}) wait for the full clean-up to be turned on`
+    : "";
+  return `[worktree-sweep] ${dryRun ? "would remove" : "removed"} ${s.removed.length} (${gb(s.freedBytes)}${leaks ? `, ${leaks} test leftovers` : ""})${pending}, skipped ${s.skipped.length}${why ? `: ${why}` : ""}${error ? `; failed: ${error}` : ""}`;
 }

package/lib/worktree-sweep/settings.ts

@@ -81,3 +81,27 @@ export function projectSweepOverrides(): Array<{
     return days === null ? [] : [{ projectId, days }];
   });
 }
+
+// The full clean-up (test leftovers, task databases, spares, temp folders,
+// build caches) removes nothing until a person turns it on for this machine,
+// after reading what a dry run found.
+const ARMED_KEY = "worktree_sweep.reaper";
+
+export function reaperArmed(): boolean {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(ARMED_KEY) as { value: string } | undefined;
+  if (!row) return false;
+  try {
+    return JSON.parse(row.value)?.armed === true;
+  } catch {
+    return false;
+  }
+}
+
+export function setReaperArmed(armed: boolean): void {
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(ARMED_KEY, JSON.stringify({ armed, at: new Date().toISOString() }));
+}

package/lib/worktree-sweep/state.ts

@@ -3,6 +3,7 @@ import {
   DEFAULT_SWEEP_DAYS,
   globalSweepDays,
   projectSweepOverrides,
+  reaperArmed,
 } from "./settings";
 import { recentRuns } from "./store";
 import type { SweepRun } from "./types";
@@ -13,6 +14,9 @@ export interface SweepState {
   defaultDays: number;
   overrides: Array<{ projectId: string; name: string; days: number }>;
   runs: SweepRun[];
+  // Whether the full clean-up (test leftovers, task databases, spares, temp
+  // folders, build caches) removes anything on this machine.
+  armed: boolean;
 }
 
 export function sweepState(): SweepState {
@@ -32,5 +36,6 @@ export function sweepState(): SweepState {
         : []
     ),
     runs: recentRuns(),
+    armed: reaperArmed(),
   };
 }

package/lib/worktree-sweep/store.ts

@@ -51,6 +51,17 @@ export function finishRun(
     summary.skipped.length,
     JSON.stringify({
       ...summary,
+      // The biggest first: they are what a person looks for.
+      removed: [...summary.removed]
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, DETAIL_CAP),
+      pending: [...(summary.pending ?? [])]
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, DETAIL_CAP),
+      pendingTotal: {
+        count: summary.pending?.length ?? 0,
+        bytes: (summary.pending ?? []).reduce((n, p) => n + p.bytes, 0),
+      },
       skipped: summary.skipped.slice(0, DETAIL_CAP),
     }),
     error,

package/lib/worktree-sweep/types.ts

@@ -1,4 +1,21 @@
-export type SweepKind = "settled" | "orphan" | "test-leak";
+export type SweepKind =
+  | "settled"
+  | "orphan"
+  | "test-leak"
+  // What a task left beside its checkout, found by the full clean-up.
+  | "database"
+  | "spare"
+  | "temp"
+  | "derived-data";
+
+// Kinds that go only once the full clean-up is turned on.
+export const ARMED_KINDS: ReadonlySet<SweepKind> = new Set([
+  "test-leak",
+  "database",
+  "spare",
+  "temp",
+  "derived-data",
+]);
 
 export interface SweepRemoved {
   path: string;
@@ -15,10 +32,31 @@ export interface SweepSkipped {
   sessionId?: string;
 }
 
+export interface CategoryTotal {
+  count: number;
+  bytes: number;
+}
+
+// What is on disk after the run, for the one-line summary.
+export interface SweepTotals {
+  worktrees: CategoryTotal;
+  databases: CategoryTotal;
+  spares: CategoryTotal;
+  temp: CategoryTotal;
+}
+
 export interface SweepSummary {
   removed: SweepRemoved[];
   skipped: SweepSkipped[];
   freedBytes: number;
+  // Found but left, because the full clean-up isn't turned on.
+  pending?: SweepRemoved[];
+  // The whole of pending, once a stored run keeps only its biggest.
+  pendingTotal?: CategoryTotal;
+  totals?: SweepTotals;
+  armed?: boolean;
+  // Where a dry run wrote its list.
+  report?: string;
 }
 
 export interface SweepRun {
@@ -50,4 +88,9 @@ export interface Candidate {
   // The PR head a merge took, when the session has one.
   prNumber?: number | null;
   branch?: string | null;
+  // A database: the server it lives on, and why it's reapable.
+  server?: { host?: string; port?: number };
+  why?: string;
+  // Known without measuring (a database's size).
+  bytes?: number;
 }

package/lib/worktrees.ts

@@ -2,6 +2,7 @@
  * Git Worktree management for isolated feature development
  */
 
+import { stopDevServer } from "./dev-instance/stopDevServer";
 import * as path from "path";
 import * as fs from "fs";
 import * as os from "os";
@@ -301,6 +302,8 @@ export function deleteWorktree(
   let marker: string | null = null;
   const done = (async () => {
     await branch;
+    // A dev server left running would outlive the folder it runs in.
+    await stopDevServer(key).catch(() => {});
     // Before anything is removed, so no reader catches it half-deleted.
     marker = markRemoving(key);
     await removeWorktree(key, repo);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.662",
+  "version": "0.3.664",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -33,6 +33,7 @@
     "dev": "AGENTOS_DEV=1 tsx server.ts",
     "dev:task": "tsx scripts/dev-task.ts",
     "dev:stop": "tsx scripts/dev-stop.ts",
+    "disk:dry-run": "tsx scripts/disk-dry-run.ts",
     "prebuild": "node scripts/gen-migrations-index.mjs",
     "build": "next build",
     "prestart": "node scripts/ensure-native.mjs && node scripts/gen-migrations-index.mjs",

package/scripts/disk-dry-run.ts

@@ -0,0 +1,57 @@
+/**
+ * What the disk clean-up would remove, without removing anything: runs a dry
+ * sweep against a copy of the live database and writes the list to
+ * ~/.agent-os/audits/disk-cleanup/<date>.md.
+ *
+ *   npm run disk:dry-run -- --db <path to the live agent-os.db>
+ *
+ * The live database is opened read-only for the copy and never written; the
+ * copy is deleted afterwards. Nothing on disk or in Postgres is touched.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import Database from "better-sqlite3";
+
+const arg = process.argv.indexOf("--db");
+const live: string = (arg > 0 && process.argv[arg + 1]) || "";
+if (!live || !fs.existsSync(live)) {
+  console.error("usage: npm run disk:dry-run -- --db <path to agent-os.db>");
+  process.exit(1);
+}
+
+async function main() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-disk-dry-"));
+  const copy = path.join(dir, "agent-os.db");
+  try {
+    const src = new Database(live, { readonly: true });
+    await src.backup(copy);
+    src.close();
+    process.env.DB_PATH = copy;
+
+    const { sweep, defaultSweepDeps } =
+      await import("../lib/worktree-sweep/runSweep");
+    const { summary } = await sweep(
+      { dryRun: true },
+      { ...defaultSweepDeps(), busy: () => false }
+    );
+    const all = [...summary.removed, ...(summary.pending ?? [])];
+    const gb = (b: number) => `${(b / 1024 ** 3).toFixed(2)} GB`;
+    for (const kind of new Set(all.map((i) => i.kind))) {
+      const items = all.filter((i) => i.kind === kind);
+      console.log(
+        `${kind}: ${items.length} (${gb(items.reduce((n, i) => n + i.bytes, 0))})`
+      );
+    }
+    console.log(`kept: ${summary.skipped.length}`);
+    console.log(`list: ${summary.report ?? "(not written)"}`);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});