@mu-crew/mu 3.13.3 → 4.1.0

package/dist/chunk-SS7NQSSZ.js

@@ -0,0 +1,3660 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+import {
+  CURRENT_SCHEMA_VERSION,
+  DEFAULT_EFFORT_DAYS,
+  DEFAULT_IMPACT,
+  DEFAULT_SUBSTATE,
+  MACHINE_LOCAL_ENTITIES,
+  MAX_AGENT_NAME_LEN,
+  NOTE_KINDS,
+  RESERVED_WORKSTREAM_NAMES,
+  SEGMENT_FORMAT_VERSION,
+  SEGMENT_READ_VERSIONS,
+  SELECT_TASK_COLS,
+  SYNCED_ENTITIES,
+  TASK_FROM_JOIN,
+  TASK_KINDS,
+  TaskNotFoundError,
+  addTasks,
+  compareHlc,
+  compareStrings,
+  decodeLine,
+  encodeSegmentLine,
+  expectsCtl,
+  formatPair,
+  getAgent,
+  getReceipt,
+  getTask,
+  getTaskNote,
+  insertNote,
+  isJsonMode,
+  isScratchWorkstream,
+  isTaskStatus,
+  listReady,
+  locksDir,
+  mapLegacyStatus,
+  newMsgId,
+  parseHlc,
+  prepareCached,
+  readWaitRegistration,
+  receiveHlc,
+  requestSha,
+  reserveReceipt,
+  resolvePair,
+  resolveWorkstreamId,
+  rowFromDb,
+  savedIdentity,
+  say,
+  shellWord,
+  taskIdFor,
+  taskRevision,
+  updateReceipt,
+  withCaptureSuppressed,
+  withFileLock,
+  withOpContext
+} from "./chunk-UCZPJX7K.js";
+
+// src/fold.ts
+function fieldsOf(payload) {
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    return {};
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const out = {};
+  for (const [field, value] of Object.entries(parsed)) {
+    if (value === null || typeof value === "string" || typeof value === "number") {
+      out[field] = value;
+    } else if (typeof value === "boolean") {
+      out[field] = value ? 1 : 0;
+    }
+  }
+  return out;
+}
+function isoOfHlc(hlc) {
+  try {
+    return new Date(parseHlc(hlc).wallMs).toISOString();
+  } catch {
+    return (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+}
+var ascending = (ops) => [...ops].sort((a, b) => compareHlc(a.hlc, b.hlc));
+function newestDel(ops) {
+  let newest = null;
+  for (const o of ops) {
+    if (o.op === "del" && (newest === null || compareHlc(o.hlc, newest) > 0)) newest = o.hlc;
+  }
+  return newest;
+}
+function laterHlc(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return compareHlc(a, b) >= 0 ? a : b;
+}
+function livePuts(ops, horizon) {
+  return ascending(ops).filter(
+    (o) => o.op === "put" && (horizon === null || compareHlc(o.hlc, horizon) > 0)
+  );
+}
+function lww(puts, field, accept) {
+  let found;
+  for (const p of puts) {
+    if (!(field in p.fields)) continue;
+    const v = accept(p.fields[field] ?? null);
+    if (v !== void 0) found = { value: v };
+  }
+  return found;
+}
+var str = (v) => typeof v === "string" ? v : void 0;
+var strOrNull = (v) => v === null || typeof v === "string" ? v : void 0;
+function foldWorkstream(ops, firstTaskPutAfter) {
+  const horizon = newestDel(ops);
+  const puts = livePuts(ops, horizon).map((o) => ({ hlc: o.hlc, fields: fieldsOf(o.payload) }));
+  const created = lww(puts, "created_at", str);
+  const torn = lww(puts, "torn_down_at", strOrNull);
+  const own = puts[0]?.hlc ?? null;
+  if (own === null && firstTaskPutAfter(horizon) === null) return null;
+  let createdAt = created?.value;
+  if (createdAt === void 0) {
+    const task = firstTaskPutAfter(horizon);
+    const start = own === null ? task : task === null ? own : earlierHlc(own, task);
+    createdAt = isoOfHlc(start ?? "");
+  }
+  return { createdAt, tornDownAt: torn?.value ?? null };
+}
+function earlierHlc(a, b) {
+  return compareHlc(a, b) <= 0 ? a : b;
+}
+function carriedSubstate(fields2) {
+  const { status, substate } = fields2;
+  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 knownStatus(v) {
+  if (typeof v !== "string") return void 0;
+  const legacy = mapLegacyStatus(v);
+  if (legacy) return legacy.status;
+  return isTaskStatus(v) ? v : void 0;
+}
+var impactOf = (v) => typeof v === "number" && Number.isFinite(v) && v >= 1 && v <= 100 ? v : void 0;
+var effortOf = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : void 0;
+var scoredOf = (v) => v === 0 || v === 1 ? v : void 0;
+var kindOf = (v) => typeof v === "string" && TASK_KINDS.includes(v) ? v : void 0;
+function foldTask(ops, horizon, localId) {
+  const puts = livePuts(ops, horizon).map((o) => ({ hlc: o.hlc, fields: fieldsOf(o.payload) }));
+  const began = puts[0]?.hlc;
+  if (began === void 0) return null;
+  const born = isoOfHlc(began);
+  const status = lww(puts, "status", knownStatus)?.value ?? "OPEN";
+  let winner = null;
+  for (const p of puts) winner = carriedSubstate(p.fields) ?? winner;
+  const pair = resolvePair(status, winner ?? DEFAULT_SUBSTATE[status]);
+  return {
+    title: lww(puts, "title", str)?.value ?? localId,
+    status,
+    substate: pair?.substate ?? DEFAULT_SUBSTATE[status],
+    impact: lww(puts, "impact", impactOf)?.value ?? DEFAULT_IMPACT,
+    effortDays: lww(puts, "effort_days", effortOf)?.value ?? DEFAULT_EFFORT_DAYS,
+    scored: lww(puts, "scored", scoredOf)?.value ?? 0,
+    dispatchHost: lww(puts, "dispatch_host", strOrNull)?.value ?? null,
+    kind: lww(puts, "kind", kindOf)?.value ?? "work",
+    wave: lww(puts, "wave", strOrNull)?.value ?? null,
+    createdAt: lww(puts, "created_at", str)?.value ?? born,
+    updatedAt: lww(puts, "updated_at", str)?.value ?? born
+  };
+}
+function noteIdentity(author, content, createdAt) {
+  return JSON.stringify([author ?? "", content, createdAt]);
+}
+function notePut(o) {
+  const f = fieldsOf(o.payload);
+  const author = typeof f.author === "string" ? f.author : f.author == null ? null : String(f.author);
+  const sentKind = f.kind;
+  return {
+    hlc: o.hlc,
+    key: o.key,
+    author,
+    content: f.content == null ? "" : String(f.content),
+    createdAt: typeof f.created_at === "string" ? f.created_at : isoOfHlc(o.hlc),
+    kind: NOTE_KINDS.includes(sentKind) ? sentKind : "note"
+  };
+}
+function foldNotes(ops, horizon) {
+  const sorted = ascending(ops);
+  const puts = sorted.filter((o) => o.op === "put").map(notePut);
+  const kills = [];
+  for (const d of sorted) {
+    if (d.op !== "del") continue;
+    const f = fieldsOf(d.payload);
+    if (f.content != null) {
+      kills.push({
+        hlc: d.hlc,
+        author: f.author == null ? null : String(f.author),
+        content: String(f.content),
+        createdAt: typeof f.created_at === "string" ? f.created_at : null
+      });
+      continue;
+    }
+    const src = puts.filter((p) => p.key === d.key && compareHlc(p.hlc, d.hlc) < 0).pop();
+    if (src)
+      kills.push({
+        hlc: d.hlc,
+        author: src.author,
+        content: src.content,
+        createdAt: src.createdAt
+      });
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const p of puts) {
+    if (horizon !== null && compareHlc(p.hlc, horizon) <= 0) continue;
+    const killed = kills.some(
+      (k) => compareHlc(k.hlc, p.hlc) > 0 && k.content === p.content && (k.author ?? "") === (p.author ?? "") && (k.createdAt === null || k.createdAt === p.createdAt)
+    );
+    if (killed) continue;
+    const id = noteIdentity(p.author, p.content, p.createdAt);
+    if (!out.has(id))
+      out.set(id, { author: p.author, content: p.content, createdAt: p.createdAt, kind: p.kind });
+  }
+  return out;
+}
+function foldEdge(ops, endpointHorizons) {
+  let horizon = newestDel(ops);
+  for (const h of endpointHorizons) horizon = laterHlc(horizon, h);
+  const first = livePuts(ops, horizon)[0];
+  if (first === void 0) return null;
+  const stamped = fieldsOf(first.payload).created_at;
+  return { createdAt: typeof stamped === "string" ? stamped : isoOfHlc(first.hlc) };
+}
+
+// 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 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 hi = (p) => `${p.slice(0, -1)}${String.fromCharCode(p.charCodeAt(p.length - 1) + 1)}`;
+var Log = class {
+  constructor(db, op) {
+    this.db = db;
+    this.pending = op && { hlc: op.hlc, op: op.op, key: op.key, payload: op.payload };
+    this.pendingEntity = op?.entity ?? "";
+  }
+  db;
+  pending;
+  pendingEntity;
+  withPending(entity, rows, inScope) {
+    const p = this.pending;
+    if (p === void 0 || entity !== this.pendingEntity || !inScope(p.key)) return rows;
+    return rows.some((r) => r.hlc === p.hlc) ? rows : [...rows, p];
+  }
+  /** The ops of one natural key. */
+  ofKey(entity, key) {
+    const rows = prepareCached(
+      this.db,
+      "SELECT hlc, op, key, payload FROM ops WHERE entity = ? AND key = ?"
+    ).all(entity, key);
+    return this.withPending(entity, rows, (k) => k === key);
+  }
+  /** The ops of every key in [lo, hi), grouped by key. */
+  range(entity, lo, hiKey) {
+    const rows = this.withPending(
+      entity,
+      prepareCached(
+        this.db,
+        "SELECT hlc, op, key, payload FROM ops WHERE entity = ? AND key >= ? AND key < ?"
+      ).all(entity, lo, hiKey),
+      (k) => k >= lo && k < hiKey
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const list = out.get(r.key);
+      if (list) list.push(r);
+      else out.set(r.key, [r]);
+    }
+    return out;
+  }
+  /** The oldest task put under workstream `ws` newer than `after`. */
+  firstTaskPutAfter(ws, after) {
+    const lo = `${ws}/`;
+    const row = prepareCached(
+      this.db,
+      `SELECT MIN(hlc) AS hlc FROM ops
+        WHERE entity = 'task' AND op = 'put' AND key >= @lo AND key < @hi
+          AND (@after IS NULL OR hlc > @after)`
+    ).get({ lo, hi: hi(lo), after });
+    const p = this.pending;
+    let best = row.hlc;
+    if (p !== void 0 && this.pendingEntity === "task" && p.op === "put" && p.key >= lo && p.key < hi(lo) && (after === null || p.hlc > after)) {
+      best = best === null || p.hlc < best ? p.hlc : best;
+    }
+    return best;
+  }
+  /** Edge keys naming a task in `scope`: a workstream (`name/`) or one task. */
+  edgeKeysTouching(scope) {
+    const candidates = "workstream" in scope ? prepareCached(
+      this.db,
+      `SELECT DISTINCT key FROM ops
+              WHERE entity = 'edge' AND (instr(key, @to) > 0 OR (key >= @lo AND key < @hi))`
+    ).all({
+      to: `->${scope.workstream}/`,
+      lo: `${scope.workstream}/`,
+      hi: hi(`${scope.workstream}/`)
+    }) : prepareCached(
+      this.db,
+      `SELECT DISTINCT key FROM ops
+              WHERE entity = 'edge'
+                AND ((key >= @lo AND key < @hi) OR substr(key, -length(@to)) = @to)`
+    ).all({ to: `->${scope.task}`, lo: `${scope.task}->`, hi: hi(`${scope.task}->`) });
+    const keys = new Set(candidates.map((r) => r.key));
+    const p = this.pending;
+    if (p !== void 0 && this.pendingEntity === "edge") keys.add(p.key);
+    return [...keys].filter((key) => {
+      let ends;
+      try {
+        ends = parseEdgeKey(key);
+      } catch {
+        return false;
+      }
+      const inScope = (t) => "workstream" in scope ? t.startsWith(`${scope.workstream}/`) : t === scope.task;
+      return inScope(ends.blocker) || inScope(ends.blocked);
+    });
+  }
+};
+function taskHorizon(log, taskKey) {
+  const { workstream } = parseTaskKey(taskKey);
+  return laterHlc(
+    newestDel(log.ofKey("task", taskKey)),
+    newestDel(log.ofKey("workstream", workstream))
+  );
+}
+function differing(a, b) {
+  return Object.keys(a).filter((k) => a[k] !== b[k]);
+}
+var workstreamId = (db, name) => prepareCached(db, "SELECT id FROM workstreams WHERE name = ?").get(name)?.id ?? null;
+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;
+}
+var UNCHANGED = { changed: false, fields: [] };
+function syncWorkstream(db, log, name) {
+  const state = foldWorkstream(
+    log.ofKey("workstream", name),
+    (after) => log.firstTaskPutAfter(name, after)
+  );
+  const row = prepareCached(
+    db,
+    "SELECT id, created_at, torn_down_at FROM workstreams WHERE name = ?"
+  ).get(name);
+  if (state === null) {
+    if (row === void 0) return UNCHANGED;
+    prepareCached(db, "DELETE FROM workstreams WHERE id = ?").run(row.id);
+    return { changed: true, fields: [] };
+  }
+  const want = { created_at: state.createdAt, torn_down_at: state.tornDownAt };
+  if (row === void 0) {
+    prepareCached(
+      db,
+      "INSERT INTO workstreams (name, created_at, torn_down_at) VALUES (?, ?, ?)"
+    ).run(name, state.createdAt, state.tornDownAt);
+    return { changed: true, fields: Object.keys(want) };
+  }
+  const fields2 = differing(want, { created_at: row.created_at, torn_down_at: row.torn_down_at });
+  if (fields2.length === 0) return UNCHANGED;
+  prepareCached(db, "UPDATE workstreams SET created_at = ?, torn_down_at = ? WHERE id = ?").run(
+    state.createdAt,
+    state.tornDownAt,
+    row.id
+  );
+  return { changed: true, fields: fields2 };
+}
+function syncTask(db, log, key) {
+  const { workstream, localId } = parseTaskKey(key);
+  const state = foldTask(log.ofKey("task", key), taskHorizon(log, key), localId);
+  const existing = prepareCached(
+    db,
+    `SELECT t.id, t.title, t.status, t.substate, t.impact, t.effort_days, t.scored,
+            t.dispatch_host, t.kind, t.wave, t.created_at, t.updated_at
+       FROM tasks t JOIN workstreams w ON w.id = t.workstream_id
+      WHERE w.name = ? AND t.local_id = ?`
+  ).get(workstream, localId);
+  if (state === null) {
+    if (existing === void 0) return UNCHANGED;
+    prepareCached(db, "DELETE FROM tasks WHERE id = ?").run(existing.id);
+    return { changed: true, fields: [] };
+  }
+  const want = {
+    title: state.title,
+    status: state.status,
+    substate: state.substate,
+    impact: state.impact,
+    effort_days: state.effortDays,
+    scored: state.scored,
+    dispatch_host: state.dispatchHost,
+    kind: state.kind,
+    wave: state.wave,
+    created_at: state.createdAt,
+    updated_at: state.updatedAt
+  };
+  if (existing === void 0) {
+    const wsId = workstreamId(db, workstream);
+    if (wsId === null) return UNCHANGED;
+    prepareCached(
+      db,
+      `INSERT INTO tasks (workstream_id, local_id, title, status, substate, impact, effort_days,
+                          scored, dispatch_host, kind, wave, owner_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`
+    ).run(
+      wsId,
+      localId,
+      state.title,
+      state.status,
+      state.substate,
+      state.impact,
+      state.effortDays,
+      state.scored,
+      state.dispatchHost,
+      state.kind,
+      state.wave,
+      state.createdAt,
+      state.updatedAt
+    );
+    return { changed: true, fields: Object.keys(want) };
+  }
+  const fields2 = differing(want, existing);
+  if (fields2.length === 0) return UNCHANGED;
+  prepareCached(
+    db,
+    `UPDATE tasks SET title = ?, status = ?, substate = ?, impact = ?, effort_days = ?,
+                      scored = ?, dispatch_host = ?, kind = ?, wave = ?, created_at = ?, updated_at = ?
+      WHERE id = ?`
+  ).run(
+    state.title,
+    state.status,
+    state.substate,
+    state.impact,
+    state.effortDays,
+    state.scored,
+    state.dispatchHost,
+    state.kind,
+    state.wave,
+    state.createdAt,
+    state.updatedAt,
+    existing.id
+  );
+  return { changed: true, fields: fields2 };
+}
+function syncNotes(db, log, taskKey) {
+  const taskId = taskRowId(db, taskKey);
+  if (taskId === null) return false;
+  const ops = [...log.range("note", `${taskKey}#`, `${taskKey}$`).values()].flat();
+  const want = foldNotes(ops, taskHorizon(log, taskKey));
+  const rows = prepareCached(
+    db,
+    "SELECT id, author, content, created_at, kind FROM task_notes WHERE task_id = ? ORDER BY id"
+  ).all(taskId);
+  let changed = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    const id = noteIdentity(r.author, r.content, r.created_at);
+    if (want.has(id) && !seen.has(id)) {
+      seen.add(id);
+      continue;
+    }
+    prepareCached(db, "DELETE FROM task_notes WHERE id = ?").run(r.id);
+    changed = true;
+  }
+  for (const [id, n] of want) {
+    if (seen.has(id)) continue;
+    prepareCached(
+      db,
+      "INSERT INTO task_notes (task_id, author, content, created_at, kind) VALUES (?, ?, ?, ?, ?)"
+    ).run(taskId, n.author, n.content, n.createdAt, n.kind);
+    changed = true;
+  }
+  return changed;
+}
+function syncEdge(db, log, key) {
+  const { blocker, blocked } = parseEdgeKey(key);
+  const state = blocker === blocked ? null : foldEdge(log.ofKey("edge", key), [taskHorizon(log, blocker), taskHorizon(log, blocked)]);
+  const fromId = taskRowId(db, blocker);
+  const toId = taskRowId(db, blocked);
+  const existing = fromId === null || toId === null ? void 0 : prepareCached(
+    db,
+    "SELECT created_at FROM task_edges WHERE from_task_id = ? AND to_task_id = ?"
+  ).get(fromId, toId);
+  const wanted = state !== null && fromId !== null && toId !== null;
+  if (!wanted) {
+    if (existing === void 0 || fromId === null || toId === null) return false;
+    prepareCached(db, "DELETE FROM task_edges WHERE from_task_id = ? AND to_task_id = ?").run(
+      fromId,
+      toId
+    );
+    return true;
+  }
+  if (existing === void 0) {
+    prepareCached(
+      db,
+      "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
+    ).run(fromId, toId, state.createdAt);
+    return true;
+  }
+  if (existing.created_at === state.createdAt) return false;
+  prepareCached(
+    db,
+    "UPDATE task_edges SET created_at = ? WHERE from_task_id = ? AND to_task_id = ?"
+  ).run(state.createdAt, fromId, toId);
+  return true;
+}
+function syncDependents(db, log, taskKey) {
+  let changed = syncNotes(db, log, taskKey);
+  for (const key of log.edgeKeysTouching({ task: taskKey })) {
+    if (syncEdge(db, log, key)) changed = true;
+  }
+  return changed;
+}
+function applyWorkstream(db, log, op) {
+  const name = op.key;
+  if (name.length === 0) throw new OpKeyMalformedError("workstream", name);
+  const ws = syncWorkstream(db, log, name);
+  let changed = ws.changed;
+  if (op.op === "del") {
+    const prefix = `${name}/`;
+    const taskKeys = [...log.range("task", prefix, hi(prefix)).keys()];
+    for (const key of taskKeys) if (syncTask(db, log, key).changed) changed = true;
+    for (const key of taskKeys) if (syncNotes(db, log, key)) changed = true;
+    const edges = log.edgeKeysTouching({ workstream: name });
+    for (const key of edges) if (syncEdge(db, log, key)) changed = true;
+  }
+  return { changed, appliedFields: ws.fields };
+}
+function applyTask(db, log, op) {
+  const { workstream } = parseTaskKey(op.key);
+  const existed = taskRowId(db, op.key) !== null;
+  const ws = syncWorkstream(db, log, workstream);
+  const task = syncTask(db, log, op.key);
+  let changed = ws.changed || task.changed;
+  const exists = taskRowId(db, op.key) !== null;
+  if ((op.op === "del" || existed !== exists) && syncDependents(db, log, op.key)) changed = true;
+  return { changed, appliedFields: task.fields };
+}
+function applyNote(db, log, op) {
+  const { taskKey } = parseNoteKey(op.key);
+  return { changed: syncNotes(db, log, taskKey), appliedFields: [] };
+}
+function applyEdge(db, log, op) {
+  parseEdgeKey(op.key);
+  return { changed: syncEdge(db, log, op.key), appliedFields: [] };
+}
+function applyOp(db, op) {
+  if (isKnownMachineLocalEntity(op.entity)) throw new OpEntityNotSyncedError(op.entity);
+  if (!isSyncedEntity(op.entity)) return { changed: false, appliedFields: [] };
+  if (op.entity === "message") return { changed: false, appliedFields: [] };
+  return withCaptureSuppressed(
+    db,
+    () => db.transaction(() => {
+      const log = new Log(db, op);
+      switch (op.entity) {
+        case "workstream":
+          return applyWorkstream(db, log, op);
+        case "task":
+          return applyTask(db, log, op);
+        case "note":
+          return applyNote(db, log, op);
+        default:
+          return applyEdge(db, log, op);
+      }
+    }).immediate()
+  );
+}
+function projectLog(db) {
+  const log = new Log(db);
+  const keys = (entity) => prepareCached(db, "SELECT DISTINCT key FROM ops WHERE entity = ?").all(entity).map((r) => r.key);
+  const taskKeys = keys("task");
+  const noteTasks = [...new Set(keys("note").map((k) => parseNoteKey(k).taskKey))];
+  const workstreams = /* @__PURE__ */ new Set([
+    ...keys("workstream"),
+    ...taskKeys.map((k) => parseTaskKey(k).workstream)
+  ]);
+  let written = 0;
+  return withCaptureSuppressed(
+    db,
+    () => db.transaction(() => {
+      for (const name of workstreams) if (syncWorkstream(db, log, name).changed) written += 1;
+      for (const key of taskKeys) if (syncTask(db, log, key).changed) written += 1;
+      for (const key of noteTasks) if (syncNotes(db, log, key)) written += 1;
+      for (const key of keys("edge")) if (syncEdge(db, log, key)) written += 1;
+      return written;
+    }).immediate()
+  );
+}
+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, fields2) {
+  const manifest = {
+    ...fields2,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    seal: manifestSeal(fields2)
+  };
+  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/sync-dir-guard.ts
+import { closeSync, openSync, readdirSync, readFileSync as readFileSync2, readSync } from "fs";
+import { join } from "path";
+var SYNC_DIR_FOREIGN_MESSAGE = "MU_SYNC_DIR holds 3.x segments; give mu 4 its own dir";
+var SyncDirForeignError = class extends Error {
+  constructor(dir, segment) {
+    super(`${SYNC_DIR_FOREIGN_MESSAGE} (${segment})`);
+    this.dir = dir;
+    this.segment = segment;
+  }
+  dir;
+  segment;
+  name = "SyncDirForeignError";
+};
+var VERSION_PREFIX = /^\{"v":(\d+)[,}]/;
+var guardOffForTests = false;
+function manifestIsPreV2(path) {
+  try {
+    const v = JSON.parse(readFileSync2(path, "utf8"))?.v;
+    return typeof v === "number" && v < 2;
+  } catch {
+    return false;
+  }
+}
+function startsAsV2OrUnknown(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return true;
+  }
+  try {
+    const buf = Buffer.alloc(24);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    const m = VERSION_PREFIX.exec(buf.toString("utf8", 0, n));
+    return m === null || Number(m[1]) >= 2;
+  } catch {
+    return true;
+  } finally {
+    closeSync(fd);
+  }
+}
+function assertSyncDirV2(dir) {
+  if (guardOffForTests) return;
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names.sort()) {
+    const path = join(dir, name);
+    const foreign = name.endsWith(".jsonl") ? !startsAsV2OrUnknown(path) : name.endsWith(".manifest") && manifestIsPreV2(path);
+    if (foreign) throw new SyncDirForeignError(dir, name);
+  }
+}
+
+// src/segments.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  appendFileSync,
+  closeSync as closeSync3,
+  existsSync as existsSync2,
+  mkdirSync,
+  openSync as openSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  readSync as readSync3,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, join as join2, resolve, sep } from "path";
+
+// src/segment-resume.ts
+import { createHash as createHash2 } from "crypto";
+import { closeSync as closeSync2, fstatSync, openSync as openSync2, readFileSync as readFileSync3, readSync as readSync2, statSync } from "fs";
+function usableShaState(state, length) {
+  if (typeof state !== "object" || state === null) return null;
+  const { h, n, tail } = state;
+  if (typeof h !== "string" || !/^[0-9a-f]{64}$/.test(h)) return null;
+  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0 || n !== length) return null;
+  if (typeof tail !== "string") return null;
+  const raw = Buffer.from(tail, "base64");
+  if (raw.length !== n % 64 || raw.toString("base64") !== tail) return null;
+  return { h, n, tail };
+}
+function encodeFingerprint(key, resume) {
+  if (resume === null) return key;
+  const { lines, size, lastHlc, state } = resume;
+  return [key, lines, size, lastHlc, state.h, state.tail].join("	");
+}
+function decodeFingerprint(raw) {
+  const [key = "", lines, size, lastHlc, h, tail] = raw.split("	");
+  if (h === void 0 || tail === void 0 || lines === void 0 || size === void 0) {
+    return { key, resume: null };
+  }
+  const n = Number(size);
+  const count = Number(lines);
+  if (!Number.isSafeInteger(n) || n <= 0 || !Number.isSafeInteger(count) || count <= 0) {
+    return { key, resume: null };
+  }
+  if (!lastHlc || !/^[0-9a-f]{64}$/.test(h)) return { key, resume: null };
+  return { key, resume: { lines: count, size: n, lastHlc, state: { h, n, tail } } };
+}
+function readAppended(path, resume, manifestSha) {
+  let fd;
+  try {
+    fd = openSync2(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const size = fstatSync(fd).size;
+    if (size <= resume.size) return null;
+    const bytes3 = Buffer.alloc(size - resume.size);
+    for (let got = 0; got < bytes3.length; ) {
+      const n = readSync2(fd, bytes3, got, bytes3.length - got, resume.size + got);
+      if (n === 0) return null;
+      got += n;
+    }
+    const state = sha256Update(resume.state, bytes3);
+    return sha256Digest(state) === manifestSha ? { bytes: bytes3, state } : null;
+  } finally {
+    closeSync2(fd);
+  }
+}
+function segmentFingerprint(path) {
+  try {
+    const { size, mtimeMs } = statSync(path);
+    const manifest = readFileSync3(manifestPath(path));
+    const sha = createHash2("sha256").update(manifest).digest("hex");
+    let count = null;
+    let parsed = null;
+    try {
+      parsed = JSON.parse(manifest.toString("utf8"));
+      count = parsed?.count;
+    } catch {
+    }
+    return { key: `${size} ${mtimeMs} ${sha}`, count, manifest: parsed };
+  } 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 === decodeFingerprint(recorded).key;
+}
+function resumePoint(db, watermarkKey, lines) {
+  const recorded = recordedFingerprint(db, watermarkKey);
+  const resume = recorded === null ? null : decodeFingerprint(recorded).resume;
+  return resume !== null && resume.lines === lines ? resume : null;
+}
+
+// src/segments.ts
+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 = resolve(dir);
+  const temp = resolve(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 join2(dir, `${machineId}${SEGMENT_EXT2}`);
+}
+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,
+      foreignVersionAt: null,
+      foreignVersion: null
+    };
+  assertSyncDirV2(dir);
+  const machineId = localMachineId(db);
+  mkdirSync(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,
+        foreignVersionAt: null,
+        foreignVersion: null
+      };
+    }
+  }
+  const lockName = createHash3("sha256").update(`${dir}${machineId}`).digest("hex").slice(0, 16);
+  return withFileLock(
+    join2(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,
+        foreignVersionAt: null,
+        foreignVersion: 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.foreign !== null) {
+      rmSync(manifestPath(path), { force: true });
+      return {
+        segmentPath: path,
+        appended: 0,
+        total: existing.lineCount,
+        skippedLocal: 0,
+        selfRepaired: null,
+        foreignVersionAt: existing.foreign.line,
+        foreignVersion: existing.foreign.version
+      };
+    }
+    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,
+    foreignVersionAt: null,
+    foreignVersion: null
+  };
+  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) {
+    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 || !SEGMENT_READ_VERSIONS.includes(m.v) || m.machine !== machineId) return null;
+  if (!manifestSelfConsistent(m)) return null;
+  const { count, lastHlc, size, mtimeMs, shaState } = m;
+  let stat;
+  try {
+    stat = statSync2(path);
+  } catch {
+    return null;
+  }
+  if (stat.size !== size || stat.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 = openSync3(path, "r");
+  try {
+    const last = Buffer.alloc(1);
+    readSync3(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);
+      readSync3(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 {
+    closeSync3(fd);
+  }
+}
+function ownSegmentForeignLine(db, dir = syncDir()) {
+  if (dir === null) return null;
+  const path = segmentPath(dir, localMachineId(db));
+  const found = readSegmentTail(path).foreign;
+  return found === null ? null : { path, ...found };
+}
+function countUnpublishedOps(db, dir) {
+  const machineId = localMachineId(db);
+  const { lastHlc } = readSegmentTail(segmentPath(dir, machineId));
+  const row = prepareCached(
+    db,
+    `SELECT COUNT(*) AS n FROM ops INDEXED BY idx_ops_machine_entity_hlc
+      WHERE machine_id = @machineId AND entity IN (${SYNCED_ENTITIES_SQL}) AND hlc > @from`
+  ).get({ machineId, from: lastHlc ?? "" });
+  return row.n;
+}
+function segmentLineCount(path) {
+  return readSegmentTail(path).count;
+}
+function readSegmentTail(path) {
+  if (!existsSync2(path))
+    return { count: 0, lastHlc: null, goodLines: [], defect: null, foreign: null, lineCount: 0 };
+  const lines = segmentLines(readFileSync4(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,
+        ...decoded.version === void 0 ? {} : { version: decoded.version }
+      };
+      break;
+    }
+    lastHlc = decoded.line.hlc;
+    count += 1;
+  }
+  let foreign = null;
+  if (defect?.kind === "unknown-version" && defect.version !== void 0) {
+    foreign = { line: defect.line, version: defect.version };
+  } else if (defect !== null) {
+    for (let i = count + 1; i < lines.length && foreign === null; i++) {
+      const later = decodeLine(lines[i] ?? "");
+      if (!later.ok && later.kind === "unknown-version" && later.version !== void 0)
+        foreign = { line: i + 1, version: later.version };
+    }
+  }
+  return {
+    count,
+    lastHlc,
+    goodLines: lines.slice(0, count),
+    defect,
+    foreign,
+    lineCount: lines.length
+  };
+}
+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 stat = statSync2(path);
+  let shaState;
+  if (incremental !== null && stat.size === incremental.size + incremental.appended.length) {
+    shaState = sha256Update(incremental.state, incremental.appended);
+  } else {
+    const bytes3 = readFileSync4(path);
+    shaState = sha256Update(sha256Initial(), bytes3);
+    stat = statSync2(path);
+  }
+  writeManifestFile(path, {
+    v: SEGMENT_FORMAT_VERSION,
+    machine,
+    count,
+    lastHlc,
+    sha256: sha256Digest(shaState),
+    size: shaState.n,
+    mtimeMs: stat.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" };
+  return checkBytesAgainstManifest(segment, manifest, readFileSync4(segment));
+}
+function checkBytesAgainstManifest(segment, manifest, bytes3) {
+  const sha = createHash3("sha256").update(bytes3).digest("hex");
+  if (sha === manifest.sha256) return { ok: true, exact: true };
+  const tail = readSegmentTail(segment);
+  if (tail.count >= manifest.count) {
+    return { ok: true, exact: false };
+  }
+  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 [];
+  assertSyncDirV2(dir);
+  const peers = [];
+  for (const name of readdirSync2(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 = join2(dir, name);
+    try {
+      if (!statSync2(path).isFile()) continue;
+    } catch {
+      continue;
+    }
+    peers.push({ machineId, watermarkKey: conflictCopy ? stem : machineId, path, conflictCopy });
+  }
+  return peers.sort((a, b) => compareStrings(a.path, 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 resetWatermark(db, watermarkKey) {
+  setWatermark(db, watermarkKey, 0);
+}
+function ingestSegment(db, peer, opts) {
+  assertSyncDirV2(dirname(peer.path));
+  const defects = [];
+  const watermarkKey = peerWatermarkKey(peer);
+  const start = getWatermark(db, watermarkKey);
+  const nothing = {
+    machineId: peer.machineId,
+    path: peer.path,
+    read: 0,
+    applied: 0,
+    changed: 0,
+    watermark: start,
+    defects,
+    truncatedAt: null
+  };
+  if (opts?.verify !== true && segmentCaughtUp(db, watermarkKey, peer.path, start)) return nothing;
+  if (!existsSync2(peer.path)) return nothing;
+  const fingerprint = segmentFingerprint(peer.path);
+  const resume = opts?.verify !== true && fingerprint?.manifest != null && start > 0 ? resumePoint(db, watermarkKey, start) : null;
+  const appended = resume !== null && fingerprint?.manifest != null ? readAppended(peer.path, resume, fingerprint.manifest.sha256) : null;
+  let lines;
+  let base;
+  let seedHlc = null;
+  let nextResume = null;
+  let resumeState = null;
+  let resumeSize = 0;
+  if (resume !== null && appended !== null) {
+    lines = segmentLines(appended.bytes.toString("utf8"));
+    base = resume.lines;
+    seedHlc = resume.lastHlc;
+    resumeState = appended.bytes[appended.bytes.length - 1] === 10 ? appended.state : null;
+    resumeSize = appended.state.n;
+  } else {
+    const manifest = readManifest(peer.path);
+    const bytes3 = readFileSync4(peer.path);
+    if (manifest !== null) {
+      const verified = checkBytesAgainstManifest(peer.path, manifest, bytes3);
+      if (!verified.ok) {
+        defects.push({ kind: "manifest-mismatch", line: 0, detail: verified.reason });
+      } else if (verified.exact) {
+        const state = usableShaState(manifest.shaState, bytes3.length);
+        if (state !== null && bytes3[bytes3.length - 1] === 10 && sha256Digest(state) === manifest.sha256) {
+          resumeState = state;
+          resumeSize = bytes3.length;
+        }
+      }
+    }
+    lines = segmentLines(bytes3.toString("utf8"));
+    base = 0;
+    if (start > 0 && start <= lines.length) {
+      const prior = lines[start - 1];
+      if (prior !== void 0) {
+        const decoded = decodeLine(prior);
+        if (decoded.ok) seedHlc = decoded.line.hlc;
+      }
+    }
+  }
+  const total = base + lines.length;
+  let applied = 0;
+  let changed = 0;
+  let watermark = start;
+  let truncatedAt = null;
+  let previousHlc = seedHlc;
+  const run = db.transaction(() => {
+    for (let index = start - base; index < lines.length; index++) {
+      const raw = lines[index];
+      const lineNo = base + 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,
+          ...decoded.version === void 0 ? {} : { version: decoded.version }
+        });
+        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;
+      }
+      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 === total;
+    if (clean && resumeState !== null && previousHlc !== null) {
+      nextResume = { lines: total, size: resumeSize, lastHlc: previousHlc, state: resumeState };
+    }
+    setWatermark(
+      db,
+      watermarkKey,
+      watermark,
+      clean && fingerprint !== null ? encodeFingerprint(fingerprint.key, nextResume) : 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);
+  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,
+        foreignVersionAt: null,
+        foreignVersion: 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 })
+  );
+  return {
+    flushed,
+    ingested,
+    defective: flushed.selfRepaired !== null || flushed.foreignVersionAt !== null || ingested.some((r) => r.defects.length > 0)
+  };
+}
+
+// src/task-auto.ts
+var CLI_KEY_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var TaskAutoRefusedError = class extends Error {
+  constructor(message, workstream, taskId) {
+    super(message);
+    this.workstream = workstream;
+    this.taskId = taskId;
+  }
+  workstream;
+  taskId;
+  name = "TaskAutoRefusedError";
+};
+var TaskAutoArgError = class extends Error {
+  name = "TaskAutoArgError";
+};
+var configOf = (r) => ({
+  cli: r.cli,
+  worktree: r.worktree === 1,
+  maxRuns: r.max_runs,
+  runs: r.runs,
+  lastSpawn: r.last_spawn,
+  enabled: r.enabled === 1
+});
+function getAutoConfig(db, taskId) {
+  const row = db.prepare(
+    "SELECT cli, worktree, max_runs, runs, last_spawn, enabled FROM task_auto WHERE task_id = ?"
+  ).get(taskId);
+  return row === void 0 ? void 0 : configOf(row);
+}
+function autoPermitted(db, taskId) {
+  return db.prepare(
+    `SELECT 1 AS x FROM task_auto a JOIN tasks t ON t.id = a.task_id
+          WHERE a.task_id = ? AND a.enabled = 1 AND t.kind = 'work' AND t.dispatch_host = ?`
+  ).get(taskId, localMachineId(db)) !== void 0;
+}
+function authorisedReady(db, workstream) {
+  if (RESERVED_WORKSTREAM_NAMES.has(workstream)) return [];
+  const rows = db.prepare(
+    `SELECT t.local_id AS local_id, a.cli, a.worktree, a.max_runs, a.runs, a.last_spawn, a.enabled
+         FROM task_auto a
+         JOIN tasks t ON t.id = a.task_id
+         JOIN workstreams w ON w.id = t.workstream_id AND w.name = ?
+        WHERE a.enabled = 1 AND a.runs < a.max_runs
+          AND t.kind = 'work' AND t.dispatch_host = ?`
+  ).all(workstream, localMachineId(db));
+  const byId = new Map(rows.map((r) => [r.local_id, configOf(r)]));
+  const out = [];
+  for (const t of listReady(db, workstream)) {
+    const auto = byId.get(t.name);
+    if (auto !== void 0) out.push({ ...t, auto });
+  }
+  return out;
+}
+function openBlockersClosure(db, workstreamId2, umbrellaId) {
+  const blockersOf = db.prepare(
+    `SELECT b.id AS id, b.local_id AS local_id, b.status AS status
+       FROM task_edges e JOIN tasks b ON b.id = e.from_task_id
+      WHERE e.to_task_id = ? AND b.workstream_id = ?`
+  );
+  const seen = /* @__PURE__ */ new Set([umbrellaId]);
+  const queue = [umbrellaId];
+  const found = [];
+  for (let cur = queue.shift(); cur !== void 0; cur = queue.shift()) {
+    const rows = blockersOf.all(cur, workstreamId2);
+    for (const r of rows) {
+      if (seen.has(r.id) || r.status === "CLOSED") continue;
+      seen.add(r.id);
+      found.push(r.local_id);
+      queue.push(r.id);
+    }
+  }
+  return found.sort();
+}
+function authorizeTasks(db, ids, opts) {
+  const ws = opts.workstream;
+  if (RESERVED_WORKSTREAM_NAMES.has(ws)) {
+    throw new TaskAutoArgError(say("task.auto_reserved_ws", ws));
+  }
+  if (!opts.off) {
+    if (!CLI_KEY_RE.test(opts.cli)) {
+      throw new TaskAutoArgError(say("task.auto_cli_key", opts.cli));
+    }
+    if (!Number.isSafeInteger(opts.maxRuns) || opts.maxRuns < 1) {
+      throw new TaskAutoArgError(say("task.auto_max", opts.maxRuns));
+    }
+  }
+  return withOpContext(
+    db,
+    { intent: opts.off ? "task.auto-off" : "task.auto", actor: opts.actor, group: "new" },
+    () => {
+      const me = localMachineId(db);
+      const selected = [...ids];
+      if (opts.blockersOf !== void 0) {
+        const umbrella = getTask(db, opts.blockersOf, ws);
+        if (!umbrella) throw new TaskNotFoundError(opts.blockersOf, ws);
+        selected.push(...openBlockersClosure(db, umbrella.workstreamId, tidOf(db, umbrella)));
+      }
+      const names = [...new Set(selected)];
+      if (names.length === 0) {
+        throw new TaskAutoArgError(
+          opts.blockersOf !== void 0 ? say("task.auto_no_blockers", opts.blockersOf) : say("task.auto_none_given")
+        );
+      }
+      const plan = [];
+      for (const name of names) {
+        const task = getTask(db, name, ws);
+        if (!task) throw new TaskNotFoundError(name, ws);
+        const id = tidOf(db, task);
+        if (!opts.off) refuseUnauthorisable(task, me);
+        plan.push({ task, id });
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let changed = false;
+      for (const { task, id } of plan) {
+        const row = db.prepare("SELECT cli, worktree, max_runs, enabled FROM task_auto WHERE task_id = ?").get(id);
+        if (opts.off) {
+          if (row !== void 0 && row.enabled === 1) {
+            db.prepare("UPDATE task_auto SET enabled = 0 WHERE task_id = ?").run(id);
+            changed = true;
+          }
+          if (task.dispatchHost === me) {
+            setHost(db, id, null, now);
+            changed = true;
+          }
+          continue;
+        }
+        const wt = opts.worktree ? 1 : 0;
+        if (row === void 0) {
+          db.prepare(
+            "INSERT INTO task_auto (task_id, cli, worktree, max_runs, created_at) VALUES (?, ?, ?, ?, ?)"
+          ).run(id, opts.cli, wt, opts.maxRuns, now);
+          changed = true;
+        } else if (row.cli !== opts.cli || row.worktree !== wt || row.max_runs !== opts.maxRuns || row.enabled !== 1) {
+          db.prepare(
+            "UPDATE task_auto SET cli = ?, worktree = ?, max_runs = ?, enabled = 1 WHERE task_id = ?"
+          ).run(opts.cli, wt, opts.maxRuns, id);
+          changed = true;
+        }
+        if (task.dispatchHost !== me) {
+          setHost(db, id, me, now);
+          changed = true;
+        }
+      }
+      return { ids: names, changed };
+    }
+  );
+}
+function tidOf(db, task) {
+  const id = taskIdFor(db, task.name, task.workstreamName);
+  if (id === null) throw new TaskNotFoundError(task.name, task.workstreamName);
+  return id;
+}
+function setHost(db, taskId, host, now) {
+  db.prepare("UPDATE tasks SET dispatch_host = ?, updated_at = ? WHERE id = ?").run(
+    host,
+    now,
+    taskId
+  );
+}
+function refuseUnauthorisable(task, me) {
+  const refuse2 = (why) => {
+    throw new TaskAutoRefusedError(
+      `cannot authorise ${task.name}: ${why}`,
+      task.workstreamName,
+      task.name
+    );
+  };
+  if (task.kind !== "work") refuse2(`it is a ${task.kind} task, not a worker job`);
+  if (task.status === "CLOSED") refuse2("it is CLOSED");
+  if (task.substate === "parked") refuse2("it is parked (unpark it first)");
+  if (task.substate === "triage") refuse2("it is in triage (accept it first)");
+  if (task.dispatchHost !== null && task.dispatchHost !== me) {
+    refuse2(`another host (${task.dispatchHost}) is designated to dispatch it`);
+  }
+}
+
+// src/task-brief.ts
+var TaskBriefMissingError = class extends Error {
+  constructor(task, workstream, reason) {
+    super(say("task.brief_missing", task, reason));
+    this.task = task;
+    this.workstream = workstream;
+  }
+  task;
+  workstream;
+  name = "TaskBriefMissingError";
+};
+function pinnedNotes(db, workstream, task) {
+  const taskId = taskIdFor(db, task, workstream);
+  if (taskId === null) throw new TaskNotFoundError(task, workstream);
+  const kinds = db.prepare("SELECT kind FROM task_notes WHERE task_id = ? ORDER BY id").all(taskId).map((r) => r.kind);
+  return { briefN: kinds.indexOf("brief") + 1, reportN: kinds.lastIndexOf("report") + 1 };
+}
+function buildTaskBrief(db, workstream, task, opts = {}) {
+  const { briefN, reportN } = pinnedNotes(db, workstream, task);
+  if (briefN < 1) {
+    throw new TaskBriefMissingError(task, workstream, "it has no brief note (kind brief)");
+  }
+  const brief = getTaskNote(db, task, workstream, briefN).content;
+  const report = reportN < 1 ? null : getTaskNote(db, task, workstream, reportN).content;
+  const parts = [brief.trimEnd()];
+  if (report !== null) parts.push(`Latest report on this task:
+${report.trimEnd()}`);
+  if (opts.retry === true) {
+    parts.push("The previous attempt died before it finished; continue from its report.");
+  } else if (opts.retry === "error") {
+    parts.push(
+      "Your previous run stopped on an API error before it finished; continue where you stopped."
+    );
+  }
+  parts.push(
+    `Work only on task ${task} (workstream ${workstream}). Commit, then end your final message with:
+CLOSE: task=${task} evidence="<command + result>"
+REPORT:
+<what you did>`
+  );
+  return { text: parts.join("\n\n") };
+}
+
+// src/auto-attempt.ts
+var IN_FLIGHT_STATES = /* @__PURE__ */ new Set([
+  "reserved",
+  "pane",
+  "claimed",
+  "sending",
+  "unknown"
+]);
+var UNSENT_STATES = /* @__PURE__ */ new Set(["reserved", "pane", "claimed"]);
+var refuse = (code, reason) => ({ ok: false, code, reason });
+function workerGone(db, taskId, receipt) {
+  if (savedIdentity(db, receipt).stale === void 0) return false;
+  const head = `[reaper] previous owner ${receipt.name} gone`;
+  return db.prepare(
+    `SELECT 1 AS x FROM task_notes
+          WHERE task_id = ? AND author = 'reaper' AND created_at >= ? AND instr(content, ?) = 1
+          LIMIT 1`
+  ).get(taskId, receipt.createdAt, head) !== void 0;
+}
+function parseAttempt(raw) {
+  if (raw === null) return void 0;
+  try {
+    const r = JSON.parse(raw);
+    if (r.v !== 1 || typeof r.key !== "string" || typeof r.attempt !== "number" || typeof r.text !== "string") {
+      return void 0;
+    }
+    return r;
+  } catch {
+    return void 0;
+  }
+}
+function readAttempt(db, taskId) {
+  const auto = getAutoConfig(db, taskId);
+  const record = parseAttempt(auto?.lastSpawn ?? null);
+  const receipt = record === void 0 ? void 0 : getReceipt(db, taskId, record.key);
+  return {
+    ...auto !== void 0 ? { auto } : {},
+    ...record !== void 0 ? { record } : {},
+    ...receipt !== void 0 ? { receipt } : {}
+  };
+}
+function deliveredOf(db, taskId) {
+  const { record, receipt } = readAttempt(db, taskId);
+  if (record === void 0 || receipt === void 0 || record.end !== void 0) return void 0;
+  if (receipt.state === "sent") return { record, receipt };
+  if (record.inPlace !== true || receipt.state !== "failed") return void 0;
+  const prior = db.prepare(
+    `SELECT attempt_key FROM spawn_receipts
+        WHERE task_id = ? AND state = 'sent' AND attempt_key LIKE 'auto:%' AND agent_id = ?
+        ORDER BY created_at DESC, attempt_key DESC LIMIT 1`
+  ).get(taskId, receipt.agentId);
+  const sent = prior === void 0 ? void 0 : getReceipt(db, taskId, prior.attempt_key);
+  return sent === void 0 ? void 0 : { record, receipt: sent };
+}
+function pendingAttempts(db, workstream) {
+  const rows = db.prepare(
+    `SELECT t.id AS id, t.local_id AS local_id
+         FROM task_auto a
+         JOIN tasks t ON t.id = a.task_id
+         JOIN workstreams w ON w.id = t.workstream_id AND w.name = ?
+         JOIN spawn_receipts r ON r.task_id = a.task_id
+          AND r.attempt_key = json_extract(a.last_spawn, '$.key')
+        WHERE a.enabled = 1 AND t.kind = 'work' AND t.dispatch_host = ?
+          AND r.state IN ('reserved', 'pane', 'claimed', 'sending', 'unknown')
+          AND json_extract(a.last_spawn, '$.end') IS NULL
+          AND json_extract(a.last_spawn, '$.text') IS NOT NULL
+        ORDER BY t.id`
+  ).all(workstream, localMachineId(db));
+  return rows.filter((r) => autoPermitted(db, r.id)).map((r) => r.local_id);
+}
+function attemptName(task, attempt) {
+  const suffix = `-${attempt}`;
+  return `${task.slice(0, MAX_AGENT_NAME_LEN - suffix.length)}${suffix}`;
+}
+var attemptSha = (name, text) => requestSha({ name, nextFree: true, text });
+function planAttempt(db, workstream, task, opts = {}) {
+  const taskId = taskIdFor(db, task, workstream);
+  if (taskId === null) return refuse("not-found", `no task ${task} in ${workstream}`);
+  if (!autoPermitted(db, taskId)) {
+    return refuse("not-permitted", `${task} is not authorised for this machine (mu task auto)`);
+  }
+  const { auto, record, receipt } = readAttempt(db, taskId);
+  if (auto === void 0) return refuse("not-permitted", `${task} has no auto config`);
+  let retry = false;
+  if (record?.end?.state === "needs_human") {
+    return refuse(
+      "parked",
+      `${record.key} of ${task} may have been delivered and waits for a human (${record.end.reason})`
+    );
+  }
+  if (record !== void 0 && receipt !== void 0 && record.end === void 0) {
+    if (IN_FLIGHT_STATES.has(receipt.state)) {
+      return refuse("in-flight", `${record.key} of ${task} is ${receipt.state}: resume it`);
+    }
+    const delivered = deliveredOf(db, taskId);
+    if (delivered !== void 0) {
+      if (!workerGone(db, taskId, delivered.receipt)) {
+        return refuse(
+          "delivered",
+          `${record.key} of ${task} was delivered and its worker is not known to be gone: not re-dispatched`
+        );
+      }
+      retry = true;
+    }
+  }
+  if (auto.runs >= auto.maxRuns) {
+    return refuse("ceiling", `${task} used its ${auto.maxRuns} run(s)`);
+  }
+  if (!listReady(db, workstream).some((t) => t.name === task)) {
+    return refuse("not-ready", `${task} is not ready`);
+  }
+  const revision = taskRevision(db, workstream, task);
+  if (opts.revision !== void 0 && opts.revision !== revision) {
+    return refuse(
+      "changed",
+      `${task} changed since it was planned (rev ${opts.revision} \u2192 ${revision})`
+    );
+  }
+  const attempt = auto.runs + 1;
+  const name = attemptName(task, attempt);
+  let brief;
+  try {
+    brief = buildTaskBrief(db, workstream, task, { retry });
+  } catch (err) {
+    if (err instanceof TaskBriefMissingError) return refuse("no-brief", err.message);
+    throw err;
+  }
+  return {
+    ok: true,
+    plan: {
+      v: 1,
+      attempt,
+      key: `auto:${attempt}`,
+      name,
+      cli: auto.cli,
+      worktree: auto.worktree,
+      text: brief.text,
+      retry,
+      task,
+      taskId,
+      workstream,
+      revision
+    }
+  };
+}
+function reserveAttempt(db, workstream, task, opts = {}) {
+  return db.transaction(() => {
+    const planned = planAttempt(db, workstream, task, opts);
+    if (!planned.ok) return planned;
+    const { plan } = planned;
+    const { task: _t, taskId, workstream: _w, revision: _r, ...record } = plan;
+    const charged = db.prepare(
+      "UPDATE task_auto SET runs = runs + 1, last_spawn = ? WHERE task_id = ? AND runs = ? AND enabled = 1"
+    ).run(JSON.stringify(record), taskId, plan.attempt - 1);
+    if (charged.changes !== 1) return refuse("changed", `${task}'s run counter moved`);
+    reserveReceipt(db, {
+      taskId,
+      attemptKey: plan.key,
+      name: plan.name,
+      workstream,
+      requestSha: attemptSha(plan.name, plan.text),
+      msgId: newMsgId()
+    });
+    return planned;
+  }).immediate();
+}
+function endAttempt(db, taskId, key, end) {
+  return db.transaction(() => {
+    const { record, receipt } = readAttempt(db, taskId);
+    if (record === void 0 || record.key !== key || record.end !== void 0) return false;
+    const changed = db.prepare("UPDATE task_auto SET last_spawn = ? WHERE task_id = ?").run(JSON.stringify({ ...record, end }), taskId).changes;
+    if (changed !== 1) return false;
+    if (receipt !== void 0 && UNSENT_STATES.has(receipt.state)) {
+      updateReceipt(db, taskId, key, { state: "failed", detail: `${end.state}: ${end.reason}` });
+    }
+    return true;
+  }).immediate();
+}
+function reserveRetry(db, workstream, task, target) {
+  return db.transaction(() => {
+    const taskId = taskIdFor(db, task, workstream);
+    if (taskId === null) return refuse("not-found", `no task ${task} in ${workstream}`);
+    if (!autoPermitted(db, taskId)) {
+      return refuse("not-permitted", `${task} is not authorised for this machine (mu task auto)`);
+    }
+    const { auto } = readAttempt(db, taskId);
+    const delivered = deliveredOf(db, taskId);
+    if (auto === void 0 || delivered === void 0) {
+      return refuse("changed", `${task} has no delivered attempt`);
+    }
+    const { receipt } = delivered;
+    const { agent } = target;
+    if (receipt.agentId !== agent.incarnation || receipt.paneId !== agent.paneId || receipt.name !== agent.name || savedIdentity(db, receipt).stale !== void 0) {
+      return refuse("changed", `${task}: the worker is not the one its attempt delivered to`);
+    }
+    if (receipt.runs === null || target.errorRuns <= receipt.runs) {
+      return refuse("changed", `${task}: that error was already answered`);
+    }
+    const row = db.prepare("SELECT status, owner_id FROM tasks WHERE id = ?").get(taskId);
+    if (row.status !== "IN_PROGRESS" || row.owner_id !== agent.incarnation) {
+      return refuse("changed", `${task} is no longer in progress with ${agent.name}`);
+    }
+    if (auto.runs >= auto.maxRuns) {
+      return refuse("ceiling", `${task} used its ${auto.maxRuns} run(s)`);
+    }
+    let brief;
+    try {
+      brief = buildTaskBrief(db, workstream, task, { retry: "error" });
+    } catch (err) {
+      if (err instanceof TaskBriefMissingError) return refuse("no-brief", err.message);
+      throw err;
+    }
+    const attempt = auto.runs + 1;
+    const plan = {
+      v: 1,
+      attempt,
+      key: `auto:${attempt}`,
+      name: agent.name,
+      cli: auto.cli,
+      worktree: auto.worktree,
+      text: brief.text,
+      retry: true,
+      inPlace: true,
+      task,
+      taskId,
+      workstream,
+      revision: taskRevision(db, workstream, task)
+    };
+    const { task: _t, taskId: _i, workstream: _w, revision: _r, ...stored } = plan;
+    const charged = db.prepare(
+      "UPDATE task_auto SET runs = runs + 1, last_spawn = ? WHERE task_id = ? AND runs = ? AND enabled = 1"
+    ).run(JSON.stringify(stored), taskId, auto.runs);
+    if (charged.changes !== 1) return refuse("changed", `${task}'s run counter moved`);
+    reserveReceipt(db, {
+      taskId,
+      attemptKey: plan.key,
+      name: agent.name,
+      workstream,
+      requestSha: attemptSha(agent.name, plan.text),
+      msgId: newMsgId()
+    });
+    updateReceipt(db, taskId, plan.key, {
+      state: "claimed",
+      agentId: agent.incarnation,
+      paneId: agent.paneId,
+      incarnation: target.pi
+    });
+    return { ok: true, plan };
+  }).immediate();
+}
+
+// src/dag.ts
+var FRONTIER_MAX_DEPTH = 12;
+var FRONTIER_MAX_NODES = 2e3;
+var FRONTIER_CLOSED_PER_NODE = 3;
+function loadOpenTaskFrontier(db, workstream, root, direction = "dependents", opts = {}) {
+  const out = { direction, entries: [], rootsCut: 0, againCut: 0 };
+  const uncapped = opts.uncapped === true;
+  const maxDepth = uncapped ? Number.POSITIVE_INFINITY : Math.min(opts.maxDepth ?? FRONTIER_MAX_DEPTH, FRONTIER_MAX_DEPTH);
+  const maxNodes = uncapped ? Number.POSITIVE_INFINITY : FRONTIER_MAX_NODES;
+  const closedPerNode = uncapped ? Number.POSITIVE_INFINITY : FRONTIER_CLOSED_PER_NODE;
+  const wsRow = db.prepare("SELECT id FROM workstreams WHERE name = ? AND torn_down_at IS NULL").get(workstream);
+  if (wsRow === void 0) return out;
+  const wsId = wsRow.id;
+  const [from, to] = direction === "dependents" ? ["from_task_id", "to_task_id"] : ["to_task_id", "from_task_id"];
+  const includeClosed = opts.includeClosed === true || uncapped;
+  const nodes = /* @__PURE__ */ new Map();
+  const rootIds = /* @__PURE__ */ new Set();
+  let level = [];
+  const startRows = [];
+  if (root !== void 0) {
+    const id = taskIdFor(db, root, workstream);
+    if (id === null) return out;
+    startRows.push(
+      db.prepare(`SELECT ${SELECT_TASK_COLS} ${TASK_FROM_JOIN} WHERE t.id = ?`).get(id)
+    );
+  } else {
+    startRows.push(
+      ...db.prepare(
+        `SELECT ${SELECT_TASK_COLS} ${TASK_FROM_JOIN}
+            WHERE t.workstream_id = ? AND t.status <> 'CLOSED'
+              AND NOT EXISTS (SELECT 1 FROM task_edges e JOIN tasks p ON p.id = e.${from}
+                               WHERE e.${to} = t.id AND p.status <> 'CLOSED'
+                                 AND p.workstream_id = t.workstream_id)
+            ORDER BY t.local_id`
+      ).all(wsId)
+    );
+  }
+  for (const raw of startRows.slice(0, maxNodes)) {
+    nodes.set(raw.id, rowFromDb(raw));
+    rootIds.add(raw.id);
+    level.push(raw.id);
+  }
+  const startCut = Math.max(0, startRows.length - maxNodes);
+  const children = /* @__PURE__ */ new Map();
+  const dropped = /* @__PURE__ */ new Map();
+  const capDropped = /* @__PURE__ */ new Map();
+  const closedHidden = /* @__PURE__ */ new Map();
+  const expands = (id) => includeClosed || rootIds.has(id) || nodes.get(id)?.status !== "CLOSED";
+  for (let depth = 0; level.length > 0; depth++) {
+    const ids = level.filter(expands);
+    if (ids.length === 0) break;
+    if (depth >= maxDepth) {
+      const counts = [];
+      for (let i = 0; i < ids.length; i += 500) {
+        const chunk = ids.slice(i, i + 500);
+        counts.push(
+          ...db.prepare(
+            `SELECT e.${from} AS src,
+                      SUM(CASE WHEN t.status = 'CLOSED' AND ? = 0 THEN 0 ELSE 1 END) AS open,
+                      SUM(CASE WHEN t.status = 'CLOSED' AND ? = 0 THEN 1 ELSE 0 END) AS closed
+                 FROM task_edges e JOIN tasks t ON t.id = e.${to}
+                WHERE e.${from} IN (${chunk.map(() => "?").join(", ")}) AND t.workstream_id = ? GROUP BY e.${from}`
+          ).all(includeClosed ? 1 : 0, includeClosed ? 1 : 0, ...chunk, wsId)
+        );
+      }
+      for (const c of counts) {
+        if (c.open > 0) dropped.set(c.src, (dropped.get(c.src) ?? 0) + c.open);
+        if (c.closed > 0) closedHidden.set(c.src, (closedHidden.get(c.src) ?? 0) + c.closed);
+      }
+      break;
+    }
+    const rows = [];
+    for (let i = 0; i < ids.length; i += 500) {
+      const chunk = ids.slice(i, i + 500);
+      rows.push(
+        ...db.prepare(
+          `SELECT e.${from} AS src, ${SELECT_TASK_COLS}
+               FROM task_edges e
+               JOIN tasks t ON t.id = e.${to}
+               JOIN workstreams ws ON ws.id = t.workstream_id AND ws.torn_down_at IS NULL
+               LEFT JOIN agents ag ON ag.id = t.owner_id
+              WHERE e.${from} IN (${chunk.map(() => "?").join(", ")}) AND t.workstream_id = ?
+              ORDER BY e.${from}, t.local_id`
+        ).all(...chunk, wsId)
+      );
+    }
+    const next = [];
+    const closedSeen = /* @__PURE__ */ new Map();
+    let capped = false;
+    for (const row of rows) {
+      const leaf = row.status === "CLOSED" && !includeClosed;
+      if (!capped) {
+        if (leaf) {
+          const n = closedSeen.get(row.src) ?? 0;
+          closedSeen.set(row.src, n + 1);
+          if (n >= closedPerNode) {
+            closedHidden.set(row.src, (closedHidden.get(row.src) ?? 0) + 1);
+            continue;
+          }
+        }
+        if (!nodes.has(row.id) && nodes.size >= maxNodes) capped = true;
+      }
+      if (capped) {
+        capDropped.set(row.src, (capDropped.get(row.src) ?? 0) + 1);
+        continue;
+      }
+      if (!nodes.has(row.id)) {
+        nodes.set(row.id, rowFromDb(row));
+        next.push(row.id);
+      }
+      const kids = children.get(row.src) ?? [];
+      kids.push(row.id);
+      children.set(row.src, kids);
+    }
+    level = next;
+  }
+  const listed = /* @__PURE__ */ new Set();
+  let recurrences = 0;
+  const walk = (id, parent, depth) => {
+    const task = nodes.get(id);
+    if (task === void 0) return;
+    const entry = {
+      task,
+      depth,
+      parent,
+      again: false,
+      kids: dropped.get(id) ?? 0,
+      closed: closedHidden.get(id) ?? 0,
+      capCut: capDropped.get(id) ?? 0
+    };
+    out.entries.push(entry);
+    listed.add(id);
+    const kids = children.get(id) ?? [];
+    if (depth >= maxDepth) {
+      for (const child of kids) {
+        if (nodes.get(child)?.status === "CLOSED" && !includeClosed) entry.closed++;
+        else entry.kids++;
+      }
+      return;
+    }
+    for (const child of kids) {
+      const c = nodes.get(child);
+      if (c === void 0) continue;
+      if (listed.has(child)) {
+        if (recurrences >= maxNodes) {
+          out.againCut++;
+          entry.kids++;
+        } else {
+          recurrences++;
+          out.entries.push({
+            task: c,
+            depth: depth + 1,
+            parent: task.name,
+            again: true,
+            kids: 0,
+            closed: 0,
+            capCut: 0
+          });
+        }
+        continue;
+      }
+      walk(child, task.name, depth + 1);
+    }
+  };
+  for (const id of [...rootIds].sort(
+    (a, b) => (nodes.get(a)?.name ?? "").localeCompare(nodes.get(b)?.name ?? "")
+  )) {
+    if (listed.has(id)) continue;
+    walk(id, null, 0);
+  }
+  out.rootsCut = startCut;
+  return out;
+}
+function renderFrontierLines(entries, label) {
+  const lines = [];
+  const open = [];
+  entries.forEach((e, i) => {
+    if (e.depth === 0) {
+      lines.push(label(e));
+      return;
+    }
+    let last = true;
+    for (let j = i + 1; j < entries.length; j++) {
+      const d = entries[j]?.depth ?? 0;
+      if (d < e.depth) break;
+      if (d === e.depth) {
+        last = false;
+        break;
+      }
+    }
+    open[e.depth] = !last;
+    let prefix = "";
+    for (let d = 1; d < e.depth; d++) prefix += open[d] ? "\u2502   " : "    ";
+    lines.push(`${prefix}${last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${label(e)}`);
+  });
+  return lines;
+}
+
+// src/log-render.ts
+function fields(payload) {
+  if (!payload.startsWith("{")) return {};
+  try {
+    const parsed = JSON.parse(payload);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function str2(bag, key) {
+  const v = bag[key];
+  return typeof v === "string" ? v : void 0;
+}
+function num(bag, key) {
+  const v = bag[key];
+  return typeof v === "number" ? v : void 0;
+}
+var NOISE_FIELDS = /* @__PURE__ */ new Set(["updated_at", "created_at"]);
+function changedFields(bag) {
+  return Object.keys(bag).filter((k) => !NOISE_FIELDS.has(k));
+}
+function parseOpKey(key) {
+  if (key === null || key === "") return {};
+  const arrow = key.indexOf("->");
+  if (arrow !== -1) {
+    const from = parseOpKey(key.slice(0, arrow));
+    const to = parseOpKey(key.slice(arrow + 2));
+    const out = {};
+    if (from.workstream !== void 0) out.workstream = from.workstream;
+    if (from.local !== void 0) out.local = from.local;
+    if (to.local !== void 0) out.to = to.local;
+    return out;
+  }
+  const slash = key.indexOf("/");
+  if (slash === -1) return { workstream: key };
+  const workstream = key.slice(0, slash);
+  const rest = key.slice(slash + 1);
+  const hash = rest.indexOf("#");
+  if (hash === -1) return { workstream, local: rest };
+  return { workstream, local: rest.slice(0, hash), note: rest.slice(hash + 1) };
+}
+var VERBS = {
+  "task.add": "task add",
+  "task.update": "task update",
+  "task.note": "task note",
+  "task.delete": "task delete",
+  "task.close": "task close",
+  "close.apply": "close apply",
+  "task.open": "task open",
+  "task.park": "task park",
+  "task.unpark": "task unpark",
+  "task.accept": "task accept",
+  "task.reject": "task reject",
+  "task.defer": "task defer",
+  "task.claim": "task claim",
+  "task.release": "task release",
+  "task.reap": "task reap",
+  "task.block": "task block",
+  "task.unblock": "task unblock",
+  "task.reparent": "task reparent",
+  "workstream.init": "workstream init",
+  "workstream.teardown": "workstream teardown",
+  "sql.write": "sql write",
+  "agent.spawn": "agent spawn",
+  "agent.spawn_failed": "agent spawn failed",
+  "agent.close": "agent close",
+  "agent.adopt": "agent adopt",
+  "agent.kick": "agent kick",
+  "agent.send": "agent send",
+  "agent.abort": "agent abort",
+  // Payload prose reads "agent stalled ..."; keep the verb matching it
+  // so the emitted text is not printed with a second, different verb.
+  "agent.stall": "agent stalled"
+};
+var KNOWN_INTENTS = Object.keys(VERBS);
+var KNOWN_VERBS = Object.values(VERBS);
+function isKnownIntent(intent) {
+  return Object.hasOwn(VERBS, intent);
+}
+function renderOp(row) {
+  const intent = row.intent;
+  if (intent === null) return null;
+  const setPrefix = "task.set-";
+  if (intent.startsWith(setPrefix)) {
+    const status = intent.slice(setPrefix.length).toUpperCase();
+    const { local } = parseOpKey(row.workstreamName);
+    return { verb: "task status", subject: local ?? "", detail: `\u2192 ${status}` };
+  }
+  if (!isKnownIntent(intent)) {
+    const parts = [`intent=${intent}`, `kind=${row.kind}`];
+    if (row.payload.startsWith("{")) {
+      const patch = changedFields(fields(row.payload));
+      if (patch.length > 0) parts.push(`patch=${patch.join(",")}`);
+    } else if (row.payload !== "") {
+      parts.push(`: ${oneLine(row.payload)}`);
+    }
+    return {
+      verb: row.op === void 0 ? "op" : `op ${row.op}`,
+      subject: row.workstreamName ?? "",
+      detail: parts.join(" ")
+    };
+  }
+  if (row.kind === "note" && row.op !== "del") return renderKnown(row, "task.note");
+  return renderKnown(row, intent);
+}
+function renderKnown(row, intent) {
+  const bag = fields(row.payload);
+  const key = parseOpKey(row.workstreamName);
+  const subject = key.local ?? key.workstream ?? "";
+  const deleted = row.op === "del";
+  switch (intent) {
+    case "task.add": {
+      const impact = num(bag, "impact");
+      const effort = num(bag, "effort_days");
+      const title = str2(bag, "title");
+      const bits = [];
+      if (title !== void 0) bits.push(`"${title}"`);
+      if (impact !== void 0) bits.push(`impact=${impact}`);
+      if (effort !== void 0) bits.push(`effort=${effort}`);
+      return { verb: VERBS[intent], subject, detail: bits.join(" ") };
+    }
+    case "task.update": {
+      const changed = changedFields(bag);
+      const detail = changed.map((f) => {
+        const v = bag[f];
+        return typeof v === "object" ? f : `${f}=${String(v)}`;
+      }).join(" ");
+      return { verb: VERBS[intent], subject, detail: detail === "" ? "(touched)" : detail };
+    }
+    case "task.note": {
+      const author = str2(bag, "author");
+      const content = str2(bag, "content") ?? "";
+      const n = key.note;
+      const head = n === void 0 ? "" : `#${n} `;
+      const by = author === void 0 || author === "" ? "" : ` by ${author}`;
+      return { verb: VERBS[intent], subject, detail: `${head}${oneLine(content)}${by}` };
+    }
+    case "task.delete":
+      return { verb: VERBS[intent], subject, detail: "" };
+    case "task.close":
+    case "close.apply":
+    case "task.open":
+    case "task.reject":
+    case "task.defer": {
+      const status = str2(bag, "status");
+      return {
+        verb: VERBS[intent],
+        subject,
+        detail: status === void 0 ? "" : `\u2192 ${pairText(bag, status)}`
+      };
+    }
+    case "task.park":
+    case "task.unpark":
+    case "task.accept": {
+      const detail = str2(bag, "substate") === void 0 ? "" : `\u2192 ${pairText(bag, "OPEN")}`;
+      return { verb: VERBS[intent], subject, detail };
+    }
+    case "task.claim": {
+      const by = row.source === "" ? "" : `by ${row.source}`;
+      const status = str2(bag, "status");
+      const tail = status === void 0 ? "" : ` \u2192 ${status}`;
+      return { verb: VERBS[intent], subject, detail: `${by}${tail}` };
+    }
+    case "task.release":
+    case "task.reap": {
+      const status = str2(bag, "status");
+      const bits = [];
+      if (Object.hasOwn(bag, "owner_id") && bag.owner_id === null) bits.push("owner cleared");
+      if (status !== void 0) bits.push(`\u2192 ${status}`);
+      return { verb: VERBS[intent], subject, detail: bits.join(" ") };
+    }
+    case "task.block":
+    case "task.unblock":
+    case "task.reparent": {
+      if (key.to !== void 0) {
+        const dir = intent === "task.unblock" ? "no longer blocks" : "blocks";
+        return { verb: VERBS[intent], subject, detail: `${dir} ${key.to}` };
+      }
+      return { verb: VERBS[intent], subject, detail: deleted ? "(edge removed)" : "(touched)" };
+    }
+    case "workstream.init":
+      return { verb: VERBS[intent], subject, detail: "" };
+    case "workstream.teardown":
+      return {
+        verb: VERBS[intent],
+        subject,
+        detail: key.local === void 0 ? "" : "(cascaded)"
+      };
+    case "sql.write": {
+      if (deleted) return { verb: VERBS[intent], subject, detail: `${row.kind} deleted` };
+      const edge = key.to === void 0 ? "" : ` -> ${key.to}`;
+      const changed = changedFields(bag).map((f) => {
+        const v = bag[f];
+        return typeof v === "object" && v !== null ? f : `${f}=${oneLine(String(v))}`;
+      }).join(" ");
+      return {
+        verb: VERBS[intent],
+        subject,
+        detail: `${row.kind}${edge} ${changed === "" ? "(touched)" : changed}`
+      };
+    }
+    // Local intents: no trigger can see these, so `emitEvent` wrote the
+    // payload as prose. It is already human-readable — show it as the
+    // detail rather than inventing a second phrasing. The leading verb
+    // is stripped so it is not printed twice.
+    case "agent.spawn":
+    case "agent.spawn_failed":
+    case "agent.close":
+    case "agent.adopt":
+    case "agent.kick":
+    case "agent.send":
+    case "agent.abort":
+    case "agent.stall": {
+      const verb = VERBS[intent];
+      if (row.payload.startsWith("{")) {
+        const named = str2(bag, "name") ?? subject;
+        return { verb, subject: named, detail: changedFields(bag).join(" ") };
+      }
+      const prose = row.payload.startsWith(verb) ? row.payload.slice(verb.length).trim() : row.payload;
+      const firstSpace = prose.indexOf(" ");
+      const name = firstSpace === -1 ? prose : prose.slice(0, firstSpace);
+      const rest = firstSpace === -1 ? "" : prose.slice(firstSpace + 1).trim();
+      return { verb, subject: name, detail: rest };
+    }
+  }
+}
+function pairText(bag, status) {
+  const pair = resolvePair(status, str2(bag, "substate"));
+  return pair === null ? status : formatPair(pair);
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function renderOpLine(row) {
+  const r = renderOp(row);
+  if (r === null) return row.payload;
+  return [r.verb, r.subject, r.detail].filter((s) => s !== "").join(" ");
+}
+function opSubject(row) {
+  const intent = row.intent;
+  if (intent === null) return null;
+  const { local } = parseOpKey(row.workstreamName);
+  if (intent.startsWith("task.") && local !== void 0 && local !== "") {
+    return { kind: "task", id: local };
+  }
+  if (intent.startsWith("agent.") && isKnownIntent(intent)) {
+    const r = renderOp(row);
+    if (r !== null && r.subject !== "") return { kind: "agent", id: r.subject };
+  }
+  return null;
+}
+
+// src/output-contract.ts
+var SGR = /\u001b\[[0-9;]*m/g;
+var stripAnsi = (s) => s.replace(SGR, "");
+function safeJsonLine(json) {
+  return json.replace(
+    /[\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/gu,
+    (c) => `\\u${(c.codePointAt(0) ?? 0).toString(16).padStart(4, "0")}`
+  );
+}
+function encodeEnvelope(envelope) {
+  return safeJsonLine(encodeEnvelopeRaw(envelope));
+}
+function encodeEnvelopeRaw(envelope) {
+  if (envelope.ok) {
+    return JSON.stringify({ ok: true, data: envelope.data, next: envelope.next });
+  }
+  const { extra, data } = envelope;
+  const doc = {
+    ok: false,
+    error: stripAnsi(envelope.error),
+    message: stripAnsi(envelope.message),
+    next: envelope.next,
+    exit: envelope.exit
+  };
+  for (const [k, v] of Object.entries(extra ?? {})) if (!(k in doc)) doc[k] = v;
+  if (data !== void 0 && !("data" in doc)) doc.data = data;
+  return JSON.stringify(doc);
+}
+function isEnvelope(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 3 && value.ok === true && "data" in value && "next" in value;
+}
+function okEnvelope(data) {
+  if (isEnvelope(data)) return data;
+  return { ok: true, data, next: null };
+}
+var RESULT_BYTES = 4096;
+
+// src/human-needed.ts
+var HumanNeededInvalidError = class extends Error {
+  name = "HumanNeededInvalidError";
+};
+var TITLE_CHARS = 60;
+function recordHumanNeeded(db, opts) {
+  const reason = opts.reason.trim();
+  const caller = opts.caller.trim();
+  if (reason === "") throw new HumanNeededInvalidError("human-needed: reason is blank");
+  if (caller === "") {
+    throw new HumanNeededInvalidError(
+      "human-needed: no caller identity (run inside a mu agent or a pi session)"
+    );
+  }
+  return withOpContext(
+    db,
+    { intent: "task.note", actor: caller, group: "new" },
+    () => db.transaction(() => {
+      const open = openNeedFor(db, caller, opts.workstream);
+      if (open !== void 0) {
+        if (open.briefs.includes(reason)) return { id: open.id, changed: false };
+        insertNote(db, open.id, reason, {
+          workstream: opts.workstream,
+          author: caller,
+          kind: "brief"
+        });
+        return { id: open.id, changed: true };
+      }
+      const title = `human needed: ${reason.replace(/\s+/g, " ").slice(0, TITLE_CHARS)}`;
+      const { ids } = addTasks(db, [{ title, note: reason }], {
+        workstream: opts.workstream,
+        kind: "human",
+        noteAuthor: caller
+      });
+      const id = ids[0];
+      if (id === void 0) throw new Error("recordHumanNeeded: no task created");
+      const taskId = db.prepare("SELECT id FROM tasks WHERE workstream_id = ? AND local_id = ?").get(resolveWorkstreamId(db, opts.workstream), id).id;
+      db.prepare("INSERT INTO human_needs (task_id, caller) VALUES (?, ?)").run(taskId, caller);
+      return { id, changed: true };
+    }).immediate()
+  );
+}
+function openNeedRows(db, caller, workstream) {
+  return db.prepare(
+    `SELECT t.id AS taskId, t.local_id AS id, w.name AS workstream
+         FROM human_needs h
+         JOIN tasks t ON t.id = h.task_id
+         JOIN workstreams w ON w.id = t.workstream_id
+        WHERE h.caller = ? AND t.kind = 'human' AND t.status = 'OPEN'
+          AND w.torn_down_at IS NULL AND (? IS NULL OR w.name = ?)
+        ORDER BY t.id`
+  ).all(caller, workstream ?? null, workstream ?? null);
+}
+function briefsOf(db, taskId) {
+  return db.prepare("SELECT content FROM task_notes WHERE task_id = ? AND kind = 'brief' ORDER BY id").all(taskId).map((r) => r.content);
+}
+function openNeedFor(db, caller, workstream) {
+  const row = openNeedRows(db, caller, workstream).at(-1);
+  return row === void 0 ? void 0 : { id: row.id, briefs: briefsOf(db, row.taskId) };
+}
+function openHumanNeeds(db, caller) {
+  return openNeedRows(db, caller).map((r) => ({
+    workstream: r.workstream,
+    id: r.id,
+    reason: briefsOf(db, r.taskId).join("; ")
+  }));
+}
+
+// src/next-hints.ts
+var UnguardedMoveError = class extends Error {
+  name = "UnguardedMoveError";
+};
+var NEXT_BYTES = 1024;
+var MAX_ALTERNATIVES = 3;
+function dispatchPrompt(task) {
+  return `Claim done: work on ${task.id}. Read: mu task notes ${task.id} -w ${task.workstream}`;
+}
+function agentRefOf(agent, runs, incarnation) {
+  return `agent:${agent.workstreamName}/${agent.name}${runs === void 0 ? "" : `@${runs}`}${incarnation === void 0 ? "" : `#${incarnation}`}`;
+}
+function resumeArgv(id, scope) {
+  return ["mu", "wait", "--resume", id, ...scope === void 0 ? [] : ["-w", scope]];
+}
+function renderArgv(argv) {
+  if (argv[0] !== "mu") throw new Error(`a next move starts with mu (got ${argv[0] ?? "nothing"})`);
+  return argv.map(shellWord).join(" ");
+}
+function renderPlan(mode, moves) {
+  for (const m of moves) {
+    if (m.destructive === true && !m.argv.includes("--if")) {
+      throw new UnguardedMoveError(`destructive move without --if: ${m.argv.join(" ")}`);
+    }
+  }
+  const ordered = mode === "seq" ? moves : [...moves].sort((a, b) => rank(a) - rank(b));
+  const commands = [...new Set(ordered.map((m) => renderArgv(m.argv)))];
+  const kept = mode === "alt" ? commands.slice(0, MAX_ALTERNATIVES) : commands;
+  return kept.length === 0 ? null : { mode, commands: kept };
+}
+var rank = (m) => m.destructive === true ? 1 : 0;
+var utf8 = (s) => Buffer.byteLength(s, "utf8");
+function capPlan(plan, bytes3 = NEXT_BYTES) {
+  if (plan === null || utf8(JSON.stringify(plan)) <= bytes3) return { next: plan, cut: 0 };
+  if (plan.mode === "seq") return { next: null, cut: plan.commands.length };
+  const commands = [...plan.commands];
+  while (commands.length > 0 && utf8(JSON.stringify({ mode: "alt", commands })) > bytes3) {
+    commands.pop();
+  }
+  const cut = plan.commands.length - commands.length;
+  return { next: commands.length === 0 ? null : { mode: "alt", commands }, cut };
+}
+function outcomeMove(db, o) {
+  switch (o.kind) {
+    case "sent":
+      if (o.runs === void 0) return void 0;
+      return {
+        argv: ["mu", "wait", agentRefOf(agentLike(o.agent), o.runs, o.incarnation)]
+      };
+    case "send-unknown": {
+      const row = getAgent(db, o.agent.name, o.agent.workstream);
+      if (row === void 0 || row.incarnation !== o.agentId) return void 0;
+      return {
+        argv: ["mu", "agent", "check", o.agent.name, o.msgId, "-w", o.agent.workstream, "--json"]
+      };
+    }
+    case "gate-spawned":
+      return { argv: ["mu", "wait", agentRefOf(agentLike(o.agent))] };
+    case "claimed-for": {
+      const owner = getAgent(db, o.owner.name, o.owner.workstream);
+      if (owner === void 0) return void 0;
+      const ctl = expectsCtl(owner);
+      if (!ctl && o.muxCanSend === false) return void 0;
+      const fresh = ctl ? ["--fresh"] : [];
+      return {
+        argv: [
+          "mu",
+          "agent",
+          "send",
+          owner.name,
+          ...fresh,
+          dispatchPrompt(o.task),
+          "-w",
+          owner.workstreamName
+        ]
+      };
+    }
+    case "preview":
+      return { argv: [...o.apply, "--if", String(o.revision)], destructive: true };
+    case "waited":
+      if (o.resumeId === null) return void 0;
+      return { argv: resumeArgv(o.resumeId, o.scope) };
+  }
+}
+var agentLike = (a) => ({ name: a.name, workstreamName: a.workstream });
+function executorMove(db, ws) {
+  if (isScratchWorkstream(ws)) return void 0;
+  if (pendingAttempts(db, ws).length === 0 && authorisedReady(db, ws).length === 0) {
+    return void 0;
+  }
+  return { argv: ["mu", "next", "-w", ws] };
+}
+function ownedWaitMove(db, callers, ws) {
+  const owes = callers.some(
+    (c) => (readWaitRegistration(db, c)?.refs ?? []).some((r) => ws === void 0 || r.workstream === ws)
+  );
+  if (!owes) return void 0;
+  return { argv: ws === void 0 ? ["mu", "wait"] : ["mu", "wait", "-w", ws] };
+}
+var COURSE_CHECK_CLOSED = 10;
+var COURSE_CHECK_AGE_MS = 24 * 36e5;
+function courseCheckHint(db, ws, now = Date.now()) {
+  const row = db.prepare(
+    `WITH w AS (SELECT id, created_at FROM workstreams WHERE name = ? AND torn_down_at IS NULL),
+            a AS (SELECT COALESCE(
+              (SELECT MAX(n.created_at) FROM task_notes n JOIN tasks t ON t.id = n.task_id
+                WHERE t.workstream_id = w.id AND n.content LIKE 'COURSE CHECK%'),
+              w.created_at) AS since, w.id AS wid FROM w)
+       SELECT a.since AS since,
+              (SELECT COUNT(*) FROM tasks t WHERE t.workstream_id = a.wid AND t.status = 'CLOSED'
+                  AND t.substate = 'done' AND t.kind = 'work' AND (SELECT MAX(c.created_at)
+                    FROM task_notes c WHERE c.task_id = t.id AND c.kind = 'close') > a.since) AS closed
+         FROM a`
+  ).get(ws);
+  if (row === void 0 || row.closed === 0) return void 0;
+  const old = now - Date.parse(row.since) >= COURSE_CHECK_AGE_MS;
+  if (row.closed < COURSE_CHECK_CLOSED && !old) return void 0;
+  return `course check due: ${row.closed} closed since ${row.since.slice(0, 16)}Z. Stop dispatching: finish merging, then follow recipes/course-correct.md`;
+}
+function computeNext(db, ctx) {
+  const moves = [];
+  const own = ctx.outcome === void 0 ? void 0 : outcomeMove(db, ctx.outcome);
+  if (own !== void 0) moves.push(own);
+  const stopped = ctx.callers.some((c) => openHumanNeeds(db, c).length > 0);
+  if (!stopped && ctx.outcome?.kind !== "preview") {
+    const exec = ctx.workstream === void 0 ? void 0 : executorMove(db, ctx.workstream);
+    if (exec !== void 0) moves.push(exec);
+    if (ctx.armed !== false && (own === void 0 || own.argv[1] !== "wait")) {
+      const wait = ownedWaitMove(db, ctx.callers, ctx.workstream);
+      if (wait !== void 0) moves.push(wait);
+    }
+  }
+  return capPlan(renderPlan("alt", moves)).next;
+}
+function computeNotices(db, ctx, now = Date.now()) {
+  const hint = ctx.workstream === void 0 || isScratchWorkstream(ctx.workstream) ? void 0 : courseCheckHint(db, ctx.workstream, now);
+  return hint === void 0 ? [] : [hint];
+}
+function noticesField(db, workstreams, now = Date.now()) {
+  const notices = [...new Set(workstreams)].flatMap(
+    (workstream) => computeNotices(db, { callers: [], workstream }, now)
+  );
+  return notices.length > 0 ? { notices } : {};
+}
+
+// src/sync.ts
+import { existsSync as existsSync3, statSync as statSync3 } from "fs";
+import Database from "better-sqlite3";
+var SyncPeerNotFoundError = class extends Error {
+  constructor(ref, known) {
+    super(say("sync.peer_not_found", ref, known));
+    this.ref = ref;
+    this.known = known;
+  }
+  ref;
+  known;
+  name = "SyncPeerNotFoundError";
+};
+var SyncPeerRefAmbiguousError = class extends Error {
+  constructor(ref, candidates) {
+    super(say("sync.peer_ambiguous", ref, candidates));
+    this.ref = ref;
+    this.candidates = candidates;
+  }
+  ref;
+  candidates;
+  name = "SyncPeerRefAmbiguousError";
+};
+var SyncSourceNotFoundError = class extends Error {
+  constructor(path) {
+    super(say("sync.source_missing", path));
+    this.path = path;
+  }
+  path;
+  name = "SyncSourceNotFoundError";
+};
+var SyncSourceTooNewError = class extends Error {
+  constructor(path, detectedVersion) {
+    super(say("sync.source_too_new", path, detectedVersion, CURRENT_SCHEMA_VERSION));
+    this.path = path;
+    this.detectedVersion = detectedVersion;
+  }
+  path;
+  detectedVersion;
+  name = "SyncSourceTooNewError";
+};
+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 = statSync3(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;
+  if (isJsonMode()) return;
+  process.stderr.write(`mu: sync: ${message}
+`);
+}
+function foreignVersionMessage(r) {
+  return `segment ${r.segmentPath ?? "?"} has a v${r.foreignVersion ?? "?"} line written by a newer mu; upgrade mu on this machine`;
+}
+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);
+      }
+    }
+  } 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, { lockWaitMs: opts?.lockWaitMs });
+    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
+      );
+    }
+    if (result.foreignVersionAt !== null) warn(foreignVersionMessage(result), opts);
+    if (result.lockBusy === true) {
+      warn("segment locked by another mu; this op publishes on the next flush", 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 sourceSchemaVersion(source) {
+  try {
+    const row = source.prepare("SELECT version FROM schema_version WHERE id = 1").get();
+    return row?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function ingestFromDb(db, path) {
+  if (!existsSync3(path)) throw new SyncSourceNotFoundError(path);
+  const self = localMachineId(db);
+  const source = new Database(path, { readonly: true, fileMustExist: true });
+  try {
+    const theirs = sourceSchemaVersion(source);
+    if (theirs !== null && theirs > CURRENT_SCHEMA_VERSION) {
+      throw new SyncSourceTooNewError(path, theirs);
+    }
+    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)) {
+          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();
+    return { path, read, changed, skippedLocal };
+  } finally {
+    try {
+      source.close();
+    } catch {
+    }
+  }
+}
+
+// src/wait-callers.ts
+function currentCallers(env = process.env) {
+  const out = [];
+  const { MU_MANAGED_AGENT: managed, MU_WORKSTREAM: ws, MU_AGENT_NAME: name } = env;
+  if (managed === "1" && ws && name) out.push(`${ws}/${name}`);
+  if (env.PI_SESSION_ID) out.push(`pi:${env.PI_SESSION_ID}`);
+  return out;
+}
+
+// src/agent-output.ts
+function workstreamIdOf(db, workstream) {
+  const row = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(workstream);
+  return row?.id ?? 0;
+}
+function agentToOutput(row, workstreamId2, live = {}) {
+  return {
+    id: row.incarnation,
+    name: row.name,
+    workstream_id: workstreamId2,
+    workstream: row.workstreamName,
+    cli: row.cli,
+    pane_id: row.paneId,
+    role: row.role,
+    tab: row.tab,
+    cwd: row.cwd,
+    base: row.base,
+    command: row.command,
+    command_source: row.commandSource,
+    spawner: row.spawner,
+    host: row.host,
+    collected_head: row.collectedHead,
+    repo: row.repo,
+    gate_token: row.gateToken,
+    created_at: row.createdAt,
+    updated_at: row.updatedAt,
+    ...live.state !== void 0 ? { state: live.state } : {},
+    ...live.source !== void 0 ? { source: live.source } : {},
+    ...live.ctl !== void 0 ? { ctl: live.ctl } : {},
+    ...live.ctlSocket !== void 0 ? { ctl_socket: live.ctlSocket } : {},
+    ...live.since !== void 0 ? { since: live.since } : {},
+    ...live.reason !== void 0 ? { reason: live.reason } : {},
+    ...live.idle !== void 0 ? { idle: live.idle } : {},
+    ...live.trustDialog !== void 0 ? { trust_dialog: live.trustDialog } : {}
+  };
+}
+function closePreviewToOutput(p) {
+  const { incarnation, paneId, ...rest } = p;
+  return { ...rest, id: incarnation, pane_id: paneId, recovery_id: p.recovery?.id ?? null };
+}
+function liveAgentToOutput(agent, workstreamId2) {
+  return agentToOutput(agent, workstreamId2, {
+    state: agent.state,
+    source: agent.source,
+    ...agent.ctl !== void 0 ? { ctl: agent.ctl } : {},
+    since: agent.since,
+    ...agent.reason !== void 0 ? { reason: agent.reason } : {},
+    ...agent.idle !== void 0 ? { idle: agent.idle } : {}
+  });
+}
+
+// src/cli/tasks/records.ts
+var RECORD_CHARS = 400;
+var JSON_TITLE_CHARS = 120;
+var JSON_FIELD_CHARS = 80;
+var UNSAFE = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069\\]/u;
+var UNSAFE_G = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069\\]/gu;
+function escapeRecordText(s) {
+  if (!UNSAFE.test(s)) return s;
+  return s.replace(UNSAFE_G, (c) => {
+    switch (c) {
+      case "\\":
+        return "\\\\";
+      case "\n":
+        return "\\n";
+      case "	":
+        return "\\t";
+      case "\r":
+        return "\\r";
+      default:
+        return `\\u{${(c.codePointAt(0) ?? 0).toString(16)}}`;
+    }
+  });
+}
+function jsonDocument(data) {
+  return encodeEnvelope(okEnvelope(data));
+}
+var bytes = (s) => Buffer.byteLength(s);
+var linesBytes = (lines) => bytes(lines.join("\n")) + 1;
+var codePoints = (s) => [...s];
+function clipEscaped(s, maxChars, maxBytes = Number.POSITIVE_INFINITY) {
+  const cps = codePoints(s);
+  let out = "";
+  let used = 0;
+  let n = 0;
+  for (const cp of cps) {
+    const esc = escapeRecordText(cp);
+    if (out.length + esc.length > maxChars || used + bytes(esc) > maxBytes) break;
+    out += esc;
+    used += bytes(esc);
+    n++;
+  }
+  return { text: out, cut: cps.length - n };
+}
+function taskToOutput(row, opts = {}) {
+  const out = {
+    id: row.name,
+    local_id: row.name,
+    workstream_id: row.workstreamId,
+    title: row.title,
+    status: row.status,
+    substate: row.substate,
+    impact: row.impact,
+    effort_days: row.effortDays,
+    scored: row.scored ? 1 : 0,
+    dispatch_host: row.dispatchHost,
+    owner_id: row.ownerId,
+    created_at: row.createdAt,
+    updated_at: row.updatedAt,
+    kind: row.kind,
+    wave: row.wave
+  };
+  if (opts.withWorkstream === true) out.workstream = row.workstreamName;
+  if (row.status === "IN_PROGRESS" && row.ownerName !== null) out.owner = row.ownerName;
+  if (opts.revision !== void 0) out.revision = opts.revision;
+  return out;
+}
+var SHOW_TITLE_CHARS = 600;
+function footerLine(c, next) {
+  if (c.more <= 0 && c.cut <= 0) return null;
+  const parts = [c.more > 0 ? `more=${c.more}` : "", c.cut > 0 ? `cut=${c.cut}` : ""];
+  return `${parts.filter(Boolean).join(" ")} next=${next}`;
+}
+function taskItemCut(row, opts = {}) {
+  const item = taskToOutput(row, opts);
+  if (opts.whole === true) return { item, cut: 0 };
+  let cut = opts.extraCut ?? 0;
+  const clip = (s, max) => {
+    const cps = codePoints(s);
+    if (cps.length <= max) return s;
+    cut += cps.length - Math.max(0, max - 1);
+    return max <= 0 ? "" : `${cps.slice(0, max - 1).join("")}\u2026`;
+  };
+  item.title = clip(row.title, opts.titleChars ?? JSON_TITLE_CHARS);
+  if (item.wave !== null) item.wave = clip(item.wave, JSON_FIELD_CHARS);
+  if (item.dispatch_host !== null) item.dispatch_host = clip(item.dispatch_host, JSON_FIELD_CHARS);
+  if (item.owner !== void 0) item.owner = clip(item.owner, JSON_FIELD_CHARS);
+  return { item, cut };
+}
+function taskRecordCut(row, opts = {}) {
+  const whole = opts.whole === true;
+  let fieldCut = 0;
+  const clip = (s, chars = 40) => {
+    if (whole) return escapeRecordText(s);
+    const { text: text2, cut: cut2 } = clipEscaped(s, chars);
+    if (cut2 === 0) return text2;
+    fieldCut += cut2;
+    return `${text2}\u2026`;
+  };
+  const kv = [`impact=${row.impact}`, `effort_days=${row.effortDays}`];
+  if (!row.scored) kv.push("scored=0");
+  if (row.status === "IN_PROGRESS" && row.ownerName !== null)
+    kv.push(`owner=${clip(row.ownerName)}`);
+  if (opts.withWorkstream === true) kv.push(`ws=${clip(row.workstreamName)}`);
+  if (row.status !== "OPEN" && row.ownerName === null && opts.claimedBy) {
+    kv.push(`self=${clip(opts.claimedBy)}`);
+  }
+  if (row.kind !== "work") kv.push(`kind=${row.kind}`);
+  if (row.wave !== null) kv.push(`wave=${clip(row.wave)}`);
+  if (row.dispatchHost !== null) kv.push(`host=${clip(row.dispatchHost)}`);
+  if (opts.times === true) kv.push(`created=${row.createdAt}`, `updated=${row.updatedAt}`);
+  else if (opts.basis === "updatedAt") kv.push(`updated=${row.updatedAt}`);
+  else if (opts.basis === "createdAt") kv.push(`created=${row.createdAt}`);
+  if (opts.revision !== void 0) kv.push(`rev=${opts.revision}`);
+  kv.push(...opts.extra ?? []);
+  const id = clip(row.name, 64);
+  const head = ["task", id, formatPair(row), kv.join(" ")].join("	");
+  const wholeTitle = escapeRecordText(row.title);
+  if (whole) return { line: `${head}	${wholeTitle}`, cut: 0 };
+  const max = opts.maxChars ?? RECORD_CHARS;
+  const bound = opts.titleChars ?? Number.POSITIVE_INFINITY;
+  const place = (h, extraCut) => {
+    const roomMax = max - codePoints(h).length - 1;
+    if (roomMax < 9) return void 0;
+    const room2 = Math.min(roomMax, bound);
+    if (codePoints(wholeTitle).length <= room2)
+      return { line: `${h}	${wholeTitle}`, cut: extraCut };
+    const { text: text2, cut: cut2 } = clipEscaped(row.title, Math.max(0, room2 - 1));
+    return { line: `${h}	${text2}\u2026`, cut: cut2 + extraCut };
+  };
+  const first = place(head, fieldCut);
+  if (first !== void 0) return first;
+  const dropped = [
+    row.status === "IN_PROGRESS" ? row.ownerName : null,
+    opts.withWorkstream === true ? row.workstreamName : null,
+    row.wave,
+    row.dispatchHost,
+    row.status !== "OPEN" && row.ownerName === null ? opts.claimedBy ?? null : null
+  ].filter((v) => typeof v === "string").reduce((n, v) => n + codePoints(v).length, 0);
+  const lean = [
+    "task",
+    id,
+    formatPair(row),
+    [...kv.slice(0, 2), ...opts.extra ?? []].join(" ")
+  ].join("	");
+  const room = Math.min(Math.max(0, max - codePoints(lean).length - 2), Math.max(0, bound - 1));
+  const { text, cut } = clipEscaped(row.title, room);
+  return { line: `${lean}	${text}\u2026`, cut: cut + dropped };
+}
+function pageRecords(all, size, budget = RESULT_BYTES, min = 1) {
+  const build = (k) => ({ shown: all.slice(0, k), more: all.length - k });
+  let page = build(Math.min(min, all.length));
+  for (let k = min + 1; k <= all.length; k++) {
+    const candidate = build(k);
+    if (size(candidate) > budget) break;
+    page = candidate;
+  }
+  return page;
+}
+function taskPage(rows, opts) {
+  const ws = opts.withWorkstream === true;
+  const whole = opts.all;
+  const render = (page2) => {
+    let cut = 0;
+    const lines = [];
+    const items = [];
+    for (const r of page2.shown) {
+      const revision = opts.revisions?.get(r.name);
+      const rev = revision === void 0 ? {} : { revision };
+      if (opts.json) {
+        const one = taskItemCut(r, { withWorkstream: ws, whole, ...rev });
+        cut += one.cut;
+        items.push(one.item);
+      } else {
+        const one = taskRecordCut(r, {
+          withWorkstream: ws,
+          whole,
+          ...rev,
+          ...opts.basis ? { basis: opts.basis } : {}
+        });
+        cut += one.cut;
+        lines.push(one.line);
+      }
+    }
+    const foot = footerLine({ more: page2.more, cut }, opts.next);
+    if (foot !== null) lines.push(foot);
+    return {
+      lines: opts.json ? [] : lines,
+      data: {
+        items,
+        count: items.length,
+        more: page2.more,
+        ...cut > 0 ? { cut } : {},
+        ...foot === null ? {} : { retrieve: opts.next }
+      }
+    };
+  };
+  const page = whole ? { shown: [...rows], more: 0 } : pageRecords(rows, (p) => {
+    const r = render(p);
+    return opts.json ? bytes(jsonDocument(r.data)) + 1 : linesBytes(r.lines);
+  });
+  const out = render(page);
+  return {
+    lines: out.lines,
+    ...opts.json ? { data: out.data } : {},
+    shown: page.shown.length,
+    more: page.more
+  };
+}
+
+// src/cli/page-records.ts
+var bytes2 = (s) => Buffer.byteLength(s);
+var COLUMN_CHARS = 64;
+var ITEM_BYTES = 2048;
+function clipPlain(s, max) {
+  const cps = codePoints(s);
+  if (cps.length <= max) return { text: s, cut: 0 };
+  return { text: cps.slice(0, max).join(""), cut: cps.length - max };
+}
+function shrinkItem(build) {
+  let out = build(1);
+  for (const scale of [0.5, 0.25, 0.125, 0]) {
+    if (bytes2(jsonDocument({ items: [out.item] })) <= ITEM_BYTES) break;
+    out = build(scale);
+  }
+  return out;
+}
+function pageOut(rows, spec) {
+  const newest = spec.newest === true;
+  const whole = spec.whole === true;
+  const render = (page2) => {
+    const shown = newest ? [...page2.shown].reverse() : page2.shown;
+    let cut = 0;
+    const clipped = [];
+    const lines = [];
+    const items = [];
+    for (const r of shown) {
+      if (spec.json) {
+        const one = spec.item(r, whole);
+        if (one.cut > 0) clipped.push(r);
+        cut += one.cut;
+        items.push(one.item);
+      } else {
+        const one = spec.text(r, whole);
+        if (one.cut > 0) clipped.push(r);
+        cut += one.cut;
+        lines.push(one.line);
+      }
+    }
+    const resume = page2.more > 0 ? spec.resume(shown, page2.more) : void 0;
+    const retrieve = cut > 0 ? (spec.retrieve ?? ((_c) => spec.resume(shown, page2.more)))(clipped) : void 0;
+    if (resume !== void 0 && resume === retrieve) {
+      lines.push(`more=${page2.more} cut=${cut} next=${resume}`);
+    } else {
+      if (resume !== void 0) lines.push(`more=${page2.more} next=${resume}`);
+      if (retrieve !== void 0) lines.push(`cut=${cut} next=${retrieve}`);
+    }
+    const single = spec.singleRetrieve === true;
+    const way = retrieve ?? (single ? resume : void 0);
+    return {
+      lines: spec.json ? [] : lines,
+      data: {
+        items,
+        count: items.length,
+        more: page2.more,
+        ...cut > 0 ? { cut } : {},
+        ...resume === void 0 || single ? {} : { resume },
+        ...way === void 0 ? {} : { retrieve: way }
+      }
+    };
+  };
+  const input = newest ? [...rows].reverse() : rows;
+  const page = whole ? { shown: [...input], more: 0 } : pageRecords(
+    input,
+    (p) => {
+      const r = render(p);
+      return spec.json ? bytes2(jsonDocument(r.data)) + 1 : linesBytes(r.lines);
+    },
+    RESULT_BYTES,
+    0
+  );
+  const out = render(page);
+  return {
+    lines: out.lines,
+    ...spec.json ? { data: out.data } : {},
+    shown: page.shown.length,
+    more: page.more
+  };
+}
+function clippedRecord(columns, free, whole = false) {
+  if (whole) return { line: [...columns, free].map(escapeRecordText).join("	"), cut: 0 };
+  let cut = 0;
+  const lean = columns.map((c) => {
+    const one = clipEscaped(c, COLUMN_CHARS);
+    cut += one.cut;
+    return one.text;
+  }).join("	");
+  const room = Math.max(0, RECORD_CHARS - lean.length - 2);
+  const tail = clipEscaped(free, room);
+  cut += tail.cut;
+  return { line: `${lean}	${tail.text}${tail.cut > 0 ? "\u2026" : ""}`, cut };
+}
+
+// src/cli/log-records.ts
+function whatLine(row) {
+  const r = renderOp(row);
+  if (r === null) return `${row.kind}: ${row.payload}`;
+  return [r.verb, r.subject, r.detail].filter((s) => s !== "").join(" ");
+}
+function logRecord(row, whole = false) {
+  const time = row.createdAt.replace(/\.\d+Z$/, "Z");
+  const scope = parseOpKey(row.workstreamName).workstream ?? "-";
+  return clippedRecord(["log", String(row.seq), time, row.source, scope], whatLine(row), whole);
+}
+var LIMITS = {
+  key: 120,
+  actor: 80,
+  intent: 80,
+  group_id: 64,
+  op: 16,
+  entity: 80,
+  payload: 240,
+  created_at: 40,
+  rendered: 160
+};
+function buildItem(row, scale) {
+  let cut = 0;
+  const clip = (s, limit) => {
+    const one = clipPlain(s, Math.floor(limit * scale));
+    cut += one.cut;
+    return one.text;
+  };
+  const item = {
+    seq: row.seq,
+    key: clip(row.workstreamName ?? "", LIMITS.key),
+    actor: clip(row.source, LIMITS.actor),
+    intent: row.intent === null ? null : clip(row.intent, LIMITS.intent),
+    group_id: clip(row.group, LIMITS.group_id),
+    op: clip(row.op, LIMITS.op),
+    entity: clip(row.kind, LIMITS.entity),
+    payload: clip(row.payload, LIMITS.payload),
+    created_at: clip(row.createdAt, LIMITS.created_at),
+    rendered: clip(renderOpLine(row), LIMITS.rendered)
+  };
+  if (cut > 0) item.cut = cut;
+  return { item, cut };
+}
+function logItem(row, whole = false) {
+  if (whole) {
+    return {
+      cut: 0,
+      item: {
+        seq: row.seq,
+        key: row.workstreamName ?? "",
+        actor: row.source,
+        intent: row.intent,
+        group_id: row.group,
+        op: row.op,
+        entity: row.kind,
+        payload: row.payload,
+        created_at: row.createdAt,
+        rendered: renderOpLine(row)
+      }
+    };
+  }
+  return shrinkItem((scale) => buildItem(row, scale));
+}
+var MAX_RUNS = 8;
+function seqCommand(seqs, gapEmpty, json) {
+  const sorted = [...new Set(seqs)].sort((a, b) => a - b);
+  const runs = [];
+  for (const n of sorted) {
+    const last = runs[runs.length - 1];
+    if (last !== void 0 && (n === last[1] + 1 || gapEmpty(last[1], n))) last[1] = n;
+    else runs.push([n, n]);
+    if (runs.length > MAX_RUNS) break;
+  }
+  const tail = json ? " --json" : "";
+  if (runs.length > MAX_RUNS || runs.length === 0) {
+    return `mu log --after ${Math.max(0, (sorted[0] ?? 1) - 1)}${tail}`;
+  }
+  const spec = runs.map(([a, b]) => a === b ? String(a) : `${a}..${b}`).join(",");
+  return `mu log --seq ${spec}${tail}`;
+}
+function logPage(rows, opts) {
+  const say2 = (seqs) => seqCommand(seqs, opts.gapEmpty, opts.json);
+  return pageOut(rows, {
+    json: opts.json,
+    newest: opts.newest,
+    whole: opts.whole === true,
+    text: (r, all) => logRecord(r, all),
+    item: (r, all) => logItem(r, all),
+    // The ops left out, by seq: a latest-N read omits the older ones, a cursor read the later.
+    resume: (shown) => {
+      if (opts.cursor === true) {
+        const at = shown[shown.length - 1]?.seq ?? (rows[0]?.seq ?? 1) - 1;
+        return `mu log --after ${at}${opts.json ? " --json" : ""}`;
+      }
+      const on = new Set(shown.map((r) => r.seq));
+      return say2(rows.filter((r) => !on.has(r.seq)).map((r) => r.seq));
+    },
+    retrieve: (clipped) => say2(clipped.map((r) => r.seq))
+  });
+}
+function logOut(row) {
+  const { item } = logItem(row);
+  return item.cut === void 0 ? item : { ...item, retrieve: `mu log --seq ${row.seq} --json` };
+}
+function logReceipt(row) {
+  const one = logRecord(row);
+  return one.cut === 0 ? [one.line] : [one.line, `cut=${one.cut} next=mu log --seq ${row.seq}`];
+}
+
+export {
+  OpEntityNotSyncedError,
+  OpKeyMalformedError,
+  applyOp,
+  projectLog,
+  applyOps,
+  readManifest,
+  SyncDirForeignError,
+  assertSyncDirV2,
+  syncDir,
+  localMachineId,
+  segmentPath,
+  flushSegment,
+  ownSegmentForeignLine,
+  countUnpublishedOps,
+  segmentLineCount,
+  verifyAgainstManifest,
+  discoverPeers,
+  getWatermark,
+  setWatermark,
+  resetWatermark,
+  ingestSegment,
+  applyIncomingOp,
+  syncPass,
+  TaskAutoRefusedError,
+  TaskAutoArgError,
+  getAutoConfig,
+  autoPermitted,
+  authorisedReady,
+  openBlockersClosure,
+  authorizeTasks,
+  TaskBriefMissingError,
+  pinnedNotes,
+  buildTaskBrief,
+  IN_FLIGHT_STATES,
+  readAttempt,
+  deliveredOf,
+  pendingAttempts,
+  attemptName,
+  planAttempt,
+  reserveAttempt,
+  endAttempt,
+  reserveRetry,
+  FRONTIER_MAX_DEPTH,
+  FRONTIER_MAX_NODES,
+  FRONTIER_CLOSED_PER_NODE,
+  loadOpenTaskFrontier,
+  renderFrontierLines,
+  workstreamIdOf,
+  agentToOutput,
+  closePreviewToOutput,
+  liveAgentToOutput,
+  parseOpKey,
+  KNOWN_INTENTS,
+  KNOWN_VERBS,
+  renderOp,
+  renderOpLine,
+  opSubject,
+  safeJsonLine,
+  encodeEnvelope,
+  okEnvelope,
+  RESULT_BYTES,
+  escapeRecordText,
+  jsonDocument,
+  linesBytes,
+  clipEscaped,
+  taskToOutput,
+  SHOW_TITLE_CHARS,
+  footerLine,
+  taskItemCut,
+  taskRecordCut,
+  pageRecords,
+  taskPage,
+  clipPlain,
+  shrinkItem,
+  pageOut,
+  clippedRecord,
+  logItem,
+  logPage,
+  logOut,
+  logReceipt,
+  HumanNeededInvalidError,
+  recordHumanNeeded,
+  openHumanNeeds,
+  UnguardedMoveError,
+  NEXT_BYTES,
+  resumeArgv,
+  renderArgv,
+  renderPlan,
+  capPlan,
+  COURSE_CHECK_CLOSED,
+  COURSE_CHECK_AGE_MS,
+  courseCheckHint,
+  computeNext,
+  computeNotices,
+  noticesField,
+  SyncPeerNotFoundError,
+  SyncPeerRefAmbiguousError,
+  SyncSourceNotFoundError,
+  SyncSourceTooNewError,
+  PEER_STALE_MS,
+  PEER_SHORT_LEN,
+  peerStatuses,
+  resolvePeerRef,
+  repairPeer,
+  syncEnabled,
+  foreignVersionMessage,
+  ambientIngest,
+  ambientFlush,
+  ambientSyncPass,
+  ingestFromDb,
+  currentCallers
+};
+//# sourceMappingURL=chunk-SS7NQSSZ.js.map