@mu-crew/mu 3.4.0 → 3.5.0

package/dist/cli.js

@@ -175,6 +175,11 @@ function fullOldPayload(cols) {
   const pairs = cols.map((c) => `'${c}', OLD.${c}`).join(", ");
   return `json_object(${pairs})`;
 }
+function noteTombstonePayload(keyExpr, cols) {
+  return `CASE WHEN EXISTS (
+      SELECT 1 FROM ops WHERE entity = 'note' AND key = ${keyExpr} AND op = 'put'
+    ) THEN '{}' ELSE ${fullOldPayload(cols)} END`;
+}
 function anyChanged(cols) {
   return cols.map((c) => `NEW.${c} IS NOT OLD.${c}`).join("\n        OR ");
 }
@@ -258,7 +263,7 @@ END;
 CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_notes_del
 BEFORE DELETE ON task_notes WHEN ${NOT_APPLYING}
 BEGIN
-  ${emitOp("note", "del", `${taskKey("OLD.task_id")} || '#' || OLD.id`, fullOldPayload(noteCols))}
+  ${emitOp("note", "del", `${taskKey("OLD.task_id")} || '#' || OLD.id`, noteTombstonePayload(`${taskKey("OLD.task_id")} || '#' || OLD.id`, noteCols))}
 END;
 
 -- \u2500\u2500\u2500 task_edges \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -7620,7 +7625,10 @@ var init_adopt = __esm({
 // src/agents/delegate.ts
 function delegateOutcome(agent, timedOut) {
   if (agent.dead) return "died";
-  if (agent.fired) return agent.lastText ? "done" : "empty";
+  if (agent.fired) {
+    if (agent.lastError !== void 0) return "error";
+    return agent.lastText ? "done" : "empty";
+  }
   return timedOut ? "timeout" : "pending";
 }
 var init_delegate = __esm({
@@ -7833,6 +7841,7 @@ async function waitForAgents(db, input, opts) {
             st.wasBusy = true;
             st.fired = true;
             if (snap.lastText !== void 0) st.lastText = snap.lastText;
+            if (snap.lastError !== void 0) st.lastError = snap.lastError;
           }
           wake();
         },
@@ -10400,13 +10409,13 @@ import {
   appendFileSync,
   existsSync as existsSync14,
   mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync3,
-  statSync as statSync2,
+  statSync as statSync3,
   writeFileSync as writeFileSync2
 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join12, resolve as resolve6, sep as sep2 } from "path";
+import { join as join13, resolve as resolve6, sep as sep2 } from "path";
 import { crc32 } from "zlib";
 function syncDir() {
   const dir = process.env.MU_SYNC_DIR;
@@ -10430,7 +10439,7 @@ function localMachineId(db) {
   return row2.machine_id;
 }
 function segmentPath(dir, machineId2) {
-  return join12(dir, `${machineId2}${SEGMENT_EXT}`);
+  return join13(dir, `${machineId2}${SEGMENT_EXT}`);
 }
 function manifestPath(segment) {
   return segment.replace(new RegExp(`${SEGMENT_EXT}$`), MANIFEST_EXT);
@@ -10574,7 +10583,7 @@ async function flushSegment(db, dir = syncDir()) {
   const path2 = segmentPath(dir, machineId2);
   const lockName = createHash2("sha256").update(`${dir}${machineId2}`).digest("hex").slice(0, 16);
   return withFileLock(
-    join12(locksDir(), `segment-${lockName}.lock`),
+    join13(locksDir(), `segment-${lockName}.lock`),
     `segment:${machineId2}`,
     () => Promise.resolve(flushLocked(db, path2, machineId2))
   );
@@ -10696,16 +10705,16 @@ function verifyAgainstManifest(segment) {
 function discoverPeers(dir, selfMachineId) {
   if (!existsSync14(dir)) return [];
   const peers = [];
-  for (const name of readdirSync3(dir)) {
+  for (const name of readdirSync4(dir)) {
     if (!name.endsWith(SEGMENT_EXT)) continue;
     const stem = name.slice(0, -SEGMENT_EXT.length);
     const conflictAt = stem.indexOf(".sync-conflict-");
     const conflictCopy = conflictAt > 0;
     const machineId2 = conflictCopy ? stem.slice(0, conflictAt) : stem;
     if (machineId2 === selfMachineId && !conflictCopy) continue;
-    const path2 = join12(dir, name);
+    const path2 = join13(dir, name);
     try {
-      if (!statSync2(path2).isFile()) continue;
+      if (!statSync3(path2).isFile()) continue;
     } catch {
       continue;
     }
@@ -10910,7 +10919,7 @@ var init_segments = __esm({
 });
 
 // src/sync.ts
-import { existsSync as existsSync15, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, statSync as statSync4 } from "fs";
 import Database2 from "better-sqlite3";
 function peerStatuses(db, dir) {
   const self = localMachineId(db);
@@ -10918,7 +10927,7 @@ function peerStatuses(db, dir) {
   const rows = discoverPeers(dir, self).map((peer) => {
     let lastSeenMs = null;
     try {
-      lastSeenMs = statSync3(peer.path).mtimeMs;
+      lastSeenMs = statSync4(peer.path).mtimeMs;
     } catch {
       lastSeenMs = null;
     }
@@ -20677,7 +20686,8 @@ async function cmdAgentWait(db, rawNames, opts) {
     const settled = ctlRequest(sock, { op: "wait", afterRuns: probe.status.runs }, { signal }).then(
       (reply) => reply.ok && reply.state !== void 0 ? {
         status: ctlRuntimeState(reply.state),
-        ...reply.lastText !== void 0 ? { lastText: reply.lastText } : {}
+        ...reply.lastText !== void 0 ? { lastText: reply.lastText } : {},
+        ...reply.lastError !== void 0 ? { lastError: reply.lastError } : {}
       } : { status: "unknown", unknownReason: reply.ok ? "ctl wait: no state" : reply.error },
       // The connection dropped. A socket that still answers (pi's /new
       // restarts the session) hands back to polling; one that does not
@@ -20886,8 +20896,308 @@ function wireSelfCommands(program) {
 }
 
 // src/cli/db.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, statSync as statSync5 } from "fs";
 import { dirname as dirname13, resolve as resolve7 } from "path";
+
+// src/compact.ts
+init_legacy_ops();
+var REDUNDANT_TOMBSTONES_SQL = `
+  SELECT d.seq AS seq, length(d.payload) AS bytes
+    FROM ops d
+   WHERE d.entity = 'note' AND d.op = 'del' AND d.payload <> '{}'
+     AND EXISTS (SELECT 1 FROM ops p
+                  WHERE p.entity = 'note' AND p.key = d.key AND p.op = 'put')`;
+function planCompact(db) {
+  const r = db.prepare(
+    `SELECT COUNT(*) AS n, COALESCE(SUM(bytes), 0) AS b FROM (${REDUNDANT_TOMBSTONES_SQL})`
+  ).get();
+  return { tombstones: r.n, bytes: r.b };
+}
+function compact(db) {
+  const plan = planCompact(db);
+  db.transaction(() => {
+    db.prepare(
+      `UPDATE ops SET payload = '{}' WHERE seq IN (SELECT seq FROM (${REDUNDANT_TOMBSTONES_SQL}))`
+    ).run();
+  })();
+  return plan;
+}
+var WORKSTREAM_OPS_WHERE = `(key = @ws OR substr(key, 1, length(@ws) + 1) = @ws || '/')`;
+function listForgetCandidates(db) {
+  const spellings = intentSpellings("workstream.teardown");
+  const names = db.prepare(
+    `SELECT key AS name, MAX(created_at) AS at
+         FROM ops
+        WHERE entity = 'workstream' AND op = 'del'
+          AND intent IN (${spellings.map(() => "?").join(", ")})
+          AND key NOT IN (SELECT name FROM workstreams)
+        GROUP BY key`
+  ).all(...spellings);
+  const cost = db.prepare(
+    `SELECT COUNT(*) AS n, COALESCE(SUM(length(payload)), 0) AS b FROM ops WHERE ${WORKSTREAM_OPS_WHERE}`
+  );
+  return names.map((r) => {
+    const c = cost.get({ ws: r.name });
+    return { name: r.name, tornDownAt: r.at, ops: c.n, bytes: c.b };
+  }).sort((a, b) => b.bytes - a.bytes);
+}
+function planForget(db, names) {
+  const all = new Map(listForgetCandidates(db).map((c) => [c.name, c]));
+  const live = new Set(
+    db.prepare("SELECT name FROM workstreams").all().map((r) => r.name)
+  );
+  const plan = { candidates: [], refused: [] };
+  for (const name of new Set(names)) {
+    const c = all.get(name);
+    if (c) plan.candidates.push(c);
+    else plan.refused.push({ name, why: live.has(name) ? "live" : "never-torn-down" });
+  }
+  return plan;
+}
+function forget(db, plan) {
+  const del = db.prepare(`DELETE FROM ops WHERE ${WORKSTREAM_OPS_WHERE}`);
+  let ops = 0;
+  db.transaction(() => {
+    for (const c of plan.candidates) ops += del.run({ ws: c.name }).changes;
+  })();
+  return { ops };
+}
+
+// src/disk-recon.ts
+init_db();
+init_workspace();
+import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join12 } from "path";
+var STALE_LOCK_REPORT_MS = 60 * 60 * 1e3;
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}K`;
+  if (bytes < 1024 * 1024 * 1024) return `${Math.round(bytes / 1024 / 1024)}M`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}G`;
+}
+function dirNames(path2) {
+  try {
+    return readdirSync3(path2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function exists(path2) {
+  try {
+    statSync2(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sizeOf(path2) {
+  try {
+    return statSync2(path2).size;
+  } catch {
+    return 0;
+  }
+}
+function findMissingWorkspaceDirs(db) {
+  return listWorkspaces2(db).filter((row2) => !exists(row2.path)).map((row2) => ({
+    agentName: row2.agentName,
+    workstreamName: row2.workstreamName,
+    path: row2.path
+  }));
+}
+function checkMissingWorkspaceDirs(db) {
+  const missing = findMissingWorkspaceDirs(db);
+  if (missing.length === 0) {
+    return { name: "ws-rows", severity: "ok", detail: "every workspace row has its dir" };
+  }
+  return {
+    name: "ws-rows",
+    severity: "warn",
+    detail: `${missing.length} workspace row(s) point at a path that is gone`,
+    remediation: [
+      "These vcs_workspaces rows name a directory that no longer exists:",
+      ...missing.map((m) => `  ${m.workstreamName}/${m.agentName}  ${m.path}`),
+      "",
+      "mu reports such a row as a healthy workspace on every read surface, and",
+      "the next send or refresh against it fails inside the VCS backend rather",
+      "than at the row that lied. Unregister them:",
+      ...missing.map((m) => `  mu workspace free ${m.agentName} -w ${m.workstreamName}`)
+    ]
+  };
+}
+function checkWorkspaceOrphanDirs(db) {
+  const orphans = listAllOrphanWorkspaces(db);
+  if (orphans.length === 0) {
+    return { name: "ws-dirs", severity: "ok", detail: "no orphan workspace dirs" };
+  }
+  const stranded = orphans.filter((o) => o.stranded);
+  const strandedNote = stranded.length > 0 ? `, ${stranded.length} stranded` : "";
+  return {
+    name: "ws-dirs",
+    severity: "warn",
+    detail: `${orphans.length} workspace dir(s) with no DB row${strandedNote}`,
+    remediation: [
+      "These directories have no row in vcs_workspaces:",
+      ...orphans.map((o) => `  ${o.path}${o.stranded ? "   (workstream row also gone)" : ""}`),
+      "",
+      "Each one blocks the next `--workspace` spawn for that agent name. mu will",
+      "not remove them: they may hold uncommitted work, and a stranded dir is the",
+      "only remaining copy of it. Inspect, then remove by hand:",
+      "  mu workspace orphans --all",
+      ...orphans.slice(0, 3).map((o) => `  rm -rf ${o.path}`)
+    ]
+  };
+}
+function checkEmptyWorkstreamDirs() {
+  const root = join12(defaultStateDir(), "workspaces");
+  const empty = dirNames(root).filter((name) => dirNames(join12(root, name)).length === 0);
+  if (empty.length === 0) {
+    return { name: "ws-empty", severity: "ok", detail: "no empty workstream dirs" };
+  }
+  return {
+    name: "ws-empty",
+    severity: "ok",
+    detail: `${empty.length} empty workstream dir(s): ${empty.slice(0, 4).join(", ")}`,
+    remediation: [
+      "These per-workstream workspace dirs hold no checkouts:",
+      ...empty.map((name) => `  ${join12(root, name)}`),
+      "",
+      "`mu workspace free` removes an agent's dir and its row but not the parent,",
+      "so this is normal residue rather than a fault. Remove if you want the",
+      "state dir to read cleanly:",
+      ...empty.slice(0, 3).map((name) => `  rmdir ${join12(root, name)}`)
+    ]
+  };
+}
+function findStrayDbFiles(stateDir = defaultStateDir()) {
+  const live = /* @__PURE__ */ new Set(["mu.db", "mu.db-wal", "mu.db-shm"]);
+  let entries;
+  try {
+    entries = readdirSync3(stateDir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  return entries.filter((name) => name.startsWith("mu.db") && !live.has(name)).map((name) => ({ name, path: join12(stateDir, name), bytes: sizeOf(join12(stateDir, name)) })).sort((a, b) => b.bytes - a.bytes);
+}
+function checkStrayDbFiles() {
+  const stateDir = defaultStateDir();
+  const stray = findStrayDbFiles(stateDir);
+  if (stray.length === 0) {
+    return { name: "db-copies", severity: "ok", detail: "no stray DB copies" };
+  }
+  const total = stray.reduce((n, f) => n + f.bytes, 0);
+  return {
+    name: "db-copies",
+    severity: "warn",
+    detail: `${stray.length} stray DB file(s), ${formatBytes(total)} \u2014 nothing reads these`,
+    remediation: [
+      `Files matching mu.db* in ${stateDir} that are not the live WAL triple:`,
+      ...stray.map((f) => `  ${formatBytes(f.bytes).padStart(6)}  ${f.name}`),
+      "",
+      `Live DB: ${defaultDbPath()}`,
+      "",
+      "These are hand-made copies and pre-upgrade saves. No mu code path reads",
+      "them and none prunes them. Real disaster recovery is the ops log, so a",
+      "copy is only ever a convenience:",
+      "  mu rebuild <file>        # DR from the ops log, not from a copy",
+      "  mu db backup <file>      # a fresh copy, if that is what you wanted"
+    ]
+  };
+}
+function checkRemovedExportsDir() {
+  const root = join12(defaultStateDir(), "exports");
+  const entries = dirNames(root);
+  if (entries.length === 0) {
+    return { name: "exports", severity: "ok", detail: "no leftover export dirs" };
+  }
+  return {
+    name: "exports",
+    severity: "warn",
+    detail: `${entries.length} export dir(s) from the removed \`mu workstream export\``,
+    remediation: [
+      `${root} holds ${entries.length} directory/ies.`,
+      "",
+      "`mu workstream export` and its markdown bucket were removed in 1.0; this",
+      "is output from a version that still had it. Nothing in mu reads or prunes",
+      "it. Keep anything you still want, then:",
+      `  rm -rf ${root}`
+    ]
+  };
+}
+function checkStaleLocks(now = Date.now()) {
+  const root = join12(defaultStateDir(), "locks");
+  const stale = [];
+  for (const name of dirNames(root)) {
+    try {
+      const ageMs2 = now - statSync2(join12(root, name)).mtimeMs;
+      if (ageMs2 > STALE_LOCK_REPORT_MS) stale.push({ name, ageMs: ageMs2 });
+    } catch {
+    }
+  }
+  if (stale.length === 0) {
+    return { name: "locks", severity: "ok", detail: "no stale lock dirs" };
+  }
+  return {
+    name: "locks",
+    severity: "warn",
+    detail: `${stale.length} lock dir(s) older than 1h`,
+    remediation: [
+      "These advisory-lock dirs outlived the process that took them:",
+      ...stale.map((s) => `  ${s.name}  (${Math.round(s.ageMs / 6e4)}m old)`),
+      "",
+      "Not a deadlock: withFileLock steals a lock older than 30s. But it only",
+      "steals under contention, so these will sit here forever. They are evidence",
+      "of a spawn or segment flush that died mid-critical-section.",
+      `  rm -rf ${root}/<name>`
+    ]
+  };
+}
+function walkBytes(path2) {
+  let total = 0;
+  let entries;
+  try {
+    entries = readdirSync3(path2, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const child = join12(path2, entry.name);
+    if (entry.isDirectory()) total += walkBytes(child);
+    else if (entry.isFile()) total += sizeOf(child);
+  }
+  return total;
+}
+function measureWorkspaceUsage(db) {
+  const root = join12(defaultStateDir(), "workspaces");
+  const registered = new Set(listWorkspaces2(db).map((w) => w.path));
+  const usage = [];
+  for (const wsName of dirNames(root)) {
+    const wsRoot = join12(root, wsName);
+    for (const agentName of dirNames(wsRoot)) {
+      const path2 = join12(wsRoot, agentName);
+      usage.push({
+        workstreamName: wsName,
+        agentName,
+        path: path2,
+        bytes: walkBytes(path2),
+        orphan: !registered.has(path2)
+      });
+    }
+  }
+  return usage.sort((a, b) => b.bytes - a.bytes);
+}
+function checkDiskRecon(db) {
+  return [
+    checkMissingWorkspaceDirs(db),
+    checkWorkspaceOrphanDirs(db),
+    checkEmptyWorkstreamDirs(),
+    checkStrayDbFiles(),
+    checkRemovedExportsDir(),
+    checkStaleLocks()
+  ];
+}
+
+// src/cli/db.ts
+init_drift();
 init_output();
 
 // src/cli/handle.ts
@@ -21695,6 +22005,110 @@ function cmdDbBackup(db, file, opts = {}) {
   console.log(`Backed up to ${pc.bold(target)}`);
   printNextSteps(nextSteps3);
 }
+function backupBeside(db, verb) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const target = `${db.name}.pre-${verb}-${ts}`;
+  db.prepare("VACUUM INTO ?").run(target);
+  return target;
+}
+function vacuumAndCheck(db, backup) {
+  const before = statSync5(db.name).size;
+  db.exec("VACUUM");
+  const after = statSync5(db.name).size;
+  const report = checkDrift(db);
+  if (!report.clean) {
+    console.error(
+      pc.red(`drift after the rewrite (${report.totalDrift}); the backup is ${backup}`)
+    );
+    throw new DriftDetectedError(report.totalDrift, report.records);
+  }
+  return { before, after };
+}
+function cmdDbCompact(db, opts = {}) {
+  const plan = planCompact(db);
+  if (opts.yes !== true || plan.tombstones === 0) {
+    const nextSteps3 = plan.tombstones === 0 ? [] : [{ intent: "Apply it", command: "mu db compact --yes" }];
+    if (opts.json === true) {
+      emitJson({ dryRun: true, ...plan, nextSteps: nextSteps3 });
+      return;
+    }
+    console.log(
+      plan.tombstones === 0 ? pc.dim("nothing to compact: no redundant note tombstones") : `${plan.tombstones} note tombstones repeat a put already in the log (${formatBytes(plan.bytes)}). Dry run; nothing changed.`
+    );
+    printNextSteps(nextSteps3);
+    return;
+  }
+  const backup = backupBeside(db, "compact");
+  compact(db);
+  const size = vacuumAndCheck(db, backup);
+  if (opts.json === true) {
+    emitJson({ dryRun: false, ...plan, backup, ...size });
+    return;
+  }
+  console.log(
+    `Compacted ${plan.tombstones} note tombstones: ${formatBytes(size.before)} \u2192 ${formatBytes(size.after)}. Drift check clean.`
+  );
+  console.log(pc.dim(`backup: ${backup}`));
+}
+function printForgetTable(plan) {
+  const t = muTable({ head: ["workstream", "torn down", "ops", "size"].map((h) => pc.bold(h)) });
+  for (const c of plan.candidates)
+    t.push([c.name, c.tornDownAt.slice(0, 10), String(c.ops), formatBytes(c.bytes)]);
+  console.log(t.toString());
+}
+function cmdDbForget(db, names, opts = {}) {
+  const plan = planForget(db, names);
+  if (plan.refused.length > 0) {
+    const why = plan.refused.map((r2) => `${r2.name} (${r2.why === "live" ? "is live" : "was never torn down"})`).join(", ");
+    throw new UsageError(`cannot forget: ${why}. Only torn-down workstreams can be forgotten.`);
+  }
+  const ops = plan.candidates.reduce((n, c) => n + c.ops, 0);
+  const bytes = plan.candidates.reduce((n, c) => n + c.bytes, 0);
+  if (opts.yes !== true) {
+    const nextSteps3 = [
+      { intent: "Forget them (NOT undoable)", command: `mu db forget ${names.join(" ")} --yes` }
+    ];
+    if (opts.json === true) {
+      emitJson({ dryRun: true, candidates: plan.candidates, ops, bytes, nextSteps: nextSteps3 });
+      return;
+    }
+    printForgetTable(plan);
+    console.log(
+      `${ops} ops (${formatBytes(bytes)} of payload). Forgetting deletes their history: mu undo can no longer restore these teardowns. Dry run; nothing changed.`
+    );
+    printNextSteps(nextSteps3);
+    return;
+  }
+  const backup = backupBeside(db, "forget");
+  const r = forget(db, plan);
+  const size = vacuumAndCheck(db, backup);
+  if (opts.json === true) {
+    emitJson({
+      dryRun: false,
+      forgotten: plan.candidates.map((c) => c.name),
+      ops: r.ops,
+      backup,
+      ...size
+    });
+    return;
+  }
+  console.log(
+    `Forgot ${plan.candidates.length} workstream(s), ${r.ops} ops: ${formatBytes(size.before)} \u2192 ${formatBytes(size.after)}. Drift check clean.`
+  );
+  console.log(pc.dim(`backup (the only way back): ${backup}`));
+}
+function forgetHint(db) {
+  const all = listForgetCandidates(db);
+  const bytes = all.reduce((n, c) => n + c.bytes, 0);
+  if (bytes < FORGET_HINT_MIN_BYTES) return void 0;
+  return {
+    total: all.length,
+    ops: all.reduce((n, c) => n + c.ops, 0),
+    bytes,
+    top: all.slice(0, 3).map((c) => c.name)
+  };
+}
+var FORGET_HINT_MIN_BYTES = 5 * 1024 * 1024;
 function wireDbCommands(program) {
   const dbCmd = program.command("db").description("Whole-DB file commands");
   dbCmd.command("backup <file>").description(
@@ -21703,247 +22117,24 @@ function wireDbCommands(program) {
     const opts = this.opts();
     return handle(async (db) => cmdDbBackup(db, file, opts), this)();
   });
+  dbCmd.command("compact").description(
+    "Shrink mu.db: blank note tombstones that repeat a put already in the log, then VACUUM. Dry run without --yes; --yes backs up beside the DB first and runs the drift check after. Local only; sync segments are untouched."
+  ).option("--yes", "apply (default: dry run)").option(...JSON_OPT).action(function() {
+    const opts = this.opts();
+    return handle(async (db) => cmdDbCompact(db, opts), this)();
+  });
+  dbCmd.command("forget <workstreams...>").description(
+    "Delete every op of torn-down workstreams to shrink mu.db. NOT undoable: mu undo can no longer restore them. Dry run without --yes; --yes backs up beside the DB first, VACUUMs, and runs the drift check. List candidates: mu workstream list --torn-down."
+  ).option("--yes", "apply (default: dry run)").option(...JSON_OPT).action(function(names) {
+    const opts = this.opts();
+    return handle(async (db) => cmdDbForget(db, names, opts), this)();
+  });
 }
 
 // src/cli/doctor.ts
 init_agents();
 import { dirname as dirname14 } from "path";
 init_db();
-
-// src/disk-recon.ts
-init_db();
-init_workspace();
-import { readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { join as join13 } from "path";
-var STALE_LOCK_REPORT_MS = 60 * 60 * 1e3;
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}K`;
-  if (bytes < 1024 * 1024 * 1024) return `${Math.round(bytes / 1024 / 1024)}M`;
-  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}G`;
-}
-function dirNames(path2) {
-  try {
-    return readdirSync4(path2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-function exists(path2) {
-  try {
-    statSync4(path2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function sizeOf(path2) {
-  try {
-    return statSync4(path2).size;
-  } catch {
-    return 0;
-  }
-}
-function findMissingWorkspaceDirs(db) {
-  return listWorkspaces2(db).filter((row2) => !exists(row2.path)).map((row2) => ({
-    agentName: row2.agentName,
-    workstreamName: row2.workstreamName,
-    path: row2.path
-  }));
-}
-function checkMissingWorkspaceDirs(db) {
-  const missing = findMissingWorkspaceDirs(db);
-  if (missing.length === 0) {
-    return { name: "ws-rows", severity: "ok", detail: "every workspace row has its dir" };
-  }
-  return {
-    name: "ws-rows",
-    severity: "warn",
-    detail: `${missing.length} workspace row(s) point at a path that is gone`,
-    remediation: [
-      "These vcs_workspaces rows name a directory that no longer exists:",
-      ...missing.map((m) => `  ${m.workstreamName}/${m.agentName}  ${m.path}`),
-      "",
-      "mu reports such a row as a healthy workspace on every read surface, and",
-      "the next send or refresh against it fails inside the VCS backend rather",
-      "than at the row that lied. Unregister them:",
-      ...missing.map((m) => `  mu workspace free ${m.agentName} -w ${m.workstreamName}`)
-    ]
-  };
-}
-function checkWorkspaceOrphanDirs(db) {
-  const orphans = listAllOrphanWorkspaces(db);
-  if (orphans.length === 0) {
-    return { name: "ws-dirs", severity: "ok", detail: "no orphan workspace dirs" };
-  }
-  const stranded = orphans.filter((o) => o.stranded);
-  const strandedNote = stranded.length > 0 ? `, ${stranded.length} stranded` : "";
-  return {
-    name: "ws-dirs",
-    severity: "warn",
-    detail: `${orphans.length} workspace dir(s) with no DB row${strandedNote}`,
-    remediation: [
-      "These directories have no row in vcs_workspaces:",
-      ...orphans.map((o) => `  ${o.path}${o.stranded ? "   (workstream row also gone)" : ""}`),
-      "",
-      "Each one blocks the next `--workspace` spawn for that agent name. mu will",
-      "not remove them: they may hold uncommitted work, and a stranded dir is the",
-      "only remaining copy of it. Inspect, then remove by hand:",
-      "  mu workspace orphans --all",
-      ...orphans.slice(0, 3).map((o) => `  rm -rf ${o.path}`)
-    ]
-  };
-}
-function checkEmptyWorkstreamDirs() {
-  const root = join13(defaultStateDir(), "workspaces");
-  const empty = dirNames(root).filter((name) => dirNames(join13(root, name)).length === 0);
-  if (empty.length === 0) {
-    return { name: "ws-empty", severity: "ok", detail: "no empty workstream dirs" };
-  }
-  return {
-    name: "ws-empty",
-    severity: "ok",
-    detail: `${empty.length} empty workstream dir(s): ${empty.slice(0, 4).join(", ")}`,
-    remediation: [
-      "These per-workstream workspace dirs hold no checkouts:",
-      ...empty.map((name) => `  ${join13(root, name)}`),
-      "",
-      "`mu workspace free` removes an agent's dir and its row but not the parent,",
-      "so this is normal residue rather than a fault. Remove if you want the",
-      "state dir to read cleanly:",
-      ...empty.slice(0, 3).map((name) => `  rmdir ${join13(root, name)}`)
-    ]
-  };
-}
-function findStrayDbFiles(stateDir = defaultStateDir()) {
-  const live = /* @__PURE__ */ new Set(["mu.db", "mu.db-wal", "mu.db-shm"]);
-  let entries;
-  try {
-    entries = readdirSync4(stateDir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-  return entries.filter((name) => name.startsWith("mu.db") && !live.has(name)).map((name) => ({ name, path: join13(stateDir, name), bytes: sizeOf(join13(stateDir, name)) })).sort((a, b) => b.bytes - a.bytes);
-}
-function checkStrayDbFiles() {
-  const stateDir = defaultStateDir();
-  const stray = findStrayDbFiles(stateDir);
-  if (stray.length === 0) {
-    return { name: "db-copies", severity: "ok", detail: "no stray DB copies" };
-  }
-  const total = stray.reduce((n, f) => n + f.bytes, 0);
-  return {
-    name: "db-copies",
-    severity: "warn",
-    detail: `${stray.length} stray DB file(s), ${formatBytes(total)} \u2014 nothing reads these`,
-    remediation: [
-      `Files matching mu.db* in ${stateDir} that are not the live WAL triple:`,
-      ...stray.map((f) => `  ${formatBytes(f.bytes).padStart(6)}  ${f.name}`),
-      "",
-      `Live DB: ${defaultDbPath()}`,
-      "",
-      "These are hand-made copies and pre-upgrade saves. No mu code path reads",
-      "them and none prunes them. Real disaster recovery is the ops log, so a",
-      "copy is only ever a convenience:",
-      "  mu rebuild <file>        # DR from the ops log, not from a copy",
-      "  mu db backup <file>      # a fresh copy, if that is what you wanted"
-    ]
-  };
-}
-function checkRemovedExportsDir() {
-  const root = join13(defaultStateDir(), "exports");
-  const entries = dirNames(root);
-  if (entries.length === 0) {
-    return { name: "exports", severity: "ok", detail: "no leftover export dirs" };
-  }
-  return {
-    name: "exports",
-    severity: "warn",
-    detail: `${entries.length} export dir(s) from the removed \`mu workstream export\``,
-    remediation: [
-      `${root} holds ${entries.length} directory/ies.`,
-      "",
-      "`mu workstream export` and its markdown bucket were removed in 1.0; this",
-      "is output from a version that still had it. Nothing in mu reads or prunes",
-      "it. Keep anything you still want, then:",
-      `  rm -rf ${root}`
-    ]
-  };
-}
-function checkStaleLocks(now = Date.now()) {
-  const root = join13(defaultStateDir(), "locks");
-  const stale = [];
-  for (const name of dirNames(root)) {
-    try {
-      const ageMs2 = now - statSync4(join13(root, name)).mtimeMs;
-      if (ageMs2 > STALE_LOCK_REPORT_MS) stale.push({ name, ageMs: ageMs2 });
-    } catch {
-    }
-  }
-  if (stale.length === 0) {
-    return { name: "locks", severity: "ok", detail: "no stale lock dirs" };
-  }
-  return {
-    name: "locks",
-    severity: "warn",
-    detail: `${stale.length} lock dir(s) older than 1h`,
-    remediation: [
-      "These advisory-lock dirs outlived the process that took them:",
-      ...stale.map((s) => `  ${s.name}  (${Math.round(s.ageMs / 6e4)}m old)`),
-      "",
-      "Not a deadlock: withFileLock steals a lock older than 30s. But it only",
-      "steals under contention, so these will sit here forever. They are evidence",
-      "of a spawn or segment flush that died mid-critical-section.",
-      `  rm -rf ${root}/<name>`
-    ]
-  };
-}
-function walkBytes(path2) {
-  let total = 0;
-  let entries;
-  try {
-    entries = readdirSync4(path2, { withFileTypes: true });
-  } catch {
-    return 0;
-  }
-  for (const entry of entries) {
-    const child = join13(path2, entry.name);
-    if (entry.isDirectory()) total += walkBytes(child);
-    else if (entry.isFile()) total += sizeOf(child);
-  }
-  return total;
-}
-function measureWorkspaceUsage(db) {
-  const root = join13(defaultStateDir(), "workspaces");
-  const registered = new Set(listWorkspaces2(db).map((w) => w.path));
-  const usage = [];
-  for (const wsName of dirNames(root)) {
-    const wsRoot = join13(root, wsName);
-    for (const agentName of dirNames(wsRoot)) {
-      const path2 = join13(wsRoot, agentName);
-      usage.push({
-        workstreamName: wsName,
-        agentName,
-        path: path2,
-        bytes: walkBytes(path2),
-        orphan: !registered.has(path2)
-      });
-    }
-  }
-  return usage.sort((a, b) => b.bytes - a.bytes);
-}
-function checkDiskRecon(db) {
-  return [
-    checkMissingWorkspaceDirs(db),
-    checkWorkspaceOrphanDirs(db),
-    checkEmptyWorkstreamDirs(),
-    checkStrayDbFiles(),
-    checkRemovedExportsDir(),
-    checkStaleLocks()
-  ];
-}
-
-// src/cli/doctor.ts
 init_doctor_summary();
 
 // src/dormant.ts
@@ -22272,12 +22463,37 @@ state (workstream=${ws})`));
       throw new DriftDetectedError(cheap.totalUnexplained, []);
     }
   }
+  const size = opsSizeHint(db);
+  if (size) {
+    console.log(`  size             : ${pc.yellow("hint")} ${size.line}`);
+    for (const c of size.commands) console.log(pc.dim(`      ${c}`));
+  }
   if (sawHazard) {
     console.log(
       pc.dim("\nSee the fleet / disk sections above: at least one finding needs attention.")
     );
   }
 }
+function opsSizeHint(db) {
+  const forgettable = forgetHint(db);
+  const tomb = planCompact(db);
+  const parts = [];
+  const commands = [];
+  if (forgettable) {
+    parts.push(
+      `${forgettable.total} torn-down workstreams hold ${forgettable.ops} ops (${formatBytes(forgettable.bytes)}); largest: ${forgettable.top.join(", ")}`
+    );
+    commands.push(
+      "see them:    mu workstream list --torn-down",
+      `forget some: mu db forget ${forgettable.top.join(" ")}`
+    );
+  }
+  if (tomb.bytes >= 1024 * 1024) {
+    parts.push(`${tomb.tombstones} redundant note tombstones (${formatBytes(tomb.bytes)})`);
+    commands.push("compact:     mu db compact");
+  }
+  return parts.length === 0 ? void 0 : { line: parts.join("; "), commands };
+}
 async function cmdDoctorJson(db, opts = {}) {
   const health = await muxHealth();
   const muExt = ctlExtensionDoctorCheck();
@@ -22419,6 +22635,7 @@ async function cmdDoctorJson(db, opts = {}) {
     disk,
     workspaceUsage,
     drift,
+    size: opsSizeHint(db) ?? null,
     remediation: drift.ok === true ? [] : driftRemediation()
   });
   if (driftFailure !== null) throw driftFailure;