@mu-crew/mu 3.13.3 → 4.1.0

package/dist/chunk-G434JKV2.js

@@ -1,641 +0,0 @@
-import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
-import {
-  groupIdFromPrefix
-} from "./chunk-KUGUFBWH.js";
-import {
-  LEGACY_LOG_ONLY_SQL_EXCLUSION,
-  localMachineId,
-  mapLegacyStatus,
-  repairTaskPair,
-  resolvePair,
-  resolveWorkstreamId,
-  withOpContext
-} from "./chunk-45KQLMEL.js";
-
-// src/undo.ts
-var UndoGroupNotFoundError = class extends Error {
-  constructor(groupId) {
-    super(`no ops found for group ${JSON.stringify(groupId)}`);
-    this.groupId = groupId;
-    this.name = "UndoGroupNotFoundError";
-  }
-  groupId;
-  errorNextSteps() {
-    return [
-      { intent: "List recent undoable groups", command: "mu undo" },
-      { intent: "Inspect a group's ops", command: "mu log --group <id>" }
-    ];
-  }
-};
-var NothingToUndoError = class extends Error {
-  constructor() {
-    super("the ops log is empty; nothing to undo");
-    this.name = "NothingToUndoError";
-  }
-  errorNextSteps() {
-    return [{ intent: "Make a change first", command: "mu task add <id> -t <title>" }];
-  }
-};
-var UndoSupersededError = class extends Error {
-  constructor(groupId, conflicts) {
-    const shown = conflicts.slice(0, 5).map((c) => `${c.key}.${c.field} (changed by ${c.groupId.slice(0, 8)})`).join(", ");
-    super(
-      `group ${groupId.slice(0, 8)} has been superseded: ${conflicts.length} field(s) were changed by a later action \u2014 ${shown}. Undoing would discard that newer work.`
-    );
-    this.groupId = groupId;
-    this.conflicts = conflicts;
-    this.name = "UndoSupersededError";
-  }
-  groupId;
-  conflicts;
-  errorNextSteps() {
-    return [
-      {
-        intent: "Inspect what changed since",
-        command: `mu log --group ${this.groupId.slice(0, 8)}`
-      },
-      {
-        intent: "Undo anyway, discarding the newer edits",
-        command: `mu undo ${this.groupId.slice(0, 8)} --yes --force`
-      }
-    ];
-  }
-};
-var ENTITY_RESTORE_ORDER = {
-  workstream: 0,
-  task: 1,
-  note: 2,
-  edge: 2
-};
-function restoreRank(entity) {
-  return ENTITY_RESTORE_ORDER[entity] ?? 3;
-}
-function priorFieldValue(db, entity, key, hlc, field, machineId) {
-  const row = db.prepare(
-    `SELECT json_extract(payload, '$.' || @field) AS value
-         FROM ops
-        WHERE entity = @entity
-          AND key    = @key
-          AND op     = 'put'
-          AND hlc    < @hlc
-          AND (@machineId IS NULL OR machine_id = @machineId)
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-          AND json_type(payload, '$.' || @field) IS NOT NULL
-        ORDER BY hlc DESC
-        LIMIT 1`
-  ).get({ entity, key, hlc, field, machineId: machineId ?? null });
-  if (row === void 0) return { found: false };
-  return { found: true, value: row.value };
-}
-function laterWriters(db, entity, key, hlc, field, excludeGroup, machineId) {
-  return db.prepare(
-    `SELECT DISTINCT group_id AS groupId, intent
-         FROM ops
-        WHERE entity   = @entity
-          AND key      = @key
-          AND op       = 'put'
-          AND hlc      > @hlc
-          AND group_id <> @excludeGroup
-          AND (@machineId IS NULL OR machine_id = @machineId)
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-          AND json_type(payload, '$.' || @field) IS NOT NULL`
-  ).all({ entity, key, hlc, field, excludeGroup, machineId: machineId ?? null });
-}
-function laterRowWriters(db, entity, key, hlc, excludeGroup) {
-  return db.prepare(
-    `SELECT DISTINCT group_id AS groupId, intent
-         FROM ops
-        WHERE entity   = @entity
-          AND key      = @key
-          AND op       = 'put'
-          AND hlc      > @hlc
-          AND group_id <> @excludeGroup
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}`
-  ).all({ entity, key, hlc, excludeGroup });
-}
-function isDeletedByLaterGroup(db, entity, key, groupId) {
-  const row = db.prepare(
-    `SELECT op, group_id AS groupId FROM ops
-        WHERE entity = @entity AND key = @key
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-        ORDER BY hlc DESC LIMIT 1`
-  ).get({ entity, key });
-  return row?.op === "del" && row.groupId !== groupId;
-}
-function laterDeleters(db, entity, key, hlc, excludeGroup) {
-  return db.prepare(
-    `SELECT DISTINCT group_id AS groupId, intent
-         FROM ops
-        WHERE entity   = @entity
-          AND key      = @key
-          AND op       = 'del'
-          AND hlc      > @hlc
-          AND group_id <> @excludeGroup`
-  ).all({ entity, key, hlc, excludeGroup });
-}
-function listRecentGroups(db, limit = 10) {
-  const rows = db.prepare(
-    `SELECT group_id                    AS groupId,
-              MAX(hlc)                    AS hlc,
-              MIN(created_at)             AS when_,
-              COUNT(*)                    AS ops,
-              MAX(actor)                  AS actor
-         FROM ops
-        WHERE entity IN ('workstream','task','note','edge')
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-        GROUP BY group_id
-        ORDER BY MAX(hlc) DESC
-        LIMIT @limit`
-  ).all({ limit });
-  return rows.map((row) => {
-    const intents = db.prepare(
-      `SELECT DISTINCT intent FROM ops
-            WHERE group_id = @groupId AND intent IS NOT NULL
-            ORDER BY seq`
-    ).all({ groupId: row.groupId }).map((r) => r.intent);
-    return {
-      groupId: row.groupId,
-      intents,
-      actor: row.actor,
-      ops: row.ops,
-      when: row.when_,
-      hlc: row.hlc
-    };
-  });
-}
-function mostRecentGroup(db) {
-  return listRecentGroups(db, 1)[0] ?? null;
-}
-function resolveGroupId(db, prefix) {
-  const resolved = groupIdFromPrefix(db, prefix);
-  if (resolved === null) throw new UndoGroupNotFoundError(prefix);
-  return resolved;
-}
-var CAPTURED_TABLE_FOR = {
-  workstream: "workstreams",
-  task: "tasks",
-  note: "task_notes",
-  edge: "task_edges"
-};
-var NEVER_RESTORE = /* @__PURE__ */ new Set(["id", "local_id", "name", "workstream_id", "task_id"]);
-var OWNER_FIELD = "owner_id";
-var NEVER_RECONSTRUCT = /* @__PURE__ */ new Set([...NEVER_RESTORE, OWNER_FIELD]);
-var TOUCH_FIELD = "updated_at";
-function planUndo(db, groupId) {
-  const rows = db.prepare(
-    `SELECT o.seq, o.hlc, o.group_id, o.machine_id, o.intent, o.actor, o.entity, o.key, o.op, o.payload,
-              (SELECT COUNT(*) FROM ops p
-                WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc
-                  AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}) AS prior,
-              (SELECT p.op FROM ops p
-                WHERE p.entity = o.entity AND p.key = o.key AND p.hlc < o.hlc
-                  AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-                ORDER BY p.hlc DESC LIMIT 1) AS priorKind
-         FROM ops o
-        WHERE o.group_id = @groupId
-          AND o.entity IN ('workstream','task','note','edge')
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-        ORDER BY o.hlc`
-  ).all({ groupId });
-  if (rows.length === 0) throw new UndoGroupNotFoundError(groupId);
-  const inverses = [];
-  let skipped = 0;
-  const seenLegacyNoteTasks = /* @__PURE__ */ new Set();
-  const restoredFields = /* @__PURE__ */ new Map();
-  let machine;
-  const localMachine = () => {
-    machine ??= localMachineId(db);
-    return machine;
-  };
-  for (const row of rows) {
-    if (row.op === "del") {
-      let fields2 = reconstructRow(db, row.entity, row.key, row.hlc);
-      if (Object.keys(fields2).length === 0) fields2 = payloadFields(row.payload);
-      if (Object.keys(fields2).length === 0 && row.entity === "note") {
-        const recovered = recoverLegacyNoteContents(db, row.key, row.hlc, seenLegacyNoteTasks);
-        for (const legacy2 of recovered) {
-          inverses.push({
-            entity: "note",
-            key: legacy2.key,
-            op: "put",
-            fields: legacy2.fields,
-            summary: `note ${legacy2.key} (recovered from legacy history)`,
-            supersededBy: []
-          });
-        }
-        skipped += 1;
-        continue;
-      }
-      const status = fields2.status;
-      const legacy = typeof status === "string" ? mapLegacyStatus(status) : null;
-      if (legacy) {
-        fields2.status = legacy.status;
-        fields2.substate = legacy.substate;
-      }
-      const conflicts = laterRowWriters(db, row.entity, row.key, row.hlc, groupId).map((w) => ({
-        field: "<row>",
-        groupId: w.groupId,
-        intent: w.intent
-      }));
-      inverses.push({
-        entity: row.entity,
-        key: row.key,
-        op: "put",
-        fields: fields2,
-        summary: `${row.entity} ${row.key} (from tombstone)`,
-        supersededBy: conflicts
-      });
-      continue;
-    }
-    if (row.prior === 0 || row.priorKind === "del") {
-      if (isDeletedByLaterGroup(db, row.entity, row.key, groupId)) {
-        skipped += 1;
-        continue;
-      }
-      const later = [...laterRowWriters(db, row.entity, row.key, row.hlc, groupId)];
-      inverses.push({
-        entity: row.entity,
-        key: row.key,
-        op: "del",
-        fields: {},
-        summary: `${row.entity} ${row.key} (it was created by this group)`,
-        supersededBy: later.map((w) => ({ field: "<row>", groupId: w.groupId, intent: w.intent }))
-      });
-      continue;
-    }
-    const payload = JSON.parse(row.payload);
-    const fields = {};
-    const supersededBy = [];
-    const rowKey = `${row.entity}\0${row.key}`;
-    const restored = restoredFields.get(rowKey) ?? /* @__PURE__ */ new Set();
-    restoredFields.set(rowKey, restored);
-    for (const field of Object.keys(payload)) {
-      if (NEVER_RESTORE.has(field) || restored.has(field)) continue;
-      restored.add(field);
-      let machineId;
-      if (field === OWNER_FIELD) {
-        if (row.machine_id !== localMachine()) continue;
-        machineId = localMachine();
-      }
-      const prior = field === OWNER_FIELD ? priorOwner(db, row.key, row.hlc, localMachine()) : priorFieldValue(db, row.entity, row.key, row.hlc, field, machineId);
-      if (!prior.found) {
-        continue;
-      }
-      if (field === OWNER_FIELD && prior.value !== null && !agentExists(db, prior.value)) continue;
-      const writers = laterWriters(db, row.entity, row.key, row.hlc, field, groupId, machineId);
-      if (field === TOUCH_FIELD && writers.length > 0) continue;
-      fields[field] = prior.value;
-      for (const writer of writers) {
-        supersededBy.push({ field, groupId: writer.groupId, intent: writer.intent });
-      }
-    }
-    for (const deleter of laterDeleters(db, row.entity, row.key, row.hlc, groupId)) {
-      supersededBy.push({ field: "<row>", groupId: deleter.groupId, intent: deleter.intent });
-    }
-    if (Object.keys(fields).length === 0) {
-      skipped += 1;
-      continue;
-    }
-    inverses.push({
-      entity: row.entity,
-      key: row.key,
-      op: "put",
-      fields,
-      summary: `${row.entity} ${row.key} ${Object.entries(fields).map(([f, v]) => `${f}=${v === null ? "NULL" : String(v)}`).join(" ")}`,
-      supersededBy
-    });
-  }
-  const ordered = [...inverses].sort((a, b) => {
-    if (a.op !== b.op) return a.op === "put" ? -1 : 1;
-    const rank = a.op === "put" ? restoreRank(a.entity) - restoreRank(b.entity) : restoreRank(b.entity) - restoreRank(a.entity);
-    return rank;
-  });
-  const intents = [...new Set(rows.map((r) => r.intent).filter((i) => i !== null))];
-  return {
-    groupId,
-    intents,
-    when: groupWhen(db, groupId),
-    inverses: ordered,
-    superseded: ordered.some((i) => i.supersededBy.length > 0),
-    skipped
-  };
-}
-function priorOwner(db, key, hlc, machineId) {
-  const local = priorFieldValue(db, "task", key, hlc, OWNER_FIELD, machineId);
-  if (!local.found) return { found: true, value: null };
-  const tomb = db.prepare(
-    `SELECT 1 FROM ops d
-        WHERE d.entity = 'task' AND d.key = @key AND d.op = 'del' AND d.hlc < @hlc
-          AND d.hlc > (SELECT MAX(hlc) FROM ops
-                        WHERE entity = 'task' AND key = @key AND op = 'put'
-                          AND hlc < @hlc AND machine_id = @machineId
-                          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-                          AND json_type(payload, '$.owner_id') IS NOT NULL)
-          AND NOT EXISTS (SELECT 1 FROM ops p
-                           WHERE p.entity = 'task' AND p.key = @key AND p.op = 'put'
-                             AND p.hlc > d.hlc AND p.seq < d.seq)
-        LIMIT 1`
-  ).get({ key, hlc, machineId });
-  return tomb === void 0 ? local : { found: true, value: null };
-}
-function agentExists(db, id) {
-  return db.prepare("SELECT 1 FROM agents WHERE id = ?").get(id) !== void 0;
-}
-function groupWhen(db, groupId) {
-  const row = db.prepare("SELECT MIN(created_at) AS when_ FROM ops WHERE group_id = ?").get(groupId);
-  return row?.when_ ?? "";
-}
-function recoverLegacyNoteContents(db, tombstoneKey, beforeHlc, seen) {
-  const parsed = parseNoteKey(tombstoneKey);
-  if (parsed === null) return [];
-  if (seen.has(parsed.taskKey)) return [];
-  seen.add(parsed.taskKey);
-  const rows = db.prepare(
-    `SELECT key, payload FROM ops
-        WHERE entity = 'note'
-          AND op = 'put'
-          AND hlc < @hlc
-          AND key LIKE @prefix
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-        ORDER BY hlc`
-  ).all({ hlc: beforeHlc, prefix: `${parsed.taskKey}#%` });
-  const out = [];
-  const contents = /* @__PURE__ */ new Set();
-  for (const row of rows) {
-    const fields = payloadFields(row.payload);
-    const content = fields.content;
-    if (typeof content !== "string" || content === "") continue;
-    if (contents.has(content)) continue;
-    contents.add(content);
-    out.push({ key: row.key, fields });
-  }
-  return out;
-}
-function payloadFields(payload) {
-  const fields = {};
-  const parsed = JSON.parse(payload);
-  for (const [field, value] of Object.entries(parsed)) {
-    if (NEVER_RECONSTRUCT.has(field)) continue;
-    if (value === null || typeof value === "string" || typeof value === "number") {
-      fields[field] = value;
-    }
-  }
-  return fields;
-}
-function reconstructRow(db, entity, key, beforeHlc) {
-  const puts = db.prepare(
-    `SELECT payload FROM ops
-        WHERE entity = @entity AND key = @key AND op = 'put' AND hlc < @hlc
-          AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-        ORDER BY hlc`
-  ).all({ entity, key, hlc: beforeHlc });
-  const fields = {};
-  for (const put of puts) {
-    const parsed = JSON.parse(put.payload);
-    for (const [field, value] of Object.entries(parsed)) {
-      if (NEVER_RECONSTRUCT.has(field)) continue;
-      if (value === null || typeof value === "string" || typeof value === "number") {
-        fields[field] = value;
-      }
-    }
-  }
-  return fields;
-}
-function undoGroup(db, groupId, opts = {}) {
-  const plan = planUndo(db, groupId);
-  if (plan.superseded && opts.force !== true) {
-    const conflicts = plan.inverses.flatMap(
-      (inv) => inv.supersededBy.map((s) => ({ key: inv.key, field: s.field, groupId: s.groupId }))
-    );
-    throw new UndoSupersededError(groupId, conflicts);
-  }
-  let applied = 0;
-  let undoGroupId = "";
-  const run = db.transaction(() => {
-    withOpContext(
-      db,
-      { intent: "undo", group: "new", ...opts.actor !== void 0 ? { actor: opts.actor } : {} },
-      () => {
-        const ctx = db.prepare("SELECT group_id FROM _op_ctx").get();
-        undoGroupId = ctx?.group_id ?? "";
-        for (const inverse of plan.inverses) {
-          if (applyInverse(db, inverse)) applied += 1;
-        }
-      }
-    );
-  });
-  run.immediate();
-  return { plan, undoGroupId: applied > 0 && undoGroupId !== "" ? undoGroupId : null, applied };
-}
-function applyInverse(db, inverse) {
-  const table = CAPTURED_TABLE_FOR[inverse.entity];
-  if (table === void 0) return false;
-  if (inverse.op === "del") return deleteRow(db, inverse);
-  return restoreRow(db, inverse, table);
-}
-function deleteRow(db, inverse) {
-  switch (inverse.entity) {
-    case "workstream":
-      return db.prepare("DELETE FROM workstreams WHERE name = ?").run(inverse.key).changes > 0;
-    case "task": {
-      const id = taskIdForKey(db, inverse.key);
-      if (id === null) return false;
-      return db.prepare("DELETE FROM tasks WHERE id = ?").run(id).changes > 0;
-    }
-    case "note": {
-      const parsed = parseNoteKey(inverse.key);
-      if (parsed === null) return false;
-      const taskId = taskIdForKey(db, parsed.taskKey);
-      if (taskId === null) return false;
-      const note = db.prepare(
-        `SELECT json_extract(payload, '$.content') AS content,
-                  json_extract(payload, '$.author') AS author,
-                  json_extract(payload, '$.created_at') AS created_at FROM ops
-            WHERE entity = 'note' AND key = ? AND op = 'put'
-              AND ${LEGACY_LOG_ONLY_SQL_EXCLUSION}
-            ORDER BY hlc DESC LIMIT 1`
-      ).get(inverse.key);
-      if (note?.content === void 0 || note.content === null) return false;
-      return db.prepare(
-        `DELETE FROM task_notes
-              WHERE task_id = @taskId AND content = @content
-                AND COALESCE(author, '') = COALESCE(@author, '')
-                AND (@createdAt IS NULL OR created_at = @createdAt)`
-      ).run({
-        taskId,
-        content: note.content,
-        author: note.author,
-        createdAt: note.created_at
-      }).changes > 0;
-    }
-    case "edge": {
-      const parsed = parseEdgeKey(inverse.key);
-      if (parsed === null) return false;
-      const from = taskIdForKey(db, parsed.blocker);
-      const to = taskIdForKey(db, parsed.blocked);
-      if (from === null || to === null) return false;
-      return db.prepare("DELETE FROM task_edges WHERE from_task_id = ? AND to_task_id = ?").run(from, to).changes > 0;
-    }
-    default:
-      return false;
-  }
-}
-function restoreRow(db, inverse, table) {
-  switch (inverse.entity) {
-    case "workstream": {
-      const exists = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(inverse.key);
-      if (!exists) {
-        db.prepare("INSERT INTO workstreams (name, created_at) VALUES (?, ?)").run(
-          inverse.key,
-          String(inverse.fields.created_at ?? (/* @__PURE__ */ new Date()).toISOString())
-        );
-        return true;
-      }
-      return updateFields(db, "workstreams", "id", exists.id, inverse.fields);
-    }
-    case "task": {
-      const parsed = parseTaskKey(inverse.key);
-      if (parsed === null) return false;
-      const id = taskIdForKey(db, inverse.key);
-      if (id === null) {
-        const wsId = ensureWorkstream(db, parsed.workstream);
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const pair = resolvePair(
-          String(inverse.fields.status ?? "OPEN"),
-          inverse.fields.substate
-        ) ?? {
-          status: "OPEN",
-          substate: "todo"
-        };
-        db.prepare(
-          `INSERT INTO tasks (workstream_id, local_id, title, status, substate, impact,
-                              effort_days, owner_id, created_at, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`
-        ).run(
-          wsId,
-          parsed.localId,
-          String(inverse.fields.title ?? parsed.localId),
-          pair.status,
-          pair.substate,
-          Number(inverse.fields.impact ?? 50),
-          Number(inverse.fields.effort_days ?? 1),
-          String(inverse.fields.created_at ?? now),
-          String(inverse.fields.updated_at ?? now)
-        );
-        return true;
-      }
-      const updated = updateFields(db, "tasks", "id", id, inverse.fields);
-      return repairTaskPair(db, id) || updated;
-    }
-    case "note": {
-      const parsed = parseNoteKey(inverse.key);
-      if (parsed === null) return false;
-      const taskId = taskIdForKey(db, parsed.taskKey);
-      if (taskId === null) return false;
-      const content = inverse.fields.content;
-      if (content === void 0 || content === null) return false;
-      const author = inverse.fields.author;
-      const createdAt = inverse.fields.created_at;
-      const exists = db.prepare(
-        `SELECT id FROM task_notes
-            WHERE task_id = @taskId AND content = @content
-              AND COALESCE(author, '') = COALESCE(@author, '')
-              AND (@createdAt IS NULL OR created_at = @createdAt)`
-      ).get({
-        taskId,
-        content: String(content),
-        author: author === void 0 || author === null ? null : String(author),
-        createdAt: createdAt === void 0 || createdAt === null ? null : String(createdAt)
-      });
-      if (exists) return false;
-      db.prepare(
-        "INSERT INTO task_notes (task_id, author, content, created_at) VALUES (?, ?, ?, ?)"
-      ).run(
-        taskId,
-        inverse.fields.author === void 0 || inverse.fields.author === null ? null : String(inverse.fields.author),
-        String(content),
-        String(inverse.fields.created_at ?? (/* @__PURE__ */ new Date()).toISOString())
-      );
-      return true;
-    }
-    case "edge": {
-      const parsed = parseEdgeKey(inverse.key);
-      if (parsed === null) return false;
-      const from = taskIdForKey(db, parsed.blocker);
-      const to = taskIdForKey(db, parsed.blocked);
-      if (from === null || to === null) return false;
-      const exists = db.prepare("SELECT 1 AS x FROM task_edges WHERE from_task_id = ? AND to_task_id = ?").get(from, to);
-      if (exists) return false;
-      db.prepare(
-        "INSERT INTO task_edges (from_task_id, to_task_id, created_at) VALUES (?, ?, ?)"
-      ).run(from, to, String(inverse.fields.created_at ?? (/* @__PURE__ */ new Date()).toISOString()));
-      return true;
-    }
-    default:
-      void table;
-      return false;
-  }
-}
-function updateFields(db, table, idColumn, id, fields) {
-  const names = Object.keys(fields).filter((f) => !NEVER_RESTORE.has(f));
-  if (names.length === 0) return false;
-  const current = db.prepare(`SELECT * FROM ${table} WHERE ${idColumn} = ?`).get(id);
-  const pending = names.filter((name) => {
-    const target = fields[name] ?? null;
-    if (current === void 0) return true;
-    return current[name] !== target;
-  });
-  if (pending.length === 0) return false;
-  const setClause = pending.map((name) => `${name} = @${name}`).join(", ");
-  const params = { id };
-  for (const name of pending) params[name] = fields[name] ?? null;
-  db.prepare(`UPDATE ${table} SET ${setClause} WHERE ${idColumn} = @id`).run(params);
-  return true;
-}
-function ensureWorkstream(db, name) {
-  const existing = db.prepare("SELECT id FROM workstreams WHERE name = ?").get(name);
-  if (existing) return existing.id;
-  db.prepare("INSERT INTO workstreams (name, created_at) VALUES (?, ?)").run(
-    name,
-    (/* @__PURE__ */ new Date()).toISOString()
-  );
-  return resolveWorkstreamId(db, name);
-}
-function parseTaskKey(key) {
-  const slash = key.indexOf("/");
-  if (slash <= 0 || slash === key.length - 1) return null;
-  return { workstream: key.slice(0, slash), localId: key.slice(slash + 1) };
-}
-function parseNoteKey(key) {
-  const hash = key.lastIndexOf("#");
-  if (hash <= 0) return null;
-  return { taskKey: key.slice(0, hash) };
-}
-function parseEdgeKey(key) {
-  const arrow = key.indexOf("->");
-  if (arrow <= 0) return null;
-  return { blocker: key.slice(0, arrow), blocked: key.slice(arrow + 2) };
-}
-function taskIdForKey(db, key) {
-  const parsed = parseTaskKey(key);
-  if (parsed === null) return null;
-  const row = db.prepare(
-    `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(parsed.workstream, parsed.localId);
-  return row?.id ?? null;
-}
-
-export {
-  UndoGroupNotFoundError,
-  NothingToUndoError,
-  UndoSupersededError,
-  priorFieldValue,
-  listRecentGroups,
-  mostRecentGroup,
-  resolveGroupId,
-  planUndo,
-  undoGroup
-};
-//# sourceMappingURL=chunk-G434JKV2.js.map