@mu-crew/mu 3.3.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
@@ -393,7 +398,7 @@ var init_status = __esm({
     TASK_STATUSES = ["OPEN", "IN_PROGRESS", "CLOSED"];
     TASK_STATUS_LIST = TASK_STATUSES.join(" | ");
     TASK_SUBSTATES = {
-      OPEN: ["todo", "parked"],
+      OPEN: ["todo", "parked", "triage"],
       IN_PROGRESS: ["active"],
       CLOSED: ["done", "rejected", "wontfix", "duplicate", "superseded"]
     };
@@ -607,7 +612,7 @@ CREATE VIEW ready AS
   SELECT t.*
     FROM tasks t
    WHERE t.status = 'OPEN'
-     AND t.substate <> 'parked'
+     AND t.substate NOT IN ('parked', 'triage')
      AND NOT EXISTS (
        SELECT 1
          FROM task_edges e
@@ -5850,7 +5855,7 @@ var init_id = __esm({
 });
 
 // src/tasks/errors.ts
-var TaskNotFoundError, TaskIdInvalidError, TaskExistsError, TaskNotInWorkstreamError, TaskAlreadyOwnedError, ClaimerNotRegisteredError, TaskClaimStaleWorkspaceError, CycleError, ReaperDetectedDuringWaitError, StallDetectedDuringWaitError, CrossWorkstreamEdgeError, SubstateReasonRequiredError, TaskParkStateError, TaskParkedError, InvalidSubstateError;
+var TaskNotFoundError, TaskIdInvalidError, TaskExistsError, TaskNotInWorkstreamError, TaskAlreadyOwnedError, ClaimerNotRegisteredError, TaskClaimStaleWorkspaceError, CycleError, ReaperDetectedDuringWaitError, StallDetectedDuringWaitError, CrossWorkstreamEdgeError, SubstateReasonRequiredError, TaskParkStateError, TaskInTriageError, TaskParkedError, InvalidSubstateError;
 var init_errors2 = __esm({
   "src/tasks/errors.ts"() {
     "use strict";
@@ -6198,6 +6203,30 @@ var init_errors2 = __esm({
         ];
       }
     };
+    TaskInTriageError = class extends Error {
+      constructor(taskId, workstream) {
+        super(`task ${taskId} is in triage (OPEN/triage); accept it or claim with --force`);
+        this.taskId = taskId;
+        this.workstream = workstream;
+      }
+      taskId;
+      workstream;
+      name = "TaskInTriageError";
+      errorNextSteps() {
+        const ws = this.workstream;
+        return [
+          {
+            intent: "Accept it as work, then claim",
+            command: `mu task accept ${this.taskId} -w ${ws}`
+          },
+          {
+            intent: "Decline it",
+            command: `mu task close ${this.taskId} --as rejected --why "<reason>" -w ${ws}`
+          },
+          { intent: "Claim it anyway", command: `mu task claim ${this.taskId} --force -w ${ws}` }
+        ];
+      }
+    };
     TaskParkedError = class extends Error {
       constructor(taskId, workstream) {
         super(`task ${taskId} is parked (OPEN/parked); unpark it or claim with --force`);
@@ -6760,8 +6789,17 @@ function addTaskImpl(db, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const insertResult = db.prepare(
       `INSERT INTO tasks (workstream_id, local_id, title, status, substate, impact, effort_days, created_at, updated_at)
-         VALUES (?, ?, ?, 'OPEN', 'todo', ?, ?, ?, ?)`
-    ).run(wsId, opts.localId, opts.title, opts.impact, opts.effortDays, now, now);
+         VALUES (?, ?, ?, 'OPEN', ?, ?, ?, ?, ?)`
+    ).run(
+      wsId,
+      opts.localId,
+      opts.title,
+      opts.triage === true ? "triage" : "todo",
+      opts.impact,
+      opts.effortDays,
+      now,
+      now
+    );
     const newTaskId = Number(insertResult.lastInsertRowid);
     if (opts.blockedBy && opts.blockedBy.length > 0) {
       const blockerLookupSameWs = db.prepare(
@@ -7049,6 +7087,28 @@ function parkTask(db, localId, opts) {
     })()
   );
 }
+function acceptTask(db, localId, opts) {
+  return withOpContext(
+    db,
+    { intent: "task.accept", group: "new" },
+    () => db.transaction(() => {
+      const before = getTask(db, localId, opts.workstream);
+      if (!before) throw new TaskNotFoundError(localId);
+      if (before.status !== "OPEN" || before.substate !== "triage") {
+        return {
+          previousStatus: before.status,
+          status: before.status,
+          previousSubstate: before.substate,
+          substate: before.substate,
+          changed: false
+        };
+      }
+      const r = setTaskStatus(db, localId, "OPEN", { workstream: opts.workstream });
+      recordEvidenceNote(db, localId, before.workstreamName, "ACCEPT", opts);
+      return r;
+    })()
+  );
+}
 function unparkTask(db, localId, opts) {
   return withOpContext(
     db,
@@ -7191,6 +7251,9 @@ function assertNotParked(task, opts) {
   if (task.status === "OPEN" && task.substate === "parked" && opts.force !== true) {
     throw new TaskParkedError(task.name, task.workstreamName);
   }
+  if (task.status === "OPEN" && task.substate === "triage" && opts.force !== true) {
+    throw new TaskInTriageError(task.name, task.workstreamName);
+  }
 }
 async function resolveActorIdentity() {
   const worker = await resolveWorkerIdentity();
@@ -7562,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({
@@ -7775,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();
         },
@@ -10083,6 +10150,10 @@ async function loadWorkstreamSnapshotFast(db, workstream, opts = {}) {
     blocked: listBlocked(db, workstream),
     recentClosed: listRecentClosed(db, workstream),
     parkedCount: listTasks(db, workstream, { status: "OPEN", substate: "parked" }).length,
+    triage: listTasks(db, workstream, { status: "OPEN", substate: "triage" }),
+    taskCount: db.prepare(
+      "SELECT count(*) AS n FROM tasks t JOIN workstreams w ON w.id = t.workstream_id WHERE w.name = ?"
+    ).get(workstream).n,
     allTasks: opts.withAllTasks === true ? listTasks(db, workstream) : [],
     workspaces: listWorkspaces2(db, workstream),
     workspaceOrphans: listWorkspaceOrphans(db, workstream),
@@ -10156,6 +10227,8 @@ function minimalSnapshot(workstream) {
     blocked: [],
     recentClosed: [],
     parkedCount: 0,
+    triage: [],
+    taskCount: 0,
     allTasks: [],
     workspaces: [],
     workspaceOrphans: [],
@@ -10336,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;
@@ -10366,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);
@@ -10510,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))
   );
@@ -10632,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;
     }
@@ -10846,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);
@@ -10854,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;
     }
@@ -11324,7 +11397,7 @@ function colorPair(pair) {
   const text2 = formatPair(pair);
   switch (pair.status) {
     case "OPEN":
-      return pair.substate === "parked" ? pc.dim(text2) : pc.cyan(text2);
+      return pair.substate === "parked" || pair.substate === "triage" ? pc.dim(text2) : pc.cyan(text2);
     case "IN_PROGRESS":
       return pc.yellow(text2);
     case "CLOSED":
@@ -11344,7 +11417,7 @@ function colorStatus(status) {
 function inkColorForPair(pair) {
   switch (pair.status) {
     case "OPEN":
-      return pair.substate === "parked" ? "gray" : "cyan";
+      return pair.substate === "parked" || pair.substate === "triage" ? "gray" : "cyan";
     case "IN_PROGRESS":
       return "yellow";
     case "CLOSED":
@@ -16537,6 +16610,7 @@ function yankCommandForTask2(t, ws) {
   switch (t.status) {
     case "OPEN":
       if (t.substate === "parked") return `mu task unpark ${t.name} -w ${ws}`;
+      if (t.substate === "triage") return `mu task accept ${t.name} -w ${ws}`;
       return t.ownerName === null ? `mu task claim ${t.name} -w ${ws}` : `mu task release ${t.name} -w ${ws}`;
     case "IN_PROGRESS":
       return `mu task close ${t.name} -w ${ws} --evidence "..."`;
@@ -17596,6 +17670,7 @@ function snapshotKey(s) {
     blocked: s.blocked.map(taskKey2),
     recentClosed: s.recentClosed.map(taskKey2),
     parkedCount: s.parkedCount,
+    triage: s.triage.map(taskKey2),
     allTasks: s.allTasks.map(taskKey2),
     commitsBackend: s.commitsBackend ?? null,
     recentCommits: s.recentCommits.map((c) => [c.sha, c.subject, c.author, c.relTime]),
@@ -18769,7 +18844,8 @@ async function cmdTaskAdd(db, localId, opts) {
       title: opts.title,
       impact: opts.impact,
       effortDays: opts.effortDays,
-      ...hasBlockers ? { blockedBy } : {}
+      ...hasBlockers ? { blockedBy } : {},
+      ...opts.triage === true ? { triage: true } : {}
     });
     const createdNote = opts.note !== void 0 ? addNote(db, createdTask.name, unescapeNoteText(opts.note), {
       author: initialNoteAuthor,
@@ -18793,7 +18869,7 @@ async function cmdTaskAdd(db, localId, opts) {
       intent: "Add a blocker",
       command: `mu task block ${task.name} --by <other-id> -w ${workstream}`
     },
-    {
+    opts.triage === true ? { intent: "Accept it as work", command: `mu task accept ${task.name} -w ${workstream}` } : {
       intent: "Claim and start",
       command: `mu task claim ${task.name} -w ${workstream} --self  (or --for <worker>)`
     }
@@ -18916,6 +18992,12 @@ async function cmdTaskShow(db, rawId, opts = {}) {
   if (task.substate === "parked") {
     console.log("");
     printNextSteps([{ intent: "Return it to next", command: `mu task unpark ${ref}` }]);
+  } else if (task.substate === "triage") {
+    console.log("");
+    printNextSteps([
+      { intent: "Accept it as work", command: `mu task accept ${ref}` },
+      { intent: "Decline it", command: `mu task close ${ref} --as rejected --why "<reason>"` }
+    ]);
   } else if (task.status === "CLOSED" && task.substate !== "done") {
     console.log("");
     printNextSteps([{ intent: "Reopen it", command: `mu task open ${ref}` }]);
@@ -19040,6 +19122,17 @@ async function cmdTaskList(db, opts) {
   const basis = relTimeBasisForSort(sortKey);
   if (basis !== null) tableOpts.relTimeBasis = basis;
   console.log(formatTaskListTable(tasks, tableOpts));
+  const first = tasks.find((t) => t.status === "OPEN" && t.substate === "triage");
+  if (first !== void 0) {
+    printNextSteps([
+      { intent: "Accept as work", command: `mu task accept ${first.name} -w ${workstream}` },
+      {
+        intent: "Decline",
+        command: `mu task close ${first.name} --as rejected|duplicate --why "<reason>" -w ${workstream}`
+      },
+      { intent: "Read the evidence", command: `mu task notes ${first.name} -w ${workstream}` }
+    ]);
+  }
 }
 async function cmdTaskNext(db, opts) {
   const workstream = await resolveWorkstream(opts.workstream);
@@ -19060,16 +19153,26 @@ async function cmdTaskNext(db, opts) {
   }
   if (tasks.length === 0) {
     const parked = listTasks(db, workstream, { substate: "parked" }).length;
-    if (parked === 0) {
+    const triage = listTasks(db, workstream, { substate: "triage" }).length;
+    if (parked === 0 && triage === 0) {
       console.log(pc.dim("(no ready tasks)"));
       return;
     }
-    console.log(pc.dim(`(no ready tasks; ${parked} parked)`));
+    const held = [parked > 0 ? `${parked} parked` : "", triage > 0 ? `${triage} in triage` : ""].filter(Boolean).join(", ");
+    console.log(pc.dim(`(no ready tasks; ${held})`));
     printNextSteps([
-      {
-        intent: "List parked tasks",
-        command: `mu task list --substate parked -w ${workstream}`
-      }
+      ...triage > 0 ? [
+        {
+          intent: "Triage findings",
+          command: `mu task list --substate triage -w ${workstream}`
+        }
+      ] : [],
+      ...parked > 0 ? [
+        {
+          intent: "List parked tasks",
+          command: `mu task list --substate parked -w ${workstream}`
+        }
+      ] : []
     ]);
     return;
   }
@@ -19638,7 +19741,14 @@ async function cmdTaskClose(db, rawId, opts = {}) {
   const taskRow = getTask(db, localId, ws);
   const r = closeTask(db, localId, sdkOpts);
   if ("skipped" in r) {
+    const inTriage = r.blockingIds.filter((id) => getTask(db, id, ws)?.substate === "triage");
     const blockingNextSteps = [
+      ...inTriage.length > 0 ? [
+        {
+          intent: `Triage ${inTriage.length} blocking finding(s) (accept, or close --as rejected|duplicate)`,
+          command: `mu task list --substate triage -w ${ws}`
+        }
+      ] : [],
       {
         intent: "Watch the remaining blockers (returns when one closes)",
         command: `mu task wait ${r.blockingIds.join(" ")} -w ${ws} --first --any --on-stall exit`
@@ -19771,6 +19881,32 @@ async function cmdTaskPark(db, rawId, opts) {
   }
   printNextSteps(nextSteps3);
 }
+async function cmdTaskAccept(db, rawId, opts = {}) {
+  const { name: localId } = await resolveEntityRef(db, rawId, opts, "task");
+  assertTaskInWorkstream(db, localId, opts.workstream);
+  const ws = await resolveWorkstream(opts.workstream);
+  const sdkOpts = { workstream: ws };
+  if (opts.evidence !== void 0) sdkOpts.evidence = opts.evidence;
+  const r = acceptTask(db, localId, sdkOpts);
+  const nextSteps3 = [
+    {
+      intent: "Claim it",
+      command: `mu task claim ${localId} -w ${ws}  (--self / --for <worker>)`
+    },
+    { intent: "Triage the next one", command: `mu task list --substate triage -w ${ws}` }
+  ];
+  if (opts.json) {
+    emitJson({ taskName: localId, ...r, nextSteps: nextSteps3 });
+    return;
+  }
+  if (!r.changed) {
+    const pair = formatPair({ status: r.status, substate: r.substate });
+    console.log(pc.dim(`${localId} is ${pair}, not in triage (no-op)`));
+  } else {
+    console.log(`Accepted ${pc.bold(localId)} ${pc.dim(`(${transition(r)})`)}`);
+  }
+  printNextSteps(nextSteps3);
+}
 async function cmdTaskUnpark(db, rawId, opts = {}) {
   const { name: localId } = await resolveEntityRef(db, rawId, opts, "task");
   assertTaskInWorkstream(db, localId, opts.workstream);
@@ -19849,7 +19985,10 @@ function wireTaskCommands(program) {
   ).requiredOption("-t, --title <title>", "task title").requiredOption("-i, --impact <n>", "impact 1..100", parseImpact).requiredOption("-e, --effort-days <days>", "effort in days (>0)", parsePositiveNumber).option(
     "-b, --blocked-by <ids...>",
     "task ids that block this one (repeat or comma-separate; or both)"
-  ).option("--note <text>", "append an initial note after creating the task").option("--note-author <name>", "author label for --note (default: current actor)").option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(id) {
+  ).option("--note <text>", "append an initial note after creating the task").option("--note-author <name>", "author label for --note (default: current actor)").option(
+    "--triage",
+    "start as OPEN/triage: a proposal (e.g. a review finding) kept out of next/claim until `mu task accept`"
+  ).option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(id) {
     const opts = this.opts();
     return handle((db) => cmdTaskAdd(db, id, opts), this)();
   });
@@ -19954,6 +20093,12 @@ function wireTaskCommands(program) {
     const opts = this.opts();
     return handle((db) => cmdTaskPark(db, id, opts), this)();
   });
+  task.command("accept <id>").description(
+    "Accept an OPEN/triage task (a proposed finding) as work: OPEN/todo, back in `next`. No-op on any other state. Decline with `close --as rejected|duplicate --why`."
+  ).option(...WORKSTREAM_OPT).option(...EVIDENCE_OPT).option(...JSON_OPT).action(function(id) {
+    const opts = this.opts();
+    return handle((db) => cmdTaskAccept(db, id, opts), this)();
+  });
   task.command("unpark <id>").description("Return a parked task to OPEN (back in `next`). No-op on any other state.").option(...WORKSTREAM_OPT).option(...EVIDENCE_OPT).option(...JSON_OPT).action(function(id) {
     const opts = this.opts();
     return handle((db) => cmdTaskUnpark(db, id, opts), this)();
@@ -19978,7 +20123,7 @@ function wireTaskCommands(program) {
   ).option(
     "--actor <name>",
     "override the actor name used for the log (only valid with --self; defaults to pane title or $USER)"
-  ).option("--force", "claim even when the task is parked (OPEN/parked)").option(
+  ).option("--force", "claim even when the task is parked or in triage (OPEN/parked, OPEN/triage)").option(
     "--strict-staleness",
     "refuse --for dispatch when the target agent's workspace is stale (default: warn and proceed)"
   ).option(...WORKSTREAM_OPT).option(...EVIDENCE_OPT).option(...JSON_OPT).action(function(taskId) {
@@ -20541,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
@@ -20750,124 +20896,424 @@ 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";
-init_output();
-
-// src/cli/handle.ts
-init_agents();
-init_db();
-init_drift();
-init_link();
-init_logs();
-init_mux2();
-init_output();
-init_rebuild();
-init_sync();
-init_tasks();
-import { CommanderError } from "commander";
 
-// src/undo.ts
-init_apply();
-init_db();
+// src/compact.ts
 init_legacy_ops();
-init_logs();
-init_op_context();
-init_status();
-var UndoGroupNotFoundError = class extends Error {
-  constructor(groupId) {
-    super(`no ops found for group ${JSON.stringify(groupId)}`);
-    this.groupId = groupId;
-    this.name = "UndoGroupNotFoundError";
-  }
-  groupId;
-  errorNextSteps() {
-    return [
-      { intent: "List recent undoable groups", command: "mu undo" },
-      { intent: "Inspect a group's ops", command: "mu log --group <id>" }
-    ];
-  }
-};
-var NothingToUndoError = class extends Error {
-  constructor() {
-    super("the ops log is empty; nothing to undo");
-    this.name = "NothingToUndoError";
+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" });
   }
-  errorNextSteps() {
-    return [{ intent: "Make a change first", command: "mu task add <id> -t <title>" }];
+  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 [];
   }
-};
-var UndoSupersededError = class extends Error {
-  constructor(groupId, conflicts) {
-    const shown = conflicts.slice(0, 5).map((c) => `${c.key}.${c.field} (changed by ${c.groupId.slice(0, 8)})`).join(", ");
-    super(
-      `group ${groupId.slice(0, 8)} has been superseded: ${conflicts.length} field(s) were changed by a later action \u2014 ${shown}. Undoing would discard that newer work.`
-    );
-    this.groupId = groupId;
-    this.conflicts = conflicts;
-    this.name = "UndoSupersededError";
+}
+function exists(path2) {
+  try {
+    statSync2(path2);
+    return true;
+  } catch {
+    return false;
   }
-  groupId;
-  conflicts;
-  errorNextSteps() {
-    return [
-      {
-        intent: "Inspect what changed since",
-        command: `mu log --group ${this.groupId.slice(0, 8)}`
-      },
-      {
-        intent: "Undo anyway, discarding the newer edits",
-        command: `mu undo ${this.groupId.slice(0, 8)} --yes --force`
-      }
-    ];
+}
+function sizeOf(path2) {
+  try {
+    return statSync2(path2).size;
+  } catch {
+    return 0;
   }
-};
-var ENTITY_RESTORE_ORDER = {
-  workstream: 0,
-  task: 1,
-  note: 2,
-  edge: 2
-};
-function restoreRank(entity) {
-  return ENTITY_RESTORE_ORDER[entity] ?? 3;
 }
-function priorFieldValue(db, entity, key, hlc, field) {
-  const row2 = db.prepare(
-    `SELECT json_extract(payload, '$.' || @field) AS value
-         FROM ops
-        WHERE entity = @entity
-          AND key    = @key
-          AND op     = 'put'
-          AND hlc    < @hlc
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-          AND json_type(payload, '$.' || @field) IS NOT NULL
-        ORDER BY hlc DESC
-        LIMIT 1`
-  ).get({ entity, key, hlc, field });
-  if (row2 === void 0) return { found: false };
-  return { found: true, value: row2.value };
+function findMissingWorkspaceDirs(db) {
+  return listWorkspaces2(db).filter((row2) => !exists(row2.path)).map((row2) => ({
+    agentName: row2.agentName,
+    workstreamName: row2.workstreamName,
+    path: row2.path
+  }));
 }
-function laterWriters(db, entity, key, hlc, field, excludeGroup) {
-  return db.prepare(
-    `SELECT DISTINCT group_id AS groupId, intent
-         FROM ops
-        WHERE entity   = @entity
-          AND key      = @key
-          AND op       = 'put'
-          AND hlc      > @hlc
-          AND group_id <> @excludeGroup
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-          AND json_type(payload, '$.' || @field) IS NOT NULL`
-  ).all({ entity, key, hlc, field, excludeGroup });
+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 laterRowWriters(db, entity, key, hlc, excludeGroup) {
-  return db.prepare(
-    `SELECT DISTINCT group_id AS groupId, intent
-         FROM ops
-        WHERE entity   = @entity
-          AND key      = @key
-          AND op       = 'put'
-          AND hlc      > @hlc
+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
+init_agents();
+init_db();
+init_drift();
+init_link();
+init_logs();
+init_mux2();
+init_output();
+init_rebuild();
+init_sync();
+init_tasks();
+import { CommanderError } from "commander";
+
+// src/undo.ts
+init_apply();
+init_db();
+init_legacy_ops();
+init_logs();
+init_op_context();
+init_status();
+var UndoGroupNotFoundError = class extends Error {
+  constructor(groupId) {
+    super(`no ops found for group ${JSON.stringify(groupId)}`);
+    this.groupId = groupId;
+    this.name = "UndoGroupNotFoundError";
+  }
+  groupId;
+  errorNextSteps() {
+    return [
+      { intent: "List recent undoable groups", command: "mu undo" },
+      { intent: "Inspect a group's ops", command: "mu log --group <id>" }
+    ];
+  }
+};
+var NothingToUndoError = class extends Error {
+  constructor() {
+    super("the ops log is empty; nothing to undo");
+    this.name = "NothingToUndoError";
+  }
+  errorNextSteps() {
+    return [{ intent: "Make a change first", command: "mu task add <id> -t <title>" }];
+  }
+};
+var UndoSupersededError = class extends Error {
+  constructor(groupId, conflicts) {
+    const shown = conflicts.slice(0, 5).map((c) => `${c.key}.${c.field} (changed by ${c.groupId.slice(0, 8)})`).join(", ");
+    super(
+      `group ${groupId.slice(0, 8)} has been superseded: ${conflicts.length} field(s) were changed by a later action \u2014 ${shown}. Undoing would discard that newer work.`
+    );
+    this.groupId = groupId;
+    this.conflicts = conflicts;
+    this.name = "UndoSupersededError";
+  }
+  groupId;
+  conflicts;
+  errorNextSteps() {
+    return [
+      {
+        intent: "Inspect what changed since",
+        command: `mu log --group ${this.groupId.slice(0, 8)}`
+      },
+      {
+        intent: "Undo anyway, discarding the newer edits",
+        command: `mu undo ${this.groupId.slice(0, 8)} --yes --force`
+      }
+    ];
+  }
+};
+var ENTITY_RESTORE_ORDER = {
+  workstream: 0,
+  task: 1,
+  note: 2,
+  edge: 2
+};
+function restoreRank(entity) {
+  return ENTITY_RESTORE_ORDER[entity] ?? 3;
+}
+function priorFieldValue(db, entity, key, hlc, field) {
+  const row2 = db.prepare(
+    `SELECT json_extract(payload, '$.' || @field) AS value
+         FROM ops
+        WHERE entity = @entity
+          AND key    = @key
+          AND op     = 'put'
+          AND hlc    < @hlc
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+          AND json_type(payload, '$.' || @field) IS NOT NULL
+        ORDER BY hlc DESC
+        LIMIT 1`
+  ).get({ entity, key, hlc, field });
+  if (row2 === void 0) return { found: false };
+  return { found: true, value: row2.value };
+}
+function laterWriters(db, entity, key, hlc, field, excludeGroup) {
+  return db.prepare(
+    `SELECT DISTINCT group_id AS groupId, intent
+         FROM ops
+        WHERE entity   = @entity
+          AND key      = @key
+          AND op       = 'put'
+          AND hlc      > @hlc
+          AND group_id <> @excludeGroup
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+          AND json_type(payload, '$.' || @field) IS NOT NULL`
+  ).all({ entity, key, hlc, field, excludeGroup });
+}
+function laterRowWriters(db, entity, key, hlc, excludeGroup) {
+  return db.prepare(
+    `SELECT DISTINCT group_id AS groupId, intent
+         FROM ops
+        WHERE entity   = @entity
+          AND key      = @key
+          AND op       = 'put'
+          AND hlc      > @hlc
           AND group_id <> @excludeGroup
           AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}`
   ).all({ entity, key, hlc, excludeGroup });
@@ -21395,7 +21841,7 @@ function classifyError(err) {
   }
   if (err instanceof NameAmbiguousError || err instanceof AgentExistsError || err instanceof TaskExistsError || err instanceof TaskAlreadyOwnedError || // Substate refusals (ts_4): a missing --why, a park from the wrong
   // phase, a claim on a parked task, a pair outside TASK_SUBSTATES.
-  err instanceof SubstateReasonRequiredError || err instanceof TaskParkStateError || err instanceof TaskParkedError || err instanceof InvalidSubstateError || err instanceof TaskClaimStaleWorkspaceError || err instanceof TaskNotInWorkstreamError || err instanceof AgentNotInWorkstreamError || err instanceof CycleError || err instanceof CrossWorkstreamEdgeError || err instanceof WorkspaceExistsError || err instanceof WorkspacePathNotEmptyError || err instanceof WorkspacePreservedError || err instanceof HomeDirAsProjectRootError || err instanceof WorkspaceVcsRequiredError || err instanceof WorkspaceDirtyError || err instanceof ClaimerNotRegisteredError || err instanceof SchemaTooOldError || err instanceof SchemaTooNewError || err instanceof TaskIdInvalidError || err instanceof WorkstreamExistsError || // Rebuild refuses to overwrite an existing target or to write onto
+  err instanceof SubstateReasonRequiredError || err instanceof TaskParkStateError || err instanceof TaskParkedError || err instanceof TaskInTriageError || err instanceof InvalidSubstateError || err instanceof TaskClaimStaleWorkspaceError || err instanceof TaskNotInWorkstreamError || err instanceof AgentNotInWorkstreamError || err instanceof CycleError || err instanceof CrossWorkstreamEdgeError || err instanceof WorkspaceExistsError || err instanceof WorkspacePathNotEmptyError || err instanceof WorkspacePreservedError || err instanceof HomeDirAsProjectRootError || err instanceof WorkspaceVcsRequiredError || err instanceof WorkspaceDirtyError || err instanceof ClaimerNotRegisteredError || err instanceof SchemaTooOldError || err instanceof SchemaTooNewError || err instanceof TaskIdInvalidError || err instanceof WorkstreamExistsError || // Rebuild refuses to overwrite an existing target or to write onto
   // the source DB: both are name/state collisions, not usage errors.
   err instanceof RebuildTargetExistsError || err instanceof RebuildTargetIsSourceError || // An abbreviated group id matching several groups: the operator must
   // disambiguate. Guessing would be catastrophic for `mu undo`.
@@ -21499,315 +21945,196 @@ function handle(fn, command, opts) {
       if (ambient) await ambientIngest(db);
       await fn(db);
     } catch (err) {
-      exitCode = emitError(err);
-    } finally {
-      activeCommand = void 0;
-      if (ambient && db !== void 0) {
-        try {
-          await ambientFlush(db);
-        } catch {
-        }
-      }
-      try {
-        db?.close();
-      } catch {
-      }
-    }
-    if (exitCode !== void 0) process.exit(exitCode);
-  };
-}
-function emitParseError(err, failingCommand) {
-  activeCommand = failingCommand;
-  try {
-    return emitError(err);
-  } finally {
-    activeCommand = void 0;
-  }
-}
-function findCommandForArgv(root, argv) {
-  let cur = root;
-  for (const t of argv) {
-    if (t.startsWith("-")) break;
-    const next = cur.commands.find(
-      (c) => c.name() === t || (c.aliases().includes(t) ?? false)
-    );
-    if (!next) break;
-    cur = next;
-  }
-  return cur;
-}
-
-// src/cli/db.ts
-function cmdDbBackup(db, file, opts = {}) {
-  const target = resolve7(file);
-  if (existsSync16(target)) {
-    throw new UsageError(`${target} already exists: mu db backup never overwrites`);
-  }
-  mkdirSync6(dirname13(target), { recursive: true });
-  db.prepare("VACUUM INTO ?").run(target);
-  const nextSteps3 = [
-    {
-      intent: "Inspect the copy without touching the live DB",
-      command: `MU_DB_PATH=${target} mu state`
-    },
-    { intent: "Disaster recovery is a rebuild, not a copy", command: "mu rebuild <file>" }
-  ];
-  if (opts.json === true) {
-    emitJson({ path: target, nextSteps: nextSteps3 });
-    return;
-  }
-  console.log(`Backed up to ${pc.bold(target)}`);
-  printNextSteps(nextSteps3);
-}
-function wireDbCommands(program) {
-  const dbCmd = program.command("db").description("Whole-DB file commands");
-  dbCmd.command("backup <file>").description(
-    "VACUUM INTO copy of the whole DB \u2014 the 'one file I can scp' convenience. Never overwrites. Real disaster recovery is `mu rebuild`."
-  ).option(...JSON_OPT).action(function(file) {
-    const opts = this.opts();
-    return handle(async (db) => cmdDbBackup(db, file, 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}`)
-    ]
+      exitCode = emitError(err);
+    } finally {
+      activeCommand = void 0;
+      if (ambient && db !== void 0) {
+        try {
+          await ambientFlush(db);
+        } catch {
+        }
+      }
+      try {
+        db?.close();
+      } catch {
+      }
+    }
+    if (exitCode !== void 0) process.exit(exitCode);
   };
 }
-function checkWorkspaceOrphanDirs(db) {
-  const orphans = listAllOrphanWorkspaces(db);
-  if (orphans.length === 0) {
-    return { name: "ws-dirs", severity: "ok", detail: "no orphan workspace dirs" };
+function emitParseError(err, failingCommand) {
+  activeCommand = failingCommand;
+  try {
+    return emitError(err);
+  } finally {
+    activeCommand = void 0;
   }
-  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" };
+function findCommandForArgv(root, argv) {
+  let cur = root;
+  for (const t of argv) {
+    if (t.startsWith("-")) break;
+    const next = cur.commands.find(
+      (c) => c.name() === t || (c.aliases().includes(t) ?? false)
+    );
+    if (!next) break;
+    cur = next;
   }
-  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)}`)
-    ]
-  };
+  return cur;
 }
-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 [];
+
+// src/cli/db.ts
+function cmdDbBackup(db, file, opts = {}) {
+  const target = resolve7(file);
+  if (existsSync16(target)) {
+    throw new UsageError(`${target} already exists: mu db backup never overwrites`);
   }
-  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" };
+  mkdirSync6(dirname13(target), { recursive: true });
+  db.prepare("VACUUM INTO ?").run(target);
+  const nextSteps3 = [
+    {
+      intent: "Inspect the copy without touching the live DB",
+      command: `MU_DB_PATH=${target} mu state`
+    },
+    { intent: "Disaster recovery is a rebuild, not a copy", command: "mu rebuild <file>" }
+  ];
+  if (opts.json === true) {
+    emitJson({ path: target, nextSteps: nextSteps3 });
+    return;
   }
-  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"
-    ]
-  };
+  console.log(`Backed up to ${pc.bold(target)}`);
+  printNextSteps(nextSteps3);
 }
-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" };
+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 {
-    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}`
-    ]
-  };
+  return { before, after };
 }
-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 {
+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;
   }
-  if (stale.length === 0) {
-    return { name: "locks", severity: "ok", detail: "no stale lock dirs" };
+  const backup = backupBeside(db, "compact");
+  compact(db);
+  const size = vacuumAndCheck(db, backup);
+  if (opts.json === true) {
+    emitJson({ dryRun: false, ...plan, backup, ...size });
+    return;
   }
-  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;
+  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;
   }
-  for (const entry of entries) {
-    const child = join13(path2, entry.name);
-    if (entry.isDirectory()) total += walkBytes(child);
-    else if (entry.isFile()) total += sizeOf(child);
+  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;
   }
-  return total;
+  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 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 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)
+  };
 }
-function checkDiskRecon(db) {
-  return [
-    checkMissingWorkspaceDirs(db),
-    checkWorkspaceOrphanDirs(db),
-    checkEmptyWorkstreamDirs(),
-    checkStrayDbFiles(),
-    checkRemovedExportsDir(),
-    checkStaleLocks()
-  ];
+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(
+    "VACUUM INTO copy of the whole DB \u2014 the 'one file I can scp' convenience. Never overwrites. Real disaster recovery is `mu rebuild`."
+  ).option(...JSON_OPT).action(function(file) {
+    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();
 init_doctor_summary();
 
 // src/dormant.ts
@@ -22136,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();
@@ -22283,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;
@@ -23020,6 +23373,7 @@ function fullJsonShape(d) {
     orphans: d.view.orphans,
     tracks: d.tracks,
     ready: withRoiAll(d.ready),
+    triage: withRoiAll(d.triage),
     inProgress: withRoiAll(d.inProgress),
     blocked: withRoiAll(d.blocked),
     recentClosed: withRoiAll(d.recentClosed),
@@ -23092,6 +23446,7 @@ async function cmdState(db, opts) {
   }
   renderFullMode(perWs);
 }
+var BIG_WORKSTREAM_TASKS = 300;
 function renderFullMode(perWs) {
   perWs.forEach((d, i) => {
     if (i > 0) console.log("");
@@ -23124,6 +23479,15 @@ function renderFullCard(d) {
       );
     }
   }
+  const total = d.taskCount;
+  const open = ready.length + inProgress.length + blocked.length + d.triage.length;
+  if (total >= BIG_WORKSTREAM_TASKS && open * 10 < total) {
+    console.log(
+      pc.dim(
+        `hint: ${total} tasks, ${open} open; start the next effort in a new <project>-<purpose> workstream`
+      )
+    );
+  }
   console.log("");
   console.log(pc.bold(`Tracks (${tracks.length})`));
   console.log(formatTracks(tracks));
@@ -23131,6 +23495,13 @@ function renderFullCard(d) {
   console.log(pc.bold(`Ready (${ready.length})`));
   console.log(ready.length === 0 ? pc.dim("  (none)") : formatTaskListTable(ready));
   console.log("");
+  if (d.triage.length > 0) {
+    console.log(
+      `${pc.bold(`Triage (${d.triage.length})`)} ${pc.dim(`accept: mu task accept <id> -w ${workstreamName} \xB7 decline: mu task close <id> --as rejected|duplicate --why ...`)}`
+    );
+    console.log(formatTaskListTable(d.triage));
+    console.log("");
+  }
   console.log(pc.bold(`In progress (${inProgress.length})`));
   console.log(inProgress.length === 0 ? pc.dim("  (none)") : formatTaskListTable(inProgress));
   console.log("");
@@ -23736,6 +24107,7 @@ function wireWorkspaceCommands(program) {
 }
 
 // src/cli/workstream.ts
+import { basename as basename2 } from "path";
 init_mux2();
 init_output();
 init_workstream();
@@ -23764,6 +24136,7 @@ async function cmdInit(db, name, opts = {}) {
   await mux.enableMuPaneBordersForSession(sessionName).catch(() => {
   });
   const created = !sessionAlready || dbCreated;
+  const nameHint = name.includes("-") ? void 0 : `name workstreams <project>-<purpose> (e.g. ${projectGuess() ?? "repo"}-${name}); one per effort`;
   const nextSteps3 = [
     { intent: "Attach the session", command: mux.attachHint({ session: sessionName }) },
     {
@@ -23781,6 +24154,7 @@ async function cmdInit(db, name, opts = {}) {
       muxSessionAlreadyExisted: sessionAlready,
       dbRowAlreadyExisted: !dbCreated,
       muWindowRepaired,
+      ...nameHint && created ? { hint: nameHint } : {},
       nextSteps: nextSteps3
     });
     return;
@@ -23796,8 +24170,13 @@ async function cmdInit(db, name, opts = {}) {
     return;
   }
   console.log(`Created workstream ${pc.bold(name)} (mux session ${pc.bold(sessionName)})`);
+  if (nameHint && created) console.log(pc.dim(`hint: ${nameHint}`));
   printNextSteps(nextSteps3);
 }
+function projectGuess() {
+  const base = basename2(process.cwd()).toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[^a-z]+/, "").replace(/-+$/, "");
+  return base === "" ? void 0 : base;
+}
 async function cmdWorkstreamList(db, opts = {}) {
   if (opts.tornDown === true) {
     const gone = listTornDownWorkstreams(db);
@@ -24053,8 +24432,12 @@ function withPositionalWorkstream(opts, name) {
   return { ...opts, workstream: name };
 }
 function wireWorkstreamCommands(program) {
-  const workstream = program.command("workstream").description("Workstream-level commands");
-  workstream.command("init <name>").description("Create the workstream's mux session and register it in the DB").option(...JSON_OPT).action(function(name) {
+  const workstream = program.command("workstream").description(
+    "Workstream-level commands. Name them <project>-<purpose> (hail-auth), one per effort; tear down when it ships. Reviews nobody will track belong in scratch delegates, not a workstream."
+  );
+  workstream.command("init <name>").description(
+    "Create the workstream's mux session and register it in the DB. Name it <project>-<purpose>."
+  ).option(...JSON_OPT).action(function(name) {
     const opts = this.opts();
     return handle((db) => cmdInit(db, name, opts), this)();
   });