@martintrojer/mu 0.4.0 → 0.4.1

package/dist/cli.js

@@ -10,8 +10,9 @@ var __export = (target, all) => {
 };
 
 // src/db.ts
+import { randomUUID } from "crypto";
 import { mkdirSync } from "fs";
-import { homedir } from "os";
+import { homedir, hostname } from "os";
 import { dirname, join, resolve } from "path";
 import Database from "better-sqlite3";
 function defaultStateDir() {
@@ -40,6 +41,7 @@ function openDb(options = {}) {
       throw new SchemaTooOldError(detectedVersion, MIN_ACCEPTED_SCHEMA_VERSION);
     }
     applySchema(db);
+    seedMachineIdentity(db);
   } else {
     db.pragma("foreign_keys = ON");
   }
@@ -76,6 +78,14 @@ function detectExistingSchemaVersion(db) {
   if (hasWorkstreams) return 1;
   return null;
 }
+function seedMachineIdentity(db) {
+  const row2 = db.prepare("SELECT COUNT(*) AS count FROM machine_identity").get();
+  if (row2.count !== 0) return;
+  db.prepare(
+    `INSERT OR IGNORE INTO machine_identity (id, machine_id, hostname, created_at)
+     VALUES (1, ?, ?, ?)`
+  ).run(randomUUID(), hostname(), (/* @__PURE__ */ new Date()).toISOString());
+}
 function applySchema(db) {
   const preBumpVersion = detectExistingSchemaVersion(db);
   db.exec(CURRENT_SCHEMA);
@@ -145,7 +155,7 @@ var init_db = __esm({
         ];
       }
     };
-    CURRENT_SCHEMA_VERSION = 7;
+    CURRENT_SCHEMA_VERSION = 8;
     MIN_ACCEPTED_SCHEMA_VERSION = 5;
     EXPECTED_TABLES = [
       "agent_logs",
@@ -155,12 +165,14 @@ var init_db = __esm({
       "archived_notes",
       "archived_tasks",
       "archives",
+      "machine_identity",
       "schema_version",
       "snapshots",
       "task_edges",
       "task_notes",
       "tasks",
       "vcs_workspaces",
+      "workstream_sync",
       "workstreams"
     ];
     READY_VIEW_SQL = `
@@ -212,6 +224,15 @@ CREATE TABLE IF NOT EXISTS schema_version (
   version INTEGER NOT NULL
 );
 
+-- machine_identity: one durable identity per DB/machine, seeded by
+-- openDb after schema creation. hostname is advisory only.
+CREATE TABLE IF NOT EXISTS machine_identity (
+  id         INTEGER PRIMARY KEY CHECK (id = 1),
+  machine_id TEXT NOT NULL,
+  hostname   TEXT,
+  created_at TEXT NOT NULL
+);
+
 -- \u2500\u2500\u2500 Tables \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\u2500\u2500\u2500\u2500\u2500\u2500
 
 -- workstreams: top of the hierarchy. name stays globally unique
@@ -223,6 +244,13 @@ CREATE TABLE IF NOT EXISTS workstreams (
   created_at  TEXT NOT NULL                  -- ISO 8601
 );
 
+-- workstream_sync: per-workstream cross-machine drift state. Rows are
+-- created on demand by db import/export code, not pre-seeded.
+CREATE TABLE IF NOT EXISTS workstream_sync (
+  workstream_id        INTEGER PRIMARY KEY REFERENCES workstreams (id) ON DELETE CASCADE,
+  last_known_peer_seqs TEXT NOT NULL DEFAULT '{}'
+);
+
 -- agents: one row per managed pane. Per-workstream unique on name.
 CREATE TABLE IF NOT EXISTS agents (
   id            INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -505,8 +533,8 @@ function listLogs(db, opts = {}) {
   const rows = db.prepare(sql).all(...params);
   return rows.map(rowFromDb);
 }
-function latestSeq(db) {
-  const row2 = db.prepare("SELECT MAX(seq) AS s FROM agent_logs").get();
+function latestSeq(db, workstreamId) {
+  const row2 = workstreamId === void 0 ? db.prepare("SELECT MAX(seq) AS s FROM agent_logs").get() : db.prepare("SELECT MAX(seq) AS s FROM agent_logs WHERE workstream_id = ?").get(workstreamId);
   return row2.s ?? 0;
 }
 function emitEvent(db, workstream, payload, source = "system") {
@@ -607,13 +635,13 @@ var init_logs = __esm({
       "workstream init",
       "workstream destroy",
       "workstream export",
-      "workstream import",
       // src/archives.ts — v6 archive verbs. Machine-wide events
       // (workstream=null) because archives outlive workstreams.
       "archive create",
       "archive delete",
       "archive add",
       "archive remove",
+      "archive restore",
       // src/exporting.ts — archive export emits the bucket-render summary
       // as a machine-wide event (workstream=null; the export spans every
       // source-ws in the archive).
@@ -2329,6 +2357,10 @@ ${scrollback.trim()}
             intent: "Or close + discard the workspace in one shot (lossy)",
             command: `mu agent close ${this.agentName} --discard-workspace`
           },
+          {
+            intent: "If the workstream was archived, restore task memory under a fresh name",
+            command: "mu archive restore <label> --as <new-workstream> --source <workstream>"
+          },
           {
             intent: "Or just inspect what's in the workspace",
             command: `cd ${this.workspacePath}`
@@ -4889,6 +4921,117 @@ var init_query = __esm({
   }
 });
 
+// src/archives/restore.ts
+function restoreArchive(db, label2, asWorkstream, opts = {}) {
+  const archiveId = resolveArchiveId(db, label2);
+  const sources = listSources(db, archiveId);
+  if (!isValidWorkstreamName(asWorkstream)) throw new WorkstreamNameInvalidError(asWorkstream);
+  const sourceWorkstream = opts.sourceWorkstream ?? sources[0];
+  if (sourceWorkstream === void 0) throw new ArchiveSourceAmbiguousError(label2, sources);
+  if (opts.sourceWorkstream === void 0 && sources.length > 1) {
+    throw new ArchiveSourceAmbiguousError(label2, sources);
+  }
+  if (opts.sourceWorkstream !== void 0 && !sources.includes(opts.sourceWorkstream)) {
+    throw new ArchiveSourceAmbiguousError(label2, sources);
+  }
+  if (tryResolveWorkstreamId(db, asWorkstream) !== null) {
+    throw new WorkstreamExistsError(asWorkstream);
+  }
+  captureSnapshot(db, `archive restore ${label2} as ${asWorkstream}`, null);
+  return db.transaction(() => {
+    ensureWorkstream(db, asWorkstream);
+    const wsId = resolveWorkstreamId(db, asWorkstream);
+    const restoredTasks = db.prepare(
+      `INSERT INTO tasks
+           (workstream_id, local_id, title, status, impact, effort_days, owner_id, created_at, updated_at)
+         SELECT ?, original_local_id, title, status, impact, effort_days, NULL,
+                original_created_at, original_updated_at
+           FROM archived_tasks
+          WHERE archive_id = ? AND source_workstream = ?
+          ORDER BY id`
+    ).run(wsId, archiveId, sourceWorkstream).changes;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const restoredEdges = db.prepare(
+      `INSERT OR IGNORE INTO task_edges (from_task_id, to_task_id, created_at)
+         SELECT live_from.id, live_to.id, ?
+           FROM archived_edges e
+           JOIN archived_tasks arch_from ON arch_from.id = e.from_archived_id
+           JOIN archived_tasks arch_to   ON arch_to.id   = e.to_archived_id
+           JOIN tasks live_from ON live_from.workstream_id = ?
+                               AND live_from.local_id = arch_from.original_local_id
+           JOIN tasks live_to   ON live_to.workstream_id = ?
+                               AND live_to.local_id = arch_to.original_local_id
+          WHERE e.archive_id = ?
+            AND arch_from.source_workstream = ?
+            AND arch_to.source_workstream = ?`
+    ).run(now, wsId, wsId, archiveId, sourceWorkstream, sourceWorkstream).changes;
+    const restoredNotes = db.prepare(
+      `INSERT INTO task_notes (task_id, author, content, created_at)
+         SELECT live.id, n.author, n.content, n.created_at
+           FROM archived_notes n
+           JOIN archived_tasks arch ON arch.id = n.archived_task_id
+           JOIN tasks live ON live.workstream_id = ?
+                          AND live.local_id = arch.original_local_id
+          WHERE n.archive_id = ? AND arch.source_workstream = ?
+          ORDER BY n.id`
+    ).run(wsId, archiveId, sourceWorkstream).changes;
+    emitEvent(
+      db,
+      asWorkstream,
+      `archive restore ${label2} source=${sourceWorkstream} as ${asWorkstream} (tasks=${restoredTasks}, edges=${restoredEdges}, notes=${restoredNotes})`
+    );
+    return {
+      archiveLabel: label2,
+      sourceWorkstream,
+      workstreamName: asWorkstream,
+      restoredTasks,
+      restoredEdges,
+      restoredNotes
+    };
+  })();
+}
+function listSources(db, archiveId) {
+  return db.prepare(
+    `SELECT source_workstream AS name
+           FROM archived_tasks
+          WHERE archive_id = ?
+          GROUP BY source_workstream
+          ORDER BY source_workstream`
+  ).all(archiveId).map((row2) => row2.name);
+}
+var ArchiveSourceAmbiguousError;
+var init_restore2 = __esm({
+  "src/archives/restore.ts"() {
+    "use strict";
+    init_db();
+    init_logs();
+    init_snapshots();
+    init_workstream();
+    init_core4();
+    ArchiveSourceAmbiguousError = class extends Error {
+      constructor(label2, sources) {
+        super(
+          sources.length === 0 ? `archive ${label2} contains no source workstreams` : `archive ${label2} requires --source <orig-ws-name>. Available: ${sources.join(", ")}`
+        );
+        this.label = label2;
+        this.sources = sources;
+      }
+      label;
+      sources;
+      name = "ArchiveSourceAmbiguousError";
+      errorNextSteps() {
+        return [
+          { intent: "Inspect archive sources", command: `mu archive show ${this.label}` },
+          ...this.sources.map((source) => ({
+            intent: `Restore source workstream ${source}`,
+            command: `mu archive restore ${this.label} --source ${source} --as <new-workstream>`
+          }))
+        ];
+      }
+    };
+  }
+});
+
 // src/archives.ts
 var init_archives = __esm({
   "src/archives.ts"() {
@@ -4897,6 +5040,7 @@ var init_archives = __esm({
     init_core4();
     init_delete();
     init_query();
+    init_restore2();
   }
 });
 
@@ -5717,7 +5861,7 @@ function exportWorkstream(db, opts) {
     source: sourceManifest
   };
 }
-var WORKSTREAM_NAME_RE, RESERVED_WORKSTREAM_PREFIX, WorkstreamNameInvalidError;
+var WORKSTREAM_NAME_RE, RESERVED_WORKSTREAM_PREFIX, WorkstreamExistsError, WorkstreamNameInvalidError;
 var init_workstream = __esm({
   "src/workstream.ts"() {
     "use strict";
@@ -5730,6 +5874,27 @@ var init_workstream = __esm({
     init_workspace();
     WORKSTREAM_NAME_RE = /^[a-z][a-z0-9_-]{0,31}$/;
     RESERVED_WORKSTREAM_PREFIX = "mu-";
+    WorkstreamExistsError = class extends Error {
+      constructor(workstream) {
+        super(`workstream already exists: ${workstream}`);
+        this.workstream = workstream;
+      }
+      workstream;
+      name = "WorkstreamExistsError";
+      errorNextSteps() {
+        return [
+          {
+            intent: "Pick a different workstream name",
+            command: "mu archive restore <label> --as <new-name>"
+          },
+          { intent: "List existing workstreams", command: "mu workstream list" },
+          {
+            intent: "Destroy the existing workstream first",
+            command: `mu workstream destroy -w ${this.workstream} --yes`
+          }
+        ];
+      }
+    };
     WorkstreamNameInvalidError = class extends Error {
       constructor(attempted) {
         const reason = attempted.startsWith(RESERVED_WORKSTREAM_PREFIX) ? `the 'mu-' prefix is reserved (mu auto-prepends 'mu-' to derive the tmux session name; '${attempted}' would produce session 'mu-${attempted}', which is double-prefixed and almost never what you want). Drop the 'mu-' from the workstream name.` : `must match /^[a-z][a-z0-9_-]{0,31}$/. tmux silently rewrites '.' to '_' and reserves ':' as a target separator, so workstream names containing those characters would create tmux sessions mu couldn't look up afterwards. Use letters, digits, '_', and '-' only.`;
@@ -6882,6 +7047,7 @@ var init_agents = __esm({
 });
 
 // src/dag.ts
+import pc2 from "picocolors";
 function loadFullDag(db, workstream, opts = {}) {
   const tasks = listTasks(db, workstream).filter(
     (t) => opts.statuses === void 0 || opts.statuses.has(t.status)
@@ -6920,7 +7086,7 @@ function renderForest(roots, edges, statusFn, tasksByName, opts = {}) {
     if (!byName.has(root.name)) byName.set(root.name, root);
     const lines = [formatTreeNodeLabel(root, statusFn, opts)];
     if (seen.has(root.name)) {
-      lines[0] = `${lines[0]}  (\u21BB already shown above)`;
+      lines[0] = `${lines[0]}${RECURRENCE_MARKER}`;
     } else {
       seen.add(root.name);
       renderForestChildren(root.name, "", edges, byName, statusFn, seen, lines, opts);
@@ -6979,7 +7145,7 @@ function renderForestChildren(taskName, prefix, edges, byName, statusFn, seen, l
     }
     if (seen.has(childName)) {
       lines.push(
-        `${prefix}${branch}${formatTreeNodeLabel(child, statusFn, opts)}  (\u21BB already shown above)`
+        `${prefix}${branch}${formatTreeNodeLabel(child, statusFn, opts)}${RECURRENCE_MARKER}`
       );
       continue;
     }
@@ -6993,10 +7159,12 @@ function formatTreeNodeLabel(t, statusFn, opts = {}) {
   if (opts.includeTitle === false) return base;
   return `${base}  ${t.title}`;
 }
+var RECURRENCE_MARKER;
 var init_dag = __esm({
   "src/dag.ts"() {
     "use strict";
     init_tasks();
+    RECURRENCE_MARKER = `  ${pc2.dim("(\u21BB)")}`;
   }
 });
 
@@ -7450,14 +7618,14 @@ function agentStatusHistogram(agents) {
   return out;
 }
 function summarizeOwnedTasks(owned) {
-  const count = owned.length;
-  if (count === 0) return { bit: "\u2014", count: 0 };
-  if (count === 1) {
+  const count2 = owned.length;
+  if (count2 === 0) return { bit: "\u2014", count: 0 };
+  if (count2 === 1) {
     const only = owned[0];
     if (!only) return { bit: "\u2014", count: 0 };
     return { bit: only.name, count: 1, onlyTaskId: only.name };
   }
-  return { bit: `\u2295${count}`, count };
+  return { bit: `\u2295${count2}`, count: count2 };
 }
 var init_state = __esm({
   "src/state.ts"() {
@@ -9622,6 +9790,9 @@ var init_keymap_spec = __esm({
           row("/", "filter/search rows", ["/"]),
           row("Enter", "drill into focused row", ["Enter"]),
           row("y", "yank action for focused row", ["y"]),
+          row("l", "launch lazygit in the project root (Commits popup only; user-driven TUI escape)", [
+            "l"
+          ]),
           row("Shift 0-9", "switch numbered popup", ["Shift 0-9"]),
           row("Esc/q", "back to dashboard", ["Esc", "q"]),
           row("?", "toggle this overlay", ["?"])
@@ -11362,13 +11533,59 @@ var init_blocked2 = __esm({
   }
 });
 
-// src/cli/tui/tuicr.ts
+// src/cli/tui/lazygit.ts
 import { spawnSync } from "child_process";
-function runTuicrInteractive(opts, deps = {}) {
+function runLazygitInteractive(opts, deps = {}) {
   const run3 = deps.spawn ?? spawnSync;
   const write = deps.write ?? ((text2) => process.stdout.write(text2));
   const env = deps.env ?? process.env;
   let result = { ok: true };
+  try {
+    write(ALT_SCREEN_EXIT);
+    const r = run3("lazygit", [], {
+      cwd: opts.cwd,
+      stdio: "inherit",
+      env
+    });
+    if (r.error !== void 0) {
+      result = { ok: false, error: lazygitErrorMessage(r.error) };
+    } else if (typeof r.status === "number" && r.status !== 0) {
+      result = { ok: false, error: `lazygit exited ${r.status}` };
+    }
+  } catch (err) {
+    result = { ok: false, error: lazygitErrorMessage(err) };
+  } finally {
+    try {
+      write(ALT_SCREEN_ENTER);
+    } catch {
+    }
+  }
+  return result;
+}
+function lazygitErrorMessage(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return "lazygit not found \xB7 install from https://github.com/jesseduffield/lazygit";
+    }
+    return err.message.length > 0 ? err.message : String(err);
+  }
+  return String(err);
+}
+var init_lazygit = __esm({
+  "src/cli/tui/lazygit.ts"() {
+    "use strict";
+    init_escapes();
+  }
+});
+
+// src/cli/tui/tuicr.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function runTuicrInteractive(opts, deps = {}) {
+  const run3 = deps.spawn ?? spawnSync2;
+  const write = deps.write ?? ((text2) => process.stdout.write(text2));
+  const env = deps.env ?? process.env;
+  let result = { ok: true };
   try {
     write(ALT_SCREEN_EXIT);
     const r = run3("tuicr", ["-r", opts.rev], {
@@ -11544,6 +11761,13 @@ function CommitsPopup({
         void yank2(showCommandForBackend(backendName, c.sha));
         return;
       }
+      case "verb":
+        if (action.key === "l") {
+          const r = runLazygitInteractive({ cwd: projectRoot });
+          if (!r.ok) onFooter?.(r.error ?? "lazygit failed", false, "error");
+          else onFooter?.("lazygit", true, "info");
+        }
+        return;
     }
   };
   usePopupActionQueue(popupActions, dispatchListAction);
@@ -11589,7 +11813,7 @@ function CommitsPopup({
     PopupShell,
     {
       title: `Commits \xB7 ${formatBackend2(backendName)} (${safeCursor + 1}/${commits.length})`,
-      hint: "y yanks VCS show command",
+      hint: "y yanks VCS show command \xB7 l lazygit",
       children: [
         /* @__PURE__ */ jsx25(Box11, { flexDirection: "column", flexGrow: 1, children: visible.map((c, i) => {
           const row2 = rows[i];
@@ -11646,6 +11870,7 @@ var init_commits2 = __esm({
     init_vcs2();
     init_columns();
     init_keys();
+    init_lazygit();
     init_list_row();
     init_popup_shell();
     init_tuicr();
@@ -13928,8 +14153,8 @@ function rowWidth(workstreams, active, indexes, leftHidden, rightHidden, showHin
 function chromeWidth(leftHidden, rightHidden, showHint) {
   return stringWidth4(PREFIX) + counterWidth("\u2039", leftHidden) + counterWidth("\u203A", rightHidden) + (showHint ? stringWidth4(leftHidden > 0 || rightHidden > 0 ? NARROW_HINT : WIDE_HINT) : 0);
 }
-function counterWidth(prefix, count) {
-  return count > 0 ? stringWidth4(`${prefix}${count} `) : 0;
+function counterWidth(prefix, count2) {
+  return count2 > 0 ? stringWidth4(`${prefix}${count2} `) : 0;
 }
 function truncateToWidth(text2, width) {
   if (width <= 0) return "";
@@ -14564,7 +14789,7 @@ var init_tui = __esm({
 init_agents();
 import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "fs";
 import { dirname as dirname7, join as join10 } from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commander";
 
 // src/cli/agents.ts
@@ -16443,9 +16668,15 @@ async function cmdArchiveAdd(db, label2, opts) {
       command: `mu archive add ${label2} -w ${workstream}`
     },
     {
-      intent: opts.destroy ? "Undo the destroy (DB only; tmux NOT rolled back)" : "Destroy the source workstream now that its memory is preserved",
-      command: opts.destroy ? "mu undo --yes" : `mu archive add ${label2} -w ${workstream} --destroy`
-    }
+      intent: opts.destroy ? "Restore the archived workstream under a fresh name" : "Destroy the source workstream now that its memory is preserved",
+      command: opts.destroy ? `mu archive restore ${label2} --as <new-workstream> --source ${workstream}` : `mu archive add ${label2} -w ${workstream} --destroy`
+    },
+    ...opts.destroy ? [
+      {
+        intent: "Undo the destroy (DB only; tmux NOT rolled back)",
+        command: "mu undo --yes"
+      }
+    ] : []
   ]);
 }
 async function cmdArchiveRemove(db, label2, opts) {
@@ -16471,6 +16702,35 @@ async function cmdArchiveRemove(db, label2, opts) {
     }
   ]);
 }
+async function cmdArchiveRestore(db, label2, opts = {}) {
+  if (!opts.as || opts.as.trim().length === 0) {
+    throw new UsageError("--as <new-ws-name> is required for `mu archive restore`");
+  }
+  const result = restoreArchive(db, label2, opts.as, {
+    sourceWorkstream: opts.source
+  });
+  const nextSteps = [
+    { intent: "Inspect restored tasks", command: `mu task list -w ${result.workstreamName}` },
+    { intent: "Undo (a snapshot was taken before the restore)", command: "mu undo --yes" }
+  ];
+  if (opts.json) {
+    emitJson({ ...result, nextSteps });
+    return;
+  }
+  console.log(
+    `Restored archive ${pc.bold(label2)} source ${pc.bold(result.sourceWorkstream)} as workstream ${pc.bold(
+      result.workstreamName
+    )} ${pc.dim(
+      `(tasks=${result.restoredTasks}, edges=${result.restoredEdges}, notes=${result.restoredNotes})`
+    )}`
+  );
+  console.log(
+    pc.dim(
+      "agents, workspace_path, and agent_logs are not restored (archives preserve task graph rows, not live panes or the live event log)."
+    )
+  );
+  printNextSteps(nextSteps);
+}
 async function cmdArchiveDelete(db, label2, opts = {}) {
   const summary = getArchive(db, label2);
   if (!opts.yes) {
@@ -16484,6 +16744,10 @@ async function cmdArchiveDelete(db, label2, opts = {}) {
           {
             intent: "Confirm and actually delete (a snapshot is taken first)",
             command: `mu archive delete ${label2} --yes`
+          },
+          {
+            intent: "Recover a source before deleting the archive",
+            command: `mu archive restore ${label2} --as <new-workstream> --source <workstream>`
           }
         ]
       });
@@ -16507,6 +16771,10 @@ async function cmdArchiveDelete(db, label2, opts = {}) {
         intent: "Confirm and actually delete",
         command: `mu archive delete ${label2} --yes`
       },
+      {
+        intent: "Recover a source before deleting the archive",
+        command: `mu archive restore ${label2} --as <new-workstream> --source <workstream>`
+      },
       {
         intent: "Surgically remove a single source workstream instead",
         command: `mu archive remove ${label2} -w <workstream>`
@@ -16524,7 +16792,7 @@ async function cmdArchiveDelete(db, label2, opts = {}) {
       removedTasks: summary.totalTasks,
       nextSteps: [
         {
-          intent: "Undo (a snapshot was taken before the delete)",
+          intent: "Recover the deleted archive (a snapshot was taken before the delete)",
           command: "mu undo --yes"
         }
       ]
@@ -16538,7 +16806,7 @@ async function cmdArchiveDelete(db, label2, opts = {}) {
   );
   printNextSteps([
     {
-      intent: "Undo (a snapshot was taken before the delete)",
+      intent: "Recover the deleted archive (a snapshot was taken before the delete)",
       command: "mu undo --yes"
     }
   ]);
@@ -16605,7 +16873,11 @@ async function cmdArchiveExport(db, label2, opts = {}) {
     0
   );
   const nextSteps = [
-    { intent: "Browse the bucket", command: `ls ${result.outDir}` },
+    { intent: "Browse the read-only human/git/docs bucket", command: `ls ${result.outDir}` },
+    {
+      intent: "Restore losslessly from the archive (not from this bucket)",
+      command: `mu archive restore ${label2} --as <new-workstream> --source <workstream>`
+    },
     {
       intent: "Re-export to refresh (additive; existing source-ws subdirs untouched)",
       command: `mu archive export ${label2} --out ${result.outDir}`
@@ -16635,6 +16907,11 @@ async function cmdArchiveExport(db, label2, opts = {}) {
       `(sources=${result.sourceCount}, tasks=${totalTasks}, written=${result.written}, unchanged=${result.unchanged}, preserved=${result.preserved})`
     )}`
   );
+  console.log(
+    pc.dim(
+      "This bucket is a read-only artifact for humans/git/docs; use `mu archive restore` for lossless un-archive."
+    )
+  );
   printNextSteps(nextSteps);
 }
 function wireArchiveCommands(program) {
@@ -16658,14 +16935,23 @@ function wireArchiveCommands(program) {
     return handle((db) => cmdArchiveShow(db, label2, opts), this)();
   });
   archive.command("add <label>").description(
-    "Snapshot a workstream's task graph (tasks + edges + notes + events) into an existing archive. Idempotent at (archive, source_workstream) granularity. With --destroy, cascades to `mu workstream destroy --yes` after the archive succeeds."
+    "Snapshot a workstream's task graph (tasks + edges + notes + events) into an existing archive. Idempotent at (archive, source_workstream) granularity. With --destroy, cascades to `mu workstream destroy --yes` after the archive succeeds; reverse with `mu archive restore <label> --as <new>`."
   ).option(...WORKSTREAM_OPT).option(
     "--destroy",
-    "After a successful archive, also destroy the source workstream (kills tmux + frees workspaces + cascade-deletes DB rows)."
+    "After a successful archive, also destroy the source workstream (kills tmux + frees workspaces + cascade-deletes DB rows). Recover later with `mu archive restore <label> --as <new>`."
   ).option(...JSON_OPT).action(function(label2) {
     const opts = this.optsWithGlobals();
     return handle((db) => cmdArchiveAdd(db, label2, opts), this)();
   });
+  archive.command("restore <label>").description(
+    "Restore one archived source workstream into a fresh workstream directly from archived_* tables. This is the lossless un-archive path; does not restore agents, workspace_path, or agent_logs (archives do not snapshot live panes or the live event log)."
+  ).requiredOption("--as <new-ws-name>", "fresh workstream name to create; refuses collisions").option(
+    "--source <orig-ws-name>",
+    "required when the archive contains multiple source workstreams"
+  ).option(...JSON_OPT).action(function(label2) {
+    const opts = this.opts();
+    return handle((db) => cmdArchiveRestore(db, label2, opts), this)();
+  });
   archive.command("remove <label>").description(
     "Surgically remove a single source workstream's contribution from an archive (rare; recovery). Other source workstreams' rows are untouched."
   ).option(...WORKSTREAM_OPT).option(...JSON_OPT).action(function(label2) {
@@ -16679,7 +16965,7 @@ function wireArchiveCommands(program) {
     return handle((db) => cmdArchiveSearch(db, pattern, opts), this)();
   });
   archive.command("export <label>").description(
-    "Render every source workstream in an archive to a bucket directory of markdown (one subdir per source-ws + bucket-level README/INDEX/manifest). Idempotent + additive: re-running refreshes only changed task files."
+    "Render every source workstream in an archive to a READ-ONLY bucket directory of markdown for humans/git/docs. Idempotent + additive: re-running refreshes only changed task files. For lossless un-archive, use `mu archive restore`."
   ).option("--out <dir>", "output directory (the bucket); required").option(...JSON_OPT).action(function(label2) {
     const opts = this.opts();
     return handle((db) => cmdArchiveExport(db, label2, opts), this)();
@@ -16692,81 +16978,1098 @@ function wireArchiveCommands(program) {
   });
 }
 
-// src/cli/doctor.ts
-init_agents();
+// src/db-sync.ts
 init_db();
-init_output();
-init_tmux();
-init_workstream();
-async function cmdDoctor(db, opts = {}) {
-  if (opts.json) {
-    return cmdDoctorJson(db);
+init_logs();
+init_snapshots();
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync2, unlinkSync as unlinkSync4, writeFileSync as writeFileSync2 } from "fs";
+import { hostname as hostname2 } from "os";
+import { dirname as dirname5, join as join8 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/db-sync-replay.ts
+init_db();
+init_snapshots();
+import { createHash as createHash2 } from "crypto";
+var DbReplayWorkstreamMissingError = class extends Error {
+  constructor(workstream) {
+    super(
+      `replay sidecar is for workstream "${workstream}", which does not exist locally; restore it first via mu db import or mu archive restore`
+    );
+    this.workstream = workstream;
   }
-  console.log(pc.bold("mu doctor"));
-  console.log(pc.bold("\nenvironment"));
+  workstream;
+  name = "DbReplayWorkstreamMissingError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Restore this workstream from a DB export",
+        command: "mu db import <file> --apply"
+      },
+      {
+        intent: "Or restore it from an archive",
+        command: `mu archive restore <label> --as ${this.workstream}`
+      }
+    ];
+  }
+};
+var DbReplayLocalIdConflictError = class extends Error {
+  constructor(workstream, conflicts) {
+    super(
+      `sidecar task id collides with different local content in ${workstream}: ${conflicts.map(
+        (c) => `${c.localId} (local: ${c.local.status} ${JSON.stringify(c.local.title)}; sidecar: ${c.sidecar.status} ${JSON.stringify(c.sidecar.title)})`
+      ).join(", ")}`
+    );
+    this.workstream = workstream;
+    this.conflicts = conflicts;
+  }
+  workstream;
+  conflicts;
+  name = "DbReplayLocalIdConflictError";
+  errorNextSteps() {
+    const first = this.conflicts[0];
+    return [
+      {
+        intent: "Create a renamed local task manually, then replay notes if desired",
+        command: first ? `mu task add ${first.localId}-replay -w ${this.workstream} -t ${shellQuote2(first.sidecar.title)} -i <impact> -e <effort>` : `mu task add <renamed-id> -w ${this.workstream} -t <title> -i <impact> -e <effort>`
+      },
+      {
+        intent: "Skip the colliding id and replay another task",
+        command: "mu db replay <sidecar> --task <other-id> --apply"
+      }
+    ];
+  }
+};
+function replayDb(db, file, opts = {}) {
+  const sidecarDb = openDb({ path: file, readonly: true });
   try {
-    const version = (await tmux(["-V"])).trim();
-    console.log(`  tmux             : ${pc.green("ok")} (${version})`);
-  } catch {
-    console.log(`  tmux             : ${pc.red("NOT FOUND")} \u2014 install tmux \u2265 3.0`);
+    const plan = buildReplayPlan(db, sidecarDb, file);
+    const taskFilter = new Set(opts.tasks ?? []);
+    const noteFilter = new Set(opts.notes ?? []);
+    const selectedTaskIds = opts.all === true ? new Set(plan.tasks.map((t) => t.localId)) : taskFilter;
+    const selectedNoteIds = opts.all === true ? new Set(plan.notes.map((n) => n.taskLocalId)) : noteFilter;
+    const hasSelectors = opts.all === true || selectedTaskIds.size > 0 || selectedNoteIds.size > 0;
+    const noteTaskIds = /* @__PURE__ */ new Set([...selectedNoteIds, ...selectedTaskIds]);
+    const hasWrites = plan.tasks.some((t) => selectedTaskIds.has(t.localId)) || plan.notes.some((n) => noteTaskIds.has(n.taskLocalId)) || plan.edges.some(
+      (e) => opts.all === true || selectedTaskIds.has(e.fromLocalId) || selectedTaskIds.has(e.toLocalId)
+    );
+    const relevantConflicts = opts.all === true ? plan.conflicts : plan.conflicts.filter((c) => selectedTaskIds.has(c.localId));
+    if (relevantConflicts.length > 0) {
+      throw new DbReplayLocalIdConflictError(plan.workstream, relevantConflicts);
+    }
+    if (opts.apply !== true || !hasSelectors) return replayResult(plan, true, false);
+    if (!hasWrites) return replayResult(plan, false, true);
+    const snapshot = captureSnapshot(db, `db replay ${file}`, null);
+    const applied = applyReplayPlan(db, plan, selectedTaskIds, selectedNoteIds, opts.all === true);
+    return { ...replayResult(plan, false, true), snapshotId: snapshot.id, ...applied };
+  } finally {
+    sidecarDb.close();
   }
-  console.log(`  $TMUX            : ${process.env.TMUX ? pc.green("set") : pc.yellow("not set")}`);
-  console.log(
-    `  $TMUX_PANE       : ${process.env.TMUX_PANE ? pc.green(process.env.TMUX_PANE) : pc.dim("not set")}`
-  );
-  console.log(
-    `  $MU_SESSION      : ${process.env.MU_SESSION ? pc.green(process.env.MU_SESSION) : pc.dim("not set")}`
+}
+function buildReplayPlan(localDb, sidecarDb, sourceFile) {
+  const sidecarWorkstreams = listLocalWorkstreams(sidecarDb);
+  const sidecarWs = sidecarWorkstreams[0];
+  if (sidecarWorkstreams.length !== 1 || !sidecarWs) {
+    throw new Error(
+      `replay sidecar must contain exactly one workstream; found ${sidecarWorkstreams.length}`
+    );
+  }
+  const localWs = listLocalWorkstreams(localDb).find((w) => w.name === sidecarWs.name);
+  if (!localWs) throw new DbReplayWorkstreamMissingError(sidecarWs.name);
+  const localTasks = new Map(
+    localDb.prepare("SELECT local_id, title, status FROM tasks WHERE workstream_id = ?").all(localWs.id).map((t) => [t.local_id, t])
   );
-  console.log(pc.bold("\ndb"));
-  console.log(`  path             : ${pc.dim(defaultDbPath())}`);
-  try {
-    const tables = db.prepare(
-      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
-    ).all().map((r) => r.name);
-    const missing = EXPECTED_TABLES.filter((t) => !tables.includes(t));
-    if (missing.length === 0) {
-      console.log(`  schema           : ${pc.green("ok")} (${EXPECTED_TABLES.length} tables)`);
-    } else {
-      console.log(`  schema           : ${pc.red("missing")} \u2014 ${missing.join(", ")}`);
+  const tasks = [];
+  const conflicts = [];
+  for (const task of listReplayTasks(sidecarDb, sidecarWs.id)) {
+    const local = localTasks.get(task.localId);
+    if (!local) tasks.push(task);
+    else if (local.title !== task.title || local.status !== task.status) {
+      conflicts.push({
+        localId: task.localId,
+        local: { title: local.title, status: local.status },
+        sidecar: { title: task.title, status: task.status }
+      });
     }
-    try {
-      const row2 = db.prepare("SELECT version FROM schema_version WHERE id = 1").get();
-      const v = row2?.version;
-      if (v === void 0) {
-        console.log(
-          `  schema_version   : ${pc.red("missing row")} (expected ${CURRENT_SCHEMA_VERSION})`
-        );
-      } else if (v === CURRENT_SCHEMA_VERSION) {
-        console.log(`  schema_version   : ${pc.green(String(v))}`);
-      } else if (v < CURRENT_SCHEMA_VERSION) {
-        console.log(
-          `  schema_version   : ${pc.yellow(String(v))} (code expects ${CURRENT_SCHEMA_VERSION}; openDb should have migrated)`
-        );
-      } else {
-        console.log(
-          `  schema_version   : ${pc.red(String(v))} (code expects ${CURRENT_SCHEMA_VERSION}; possible downgrade or future-version DB)`
-        );
-      }
-    } catch {
-      console.log(
-        `  schema_version   : ${pc.red("unreadable")} (schema_version table missing or wrong shape)`
+  }
+  const localNoteHashes = new Set(listReplayNotes(localDb, localWs.id).map((n) => n.hash));
+  const localEdges = new Set(listReplayEdges(localDb, localWs.id).map(edgeKey));
+  return {
+    sourceFile,
+    workstream: sidecarWs.name,
+    tasks,
+    notes: listReplayNotes(sidecarDb, sidecarWs.id).filter((n) => !localNoteHashes.has(n.hash)),
+    edges: listReplayEdges(sidecarDb, sidecarWs.id).filter((e) => !localEdges.has(edgeKey(e))),
+    conflicts
+  };
+}
+function applyReplayPlan(db, plan, selectedTaskIds, selectedNoteIds, replayAllEdges) {
+  const warnings = [];
+  const added = db.transaction(() => {
+    const wsId = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(plan.workstream)?.id;
+    if (wsId === void 0) throw new DbReplayWorkstreamMissingError(plan.workstream);
+    const taskIds = new Set(selectedTaskIds);
+    const noteTaskIds = /* @__PURE__ */ new Set([...selectedNoteIds, ...taskIds]);
+    let tasks = 0;
+    let notes = 0;
+    let edges = 0;
+    const insertTask = db.prepare(
+      `INSERT OR IGNORE INTO tasks (workstream_id, local_id, title, status, impact, effort_days, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const task of plan.tasks) {
+      if (!taskIds.has(task.localId)) continue;
+      const result = insertTask.run(
+        wsId,
+        task.localId,
+        task.title,
+        task.status,
+        task.impact,
+        task.effortDays,
+        task.createdAt,
+        task.updatedAt
       );
+      if (result.changes > 0) tasks += 1;
     }
-    const journal = db.pragma("journal_mode", { simple: true });
-    console.log(
-      `  journal_mode     : ${journal === "wal" ? pc.green(String(journal)) : pc.yellow(String(journal))}`
+    const existingNoteHashes = new Set(listReplayNotes(db, wsId).map((n) => n.hash));
+    const insertNote = db.prepare(
+      `INSERT INTO task_notes (task_id, author, content, created_at)
+       SELECT id, ?, ?, ? FROM tasks WHERE workstream_id = ? AND local_id = ?`
     );
-    const fk = db.pragma("foreign_keys", { simple: true });
-    console.log(`  foreign_keys     : ${fk === 1 ? pc.green("on") : pc.red(`off (${fk})`)}`);
-  } catch (err) {
-    console.log(
-      `  schema           : ${pc.red("FAIL")} \u2014 ${err instanceof Error ? err.message : err}`
+    for (const note of plan.notes) {
+      if (!noteTaskIds.has(note.taskLocalId) || existingNoteHashes.has(note.hash)) continue;
+      const result = insertNote.run(
+        note.author,
+        note.content,
+        note.createdAt,
+        wsId,
+        note.taskLocalId
+      );
+      if (result.changes > 0) {
+        notes += 1;
+        existingNoteHashes.add(note.hash);
+      }
+    }
+    const insertEdge = db.prepare(
+      `INSERT OR IGNORE INTO task_edges (from_task_id, to_task_id, created_at)
+       SELECT f.id, t.id, ?
+         FROM tasks f, tasks t
+        WHERE f.workstream_id = ? AND f.local_id = ?
+          AND t.workstream_id = ? AND t.local_id = ?`
     );
-  }
-  console.log(pc.bold("\nworkstream"));
-  let currentWorkstream = null;
-  try {
-    currentWorkstream = await resolveWorkstream();
+    for (const edge of plan.edges) {
+      if (!replayAllEdges && !taskIds.has(edge.fromLocalId) && !taskIds.has(edge.toLocalId)) {
+        continue;
+      }
+      if (!hasTask(db, wsId, edge.fromLocalId) || !hasTask(db, wsId, edge.toLocalId)) {
+        warnings.push(
+          `skipped edge ${edge.fromLocalId} -> ${edge.toLocalId}: one endpoint is missing locally`
+        );
+        continue;
+      }
+      const result = insertEdge.run(edge.createdAt, wsId, edge.fromLocalId, wsId, edge.toLocalId);
+      if (result.changes > 0) edges += 1;
+    }
+    return { tasks, notes, edges };
+  })();
+  return { added, warnings };
+}
+function replayResult(plan, dryRun, applied) {
+  return { ...plan, dryRun, applied, added: { tasks: 0, notes: 0, edges: 0 }, warnings: [] };
+}
+function listLocalWorkstreams(db) {
+  return db.prepare("SELECT id, name FROM workstreams ORDER BY name").all();
+}
+function listReplayTasks(db, wsId) {
+  return db.prepare(
+    `SELECT local_id, title, status, impact, effort_days, created_at, updated_at
+           FROM tasks
+          WHERE workstream_id = ?
+          ORDER BY local_id`
+  ).all(wsId).map((row2) => ({
+    localId: row2.local_id,
+    title: row2.title,
+    status: row2.status,
+    impact: row2.impact,
+    effortDays: row2.effort_days,
+    createdAt: row2.created_at,
+    updatedAt: row2.updated_at
+  }));
+}
+function listReplayNotes(db, wsId) {
+  const rows = db.prepare(
+    `SELECT t.local_id AS taskLocalId, n.author, n.content, n.created_at AS createdAt
+         FROM task_notes n
+         JOIN tasks t ON t.id = n.task_id
+        WHERE t.workstream_id = ?
+        ORDER BY n.created_at, n.id`
+  ).all(wsId);
+  return rows.map((row2) => ({ ...row2, hash: noteHash(row2) }));
+}
+function listReplayEdges(db, wsId) {
+  return db.prepare(
+    `SELECT f.local_id AS fromLocalId, t.local_id AS toLocalId, e.created_at AS createdAt
+         FROM task_edges e
+         JOIN tasks f ON f.id = e.from_task_id
+         JOIN tasks t ON t.id = e.to_task_id
+        WHERE f.workstream_id = ? AND t.workstream_id = ?
+        ORDER BY f.local_id, t.local_id`
+  ).all(wsId, wsId);
+}
+function noteHash(note) {
+  return createHash2("sha256").update(`${note.taskLocalId}\0${note.content}\0${note.createdAt}`).digest("hex");
+}
+function edgeKey(edge) {
+  return `${edge.fromLocalId}\0${edge.toLocalId}`;
+}
+function hasTask(db, wsId, localId) {
+  return db.prepare("SELECT 1 FROM tasks WHERE workstream_id = ? AND local_id = ?").get(wsId, localId) !== void 0;
+}
+function shellQuote2(s) {
+  return `'${s.replace(/'/g, `'"'"'`)}'`;
+}
+
+// src/db-sync.ts
+var DbExportTargetExistsError = class extends Error {
+  constructor(file) {
+    super(`DB export target already exists: ${file}`);
+    this.file = file;
+  }
+  file;
+  name = "DbExportTargetExistsError";
+  errorNextSteps() {
+    return [
+      { intent: "Choose a different target", command: "mu db export <new-file>" },
+      { intent: "Overwrite this target", command: `mu db export ${shellQuote3(this.file)} --force` }
+    ];
+  }
+};
+var DbImportManifestMissingError = class extends Error {
+  constructor(manifestPath) {
+    super(`DB import manifest not found: ${manifestPath}`);
+    this.manifestPath = manifestPath;
+  }
+  manifestPath;
+  name = "DbImportManifestMissingError";
+  errorNextSteps() {
+    return [
+      { intent: "Export the DB with its sidecar", command: "mu db export /tmp/mu.db --force" },
+      { intent: "Copy the sidecar too", command: `scp <host>:${shellQuote3(this.manifestPath)} .` }
+    ];
+  }
+};
+var DbImportSchemaTooOldError = class extends Error {
+  constructor(sourceVersion) {
+    super(
+      `source DB schema v${sourceVersion} is older than local mu requires (v${CURRENT_SCHEMA_VERSION})`
+    );
+    this.sourceVersion = sourceVersion;
+  }
+  sourceVersion;
+  name = "DbImportSchemaTooOldError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Upgrade mu on the source machine",
+        command: "npm run build && mu db export <file> --force"
+      },
+      { intent: "Then retry this import", command: "mu db import <file> --apply" }
+    ];
+  }
+};
+var DbImportSchemaTooNewError = class extends Error {
+  constructor(sourceVersion) {
+    super(
+      `source DB schema v${sourceVersion} is newer than this mu supports (v${CURRENT_SCHEMA_VERSION}); upgrade local mu`
+    );
+    this.sourceVersion = sourceVersion;
+  }
+  sourceVersion;
+  name = "DbImportSchemaTooNewError";
+  errorNextSteps() {
+    return [
+      { intent: "Upgrade local mu", command: "git pull && npm install && npm run build" },
+      { intent: "Then retry this import", command: "mu db import <file> --apply" }
+    ];
+  }
+};
+var DbImportSourceStaleError = class extends Error {
+  constructor(workstreams) {
+    super(`source DB is stale for local-ahead workstream(s): ${workstreams.join(", ")}`);
+    this.workstreams = workstreams;
+  }
+  workstreams;
+  name = "DbImportSourceStaleError";
+  errorNextSteps() {
+    return [
+      { intent: "Re-export from this machine", command: "mu db export /tmp/mu-fresh.db --force" },
+      { intent: "Dry-run the incoming file first", command: "mu db import <file>" }
+    ];
+  }
+};
+var DbImportConflictError = class extends Error {
+  constructor(workstreams) {
+    super(`source and local both advanced for workstream(s): ${workstreams.join(", ")}`);
+    this.workstreams = workstreams;
+  }
+  workstreams;
+  name = "DbImportConflictError";
+  errorNextSteps() {
+    return [
+      { intent: "Preview the conflicting workstreams", command: "mu db import <file> --json" },
+      {
+        intent: "Clobber from source after parking local divergence",
+        command: "mu db import <file> --apply --force-source"
+      }
+    ];
+  }
+};
+function exportDb(db, file, opts = {}) {
+  const target = file;
+  const manifestPath = `${target}.manifest.json`;
+  const targetExists = existsSync12(target);
+  if (targetExists && opts.force !== true) throw new DbExportTargetExistsError(target);
+  const manifest = buildExportManifest(db);
+  mkdirSync4(dirname5(target), { recursive: true });
+  try {
+    if (targetExists) unlinkSync4(target);
+    db.exec(`VACUUM INTO ${quoteSqlString2(target)}`);
+    writeFileSync2(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  } catch (err) {
+    try {
+      if (existsSync12(target)) unlinkSync4(target);
+    } catch {
+    }
+    throw err;
+  }
+  return { file: target, manifestPath, manifest, overwritten: targetExists };
+}
+function importDb(db, file, opts = {}) {
+  const manifest = readImportManifest(file);
+  assertImportSchemaCompatible(manifest.schemaVersion);
+  const sourceDb = openDb({ path: file, readonly: true });
+  try {
+    const summary = buildImportPlan(db, manifest, file, opts.onlyWorkstreams);
+    if (opts.apply !== true) {
+      return {
+        machineId: manifest.machineId,
+        sourceFile: file,
+        dryRun: true,
+        applied: false,
+        summary
+      };
+    }
+    const stale = summary.filter((s) => s.decision === "LOCAL_AHEAD").map((s) => s.workstream);
+    if (stale.length > 0) throw new DbImportSourceStaleError(stale);
+    const conflicts = summary.filter((s) => s.decision === "CONFLICT").map((s) => s.workstream);
+    if (conflicts.length > 0 && opts.forceSource !== true)
+      throw new DbImportConflictError(conflicts);
+    const mutating = summary.some((s) => shouldReplace(s.decision, opts.forceSource === true));
+    const snapshot = mutating ? captureSnapshot(db, `db import ${file}`, null) : void 0;
+    for (const item of summary) {
+      if (!shouldReplace(item.decision, opts.forceSource === true)) continue;
+      if (item.decision === "CONFLICT") {
+        item.parkPath = parkLocalWorkstream(db, item.workstream);
+      }
+      const sourceWs = manifest.workstreams.find((w) => w.name === item.workstream);
+      const sourceSeq = sourceWs?.latestSeq ?? 0;
+      replaceWorkstreamFromSource(db, sourceDb, item.workstream, manifest.machineId, sourceSeq);
+    }
+    return {
+      machineId: manifest.machineId,
+      sourceFile: file,
+      dryRun: false,
+      applied: true,
+      ...snapshot ? { snapshotId: snapshot.id } : {},
+      summary
+    };
+  } finally {
+    sourceDb.close();
+  }
+}
+function buildImportPlan(localDb, manifest, sourceFile, onlyWorkstreams) {
+  const sourceByName = new Map(manifest.workstreams.map((w) => [w.name, w]));
+  const localByName = new Map(listLocalWorkstreams2(localDb).map((w) => [w.name, w]));
+  const localMachineId = getMachineIdentity(localDb)?.machine_id ?? "";
+  const only = normaliseOnlyWorkstreams(onlyWorkstreams);
+  const names = Array.from(/* @__PURE__ */ new Set([...sourceByName.keys(), ...localByName.keys()])).filter((name) => only.size === 0 || only.has(name)).sort();
+  return names.map((name) => {
+    const source = sourceByName.get(name);
+    const local = localByName.get(name);
+    const sourceSeq = source?.latestSeq ?? 0;
+    const localSeq = local ? latestSeq(localDb, local.id) : 0;
+    const synced = source !== void 0 && local !== void 0 && manifest.machineId === localMachineId ? { sourceSeq: Math.min(sourceSeq, localSeq), localSeq: Math.min(sourceSeq, localSeq) } : local ? lastKnownPeerSync(localDb, local.id, manifest.machineId) : { sourceSeq: 0, localSeq: 0 };
+    const decision = classifyWorkstream({
+      hasSource: source !== void 0,
+      hasLocal: local !== void 0,
+      sourceSeq,
+      localSeq,
+      syncedSourceSeq: synced.sourceSeq,
+      syncedLocalSeq: synced.localSeq
+    });
+    return {
+      workstream: name,
+      decision,
+      delta: {
+        sourceFile,
+        sourceSeq,
+        localSeq,
+        lastSynced: synced.sourceSeq,
+        localSynced: synced.localSeq,
+        source: source ? countsFromManifest(source) : null,
+        local: local ? countWorkstream(localDb, local.id) : null
+      },
+      ...decision === "LOCAL_AHEAD" ? { needs: "re-export from this machine" } : {},
+      ...decision === "CONFLICT" ? { needs: "--force-source" } : {}
+    };
+  });
+}
+function classifyWorkstream(opts) {
+  if (opts.hasSource && !opts.hasLocal) return "IMPORT";
+  if (!opts.hasSource && opts.hasLocal)
+    return opts.syncedSourceSeq > 0 || opts.syncedLocalSeq > 0 ? "LOCAL_AHEAD" : "LEAVE_ALONE";
+  if (!opts.hasSource && !opts.hasLocal) return "IDENTICAL";
+  const sourceAdvanced = opts.sourceSeq > opts.syncedSourceSeq;
+  const localAdvanced = opts.localSeq > opts.syncedLocalSeq;
+  if (!sourceAdvanced && !localAdvanced) return "IDENTICAL";
+  if (sourceAdvanced && !localAdvanced) return "FAST_FORWARD";
+  if (!sourceAdvanced && localAdvanced) return "LOCAL_AHEAD";
+  return "CONFLICT";
+}
+function shouldReplace(decision, forceSource) {
+  return decision === "FAST_FORWARD" || decision === "IMPORT" || decision === "CONFLICT" && forceSource;
+}
+function replaceWorkstreamFromSource(localDb, sourceDb, workstream, sourceMachineId, sourceSeq) {
+  localDb.transaction(() => {
+    const existing = localDb.prepare("SELECT id FROM workstreams WHERE name = ?").get(workstream);
+    if (existing) {
+      localDb.prepare("DELETE FROM vcs_workspaces WHERE workstream_id = ?").run(existing.id);
+      localDb.prepare("DELETE FROM agents WHERE workstream_id = ?").run(existing.id);
+      localDb.prepare("DELETE FROM workstreams WHERE id = ?").run(existing.id);
+    }
+    copyWorkstreamRows(sourceDb, localDb, workstream, {
+      includeMachineLocalRows: false,
+      preserveLogSeq: false,
+      includeSync: false
+    });
+    const wsId = localDb.prepare("SELECT id FROM workstreams WHERE name = ?").get(workstream)?.id;
+    if (wsId === void 0) throw new Error(`importDb: failed to import workstream ${workstream}`);
+    writeSyncState(localDb, wsId, sourceMachineId, sourceSeq);
+  })();
+}
+function parkLocalWorkstream(db, workstream) {
+  const dir = join8(defaultStateDir(), "divergence");
+  mkdirSync4(dir, { recursive: true });
+  const path2 = join8(
+    dir,
+    `${workstream}-${(/* @__PURE__ */ new Date()).toISOString()}-${randomUUID2().slice(0, 8)}.db`
+  );
+  const parkDb = openDb({ path: path2 });
+  try {
+    const identity = getMachineIdentity(db);
+    if (identity) {
+      parkDb.prepare(
+        `UPDATE machine_identity
+              SET machine_id = ?, hostname = ?, created_at = ?
+            WHERE id = 1`
+      ).run(
+        identity.machine_id,
+        identity.hostname,
+        identity.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+      );
+    }
+    copyWorkstreamRows(db, parkDb, workstream, {
+      includeMachineLocalRows: true,
+      preserveLogSeq: true,
+      includeSync: true
+    });
+  } catch (err) {
+    try {
+      parkDb.close();
+    } catch {
+    }
+    try {
+      if (existsSync12(path2)) unlinkSync4(path2);
+    } catch {
+    }
+    throw err;
+  }
+  parkDb.close();
+  return path2;
+}
+function copyWorkstreamRows(sourceDb, targetDb, workstream, opts) {
+  const sourceWs = sourceDb.prepare("SELECT id, name, created_at FROM workstreams WHERE name = ?").get(workstream);
+  if (!sourceWs) throw new Error(`copyWorkstreamRows: no such workstream ${workstream}`);
+  targetDb.prepare("INSERT INTO workstreams (name, created_at) VALUES (?, ?)").run(sourceWs.name, sourceWs.created_at);
+  const targetWsId = targetDb.prepare("SELECT id FROM workstreams WHERE name = ?").get(workstream).id;
+  if (opts.includeMachineLocalRows) copyAgents(sourceDb, targetDb, sourceWs.id, targetWsId);
+  copyTasks(sourceDb, targetDb, sourceWs.id, targetWsId, opts.includeMachineLocalRows);
+  copyEdges(sourceDb, targetDb, sourceWs.id, targetWsId);
+  copyNotes(sourceDb, targetDb, sourceWs.id, targetWsId);
+  copyLogs(sourceDb, targetDb, sourceWs.id, targetWsId, opts.preserveLogSeq);
+  if (opts.includeMachineLocalRows) copyWorkspaces(sourceDb, targetDb, sourceWs.id, targetWsId);
+  if (opts.includeSync) copySync(sourceDb, targetDb, sourceWs.id, targetWsId);
+}
+function copyAgents(sourceDb, targetDb, sourceWsId, targetWsId) {
+  const rows = sourceDb.prepare(
+    `SELECT name, cli, pane_id, status, role, tab, created_at, updated_at
+         FROM agents
+        WHERE workstream_id = ?
+        ORDER BY id`
+  ).all(sourceWsId);
+  const insert = targetDb.prepare(
+    `INSERT INTO agents (workstream_id, name, cli, pane_id, status, role, tab, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const row2 of rows) {
+    insert.run(
+      targetWsId,
+      row2.name,
+      row2.cli,
+      row2.pane_id,
+      row2.status,
+      row2.role,
+      row2.tab,
+      row2.created_at,
+      row2.updated_at
+    );
+  }
+}
+function copyTasks(sourceDb, targetDb, sourceWsId, targetWsId, includeOwners) {
+  const rows = sourceDb.prepare(
+    `SELECT t.local_id, t.title, t.status, t.impact, t.effort_days, a.name AS owner_name,
+              t.created_at, t.updated_at
+         FROM tasks t
+         LEFT JOIN agents a ON a.id = t.owner_id
+        WHERE t.workstream_id = ?
+        ORDER BY t.id`
+  ).all(sourceWsId);
+  const ownerLookup = targetDb.prepare(
+    "SELECT id FROM agents WHERE workstream_id = ? AND name = ?"
+  );
+  const insert = targetDb.prepare(
+    `INSERT INTO tasks (workstream_id, local_id, title, status, impact, effort_days, owner_id, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const row2 of rows) {
+    const ownerId = includeOwners && row2.owner_name !== null ? ownerLookup.get(targetWsId, row2.owner_name)?.id ?? null : null;
+    insert.run(
+      targetWsId,
+      row2.local_id,
+      row2.title,
+      row2.status,
+      row2.impact,
+      row2.effort_days,
+      ownerId,
+      row2.created_at,
+      row2.updated_at
+    );
+  }
+}
+function copyEdges(sourceDb, targetDb, sourceWsId, targetWsId) {
+  const rows = sourceDb.prepare(
+    `SELECT f.local_id AS from_local_id, t.local_id AS to_local_id, e.created_at
+         FROM task_edges e
+         JOIN tasks f ON f.id = e.from_task_id
+         JOIN tasks t ON t.id = e.to_task_id
+        WHERE f.workstream_id = ? AND t.workstream_id = ?
+        ORDER BY e.created_at, f.local_id, t.local_id`
+  ).all(sourceWsId, sourceWsId);
+  const insert = targetDb.prepare(
+    `INSERT OR IGNORE INTO task_edges (from_task_id, to_task_id, created_at)
+     SELECT f.id, t.id, ?
+       FROM tasks f, tasks t
+      WHERE f.workstream_id = ? AND f.local_id = ?
+        AND t.workstream_id = ? AND t.local_id = ?`
+  );
+  for (const row2 of rows) {
+    insert.run(row2.created_at, targetWsId, row2.from_local_id, targetWsId, row2.to_local_id);
+  }
+}
+function copyNotes(sourceDb, targetDb, sourceWsId, targetWsId) {
+  const rows = sourceDb.prepare(
+    `SELECT t.local_id AS task_local_id, n.author, n.content, n.created_at
+         FROM task_notes n
+         JOIN tasks t ON t.id = n.task_id
+        WHERE t.workstream_id = ?
+        ORDER BY n.id`
+  ).all(sourceWsId);
+  const insert = targetDb.prepare(
+    `INSERT INTO task_notes (task_id, author, content, created_at)
+     SELECT id, ?, ?, ? FROM tasks WHERE workstream_id = ? AND local_id = ?`
+  );
+  for (const row2 of rows) {
+    insert.run(row2.author, row2.content, row2.created_at, targetWsId, row2.task_local_id);
+  }
+}
+function copyLogs(sourceDb, targetDb, sourceWsId, targetWsId, preserveSeq) {
+  const rows = sourceDb.prepare(
+    `SELECT seq, source, kind, payload, created_at
+         FROM agent_logs
+        WHERE workstream_id = ?
+        ORDER BY seq`
+  ).all(sourceWsId);
+  const insertPreserve = targetDb.prepare(
+    "INSERT INTO agent_logs (seq, workstream_id, source, kind, payload, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  const insertRenumber = targetDb.prepare(
+    "INSERT INTO agent_logs (workstream_id, source, kind, payload, created_at) VALUES (?, ?, ?, ?, ?)"
+  );
+  for (const row2 of rows) {
+    if (preserveSeq) {
+      insertPreserve.run(row2.seq, targetWsId, row2.source, row2.kind, row2.payload, row2.created_at);
+    } else {
+      insertRenumber.run(targetWsId, row2.source, row2.kind, row2.payload, row2.created_at);
+    }
+  }
+}
+function copyWorkspaces(sourceDb, targetDb, sourceWsId, targetWsId) {
+  const rows = sourceDb.prepare(
+    `SELECT a.name AS agent_name, v.backend, v.path, v.parent_ref, v.created_at
+         FROM vcs_workspaces v
+         JOIN agents a ON a.id = v.agent_id
+        WHERE v.workstream_id = ?
+        ORDER BY v.id`
+  ).all(sourceWsId);
+  const agentLookup = targetDb.prepare(
+    "SELECT id FROM agents WHERE workstream_id = ? AND name = ?"
+  );
+  const insert = targetDb.prepare(
+    `INSERT INTO vcs_workspaces (agent_id, workstream_id, backend, path, parent_ref, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  );
+  for (const row2 of rows) {
+    const agentId = agentLookup.get(targetWsId, row2.agent_name)?.id;
+    if (agentId === void 0) continue;
+    insert.run(agentId, targetWsId, row2.backend, row2.path, row2.parent_ref, row2.created_at);
+  }
+}
+function copySync(sourceDb, targetDb, sourceWsId, targetWsId) {
+  const row2 = sourceDb.prepare("SELECT last_known_peer_seqs FROM workstream_sync WHERE workstream_id = ?").get(sourceWsId);
+  if (!row2) return;
+  targetDb.prepare("INSERT INTO workstream_sync (workstream_id, last_known_peer_seqs) VALUES (?, ?)").run(targetWsId, row2.last_known_peer_seqs);
+}
+function writeSyncState(db, workstreamId, sourceMachineId, sourceSeq) {
+  const localSeq = latestSeq(db, workstreamId);
+  const peers = {
+    [sourceMachineId]: sourceSeq,
+    [localSeqKey(sourceMachineId)]: localSeq
+  };
+  db.prepare(
+    `INSERT OR REPLACE INTO workstream_sync (workstream_id, last_known_peer_seqs)
+     VALUES (?, ?)`
+  ).run(workstreamId, JSON.stringify(peers));
+}
+function lastKnownPeerSync(db, workstreamId, machineId) {
+  const row2 = db.prepare("SELECT last_known_peer_seqs FROM workstream_sync WHERE workstream_id = ?").get(workstreamId);
+  if (!row2) return { sourceSeq: 0, localSeq: 0 };
+  const parsed = parsePeerSeqs(row2.last_known_peer_seqs);
+  const sourceSeq = parsed[machineId] ?? 0;
+  return { sourceSeq, localSeq: parsed[localSeqKey(machineId)] ?? sourceSeq };
+}
+function localSeqKey(machineId) {
+  return `${machineId}:local`;
+}
+function parsePeerSeqs(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "number" && Number.isFinite(value)) result[key] = value;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function readImportManifest(file) {
+  const manifestPath = `${file}.manifest.json`;
+  if (!existsSync12(manifestPath)) throw new DbImportManifestMissingError(manifestPath);
+  return JSON.parse(readFileSync2(manifestPath, "utf8"));
+}
+function assertImportSchemaCompatible(sourceVersion) {
+  if (sourceVersion < CURRENT_SCHEMA_VERSION) throw new DbImportSchemaTooOldError(sourceVersion);
+  if (sourceVersion > CURRENT_SCHEMA_VERSION) throw new DbImportSchemaTooNewError(sourceVersion);
+}
+function buildExportManifest(db) {
+  const identity = getMachineIdentity(db);
+  const schemaRow = db.prepare("SELECT version FROM schema_version WHERE id = 1").get();
+  const workstreams = listLocalWorkstreams2(db);
+  return {
+    muVersion: readPackageVersion(),
+    schemaVersion: schemaRow?.version ?? CURRENT_SCHEMA_VERSION,
+    machineId: identity?.machine_id ?? "",
+    hostname: identity?.hostname ?? hostname2(),
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workstreams: workstreams.map((ws) => ({
+      name: ws.name,
+      tasks: count(db, "SELECT COUNT(*) AS n FROM tasks WHERE workstream_id = ?", ws.id),
+      edges: count(
+        db,
+        `SELECT COUNT(*) AS n
+           FROM task_edges e
+           JOIN tasks f ON f.id = e.from_task_id
+           JOIN tasks t ON t.id = e.to_task_id
+          WHERE f.workstream_id = ? AND t.workstream_id = ?`,
+        ws.id,
+        ws.id
+      ),
+      notes: count(
+        db,
+        `SELECT COUNT(*) AS n
+           FROM task_notes n
+           JOIN tasks t ON t.id = n.task_id
+          WHERE t.workstream_id = ?`,
+        ws.id
+      ),
+      latestSeq: latestSeq(db, ws.id)
+    }))
+  };
+}
+function listLocalWorkstreams2(db) {
+  return db.prepare("SELECT id, name FROM workstreams ORDER BY name").all();
+}
+function getMachineIdentity(db) {
+  return db.prepare("SELECT machine_id, hostname, created_at FROM machine_identity WHERE id = 1").get();
+}
+function countWorkstream(db, wsId) {
+  return {
+    tasks: count(db, "SELECT COUNT(*) AS n FROM tasks WHERE workstream_id = ?", wsId),
+    edges: count(
+      db,
+      `SELECT COUNT(*) AS n
+         FROM task_edges e
+         JOIN tasks f ON f.id = e.from_task_id
+         JOIN tasks t ON t.id = e.to_task_id
+        WHERE f.workstream_id = ? AND t.workstream_id = ?`,
+      wsId,
+      wsId
+    ),
+    notes: count(
+      db,
+      `SELECT COUNT(*) AS n
+         FROM task_notes n
+         JOIN tasks t ON t.id = n.task_id
+        WHERE t.workstream_id = ?`,
+      wsId
+    )
+  };
+}
+function countsFromManifest(ws) {
+  return { tasks: ws.tasks, edges: ws.edges, notes: ws.notes };
+}
+function normaliseOnlyWorkstreams(input) {
+  if (!input || input.length === 0) return /* @__PURE__ */ new Set();
+  return new Set(
+    input.flatMap((v) => v.split(",")).map((v) => v.trim()).filter((v) => v.length > 0)
+  );
+}
+function count(db, sql, ...params) {
+  const row2 = db.prepare(sql).get(...params);
+  return row2?.n ?? 0;
+}
+function quoteSqlString2(s) {
+  return `'${s.replace(/'/g, "''")}'`;
+}
+function readPackageVersion() {
+  try {
+    const here = dirname5(fileURLToPath2(import.meta.url));
+    const raw = readFileSync2(join8(here, "..", "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function shellQuote3(s) {
+  return `'${s.replace(/'/g, `'"'"'`)}'`;
+}
+
+// src/cli/db.ts
+init_output();
+function exportNextSteps(file) {
+  return [
+    { intent: "Ship the DB copy", command: `scp ${file} <other-machine>:/tmp/mu.db` },
+    { intent: "Ship the manifest too", command: `scp ${file}.manifest.json <other-machine>:/tmp/` },
+    { intent: "Import on the other side", command: "mu db import /tmp/mu.db" }
+  ];
+}
+function importNextSteps(result) {
+  if (result.dryRun) {
+    const hasConflict = result.summary.some((s) => s.decision === "CONFLICT");
+    const hasStale = result.summary.some((s) => s.decision === "LOCAL_AHEAD");
+    return [
+      ...hasStale ? [{ intent: "Source is stale", command: "re-export from this machine before importing" }] : [],
+      ...hasConflict ? [
+        {
+          intent: "Clobber source after parking local",
+          command: `mu db import ${result.sourceFile} --apply --force-source`
+        }
+      ] : [],
+      ...!hasConflict && !hasStale ? [{ intent: "Apply this plan", command: `mu db import ${result.sourceFile} --apply` }] : []
+    ];
+  }
+  return [
+    { intent: "Undo if needed", command: "mu undo --yes" },
+    { intent: "Inspect workstreams", command: "mu state --json" }
+  ];
+}
+function replayNextSteps(result) {
+  if (result.dryRun) {
+    const firstTask = result.tasks[0]?.localId;
+    return [
+      ...firstTask ? [
+        {
+          intent: "Replay one parked task",
+          command: `mu db replay ${result.sourceFile} --task ${firstTask} --apply`
+        }
+      ] : [],
+      {
+        intent: "Replay all parked rows",
+        command: `mu db replay ${result.sourceFile} --all --apply`
+      }
+    ];
+  }
+  return [
+    { intent: "Undo if needed", command: "mu undo --yes" },
+    { intent: "Inspect the workstream", command: `mu task list -w ${result.workstream}` }
+  ];
+}
+async function cmdDbExport(db, file, opts = {}) {
+  const result = exportDb(db, file, opts);
+  const nextSteps = exportNextSteps(result.file);
+  if (opts.json) {
+    emitJson({ ...result, nextSteps });
+    return;
+  }
+  console.log(
+    `Exported whole mu DB \u2192 ${pc.bold(result.file)} ${pc.dim(
+      `(schema=v${result.manifest.schemaVersion}, workstreams=${result.manifest.workstreams.length}, manifest=${result.manifestPath})`
+    )}`
+  );
+  if (result.overwritten) console.log(pc.dim("Overwrote existing target due to --force."));
+  printNextSteps(nextSteps);
+}
+async function cmdDbImport(db, file, opts = {}) {
+  const result = importDb(db, file, {
+    apply: opts.apply,
+    forceSource: opts.forceSource,
+    onlyWorkstreams: opts.onlyWs
+  });
+  const nextSteps = importNextSteps(result);
+  if (opts.json) {
+    emitJson({ ...result, nextSteps });
+    return;
+  }
+  console.log(
+    `${result.dryRun ? "Dry-run" : "Applied"} DB import from ${pc.bold(result.sourceFile)} ${pc.dim(
+      `(source machine=${result.machineId})`
+    )}`
+  );
+  if (result.snapshotId !== void 0) {
+    console.log(pc.dim(`Safety snapshot #${result.snapshotId} captured before import.`));
+  }
+  console.log(renderImportSummary(result.summary));
+  printNextSteps(nextSteps);
+}
+function renderImportSummary(summary) {
+  const table = muTable({
+    head: ["workstream", "decision", "source_seq", "local_seq", "last_synced", "needs"]
+  });
+  for (const item of summary) {
+    const delta = item.delta;
+    table.push([
+      item.workstream,
+      item.decision,
+      String(delta.sourceSeq ?? ""),
+      String(delta.localSeq ?? ""),
+      String(delta.lastSynced ?? ""),
+      item.parkPath ?? item.needs ?? ""
+    ]);
+  }
+  return table.toString();
+}
+async function cmdDbReplay(db, file, opts = {}) {
+  const result = replayDb(db, file, {
+    apply: opts.apply,
+    tasks: opts.task,
+    notes: opts.note,
+    all: opts.all
+  });
+  const nextSteps = replayNextSteps(result);
+  if (opts.json) {
+    emitJson({ ...result, nextSteps });
+    return;
+  }
+  console.log(
+    `${result.dryRun ? "Dry-run" : "Applied"} DB replay from ${pc.bold(result.sourceFile)} ${pc.dim(
+      `(workstream=${result.workstream})`
+    )}`
+  );
+  if (result.snapshotId !== void 0) {
+    console.log(pc.dim(`Safety snapshot #${result.snapshotId} captured before replay.`));
+  }
+  console.log(renderReplaySummary(result));
+  for (const warning of result.warnings) console.warn(pc.yellow(`warning: ${warning}`));
+  printNextSteps(nextSteps);
+}
+function renderReplaySummary(result) {
+  const table = muTable({ head: ["kind", "count", "details"] });
+  table.push([
+    "tasks",
+    String(result.tasks.length),
+    result.tasks.map((t) => `${t.localId} (${t.status})`).join(", ")
+  ]);
+  table.push([
+    "notes",
+    String(result.notes.length),
+    result.notes.map((n) => `${n.taskLocalId}@${n.createdAt}`).join(", ")
+  ]);
+  table.push([
+    "edges",
+    String(result.edges.length),
+    result.edges.map((e) => `${e.fromLocalId}->${e.toLocalId}`).join(", ")
+  ]);
+  table.push([
+    "conflicts",
+    String(result.conflicts.length),
+    result.conflicts.map(
+      (c) => `${c.localId}: local=${c.local.status}/${c.local.title}; sidecar=${c.sidecar.status}/${c.sidecar.title}`
+    ).join(", ")
+  ]);
+  if (!result.dryRun) {
+    table.push([
+      "added",
+      String(result.added.tasks + result.added.notes + result.added.edges),
+      `tasks=${result.added.tasks}, notes=${result.added.notes}, edges=${result.added.edges}`
+    ]);
+  }
+  return table.toString();
+}
+function collectOnlyWs(value, previous = []) {
+  return collectRepeatedCsv(value, previous);
+}
+function collectRepeatedCsv(value, previous = []) {
+  return [
+    ...previous,
+    ...value.split(",").map((v) => v.trim()).filter((v) => v.length > 0)
+  ];
+}
+function wireDbCommands(program) {
+  const db = program.command("db").description("Whole-machine DB sync commands");
+  db.command("export <file>").description(
+    "Export the entire mu SQLite DB to <file> via VACUUM INTO and write <file>.manifest.json. Whole-machine by design; no --workstream flag."
+  ).option("--force", "overwrite an existing target file").option(...JSON_OPT).action(function(file) {
+    const opts = this.opts();
+    return handle((dbHandle) => cmdDbExport(dbHandle, file, opts), this)();
+  });
+  db.command("import <file>").description(
+    "Import an exported mu DB with per-workstream drift detection. Dry-run by default; pass --apply to commit. Use --force-source to clobber conflicts after parking local divergence."
+  ).option("--apply", "actually apply the import plan (default is dry-run)").option(
+    "--only-ws <names>",
+    "restrict to workstream names; repeat or comma-separate",
+    collectOnlyWs,
+    []
+  ).option("--force-source", "on conflict, park local divergence then replace from source").option(...JSON_OPT).action(function(file) {
+    const opts = this.opts();
+    return handle((dbHandle) => cmdDbImport(dbHandle, file, opts), this)();
+  });
+  db.command("replay <sidecar-file>").description(
+    "Manually cherry-pick tasks, notes, and eligible edges from a divergence sidecar parked by mu db import --force-source. Dry-run by default; pass --apply to write."
+  ).option("--apply", "actually apply the replay selection (default is dry-run)").option(
+    "--task <id>",
+    "replay a missing task plus its notes and eligible edges; repeat or comma-separate",
+    collectRepeatedCsv,
+    []
+  ).option(
+    "--note <task-id>",
+    "replay missing notes for a task; repeat or comma-separate",
+    collectRepeatedCsv,
+    []
+  ).option("--all", "replay every missing local-only item from the sidecar").option(...JSON_OPT).action(function(file) {
+    const opts = this.opts();
+    return handle((dbHandle) => cmdDbReplay(dbHandle, file, opts), this)();
+  });
+}
+
+// src/cli/doctor.ts
+init_agents();
+init_db();
+init_output();
+init_tmux();
+init_workstream();
+async function cmdDoctor(db, opts = {}) {
+  if (opts.json) {
+    return cmdDoctorJson(db);
+  }
+  console.log(pc.bold("mu doctor"));
+  console.log(pc.bold("\nenvironment"));
+  try {
+    const version = (await tmux(["-V"])).trim();
+    console.log(`  tmux             : ${pc.green("ok")} (${version})`);
+  } catch {
+    console.log(`  tmux             : ${pc.red("NOT FOUND")} \u2014 install tmux \u2265 3.0`);
+  }
+  console.log(`  $TMUX            : ${process.env.TMUX ? pc.green("set") : pc.yellow("not set")}`);
+  console.log(
+    `  $TMUX_PANE       : ${process.env.TMUX_PANE ? pc.green(process.env.TMUX_PANE) : pc.dim("not set")}`
+  );
+  console.log(
+    `  $MU_SESSION      : ${process.env.MU_SESSION ? pc.green(process.env.MU_SESSION) : pc.dim("not set")}`
+  );
+  console.log(pc.bold("\ndb"));
+  console.log(`  path             : ${pc.dim(defaultDbPath())}`);
+  try {
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    ).all().map((r) => r.name);
+    const missing = EXPECTED_TABLES.filter((t) => !tables.includes(t));
+    if (missing.length === 0) {
+      console.log(`  schema           : ${pc.green("ok")} (${EXPECTED_TABLES.length} tables)`);
+    } else {
+      console.log(`  schema           : ${pc.red("missing")} \u2014 ${missing.join(", ")}`);
+    }
+    try {
+      const row2 = db.prepare("SELECT version FROM schema_version WHERE id = 1").get();
+      const v = row2?.version;
+      if (v === void 0) {
+        console.log(
+          `  schema_version   : ${pc.red("missing row")} (expected ${CURRENT_SCHEMA_VERSION})`
+        );
+      } else if (v === CURRENT_SCHEMA_VERSION) {
+        console.log(`  schema_version   : ${pc.green(String(v))}`);
+      } else if (v < CURRENT_SCHEMA_VERSION) {
+        console.log(
+          `  schema_version   : ${pc.yellow(String(v))} (code expects ${CURRENT_SCHEMA_VERSION}; openDb should have migrated)`
+        );
+      } else {
+        console.log(
+          `  schema_version   : ${pc.red(String(v))} (code expects ${CURRENT_SCHEMA_VERSION}; possible downgrade or future-version DB)`
+        );
+      }
+    } catch {
+      console.log(
+        `  schema_version   : ${pc.red("unreadable")} (schema_version table missing or wrong shape)`
+      );
+    }
+    const journal = db.pragma("journal_mode", { simple: true });
+    console.log(
+      `  journal_mode     : ${journal === "wal" ? pc.green(String(journal)) : pc.yellow(String(journal))}`
+    );
+    const fk = db.pragma("foreign_keys", { simple: true });
+    console.log(`  foreign_keys     : ${fk === 1 ? pc.green("on") : pc.red(`off (${fk})`)}`);
+  } catch (err) {
+    console.log(
+      `  schema           : ${pc.red("FAIL")} \u2014 ${err instanceof Error ? err.message : err}`
+    );
+  }
+  console.log(pc.bold("\nworkstream"));
+  let currentWorkstream = null;
+  try {
+    currentWorkstream = await resolveWorkstream();
     console.log(`  current          : ${pc.green(currentWorkstream)}`);
   } catch {
     console.log(
@@ -16933,553 +18236,8 @@ function wireDoctorCommand(program) {
 // src/cli/handle.ts
 init_agents();
 init_archives();
-init_db();
 import { CommanderError } from "commander";
-
-// src/importing.ts
 init_db();
-init_exporting();
-init_logs();
-init_status();
-init_workstream();
-import { existsSync as existsSync12, readFileSync as readFileSync2, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join8 } from "path";
-var ImportBucketInvalidError = class extends Error {
-  constructor(bucketDir, reason) {
-    super(`not a valid mu bucket export at ${bucketDir}: ${reason}`);
-    this.bucketDir = bucketDir;
-    this.reason = reason;
-  }
-  bucketDir;
-  reason;
-  name = "ImportBucketInvalidError";
-  errorNextSteps() {
-    return [
-      { intent: "List the directory's contents", command: `ls ${this.bucketDir}` },
-      {
-        intent: "Inspect the manifest (must be bucketVersion 2)",
-        command: `cat ${this.bucketDir}/manifest.json`
-      }
-    ];
-  }
-};
-var ImportSourceNotInBucketError = class extends Error {
-  constructor(bucketDir, badName, validNames) {
-    super(
-      `--source-ws "${badName}" is not a source-ws in bucket ${bucketDir}; valid: ${validNames.length === 0 ? "<none>" : validNames.join(", ")}`
-    );
-    this.bucketDir = bucketDir;
-    this.badName = badName;
-    this.validNames = validNames;
-  }
-  bucketDir;
-  badName;
-  validNames;
-  name = "ImportSourceNotInBucketError";
-  errorNextSteps() {
-    return [
-      { intent: "List the bucket's source-ws subdirs", command: `ls ${this.bucketDir}` },
-      {
-        intent: "Inspect the bucket manifest's sources map",
-        command: `cat ${this.bucketDir}/manifest.json | head -40`
-      }
-    ];
-  }
-};
-var WorkstreamAlreadyExistsError = class extends Error {
-  constructor(workstream) {
-    super(
-      `workstream "${workstream}" already exists in the DB; mu workstream import refuses to merge silently. Pass --workstream <new-name> to import under a different name (single-source buckets only), or destroy the existing workstream first.`
-    );
-    this.workstream = workstream;
-  }
-  workstream;
-  name = "WorkstreamAlreadyExistsError";
-  errorNextSteps() {
-    return [
-      {
-        intent: "Import under a new name (single-source bucket only)",
-        command: "mu workstream import <bucket> --workstream <new-name>"
-      },
-      {
-        intent: "Or destroy the existing workstream first",
-        command: `mu workstream destroy -w ${this.workstream} --yes`
-      }
-    ];
-  }
-};
-var ImportFrontmatterParseError = class extends Error {
-  constructor(path2, line, raw) {
-    super(`failed to parse frontmatter at ${path2}:${line}: ${raw}`);
-    this.path = path2;
-    this.line = line;
-    this.raw = raw;
-  }
-  path;
-  line;
-  raw;
-  name = "ImportFrontmatterParseError";
-  errorNextSteps() {
-    return [{ intent: "Inspect the offending file", command: `sed -n 1,30p ${this.path}` }];
-  }
-};
-var ImportEdgeRefMissingError = class extends Error {
-  constructor(fromTask, toTask, direction) {
-    super(
-      `task "${fromTask}" references "${toTask}" via ${direction}, but no task with that id was found in the import`
-    );
-    this.fromTask = fromTask;
-    this.toTask = toTask;
-    this.direction = direction;
-  }
-  fromTask;
-  toTask;
-  direction;
-  name = "ImportEdgeRefMissingError";
-  errorNextSteps() {
-    return [
-      {
-        intent: "Inspect the offending task file in the bucket",
-        command: `grep -l 'id: "${this.fromTask}"' <bucket>/*/tasks/`
-      }
-    ];
-  }
-};
-function unquote(raw) {
-  const trimmed = raw.trim();
-  if (trimmed === "null") return null;
-  if (trimmed.length < 2 || trimmed[0] !== '"' || trimmed[trimmed.length - 1] !== '"') {
-    return raw.trim();
-  }
-  const inner = trimmed.slice(1, -1);
-  let out = "";
-  for (let i = 0; i < inner.length; i++) {
-    const ch = inner[i];
-    if (ch === "\\" && i + 1 < inner.length) {
-      const next = inner[i + 1];
-      if (next === '"' || next === "\\") {
-        out += next;
-        i += 1;
-        continue;
-      }
-    }
-    if (ch !== void 0) out += ch;
-  }
-  return out;
-}
-function parseStringArray(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
-    throw new Error(`expected [..] array, got ${JSON.stringify(raw)}`);
-  }
-  const inner = trimmed.slice(1, -1).trim();
-  if (inner === "") return [];
-  const out = [];
-  let i = 0;
-  while (i < inner.length) {
-    while (i < inner.length && (inner[i] === " " || inner[i] === ",")) i += 1;
-    if (i >= inner.length) break;
-    if (inner[i] !== '"') {
-      throw new Error(`expected quoted string in array, got ${JSON.stringify(inner.slice(i))}`);
-    }
-    let j = i + 1;
-    while (j < inner.length) {
-      if (inner[j] === "\\" && j + 1 < inner.length) {
-        j += 2;
-        continue;
-      }
-      if (inner[j] === '"') break;
-      j += 1;
-    }
-    if (j >= inner.length) {
-      throw new Error("unterminated quoted string in array");
-    }
-    const scalar = unquote(inner.slice(i, j + 1));
-    if (scalar === null) {
-      throw new Error("null is not a legal array element");
-    }
-    out.push(scalar);
-    i = j + 1;
-  }
-  return out;
-}
-function parseTaskMarkdown(path2) {
-  const raw = readFileSync2(path2, "utf8");
-  const lines = raw.split("\n");
-  if (lines[0] !== "---") {
-    throw new ImportFrontmatterParseError(path2, 1, lines[0] ?? "");
-  }
-  let end = -1;
-  for (let i2 = 1; i2 < lines.length; i2++) {
-    if (lines[i2] === "---") {
-      end = i2;
-      break;
-    }
-  }
-  if (end === -1) {
-    throw new ImportFrontmatterParseError(path2, 1, "missing closing '---' for frontmatter");
-  }
-  const fields = {};
-  for (let i2 = 1; i2 < end; i2++) {
-    const line = lines[i2] ?? "";
-    const colon = line.indexOf(":");
-    if (colon === -1) {
-      throw new ImportFrontmatterParseError(path2, i2 + 1, line);
-    }
-    const key = line.slice(0, colon).trim();
-    const value = line.slice(colon + 1).trim();
-    fields[key] = value;
-  }
-  function require2(key) {
-    const v = fields[key];
-    if (v === void 0) {
-      throw new ImportFrontmatterParseError(path2, 1, `missing frontmatter key: ${key}`);
-    }
-    return v;
-  }
-  const id = unquote(require2("id"));
-  if (id === null || id === "") {
-    throw new ImportFrontmatterParseError(path2, 1, "id must be a non-empty string");
-  }
-  const workstream = unquote(require2("workstream"));
-  if (workstream === null || workstream === "") {
-    throw new ImportFrontmatterParseError(path2, 1, "workstream must be a non-empty string");
-  }
-  const statusRaw = require2("status");
-  if (!isTaskStatus(statusRaw)) {
-    throw new ImportFrontmatterParseError(path2, 1, `unknown status: ${statusRaw}`);
-  }
-  const impact = Number(require2("impact"));
-  const effortDays = Number(require2("effort_days"));
-  if (!Number.isFinite(impact) || !Number.isFinite(effortDays)) {
-    throw new ImportFrontmatterParseError(path2, 1, "impact / effort_days must be numeric");
-  }
-  const ownerName = unquote(require2("owner"));
-  const createdAt = unquote(require2("created_at"));
-  const updatedAt = unquote(require2("updated_at"));
-  if (createdAt === null || updatedAt === null) {
-    throw new ImportFrontmatterParseError(path2, 1, "created_at / updated_at cannot be null");
-  }
-  let blockedBy;
-  let blocks;
-  try {
-    blockedBy = parseStringArray(require2("blocked_by"));
-    blocks = parseStringArray(require2("blocks"));
-  } catch (err) {
-    throw new ImportFrontmatterParseError(
-      path2,
-      1,
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-  let bodyIdx = end + 1;
-  while (bodyIdx < lines.length && lines[bodyIdx] === "") bodyIdx += 1;
-  const titleLine = lines[bodyIdx] ?? "";
-  if (!titleLine.startsWith("# ")) {
-    throw new ImportFrontmatterParseError(
-      path2,
-      bodyIdx + 1,
-      "expected '# <title>' after frontmatter"
-    );
-  }
-  const title = titleLine.slice(2).trim();
-  const notes = [];
-  let i = bodyIdx + 1;
-  while (i < lines.length && !(lines[i] ?? "").startsWith("## Notes (")) i += 1;
-  if (i < lines.length) {
-    i += 1;
-    while (i < lines.length) {
-      const line = lines[i] ?? "";
-      if (!line.startsWith("### #")) {
-        i += 1;
-        continue;
-      }
-      const headerRest = line.slice(line.indexOf(" by ") + 4);
-      const lastComma = headerRest.lastIndexOf(", ");
-      if (lastComma === -1) {
-        throw new ImportFrontmatterParseError(path2, i + 1, line);
-      }
-      const authorRaw = headerRest.slice(0, lastComma);
-      const author = unquote(authorRaw);
-      const createdAtNote = headerRest.slice(lastComma + 2);
-      i += 1;
-      while (i < lines.length && lines[i] === "") i += 1;
-      const openFence = lines[i] ?? "";
-      if (!/^`{3,}$/.test(openFence)) {
-        throw new ImportFrontmatterParseError(path2, i + 1, openFence);
-      }
-      const fence = openFence;
-      i += 1;
-      const contentLines = [];
-      while (i < lines.length && lines[i] !== fence) {
-        contentLines.push(lines[i] ?? "");
-        i += 1;
-      }
-      if (i >= lines.length) {
-        throw new ImportFrontmatterParseError(path2, i + 1, `unterminated note fence ${fence}`);
-      }
-      i += 1;
-      notes.push({ author, createdAt: createdAtNote, content: contentLines.join("\n") });
-    }
-  }
-  return {
-    id,
-    workstream,
-    status: statusRaw,
-    impact,
-    effortDays,
-    ownerName,
-    createdAt,
-    updatedAt,
-    blockedBy,
-    blocks,
-    title,
-    notes
-  };
-}
-function walkBucket(bucketDir) {
-  if (!existsSync12(bucketDir)) {
-    throw new ImportBucketInvalidError(bucketDir, "directory does not exist");
-  }
-  if (!statSync4(bucketDir).isDirectory()) {
-    throw new ImportBucketInvalidError(bucketDir, "not a directory");
-  }
-  const manifestPath = join8(bucketDir, "manifest.json");
-  const probe = readManifest(manifestPath);
-  if (probe.kind === "v2") {
-    const manifest = probe.manifest;
-    const sources = [];
-    for (const entry of readdirSync3(bucketDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const sourceDir = join8(bucketDir, entry.name);
-      const tasksDir2 = join8(sourceDir, "tasks");
-      if (!existsSync12(tasksDir2) || !statSync4(tasksDir2).isDirectory()) continue;
-      const taskFiles2 = [];
-      for (const f of readdirSync3(tasksDir2, { withFileTypes: true })) {
-        if (f.isFile() && f.name.endsWith(".md")) {
-          taskFiles2.push(join8(tasksDir2, f.name));
-        }
-      }
-      taskFiles2.sort();
-      sources.push({ diskName: entry.name, taskFiles: taskFiles2 });
-    }
-    sources.sort((a, b) => a.diskName.localeCompare(b.diskName));
-    return { manifest, sources, shape: "bucket" };
-  }
-  if (probe.kind === "corrupt") {
-    throw new ImportBucketInvalidError(bucketDir, "manifest.json is unreadable / malformed");
-  }
-  const tasksDir = join8(bucketDir, "tasks");
-  const looksLikeSourceWs = existsSync12(join8(bucketDir, "README.md")) && existsSync12(join8(bucketDir, "INDEX.md")) && existsSync12(tasksDir) && statSync4(tasksDir).isDirectory();
-  if (!looksLikeSourceWs) {
-    throw new ImportBucketInvalidError(bucketDir, "manifest.json missing");
-  }
-  const parentDir = dirname5(bucketDir);
-  const baseName = basename2(bucketDir);
-  const parentProbe = readManifest(join8(parentDir, "manifest.json"));
-  if (parentProbe.kind !== "v2") {
-    throw new ImportBucketInvalidError(
-      bucketDir,
-      `${bucketDir} looks like a per-source-ws subdir (README.md + INDEX.md + tasks/), but ${parentDir}/manifest.json is missing or not a bucketVersion 2 manifest. Pass the parent bucket directory instead, or re-export.`
-    );
-  }
-  const parentManifest = parentProbe.manifest;
-  if (!Object.prototype.hasOwnProperty.call(parentManifest.sources ?? {}, baseName)) {
-    throw new ImportBucketInvalidError(
-      bucketDir,
-      `${bucketDir} looks like a per-source-ws subdir but "${baseName}" is not in the parent bucket manifest's sources (${parentDir}/manifest.json). Re-export to refresh the bucket manifest.`
-    );
-  }
-  const taskFiles = [];
-  for (const f of readdirSync3(tasksDir, { withFileTypes: true })) {
-    if (f.isFile() && f.name.endsWith(".md")) {
-      taskFiles.push(join8(tasksDir, f.name));
-    }
-  }
-  taskFiles.sort();
-  return {
-    manifest: parentManifest,
-    sources: [{ diskName: baseName, taskFiles }],
-    shape: "sourceWsSubdir"
-  };
-}
-function importOneSource(db, targetWorkstream, parsed, options) {
-  const idSet = new Set(parsed.map((p) => p.id));
-  for (const t of parsed) {
-    for (const blocker of t.blockedBy) {
-      if (!idSet.has(blocker)) {
-        throw new ImportEdgeRefMissingError(t.id, blocker, "blocked_by");
-      }
-    }
-    for (const dep of t.blocks) {
-      if (!idSet.has(dep)) {
-        throw new ImportEdgeRefMissingError(t.id, dep, "blocks");
-      }
-    }
-  }
-  if (options.dryRun) {
-    const edgePairs = /* @__PURE__ */ new Set();
-    for (const t of parsed) {
-      for (const blocker of t.blockedBy) edgePairs.add(`${blocker}\0${t.id}`);
-      for (const dep of t.blocks) edgePairs.add(`${t.id}\0${dep}`);
-    }
-    const noteCount = parsed.reduce((acc, p) => acc + p.notes.length, 0);
-    return {
-      tasksImported: parsed.length,
-      edgesImported: edgePairs.size,
-      notesImported: noteCount
-    };
-  }
-  return db.transaction(() => {
-    ensureWorkstream(db, targetWorkstream);
-    const wsId = resolveWorkstreamId(db, targetWorkstream);
-    const insertTask = db.prepare(
-      `INSERT INTO tasks
-         (workstream_id, local_id, title, status, impact, effort_days, owner_id, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)`
-    );
-    const taskIdByLocalId = /* @__PURE__ */ new Map();
-    for (const t of parsed) {
-      const r = insertTask.run(
-        wsId,
-        t.id,
-        t.title,
-        t.status,
-        t.impact,
-        t.effortDays,
-        t.createdAt,
-        t.updatedAt
-      );
-      taskIdByLocalId.set(t.id, Number(r.lastInsertRowid));
-    }
-    const insertEdge = db.prepare(
-      "INSERT OR IGNORE INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
-    );
-    const seenEdges = /* @__PURE__ */ new Set();
-    let edgesImported = 0;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const recordEdge = (fromLocal, toLocal) => {
-      const key = `${fromLocal}\0${toLocal}`;
-      if (seenEdges.has(key)) return;
-      seenEdges.add(key);
-      const fromId = taskIdByLocalId.get(fromLocal);
-      const toId = taskIdByLocalId.get(toLocal);
-      if (fromId === void 0 || toId === void 0) return;
-      const r = insertEdge.run(fromId, toId, now);
-      if (r.changes > 0) edgesImported += 1;
-    };
-    for (const t of parsed) {
-      for (const blocker of t.blockedBy) recordEdge(blocker, t.id);
-      for (const dep of t.blocks) recordEdge(t.id, dep);
-    }
-    const insertNote = db.prepare(
-      "INSERT INTO task_notes (task_id, author, content, created_at) VALUES (?, ?, ?, ?)"
-    );
-    let notesImported = 0;
-    for (const t of parsed) {
-      const taskId = taskIdByLocalId.get(t.id);
-      if (taskId === void 0) continue;
-      for (const note of t.notes) {
-        insertNote.run(taskId, note.author, note.content, note.createdAt);
-        notesImported += 1;
-      }
-    }
-    emitEvent(
-      db,
-      targetWorkstream,
-      `workstream import ${targetWorkstream} (tasks=${parsed.length}, edges=${edgesImported}, notes=${notesImported})`
-    );
-    return {
-      tasksImported: parsed.length,
-      edgesImported,
-      notesImported
-    };
-  })();
-}
-function importBucket(db, opts) {
-  const { manifest, sources, shape } = walkBucket(opts.bucketDir);
-  if (shape === "sourceWsSubdir" && opts.sourceWs !== void 0 && opts.sourceWs.length > 0) {
-    throw new ImportBucketInvalidError(
-      opts.bucketDir,
-      `cannot pass --source-ws when ${opts.bucketDir} is itself a source-ws subdir; drop the flag`
-    );
-  }
-  let filteredSources = sources;
-  if (opts.sourceWs !== void 0 && opts.sourceWs.length > 0) {
-    const validNames = Object.keys(manifest.sources ?? {}).sort();
-    const validSet = new Set(validNames);
-    for (const wanted of opts.sourceWs) {
-      if (!validSet.has(wanted)) {
-        throw new ImportSourceNotInBucketError(opts.bucketDir, wanted, validNames);
-      }
-    }
-    const wantedSet = new Set(opts.sourceWs);
-    filteredSources = sources.filter((s) => wantedSet.has(s.diskName));
-  }
-  if (opts.workstreamOverride !== void 0 && filteredSources.length !== 1) {
-    throw new ImportBucketInvalidError(
-      opts.bucketDir,
-      `--workstream override requires a single source-ws subdir; this bucket has ${filteredSources.length}`
-    );
-  }
-  const dryRun = opts.dryRun === true;
-  const results = [];
-  for (const source of filteredSources) {
-    const targetName = opts.workstreamOverride ?? source.diskName;
-    const result = {
-      workstreamName: targetName,
-      tasksImported: 0,
-      edgesImported: 0,
-      notesImported: 0,
-      tombstonesSkipped: 0,
-      errors: []
-    };
-    const liveFiles = [];
-    for (const file of source.taskFiles) {
-      const head = readFileSync2(file, "utf8").slice(0, DELETED_BANNER_PREFIX.length);
-      if (head.startsWith(DELETED_BANNER_PREFIX)) {
-        result.tombstonesSkipped += 1;
-        continue;
-      }
-      liveFiles.push(file);
-    }
-    if (!dryRun) {
-      const existing = db.prepare("SELECT 1 AS x FROM workstreams WHERE name = ?").get(targetName);
-      if (existing !== void 0) {
-        const err = new WorkstreamAlreadyExistsError(targetName);
-        result.errors.push(err.message);
-        results.push(result);
-        throw err;
-      }
-    }
-    let parsed;
-    try {
-      parsed = liveFiles.map(parseTaskMarkdown);
-    } catch (err) {
-      result.errors.push(err instanceof Error ? err.message : String(err));
-      results.push(result);
-      throw err;
-    }
-    try {
-      const counts = importOneSource(db, targetName, parsed, { dryRun });
-      result.tasksImported = counts.tasksImported;
-      result.edgesImported = counts.edgesImported;
-      result.notesImported = counts.notesImported;
-    } catch (err) {
-      result.errors.push(err instanceof Error ? err.message : String(err));
-      results.push(result);
-      throw err;
-    }
-    results.push(result);
-  }
-  return {
-    bucketLabel: manifest.bucketLabel,
-    bucketVersion: manifest.bucketVersion,
-    sources: results
-  };
-}
-
-// src/cli/handle.ts
 init_output();
 init_snapshots();
 init_tasks();
@@ -17534,13 +18292,34 @@ var NameAmbiguousError = class extends Error {
   }
 };
 function classifyError(err) {
-  if (err instanceof UsageError || err instanceof WorkstreamNameInvalidError || err instanceof ArchiveLabelInvalidError || err instanceof ImportBucketInvalidError || err instanceof ImportFrontmatterParseError || err instanceof ImportEdgeRefMissingError || err instanceof PruneOptionsInvalidError) {
+  if (err instanceof UsageError || err instanceof WorkstreamNameInvalidError || err instanceof ArchiveLabelInvalidError || err instanceof PruneOptionsInvalidError) {
     return { label: "error", exitCode: 2 };
   }
   if (err instanceof AgentNotFoundError || err instanceof TaskNotFoundError || err instanceof WorkstreamNotFoundError || err instanceof WorkspaceNotFoundError || err instanceof SnapshotNotFoundError || err instanceof ArchiveNotFoundError) {
     return { label: "not found", exitCode: 3 };
   }
-  if (err instanceof NameAmbiguousError || err instanceof AgentExistsError || err instanceof TaskExistsError || err instanceof TaskAlreadyOwnedError || err instanceof TaskClaimStaleWorkspaceError || err instanceof TaskNotInWorkstreamError || err instanceof AgentNotInWorkstreamError || err instanceof CycleError || err instanceof TaskHasOpenDependentsError || 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 SnapshotVersionMismatchError || err instanceof SchemaTooOldError || err instanceof TaskIdInvalidError || err instanceof ArchiveAlreadyExistsError || err instanceof ImportSourceNotInBucketError || err instanceof WorkstreamAlreadyExistsError) {
+  if (err instanceof DbImportManifestMissingError) {
+    return { label: "db import manifest missing", exitCode: 8 };
+  }
+  if (err instanceof DbImportSchemaTooOldError) {
+    return { label: "db import schema too old", exitCode: 9 };
+  }
+  if (err instanceof DbImportSchemaTooNewError) {
+    return { label: "db import schema too new", exitCode: 10 };
+  }
+  if (err instanceof DbImportSourceStaleError) {
+    return { label: "db import source stale", exitCode: 11 };
+  }
+  if (err instanceof DbImportConflictError) {
+    return { label: "db import conflict", exitCode: 12 };
+  }
+  if (err instanceof DbReplayWorkstreamMissingError) {
+    return { label: "db replay workstream missing", exitCode: 13 };
+  }
+  if (err instanceof DbReplayLocalIdConflictError) {
+    return { label: "db replay local-id conflict", exitCode: 14 };
+  }
+  if (err instanceof NameAmbiguousError || err instanceof AgentExistsError || err instanceof TaskExistsError || err instanceof TaskAlreadyOwnedError || err instanceof TaskClaimStaleWorkspaceError || err instanceof TaskNotInWorkstreamError || err instanceof AgentNotInWorkstreamError || err instanceof CycleError || err instanceof TaskHasOpenDependentsError || 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 SnapshotVersionMismatchError || err instanceof SchemaTooOldError || err instanceof TaskIdInvalidError || err instanceof ArchiveAlreadyExistsError || err instanceof ArchiveSourceAmbiguousError || err instanceof DbExportTargetExistsError || err instanceof WorkstreamExistsError) {
     return { label: "conflict", exitCode: 4 };
   }
   if (err instanceof AgentSpawnCliNotFoundError) {
@@ -18394,7 +19173,7 @@ async function cmdSql(db, query, opts = {}) {
   }
 }
 function countTopLevelStatements(sql) {
-  let count = 0;
+  let count2 = 0;
   let inSingle = false;
   let inDouble = false;
   let inLineComment = false;
@@ -18450,15 +19229,15 @@ function countTopLevelStatements(sql) {
     }
     if (c === ";") {
       if (sawNonWs) {
-        count++;
+        count2++;
         sawNonWs = false;
       }
       continue;
     }
     if (c !== void 0 && /\S/.test(c)) sawNonWs = true;
   }
-  if (sawNonWs) count++;
-  return count;
+  if (sawNonWs) count2++;
+  return count2;
 }
 function formatCell(v) {
   if (v === null || v === void 0) return pc.dim("null");
@@ -19202,75 +19981,6 @@ async function cmdWorkstreamExport(db, opts) {
   );
   printNextSteps(nextSteps);
 }
-async function cmdWorkstreamImport(db, bucketDir, opts) {
-  let sourceWs;
-  if (opts.sourceWs !== void 0) {
-    const canonical = parseCsvFlag(opts.sourceWs);
-    if (canonical.length === 0) {
-      throw new UsageError(
-        "--source-ws was passed but resolved to zero names (empty strings / commas only); pass at least one source-ws name or drop the flag"
-      );
-    }
-    sourceWs = canonical;
-  }
-  const result = importBucket(db, {
-    bucketDir,
-    workstreamOverride: opts.workstream,
-    sourceWs,
-    dryRun: opts.dryRun
-  });
-  const totalTasks = result.sources.reduce((acc, s) => acc + s.tasksImported, 0);
-  const totalEdges = result.sources.reduce((acc, s) => acc + s.edgesImported, 0);
-  const totalNotes = result.sources.reduce((acc, s) => acc + s.notesImported, 0);
-  const totalTombstones = result.sources.reduce((acc, s) => acc + s.tombstonesSkipped, 0);
-  const importedNames = result.sources.map((s) => s.workstreamName);
-  const nextSteps = [];
-  if (!opts.dryRun) {
-    for (const name of importedNames) {
-      nextSteps.push({
-        intent: `Inspect ${name}`,
-        command: `mu task tree -w ${name}`
-      });
-    }
-    nextSteps.push({
-      intent: "Re-export to verify the round trip is byte-stable",
-      command: `mu workstream export -w ${importedNames[0] ?? "<ws>"} --out <new-dir>`
-    });
-  } else {
-    const sourceWsFlag = sourceWs !== void 0 && sourceWs.length > 0 ? ` --source-ws ${sourceWs.join(",")}` : "";
-    nextSteps.push({
-      intent: "Run the import for real",
-      command: `mu workstream import ${bucketDir}${opts.workstream ? ` --workstream ${opts.workstream}` : ""}${sourceWsFlag}`
-    });
-  }
-  if (opts.json) {
-    emitJson({
-      ...result,
-      bucketDir,
-      dryRun: opts.dryRun === true,
-      totals: {
-        tasks: totalTasks,
-        edges: totalEdges,
-        notes: totalNotes,
-        tombstones: totalTombstones
-      },
-      nextSteps
-    });
-    return;
-  }
-  const verb = opts.dryRun ? "Would import" : "Imported";
-  console.log(
-    `${verb} ${pc.bold(String(result.sources.length))} source-ws from ${pc.bold(bucketDir)} ${pc.dim(
-      `(bucketVersion=${result.bucketVersion}${result.bucketLabel ? `, label=${result.bucketLabel}` : ""}; tasks=${totalTasks}, edges=${totalEdges}, notes=${totalNotes}, tombstones_skipped=${totalTombstones})`
-    )}`
-  );
-  for (const s of result.sources) {
-    console.log(
-      `  ${pc.bold(s.workstreamName)}: tasks=${s.tasksImported}, edges=${s.edgesImported}, notes=${s.notesImported}, tombstones=${s.tombstonesSkipped}`
-    );
-  }
-  printNextSteps(nextSteps);
-}
 function autoExportDir(workstream) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return join9(defaultStateDir(), "exports", `${workstream}-${ts}`);
@@ -19595,18 +20305,6 @@ function wireWorkstreamCommands(program) {
     const opts = this.opts();
     return handle((db) => cmdDestroy(db, opts), this)();
   });
-  workstream.command("import <bucket-dir>").description(
-    "Rebuild a workstream (or a multi-source bucket of workstreams) from a v0.3 markdown export. Accepts EITHER a bucket directory (top-level manifest.json + per-source-ws subdirs) OR a single per-source-ws subdir (auto-detected via README.md + INDEX.md + tasks/, validated against the parent bucket's manifest). Per source-ws transactional: each source-ws is imported in its own SQLite transaction; siblings are unaffected by a sibling's failure. Refuses to merge silently into an existing workstream \u2014 pass --workstream <name> (single-source after any --source-ws filter only) or destroy the existing one first."
-  ).option(
-    "--workstream <name>",
-    "override the imported workstream's name (single-source after any --source-ws filter only)"
-  ).option(
-    "--source-ws <names...>",
-    "restrict the import to a subset of source-ws subdirs (repeat or comma-separate; or both)"
-  ).option("--dry-run", "walk + parse + validate; report what WOULD be created; no DB writes").option(...JSON_OPT).action(function(bucketDir) {
-    const opts = this.opts();
-    return handle((db) => cmdWorkstreamImport(db, bucketDir, opts), this)();
-  });
   workstream.command("export").description(
     "Render a workstream's task graph + notes to a bucket directory of markdown. Bucket layout: <out>/README.md + INDEX.md + manifest.json (bucketVersion 2) + <ws>/{README.md,INDEX.md,tasks/<id>.md}. Idempotent + additive: re-export refreshes only changed task files; passing -w with a different workstream into the same --out appends a sibling source-ws subdir; deleted tasks are preserved with a banner. Pre-0.3 export dirs are not migrated in place."
   ).option(...WORKSTREAM_OPT).option("--out <dir>", "output directory (the bucket; defaults to ./<workstream>/)").option(...JSON_OPT).action(function() {
@@ -19857,9 +20555,9 @@ async function cmdBareTui(db, program, requestedWorkstreams) {
     throw err;
   }
 }
-function readPackageVersion() {
+function readPackageVersion2() {
   try {
-    const here = dirname7(fileURLToPath2(import.meta.url));
+    const here = dirname7(fileURLToPath3(import.meta.url));
     const pkgPath = join10(here, "..", "package.json");
     const raw = readFileSync3(pkgPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -19872,7 +20570,7 @@ function buildProgram() {
   const program = new Command();
   program.name("mu").description(
     "Persistent crew of AI agents in tmux panes coordinated through a built-in task DAG."
-  ).version(readPackageVersion()).helpOption("-h, --help").configureHelp({ sortSubcommands: true }).enablePositionalOptions().option(
+  ).version(readPackageVersion2()).helpOption("-h, --help").configureHelp({ sortSubcommands: true }).enablePositionalOptions().option(
     "-w, --workstream <names...>",
     "workstream(s) to render (repeat or comma-separate; or both; defaults to $MU_SESSION or current tmux session)"
   ).option(...JSON_OPT).action(function() {
@@ -19894,13 +20592,15 @@ function buildProgram() {
   wireStateCommands(program);
   wireSqlCommand(program);
   wireSnapshotCommands(program);
+  wireDbCommands(program);
   wireDoctorCommand(program);
   applyAlphabeticalHelpSort(program);
   applyExitOverride(program);
   return program;
 }
 function applyAlphabeticalHelpSort(cmd) {
-  cmd.configureHelp({ ...cmd.configureHelp(), sortSubcommands: true });
+  const keepSemanticOrder = cmd.name() === "archive";
+  cmd.configureHelp({ ...cmd.configureHelp(), sortSubcommands: !keepSemanticOrder });
   for (const sub of cmd.commands) {
     applyAlphabeticalHelpSort(sub);
   }