@mu-crew/mu 3.9.0 → 3.10.0

package/dist/chunk-YIF3X32A.js

@@ -0,0 +1,2792 @@
+import {
+  defaultStateDir,
+  xdgStateHome
+} from "./chunk-4PACTXAB.js";
+
+// src/capture.ts
+var UNRESOLVED = "<unresolved>";
+var OP_CTX_DDL = `
+CREATE TEMP TABLE IF NOT EXISTS _op_ctx (
+  group_id TEXT,
+  actor    TEXT,
+  intent   TEXT,
+  applying INTEGER NOT NULL DEFAULT 0
+);
+CREATE TEMP TABLE IF NOT EXISTS _op_clock (
+  now_ms INTEGER NOT NULL DEFAULT 0
+);
+CREATE TEMP TABLE IF NOT EXISTS _op_dying (
+  kind TEXT NOT NULL,
+  id   INTEGER NOT NULL,
+  key  TEXT NOT NULL,
+  PRIMARY KEY (kind, id)
+);
+`;
+var OP_CTX_SEED = `
+INSERT INTO _op_ctx (group_id, actor, intent, applying)
+  SELECT NULL, NULL, NULL, 0 WHERE NOT EXISTS (SELECT 1 FROM _op_ctx);
+INSERT INTO _op_clock (now_ms)
+  SELECT 0 WHERE NOT EXISTS (SELECT 1 FROM _op_clock);
+`;
+var NOT_APPLYING = "(SELECT applying FROM _op_ctx) = 0";
+var ADVANCE_CLOCK = `
+  UPDATE _op_clock SET now_ms = CAST(unixepoch('subsec') * 1000 AS INTEGER);
+  UPDATE machine_identity
+     SET last_wall    = MAX(last_wall, (SELECT now_ms FROM _op_clock)),
+         last_counter = CASE WHEN (SELECT now_ms FROM _op_clock) > last_wall
+                             THEN 0 ELSE last_counter + 1 END
+   WHERE id = 1;`;
+var HLC = `(SELECT printf('%015d.%06d.%s', last_wall, last_counter, machine_id)
+                FROM machine_identity WHERE id = 1)`;
+var OP_COLS = "(hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at)";
+var OP_CTX_VALUES = `
+  (SELECT machine_id FROM machine_identity WHERE id = 1),
+  COALESCE((SELECT group_id FROM _op_ctx), lower(hex(randomblob(8)))),
+  (SELECT actor  FROM _op_ctx),
+  (SELECT intent FROM _op_ctx)`;
+var CREATED_AT = `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+var wsKey = (idExpr) => `COALESCE(
+  (SELECT w.name FROM workstreams w WHERE w.id = ${idExpr}),
+  (SELECT d.key FROM _op_dying d WHERE d.kind = 'workstream' AND d.id = ${idExpr}),
+  '${UNRESOLVED}')`;
+var taskKey = (idExpr) => `COALESCE(
+  (SELECT ${wsKey("t.workstream_id")} || '/' || t.local_id
+     FROM tasks t WHERE t.id = ${idExpr}),
+  (SELECT d.key FROM _op_dying d WHERE d.kind = 'task' AND d.id = ${idExpr}),
+  '${UNRESOLVED}')`;
+function changedPayload(cols) {
+  let expr = "'{}'";
+  for (const col of cols) {
+    expr = `CASE WHEN NEW.${col} IS NOT OLD.${col}
+                 THEN json_insert(${expr}, '$.${col}', NEW.${col})
+                 ELSE ${expr} END`;
+  }
+  return expr;
+}
+function fullPayload(cols) {
+  const pairs = cols.map((c) => `'${c}', NEW.${c}`).join(", ");
+  return `json_object(${pairs})`;
+}
+function fullOldPayload(cols) {
+  const pairs = cols.map((c) => `'${c}', OLD.${c}`).join(", ");
+  return `json_object(${pairs})`;
+}
+function noteTombstonePayload(keyExpr, cols) {
+  return `CASE WHEN EXISTS (
+      SELECT 1 FROM ops WHERE entity = 'note' AND key = ${keyExpr} AND op = 'put'
+    ) THEN '{}' ELSE ${fullOldPayload(cols)} END`;
+}
+function anyChanged(cols) {
+  return cols.map((c) => `NEW.${c} IS NOT OLD.${c}`).join("\n        OR ");
+}
+function emitOp(entity, opKind, keyExpr, payloadExpr) {
+  return `${ADVANCE_CLOCK}
+  INSERT INTO ops ${OP_COLS} VALUES (
+    ${HLC},${OP_CTX_VALUES},
+    '${entity}',
+    ${keyExpr},
+    '${opKind}',
+    ${payloadExpr},
+    ${CREATED_AT}
+  );`;
+}
+var CAPTURED_COLUMNS = {
+  workstreams: ["name", "created_at"],
+  tasks: [
+    "local_id",
+    "title",
+    "status",
+    "substate",
+    "impact",
+    "effort_days",
+    "owner_id",
+    "created_at",
+    "updated_at"
+  ],
+  task_notes: ["author", "content", "created_at"],
+  task_edges: ["created_at"]
+};
+var KEY_COLUMNS = {
+  workstreams: ["name"],
+  tasks: ["workstream_id", "local_id"],
+  task_notes: ["id", "task_id"],
+  task_edges: ["from_task_id", "to_task_id"]
+};
+function keyGuard(table) {
+  const cols = KEY_COLUMNS[table];
+  const msg = `mu: ${table}.${cols.join("/")} is part of the natural key that every op is filed under; changing it would desync the ops log, sync and undo. Add a new row (mu task add / mu workstream init) instead of moving or renaming one.`;
+  return `
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_${table}_key
+BEFORE UPDATE OF ${cols.join(", ")} ON ${table}
+  WHEN ${anyChanged(cols)}
+BEGIN
+  SELECT RAISE(ABORT, '${msg.replaceAll("'", "''")}');
+END;`;
+}
+var DYING_STASH = (kind, keyExpr) => `INSERT OR REPLACE INTO _op_dying (kind, id, key) VALUES ('${kind}', OLD.id, ${keyExpr});`;
+function buildTriggerDdl() {
+  const wsCols = CAPTURED_COLUMNS.workstreams;
+  const taskCols = CAPTURED_COLUMNS.tasks;
+  const noteCols = CAPTURED_COLUMNS.task_notes;
+  const edgeCols = CAPTURED_COLUMNS.task_edges;
+  const taskKeyNew = `${wsKey("NEW.workstream_id")} || '/' || NEW.local_id`;
+  const taskKeyOld = `${wsKey("OLD.workstream_id")} || '/' || OLD.local_id`;
+  const edgeKeyNew = `${taskKey("NEW.from_task_id")} || '->' || ${taskKey("NEW.to_task_id")}`;
+  const edgeKeyOld = `${taskKey("OLD.from_task_id")} || '->' || ${taskKey("OLD.to_task_id")}`;
+  return `
+-- \u2500\u2500\u2500 natural-key guards (see KEY_COLUMNS) \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
+${keyGuard("workstreams")}
+${keyGuard("tasks")}
+${keyGuard("task_notes")}
+${keyGuard("task_edges")}
+
+-- \u2500\u2500\u2500 workstreams \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
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_workstreams_ins
+AFTER INSERT ON workstreams WHEN ${NOT_APPLYING}
+BEGIN
+  ${emitOp("workstream", "put", "NEW.name", fullPayload(wsCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_workstreams_upd
+AFTER UPDATE ON workstreams WHEN ${NOT_APPLYING}
+  AND (${anyChanged(wsCols)})
+BEGIN
+  ${emitOp("workstream", "put", "NEW.name", changedPayload(wsCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_workstreams_del
+BEFORE DELETE ON workstreams WHEN ${NOT_APPLYING}
+BEGIN
+  ${DYING_STASH("workstream", "OLD.name")}
+  ${emitOp("workstream", "del", "OLD.name", "'{}'")}
+END;
+
+-- \u2500\u2500\u2500 tasks \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
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_tasks_ins
+AFTER INSERT ON tasks WHEN ${NOT_APPLYING}
+BEGIN
+  ${emitOp("task", "put", taskKeyNew, fullPayload(taskCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_tasks_upd
+AFTER UPDATE ON tasks WHEN ${NOT_APPLYING}
+  AND (${anyChanged(taskCols)})
+BEGIN
+  ${emitOp("task", "put", taskKeyNew, changedPayload(taskCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_tasks_del
+BEFORE DELETE ON tasks WHEN ${NOT_APPLYING}
+BEGIN
+  ${DYING_STASH("task", taskKeyOld)}
+  ${emitOp("task", "del", taskKeyOld, "'{}'")}
+END;
+
+-- \u2500\u2500\u2500 task_notes \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
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_notes_ins
+AFTER INSERT ON task_notes WHEN ${NOT_APPLYING}
+BEGIN
+  ${emitOp("note", "put", `${taskKey("NEW.task_id")} || '#' || NEW.id`, fullPayload(noteCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_notes_upd
+AFTER UPDATE ON task_notes WHEN ${NOT_APPLYING}
+  AND (${anyChanged(noteCols)})
+BEGIN
+  ${emitOp("note", "put", `${taskKey("NEW.task_id")} || '#' || NEW.id`, changedPayload(noteCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_notes_del
+BEFORE DELETE ON task_notes WHEN ${NOT_APPLYING}
+BEGIN
+  ${emitOp("note", "del", `${taskKey("OLD.task_id")} || '#' || OLD.id`, noteTombstonePayload(`${taskKey("OLD.task_id")} || '#' || OLD.id`, noteCols))}
+END;
+
+-- \u2500\u2500\u2500 task_edges \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_edges_ins
+AFTER INSERT ON task_edges WHEN ${NOT_APPLYING}
+BEGIN
+  ${emitOp("edge", "put", edgeKeyNew, fullPayload(edgeCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_edges_upd
+AFTER UPDATE ON task_edges WHEN ${NOT_APPLYING}
+  AND (${anyChanged(edgeCols)})
+BEGIN
+  ${emitOp("edge", "put", edgeKeyNew, changedPayload(edgeCols))}
+END;
+
+CREATE TEMP TRIGGER IF NOT EXISTS _cap_task_edges_del
+BEFORE DELETE ON task_edges WHEN ${NOT_APPLYING}
+BEGIN
+  ${emitOp("edge", "del", edgeKeyOld, "'{}'")}
+END;
+`;
+}
+var CAPTURE_TRIGGER_DDL = buildTriggerDdl();
+function captureBookkeepingChanges(db, groupId) {
+  const row = db.prepare(
+    `SELECT COUNT(*) AS ops,
+              COALESCE(SUM(op = 'del' AND entity IN ('workstream', 'task')), 0) AS stashed
+         FROM ops WHERE group_id = ?`
+  ).get(groupId);
+  return 3 * row.ops + row.stashed;
+}
+function installCapture(db) {
+  db.exec(OP_CTX_DDL);
+  db.exec(OP_CTX_SEED);
+  db.exec(CAPTURE_TRIGGER_DDL);
+}
+
+// src/tasks/status.ts
+var TASK_STATUSES = ["OPEN", "IN_PROGRESS", "CLOSED"];
+function isTaskStatus(s) {
+  return TASK_STATUSES.includes(s);
+}
+var TASK_STATUS_LIST = TASK_STATUSES.join(" | ");
+var TASK_SUBSTATES = {
+  OPEN: ["todo", "parked", "triage"],
+  IN_PROGRESS: ["active"],
+  CLOSED: ["done", "rejected", "wontfix", "duplicate", "superseded"]
+};
+var DEFAULT_SUBSTATE = { OPEN: "todo", IN_PROGRESS: "active", CLOSED: "done" };
+var TASK_SUBSTATE_ROWS = TASK_STATUSES.flatMap(
+  (status) => TASK_SUBSTATES[status].map(
+    (substate) => [status, substate, substate === DEFAULT_SUBSTATE[status] ? 1 : 0]
+  )
+);
+function isValidPair(status, substate) {
+  if (!isTaskStatus(status)) return false;
+  return TASK_SUBSTATES[status].includes(substate);
+}
+var LEGACY_STATUS_PAIRS = {
+  REJECTED: { status: "CLOSED", substate: "rejected" },
+  DEFERRED: { status: "OPEN", substate: "parked" }
+};
+function mapLegacyStatus(value) {
+  const pair = LEGACY_STATUS_PAIRS[value];
+  return pair ? { ...pair } : null;
+}
+function resolvePair(status, substate) {
+  const legacy = mapLegacyStatus(status);
+  if (legacy) return legacy;
+  if (!isTaskStatus(status)) return null;
+  if (typeof substate === "string" && isValidPair(status, substate)) {
+    return { status, substate };
+  }
+  return { status, substate: DEFAULT_SUBSTATE[status] };
+}
+function formatPair(pair) {
+  return pair.substate === DEFAULT_SUBSTATE[pair.status] ? pair.status : `${pair.status}/${pair.substate}`;
+}
+
+// src/db.ts
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { homedir, hostname } from "os";
+import { dirname, join, resolve } from "path";
+import Database from "better-sqlite3";
+var statementCache = /* @__PURE__ */ new WeakMap();
+function prepareCached(db, sql) {
+  let byDb = statementCache.get(db);
+  if (byDb === void 0) {
+    byDb = /* @__PURE__ */ new Map();
+    statementCache.set(db, byDb);
+  }
+  let stmt = byDb.get(sql);
+  if (stmt === void 0) {
+    stmt = db.prepare(sql);
+    byDb.set(sql, stmt);
+  }
+  return stmt;
+}
+function defaultDbPath() {
+  if (process.env.MU_DB_PATH) return process.env.MU_DB_PATH;
+  return join(defaultStateDir(), "mu.db");
+}
+function openDb(options = {}) {
+  const path = options.path ?? defaultDbPath();
+  refuseUserDbDuringTests(path);
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new Database(path, { readonly: options.readonly ?? false });
+  if (!options.readonly) {
+    db.pragma("busy_timeout = 5000");
+    const detectedVersion = detectExistingSchemaVersion(db);
+    if (detectedVersion !== null && detectedVersion > CURRENT_SCHEMA_VERSION) {
+      try {
+        db.close();
+      } catch {
+      }
+      throw new SchemaTooNewError(detectedVersion, CURRENT_SCHEMA_VERSION);
+    }
+    if (detectedVersion !== null && detectedVersion < MIN_ACCEPTED_SCHEMA_VERSION) {
+      try {
+        db.close();
+      } catch {
+      }
+      throw new SchemaTooOldError(detectedVersion, MIN_ACCEPTED_SCHEMA_VERSION);
+    }
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    if (detectedVersion !== CURRENT_SCHEMA_VERSION || !schemaIsCurrent(db)) applySchema(db);
+    seedMachineIdentity(db);
+    installCapture(db);
+  } else {
+    db.pragma("foreign_keys = ON");
+  }
+  return db;
+}
+function refuseUserDbDuringTests(path) {
+  const inTest = process.env.VITEST !== void 0 || process.env.NODE_ENV === "test";
+  if (!inTest) return;
+  const home = process.env.HOME ?? homedir();
+  const realDb = resolve(join(xdgStateHome(home), "mu", "mu.db"));
+  if (resolve(path) === realDb) {
+    throw new Error(
+      `openDb refused: tests must NEVER write to the user DB (${realDb}). Set MU_DB_PATH to a per-test temp path (test/_runCli.ts does this automatically) or pass an explicit { path } argument. The leak source is the call site of openDb in this stack frame.`
+    );
+  }
+}
+var WorkstreamNotFoundError = class extends Error {
+  constructor(workstream) {
+    super(`no such workstream: ${workstream}`);
+    this.workstream = workstream;
+  }
+  workstream;
+  name = "WorkstreamNotFoundError";
+  errorNextSteps() {
+    return [
+      { intent: "List workstreams", command: "mu workstream list" },
+      {
+        intent: "Initialise this workstream",
+        command: `mu workstream init ${this.workstream}`
+      }
+    ];
+  }
+};
+function resolveWorkstreamId(db, workstream) {
+  const row = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(workstream);
+  if (!row) throw new WorkstreamNotFoundError(workstream);
+  return row.id;
+}
+function tryResolveWorkstreamId(db, workstream) {
+  const row = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(workstream);
+  return row ? row.id : null;
+}
+var SchemaTooOldError = class extends Error {
+  constructor(detectedVersion, requiredVersion) {
+    super(
+      `Detected v${detectedVersion} schema; v${requiredVersion} is required. mu ships NO in-place migration \u2014 your v${detectedVersion} DB is untouched. Back it up or move it aside, then start a fresh v${requiredVersion} DB.`
+    );
+    this.detectedVersion = detectedVersion;
+    this.requiredVersion = requiredVersion;
+  }
+  detectedVersion;
+  requiredVersion;
+  name = "SchemaTooOldError";
+  errorNextSteps() {
+    return [
+      {
+        intent: "Keep a copy of the old DB before anything else",
+        command: `mu db backup "$HOME/mu-v${this.detectedVersion}-backup.db"`
+      },
+      {
+        intent: "Move the old DB aside without deleting it",
+        command: `mv "\${MU_DB_PATH:-$HOME/.local/state/mu/mu.db}" "\${MU_DB_PATH:-$HOME/.local/state/mu/mu.db}.old"`
+      },
+      {
+        intent: `Migrate the old DB into a fresh v${this.requiredVersion} DB (run in a mu git checkout: the npm package does not ship scripts/)`,
+        command: `npx tsx scripts/migrate.ts "\${MU_DB_PATH:-$HOME/.local/state/mu/mu.db}.old" --out /tmp/mu-v${this.requiredVersion}.db`
+      },
+      {
+        intent: "Verify the fresh DB before swapping",
+        command: `MU_DB_PATH=/tmp/mu-v${this.requiredVersion}.db mu doctor --deep`
+      }
+    ];
+  }
+};
+var SchemaTooNewError = class extends Error {
+  constructor(detectedVersion, supportedVersion) {
+    super(`DB is v${detectedVersion}; this mu understands up to v${supportedVersion}. Upgrade mu.`);
+    this.detectedVersion = detectedVersion;
+    this.supportedVersion = supportedVersion;
+  }
+  detectedVersion;
+  supportedVersion;
+  name = "SchemaTooNewError";
+  errorNextSteps() {
+    return [{ intent: "Check which mu is on PATH", command: "which mu && mu --version" }];
+  }
+};
+function detectExistingSchemaVersion(db) {
+  const hasVersionTable = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
+  if (hasVersionTable) {
+    const row = db.prepare("SELECT version FROM schema_version WHERE id = 1").get();
+    return row?.version ?? null;
+  }
+  const hasWorkstreams = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workstreams'").get();
+  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) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    db.exec(CURRENT_SCHEMA);
+    const seed = db.prepare(
+      "INSERT OR IGNORE INTO task_substates (status, substate, is_default) VALUES (?, ?, ?)"
+    );
+    for (const [status, substate, isDefault] of TASK_SUBSTATE_ROWS) {
+      seed.run(status, substate, isDefault);
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/already exists/i.test(msg)) throw err;
+  }
+  db.prepare("INSERT OR IGNORE INTO schema_version (id, version) VALUES (1, ?)").run(
+    CURRENT_SCHEMA_VERSION
+  );
+}
+var expectedCache;
+function expectedObjects() {
+  if (expectedCache !== void 0) return expectedCache;
+  const names = (re) => [...CURRENT_SCHEMA.matchAll(re)].map((m) => m[1]).filter((n) => n !== void 0);
+  const views = /* @__PURE__ */ new Map();
+  for (const sql of [READY_VIEW_SQL, BLOCKED_VIEW_SQL, GOALS_VIEW_SQL]) {
+    const m = /CREATE VIEW (\w+)[^;]*/.exec(sql);
+    if (m?.[1] !== void 0) views.set(m[1], m[0]);
+  }
+  expectedCache = {
+    tables: names(/CREATE TABLE IF NOT EXISTS (\w+)/g),
+    indexes: names(/CREATE (?:UNIQUE )?INDEX IF NOT EXISTS (\w+)/g),
+    views
+  };
+  return expectedCache;
+}
+function schemaIsCurrent(db) {
+  const rows = db.prepare("SELECT type, name, sql FROM sqlite_master").all();
+  const have = new Map(rows.map((r) => [`${r.type}:${r.name}`, r.sql]));
+  const expected = expectedObjects();
+  if (expected.tables.some((t) => !have.has(`table:${t}`))) return false;
+  if (expected.indexes.some((i) => !have.has(`index:${i}`))) return false;
+  for (const [name, sql] of expected.views) {
+    if (have.get(`view:${name}`) !== sql) return false;
+  }
+  const pairs = new Set(
+    db.prepare("SELECT status, substate FROM task_substates").all().map((r) => `${r.status}/${r.substate}`)
+  );
+  return TASK_SUBSTATE_ROWS.every(([status, substate]) => pairs.has(`${status}/${substate}`));
+}
+var CURRENT_SCHEMA_VERSION = 11;
+var MIN_ACCEPTED_SCHEMA_VERSION = 11;
+var EXPECTED_TABLES = [
+  "agents",
+  "machine_identity",
+  "ops",
+  "schema_version",
+  "sync_fingerprints",
+  "sync_peers",
+  "task_edges",
+  "task_notes",
+  "task_substates",
+  "tasks",
+  "vcs_workspaces",
+  "workstreams"
+];
+var SYNCED_ENTITIES = ["workstream", "task", "edge", "note", "message"];
+var MACHINE_LOCAL_ENTITIES = ["agent", "workspace", "event", "broadcast"];
+var PORTABLE_TABLES = ["task_edges", "task_notes", "tasks", "workstreams"];
+var MACHINE_LOCAL_TABLES = [
+  "agents",
+  "machine_identity",
+  "ops",
+  "schema_version",
+  "sync_fingerprints",
+  "sync_peers",
+  "task_substates",
+  "vcs_workspaces"
+];
+var READY_VIEW_SQL = `
+DROP VIEW IF EXISTS ready;
+CREATE VIEW ready AS
+  SELECT t.*
+    FROM tasks t
+   WHERE t.status = 'OPEN'
+     AND t.substate NOT IN ('parked', 'triage')
+     AND NOT EXISTS (
+       SELECT 1
+         FROM task_edges e
+         JOIN tasks      b ON e.from_task_id = b.id
+        WHERE e.to_task_id = t.id
+          AND b.status <> 'CLOSED'
+     );
+`;
+var BLOCKED_VIEW_SQL = `
+DROP VIEW IF EXISTS blocked;
+CREATE VIEW blocked AS
+  SELECT t.*
+    FROM tasks t
+   WHERE t.status = 'OPEN'
+     AND EXISTS (
+       SELECT 1
+         FROM task_edges e
+         JOIN tasks      b ON e.from_task_id = b.id
+        WHERE e.to_task_id = t.id
+          AND b.status <> 'CLOSED'
+     );
+`;
+var GOALS_VIEW_SQL = `
+DROP VIEW IF EXISTS goals;
+CREATE VIEW goals AS
+  SELECT t.*
+    FROM tasks t
+   WHERE t.status <> 'CLOSED'
+     AND NOT EXISTS (
+       SELECT 1 FROM task_edges WHERE from_task_id = t.id
+     );
+`;
+var CURRENT_SCHEMA = `
+-- \u2500\u2500\u2500 Schema versioning \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
+--
+-- Single-row table tracking which schema version this DB is at. Migrations
+-- read and update this; the row is INSERT-OR-IGNOREd by applySchema with
+-- the current version on a fresh DB.
+CREATE TABLE IF NOT EXISTS schema_version (
+  id      INTEGER PRIMARY KEY CHECK (id = 1),
+  version INTEGER NOT NULL
+);
+
+-- machine_identity: one durable identity per DB/machine, seeded by
+-- openDb after schema creation. hostname is advisory only.
+--
+-- last_wall / last_counter are the persisted hybrid logical clock
+-- (src/hlc.ts, VOCABULARY \xA7 HLC). They live here because every mu
+-- invocation is a fresh process \u2014 an in-memory counter would reset
+-- constantly and mint duplicate HLCs, which UNIQUE (machine_id, hlc)
+-- on the ops table would then reject.
+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,
+  last_wall    INTEGER NOT NULL DEFAULT 0,
+  last_counter INTEGER NOT NULL DEFAULT 0
+);
+
+-- \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
+-- because it IS a tmux session name; no <scope_id> column because
+-- there's no parent.
+CREATE TABLE IF NOT EXISTS workstreams (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  name        TEXT UNIQUE NOT NULL,
+  created_at  TEXT NOT NULL                  -- ISO 8601
+);
+
+
+-- agents: one row per managed pane. Per-workstream unique on name.
+CREATE TABLE IF NOT EXISTS agents (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  workstream_id INTEGER NOT NULL REFERENCES workstreams (id) ON DELETE CASCADE,
+  name          TEXT NOT NULL,                  -- per-workstream unique
+  cli           TEXT NOT NULL DEFAULT 'pi',
+  pane_id       TEXT NOT NULL,
+  status        TEXT NOT NULL,                    -- DEPRECATED (2.0): always 'spawning'; runtime state lives in murmur. Drop at the first v11 migration.
+  role          TEXT NOT NULL DEFAULT 'full-access',
+  tab           TEXT,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL,
+  UNIQUE (workstream_id, name),
+  CHECK (status IN (
+    'spawning', 'busy', 'needs_input', 'needs_permission',
+    'free', 'unreachable', 'terminated'
+  )),
+  CHECK (role IN ('full-access', 'read-only'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_agents_workstream ON agents (workstream_id);
+CREATE INDEX IF NOT EXISTS idx_agents_status ON agents (status);
+
+-- task_substates: the legal (status, substate) pairs. Seeded from
+-- TASK_SUBSTATE_ROWS (src/tasks/status.ts) by applySchema; exactly one
+-- default per status.
+CREATE TABLE IF NOT EXISTS task_substates (
+  status     TEXT NOT NULL,
+  substate   TEXT NOT NULL,
+  is_default INTEGER NOT NULL DEFAULT 0 CHECK (is_default IN (0, 1)),
+  PRIMARY KEY (status, substate)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_task_substates_one_default
+  ON task_substates (status) WHERE is_default = 1;
+
+-- tasks: per-workstream unique on local_id (TRULY local now \u2014
+-- different workstreams may reuse the same local_id).
+CREATE TABLE IF NOT EXISTS tasks (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  workstream_id INTEGER NOT NULL REFERENCES workstreams (id) ON DELETE CASCADE,
+  local_id      TEXT NOT NULL,                 -- per-workstream unique
+  title         TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'OPEN',
+  -- OPEN | IN_PROGRESS | CLOSED \u2014 see VOCABULARY.md.
+  substate      TEXT NOT NULL,
+  -- Qualifies status. No DEFAULT on purpose: a writer that forgets it
+  -- must fail loudly rather than silently pick one.
+  impact        INTEGER NOT NULL,
+  effort_days   REAL NOT NULL,
+  owner_id      INTEGER REFERENCES agents (id) ON DELETE SET NULL,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL,
+  UNIQUE (workstream_id, local_id),
+  CHECK (impact BETWEEN 1 AND 100),
+  CHECK (effort_days > 0),
+  FOREIGN KEY (status, substate) REFERENCES task_substates (status, substate)
+    DEFERRABLE INITIALLY DEFERRED
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_workstream ON tasks (workstream_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks (status);
+CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks (owner_id);
+
+-- task_edges: composite PK by pair. INTEGER FKs into tasks.id.
+CREATE TABLE IF NOT EXISTS task_edges (
+  from_task_id INTEGER NOT NULL REFERENCES tasks (id) ON DELETE CASCADE,
+  to_task_id   INTEGER NOT NULL REFERENCES tasks (id) ON DELETE CASCADE,
+  created_at   TEXT NOT NULL,
+  PRIMARY KEY (from_task_id, to_task_id),
+  CHECK (from_task_id <> to_task_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_edges_to ON task_edges (to_task_id);
+
+-- task_notes: append-only context. author stays free-text
+-- ("orchestrator", "user", "\u03C0 - mu", "system") \u2014 not always a
+-- registered agent.
+CREATE TABLE IF NOT EXISTS task_notes (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id    INTEGER NOT NULL REFERENCES tasks (id) ON DELETE CASCADE,
+  author     TEXT,
+  content    TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_notes_task ON task_notes (task_id);
+
+-- \u2500\u2500\u2500 The ops log (VISION.md \xA7 2b, VOCABULARY.md \xA7 op / ops log) \u2500\u2500\u2500\u2500\u2500\u2500
+--
+-- The single append-only record of every change. Sync, undo, and
+-- history are all queries or replays over this one table.
+--
+-- Deliberately FK-free. An op must stay readable after the row (and
+-- the workstream) it records is gone \u2014 a tombstone op for a destroyed
+-- workstream is the whole point \u2014 so 'key' holds the NATURAL key
+-- ('<workstream>/<local_id>'), never a surrogate id. That is also why
+-- keys don't collide across machines.
+--
+--   seq        local-only append cursor (AUTOINCREMENT never recycles)
+--   hlc        the ORDERING key across machines (VOCABULARY \xA7 HLC)
+--   machine_id which peer wrote this op
+--   group_id   the undo unit: all ops of one operator action
+--   actor      who caused it (may not be a registered worker)
+--   intent     semantic label ('task.close', 'agent.spawn')
+--   entity/key what it addresses ('task', 'mu/ops-log')
+--   op         'put' (semantic partial update) | 'del' (tombstone)
+--   payload    JSON of ONLY the columns that changed
+--
+-- UNIQUE (machine_id, hlc) is load-bearing: it makes ingest idempotent
+-- for free, which is what lets 'mu sync --repair' be nothing more than
+-- "re-read that peer's segment from zero".
+CREATE TABLE IF NOT EXISTS ops (
+  seq        INTEGER PRIMARY KEY AUTOINCREMENT,
+  hlc        TEXT NOT NULL,
+  machine_id TEXT NOT NULL,
+  group_id   TEXT NOT NULL,
+  actor      TEXT,
+  intent     TEXT,
+  entity     TEXT NOT NULL,
+  key        TEXT NOT NULL,
+  op         TEXT NOT NULL CHECK (op IN ('put','del')),
+  payload    TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  UNIQUE (machine_id, hlc)
+);
+
+-- Four indexes, one per read shape that actually exists:
+--   hlc         \u2014 replay/rebuild walks the log in HLC order.
+--   entity,key  \u2014 "what happened to this task" (history + per-field merge).
+--   group_id    \u2014 'mu undo <group>' gathers one action's ops.
+--   machine_id,entity,hlc \u2014 sync flush seeks this machine's SYNCED ops
+--                 past the segment's last hlc, so a trailing run of
+--                 machine-local ops (agent.*) costs nothing per flush.
+-- (Other machine_id lookups ride the UNIQUE (machine_id, hlc) index;
+-- seq is the PK. No speculative index beyond these.)
+CREATE INDEX IF NOT EXISTS idx_ops_hlc ON ops (hlc);
+CREATE INDEX IF NOT EXISTS idx_ops_entity_key ON ops (entity, key);
+CREATE INDEX IF NOT EXISTS idx_ops_group ON ops (group_id);
+CREATE INDEX IF NOT EXISTS idx_ops_machine_entity_hlc ON ops (machine_id, entity, hlc);
+
+-- sync_peers: one row per known peer, holding its watermark \u2014 how far
+-- into that peer's segment we have applied. One integer suffices
+-- because segments are append-only and ordered. Rows are created on
+-- demand at first ingest; there is no membership list to configure.
+-- A Syncthing conflict copy gets its own row, keyed by its file stem.
+-- last_seen_at is the ISO time of the last watermark write.
+CREATE TABLE IF NOT EXISTS sync_peers (
+  machine_id       TEXT PRIMARY KEY,
+  last_applied_seq INTEGER NOT NULL DEFAULT 0,
+  last_seen_at     TEXT
+);
+
+-- sync_fingerprints: the caught-up fingerprint, '<size> <mtimeMs>
+-- <manifest sha256>' of a peer segment, recorded with the watermark
+-- when ingest read that segment cleanly to its end (src/segments.ts
+-- segmentCaughtUp). Keyed like sync_peers; a watermark write without a
+-- clean read deletes the row. A cache: losing it costs one full read.
+-- Additive, so no schema bump: an older mu ignores it, and any
+-- watermark it writes can no longer match a stale fingerprint.
+CREATE TABLE IF NOT EXISTS sync_fingerprints (
+  machine_id  TEXT PRIMARY KEY,
+  fingerprint TEXT NOT NULL
+);
+
+-- vcs_workspaces: one isolated working copy per agent.
+-- UNIQUE (agent_id) enforces the 1:1 invariant; workstream_id is
+-- denormalised for query convenience. path is UNIQUE because two
+-- agents pointing at the same on-disk workspace would defeat the
+-- purpose.
+CREATE TABLE IF NOT EXISTS vcs_workspaces (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id      INTEGER NOT NULL UNIQUE REFERENCES agents (id) ON DELETE CASCADE,
+  workstream_id INTEGER NOT NULL REFERENCES workstreams (id) ON DELETE CASCADE,
+  backend       TEXT NOT NULL CHECK (backend IN ('jj', 'sl', 'git', 'none')),
+  path          TEXT NOT NULL UNIQUE,
+  parent_ref    TEXT,
+  created_at    TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_vcs_workspaces_workstream ON vcs_workspaces (workstream_id);
+
+-- \u2500\u2500\u2500 Views (replaced when stale so the latest definition wins) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+-- See READY_VIEW_SQL / BLOCKED_VIEW_SQL / GOALS_VIEW_SQL above for the
+-- canonical DDL \u2014 interpolated here so applySchema is one db.exec().
+${READY_VIEW_SQL}
+${BLOCKED_VIEW_SQL}
+${GOALS_VIEW_SQL}
+`;
+
+// src/hlc.ts
+var WALL_WIDTH = 15;
+var COUNTER_WIDTH = 6;
+var SEP = ".";
+var MAX_WALL = 10 ** WALL_WIDTH - 1;
+var MAX_COUNTER = 10 ** COUNTER_WIDTH - 1;
+var HlcParseError = class extends Error {
+  constructor(value) {
+    super(`Malformed HLC: ${JSON.stringify(value)}`);
+    this.value = value;
+    this.name = "HlcParseError";
+  }
+  value;
+};
+var HlcOverflowError = class extends Error {
+  constructor(field, value) {
+    super(
+      field === "counter" ? `HLC counter overflow (${value} > ${MAX_COUNTER}): more than ${MAX_COUNTER + 1} ops in one millisecond` : `HLC wall-clock overflow (${value} > ${MAX_WALL}): system clock is far in the future`
+    );
+    this.field = field;
+    this.value = value;
+    this.name = "HlcOverflowError";
+  }
+  field;
+  value;
+};
+var MachineIdentityMissingError = class extends Error {
+  constructor() {
+    super("machine_identity row (id = 1) is missing; the DB was not opened via openDb()");
+    this.name = "MachineIdentityMissingError";
+  }
+};
+function formatHlc(hlc) {
+  const { wallMs, counter, machineId } = hlc;
+  if (!Number.isInteger(wallMs) || wallMs < 0) throw new HlcParseError(String(wallMs));
+  if (!Number.isInteger(counter) || counter < 0) throw new HlcParseError(String(counter));
+  if (wallMs > MAX_WALL) throw new HlcOverflowError("wall", wallMs);
+  if (counter > MAX_COUNTER) throw new HlcOverflowError("counter", counter);
+  if (machineId.length === 0 || machineId.includes(SEP)) throw new HlcParseError(machineId);
+  return `${String(wallMs).padStart(WALL_WIDTH, "0")}${SEP}${String(counter).padStart(
+    COUNTER_WIDTH,
+    "0"
+  )}${SEP}${machineId}`;
+}
+function parseHlc(value) {
+  const parts = value.split(SEP);
+  if (parts.length !== 3) throw new HlcParseError(value);
+  const [wall, counter, machineId] = parts;
+  if (wall === void 0 || counter === void 0 || machineId === void 0) {
+    throw new HlcParseError(value);
+  }
+  if (wall.length !== WALL_WIDTH || counter.length !== COUNTER_WIDTH || machineId.length === 0) {
+    throw new HlcParseError(value);
+  }
+  if (!/^\d+$/.test(wall) || !/^\d+$/.test(counter)) throw new HlcParseError(value);
+  return { wallMs: Number(wall), counter: Number(counter), machineId };
+}
+function compareHlc(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function nextHlc(db, now = Date.now()) {
+  const row = db.prepare(
+    `UPDATE machine_identity
+          SET last_wall    = MAX(last_wall, @now),
+              last_counter = CASE WHEN @now > last_wall THEN 0 ELSE last_counter + 1 END
+        WHERE id = 1
+        RETURNING machine_id, last_wall, last_counter`
+  ).get({ now: Math.floor(now) });
+  if (!row) throw new MachineIdentityMissingError();
+  return formatHlc({ wallMs: row.last_wall, counter: row.last_counter, machineId: row.machine_id });
+}
+function receiveHlc(db, remoteHlc, now = Date.now()) {
+  const remote = parseHlc(remoteHlc);
+  const wallNow = Math.floor(now);
+  const read = prepareCached(
+    db,
+    "SELECT machine_id, last_wall, last_counter FROM machine_identity WHERE id = 1"
+  );
+  const write = prepareCached(
+    db,
+    "UPDATE machine_identity SET last_wall = @wall, last_counter = @counter WHERE id = 1"
+  );
+  const advance = () => {
+    const row = read.get();
+    if (!row) throw new MachineIdentityMissingError();
+    const wall = Math.max(row.last_wall, remote.wallMs, wallNow);
+    const localAtMax = row.last_wall === wall;
+    const remoteAtMax = remote.wallMs === wall;
+    let counter;
+    if (!localAtMax && !remoteAtMax) {
+      counter = 0;
+    } else if (localAtMax && remoteAtMax) {
+      counter = Math.max(row.last_counter, remote.counter) + 1;
+    } else if (localAtMax) {
+      counter = row.last_counter + 1;
+    } else {
+      counter = remote.counter + 1;
+    }
+    if (counter > MAX_COUNTER) throw new HlcOverflowError("counter", counter);
+    write.run({ wall, counter });
+    return formatHlc({ wallMs: wall, counter, machineId: row.machine_id });
+  };
+  if (db.inTransaction) return advance();
+  return db.transaction(advance).immediate();
+}
+
+// src/op-context.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function currentOpContext(db) {
+  const row = db.prepare("SELECT group_id, actor, intent, applying FROM _op_ctx").get();
+  if (!row) return { groupId: null, actor: null, intent: null, applying: false };
+  return {
+    groupId: row.group_id,
+    actor: row.actor,
+    intent: row.intent,
+    applying: row.applying !== 0
+  };
+}
+function writeCtx(db, row) {
+  prepareCached(
+    db,
+    `UPDATE _op_ctx SET group_id = @group_id, actor = @actor,
+                        intent = @intent, applying = @applying`
+  ).run(row);
+}
+function readCtx(db) {
+  return prepareCached(db, "SELECT group_id, actor, intent, applying FROM _op_ctx").get();
+}
+function withOpContext(db, ctx, fn) {
+  const previous = readCtx(db);
+  if (!previous) {
+    return fn();
+  }
+  const groupId = ctx.group === "new" ? randomUUID2() : ctx.group !== void 0 ? ctx.group : previous.group_id ?? randomUUID2();
+  const intent = ctx.intent !== void 0 ? ctx.intent : previous.intent ?? ctx.intentIfUnset ?? null;
+  writeCtx(db, {
+    group_id: groupId,
+    // An explicit undefined inherits; only a provided value overrides.
+    actor: ctx.actor !== void 0 ? ctx.actor : previous.actor,
+    intent,
+    applying: previous.applying
+  });
+  try {
+    return fn();
+  } finally {
+    writeCtx(db, previous);
+  }
+}
+function withCaptureSuppressed(db, fn) {
+  const previous = readCtx(db);
+  if (!previous) return fn();
+  writeCtx(db, { ...previous, applying: 1 });
+  try {
+    return fn();
+  } finally {
+    writeCtx(db, previous);
+  }
+}
+
+// src/file-lock.ts
+import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+function locksDir() {
+  return join2(defaultStateDir(), "locks");
+}
+var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
+var DEFAULT_STALE_LOCK_MS = 3e4;
+var RETRY_INTERVAL_MS = 25;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function resolveTimeout(opts) {
+  const envVar = opts?.timeoutEnvVar;
+  if (envVar !== void 0) {
+    const raw = process.env[envVar];
+    if (raw !== void 0 && raw !== "") {
+      const n = Number.parseInt(raw, 10);
+      if (Number.isFinite(n) && n >= 0) return n;
+    }
+  }
+  return opts?.acquireTimeoutMs ?? DEFAULT_ACQUIRE_TIMEOUT_MS;
+}
+async function isStale(path, staleMs) {
+  try {
+    const s = await stat(path);
+    return Date.now() - s.mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+async function withFileLock(lockPath, label, fn, opts) {
+  const staleMs = opts?.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+  const deadline = Date.now() + resolveTimeout(opts);
+  const onUnavailable = opts?.onUnavailable;
+  const unlocked = async () => onUnavailable === void 0 ? await fn() : onUnavailable();
+  let held = false;
+  try {
+    await mkdir(locksDir(), { recursive: true });
+  } catch {
+    return await unlocked();
+  }
+  while (!held) {
+    try {
+      await mkdir(lockPath);
+      held = true;
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST") return await unlocked();
+      if (await isStale(lockPath, staleMs)) {
+        await rm(lockPath, { recursive: true, force: true }).catch(() => {
+        });
+        continue;
+      }
+      if (Date.now() >= deadline) return await unlocked();
+      await sleep(RETRY_INTERVAL_MS);
+    }
+  }
+  await writeFile(
+    join2(lockPath, "meta.json"),
+    JSON.stringify({ pid: process.pid, label, acquiredAt: (/* @__PURE__ */ new Date()).toISOString() })
+  ).catch(() => {
+  });
+  try {
+    return await fn();
+  } finally {
+    await rm(lockPath, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function readFileLockMeta(lockPath) {
+  try {
+    const raw = await readFile(join2(lockPath, "meta.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/legacy-ops.ts
+var LEGACY_LOG_ONLY_INTENTS = /* @__PURE__ */ new Set(["workstream.export"]);
+function isLegacyLogOnlyIntent(intent) {
+  return intent !== null && LEGACY_LOG_ONLY_INTENTS.has(intent);
+}
+var LEGACY_LOG_ONLY_SQL_EXCLUSION = `(intent IS NULL OR intent NOT IN (${[
+  ...LEGACY_LOG_ONLY_INTENTS
+].map((i) => `'${i}'`).join(", ")}))`;
+var LEGACY_INTENT_SYNONYMS = /* @__PURE__ */ new Map([
+  ["workstream.teardown", ["workstream.destroy"]]
+]);
+function intentSpellings(intent) {
+  const legacy = LEGACY_INTENT_SYNONYMS.get(intent);
+  return legacy === void 0 ? [intent] : [intent, ...legacy];
+}
+
+// src/apply.ts
+var OpEntityNotSyncedError = class extends Error {
+  constructor(entity) {
+    super(
+      `op entity ${JSON.stringify(entity)} is machine-local and must never arrive from a peer (synced entities: ${SYNCED_ENTITIES.join(", ")})`
+    );
+    this.entity = entity;
+    this.name = "OpEntityNotSyncedError";
+  }
+  entity;
+};
+var OpKeyMalformedError = class extends Error {
+  constructor(entity, key) {
+    super(`malformed ${entity} key: ${JSON.stringify(key)}`);
+    this.entity = entity;
+    this.key = key;
+    this.name = "OpKeyMalformedError";
+  }
+  entity;
+  key;
+};
+function isSyncedEntity(entity) {
+  return SYNCED_ENTITIES.includes(entity);
+}
+function isKnownMachineLocalEntity(entity) {
+  return MACHINE_LOCAL_ENTITIES.includes(entity);
+}
+function fieldHlc(db, op, field) {
+  const row = prepareCached(
+    db,
+    `SELECT MAX(hlc) AS hlc
+         FROM ops
+        WHERE entity = @entity
+          AND key    = @key
+          AND op     = 'put'
+          AND hlc   <> @self
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+          AND json_type(payload, '$.' || @field) IS NOT NULL`
+  ).get({ entity: op.entity, key: op.key, self: op.hlc, field });
+  return row?.hlc ?? null;
+}
+function tombstoneHlc(db, op) {
+  const row = prepareCached(
+    db,
+    `SELECT MAX(hlc) AS hlc
+         FROM ops
+        WHERE entity = @entity AND key = @key AND op = 'del' AND hlc <> @self`
+  ).get({ entity: op.entity, key: op.key, self: op.hlc });
+  return row?.hlc ?? null;
+}
+function anyHlc(db, op, kind) {
+  const row = prepareCached(
+    db,
+    `SELECT MAX(hlc) AS hlc
+         FROM ops
+        WHERE entity = @entity AND key = @key AND op = @kind AND hlc <> @self`
+  ).get({ entity: op.entity, key: op.key, kind, self: op.hlc });
+  return row?.hlc ?? null;
+}
+function wins(candidate, incumbent) {
+  if (incumbent === null) return true;
+  return compareHlc(candidate, incumbent) > 0;
+}
+function decodePayload(payload) {
+  const parsed = JSON.parse(payload);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new SyntaxError(`op payload must be a JSON object, got ${payload.slice(0, 40)}`);
+  }
+  const entries = [];
+  for (const [field, value] of Object.entries(parsed)) {
+    if (value === null || typeof value === "string" || typeof value === "number") {
+      entries.push([field, value]);
+      continue;
+    }
+    if (typeof value === "boolean") {
+      entries.push([field, value ? 1 : 0]);
+      continue;
+    }
+    throw new SyntaxError(`op payload field ${JSON.stringify(field)} has unsupported type`);
+  }
+  return entries;
+}
+function parseTaskKey(key) {
+  const slash = key.indexOf("/");
+  if (slash <= 0 || slash === key.length - 1) throw new OpKeyMalformedError("task", key);
+  const workstream = key.slice(0, slash);
+  const localId = key.slice(slash + 1);
+  if (workstream.length === 0 || localId.length === 0) {
+    throw new OpKeyMalformedError("task", key);
+  }
+  return { workstream, localId };
+}
+function parseNoteKey(key) {
+  const hash = key.lastIndexOf("#");
+  if (hash <= 0 || hash === key.length - 1) throw new OpKeyMalformedError("note", key);
+  return { taskKey: key.slice(0, hash) };
+}
+function parseEdgeKey(key) {
+  const arrow = key.indexOf("->");
+  if (arrow <= 0) throw new OpKeyMalformedError("edge", key);
+  const blocker = key.slice(0, arrow);
+  const blocked = key.slice(arrow + 2);
+  if (blocker.length === 0 || blocked.length === 0) throw new OpKeyMalformedError("edge", key);
+  return { blocker, blocked };
+}
+var NEVER_APPLY = /* @__PURE__ */ new Set(["owner_id", "local_id", "name", "id", "workstream_id", "task_id"]);
+function ensureWorkstreamRow(db, name) {
+  const existing = prepareCached(db, "SELECT id FROM workstreams WHERE name = ?").get(name);
+  if (existing) return existing.id;
+  prepareCached(db, "INSERT INTO workstreams (name, created_at) VALUES (?, ?)").run(
+    name,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const created = prepareCached(db, "SELECT id FROM workstreams WHERE name = ?").get(name);
+  if (!created) throw new Error(`failed to create workstream row for ${name}`);
+  return created.id;
+}
+function taskRowId(db, key) {
+  const { workstream, localId } = parseTaskKey(key);
+  const row = prepareCached(
+    db,
+    `SELECT t.id AS id
+         FROM tasks t
+         JOIN workstreams w ON w.id = t.workstream_id
+        WHERE w.name = ? AND t.local_id = ?`
+  ).get(workstream, localId);
+  return row?.id ?? null;
+}
+function applyFieldLww(db, op, table, rowId, entries) {
+  const applied = [];
+  for (const [field, value] of entries) {
+    if (NEVER_APPLY.has(field)) continue;
+    if (!wins(op.hlc, fieldHlc(db, op, field))) continue;
+    const current = prepareCached(db, `SELECT ${field} AS v FROM ${table} WHERE id = ?`).get(
+      rowId
+    );
+    if (current !== void 0 && current.v === value) continue;
+    prepareCached(db, `UPDATE ${table} SET ${field} = ? WHERE id = ?`).run(value, rowId);
+    applied.push(field);
+  }
+  return applied;
+}
+var APPLIABLE_COLUMNS = {
+  tasks: ["title", "status", "substate", "impact", "effort_days", "created_at", "updated_at"],
+  workstreams: ["created_at"]
+};
+function filterAppliable(table, entries) {
+  const allowed = APPLIABLE_COLUMNS[table];
+  return entries.filter(([field]) => allowed.includes(field));
+}
+function applyTaskPut(db, op) {
+  const { workstream, localId } = parseTaskKey(op.key);
+  const entries = [];
+  for (const entry of filterAppliable("tasks", decodePayload(op.payload))) {
+    const [field, value] = entry;
+    if (field === "substate") continue;
+    if (field === "status") {
+      if (typeof value !== "string") continue;
+      const legacy = mapLegacyStatus(value);
+      if (legacy) entries.push(["status", legacy.status]);
+      else if (isTaskStatus(value)) entries.push(entry);
+      continue;
+    }
+    entries.push(entry);
+  }
+  const pending = { hlc: op.hlc, substate: carriedSubstate(JSON.parse(op.payload)) };
+  const existing = taskRowId(db, op.key);
+  if (existing === null) {
+    const tomb = tombstoneHlc(db, op);
+    if (tomb !== null && !wins(op.hlc, tomb)) {
+      return { changed: false, appliedFields: [], skipped: "older-than-tombstone" };
+    }
+    const wsId = ensureWorkstreamRow(db, workstream);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    prepareCached(
+      db,
+      `INSERT INTO tasks (workstream_id, local_id, title, status, substate, impact, effort_days,
+                          owner_id, created_at, updated_at)
+       VALUES (?, ?, ?, 'OPEN', 'todo', 50, 1, NULL, ?, ?)`
+    ).run(wsId, localId, localId, now, now);
+    const rowId = taskRowId(db, op.key);
+    if (rowId === null) throw new Error(`failed to create task row for ${op.key}`);
+    const applied2 = applyFieldLww(db, op, "tasks", rowId, entries);
+    if (repairTaskPair(db, rowId, pending)) applied2.push("substate");
+    return { changed: true, appliedFields: applied2 };
+  }
+  const applied = applyFieldLww(db, op, "tasks", existing, entries);
+  if (repairTaskPair(db, existing, pending)) applied.push("substate");
+  return applied.length > 0 ? { changed: true, appliedFields: applied } : { changed: false, appliedFields: [], skipped: "older-than-current" };
+}
+function carriedSubstate(payload) {
+  if (payload === null || typeof payload !== "object") return null;
+  const { status, substate } = payload;
+  if (typeof status === "string") {
+    const legacy = mapLegacyStatus(status);
+    if (legacy) return legacy.substate;
+    if (typeof substate !== "string" && isTaskStatus(status)) return DEFAULT_SUBSTATE[status];
+  }
+  return typeof substate === "string" ? substate : null;
+}
+function repairTaskPair(db, rowId, pending) {
+  const row = prepareCached(
+    db,
+    `SELECT t.status, t.substate, w.name || '/' || t.local_id AS key
+         FROM tasks t JOIN workstreams w ON w.id = t.workstream_id
+        WHERE t.id = ?`
+  ).get(rowId);
+  if (!row) return false;
+  let winner = null;
+  const writers = prepareCached(
+    db,
+    `SELECT hlc, payload FROM ops
+        WHERE entity = 'task' AND key = ? AND op = 'put' AND hlc <> ?
+          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+          AND (json_type(payload, '$.substate') IS NOT NULL
+               OR json_type(payload, '$.status') IS NOT NULL)
+        ORDER BY hlc DESC`
+  ).iterate(row.key, pending?.hlc ?? "");
+  for (const w of writers) {
+    const substate = carriedSubstate(JSON.parse(w.payload));
+    if (substate === null) continue;
+    winner = { hlc: w.hlc, substate };
+    break;
+  }
+  if (pending && pending.substate !== null && wins(pending.hlc, winner?.hlc ?? null)) {
+    winner = { hlc: pending.hlc, substate: pending.substate };
+  }
+  const target = resolvePair(row.status, winner?.substate ?? row.substate);
+  if (target === null || target.substate === row.substate) return false;
+  prepareCached(db, "UPDATE tasks SET substate = ? WHERE id = ?").run(target.substate, rowId);
+  return true;
+}
+function applyWorkstreamPut(db, op) {
+  const name = op.key;
+  if (name.length === 0) throw new OpKeyMalformedError("workstream", name);
+  const entries = filterAppliable("workstreams", decodePayload(op.payload));
+  const existing = prepareCached(db, "SELECT id FROM workstreams WHERE name = ?").get(name);
+  if (!existing) {
+    const tomb = tombstoneHlc(db, op);
+    if (tomb !== null && !wins(op.hlc, tomb)) {
+      return { changed: false, appliedFields: [], skipped: "older-than-tombstone" };
+    }
+    const id = ensureWorkstreamRow(db, name);
+    const applied2 = applyFieldLww(db, op, "workstreams", id, entries);
+    return { changed: true, appliedFields: applied2 };
+  }
+  const applied = applyFieldLww(db, op, "workstreams", existing.id, entries);
+  return applied.length > 0 ? { changed: true, appliedFields: applied } : { changed: false, appliedFields: [], skipped: "older-than-current" };
+}
+function applyNotePut(db, op) {
+  const { taskKey: taskKey2 } = parseNoteKey(op.key);
+  const taskId = taskRowId(db, taskKey2);
+  if (taskId === null) {
+    return { changed: false, appliedFields: [], skipped: "absent" };
+  }
+  const entries = decodePayload(op.payload);
+  const author = entries.find(([f]) => f === "author")?.[1] ?? null;
+  const content = entries.find(([f]) => f === "content")?.[1] ?? "";
+  const stamped = entries.find(([f]) => f === "created_at")?.[1];
+  const createdAt = stamped ?? (/* @__PURE__ */ new Date()).toISOString();
+  const authorText = author === null ? null : String(author);
+  const already = prepareCached(
+    db,
+    `SELECT 1 AS present FROM task_notes
+        WHERE task_id = @taskId AND content = @content
+          AND COALESCE(author, '') = COALESCE(@author, '')
+          AND (@stamped IS NULL OR created_at = @stamped)
+        LIMIT 1`
+  ).get({
+    taskId,
+    content: String(content),
+    author: authorText,
+    stamped: stamped === void 0 || stamped === null ? null : String(stamped)
+  });
+  if (already) return { changed: false, appliedFields: [], skipped: "already-present" };
+  const tomb = tombstoneHlc(db, op);
+  if (tomb !== null && !wins(op.hlc, tomb)) {
+    return { changed: false, appliedFields: [], skipped: "older-than-tombstone" };
+  }
+  prepareCached(
+    db,
+    "INSERT INTO task_notes (task_id, author, content, created_at) VALUES (?, ?, ?, ?)"
+  ).run(taskId, authorText, String(content), String(createdAt));
+  return { changed: true, appliedFields: ["content"] };
+}
+function applyEdgePut(db, op) {
+  const { blocker, blocked } = parseEdgeKey(op.key);
+  const fromId = taskRowId(db, blocker);
+  const toId = taskRowId(db, blocked);
+  if (fromId === null || toId === null) {
+    return { changed: false, appliedFields: [], skipped: "absent" };
+  }
+  const removedAt = anyHlc(db, op, "del");
+  if (removedAt !== null && !wins(op.hlc, removedAt)) {
+    return { changed: false, appliedFields: [], skipped: "older-than-tombstone" };
+  }
+  const existing = prepareCached(
+    db,
+    "SELECT 1 AS present FROM task_edges WHERE from_task_id = ? AND to_task_id = ?"
+  ).get(fromId, toId);
+  if (existing) return { changed: false, appliedFields: [], skipped: "already-present" };
+  const entries = decodePayload(op.payload);
+  const createdAt = entries.find(([f]) => f === "created_at")?.[1] ?? (/* @__PURE__ */ new Date()).toISOString();
+  prepareCached(
+    db,
+    "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
+  ).run(fromId, toId, String(createdAt));
+  return { changed: true, appliedFields: ["created_at"] };
+}
+function applyDel(db, op) {
+  const newestPut = anyHlc(db, op, "put");
+  if (newestPut !== null && !wins(op.hlc, newestPut)) {
+    return { changed: false, appliedFields: [], skipped: "older-than-current" };
+  }
+  switch (op.entity) {
+    case "workstream": {
+      const r = prepareCached(db, "DELETE FROM workstreams WHERE name = ?").run(op.key);
+      return {
+        changed: r.changes > 0,
+        appliedFields: [],
+        ...r.changes > 0 ? {} : { skipped: "absent" }
+      };
+    }
+    case "task": {
+      const rowId = taskRowId(db, op.key);
+      if (rowId === null) return { changed: false, appliedFields: [], skipped: "absent" };
+      prepareCached(db, "DELETE FROM tasks WHERE id = ?").run(rowId);
+      return { changed: true, appliedFields: [] };
+    }
+    case "note": {
+      const { taskKey: taskKey2 } = parseNoteKey(op.key);
+      const taskId = taskRowId(db, taskKey2);
+      if (taskId === null) return { changed: false, appliedFields: [], skipped: "absent" };
+      let entries = decodePayload(op.payload);
+      if (!entries.some(([f, v]) => f === "content" && v !== null)) {
+        const src = prepareCached(
+          db,
+          `SELECT payload FROM ops
+              WHERE entity = 'note' AND key = @key AND op = 'put'
+                AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
+              ORDER BY hlc DESC LIMIT 1`
+        ).get({ key: op.key });
+        if (!src) return { changed: false, appliedFields: [], skipped: "absent" };
+        entries = decodePayload(src.payload);
+      }
+      const content = entries.find(([f]) => f === "content")?.[1] ?? "";
+      const author = entries.find(([f]) => f === "author")?.[1] ?? null;
+      const createdAt = entries.find(([f]) => f === "created_at")?.[1] ?? null;
+      const r = prepareCached(
+        db,
+        `DELETE FROM task_notes
+            WHERE task_id = @taskId AND content = @content
+              AND COALESCE(author, '') = COALESCE(@author, '')
+              AND (@createdAt IS NULL OR created_at = @createdAt)`
+      ).run({
+        taskId,
+        content: String(content),
+        author: author === null ? null : String(author),
+        createdAt: createdAt === null ? null : String(createdAt)
+      });
+      return {
+        changed: r.changes > 0,
+        appliedFields: [],
+        ...r.changes > 0 ? {} : { skipped: "absent" }
+      };
+    }
+    case "edge": {
+      const { blocker, blocked } = parseEdgeKey(op.key);
+      const fromId = taskRowId(db, blocker);
+      const toId = taskRowId(db, blocked);
+      if (fromId === null || toId === null) {
+        return { changed: false, appliedFields: [], skipped: "absent" };
+      }
+      const r = prepareCached(
+        db,
+        "DELETE FROM task_edges WHERE from_task_id = ? AND to_task_id = ?"
+      ).run(fromId, toId);
+      return {
+        changed: r.changes > 0,
+        appliedFields: [],
+        ...r.changes > 0 ? {} : { skipped: "absent" }
+      };
+    }
+    default:
+      return { changed: false, appliedFields: [], skipped: "absent" };
+  }
+}
+function applyOp(db, op) {
+  if (isKnownMachineLocalEntity(op.entity)) throw new OpEntityNotSyncedError(op.entity);
+  if (!isSyncedEntity(op.entity)) return { changed: false, appliedFields: [] };
+  return withCaptureSuppressed(db, () => {
+    if (op.op === "del") return applyDel(db, op);
+    switch (op.entity) {
+      case "workstream":
+        return applyWorkstreamPut(db, op);
+      case "task":
+        return db.transaction(() => applyTaskPut(db, op)).immediate();
+      case "note":
+        return applyNotePut(db, op);
+      case "edge":
+        return applyEdgePut(db, op);
+      case "message":
+        return { changed: false, appliedFields: [] };
+      default:
+        return { changed: false, appliedFields: [] };
+    }
+  });
+}
+function reprojectDeferredOps(db) {
+  installOpKeyFunctions(db);
+  const rows = [
+    ...db.prepare(
+      `SELECT o.hlc, o.machine_id, o.group_id, o.actor, o.intent, o.entity,
+                o.key, o.op, o.payload
+           FROM ops o
+           JOIN tasks ft ON ft.local_id = edge_local(o.key, 0)
+           JOIN workstreams fw ON fw.id = ft.workstream_id AND fw.name = edge_ws(o.key, 0)
+           JOIN tasks tt ON tt.local_id = edge_local(o.key, 1)
+           JOIN workstreams tw ON tw.id = tt.workstream_id AND tw.name = edge_ws(o.key, 1)
+          WHERE o.entity = 'edge' AND o.op = 'put'
+            AND NOT EXISTS (SELECT 1 FROM task_edges e
+                             WHERE e.from_task_id = ft.id AND e.to_task_id = tt.id)
+            AND NOT EXISTS (SELECT 1 FROM ops d
+                             WHERE d.entity = 'edge' AND d.key = o.key
+                               AND d.op = 'del' AND d.hlc > o.hlc)`
+    ).all(),
+    ...db.prepare(
+      `SELECT o.hlc, o.machine_id, o.group_id, o.actor, o.intent, o.entity,
+                o.key, o.op, o.payload
+           FROM ops o
+           JOIN tasks t ON t.local_id = note_local(o.key)
+           JOIN workstreams w ON w.id = t.workstream_id AND w.name = note_ws(o.key)
+          WHERE o.entity = 'note' AND o.op = 'put'
+            AND NOT EXISTS (SELECT 1 FROM task_notes n
+                             WHERE n.task_id = t.id
+                               AND n.content = COALESCE(json_extract(o.payload, '$.content'), '')
+                               AND COALESCE(n.author, '')
+                                   = COALESCE(json_extract(o.payload, '$.author'), '')
+                               AND n.created_at = json_extract(o.payload, '$.created_at'))
+            AND NOT EXISTS (SELECT 1 FROM ops d
+                             WHERE d.entity = 'note' AND d.key = o.key
+                               AND d.op = 'del' AND d.hlc > o.hlc)`
+    ).all()
+  ];
+  if (rows.length === 0) return 0;
+  let changed = 0;
+  for (const row of rows.sort((a, b) => compareHlc(a.hlc, b.hlc))) {
+    if (applyOp(db, rowToOp(row)).changed) changed += 1;
+  }
+  return changed;
+}
+function rowToOp(row) {
+  return {
+    hlc: row.hlc,
+    machineId: row.machine_id,
+    groupId: row.group_id,
+    actor: row.actor,
+    intent: row.intent,
+    entity: row.entity,
+    key: row.key,
+    op: row.op === "del" ? "del" : "put",
+    payload: row.payload
+  };
+}
+function installOpKeyFunctions(db) {
+  const safe = (f) => {
+    try {
+      return f();
+    } catch {
+      return null;
+    }
+  };
+  const opts = { deterministic: true, varargs: false };
+  db.function(
+    "edge_ws",
+    opts,
+    (key, side) => safe(() => {
+      const parts = parseEdgeKey(String(key));
+      return parseTaskKey(Number(side) === 0 ? parts.blocker : parts.blocked).workstream;
+    })
+  );
+  db.function(
+    "edge_local",
+    opts,
+    (key, side) => safe(() => {
+      const parts = parseEdgeKey(String(key));
+      return parseTaskKey(Number(side) === 0 ? parts.blocker : parts.blocked).localId;
+    })
+  );
+  db.function(
+    "note_ws",
+    opts,
+    (key) => safe(() => parseTaskKey(parseNoteKey(String(key)).taskKey).workstream)
+  );
+  db.function(
+    "note_local",
+    opts,
+    (key) => safe(() => parseTaskKey(parseNoteKey(String(key)).taskKey).localId)
+  );
+}
+function applyOps(db, ops) {
+  const ordered = [...ops].sort((a, b) => compareHlc(a.hlc, b.hlc));
+  const run = db.transaction(() => ordered.map((op) => applyOp(db, op)));
+  return run.immediate();
+}
+
+// src/segment-manifest.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+// src/sha256-resumable.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var INITIAL_H = "6a09e667bb67ae853c6ef372a54ff53a510e527f9b05688c1f83d9ab5be0cd19";
+function sha256Initial() {
+  return { h: INITIAL_H, n: 0, tail: "" };
+}
+function wordsOf(hex) {
+  const h = new Uint32Array(8);
+  for (let i = 0; i < 8; i++) h[i] = Number.parseInt(hex.slice(i * 8, i * 8 + 8), 16);
+  return h;
+}
+function hexOf(h) {
+  let out = "";
+  for (const word of h) out += word.toString(16).padStart(8, "0");
+  return out;
+}
+var W = new Uint32Array(64);
+function compress(h, data, offset, end) {
+  let h0 = h[0] ?? 0;
+  let h1 = h[1] ?? 0;
+  let h2 = h[2] ?? 0;
+  let h3 = h[3] ?? 0;
+  let h4 = h[4] ?? 0;
+  let h5 = h[5] ?? 0;
+  let h6 = h[6] ?? 0;
+  let h7 = h[7] ?? 0;
+  for (let p = offset; p + 64 <= end; p += 64) {
+    for (let i = 0; i < 16; i++) {
+      const j = p + i * 4;
+      W[i] = (data[j] ?? 0) << 24 | (data[j + 1] ?? 0) << 16 | (data[j + 2] ?? 0) << 8 | (data[j + 3] ?? 0);
+    }
+    for (let i = 16; i < 64; i++) {
+      const w15 = W[i - 15] ?? 0;
+      const w2 = W[i - 2] ?? 0;
+      const s0 = (w15 >>> 7 | w15 << 25) ^ (w15 >>> 18 | w15 << 14) ^ w15 >>> 3;
+      const s1 = (w2 >>> 17 | w2 << 15) ^ (w2 >>> 19 | w2 << 13) ^ w2 >>> 10;
+      W[i] = (W[i - 16] ?? 0) + s0 + (W[i - 7] ?? 0) + s1 | 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let hh = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+      const ch = e & f ^ ~e & g;
+      const t1 = hh + S1 + ch + (K[i] ?? 0) + (W[i] ?? 0) | 0;
+      const S0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + maj | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h0 = h0 + a | 0;
+    h1 = h1 + b | 0;
+    h2 = h2 + c | 0;
+    h3 = h3 + d | 0;
+    h4 = h4 + e | 0;
+    h5 = h5 + f | 0;
+    h6 = h6 + g | 0;
+    h7 = h7 + hh | 0;
+  }
+  h.set([h0, h1, h2, h3, h4, h5, h6, h7]);
+}
+function sha256Update(state, data) {
+  const pending = Buffer.from(state.tail, "base64");
+  const all = pending.length === 0 ? data : Buffer.concat([pending, data]);
+  const h = wordsOf(state.h);
+  const whole = all.length - all.length % 64;
+  compress(h, all, 0, whole);
+  return {
+    h: hexOf(h),
+    n: state.n + data.length,
+    tail: Buffer.from(all.subarray(whole)).toString("base64")
+  };
+}
+function sha256Digest(state) {
+  const pending = Buffer.from(state.tail, "base64");
+  const padLen = pending.length < 56 ? 64 : 128;
+  const block = Buffer.alloc(padLen);
+  pending.copy(block);
+  block[pending.length] = 128;
+  const bits = state.n * 8;
+  block.writeUInt32BE(Math.floor(bits / 2 ** 32), padLen - 8);
+  block.writeUInt32BE(bits >>> 0, padLen - 4);
+  const h = wordsOf(state.h);
+  compress(h, block, 0, padLen);
+  return hexOf(h);
+}
+
+// src/segment-manifest.ts
+var SEGMENT_EXT = ".jsonl";
+var MANIFEST_EXT = ".manifest";
+function manifestPath(segment) {
+  return segment.replace(new RegExp(`${SEGMENT_EXT}$`), MANIFEST_EXT);
+}
+function manifestSeal(m) {
+  return createHash("sha256").update(
+    [
+      m.v,
+      m.machine,
+      m.count,
+      m.lastHlc ?? "",
+      m.sha256,
+      m.size,
+      m.mtimeMs,
+      m.shaState.h,
+      m.shaState.n,
+      m.shaState.tail
+    ].join("")
+  ).digest("hex");
+}
+var HEX64 = /^[0-9a-f]{64}$/;
+function manifestSelfConsistent(m) {
+  const { count, lastHlc, size, mtimeMs, shaState, seal } = m;
+  if (!Number.isSafeInteger(count) || count < 0) return false;
+  if (typeof size !== "number" || !Number.isSafeInteger(size) || size < 0) return false;
+  if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs)) return false;
+  if (lastHlc !== null && typeof lastHlc !== "string") return false;
+  if (count === 0 !== (size === 0) || count === 0 !== (lastHlc === null)) return false;
+  if (typeof m.sha256 !== "string" || !HEX64.test(m.sha256)) return false;
+  if (typeof seal !== "string" || !HEX64.test(seal)) return false;
+  if (typeof shaState !== "object" || shaState === null || typeof shaState.h !== "string" || !HEX64.test(shaState.h) || shaState.n !== size || typeof shaState.tail !== "string") {
+    return false;
+  }
+  const tail = Buffer.from(shaState.tail, "base64");
+  if (tail.length !== size % 64 || tail.toString("base64") !== shaState.tail) return false;
+  if (sha256Digest(shaState) !== m.sha256) return false;
+  return manifestSeal({ ...m, size, mtimeMs, shaState }) === seal;
+}
+function writeManifestFile(segment, fields) {
+  const manifest = {
+    ...fields,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    seal: manifestSeal(fields)
+  };
+  writeFileSync(manifestPath(segment), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function readManifest(segment) {
+  const path = manifestPath(segment);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/segments.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  appendFileSync,
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  readSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { tmpdir } from "os";
+import { join as join3, resolve as resolve2, sep } from "path";
+import { crc32 } from "zlib";
+var SEGMENT_FORMAT_VERSION = 1;
+var SEGMENT_EXT2 = ".jsonl";
+function syncDir() {
+  const dir = process.env.MU_SYNC_DIR;
+  if (dir === void 0 || dir.trim() === "") return null;
+  refuseUserSyncDirDuringTests(dir);
+  return dir;
+}
+function refuseUserSyncDirDuringTests(dir) {
+  const inTest = process.env.VITEST !== void 0 || process.env.NODE_ENV === "test";
+  if (!inTest) return;
+  const resolved = resolve2(dir);
+  const temp = resolve2(tmpdir());
+  if (resolved === temp || resolved.startsWith(temp + sep)) return;
+  throw new Error(
+    `syncDir refused: tests must NEVER flush ops into a real sync dir (MU_SYNC_DIR=${resolved}). Doing so writes a segment named after this run's machine_id and leaves a permanent phantom peer. Point MU_SYNC_DIR at a mkdtemp() path under ${temp}, or leave it unset (test/_setup.ts clears it by default).`
+  );
+}
+function localMachineId(db) {
+  const row = db.prepare("SELECT machine_id FROM machine_identity WHERE id = 1").get();
+  if (row === void 0) throw new Error("machine_identity row missing; not a mu DB");
+  return row.machine_id;
+}
+function segmentPath(dir, machineId) {
+  return join3(dir, `${machineId}${SEGMENT_EXT2}`);
+}
+function canonicalBytes(line, payloadText) {
+  return [
+    String(line.v),
+    line.hlc,
+    line.machine,
+    line.group,
+    line.intent ?? "",
+    line.actor ?? "",
+    line.entity,
+    line.key,
+    line.op,
+    payloadText
+  ].join("");
+}
+function computeCrc(line, payloadText) {
+  return crc32(canonicalBytes(line, payloadText)).toString(16).padStart(8, "0");
+}
+function payloadTextFor(payload) {
+  try {
+    JSON.parse(payload);
+    return payload;
+  } catch {
+    return JSON.stringify(payload);
+  }
+}
+function encodeSegmentLine(op) {
+  const base = {
+    v: SEGMENT_FORMAT_VERSION,
+    hlc: op.hlc,
+    machine: op.machineId,
+    group: op.groupId,
+    intent: op.intent,
+    actor: op.actor,
+    entity: op.entity,
+    key: op.key,
+    op: op.op,
+    payload: null
+    // replaced below; kept out of the crc input shape
+  };
+  const payloadText = payloadTextFor(op.payload);
+  const crc = computeCrc(base, payloadText);
+  return `{"v":${base.v},"hlc":${JSON.stringify(base.hlc)},"machine":${JSON.stringify(
+    base.machine
+  )},"group":${JSON.stringify(base.group)},"intent":${JSON.stringify(
+    base.intent
+  )},"actor":${JSON.stringify(base.actor)},"entity":${JSON.stringify(
+    base.entity
+  )},"key":${JSON.stringify(base.key)},"op":${JSON.stringify(
+    base.op
+  )},"payload":${payloadText},"crc":${JSON.stringify(crc)}}`;
+}
+function decodeLine(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return looksComplete(raw) ? { ok: false, kind: "malformed-shape", detail: `complete line is not valid JSON: ${detail}` } : { ok: false, kind: "torn-write", detail };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, kind: "malformed-shape", detail: "line is not a JSON object" };
+  }
+  const obj = parsed;
+  if (typeof obj.v !== "number") {
+    return { ok: false, kind: "malformed-shape", detail: "missing numeric 'v'" };
+  }
+  if (obj.v !== SEGMENT_FORMAT_VERSION) {
+    return {
+      ok: false,
+      kind: "unknown-version",
+      detail: `segment format v${obj.v}, this mu understands v${SEGMENT_FORMAT_VERSION}`
+    };
+  }
+  for (const field of ["hlc", "machine", "group", "entity", "key", "op", "crc"]) {
+    if (typeof obj[field] !== "string") {
+      return { ok: false, kind: "malformed-shape", detail: `missing string '${field}'` };
+    }
+  }
+  const opKind = obj.op;
+  if (opKind !== "put" && opKind !== "del") {
+    return { ok: false, kind: "malformed-shape", detail: `bad op '${String(opKind)}'` };
+  }
+  if (!("payload" in obj)) {
+    return { ok: false, kind: "malformed-shape", detail: "missing 'payload'" };
+  }
+  const payloadText = extractPayloadText(raw);
+  if (payloadText === null) {
+    return { ok: false, kind: "malformed-shape", detail: "could not locate payload text" };
+  }
+  const line = {
+    v: obj.v,
+    hlc: obj.hlc,
+    machine: obj.machine,
+    group: obj.group,
+    intent: typeof obj.intent === "string" ? obj.intent : null,
+    actor: typeof obj.actor === "string" ? obj.actor : null,
+    entity: obj.entity,
+    key: obj.key,
+    op: opKind,
+    payload: obj.payload,
+    crc: obj.crc
+  };
+  const expected = computeCrc({ ...line, payload: null }, payloadText);
+  if (expected !== line.crc) {
+    return {
+      ok: false,
+      kind: "crc-mismatch",
+      detail: `crc ${line.crc} != computed ${expected} (bit rot?)`
+    };
+  }
+  return { ok: true, line, payloadText: storedPayloadFor(line, payloadText) };
+}
+function storedPayloadFor(line, payloadText) {
+  if (typeof line.payload !== "string") return payloadText;
+  try {
+    JSON.parse(line.payload);
+    return payloadText;
+  } catch {
+    return line.payload;
+  }
+}
+function looksComplete(raw) {
+  return raw.trimEnd().endsWith("}") && raw.includes(',"crc":"');
+}
+function extractPayloadText(raw) {
+  const start = raw.indexOf('"payload":');
+  if (start < 0) return null;
+  const end = raw.lastIndexOf(',"crc":');
+  if (end <= start) return null;
+  return raw.slice(start + '"payload":'.length, end);
+}
+var AMBIENT_FLUSH_LOCK_WAIT_MS = 2e3;
+var VERIFY_FLUSH_LOCK_WAIT_MS = 15e3;
+async function flushSegment(db, dir = syncDir(), opts) {
+  if (dir === null)
+    return { segmentPath: null, appended: 0, total: 0, skippedLocal: 0, selfRepaired: null };
+  const machineId = localMachineId(db);
+  mkdirSync2(dir, { recursive: true });
+  const path = segmentPath(dir, machineId);
+  const verify = opts?.verify === true;
+  const pre = verify ? null : trustedTail(path, machineId);
+  if (pre !== null) {
+    const pending = pendingLines(db, machineId, pre.lastHlc, false);
+    if (pending.lines.length === 0) {
+      return {
+        segmentPath: path,
+        appended: 0,
+        total: pre.count,
+        skippedLocal: pending.skippedLocal,
+        selfRepaired: null
+      };
+    }
+  }
+  const lockName = createHash2("sha256").update(`${dir}${machineId}`).digest("hex").slice(0, 16);
+  return withFileLock(
+    join3(locksDir(), `segment-${lockName}.lock`),
+    `segment:${machineId}`,
+    () => Promise.resolve(flushLocked(db, path, machineId, verify)),
+    {
+      acquireTimeoutMs: opts?.lockWaitMs ?? (verify ? VERIFY_FLUSH_LOCK_WAIT_MS : AMBIENT_FLUSH_LOCK_WAIT_MS),
+      onUnavailable: () => ({
+        segmentPath: path,
+        appended: 0,
+        total: pre?.count ?? 0,
+        skippedLocal: 0,
+        selfRepaired: null,
+        lockBusy: true
+      })
+    }
+  );
+}
+function flushLocked(db, path, machineId, verify) {
+  const trusted = verify ? null : trustedTail(path, machineId);
+  let count;
+  let since;
+  let selfRepaired = null;
+  if (trusted !== null) {
+    count = trusted.count;
+    since = trusted.lastHlc;
+  } else {
+    const existing = readSegmentTail(path);
+    count = existing.count;
+    since = existing.lastHlc;
+    if (existing.defect !== null) {
+      selfRepaired = existing.defect;
+      writeFileSync2(
+        path,
+        existing.goodLines.length > 0 ? `${existing.goodLines.join("\n")}
+` : "",
+        "utf8"
+      );
+    }
+  }
+  const pending = pendingLines(db, machineId, since, trusted === null);
+  let appended = null;
+  if (pending.lines.length > 0) {
+    appended = Buffer.from(`${pending.lines.join("\n")}
+`, "utf8");
+    appendFileSync(path, appended);
+  } else if (!existsSync2(path)) {
+    writeFileSync2(path, "", "utf8");
+  }
+  const total = count + pending.lines.length;
+  const result = {
+    segmentPath: path,
+    appended: pending.lines.length,
+    total,
+    skippedLocal: pending.skippedLocal,
+    selfRepaired
+  };
+  if (trusted !== null && appended === null) return result;
+  writeManifest(
+    path,
+    machineId,
+    total,
+    pending.lastHlc ?? since,
+    trusted !== null && appended !== null ? { state: trusted.shaState, size: trusted.size, appended } : null
+  );
+  return result;
+}
+var SYNCED_ENTITIES_SQL = SYNCED_ENTITIES.map((e) => `'${e}'`).join(", ");
+function pendingLines(db, machineId, since, countTrailing) {
+  const from = since ?? "";
+  const rows = prepareCached(
+    db,
+    `SELECT hlc, machine_id, group_id, intent, actor, entity, key, op, payload
+       FROM ops INDEXED BY idx_ops_machine_entity_hlc
+      WHERE machine_id = @machineId
+        AND entity IN (${SYNCED_ENTITIES_SQL})
+        AND hlc > @from
+      ORDER BY hlc`
+  ).all({ machineId, from });
+  const lines = [];
+  let lastHlc = null;
+  for (const row2 of rows) {
+    if (isLegacyLogOnlyIntent(row2.intent)) continue;
+    lines.push(
+      encodeSegmentLine({
+        hlc: row2.hlc,
+        machineId: row2.machine_id,
+        groupId: row2.group_id,
+        intent: row2.intent,
+        actor: row2.actor,
+        entity: row2.entity,
+        key: row2.key,
+        op: row2.op === "del" ? "del" : "put",
+        payload: row2.payload
+      })
+    );
+    lastHlc = row2.hlc;
+  }
+  let row;
+  if (countTrailing) {
+    row = prepareCached(
+      db,
+      "SELECT COUNT(*) AS n FROM ops WHERE machine_id = @machineId AND hlc > @from"
+    ).get({ machineId, from });
+  } else if (lastHlc !== null) {
+    row = prepareCached(
+      db,
+      `SELECT COUNT(*) AS n FROM ops
+        WHERE machine_id = @machineId AND hlc > @from AND hlc <= @upTo`
+    ).get({ machineId, from, upTo: lastHlc });
+  } else {
+    return { lines, lastHlc, skippedLocal: 0 };
+  }
+  return { lines, lastHlc, skippedLocal: row.n - lines.length };
+}
+function trustedTail(path, machineId) {
+  const m = readManifest(path);
+  if (m === null || m.v !== SEGMENT_FORMAT_VERSION || m.machine !== machineId) return null;
+  if (!manifestSelfConsistent(m)) return null;
+  const { count, lastHlc, size, mtimeMs, shaState } = m;
+  let stat2;
+  try {
+    stat2 = statSync(path);
+  } catch {
+    return null;
+  }
+  if (stat2.size !== size || stat2.mtimeMs !== mtimeMs) return null;
+  if (count === 0) return lastHlc === null ? { count, lastHlc, size, shaState } : null;
+  const last = readLastLine(path, size);
+  if (last === null) return null;
+  const decoded = decodeLine(last);
+  if (!decoded.ok || decoded.line.hlc !== lastHlc) return null;
+  return { count, lastHlc, size, shaState };
+}
+function readLastLine(path, size) {
+  if (size === 0) return null;
+  const fd = openSync(path, "r");
+  try {
+    const last = Buffer.alloc(1);
+    readSync(fd, last, 0, 1, size - 1);
+    if (last[0] !== 10) return null;
+    const chunks = [];
+    let end = size - 1;
+    while (end > 0) {
+      const start = Math.max(0, end - 64 * 1024);
+      const buf = Buffer.alloc(end - start);
+      readSync(fd, buf, 0, buf.length, start);
+      const nl = buf.lastIndexOf(10);
+      if (nl >= 0) {
+        chunks.unshift(buf.subarray(nl + 1));
+        break;
+      }
+      chunks.unshift(buf);
+      end = start;
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+function segmentFingerprint(path) {
+  try {
+    const { size, mtimeMs } = statSync(path);
+    const manifest = readFileSync2(manifestPath(path));
+    const sha = createHash2("sha256").update(manifest).digest("hex");
+    let count = null;
+    try {
+      count = JSON.parse(manifest.toString("utf8")).count;
+    } catch {
+    }
+    return { key: `${size} ${mtimeMs} ${sha}`, count };
+  } catch {
+    return null;
+  }
+}
+function recordedFingerprint(db, watermarkKey) {
+  const row = prepareCached(
+    db,
+    "SELECT fingerprint FROM sync_fingerprints WHERE machine_id = ?"
+  ).get(watermarkKey);
+  return row?.fingerprint ?? null;
+}
+function segmentCaughtUp(db, watermarkKey, path, lines) {
+  const recorded = recordedFingerprint(db, watermarkKey);
+  if (recorded === null) return false;
+  const now = segmentFingerprint(path);
+  return now !== null && now.count === lines && now.key === recorded;
+}
+function segmentLineCount(path) {
+  return readSegmentTail(path).count;
+}
+function readSegmentTail(path) {
+  if (!existsSync2(path)) return { count: 0, lastHlc: null, goodLines: [], defect: null };
+  const lines = segmentLines(readFileSync2(path, "utf8"));
+  let lastHlc = null;
+  let count = 0;
+  let defect = null;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (line === void 0) break;
+    if (line.trim() === "") {
+      defect = { kind: "malformed-shape", line: index + 1, detail: "blank line" };
+      break;
+    }
+    const decoded = decodeLine(line);
+    if (!decoded.ok) {
+      defect = { kind: decoded.kind, line: index + 1, detail: decoded.detail };
+      break;
+    }
+    lastHlc = decoded.line.hlc;
+    count += 1;
+  }
+  return { count, lastHlc, goodLines: lines.slice(0, count), defect };
+}
+function segmentLines(raw) {
+  const lines = raw.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function writeManifest(path, machine, count, lastHlc, incremental) {
+  let stat2 = statSync(path);
+  let shaState;
+  if (incremental !== null && stat2.size === incremental.size + incremental.appended.length) {
+    shaState = sha256Update(incremental.state, incremental.appended);
+  } else {
+    const bytes = readFileSync2(path);
+    shaState = sha256Update(sha256Initial(), bytes);
+    stat2 = statSync(path);
+  }
+  writeManifestFile(path, {
+    v: SEGMENT_FORMAT_VERSION,
+    machine,
+    count,
+    lastHlc,
+    sha256: sha256Digest(shaState),
+    size: shaState.n,
+    mtimeMs: stat2.mtimeMs,
+    shaState
+  });
+}
+function verifyAgainstManifest(segment) {
+  const manifest = readManifest(segment);
+  if (manifest === null) return { ok: true };
+  if (!existsSync2(segment)) return { ok: false, reason: "segment missing but manifest present" };
+  const sha = createHash2("sha256").update(readFileSync2(segment)).digest("hex");
+  if (sha === manifest.sha256) return { ok: true };
+  const tail = readSegmentTail(segment);
+  if (tail.count >= manifest.count) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    reason: `sha mismatch and file has FEWER records than the manifest (${tail.count} < ${manifest.count}): truncated`
+  };
+}
+function discoverPeers(dir, selfMachineId) {
+  if (!existsSync2(dir)) return [];
+  const peers = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(SEGMENT_EXT2)) continue;
+    const stem = name.slice(0, -SEGMENT_EXT2.length);
+    const conflictAt = stem.indexOf(".sync-conflict-");
+    const conflictCopy = conflictAt > 0;
+    const machineId = conflictCopy ? stem.slice(0, conflictAt) : stem;
+    if (machineId === selfMachineId && !conflictCopy) continue;
+    const path = join3(dir, name);
+    try {
+      if (!statSync(path).isFile()) continue;
+    } catch {
+      continue;
+    }
+    peers.push({ machineId, watermarkKey: conflictCopy ? stem : machineId, path, conflictCopy });
+  }
+  return peers.sort((a, b) => a.path.localeCompare(b.path));
+}
+function peerWatermarkKey(peer) {
+  return peer.watermarkKey ?? peer.machineId;
+}
+function getWatermark(db, watermarkKey) {
+  const row = db.prepare("SELECT last_applied_seq AS n FROM sync_peers WHERE machine_id = ?").get(watermarkKey);
+  return row?.n ?? 0;
+}
+function setWatermark(db, watermarkKey, value, fingerprint) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  prepareCached(
+    db,
+    `INSERT INTO sync_peers (machine_id, last_applied_seq, last_seen_at)
+     VALUES (@machineId, @value, @seenAt)
+     ON CONFLICT (machine_id) DO UPDATE
+       SET last_applied_seq = @value, last_seen_at = @seenAt`
+  ).run({ machineId: watermarkKey, value, seenAt: now });
+  if (fingerprint == null) {
+    prepareCached(db, "DELETE FROM sync_fingerprints WHERE machine_id = ?").run(watermarkKey);
+  } else {
+    prepareCached(
+      db,
+      `INSERT INTO sync_fingerprints (machine_id, fingerprint) VALUES (?, ?)
+       ON CONFLICT (machine_id) DO UPDATE SET fingerprint = excluded.fingerprint`
+    ).run(watermarkKey, fingerprint);
+  }
+}
+function markReprojectionPending(db) {
+  prepareCached(db, "PRAGMA user_version = 1").run();
+}
+function reprojectIfPending(db, opts) {
+  if (opts?.force !== true && db.pragma("user_version", { simple: true }) === 0) return 0;
+  return db.transaction(() => {
+    const pending = db.pragma("user_version", { simple: true }) !== 0;
+    if (!pending && opts?.force !== true) return 0;
+    const changed = reprojectDeferredOps(db);
+    if (pending) db.pragma("user_version = 0");
+    return changed;
+  }).immediate();
+}
+function resetWatermark(db, watermarkKey) {
+  setWatermark(db, watermarkKey, 0);
+}
+function ingestSegment(db, peer, opts) {
+  const defects = [];
+  const watermarkKey = peerWatermarkKey(peer);
+  const start = getWatermark(db, watermarkKey);
+  if (opts?.verify !== true && segmentCaughtUp(db, watermarkKey, peer.path, start)) {
+    return {
+      machineId: peer.machineId,
+      path: peer.path,
+      read: 0,
+      applied: 0,
+      changed: 0,
+      watermark: start,
+      defects,
+      truncatedAt: null
+    };
+  }
+  if (!existsSync2(peer.path)) {
+    return {
+      machineId: peer.machineId,
+      path: peer.path,
+      read: 0,
+      applied: 0,
+      changed: 0,
+      watermark: start,
+      defects,
+      truncatedAt: null
+    };
+  }
+  const fingerprint = segmentFingerprint(peer.path);
+  const verified = verifyAgainstManifest(peer.path);
+  if (!verified.ok) {
+    defects.push({ kind: "manifest-mismatch", line: 0, detail: verified.reason });
+  }
+  const lines = segmentLines(readFileSync2(peer.path, "utf8"));
+  let applied = 0;
+  let changed = 0;
+  let watermark = start;
+  let truncatedAt = null;
+  let previousHlc = null;
+  if (start > 0 && start <= lines.length) {
+    const prior = lines[start - 1];
+    if (prior !== void 0) {
+      const decoded = decodeLine(prior);
+      if (decoded.ok) previousHlc = decoded.line.hlc;
+    }
+  }
+  const run = db.transaction(() => {
+    for (let index = start; index < lines.length; index++) {
+      const raw = lines[index];
+      const lineNo = index + 1;
+      if (raw === void 0 || raw.trim() === "") {
+        defects.push({ kind: "malformed-shape", line: lineNo, detail: "blank line" });
+        truncatedAt = lineNo;
+        break;
+      }
+      const decoded = decodeLine(raw);
+      if (!decoded.ok) {
+        defects.push({ kind: decoded.kind, line: lineNo, detail: decoded.detail });
+        truncatedAt = lineNo;
+        break;
+      }
+      const op = {
+        hlc: decoded.line.hlc,
+        machineId: decoded.line.machine,
+        groupId: decoded.line.group,
+        actor: decoded.line.actor,
+        intent: decoded.line.intent,
+        entity: decoded.line.entity,
+        key: decoded.line.key,
+        op: decoded.line.op,
+        payload: decoded.payloadText
+      };
+      if (previousHlc !== null && decoded.line.hlc <= previousHlc) {
+        if (isAlreadyRecorded(db, op)) {
+          defects.push({
+            kind: "duplicate-op",
+            line: lineNo,
+            detail: `hlc ${decoded.line.hlc} re-delivered \u2014 skipped`
+          });
+          watermark = lineNo;
+          continue;
+        }
+        defects.push({
+          kind: "non-monotonic-hlc",
+          line: lineNo,
+          detail: `hlc ${decoded.line.hlc} <= previous ${previousHlc}`
+        });
+        truncatedAt = lineNo;
+        break;
+      }
+      if (isLegacyLogOnlyIntent(decoded.line.intent)) {
+        previousHlc = op.hlc;
+        watermark = lineNo;
+        continue;
+      }
+      try {
+        const result = applyIncomingOp(db, op);
+        if (result.changed) changed += 1;
+      } catch (err) {
+        if (err instanceof OpEntityNotSyncedError) {
+          defects.push({
+            kind: "entity-not-synced",
+            line: lineNo,
+            detail: `peer sent machine-local entity '${op.entity}' \u2014 skipped`
+          });
+          previousHlc = op.hlc;
+          watermark = lineNo;
+          continue;
+        }
+        throw err;
+      }
+      applied += 1;
+      previousHlc = op.hlc;
+      watermark = lineNo;
+    }
+    const clean = defects.length === 0 && watermark === lines.length;
+    setWatermark(db, watermarkKey, watermark, clean ? fingerprint?.key ?? null : null);
+  });
+  run.immediate();
+  return {
+    machineId: peer.machineId,
+    path: peer.path,
+    read: watermark - start,
+    applied,
+    changed,
+    watermark,
+    defects,
+    truncatedAt
+  };
+}
+function isAlreadyRecorded(db, op) {
+  const row = prepareCached(
+    db,
+    `SELECT 1 FROM ops
+        WHERE machine_id = @machineId AND hlc = @hlc
+          AND entity = @entity AND key = @key AND op = @op
+        LIMIT 1`
+  ).get({
+    machineId: op.machineId,
+    hlc: op.hlc,
+    entity: op.entity,
+    key: op.key,
+    op: op.op
+  });
+  return row !== void 0;
+}
+function applyIncomingOp(db, op) {
+  receiveHlc(db, op.hlc);
+  const result = applyOp(db, op);
+  if (result.changed || result.skipped === "absent") markReprojectionPending(db);
+  prepareCached(
+    db,
+    `INSERT OR IGNORE INTO ops
+       (hlc, machine_id, group_id, actor, intent, entity, key, op, payload, created_at)
+     VALUES (@hlc, @machineId, @groupId, @actor, @intent, @entity, @key, @op, @payload, @createdAt)`
+  ).run({
+    hlc: op.hlc,
+    machineId: op.machineId,
+    groupId: op.groupId,
+    actor: op.actor ?? null,
+    intent: op.intent ?? null,
+    entity: op.entity,
+    key: op.key,
+    op: op.op,
+    payload: op.payload,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { changed: result.changed };
+}
+async function syncPass(db, dir = syncDir()) {
+  if (dir === null) {
+    return {
+      flushed: { segmentPath: null, appended: 0, total: 0, skippedLocal: 0, selfRepaired: null },
+      ingested: [],
+      defective: false
+    };
+  }
+  const flushed = await flushSegment(db, dir, { verify: true });
+  const self = localMachineId(db);
+  const ingested = discoverPeers(dir, self).map(
+    (peer) => ingestSegment(db, peer, { verify: true })
+  );
+  reprojectIfPending(db, { force: true });
+  return {
+    flushed,
+    ingested,
+    defective: flushed.selfRepaired !== null || ingested.some((r) => r.defects.length > 0)
+  };
+}
+
+// src/sync.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import Database2 from "better-sqlite3";
+var SyncPeerNotFoundError = class extends Error {
+  constructor(ref, known) {
+    super(
+      `no peer matches ${JSON.stringify(ref)}${known.length === 0 ? " (no peers discovered)" : ` (known peers: ${known.join(", ")})`}`
+    );
+    this.ref = ref;
+    this.known = known;
+  }
+  ref;
+  known;
+  name = "SyncPeerNotFoundError";
+};
+var SyncPeerRefAmbiguousError = class extends Error {
+  constructor(ref, candidates) {
+    super(
+      `peer ref ${JSON.stringify(ref)} matches ${candidates.length} peers (${candidates.join(", ")}); pass more characters`
+    );
+    this.ref = ref;
+    this.candidates = candidates;
+  }
+  ref;
+  candidates;
+  name = "SyncPeerRefAmbiguousError";
+};
+var SyncSourceNotFoundError = class extends Error {
+  constructor(path) {
+    super(`--from: no such file: ${path}`);
+    this.path = path;
+  }
+  path;
+  name = "SyncSourceNotFoundError";
+};
+var PEER_STALE_MS = 24 * 60 * 60 * 1e3;
+var PEER_SHORT_LEN = 8;
+function peerStatuses(db, dir) {
+  const self = localMachineId(db);
+  const now = Date.now();
+  const rows = discoverPeers(dir, self).map((peer) => {
+    let lastSeenMs = null;
+    try {
+      lastSeenMs = statSync2(peer.path).mtimeMs;
+    } catch {
+      lastSeenMs = null;
+    }
+    const watermarkKey = peerWatermarkKey(peer);
+    const watermark = getWatermark(db, watermarkKey);
+    const total = segmentCaughtUp(db, watermarkKey, peer.path, watermark) ? watermark : segmentLineCount(peer.path);
+    const ageMs = lastSeenMs === null ? null : Math.max(0, now - lastSeenMs);
+    return {
+      machineId: peer.machineId,
+      short: peer.machineId.slice(0, PEER_SHORT_LEN),
+      path: peer.path,
+      conflictCopy: peer.conflictCopy,
+      watermarkKey,
+      watermark,
+      total,
+      behind: Math.max(0, total - watermark),
+      lastSeenMs,
+      ageMs,
+      stale: ageMs === null || ageMs > PEER_STALE_MS
+    };
+  });
+  return rows.sort((a, b) => (b.lastSeenMs ?? 0) - (a.lastSeenMs ?? 0));
+}
+function resolvePeerRef(peers, ref) {
+  const matches = peers.filter((p) => p.machineId.startsWith(ref));
+  const exact = matches.filter((p) => p.machineId === ref);
+  const candidates = exact.length > 0 ? exact : matches;
+  const machines = [...new Set(candidates.map((p) => p.machineId))];
+  const first = candidates.find((p) => !p.conflictCopy) ?? candidates[0];
+  if (first === void 0) {
+    throw new SyncPeerNotFoundError(
+      ref,
+      peers.map((p) => p.short)
+    );
+  }
+  if (machines.length > 1) {
+    throw new SyncPeerRefAmbiguousError(
+      ref,
+      machines.map((m) => m.slice(0, PEER_SHORT_LEN))
+    );
+  }
+  return first;
+}
+function repairPeer(db, ref, dir) {
+  const peers = peerStatuses(db, dir);
+  const peer = resolvePeerRef(peers, ref);
+  for (const p of peers) {
+    if (p.machineId === peer.machineId) resetWatermark(db, peerWatermarkKey(p));
+  }
+  return peer;
+}
+function syncEnabled() {
+  return syncDir() !== null;
+}
+function warn(message, opts) {
+  if (opts?.quiet === true) return;
+  process.stderr.write(`mu: sync: ${message}
+`);
+}
+function describeDefects(peerShort, defects) {
+  const first = defects[0];
+  const detail = first === void 0 ? "unknown defect" : `${first.kind} at line ${first.line}`;
+  const more = defects.length > 1 ? ` (+${defects.length - 1} more)` : "";
+  const skipped = /* @__PURE__ */ new Set(["entity-not-synced", "duplicate-op"]);
+  const fileWide = /* @__PURE__ */ new Set(["manifest-mismatch"]);
+  let hint;
+  if (defects.every((d) => skipped.has(d.kind))) {
+    hint = " \u2014 skipped; the rest of the segment applied";
+  } else if (defects.every((d) => skipped.has(d.kind) || fileWide.has(d.kind))) {
+    hint = " \u2014 the file is shorter than its manifest; copy it from the peer again";
+  } else {
+    hint = ` \u2014 re-read with \`mu sync --repair ${peerShort}\``;
+  }
+  return `peer ${peerShort}: ${detail}${more}${hint}`;
+}
+async function ambientIngest(db, opts) {
+  const dir = syncDir();
+  if (dir === null) return { ingested: [], warnings: [] };
+  const warnings = [];
+  const ingested = [];
+  try {
+    const self = localMachineId(db);
+    for (const peer of discoverPeers(dir, self)) {
+      try {
+        const result = ingestSegment(db, peer);
+        ingested.push(result);
+        if (result.defects.length > 0) {
+          const message = describeDefects(peer.machineId.slice(0, PEER_SHORT_LEN), result.defects);
+          warnings.push(message);
+          warn(message, opts);
+        }
+      } catch (err) {
+        const message = `peer ${peer.machineId.slice(0, PEER_SHORT_LEN)}: ${err instanceof Error ? err.message : String(err)}`;
+        warnings.push(message);
+        warn(message, opts);
+      }
+    }
+    reprojectIfPending(db);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warnings.push(message);
+    warn(message, opts);
+  }
+  return { ingested, warnings };
+}
+async function ambientFlush(db, opts) {
+  const dir = syncDir();
+  if (dir === null) return null;
+  try {
+    const result = await flushSegment(db, dir);
+    if (result.selfRepaired !== null) {
+      const d = result.selfRepaired;
+      warn(
+        `own segment truncated back to its last good line: ${d.kind} at line ${d.line} (${d.detail}) \u2014 regenerated from the ops table`,
+        opts
+      );
+    }
+    return result;
+  } catch (err) {
+    warn(err instanceof Error ? err.message : String(err), opts);
+    return null;
+  }
+}
+async function ambientSyncPass(db, opts) {
+  if (!syncEnabled()) return { ingested: [], flushed: null };
+  const { ingested } = await ambientIngest(db, opts);
+  const flushed = await ambientFlush(db, opts);
+  return { ingested, flushed };
+}
+function ingestFromDb(db, path) {
+  if (!existsSync3(path)) throw new SyncSourceNotFoundError(path);
+  const self = localMachineId(db);
+  const source = new Database2(path, { readonly: true, fileMustExist: true });
+  try {
+    const rows = source.prepare(
+      `SELECT hlc, machine_id, group_id, actor, intent, entity, key, op, payload
+           FROM ops
+          WHERE machine_id != ?
+          ORDER BY hlc`
+    ).all(self);
+    const synced = new Set(SYNCED_ENTITIES);
+    let read = 0;
+    let changed = 0;
+    let skippedLocal = 0;
+    const run = db.transaction(() => {
+      for (const row of rows) {
+        if (!synced.has(row.entity) || isLegacyLogOnlyIntent(row.intent)) {
+          skippedLocal += 1;
+          continue;
+        }
+        const op = {
+          hlc: row.hlc,
+          machineId: row.machine_id,
+          groupId: row.group_id,
+          actor: row.actor,
+          intent: row.intent,
+          entity: row.entity,
+          key: row.key,
+          op: row.op === "del" ? "del" : "put",
+          payload: row.payload
+        };
+        const result = applyIncomingOp(db, op);
+        read += 1;
+        if (result.changed) changed += 1;
+      }
+    });
+    run.immediate();
+    changed += reprojectIfPending(db, { force: true });
+    return { path, read, changed, skippedLocal };
+  } finally {
+    try {
+      source.close();
+    } catch {
+    }
+  }
+}
+function transportNextSteps(dir, peers) {
+  const stale = peers.filter((p) => p.stale);
+  if (stale.length === 0) return [];
+  return [
+    {
+      intent: `Pull fresh segments (${stale.length} stale peer${stale.length === 1 ? "" : "s"})`,
+      command: `rsync -av <host>:${dir}/ ${dir}/`
+    },
+    {
+      intent: "Or stop doing it by hand",
+      command: `# share ${dir} with Syncthing on every machine`
+    }
+  ];
+}
+
+export {
+  OP_CTX_DDL,
+  CAPTURE_TRIGGER_DDL,
+  captureBookkeepingChanges,
+  installCapture,
+  TASK_STATUSES,
+  isTaskStatus,
+  TASK_STATUS_LIST,
+  TASK_SUBSTATES,
+  DEFAULT_SUBSTATE,
+  TASK_SUBSTATE_ROWS,
+  isValidPair,
+  mapLegacyStatus,
+  resolvePair,
+  formatPair,
+  defaultDbPath,
+  openDb,
+  WorkstreamNotFoundError,
+  resolveWorkstreamId,
+  tryResolveWorkstreamId,
+  SchemaTooOldError,
+  SchemaTooNewError,
+  CURRENT_SCHEMA_VERSION,
+  EXPECTED_TABLES,
+  SYNCED_ENTITIES,
+  MACHINE_LOCAL_ENTITIES,
+  PORTABLE_TABLES,
+  MACHINE_LOCAL_TABLES,
+  HlcParseError,
+  HlcOverflowError,
+  MachineIdentityMissingError,
+  formatHlc,
+  parseHlc,
+  compareHlc,
+  nextHlc,
+  receiveHlc,
+  isLegacyLogOnlyIntent,
+  LEGACY_LOG_ONLY_SQL_EXCLUSION,
+  intentSpellings,
+  currentOpContext,
+  withOpContext,
+  withCaptureSuppressed,
+  locksDir,
+  withFileLock,
+  readFileLockMeta,
+  OpEntityNotSyncedError,
+  OpKeyMalformedError,
+  repairTaskPair,
+  applyOp,
+  applyOps,
+  readManifest,
+  SEGMENT_FORMAT_VERSION,
+  syncDir,
+  localMachineId,
+  segmentPath,
+  flushSegment,
+  segmentLineCount,
+  verifyAgainstManifest,
+  discoverPeers,
+  getWatermark,
+  setWatermark,
+  resetWatermark,
+  ingestSegment,
+  applyIncomingOp,
+  syncPass,
+  SyncPeerNotFoundError,
+  SyncPeerRefAmbiguousError,
+  SyncSourceNotFoundError,
+  PEER_STALE_MS,
+  PEER_SHORT_LEN,
+  peerStatuses,
+  resolvePeerRef,
+  repairPeer,
+  syncEnabled,
+  ambientIngest,
+  ambientFlush,
+  ambientSyncPass,
+  ingestFromDb,
+  transportNextSteps
+};
+//# sourceMappingURL=chunk-YIF3X32A.js.map