@versatly/workgraph 0.1.0 → 0.2.0

package/dist/chunk-CRQXDCPR.js

@@ -1,1443 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/types.ts
-var THREAD_STATUS_TRANSITIONS = {
-  open: ["active", "cancelled"],
-  active: ["blocked", "done", "cancelled", "open"],
-  blocked: ["active", "cancelled"],
-  done: [],
-  cancelled: ["open"]
-};
-
-// src/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  defineType: () => defineType,
-  extendType: () => extendType,
-  getType: () => getType,
-  listTypes: () => listTypes,
-  loadRegistry: () => loadRegistry,
-  registryPath: () => registryPath,
-  saveRegistry: () => saveRegistry
-});
-import fs2 from "fs";
-import path2 from "path";
-
-// src/ledger.ts
-var ledger_exports = {};
-__export(ledger_exports, {
-  activityOf: () => activityOf,
-  allClaims: () => allClaims,
-  append: () => append,
-  blame: () => blame,
-  claimsFromIndex: () => claimsFromIndex,
-  currentOwner: () => currentOwner,
-  historyOf: () => historyOf,
-  isClaimed: () => isClaimed,
-  ledgerChainStatePath: () => ledgerChainStatePath,
-  ledgerIndexPath: () => ledgerIndexPath,
-  ledgerPath: () => ledgerPath,
-  loadChainState: () => loadChainState,
-  loadIndex: () => loadIndex,
-  query: () => query,
-  readAll: () => readAll,
-  readSince: () => readSince,
-  rebuildHashChainState: () => rebuildHashChainState,
-  rebuildIndex: () => rebuildIndex,
-  recent: () => recent,
-  verifyHashChain: () => verifyHashChain
-});
-import fs from "fs";
-import path from "path";
-import crypto from "crypto";
-var LEDGER_FILE = ".clawvault/ledger.jsonl";
-var LEDGER_INDEX_FILE = ".clawvault/ledger-index.json";
-var LEDGER_CHAIN_FILE = ".clawvault/ledger-chain.json";
-var LEDGER_INDEX_VERSION = 1;
-var LEDGER_CHAIN_VERSION = 1;
-var LEDGER_GENESIS_HASH = "GENESIS";
-function ledgerPath(workspacePath) {
-  return path.join(workspacePath, LEDGER_FILE);
-}
-function ledgerIndexPath(workspacePath) {
-  return path.join(workspacePath, LEDGER_INDEX_FILE);
-}
-function ledgerChainStatePath(workspacePath) {
-  return path.join(workspacePath, LEDGER_CHAIN_FILE);
-}
-function append(workspacePath, actor, op, target, type, data) {
-  const chainState = ensureChainState(workspacePath);
-  const baseEntry = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    actor,
-    op,
-    target,
-    ...type ? { type } : {},
-    ...data && Object.keys(data).length > 0 ? { data } : {},
-    prevHash: chainState.lastHash
-  };
-  const entry = {
-    ...baseEntry,
-    hash: computeEntryHash(baseEntry)
-  };
-  const lPath = ledgerPath(workspacePath);
-  const dir = path.dirname(lPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.appendFileSync(lPath, JSON.stringify(entry) + "\n", "utf-8");
-  updateIndexWithEntry(workspacePath, entry);
-  updateChainStateWithEntry(workspacePath, entry);
-  return entry;
-}
-function readAll(workspacePath) {
-  const lPath = ledgerPath(workspacePath);
-  if (!fs.existsSync(lPath)) return [];
-  const lines = fs.readFileSync(lPath, "utf-8").split("\n").filter(Boolean);
-  return lines.map((line) => JSON.parse(line));
-}
-function readSince(workspacePath, since) {
-  return readAll(workspacePath).filter((e) => e.ts >= since);
-}
-function loadIndex(workspacePath) {
-  const idxPath = ledgerIndexPath(workspacePath);
-  if (!fs.existsSync(idxPath)) return null;
-  try {
-    const raw = fs.readFileSync(idxPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function loadChainState(workspacePath) {
-  const chainPath = ledgerChainStatePath(workspacePath);
-  if (!fs.existsSync(chainPath)) return null;
-  try {
-    const raw = fs.readFileSync(chainPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function rebuildIndex(workspacePath) {
-  const index = seedIndex();
-  const entries = readAll(workspacePath);
-  for (const entry of entries) {
-    applyClaimMutation(index, entry);
-    index.lastEntryTs = entry.ts;
-  }
-  saveIndex(workspacePath, index);
-  return index;
-}
-function rebuildHashChainState(workspacePath) {
-  const entries = readAll(workspacePath);
-  let rollingHash = LEDGER_GENESIS_HASH;
-  for (const entry of entries) {
-    const normalized = normalizeEntryForHash(entry, rollingHash);
-    rollingHash = computeEntryHash(normalized);
-  }
-  const chainState = {
-    version: LEDGER_CHAIN_VERSION,
-    algorithm: "sha256",
-    lastHash: rollingHash,
-    count: entries.length,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveChainState(workspacePath, chainState);
-  return chainState;
-}
-function claimsFromIndex(workspacePath) {
-  try {
-    const index = loadIndex(workspacePath);
-    if (index?.version === LEDGER_INDEX_VERSION) {
-      return new Map(Object.entries(index.claims));
-    }
-    const rebuilt = rebuildIndex(workspacePath);
-    return new Map(Object.entries(rebuilt.claims));
-  } catch {
-    return claimsFromLedger(workspacePath);
-  }
-}
-function query(workspacePath, options = {}) {
-  let entries = readAll(workspacePath);
-  if (options.actor) entries = entries.filter((entry) => entry.actor === options.actor);
-  if (options.op) entries = entries.filter((entry) => entry.op === options.op);
-  if (options.target) entries = entries.filter((entry) => entry.target === options.target);
-  if (options.targetIncludes) entries = entries.filter((entry) => entry.target.includes(options.targetIncludes));
-  if (options.type) entries = entries.filter((entry) => entry.type === options.type);
-  if (options.since) entries = entries.filter((entry) => entry.ts >= options.since);
-  if (options.until) entries = entries.filter((entry) => entry.ts <= options.until);
-  if (options.offset && options.offset > 0) entries = entries.slice(options.offset);
-  if (options.limit && options.limit >= 0) entries = entries.slice(0, options.limit);
-  return entries;
-}
-function blame(workspacePath, target) {
-  const history = historyOf(workspacePath, target);
-  const byActor = /* @__PURE__ */ new Map();
-  for (const entry of history) {
-    const existing = byActor.get(entry.actor) ?? {
-      actor: entry.actor,
-      count: 0,
-      ops: {},
-      lastTs: entry.ts
-    };
-    existing.count += 1;
-    existing.ops[entry.op] = (existing.ops[entry.op] ?? 0) + 1;
-    if (entry.ts > existing.lastTs) existing.lastTs = entry.ts;
-    byActor.set(entry.actor, existing);
-  }
-  return {
-    target,
-    totalEntries: history.length,
-    actors: [...byActor.values()].sort((a, b) => b.count - a.count || a.actor.localeCompare(b.actor)),
-    latest: history.length > 0 ? history[history.length - 1] : null
-  };
-}
-function verifyHashChain(workspacePath, options = {}) {
-  const entries = readAll(workspacePath);
-  const warnings = [];
-  const issues = [];
-  let rollingHash = LEDGER_GENESIS_HASH;
-  for (let idx = 0; idx < entries.length; idx++) {
-    const entry = entries[idx];
-    const entryNumber = idx + 1;
-    if (entry.prevHash === void 0) {
-      const message = `Entry #${entryNumber} missing prevHash`;
-      if (options.strict) issues.push(message);
-      else warnings.push(message);
-    } else if (entry.prevHash !== rollingHash) {
-      issues.push(`Entry #${entryNumber} prevHash mismatch`);
-    }
-    const normalized = normalizeEntryForHash(entry, rollingHash);
-    const expectedHash = computeEntryHash(normalized);
-    if (entry.hash === void 0) {
-      const message = `Entry #${entryNumber} missing hash`;
-      if (options.strict) issues.push(message);
-      else warnings.push(message);
-      rollingHash = expectedHash;
-      continue;
-    }
-    if (entry.hash !== expectedHash) {
-      issues.push(`Entry #${entryNumber} hash mismatch`);
-    }
-    rollingHash = entry.hash;
-  }
-  const chainState = loadChainState(workspacePath);
-  if (chainState) {
-    if (chainState.count !== entries.length) {
-      issues.push(`Chain state count mismatch: state=${chainState.count} actual=${entries.length}`);
-    }
-    if (chainState.lastHash !== rollingHash) {
-      issues.push("Chain state lastHash mismatch");
-    }
-  } else if (entries.length > 0) {
-    warnings.push("Ledger chain state file missing");
-  }
-  return {
-    ok: issues.length === 0 && (!options.strict || warnings.length === 0),
-    entries: entries.length,
-    lastHash: rollingHash,
-    issues,
-    warnings,
-    chainState
-  };
-}
-function currentOwner(workspacePath, target) {
-  return allClaims(workspacePath).get(target) ?? null;
-}
-function isClaimed(workspacePath, target) {
-  return currentOwner(workspacePath, target) !== null;
-}
-function historyOf(workspacePath, target) {
-  return readAll(workspacePath).filter((e) => e.target === target);
-}
-function activityOf(workspacePath, actor) {
-  return readAll(workspacePath).filter((e) => e.actor === actor);
-}
-function allClaims(workspacePath) {
-  return claimsFromIndex(workspacePath);
-}
-function recent(workspacePath, count = 20) {
-  const all = readAll(workspacePath);
-  return all.slice(-count);
-}
-function updateIndexWithEntry(workspacePath, entry) {
-  const index = loadIndex(workspacePath) ?? seedIndex();
-  applyClaimMutation(index, entry);
-  index.lastEntryTs = entry.ts;
-  saveIndex(workspacePath, index);
-}
-function updateChainStateWithEntry(workspacePath, entry) {
-  const state = ensureChainState(workspacePath);
-  const chainState = {
-    version: LEDGER_CHAIN_VERSION,
-    algorithm: "sha256",
-    lastHash: entry.hash ?? state.lastHash,
-    count: state.count + 1,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveChainState(workspacePath, chainState);
-}
-function saveIndex(workspacePath, index) {
-  const idxPath = ledgerIndexPath(workspacePath);
-  const dir = path.dirname(idxPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(idxPath, JSON.stringify(index, null, 2) + "\n", "utf-8");
-}
-function saveChainState(workspacePath, state) {
-  const chainPath = ledgerChainStatePath(workspacePath);
-  const dir = path.dirname(chainPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(chainPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
-}
-function seedIndex() {
-  return {
-    version: LEDGER_INDEX_VERSION,
-    lastEntryTs: "",
-    claims: {}
-  };
-}
-function applyClaimMutation(index, entry) {
-  if (entry.op === "claim") {
-    index.claims[entry.target] = entry.actor;
-    return;
-  }
-  if (entry.op === "release" || entry.op === "done" || entry.op === "cancel") {
-    delete index.claims[entry.target];
-  }
-}
-function claimsFromLedger(workspacePath) {
-  const claims = /* @__PURE__ */ new Map();
-  const entries = readAll(workspacePath);
-  for (const entry of entries) {
-    if (entry.op === "claim") claims.set(entry.target, entry.actor);
-    if (entry.op === "release" || entry.op === "done" || entry.op === "cancel") {
-      claims.delete(entry.target);
-    }
-  }
-  return claims;
-}
-function ensureChainState(workspacePath) {
-  const existing = loadChainState(workspacePath);
-  if (existing?.version === LEDGER_CHAIN_VERSION) return existing;
-  return rebuildHashChainState(workspacePath);
-}
-function normalizeEntryForHash(entry, fallbackPrevHash) {
-  return {
-    ts: entry.ts,
-    actor: entry.actor,
-    op: entry.op,
-    target: entry.target,
-    ...entry.type ? { type: entry.type } : {},
-    ...entry.data ? { data: entry.data } : {},
-    prevHash: entry.prevHash ?? fallbackPrevHash
-  };
-}
-function computeEntryHash(entry) {
-  const payload = stableStringify({
-    ts: entry.ts,
-    actor: entry.actor,
-    op: entry.op,
-    target: entry.target,
-    ...entry.type ? { type: entry.type } : {},
-    ...entry.data ? { data: entry.data } : {},
-    prevHash: entry.prevHash ?? LEDGER_GENESIS_HASH
-  });
-  return crypto.createHash("sha256").update(payload).digest("hex");
-}
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const obj = value;
-  const keys = Object.keys(obj).sort();
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
-}
-
-// src/registry.ts
-var REGISTRY_FILE = ".clawvault/registry.json";
-var CURRENT_VERSION = 1;
-var BUILT_IN_TYPES = [
-  {
-    name: "thread",
-    description: "A unit of coordinated work. The core workgraph node.",
-    directory: "threads",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true, description: "What this thread is about" },
-      goal: { type: "string", required: true, description: "What success looks like" },
-      status: { type: "string", required: true, default: "open", description: "open | active | blocked | done | cancelled" },
-      owner: { type: "string", description: "Agent that claimed this thread" },
-      priority: { type: "string", default: "medium", description: "urgent | high | medium | low" },
-      deps: { type: "list", default: [], description: "Thread refs this depends on" },
-      parent: { type: "ref", description: "Parent thread if decomposed from larger thread" },
-      space: { type: "ref", description: "Space ref this thread belongs to" },
-      context_refs: { type: "list", default: [], description: "Docs that inform this work" },
-      tags: { type: "list", default: [], description: "Freeform tags" },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true }
-    }
-  },
-  {
-    name: "space",
-    description: "A workspace boundary that groups related threads and sets context.",
-    directory: "spaces",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true, description: "Space name" },
-      description: { type: "string", description: "What this space is for" },
-      members: { type: "list", default: [], description: "Agent names that participate" },
-      thread_refs: { type: "list", default: [], description: "Thread refs in this space" },
-      tags: { type: "list", default: [], description: "Freeform tags" },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true }
-    }
-  },
-  {
-    name: "decision",
-    description: "A recorded decision with reasoning and context.",
-    directory: "decisions",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      date: { type: "date", required: true },
-      status: { type: "string", default: "active", description: "active | superseded | reverted" },
-      context_refs: { type: "list", default: [], description: "What informed this decision" },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "lesson",
-    description: "A captured insight or pattern learned from experience.",
-    directory: "lessons",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      date: { type: "date", required: true },
-      confidence: { type: "string", default: "medium", description: "high | medium | low" },
-      context_refs: { type: "list", default: [] },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "fact",
-    description: "A structured piece of knowledge with optional temporal validity.",
-    directory: "facts",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      subject: { type: "string", required: true },
-      predicate: { type: "string", required: true },
-      object: { type: "string", required: true },
-      confidence: { type: "number", default: 1 },
-      valid_from: { type: "date" },
-      valid_until: { type: "date" },
-      source: { type: "ref", description: "Where this fact came from" }
-    }
-  },
-  {
-    name: "agent",
-    description: "A registered participant in the workgraph.",
-    directory: "agents",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      name: { type: "string", required: true },
-      role: { type: "string", description: "What this agent specializes in" },
-      capabilities: { type: "list", default: [], description: "What this agent can do" },
-      active_threads: { type: "list", default: [], description: "Threads currently claimed" },
-      last_seen: { type: "date" }
-    }
-  },
-  {
-    name: "skill",
-    description: "A reusable agent skill shared through the workgraph workspace.",
-    directory: "skills",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true, description: "Skill title" },
-      status: { type: "string", required: true, default: "draft", description: "draft | proposed | active | deprecated | archived" },
-      version: { type: "string", default: "0.1.0", description: "Semantic version of this skill" },
-      owner: { type: "string", description: "Primary skill owner/maintainer" },
-      reviewers: { type: "list", default: [], description: "Reviewers involved in proposal" },
-      proposal_thread: { type: "ref", description: "Thread coordinating review/promotion" },
-      proposed_at: { type: "date" },
-      promoted_at: { type: "date" },
-      distribution: { type: "string", default: "tailscale-shared-vault", description: "Distribution channel for skill usage" },
-      tailscale_path: { type: "string", description: "Shared vault path over Tailscale" },
-      tags: { type: "list", default: [] },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true }
-    }
-  }
-];
-function registryPath(workspacePath) {
-  return path2.join(workspacePath, REGISTRY_FILE);
-}
-function loadRegistry(workspacePath) {
-  const rPath = registryPath(workspacePath);
-  if (fs2.existsSync(rPath)) {
-    const raw = fs2.readFileSync(rPath, "utf-8");
-    const registry = JSON.parse(raw);
-    return ensureBuiltIns(registry);
-  }
-  return seedRegistry();
-}
-function saveRegistry(workspacePath, registry) {
-  const rPath = registryPath(workspacePath);
-  const dir = path2.dirname(rPath);
-  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(rPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
-}
-function defineType(workspacePath, name, description, fields, actor, directory) {
-  const registry = loadRegistry(workspacePath);
-  const safeName = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
-  if (registry.types[safeName]?.builtIn) {
-    throw new Error(`Cannot redefine built-in type "${safeName}". You can extend it with new fields instead.`);
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const typeDef = {
-    name: safeName,
-    description,
-    fields: {
-      title: { type: "string", required: true },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] },
-      ...fields
-    },
-    directory: directory ?? `${safeName}s`,
-    builtIn: false,
-    createdAt: now,
-    createdBy: actor
-  };
-  registry.types[safeName] = typeDef;
-  saveRegistry(workspacePath, registry);
-  append(workspacePath, actor, "define", ".clawvault/registry.json", safeName, {
-    name: safeName,
-    directory: typeDef.directory,
-    fields: Object.keys(typeDef.fields)
-  });
-  return typeDef;
-}
-function getType(workspacePath, name) {
-  const registry = loadRegistry(workspacePath);
-  return registry.types[name];
-}
-function listTypes(workspacePath) {
-  const registry = loadRegistry(workspacePath);
-  return Object.values(registry.types);
-}
-function extendType(workspacePath, name, newFields, _actor) {
-  const registry = loadRegistry(workspacePath);
-  const existing = registry.types[name];
-  if (!existing) throw new Error(`Type "${name}" not found in registry.`);
-  existing.fields = { ...existing.fields, ...newFields };
-  saveRegistry(workspacePath, registry);
-  return existing;
-}
-function seedRegistry() {
-  const types = {};
-  for (const t of BUILT_IN_TYPES) {
-    types[t.name] = t;
-  }
-  return { version: CURRENT_VERSION, types };
-}
-function ensureBuiltIns(registry) {
-  for (const t of BUILT_IN_TYPES) {
-    if (!registry.types[t.name]) {
-      registry.types[t.name] = t;
-    }
-  }
-  return registry;
-}
-
-// src/store.ts
-var store_exports = {};
-__export(store_exports, {
-  activeThreads: () => activeThreads,
-  blockedThreads: () => blockedThreads,
-  create: () => create,
-  findByField: () => findByField,
-  list: () => list,
-  openThreads: () => openThreads,
-  read: () => read,
-  remove: () => remove,
-  threadsInSpace: () => threadsInSpace,
-  update: () => update
-});
-import fs3 from "fs";
-import path3 from "path";
-import matter from "gray-matter";
-function create(workspacePath, typeName, fields, body, actor) {
-  const typeDef = getType(workspacePath, typeName);
-  if (!typeDef) {
-    throw new Error(`Unknown primitive type "${typeName}". Run \`workgraph primitive list\` to see available types, or \`workgraph primitive define\` to create one.`);
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const merged = applyDefaults(typeDef, {
-    ...fields,
-    created: fields.created ?? now,
-    updated: now
-  });
-  validateFields(typeDef, merged, "create");
-  const slug = slugify(String(merged.title ?? merged.name ?? typeName));
-  const relDir = typeDef.directory;
-  const relPath = `${relDir}/${slug}.md`;
-  const absDir = path3.join(workspacePath, relDir);
-  const absPath = path3.join(workspacePath, relPath);
-  if (!fs3.existsSync(absDir)) fs3.mkdirSync(absDir, { recursive: true });
-  if (fs3.existsSync(absPath)) {
-    throw new Error(`File already exists: ${relPath}. Use update instead.`);
-  }
-  const content = matter.stringify(body, stripUndefined(merged));
-  fs3.writeFileSync(absPath, content, "utf-8");
-  append(workspacePath, actor, "create", relPath, typeName, {
-    title: merged.title ?? slug
-  });
-  return { path: relPath, type: typeName, fields: merged, body };
-}
-function read(workspacePath, relPath) {
-  const absPath = path3.join(workspacePath, relPath);
-  if (!fs3.existsSync(absPath)) return null;
-  const raw = fs3.readFileSync(absPath, "utf-8");
-  const { data, content } = matter(raw);
-  const typeName = inferType(workspacePath, relPath);
-  return { path: relPath, type: typeName, fields: data, body: content.trim() };
-}
-function list(workspacePath, typeName) {
-  const typeDef = getType(workspacePath, typeName);
-  if (!typeDef) return [];
-  const dir = path3.join(workspacePath, typeDef.directory);
-  if (!fs3.existsSync(dir)) return [];
-  const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".md"));
-  const instances = [];
-  for (const file of files) {
-    const relPath = `${typeDef.directory}/${file}`;
-    const inst = read(workspacePath, relPath);
-    if (inst) instances.push(inst);
-  }
-  return instances;
-}
-function update(workspacePath, relPath, fieldUpdates, bodyUpdate, actor) {
-  const existing = read(workspacePath, relPath);
-  if (!existing) throw new Error(`Not found: ${relPath}`);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const newFields = { ...existing.fields, ...fieldUpdates, updated: now };
-  const typeDef = getType(workspacePath, existing.type);
-  if (!typeDef) throw new Error(`Unknown primitive type "${existing.type}" for ${relPath}`);
-  validateFields(typeDef, newFields, "update");
-  const newBody = bodyUpdate ?? existing.body;
-  const absPath = path3.join(workspacePath, relPath);
-  const content = matter.stringify(newBody, stripUndefined(newFields));
-  fs3.writeFileSync(absPath, content, "utf-8");
-  append(workspacePath, actor, "update", relPath, existing.type, {
-    changed: Object.keys(fieldUpdates)
-  });
-  return { path: relPath, type: existing.type, fields: newFields, body: newBody };
-}
-function remove(workspacePath, relPath, actor) {
-  const absPath = path3.join(workspacePath, relPath);
-  if (!fs3.existsSync(absPath)) throw new Error(`Not found: ${relPath}`);
-  const archiveDir = path3.join(workspacePath, ".clawvault", "archive");
-  if (!fs3.existsSync(archiveDir)) fs3.mkdirSync(archiveDir, { recursive: true });
-  const archivePath = path3.join(archiveDir, path3.basename(relPath));
-  fs3.renameSync(absPath, archivePath);
-  const typeName = inferType(workspacePath, relPath);
-  append(workspacePath, actor, "delete", relPath, typeName);
-}
-function findByField(workspacePath, typeName, field, value) {
-  return list(workspacePath, typeName).filter((inst) => inst.fields[field] === value);
-}
-function openThreads(workspacePath) {
-  return findByField(workspacePath, "thread", "status", "open");
-}
-function activeThreads(workspacePath) {
-  return findByField(workspacePath, "thread", "status", "active");
-}
-function blockedThreads(workspacePath) {
-  return findByField(workspacePath, "thread", "status", "blocked");
-}
-function threadsInSpace(workspacePath, spaceRef) {
-  const normalizedTarget = normalizeRefPath(spaceRef);
-  return list(workspacePath, "thread").filter((thread) => {
-    const rawSpace = thread.fields.space;
-    if (!rawSpace) return false;
-    return normalizeRefPath(rawSpace) === normalizedTarget;
-  });
-}
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
-}
-function applyDefaults(typeDef, fields) {
-  const result = { ...fields };
-  for (const [key, def] of Object.entries(typeDef.fields)) {
-    if (result[key] === void 0 && def.default !== void 0) {
-      result[key] = def.default;
-    }
-  }
-  return result;
-}
-function stripUndefined(obj) {
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (v !== void 0) result[k] = v;
-  }
-  return result;
-}
-function inferType(workspacePath, relPath) {
-  const registry = loadRegistry(workspacePath);
-  const dir = relPath.split("/")[0];
-  for (const typeDef of Object.values(registry.types)) {
-    if (typeDef.directory === dir) return typeDef.name;
-  }
-  return "unknown";
-}
-function normalizeRefPath(value) {
-  const raw = String(value ?? "").trim();
-  if (!raw) return "";
-  const unwrapped = raw.startsWith("[[") && raw.endsWith("]]") ? raw.slice(2, -2) : raw;
-  return unwrapped.endsWith(".md") ? unwrapped : `${unwrapped}.md`;
-}
-function validateFields(typeDef, fields, mode) {
-  const issues = [];
-  for (const [fieldName, definition] of Object.entries(typeDef.fields)) {
-    const value = fields[fieldName];
-    if (definition.required && isMissingRequiredValue(value)) {
-      issues.push(`Missing required field "${fieldName}"`);
-      continue;
-    }
-    if (value === void 0 || value === null) continue;
-    if (!isFieldTypeCompatible(definition.type, value)) {
-      issues.push(`Field "${fieldName}" expected ${definition.type}, got ${describeValue(value)}`);
-    }
-  }
-  if (issues.length > 0) {
-    throw new Error(`Invalid ${typeDef.name} ${mode} payload: ${issues.join("; ")}`);
-  }
-}
-function isMissingRequiredValue(value) {
-  if (value === void 0 || value === null) return true;
-  if (typeof value === "string" && value.trim().length === 0) return true;
-  return false;
-}
-function isFieldTypeCompatible(type, value) {
-  switch (type) {
-    case "string":
-    case "ref":
-    case "date":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && Number.isFinite(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "list":
-      return Array.isArray(value);
-    case "any":
-      return true;
-    default:
-      return true;
-  }
-}
-function describeValue(value) {
-  if (Array.isArray(value)) return "array";
-  if (value === null) return "null";
-  return typeof value;
-}
-
-// src/thread.ts
-var thread_exports = {};
-__export(thread_exports, {
-  block: () => block,
-  cancel: () => cancel,
-  claim: () => claim,
-  claimNextReady: () => claimNextReady,
-  claimNextReadyInSpace: () => claimNextReadyInSpace,
-  createThread: () => createThread,
-  decompose: () => decompose,
-  done: () => done,
-  isReadyForClaim: () => isReadyForClaim,
-  listReadyThreads: () => listReadyThreads,
-  listReadyThreadsInSpace: () => listReadyThreadsInSpace,
-  pickNextReadyThread: () => pickNextReadyThread,
-  pickNextReadyThreadInSpace: () => pickNextReadyThreadInSpace,
-  release: () => release,
-  unblock: () => unblock
-});
-function createThread(workspacePath, title, goal, actor, opts = {}) {
-  const normalizedSpace = opts.space ? normalizeWorkspaceRef(opts.space) : void 0;
-  const contextRefs = opts.context_refs ?? [];
-  const mergedContextRefs = normalizedSpace && !contextRefs.includes(normalizedSpace) ? [...contextRefs, normalizedSpace] : contextRefs;
-  return create(workspacePath, "thread", {
-    title,
-    goal,
-    status: "open",
-    priority: opts.priority ?? "medium",
-    deps: opts.deps ?? [],
-    parent: opts.parent,
-    space: normalizedSpace,
-    context_refs: mergedContextRefs,
-    tags: opts.tags ?? []
-  }, `## Goal
-
-${goal}
-`, actor);
-}
-function isReadyForClaim(workspacePath, threadPathOrInstance) {
-  const instance = typeof threadPathOrInstance === "string" ? read(workspacePath, threadPathOrInstance) : threadPathOrInstance;
-  if (!instance) return false;
-  if (instance.type !== "thread") return false;
-  if (instance.fields.status !== "open") return false;
-  const hasUnfinishedChildren = list(workspacePath, "thread").some(
-    (candidate) => candidate.fields.parent === instance.path && !["done", "cancelled"].includes(String(candidate.fields.status))
-  );
-  if (hasUnfinishedChildren) return false;
-  const deps = Array.isArray(instance.fields.deps) ? instance.fields.deps : [];
-  if (deps.length === 0) return true;
-  for (const dep of deps) {
-    const depRef = normalizeThreadRef(dep);
-    if (depRef.startsWith("external/")) return false;
-    const depThread = read(workspacePath, depRef);
-    if (!depThread || depThread.fields.status !== "done") {
-      return false;
-    }
-  }
-  return true;
-}
-function listReadyThreads(workspacePath) {
-  const open = openThreads(workspacePath);
-  return open.filter((t) => isReadyForClaim(workspacePath, t)).sort(compareThreadPriority);
-}
-function listReadyThreadsInSpace(workspacePath, spaceRef) {
-  const normalizedSpace = normalizeWorkspaceRef(spaceRef);
-  return listReadyThreads(workspacePath).filter(
-    (thread) => normalizeWorkspaceRef(thread.fields.space) === normalizedSpace
-  );
-}
-function pickNextReadyThread(workspacePath) {
-  const ready = listReadyThreads(workspacePath);
-  return ready[0] ?? null;
-}
-function pickNextReadyThreadInSpace(workspacePath, spaceRef) {
-  const ready = listReadyThreadsInSpace(workspacePath, spaceRef);
-  return ready[0] ?? null;
-}
-function claimNextReady(workspacePath, actor) {
-  const next = pickNextReadyThread(workspacePath);
-  if (!next) return null;
-  return claim(workspacePath, next.path, actor);
-}
-function claimNextReadyInSpace(workspacePath, actor, spaceRef) {
-  const next = pickNextReadyThreadInSpace(workspacePath, spaceRef);
-  if (!next) return null;
-  return claim(workspacePath, next.path, actor);
-}
-function claim(workspacePath, threadPath, actor) {
-  const thread = read(workspacePath, threadPath);
-  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-  const status = thread.fields.status;
-  if (status !== "open") {
-    throw new Error(`Cannot claim thread in "${status}" state. Only "open" threads can be claimed.`);
-  }
-  const owner = currentOwner(workspacePath, threadPath);
-  if (owner) {
-    throw new Error(`Thread already claimed by "${owner}". Wait for release or use a different thread.`);
-  }
-  append(workspacePath, actor, "claim", threadPath, "thread");
-  return update(workspacePath, threadPath, {
-    status: "active",
-    owner: actor
-  }, void 0, actor);
-}
-function release(workspacePath, threadPath, actor, reason) {
-  const thread = read(workspacePath, threadPath);
-  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-  assertOwner(workspacePath, threadPath, actor);
-  append(
-    workspacePath,
-    actor,
-    "release",
-    threadPath,
-    "thread",
-    reason ? { reason } : void 0
-  );
-  return update(workspacePath, threadPath, {
-    status: "open",
-    owner: null
-  }, void 0, actor);
-}
-function block(workspacePath, threadPath, actor, blockedBy, reason) {
-  const thread = read(workspacePath, threadPath);
-  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-  assertTransition(thread.fields.status, "blocked");
-  append(workspacePath, actor, "block", threadPath, "thread", {
-    blocked_by: blockedBy,
-    ...reason ? { reason } : {}
-  });
-  const currentDeps = thread.fields.deps ?? [];
-  const updatedDeps = currentDeps.includes(blockedBy) ? currentDeps : [...currentDeps, blockedBy];
-  return update(workspacePath, threadPath, {
-    status: "blocked",
-    deps: updatedDeps
-  }, void 0, actor);
-}
-function unblock(workspacePath, threadPath, actor) {
-  const thread = read(workspacePath, threadPath);
-  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-  assertTransition(thread.fields.status, "active");
-  append(workspacePath, actor, "unblock", threadPath, "thread");
-  return update(workspacePath, threadPath, {
-    status: "active"
-  }, void 0, actor);
-}
-function done(workspacePath, threadPath, actor, output) {
-  const thread = read(workspacePath, threadPath);
-  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-  assertTransition(thread.fields.status, "done");
-  assertOwner(workspacePath, threadPath, actor);
-  append(
-    workspacePath,
-    actor,
-    "done",
-    threadPath,
-    "thread",
-    output ? { output } : void 0
-  );
-  const newBody = output ? `${thread.body}
-
-## Output
-
-${output}
-` : thread.body;
-  return update(workspacePath, threadPath, {
-    status: "done"
-  }, newBody, actor);
-}
-function cancel(workspacePath, threadPath, actor, reason) {
-  const thread = read(workspacePath, threadPath);
-  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
-  assertTransition(thread.fields.status, "cancelled");
-  append(
-    workspacePath,
-    actor,
-    "cancel",
-    threadPath,
-    "thread",
-    reason ? { reason } : void 0
-  );
-  return update(workspacePath, threadPath, {
-    status: "cancelled",
-    owner: null
-  }, void 0, actor);
-}
-function decompose(workspacePath, parentPath, subthreads, actor) {
-  const parent = read(workspacePath, parentPath);
-  if (!parent) throw new Error(`Thread not found: ${parentPath}`);
-  const created = [];
-  for (const sub of subthreads) {
-    const inst = createThread(workspacePath, sub.title, sub.goal, actor, {
-      parent: parentPath,
-      deps: sub.deps,
-      space: typeof parent.fields.space === "string" ? parent.fields.space : void 0
-    });
-    created.push(inst);
-  }
-  const childRefs = created.map((c) => `[[${c.path}]]`);
-  const decomposeNote = `
-
-## Sub-threads
-
-${childRefs.map((r) => `- ${r}`).join("\n")}
-`;
-  update(workspacePath, parentPath, {}, parent.body + decomposeNote, actor);
-  append(workspacePath, actor, "decompose", parentPath, "thread", {
-    children: created.map((c) => c.path)
-  });
-  return created;
-}
-function assertTransition(from, to) {
-  const allowed = THREAD_STATUS_TRANSITIONS[from];
-  if (!allowed?.includes(to)) {
-    throw new Error(`Invalid transition: "${from}" \u2192 "${to}". Allowed: ${allowed?.join(", ") ?? "none"}`);
-  }
-}
-function assertOwner(workspacePath, threadPath, actor) {
-  const owner = currentOwner(workspacePath, threadPath);
-  if (owner && owner !== actor) {
-    throw new Error(`Thread is owned by "${owner}", not "${actor}". Only the owner can perform this action.`);
-  }
-}
-function compareThreadPriority(a, b) {
-  const rank = (value) => {
-    const normalized = String(value ?? "medium").toLowerCase();
-    switch (normalized) {
-      case "urgent":
-        return 0;
-      case "high":
-        return 1;
-      case "medium":
-        return 2;
-      case "low":
-        return 3;
-      default:
-        return 4;
-    }
-  };
-  const byPriority = rank(a.fields.priority) - rank(b.fields.priority);
-  if (byPriority !== 0) return byPriority;
-  const createdA = Date.parse(String(a.fields.created ?? ""));
-  const createdB = Date.parse(String(b.fields.created ?? ""));
-  const safeA = Number.isNaN(createdA) ? Number.MAX_SAFE_INTEGER : createdA;
-  const safeB = Number.isNaN(createdB) ? Number.MAX_SAFE_INTEGER : createdB;
-  return safeA - safeB;
-}
-function normalizeThreadRef(value) {
-  const raw = String(value ?? "").trim();
-  if (!raw) return raw;
-  const unwrapped = raw.startsWith("[[") && raw.endsWith("]]") ? raw.slice(2, -2) : raw;
-  if (unwrapped.startsWith("external/")) return unwrapped;
-  if (unwrapped.endsWith(".md")) return unwrapped;
-  return `${unwrapped}.md`;
-}
-function normalizeWorkspaceRef(value) {
-  const raw = String(value ?? "").trim();
-  if (!raw) return "";
-  const unwrapped = raw.startsWith("[[") && raw.endsWith("]]") ? raw.slice(2, -2) : raw;
-  return unwrapped.endsWith(".md") ? unwrapped : `${unwrapped}.md`;
-}
-
-// src/workspace.ts
-var workspace_exports = {};
-__export(workspace_exports, {
-  initWorkspace: () => initWorkspace,
-  isWorkgraphWorkspace: () => isWorkgraphWorkspace,
-  workspaceConfigPath: () => workspaceConfigPath
-});
-import fs5 from "fs";
-import path5 from "path";
-
-// src/bases.ts
-var bases_exports = {};
-__export(bases_exports, {
-  generateBasesFromPrimitiveRegistry: () => generateBasesFromPrimitiveRegistry,
-  primitiveRegistryManifestPath: () => primitiveRegistryManifestPath,
-  readPrimitiveRegistryManifest: () => readPrimitiveRegistryManifest,
-  syncPrimitiveRegistryManifest: () => syncPrimitiveRegistryManifest
-});
-import fs4 from "fs";
-import path4 from "path";
-import YAML from "yaml";
-var REGISTRY_MANIFEST_FILE = ".clawvault/primitive-registry.yaml";
-var DEFAULT_BASES_DIR = ".clawvault/bases";
-function primitiveRegistryManifestPath(workspacePath) {
-  return path4.join(workspacePath, REGISTRY_MANIFEST_FILE);
-}
-function readPrimitiveRegistryManifest(workspacePath) {
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  if (!fs4.existsSync(manifestPath)) {
-    throw new Error(`Primitive registry manifest not found: ${manifestPath}`);
-  }
-  const raw = fs4.readFileSync(manifestPath, "utf-8");
-  return YAML.parse(raw);
-}
-function syncPrimitiveRegistryManifest(workspacePath) {
-  const registry = loadRegistry(workspacePath);
-  const manifest = {
-    version: 1,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    primitives: Object.values(registry.types).map((primitive) => ({
-      name: primitive.name,
-      directory: primitive.directory,
-      canonical: primitive.builtIn,
-      builtIn: primitive.builtIn,
-      fields: Object.entries(primitive.fields).map(([name, field]) => ({
-        name,
-        type: field.type,
-        ...field.required ? { required: true } : {},
-        ...field.description ? { description: field.description } : {}
-      }))
-    })).sort((a, b) => a.name.localeCompare(b.name))
-  };
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  ensureDirectory(path4.dirname(manifestPath));
-  fs4.writeFileSync(manifestPath, YAML.stringify(manifest), "utf-8");
-  return manifest;
-}
-function generateBasesFromPrimitiveRegistry(workspacePath, options = {}) {
-  const manifest = readPrimitiveRegistryManifest(workspacePath);
-  const includeNonCanonical = options.includeNonCanonical === true;
-  const outputDirectory = path4.join(workspacePath, options.outputDirectory ?? DEFAULT_BASES_DIR);
-  ensureDirectory(outputDirectory);
-  const generated = [];
-  const primitives = manifest.primitives.filter(
-    (primitive) => includeNonCanonical ? true : primitive.canonical
-  );
-  for (const primitive of primitives) {
-    const relBasePath = `${primitive.name}.base`;
-    const absBasePath = path4.join(outputDirectory, relBasePath);
-    const content = renderBaseFile(primitive);
-    fs4.writeFileSync(absBasePath, content, "utf-8");
-    generated.push(path4.relative(workspacePath, absBasePath).replace(/\\/g, "/"));
-  }
-  return {
-    outputDirectory: path4.relative(workspacePath, outputDirectory).replace(/\\/g, "/"),
-    generated: generated.sort()
-  };
-}
-function renderBaseFile(primitive) {
-  const columnFields = primitive.fields.map((field) => field.name).filter((name, idx, arr) => arr.indexOf(name) === idx);
-  const baseDoc = {
-    id: primitive.name,
-    title: `${titleCase(primitive.name)} Base`,
-    source: {
-      type: "folder",
-      path: primitive.directory,
-      extension: "md"
-    },
-    views: [
-      {
-        id: "table",
-        type: "table",
-        name: "All",
-        columns: ["file.name", ...columnFields]
-      }
-    ]
-  };
-  return YAML.stringify(baseDoc);
-}
-function ensureDirectory(dirPath) {
-  if (!fs4.existsSync(dirPath)) fs4.mkdirSync(dirPath, { recursive: true });
-}
-function titleCase(value) {
-  return value.split(/[-_]/g).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join(" ");
-}
-
-// src/workspace.ts
-var WORKGRAPH_CONFIG_FILE = ".workgraph.json";
-function workspaceConfigPath(workspacePath) {
-  return path5.join(workspacePath, WORKGRAPH_CONFIG_FILE);
-}
-function isWorkgraphWorkspace(workspacePath) {
-  return fs5.existsSync(workspaceConfigPath(workspacePath));
-}
-function initWorkspace(targetPath, options = {}) {
-  const resolvedPath = path5.resolve(targetPath);
-  const configPath = workspaceConfigPath(resolvedPath);
-  if (fs5.existsSync(configPath)) {
-    throw new Error(`Workgraph workspace already initialized at ${resolvedPath}`);
-  }
-  const createdDirectories = [];
-  ensureDir(resolvedPath, createdDirectories);
-  ensureDir(path5.join(resolvedPath, ".clawvault"), createdDirectories);
-  const registry = loadRegistry(resolvedPath);
-  saveRegistry(resolvedPath, registry);
-  syncPrimitiveRegistryManifest(resolvedPath);
-  if (options.createTypeDirs !== false) {
-    const types = listTypes(resolvedPath);
-    for (const typeDef of types) {
-      ensureDir(path5.join(resolvedPath, typeDef.directory), createdDirectories);
-    }
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const config = {
-    name: options.name ?? path5.basename(resolvedPath),
-    version: "1.0.0",
-    mode: "workgraph",
-    createdAt: now,
-    updatedAt: now
-  };
-  fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  if (options.createReadme !== false) {
-    writeReadmeIfMissing(resolvedPath, config.name);
-  }
-  const bases = options.createBases === false ? { generated: [] } : generateBasesFromPrimitiveRegistry(resolvedPath);
-  return {
-    workspacePath: resolvedPath,
-    configPath,
-    config,
-    createdDirectories,
-    seededTypes: listTypes(resolvedPath).map((t) => t.name),
-    generatedBases: bases.generated,
-    primitiveRegistryManifestPath: ".clawvault/primitive-registry.yaml"
-  };
-}
-function ensureDir(dirPath, createdDirectories) {
-  if (fs5.existsSync(dirPath)) return;
-  fs5.mkdirSync(dirPath, { recursive: true });
-  createdDirectories.push(dirPath);
-}
-function writeReadmeIfMissing(workspacePath, name) {
-  const readmePath = path5.join(workspacePath, "README.md");
-  if (fs5.existsSync(readmePath)) return;
-  const content = `# ${name}
-
-Agent-first workgraph workspace for multi-agent coordination.
-
-## Quickstart
-
-\`\`\`bash
-workgraph thread list --json
-workgraph thread next --claim --actor agent-a --json
-workgraph ledger show --count 20 --json
-\`\`\`
-`;
-  fs5.writeFileSync(readmePath, content, "utf-8");
-}
-
-// src/command-center.ts
-var command_center_exports = {};
-__export(command_center_exports, {
-  generateCommandCenter: () => generateCommandCenter
-});
-import fs6 from "fs";
-import path6 from "path";
-function generateCommandCenter(workspacePath, options = {}) {
-  const actor = options.actor ?? "system";
-  const recentCount = options.recentCount ?? 15;
-  const relOutputPath = options.outputPath ?? "Command Center.md";
-  const absOutputPath = resolvePathWithinWorkspace(workspacePath, relOutputPath);
-  const normalizedOutputPath = path6.relative(workspacePath, absOutputPath).replace(/\\/g, "/");
-  const allThreads = list(workspacePath, "thread");
-  const openThreads2 = allThreads.filter((thread) => thread.fields.status === "open");
-  const activeThreads2 = allThreads.filter((thread) => thread.fields.status === "active");
-  const blockedThreads2 = allThreads.filter((thread) => thread.fields.status === "blocked");
-  const doneThreads = allThreads.filter((thread) => thread.fields.status === "done");
-  const claims = allClaims(workspacePath);
-  const recentEvents = recent(workspacePath, recentCount);
-  const content = renderCommandCenter({
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    openThreads: openThreads2,
-    activeThreads: activeThreads2,
-    blockedThreads: blockedThreads2,
-    doneThreads,
-    claims: [...claims.entries()].map(([target, owner]) => ({ target, owner })),
-    recentEvents
-  });
-  const parentDir = path6.dirname(absOutputPath);
-  if (!fs6.existsSync(parentDir)) fs6.mkdirSync(parentDir, { recursive: true });
-  const existed = fs6.existsSync(absOutputPath);
-  fs6.writeFileSync(absOutputPath, content, "utf-8");
-  append(
-    workspacePath,
-    actor,
-    existed ? "update" : "create",
-    normalizedOutputPath,
-    "command-center",
-    {
-      generated: true,
-      open_threads: openThreads2.length,
-      active_claims: claims.size,
-      recent_events: recentEvents.length
-    }
-  );
-  return {
-    outputPath: normalizedOutputPath,
-    stats: {
-      totalThreads: allThreads.length,
-      openThreads: openThreads2.length,
-      activeThreads: activeThreads2.length,
-      blockedThreads: blockedThreads2.length,
-      doneThreads: doneThreads.length,
-      activeClaims: claims.size,
-      recentEvents: recentEvents.length
-    },
-    content
-  };
-}
-function resolvePathWithinWorkspace(workspacePath, outputPath) {
-  const base = path6.resolve(workspacePath);
-  const resolved = path6.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path6.sep) && resolved !== base) {
-    throw new Error(`Invalid command-center output path: ${outputPath}`);
-  }
-  return resolved;
-}
-function renderCommandCenter(input) {
-  const header = [
-    "# Workgraph Command Center",
-    "",
-    `Generated: ${input.generatedAt}`,
-    ""
-  ];
-  const statusBlock = [
-    "## Thread Status",
-    "",
-    `- Open: ${input.openThreads.length}`,
-    `- Active: ${input.activeThreads.length}`,
-    `- Blocked: ${input.blockedThreads.length}`,
-    `- Done: ${input.doneThreads.length}`,
-    ""
-  ];
-  const openTable = [
-    "## Open Threads",
-    "",
-    "| Priority | Title | Path |",
-    "|---|---|---|",
-    ...input.openThreads.length > 0 ? input.openThreads.map((thread) => `| ${String(thread.fields.priority ?? "medium")} | ${String(thread.fields.title ?? "Untitled")} | \`${thread.path}\` |`) : ["| - | None | - |"],
-    ""
-  ];
-  const claimsSection = [
-    "## Active Claims",
-    "",
-    ...input.claims.length > 0 ? input.claims.map((claim2) => `- ${claim2.owner} -> \`${claim2.target}\``) : ["- None"],
-    ""
-  ];
-  const blockedSection = [
-    "## Blocked Threads",
-    "",
-    ...input.blockedThreads.length > 0 ? input.blockedThreads.map((thread) => {
-      const deps = Array.isArray(thread.fields.deps) ? thread.fields.deps.join(", ") : "";
-      return `- ${String(thread.fields.title ?? thread.path)} (\`${thread.path}\`)${deps ? ` blocked by: ${deps}` : ""}`;
-    }) : ["- None"],
-    ""
-  ];
-  const recentSection = [
-    "## Recent Ledger Activity",
-    "",
-    ...input.recentEvents.length > 0 ? input.recentEvents.map((event) => `- ${event.ts} ${event.op} ${event.actor} -> \`${event.target}\``) : ["- No activity"],
-    ""
-  ];
-  return [
-    ...header,
-    ...statusBlock,
-    ...openTable,
-    ...claimsSection,
-    ...blockedSection,
-    ...recentSection
-  ].join("\n");
-}
-
-// src/skill.ts
-var skill_exports = {};
-__export(skill_exports, {
-  listSkills: () => listSkills,
-  loadSkill: () => loadSkill,
-  promoteSkill: () => promoteSkill,
-  proposeSkill: () => proposeSkill,
-  writeSkill: () => writeSkill
-});
-function writeSkill(workspacePath, title, body, actor, options = {}) {
-  const relPath = pathForSkillTitle(title);
-  const existing = read(workspacePath, relPath);
-  const status = options.status ?? existing?.fields.status ?? "draft";
-  if (!existing) {
-    return create(workspacePath, "skill", {
-      title,
-      owner: options.owner ?? actor,
-      version: options.version ?? "0.1.0",
-      status,
-      distribution: options.distribution ?? "tailscale-shared-vault",
-      tailscale_path: options.tailscalePath,
-      reviewers: options.reviewers ?? [],
-      tags: options.tags ?? []
-    }, body, actor);
-  }
-  return update(workspacePath, existing.path, {
-    title,
-    owner: options.owner ?? existing.fields.owner ?? actor,
-    version: options.version ?? existing.fields.version ?? "0.1.0",
-    status,
-    distribution: options.distribution ?? existing.fields.distribution ?? "tailscale-shared-vault",
-    tailscale_path: options.tailscalePath ?? existing.fields.tailscale_path,
-    reviewers: options.reviewers ?? existing.fields.reviewers ?? [],
-    tags: options.tags ?? existing.fields.tags ?? []
-  }, body, actor);
-}
-function loadSkill(workspacePath, skillRef) {
-  const normalized = normalizeSkillRef(skillRef);
-  const skill = read(workspacePath, normalized);
-  if (!skill) throw new Error(`Skill not found: ${skillRef}`);
-  if (skill.type !== "skill") throw new Error(`Target is not a skill primitive: ${skillRef}`);
-  return skill;
-}
-function listSkills(workspacePath, options = {}) {
-  let skills = list(workspacePath, "skill");
-  if (options.status) {
-    skills = skills.filter((skill) => skill.fields.status === options.status);
-  }
-  return skills;
-}
-function proposeSkill(workspacePath, skillRef, actor, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  let proposalThread = options.proposalThread;
-  if (!proposalThread && options.createThreadIfMissing !== false) {
-    const createdThread = createThread(
-      workspacePath,
-      `Review skill: ${String(skill.fields.title)}`,
-      `Review and approve skill ${skill.path} for activation.`,
-      actor,
-      {
-        priority: "medium",
-        space: options.space,
-        context_refs: [skill.path]
-      }
-    );
-    proposalThread = createdThread.path;
-  }
-  return update(workspacePath, skill.path, {
-    status: "proposed",
-    proposal_thread: proposalThread ?? skill.fields.proposal_thread,
-    proposed_at: (/* @__PURE__ */ new Date()).toISOString(),
-    reviewers: options.reviewers ?? skill.fields.reviewers ?? []
-  }, void 0, actor);
-}
-function promoteSkill(workspacePath, skillRef, actor, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const currentVersion = String(skill.fields.version ?? "0.1.0");
-  const nextVersion = options.version ?? bumpPatchVersion(currentVersion);
-  return update(workspacePath, skill.path, {
-    status: "active",
-    version: nextVersion,
-    promoted_at: (/* @__PURE__ */ new Date()).toISOString()
-  }, void 0, actor);
-}
-function pathForSkillTitle(title) {
-  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
-  return `skills/${slug}.md`;
-}
-function normalizeSkillRef(skillRef) {
-  const raw = skillRef.trim();
-  if (!raw) return raw;
-  if (raw.includes("/")) {
-    return raw.endsWith(".md") ? raw : `${raw}.md`;
-  }
-  const slug = raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
-  return `skills/${slug}.md`;
-}
-function bumpPatchVersion(version) {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return "0.1.0";
-  const major = Number.parseInt(match[1], 10);
-  const minor = Number.parseInt(match[2], 10);
-  const patch = Number.parseInt(match[3], 10) + 1;
-  return `${major}.${minor}.${patch}`;
-}
-
-export {
-  THREAD_STATUS_TRANSITIONS,
-  ledger_exports,
-  registry_exports,
-  store_exports,
-  thread_exports,
-  bases_exports,
-  workspace_exports,
-  command_center_exports,
-  skill_exports
-};