@martintrojer/mu 0.4.0 → 0.4.1

package/dist/index.js

@@ -5,8 +5,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() {
@@ -35,6 +36,7 @@ function openDb(options = {}) {
       throw new SchemaTooOldError(detectedVersion, MIN_ACCEPTED_SCHEMA_VERSION);
     }
     applySchema(db);
+    seedMachineIdentity(db);
   } else {
     db.pragma("foreign_keys = ON");
   }
@@ -120,6 +122,14 @@ function detectExistingSchemaVersion(db) {
   if (hasWorkstreams) return 1;
   return null;
 }
+function seedMachineIdentity(db) {
+  const row = db.prepare("SELECT COUNT(*) AS count FROM machine_identity").get();
+  if (row.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);
@@ -136,7 +146,7 @@ function applySchema(db) {
     CURRENT_SCHEMA_VERSION
   );
 }
-var CURRENT_SCHEMA_VERSION = 7;
+var CURRENT_SCHEMA_VERSION = 8;
 var MIN_ACCEPTED_SCHEMA_VERSION = 5;
 var EXPECTED_TABLES = [
   "agent_logs",
@@ -146,12 +156,14 @@ var EXPECTED_TABLES = [
   "archived_notes",
   "archived_tasks",
   "archives",
+  "machine_identity",
   "schema_version",
   "snapshots",
   "task_edges",
   "task_notes",
   "tasks",
   "vcs_workspaces",
+  "workstream_sync",
   "workstreams"
 ];
 var READY_VIEW_SQL = `
@@ -203,6 +215,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
@@ -214,6 +235,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,
@@ -503,8 +531,8 @@ function listLogs(db, opts = {}) {
   const rows = db.prepare(sql).all(...params);
   return rows.map(rowFromDb);
 }
-function latestSeq(db) {
-  const row = db.prepare("SELECT MAX(seq) AS s FROM agent_logs").get();
+function latestSeq(db, workstreamId) {
+  const row = 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 row.s ?? 0;
 }
 function emitEvent(db, workstream, payload, source = "system") {
@@ -565,13 +593,13 @@ var EVENT_VERB_PREFIXES = [
   "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).
@@ -2236,6 +2264,10 @@ var WorkspacePreservedError = class extends Error {
         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}`
@@ -4568,6 +4600,106 @@ function searchArchives(db, opts) {
   return hits.slice(0, limit);
 }
 
+// src/archives/restore.ts
+var ArchiveSourceAmbiguousError = class extends Error {
+  constructor(label, sources) {
+    super(
+      sources.length === 0 ? `archive ${label} contains no source workstreams` : `archive ${label} requires --source <orig-ws-name>. Available: ${sources.join(", ")}`
+    );
+    this.label = label;
+    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>`
+      }))
+    ];
+  }
+};
+function restoreArchive(db, label, asWorkstream, opts = {}) {
+  const archiveId = resolveArchiveId(db, label);
+  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(label, sources);
+  if (opts.sourceWorkstream === void 0 && sources.length > 1) {
+    throw new ArchiveSourceAmbiguousError(label, sources);
+  }
+  if (opts.sourceWorkstream !== void 0 && !sources.includes(opts.sourceWorkstream)) {
+    throw new ArchiveSourceAmbiguousError(label, sources);
+  }
+  if (tryResolveWorkstreamId(db, asWorkstream) !== null) {
+    throw new WorkstreamExistsError(asWorkstream);
+  }
+  captureSnapshot(db, `archive restore ${label} 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 ${label} source=${sourceWorkstream} as ${asWorkstream} (tasks=${restoredTasks}, edges=${restoredEdges}, notes=${restoredNotes})`
+    );
+    return {
+      archiveLabel: label,
+      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((row) => row.name);
+}
+
 // src/tasks/status.ts
 var TASK_STATUSES = [
   "OPEN",
@@ -5145,6 +5277,27 @@ function isValidWorkstreamName(name) {
   if (name.startsWith(RESERVED_WORKSTREAM_PREFIX)) return false;
   return true;
 }
+var 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`
+      }
+    ];
+  }
+};
 var 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.`;
@@ -6389,6 +6542,8 @@ async function listLiveAgents(db, opts) {
 }
 
 // src/dag.ts
+import pc2 from "picocolors";
+var RECURRENCE_MARKER = `  ${pc2.dim("(\u21BB)")}`;
 function loadFullDag(db, workstream, opts = {}) {
   const tasks = listTasks(db, workstream).filter(
     (t) => opts.statuses === void 0 || opts.statuses.has(t.status)
@@ -6427,7 +6582,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);
@@ -6486,7 +6641,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;
     }
@@ -6501,6 +6656,811 @@ function formatTreeNodeLabel(t, statusFn, opts = {}) {
   return `${base}  ${t.title}`;
 }
 
+// src/db-sync.ts
+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
+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;
+  }
+  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 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();
+  }
+}
+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])
+  );
+  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 }
+      });
+    }
+  }
+  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 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 = ?`
+    );
+    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 = ?`
+    );
+    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((row) => ({
+    localId: row.local_id,
+    title: row.title,
+    status: row.status,
+    impact: row.impact,
+    effortDays: row.effort_days,
+    createdAt: row.created_at,
+    updatedAt: row.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((row) => ({ ...row, hash: noteHash(row) }));
+}
+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 path = join8(
+    dir,
+    `${workstream}-${(/* @__PURE__ */ new Date()).toISOString()}-${randomUUID2().slice(0, 8)}.db`
+  );
+  const parkDb = openDb({ path });
+  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(path)) unlinkSync4(path);
+    } catch {
+    }
+    throw err;
+  }
+  parkDb.close();
+  return path;
+}
+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 row of rows) {
+    insert.run(
+      targetWsId,
+      row.name,
+      row.cli,
+      row.pane_id,
+      row.status,
+      row.role,
+      row.tab,
+      row.created_at,
+      row.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 row of rows) {
+    const ownerId = includeOwners && row.owner_name !== null ? ownerLookup.get(targetWsId, row.owner_name)?.id ?? null : null;
+    insert.run(
+      targetWsId,
+      row.local_id,
+      row.title,
+      row.status,
+      row.impact,
+      row.effort_days,
+      ownerId,
+      row.created_at,
+      row.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 row of rows) {
+    insert.run(row.created_at, targetWsId, row.from_local_id, targetWsId, row.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 row of rows) {
+    insert.run(row.author, row.content, row.created_at, targetWsId, row.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 row of rows) {
+    if (preserveSeq) {
+      insertPreserve.run(row.seq, targetWsId, row.source, row.kind, row.payload, row.created_at);
+    } else {
+      insertRenumber.run(targetWsId, row.source, row.kind, row.payload, row.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 row of rows) {
+    const agentId = agentLookup.get(targetWsId, row.agent_name)?.id;
+    if (agentId === void 0) continue;
+    insert.run(agentId, targetWsId, row.backend, row.path, row.parent_ref, row.created_at);
+  }
+}
+function copySync(sourceDb, targetDb, sourceWsId, targetWsId) {
+  const row = sourceDb.prepare("SELECT last_known_peer_seqs FROM workstream_sync WHERE workstream_id = ?").get(sourceWsId);
+  if (!row) return;
+  targetDb.prepare("INSERT INTO workstream_sync (workstream_id, last_known_peer_seqs) VALUES (?, ?)").run(targetWsId, row.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 row = db.prepare("SELECT last_known_peer_seqs FROM workstream_sync WHERE workstream_id = ?").get(workstreamId);
+  if (!row) return { sourceSeq: 0, localSeq: 0 };
+  const parsed = parsePeerSeqs(row.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 row = db.prepare(sql).get(...params);
+  return row?.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/tracks.ts
 function getParallelTracks(db, workstream) {
   const goals = listGoals(db, workstream).filter(
@@ -6603,544 +7563,6 @@ var UnionFind = class {
   }
 };
 
-// src/importing.ts
-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(path, line, raw) {
-    super(`failed to parse frontmatter at ${path}:${line}: ${raw}`);
-    this.path = path;
-    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(path) {
-  const raw = readFileSync2(path, "utf8");
-  const lines = raw.split("\n");
-  if (lines[0] !== "---") {
-    throw new ImportFrontmatterParseError(path, 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(path, 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(path, 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(path, 1, `missing frontmatter key: ${key}`);
-    }
-    return v;
-  }
-  const id = unquote(require2("id"));
-  if (id === null || id === "") {
-    throw new ImportFrontmatterParseError(path, 1, "id must be a non-empty string");
-  }
-  const workstream = unquote(require2("workstream"));
-  if (workstream === null || workstream === "") {
-    throw new ImportFrontmatterParseError(path, 1, "workstream must be a non-empty string");
-  }
-  const statusRaw = require2("status");
-  if (!isTaskStatus(statusRaw)) {
-    throw new ImportFrontmatterParseError(path, 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(path, 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(path, 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(
-      path,
-      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(
-      path,
-      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(path, 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(path, 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(path, 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/doctor-summary.ts
 function loadDoctorSummary(db, snapshot) {
   const checks = [];
@@ -7476,14 +7898,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 };
 }
 export {
   AgentDiedOnSpawnError,
@@ -7495,16 +7917,22 @@ export {
   ArchiveAlreadyExistsError,
   ArchiveLabelInvalidError,
   ArchiveNotFoundError,
+  ArchiveSourceAmbiguousError,
   CURRENT_SCHEMA_VERSION,
   ClaimerNotRegisteredError,
   CrossWorkstreamEdgeError,
   CycleError,
+  DbExportTargetExistsError,
+  DbImportConflictError,
+  DbImportManifestMissingError,
+  DbImportSchemaTooNewError,
+  DbImportSchemaTooOldError,
+  DbImportSourceStaleError,
+  DbReplayLocalIdConflictError,
+  DbReplayWorkstreamMissingError,
   EVENT_VERB_PREFIXES,
   EXPECTED_TABLES,
   HomeDirAsProjectRootError,
-  ImportBucketInvalidError,
-  ImportEdgeRefMissingError,
-  ImportFrontmatterParseError,
   NoForegroundProcessError,
   PANE_ID_RE,
   PaneNotFoundError,
@@ -7528,7 +7956,7 @@ export {
   WorkspaceNotFoundError,
   WorkspacePathNotEmptyError,
   WorkspacePreservedError,
-  WorkstreamAlreadyExistsError,
+  WorkstreamExistsError,
   WorkstreamNameInvalidError,
   addBlockEdge,
   addNote,
@@ -7539,6 +7967,8 @@ export {
   appendLog,
   assertValidPaneId,
   backendByName,
+  buildImportPlan,
+  buildReplayPlan,
   capturePane,
   captureSnapshot,
   checkCommandResolvable,
@@ -7570,6 +8000,7 @@ export {
   ensureWorkstream,
   envVarNameForCli,
   exportArchive,
+  exportDb,
   exportSourceForWorkstream,
   exportSourcesForArchive,
   exportWorkstream,
@@ -7594,7 +8025,7 @@ export {
   gitBackend,
   idFromTitle,
   idFromTitleVerbose,
-  importBucket,
+  importDb,
   insertAgent,
   isKickSignal,
   isStaleVersion,
@@ -7663,6 +8094,7 @@ export {
   renderTaskTree,
   renderToBucket,
   reparentTask,
+  replayDb,
   resetCommandResolverForTests,
   resetKickProcessExecutor,
   resetSleep,
@@ -7671,6 +8103,7 @@ export {
   resolveActorIdentity,
   resolveCliCommand,
   resolveCliCommandWithSource,
+  restoreArchive,
   restoreSnapshot,
   roiBucket,
   searchArchives,