@versatly/workgraph 0.2.0 → 1.0.0

package/dist/chunk-XUMA4O2Z.js

@@ -1,2817 +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 = ".workgraph/ledger.jsonl";
-var LEDGER_INDEX_FILE = ".workgraph/ledger-index.json";
-var LEDGER_CHAIN_FILE = ".workgraph/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 = ".workgraph/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",
-        enum: ["open", "active", "blocked", "done", "cancelled"],
-        description: "open | active | blocked | done | cancelled"
-      },
-      owner: { type: "string", description: "Agent that claimed this thread" },
-      priority: {
-        type: "string",
-        default: "medium",
-        enum: ["urgent", "high", "medium", "low"],
-        description: "urgent | high | medium | low"
-      },
-      deps: { type: "list", default: [], description: "Thread refs this depends on" },
-      parent: { type: "ref", refTypes: ["thread"], description: "Parent thread if decomposed from larger thread" },
-      space: { type: "ref", refTypes: ["space"], 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: "draft", enum: ["draft", "proposed", "approved", "active", "superseded", "reverted"], description: "draft | proposed | approved | 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", enum: ["draft", "proposed", "active", "deprecated", "archived"], description: "draft | proposed | active | deprecated | archived" },
-      version: { type: "string", default: "0.1.0", template: "semver", 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" },
-      depends_on: { type: "list", default: [], description: "Skill dependencies by slug or path" },
-      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 }
-    }
-  },
-  {
-    name: "onboarding",
-    description: "Agent or team onboarding lifecycle primitive.",
-    directory: "onboarding",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      actor: { type: "string", required: true },
-      status: { type: "string", default: "active", enum: ["active", "completed", "paused"] },
-      spaces: { type: "list", default: [] },
-      thread_refs: { type: "list", default: [] },
-      board: { type: "ref" },
-      command_center: { type: "ref" },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "policy",
-    description: "Governance policy primitive for approvals and guardrails.",
-    directory: "policies",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      status: { type: "string", default: "draft", enum: ["draft", "proposed", "approved", "active", "retired"] },
-      scope: { type: "string", default: "workspace" },
-      approvers: { type: "list", default: [] },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "incident",
-    description: "Incident coordination primitive with gated lifecycle.",
-    directory: "incidents",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      severity: { type: "string", default: "sev3", enum: ["sev0", "sev1", "sev2", "sev3", "sev4"] },
-      status: { type: "string", default: "draft", enum: ["draft", "proposed", "approved", "active", "resolved", "closed"] },
-      owner: { type: "string" },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "trigger",
-    description: "Event trigger contract with policy-aware activation.",
-    directory: "triggers",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      event: { type: "string", required: true },
-      status: { type: "string", default: "draft", enum: ["draft", "proposed", "approved", "active", "paused", "retired"] },
-      action: { type: "string", required: true },
-      idempotency_scope: { type: "string", default: "event+target" },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "checkpoint",
-    description: "Agent checkpoint/hand-off primitive for orientation continuity.",
-    directory: "checkpoints",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      actor: { type: "string", required: true },
-      summary: { type: "string", required: true },
-      next: { type: "list", default: [] },
-      blocked: { type: "list", default: [] },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] }
-    }
-  },
-  {
-    name: "run",
-    description: "Background agent run primitive with lifecycle state.",
-    directory: "runs",
-    builtIn: true,
-    createdAt: "2026-01-01T00:00:00.000Z",
-    createdBy: "system",
-    fields: {
-      title: { type: "string", required: true },
-      objective: { type: "string", required: true },
-      runtime: { type: "string", required: true },
-      status: { type: "string", required: true, default: "queued", enum: ["queued", "running", "succeeded", "failed", "cancelled"] },
-      run_id: { type: "string", required: true },
-      owner: { type: "string" },
-      created: { type: "date", required: true },
-      updated: { type: "date", required: true },
-      tags: { type: "list", default: [] }
-    }
-  }
-];
-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", ".workgraph/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 fs5 from "fs";
-import path5 from "path";
-import matter from "gray-matter";
-
-// src/graph.ts
-var graph_exports = {};
-__export(graph_exports, {
-  buildWikiLinkGraph: () => buildWikiLinkGraph,
-  graphHygieneReport: () => graphHygieneReport,
-  graphIndexPath: () => graphIndexPath,
-  graphNeighborhood: () => graphNeighborhood,
-  readWikiLinkGraphIndex: () => readWikiLinkGraphIndex,
-  refreshWikiLinkGraphIndex: () => refreshWikiLinkGraphIndex
-});
-import fs3 from "fs";
-import path3 from "path";
-var GRAPH_INDEX_FILE = ".workgraph/graph-index.json";
-function graphIndexPath(workspacePath) {
-  return path3.join(workspacePath, GRAPH_INDEX_FILE);
-}
-function buildWikiLinkGraph(workspacePath) {
-  const nodes = listMarkdownFiles(workspacePath);
-  const nodeSet = new Set(nodes);
-  const edges = [];
-  const backlinks = {};
-  const outDegree = /* @__PURE__ */ new Map();
-  const inDegree = /* @__PURE__ */ new Map();
-  const brokenLinks = [];
-  for (const node of nodes) {
-    const content = fs3.readFileSync(path3.join(workspacePath, node), "utf-8");
-    const links = extractWikiLinks(content);
-    outDegree.set(node, links.length);
-    for (const rawLink of links) {
-      const target = normalizeWikiRef(rawLink);
-      edges.push({ from: node, to: target });
-      if (!backlinks[target]) backlinks[target] = [];
-      backlinks[target].push(node);
-      inDegree.set(target, (inDegree.get(target) ?? 0) + 1);
-      if (!nodeSet.has(target) && !target.startsWith("http")) {
-        brokenLinks.push({ from: node, to: target });
-      }
-    }
-  }
-  const orphans = nodes.filter((node) => (outDegree.get(node) ?? 0) === 0 && (inDegree.get(node) ?? 0) === 0);
-  const hubs = nodes.map((node) => ({
-    node,
-    degree: (outDegree.get(node) ?? 0) + (inDegree.get(node) ?? 0)
-  })).filter((entry) => entry.degree > 0).sort((a, b) => b.degree - a.degree || a.node.localeCompare(b.node)).slice(0, 20);
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    nodes: nodes.sort(),
-    edges,
-    backlinks,
-    orphans: orphans.sort(),
-    brokenLinks,
-    hubs
-  };
-}
-function refreshWikiLinkGraphIndex(workspacePath) {
-  const graph = buildWikiLinkGraph(workspacePath);
-  const indexPath = graphIndexPath(workspacePath);
-  const dir = path3.dirname(indexPath);
-  if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
-  fs3.writeFileSync(indexPath, JSON.stringify(graph, null, 2) + "\n", "utf-8");
-  return graph;
-}
-function readWikiLinkGraphIndex(workspacePath) {
-  const indexPath = graphIndexPath(workspacePath);
-  if (!fs3.existsSync(indexPath)) return null;
-  try {
-    const raw = fs3.readFileSync(indexPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function graphHygieneReport(workspacePath) {
-  const graph = buildWikiLinkGraph(workspacePath);
-  return {
-    generatedAt: graph.generatedAt,
-    nodeCount: graph.nodes.length,
-    edgeCount: graph.edges.length,
-    orphanCount: graph.orphans.length,
-    brokenLinkCount: graph.brokenLinks.length,
-    hubs: graph.hubs,
-    orphans: graph.orphans,
-    brokenLinks: graph.brokenLinks
-  };
-}
-function graphNeighborhood(workspacePath, nodeRef, options = {}) {
-  const graph = options.refresh ? refreshWikiLinkGraphIndex(workspacePath) : readWikiLinkGraphIndex(workspacePath) ?? buildWikiLinkGraph(workspacePath);
-  const node = normalizeWikiRef(nodeRef);
-  const outgoing = graph.edges.filter((edge) => edge.from === node).map((edge) => edge.to).sort();
-  const incoming = (graph.backlinks[node] ?? []).slice().sort();
-  return {
-    node,
-    exists: graph.nodes.includes(node),
-    outgoing,
-    incoming
-  };
-}
-function listMarkdownFiles(workspacePath) {
-  const output = [];
-  const stack = [workspacePath];
-  const ignoredDirs = /* @__PURE__ */ new Set([".git", "node_modules", "dist"]);
-  while (stack.length > 0) {
-    const current = stack.pop();
-    const entries = fs3.readdirSync(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const absPath = path3.join(current, entry.name);
-      const relPath = path3.relative(workspacePath, absPath).replace(/\\/g, "/");
-      if (entry.isDirectory()) {
-        if (ignoredDirs.has(entry.name)) continue;
-        stack.push(absPath);
-        continue;
-      }
-      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      output.push(relPath);
-    }
-  }
-  return output;
-}
-function extractWikiLinks(content) {
-  const matches = content.matchAll(/\[\[([^[\]]+)\]\]/g);
-  const refs = [];
-  for (const match of matches) {
-    if (match[1]) refs.push(match[1].trim());
-  }
-  return refs;
-}
-function normalizeWikiRef(rawRef) {
-  const primary = rawRef.split("|")[0].trim();
-  if (!primary) return primary;
-  if (/^https?:\/\//i.test(primary)) return primary;
-  return primary.endsWith(".md") ? primary : `${primary}.md`;
-}
-
-// src/policy.ts
-var policy_exports = {};
-__export(policy_exports, {
-  canTransitionStatus: () => canTransitionStatus,
-  getParty: () => getParty,
-  loadPolicyRegistry: () => loadPolicyRegistry,
-  policyPath: () => policyPath,
-  savePolicyRegistry: () => savePolicyRegistry,
-  upsertParty: () => upsertParty
-});
-import fs4 from "fs";
-import path4 from "path";
-var POLICY_FILE = ".workgraph/policy.json";
-var POLICY_VERSION = 1;
-var SENSITIVE_TYPES = /* @__PURE__ */ new Set(["decision", "policy", "incident", "trigger"]);
-function policyPath(workspacePath) {
-  return path4.join(workspacePath, POLICY_FILE);
-}
-function loadPolicyRegistry(workspacePath) {
-  const pPath = policyPath(workspacePath);
-  if (!fs4.existsSync(pPath)) {
-    const seeded = seedPolicyRegistry();
-    savePolicyRegistry(workspacePath, seeded);
-    return seeded;
-  }
-  try {
-    const raw = fs4.readFileSync(pPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.version || !parsed.parties) {
-      return seedPolicyRegistry();
-    }
-    return parsed;
-  } catch {
-    return seedPolicyRegistry();
-  }
-}
-function savePolicyRegistry(workspacePath, registry) {
-  const pPath = policyPath(workspacePath);
-  const dir = path4.dirname(pPath);
-  if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-  fs4.writeFileSync(pPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
-}
-function upsertParty(workspacePath, partyId, updates) {
-  const registry = loadPolicyRegistry(workspacePath);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = registry.parties[partyId];
-  const next = {
-    id: partyId,
-    roles: updates.roles ?? existing?.roles ?? [],
-    capabilities: updates.capabilities ?? existing?.capabilities ?? [],
-    createdAt: existing?.createdAt ?? now,
-    updatedAt: now
-  };
-  registry.parties[partyId] = next;
-  savePolicyRegistry(workspacePath, registry);
-  return next;
-}
-function getParty(workspacePath, partyId) {
-  const registry = loadPolicyRegistry(workspacePath);
-  return registry.parties[partyId] ?? null;
-}
-function canTransitionStatus(workspacePath, actor, primitiveType, fromStatus, toStatus) {
-  if (!fromStatus || !toStatus || fromStatus === toStatus) {
-    return { allowed: true };
-  }
-  if (!SENSITIVE_TYPES.has(primitiveType)) {
-    return { allowed: true };
-  }
-  if (actor === "system") {
-    return { allowed: true };
-  }
-  const needsPromotionCapability = ["approved", "active"].includes(toStatus);
-  if (!needsPromotionCapability) {
-    return { allowed: true };
-  }
-  const party = getParty(workspacePath, actor);
-  if (!party) {
-    return {
-      allowed: false,
-      reason: `Policy gate blocked transition ${primitiveType}:${fromStatus}->${toStatus}; actor "${actor}" is not a registered party.`
-    };
-  }
-  const requiredCapabilities = [
-    `promote:${primitiveType}`,
-    "promote:sensitive"
-  ];
-  const hasCapability = requiredCapabilities.some((cap) => party.capabilities.includes(cap));
-  if (!hasCapability) {
-    return {
-      allowed: false,
-      reason: `Policy gate blocked transition ${primitiveType}:${fromStatus}->${toStatus}; actor "${actor}" lacks required capabilities (${requiredCapabilities.join(" or ")}).`
-    };
-  }
-  return { allowed: true };
-}
-function seedPolicyRegistry() {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    version: POLICY_VERSION,
-    parties: {
-      system: {
-        id: "system",
-        roles: ["admin"],
-        capabilities: ["promote:sensitive", "dispatch:run", "policy:manage"],
-        createdAt: now,
-        updatedAt: now
-      }
-    }
-  };
-}
-
-// src/store.ts
-function create(workspacePath, typeName, fields, body, actor, options = {}) {
-  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
-  });
-  const initialStatus = typeof merged.status === "string" ? String(merged.status) : void 0;
-  const createPolicyDecision = canTransitionStatus(
-    workspacePath,
-    actor,
-    typeName,
-    "draft",
-    initialStatus ?? "draft"
-  );
-  if (!createPolicyDecision.allowed) {
-    throw new Error(createPolicyDecision.reason ?? "Policy gate blocked create transition.");
-  }
-  validateFields(workspacePath, typeDef, merged, "create");
-  const relDir = typeDef.directory;
-  const slug = slugify(String(merged.title ?? merged.name ?? typeName));
-  const relPath = resolveCreatePath(relDir, slug, options.pathOverride);
-  const absDir = path5.dirname(path5.join(workspacePath, relPath));
-  const absPath = path5.join(workspacePath, relPath);
-  if (!fs5.existsSync(absDir)) fs5.mkdirSync(absDir, { recursive: true });
-  if (fs5.existsSync(absPath)) {
-    throw new Error(`File already exists: ${relPath}. Use update instead.`);
-  }
-  const content = matter.stringify(body, stripUndefined(merged));
-  fs5.writeFileSync(absPath, content, "utf-8");
-  append(workspacePath, actor, "create", relPath, typeName, {
-    title: merged.title ?? slug,
-    ...typeof merged.status === "string" ? { status: merged.status } : {}
-  });
-  refreshWikiLinkGraphIndex(workspacePath);
-  return { path: relPath, type: typeName, fields: merged, body };
-}
-function read(workspacePath, relPath) {
-  const absPath = path5.join(workspacePath, relPath);
-  if (!fs5.existsSync(absPath)) return null;
-  const raw = fs5.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 = path5.join(workspacePath, typeDef.directory);
-  if (!fs5.existsSync(dir)) return [];
-  const files = listMarkdownFilesRecursive(dir);
-  const instances = [];
-  for (const file of files) {
-    const relPath = path5.relative(workspacePath, file).replace(/\\/g, "/");
-    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}`);
-  const previousStatus = typeof existing.fields["status"] === "string" ? String(existing.fields["status"]) : void 0;
-  const nextStatus = typeof newFields["status"] === "string" ? String(newFields["status"]) : void 0;
-  const transitionDecision = canTransitionStatus(
-    workspacePath,
-    actor,
-    existing.type,
-    previousStatus,
-    nextStatus
-  );
-  if (!transitionDecision.allowed) {
-    throw new Error(transitionDecision.reason ?? "Policy gate blocked status transition.");
-  }
-  validateFields(workspacePath, typeDef, newFields, "update");
-  const newBody = bodyUpdate ?? existing.body;
-  const absPath = path5.join(workspacePath, relPath);
-  const content = matter.stringify(newBody, stripUndefined(newFields));
-  fs5.writeFileSync(absPath, content, "utf-8");
-  append(workspacePath, actor, "update", relPath, existing.type, {
-    changed: Object.keys(fieldUpdates),
-    ...previousStatus !== nextStatus && nextStatus ? {
-      from_status: previousStatus ?? null,
-      to_status: nextStatus
-    } : {}
-  });
-  refreshWikiLinkGraphIndex(workspacePath);
-  return { path: relPath, type: existing.type, fields: newFields, body: newBody };
-}
-function remove(workspacePath, relPath, actor) {
-  const absPath = path5.join(workspacePath, relPath);
-  if (!fs5.existsSync(absPath)) throw new Error(`Not found: ${relPath}`);
-  const archiveDir = path5.join(workspacePath, ".workgraph", "archive");
-  if (!fs5.existsSync(archiveDir)) fs5.mkdirSync(archiveDir, { recursive: true });
-  const archivePath = path5.join(archiveDir, path5.basename(relPath));
-  fs5.renameSync(absPath, archivePath);
-  const typeName = inferType(workspacePath, relPath);
-  append(workspacePath, actor, "delete", relPath, typeName);
-  refreshWikiLinkGraphIndex(workspacePath);
-}
-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 resolveCreatePath(directory, slug, pathOverride) {
-  if (!pathOverride) {
-    return `${directory}/${slug}.md`;
-  }
-  const normalized = pathOverride.replace(/\\/g, "/").replace(/^\.\//, "");
-  const withExtension = normalized.endsWith(".md") ? normalized : `${normalized}.md`;
-  if (!withExtension.startsWith(`${directory}/`)) {
-    throw new Error(`Invalid create path override "${pathOverride}". Must stay under "${directory}/".`);
-  }
-  return withExtension;
-}
-function listMarkdownFilesRecursive(rootDir) {
-  const output = [];
-  const stack = [rootDir];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    const entries = fs5.readdirSync(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const absPath = path5.join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(absPath);
-        continue;
-      }
-      if (entry.isFile() && entry.name.endsWith(".md")) {
-        output.push(absPath);
-      }
-    }
-  }
-  return output;
-}
-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(workspacePath, 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)}`);
-      continue;
-    }
-    if (definition.enum && definition.enum.length > 0 && !definition.enum.includes(value)) {
-      issues.push(`Field "${fieldName}" must be one of [${definition.enum.join(", ")}]`);
-      continue;
-    }
-    if (definition.template && typeof value === "string" && !matchesTemplate(definition.template, value)) {
-      issues.push(`Field "${fieldName}" does not satisfy template "${definition.template}"`);
-      continue;
-    }
-    if (definition.pattern && typeof value === "string") {
-      let expression;
-      try {
-        expression = new RegExp(definition.pattern);
-      } catch {
-        issues.push(`Field "${fieldName}" has invalid pattern "${definition.pattern}"`);
-        continue;
-      }
-      if (!expression.test(value)) {
-        issues.push(`Field "${fieldName}" does not match pattern "${definition.pattern}"`);
-        continue;
-      }
-    }
-    if (definition.type === "ref" && typeof value === "string") {
-      const refValidation = validateRefValue(workspacePath, value, definition.refTypes);
-      if (!refValidation.ok) {
-        issues.push(refValidation.reason);
-        continue;
-      }
-    }
-  }
-  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":
-      return typeof value === "string";
-    case "date":
-      return typeof value === "string" && isDateString(value);
-    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;
-}
-function matchesTemplate(template, value) {
-  switch (template) {
-    case "slug":
-      return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
-    case "semver":
-      return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value);
-    case "email":
-      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
-    case "url":
-      try {
-        const url = new URL(value);
-        return url.protocol === "http:" || url.protocol === "https:";
-      } catch {
-        return false;
-      }
-    case "iso-date":
-      return isDateString(value);
-    default:
-      return true;
-  }
-}
-function isDateString(value) {
-  const timestamp = Date.parse(value);
-  return Number.isFinite(timestamp);
-}
-function validateRefValue(workspacePath, rawRef, allowedTypes) {
-  const normalized = normalizeRefPath(rawRef);
-  if (normalized.startsWith("external/")) {
-    return { ok: true };
-  }
-  const target = read(workspacePath, normalized);
-  if (!target && allowedTypes && allowedTypes.length > 0) {
-    const refDir = normalized.split("/")[0];
-    const registry = loadRegistry(workspacePath);
-    const allowedDirs = allowedTypes.map((typeName) => registry.types[typeName]?.directory).filter((dirName) => !!dirName);
-    if (allowedDirs.includes(refDir)) {
-      return { ok: true };
-    }
-  }
-  if (!target) {
-    return { ok: false, reason: `Reference target not found: ${normalized}` };
-  }
-  if (allowedTypes && allowedTypes.length > 0 && !allowedTypes.includes(target.type)) {
-    return {
-      ok: false,
-      reason: `Reference ${normalized} has type "${target.type}" but allowed types are [${allowedTypes.join(", ")}]`
-    };
-  }
-  return { ok: true };
-}
-
-// 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 status2 = thread.fields.status;
-  if (status2 !== "open") {
-    throw new Error(`Cannot claim thread in "${status2}" 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 fs7 from "fs";
-import path7 from "path";
-
-// src/bases.ts
-var bases_exports = {};
-__export(bases_exports, {
-  generateBasesFromPrimitiveRegistry: () => generateBasesFromPrimitiveRegistry,
-  primitiveRegistryManifestPath: () => primitiveRegistryManifestPath,
-  readPrimitiveRegistryManifest: () => readPrimitiveRegistryManifest,
-  syncPrimitiveRegistryManifest: () => syncPrimitiveRegistryManifest
-});
-import fs6 from "fs";
-import path6 from "path";
-import YAML from "yaml";
-var REGISTRY_MANIFEST_FILE = ".workgraph/primitive-registry.yaml";
-var DEFAULT_BASES_DIR = ".workgraph/bases";
-function primitiveRegistryManifestPath(workspacePath) {
-  return path6.join(workspacePath, REGISTRY_MANIFEST_FILE);
-}
-function readPrimitiveRegistryManifest(workspacePath) {
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  if (!fs6.existsSync(manifestPath)) {
-    throw new Error(`Primitive registry manifest not found: ${manifestPath}`);
-  }
-  const raw = fs6.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(path6.dirname(manifestPath));
-  fs6.writeFileSync(manifestPath, YAML.stringify(manifest), "utf-8");
-  return manifest;
-}
-function generateBasesFromPrimitiveRegistry(workspacePath, options = {}) {
-  const manifest = readPrimitiveRegistryManifest(workspacePath);
-  const includeNonCanonical = options.includeNonCanonical === true;
-  const outputDirectory = path6.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 = path6.join(outputDirectory, relBasePath);
-    const content = renderBaseFile(primitive);
-    fs6.writeFileSync(absBasePath, content, "utf-8");
-    generated.push(path6.relative(workspacePath, absBasePath).replace(/\\/g, "/"));
-  }
-  return {
-    outputDirectory: path6.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 (!fs6.existsSync(dirPath)) fs6.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 path7.join(workspacePath, WORKGRAPH_CONFIG_FILE);
-}
-function isWorkgraphWorkspace(workspacePath) {
-  return fs7.existsSync(workspaceConfigPath(workspacePath));
-}
-function initWorkspace(targetPath, options = {}) {
-  const resolvedPath = path7.resolve(targetPath);
-  const configPath = workspaceConfigPath(resolvedPath);
-  if (fs7.existsSync(configPath)) {
-    throw new Error(`Workgraph workspace already initialized at ${resolvedPath}`);
-  }
-  const createdDirectories = [];
-  ensureDir(resolvedPath, createdDirectories);
-  ensureDir(path7.join(resolvedPath, ".workgraph"), createdDirectories);
-  const registry = loadRegistry(resolvedPath);
-  saveRegistry(resolvedPath, registry);
-  syncPrimitiveRegistryManifest(resolvedPath);
-  if (options.createTypeDirs !== false) {
-    const types = listTypes(resolvedPath);
-    for (const typeDef of types) {
-      ensureDir(path7.join(resolvedPath, typeDef.directory), createdDirectories);
-    }
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const config = {
-    name: options.name ?? path7.basename(resolvedPath),
-    version: "1.0.0",
-    mode: "workgraph",
-    createdAt: now,
-    updatedAt: now
-  };
-  fs7.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);
-  loadPolicyRegistry(resolvedPath);
-  refreshWikiLinkGraphIndex(resolvedPath);
-  return {
-    workspacePath: resolvedPath,
-    configPath,
-    config,
-    createdDirectories,
-    seededTypes: listTypes(resolvedPath).map((t) => t.name),
-    generatedBases: bases.generated,
-    primitiveRegistryManifestPath: ".workgraph/primitive-registry.yaml"
-  };
-}
-function ensureDir(dirPath, createdDirectories) {
-  if (fs7.existsSync(dirPath)) return;
-  fs7.mkdirSync(dirPath, { recursive: true });
-  createdDirectories.push(dirPath);
-}
-function writeReadmeIfMissing(workspacePath, name) {
-  const readmePath = path7.join(workspacePath, "README.md");
-  if (fs7.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
-\`\`\`
-`;
-  fs7.writeFileSync(readmePath, content, "utf-8");
-}
-
-// src/command-center.ts
-var command_center_exports = {};
-__export(command_center_exports, {
-  generateCommandCenter: () => generateCommandCenter
-});
-import fs8 from "fs";
-import path8 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 = path8.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 = path8.dirname(absOutputPath);
-  if (!fs8.existsSync(parentDir)) fs8.mkdirSync(parentDir, { recursive: true });
-  const existed = fs8.existsSync(absOutputPath);
-  fs8.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 = path8.resolve(workspacePath);
-  const resolved = path8.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path8.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,
-  skillDiff: () => skillDiff,
-  skillHistory: () => skillHistory,
-  writeSkill: () => writeSkill
-});
-import fs9 from "fs";
-import path9 from "path";
-function writeSkill(workspacePath, title, body, actor, options = {}) {
-  const slug = skillSlug(title);
-  const bundleSkillPath = folderSkillPath(slug);
-  const legacyPath = legacySkillPath(slug);
-  const existing = read(workspacePath, bundleSkillPath) ?? read(workspacePath, legacyPath);
-  const status2 = options.status ?? existing?.fields.status ?? "draft";
-  if (existing && options.expectedUpdatedAt) {
-    const currentUpdatedAt = String(existing.fields.updated ?? "");
-    if (currentUpdatedAt !== options.expectedUpdatedAt) {
-      throw new Error(`Concurrent skill update detected for ${existing.path}. Expected updated="${options.expectedUpdatedAt}" but found "${currentUpdatedAt}".`);
-    }
-  }
-  if (!existing) {
-    ensureSkillBundleScaffold(workspacePath, slug);
-    const created = create(workspacePath, "skill", {
-      title,
-      owner: options.owner ?? actor,
-      version: options.version ?? "0.1.0",
-      status: status2,
-      distribution: options.distribution ?? "tailscale-shared-vault",
-      tailscale_path: options.tailscalePath,
-      reviewers: options.reviewers ?? [],
-      depends_on: options.dependsOn ?? [],
-      tags: options.tags ?? []
-    }, body, actor, {
-      pathOverride: bundleSkillPath
-    });
-    writeSkillManifest(workspacePath, slug, created, actor);
-    return created;
-  }
-  const updated = update(workspacePath, existing.path, {
-    title,
-    owner: options.owner ?? existing.fields.owner ?? actor,
-    version: options.version ?? existing.fields.version ?? "0.1.0",
-    status: status2,
-    distribution: options.distribution ?? existing.fields.distribution ?? "tailscale-shared-vault",
-    tailscale_path: options.tailscalePath ?? existing.fields.tailscale_path,
-    reviewers: options.reviewers ?? existing.fields.reviewers ?? [],
-    depends_on: options.dependsOn ?? existing.fields.depends_on ?? [],
-    tags: options.tags ?? existing.fields.tags ?? []
-  }, body, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-function loadSkill(workspacePath, skillRef) {
-  const normalizedCandidates = normalizeSkillRefCandidates(skillRef);
-  const skill = normalizedCandidates.map((candidate) => read(workspacePath, candidate)).find((entry) => entry !== null);
-  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);
-  }
-  if (options.updatedSince) {
-    const threshold = Date.parse(options.updatedSince);
-    if (Number.isFinite(threshold)) {
-      skills = skills.filter((skill) => {
-        const updatedAt = Date.parse(String(skill.fields.updated ?? ""));
-        return Number.isFinite(updatedAt) && updatedAt >= threshold;
-      });
-    }
-  }
-  return skills;
-}
-function proposeSkill(workspacePath, skillRef, actor, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const slug = skillSlug(String(skill.fields.title ?? 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;
-  }
-  const updated = 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);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-function skillHistory(workspacePath, skillRef, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const entries = historyOf(workspacePath, skill.path);
-  if (options.limit && options.limit > 0) {
-    return entries.slice(-options.limit);
-  }
-  return entries;
-}
-function skillDiff(workspacePath, skillRef) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const entries = historyOf(workspacePath, skill.path).filter((entry) => entry.op === "create" || entry.op === "update");
-  const latest = entries.length > 0 ? entries[entries.length - 1] : null;
-  const previous = entries.length > 1 ? entries[entries.length - 2] : null;
-  const changedFields = Array.isArray(latest?.data?.changed) ? latest.data.changed.map((value) => String(value)) : latest?.op === "create" ? Object.keys(skill.fields) : [];
-  return {
-    path: skill.path,
-    latestEntryTs: latest?.ts ?? null,
-    previousEntryTs: previous?.ts ?? null,
-    changedFields
-  };
-}
-function promoteSkill(workspacePath, skillRef, actor, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const slug = skillSlug(String(skill.fields.title ?? skillRef));
-  const currentVersion = String(skill.fields.version ?? "0.1.0");
-  const nextVersion = options.version ?? bumpPatchVersion(currentVersion);
-  const updated = update(workspacePath, skill.path, {
-    status: "active",
-    version: nextVersion,
-    promoted_at: (/* @__PURE__ */ new Date()).toISOString()
-  }, void 0, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-function skillSlug(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
-}
-function normalizeSkillRefCandidates(skillRef) {
-  const raw = skillRef.trim();
-  if (!raw) return [];
-  if (raw.includes("/")) {
-    const normalized = raw.endsWith(".md") ? raw : `${raw}.md`;
-    if (normalized.endsWith("/SKILL.md")) return [normalized];
-    if (normalized.endsWith("/SKILL")) return [`${normalized}.md`];
-    if (normalized.endsWith(".md")) {
-      const noExt = normalized.slice(0, -3);
-      return [normalized, `${noExt}/SKILL.md`];
-    }
-    return [normalized, `${normalized}/SKILL.md`];
-  }
-  const slug = skillSlug(raw);
-  return [folderSkillPath(slug), legacySkillPath(slug)];
-}
-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}`;
-}
-function folderSkillPath(slug) {
-  return `skills/${slug}/SKILL.md`;
-}
-function legacySkillPath(slug) {
-  return `skills/${slug}.md`;
-}
-function ensureSkillBundleScaffold(workspacePath, slug) {
-  const skillRoot = path9.join(workspacePath, "skills", slug);
-  fs9.mkdirSync(skillRoot, { recursive: true });
-  for (const subdir of ["scripts", "examples", "tests", "assets"]) {
-    fs9.mkdirSync(path9.join(skillRoot, subdir), { recursive: true });
-  }
-}
-function writeSkillManifest(workspacePath, slug, skill, actor) {
-  const manifestPath = path9.join(workspacePath, "skills", slug, "skill-manifest.json");
-  const dir = path9.dirname(manifestPath);
-  fs9.mkdirSync(dir, { recursive: true });
-  const manifest = {
-    version: 1,
-    slug,
-    title: String(skill.fields.title ?? slug),
-    primitivePath: skill.path,
-    owner: String(skill.fields.owner ?? actor),
-    skillVersion: String(skill.fields.version ?? "0.1.0"),
-    status: String(skill.fields.status ?? "draft"),
-    dependsOn: Array.isArray(skill.fields.depends_on) ? skill.fields.depends_on.map((value) => String(value)) : [],
-    components: {
-      skillDoc: "SKILL.md",
-      scriptsDir: "scripts/",
-      examplesDir: "examples/",
-      testsDir: "tests/",
-      assetsDir: "assets/"
-    },
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs9.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
-}
-
-// src/query.ts
-var query_exports = {};
-__export(query_exports, {
-  keywordSearch: () => keywordSearch,
-  queryPrimitives: () => queryPrimitives
-});
-function queryPrimitives(workspacePath, filters = {}) {
-  const typeNames = filters.type ? [filters.type] : listTypes(workspacePath).map((type) => type.name);
-  const all = typeNames.flatMap((typeName) => list(workspacePath, typeName));
-  const matched = all.filter((instance) => matchesFilters(instance, filters));
-  const offset = Math.max(0, filters.offset ?? 0);
-  const limited = filters.limit && filters.limit >= 0 ? matched.slice(offset, offset + filters.limit) : matched.slice(offset);
-  return limited;
-}
-function keywordSearch(workspacePath, text, filters = {}) {
-  return queryPrimitives(workspacePath, {
-    ...filters,
-    text
-  });
-}
-function matchesFilters(instance, filters) {
-  if (filters.status && String(instance.fields.status ?? "") !== filters.status) return false;
-  if (filters.owner && String(instance.fields.owner ?? "") !== filters.owner) return false;
-  if (filters.tag && !hasTag(instance, filters.tag)) return false;
-  if (filters.pathIncludes && !instance.path.includes(filters.pathIncludes)) return false;
-  if (filters.updatedAfter && !isDateOnOrAfter(instance.fields.updated, filters.updatedAfter)) return false;
-  if (filters.updatedBefore && !isDateOnOrBefore(instance.fields.updated, filters.updatedBefore)) return false;
-  if (filters.createdAfter && !isDateOnOrAfter(instance.fields.created, filters.createdAfter)) return false;
-  if (filters.createdBefore && !isDateOnOrBefore(instance.fields.created, filters.createdBefore)) return false;
-  if (filters.text && !containsText(instance, filters.text)) return false;
-  return true;
-}
-function hasTag(instance, tag) {
-  const tags = instance.fields.tags;
-  if (!Array.isArray(tags)) return false;
-  return tags.map((value) => String(value)).includes(tag);
-}
-function containsText(instance, text) {
-  const haystack = [
-    instance.path,
-    instance.type,
-    stringifyFields(instance.fields),
-    instance.body
-  ].join("\n").toLowerCase();
-  return haystack.includes(text.toLowerCase());
-}
-function stringifyFields(fields) {
-  try {
-    return JSON.stringify(fields);
-  } catch {
-    return "";
-  }
-}
-function isDateOnOrAfter(value, thresholdIso) {
-  const ts = Date.parse(String(value ?? ""));
-  const threshold = Date.parse(thresholdIso);
-  if (!Number.isFinite(ts) || !Number.isFinite(threshold)) return false;
-  return ts >= threshold;
-}
-function isDateOnOrBefore(value, thresholdIso) {
-  const ts = Date.parse(String(value ?? ""));
-  const threshold = Date.parse(thresholdIso);
-  if (!Number.isFinite(ts) || !Number.isFinite(threshold)) return false;
-  return ts <= threshold;
-}
-
-// src/orientation.ts
-var orientation_exports = {};
-__export(orientation_exports, {
-  brief: () => brief,
-  checkpoint: () => checkpoint,
-  intake: () => intake,
-  statusSnapshot: () => statusSnapshot
-});
-function statusSnapshot(workspacePath) {
-  const threads = list(workspacePath, "thread");
-  const allPrimitives = queryPrimitives(workspacePath);
-  const byType = allPrimitives.reduce((acc, instance) => {
-    acc[instance.type] = (acc[instance.type] ?? 0) + 1;
-    return acc;
-  }, {});
-  const claims = allClaims(workspacePath);
-  const ready = listReadyThreads(workspacePath);
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    threads: {
-      total: threads.length,
-      open: threads.filter((item) => item.fields.status === "open").length,
-      active: threads.filter((item) => item.fields.status === "active").length,
-      blocked: threads.filter((item) => item.fields.status === "blocked").length,
-      done: threads.filter((item) => item.fields.status === "done").length,
-      cancelled: threads.filter((item) => item.fields.status === "cancelled").length,
-      ready: ready.length
-    },
-    claims: {
-      active: claims.size
-    },
-    primitives: {
-      total: allPrimitives.length,
-      byType
-    }
-  };
-}
-function brief(workspacePath, actor, options = {}) {
-  const myClaims = [...allClaims(workspacePath).entries()].filter(([, owner]) => owner === actor).map(([target]) => read(workspacePath, target)).filter((instance) => instance !== null);
-  const myOpenThreads = queryPrimitives(workspacePath, {
-    type: "thread",
-    owner: actor
-  }).filter((instance) => ["open", "active"].includes(String(instance.fields.status)));
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    actor,
-    myClaims,
-    myOpenThreads,
-    blockedThreads: blockedThreads(workspacePath),
-    nextReadyThreads: listReadyThreads(workspacePath).slice(0, options.nextCount ?? 5),
-    recentActivity: recent(workspacePath, options.recentCount ?? 12)
-  };
-}
-function checkpoint(workspacePath, actor, summary, options = {}) {
-  const title = `Checkpoint ${(/* @__PURE__ */ new Date()).toISOString()}`;
-  const bodyLines = [
-    "## Summary",
-    "",
-    summary,
-    "",
-    "## Next",
-    "",
-    ...options.next && options.next.length > 0 ? options.next.map((item) => `- ${item}`) : ["- None"],
-    "",
-    "## Blocked",
-    "",
-    ...options.blocked && options.blocked.length > 0 ? options.blocked.map((item) => `- ${item}`) : ["- None"],
-    ""
-  ];
-  return create(
-    workspacePath,
-    "checkpoint",
-    {
-      title,
-      actor,
-      summary,
-      next: options.next ?? [],
-      blocked: options.blocked ?? [],
-      tags: options.tags ?? []
-    },
-    bodyLines.join("\n"),
-    actor
-  );
-}
-function intake(workspacePath, actor, observation, options = {}) {
-  return checkpoint(workspacePath, actor, observation, {
-    tags: ["intake", ...options.tags ?? []]
-  });
-}
-
-// src/board.ts
-var board_exports = {};
-__export(board_exports, {
-  generateKanbanBoard: () => generateKanbanBoard,
-  syncKanbanBoard: () => syncKanbanBoard
-});
-import fs10 from "fs";
-import path10 from "path";
-function generateKanbanBoard(workspacePath, options = {}) {
-  const threads = list(workspacePath, "thread");
-  const grouped = groupThreads(threads);
-  const includeCancelled = options.includeCancelled === true;
-  const lanes = [
-    { title: "Backlog", items: grouped.open, checkChar: " " },
-    { title: "In Progress", items: grouped.active, checkChar: " " },
-    { title: "Blocked", items: grouped.blocked, checkChar: " " },
-    { title: "Done", items: grouped.done, checkChar: "x" }
-  ];
-  if (includeCancelled) {
-    lanes.push({ title: "Cancelled", items: grouped.cancelled, checkChar: "x" });
-  }
-  const content = renderKanbanMarkdown(lanes);
-  const relOutputPath = options.outputPath ?? "ops/Workgraph Board.md";
-  const absOutputPath = resolvePathWithinWorkspace2(workspacePath, relOutputPath);
-  const parentDir = path10.dirname(absOutputPath);
-  if (!fs10.existsSync(parentDir)) fs10.mkdirSync(parentDir, { recursive: true });
-  fs10.writeFileSync(absOutputPath, content, "utf-8");
-  return {
-    outputPath: path10.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    counts: {
-      backlog: grouped.open.length,
-      inProgress: grouped.active.length,
-      blocked: grouped.blocked.length,
-      done: grouped.done.length,
-      cancelled: grouped.cancelled.length
-    },
-    content
-  };
-}
-function syncKanbanBoard(workspacePath, options = {}) {
-  return generateKanbanBoard(workspacePath, options);
-}
-function groupThreads(threads) {
-  const groups = {
-    open: [],
-    active: [],
-    blocked: [],
-    done: [],
-    cancelled: []
-  };
-  for (const thread of threads) {
-    const status2 = String(thread.fields.status ?? "open");
-    switch (status2) {
-      case "active":
-        groups.active.push(thread);
-        break;
-      case "blocked":
-        groups.blocked.push(thread);
-        break;
-      case "done":
-        groups.done.push(thread);
-        break;
-      case "cancelled":
-        groups.cancelled.push(thread);
-        break;
-      case "open":
-      default:
-        groups.open.push(thread);
-        break;
-    }
-  }
-  const byPriority = (a, b) => {
-    const rank = (value) => {
-      switch (String(value ?? "medium")) {
-        case "urgent":
-          return 0;
-        case "high":
-          return 1;
-        case "medium":
-          return 2;
-        case "low":
-          return 3;
-        default:
-          return 4;
-      }
-    };
-    return rank(a.fields.priority) - rank(b.fields.priority) || String(a.fields.title).localeCompare(String(b.fields.title));
-  };
-  groups.open.sort(byPriority);
-  groups.active.sort(byPriority);
-  groups.blocked.sort(byPriority);
-  groups.done.sort(byPriority);
-  groups.cancelled.sort(byPriority);
-  return groups;
-}
-function renderKanbanMarkdown(lanes) {
-  const settings = {
-    "kanban-plugin": "board"
-  };
-  const lines = [
-    "---",
-    "kanban-plugin: board",
-    "---",
-    ""
-  ];
-  for (const lane of lanes) {
-    lines.push(`## ${lane.title}`);
-    lines.push("");
-    for (const thread of lane.items) {
-      const title = String(thread.fields.title ?? thread.path);
-      const priority = String(thread.fields.priority ?? "medium");
-      lines.push(`- [${lane.checkChar}] [[${thread.path}|${title}]] (#${priority})`);
-    }
-    lines.push("");
-    lines.push("");
-    lines.push("");
-  }
-  lines.push("%% kanban:settings");
-  lines.push("```");
-  lines.push(JSON.stringify(settings));
-  lines.push("```");
-  lines.push("%%");
-  lines.push("");
-  return lines.join("\n");
-}
-function resolvePathWithinWorkspace2(workspacePath, outputPath) {
-  const base = path10.resolve(workspacePath);
-  const resolved = path10.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path10.sep) && resolved !== base) {
-    throw new Error(`Invalid board output path: ${outputPath}`);
-  }
-  return resolved;
-}
-
-// src/dispatch.ts
-var dispatch_exports = {};
-__export(dispatch_exports, {
-  createRun: () => createRun,
-  followup: () => followup,
-  listRuns: () => listRuns,
-  logs: () => logs,
-  markRun: () => markRun,
-  status: () => status,
-  stop: () => stop
-});
-import fs11 from "fs";
-import path11 from "path";
-import { randomUUID } from "crypto";
-var RUNS_FILE = ".workgraph/dispatch-runs.json";
-function createRun(workspacePath, input) {
-  const state = loadRuns(workspacePath);
-  if (input.idempotencyKey) {
-    const existing = state.runs.find((run2) => run2.idempotencyKey === input.idempotencyKey);
-    if (existing) return existing;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const run = {
-    id: `run_${randomUUID()}`,
-    createdAt: now,
-    updatedAt: now,
-    actor: input.actor,
-    adapter: input.adapter ?? "cursor-cloud",
-    objective: input.objective,
-    status: "queued",
-    idempotencyKey: input.idempotencyKey,
-    context: input.context,
-    followups: [],
-    logs: [
-      { ts: now, level: "info", message: `Run created for objective: ${input.objective}` }
-    ]
-  };
-  state.runs.push(run);
-  saveRuns(workspacePath, state);
-  append(workspacePath, input.actor, "create", `.workgraph/runs/${run.id}`, "run", {
-    adapter: run.adapter,
-    objective: run.objective,
-    status: run.status
-  });
-  ensureRunPrimitive(workspacePath, run, input.actor);
-  return run;
-}
-function status(workspacePath, runId) {
-  const run = getRun(workspacePath, runId);
-  if (!run) throw new Error(`Run not found: ${runId}`);
-  return run;
-}
-function followup(workspacePath, runId, actor, input) {
-  const state = loadRuns(workspacePath);
-  const run = state.runs.find((entry) => entry.id === runId);
-  if (!run) throw new Error(`Run not found: ${runId}`);
-  if (!["queued", "running"].includes(run.status)) {
-    throw new Error(`Cannot send follow-up to run ${runId} in terminal status "${run.status}".`);
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  run.followups.push({ ts: now, actor, input });
-  run.updatedAt = now;
-  run.logs.push({ ts: now, level: "info", message: `Follow-up from ${actor}: ${input}` });
-  if (run.status === "queued") run.status = "running";
-  saveRuns(workspacePath, state);
-  append(workspacePath, actor, "update", `.workgraph/runs/${run.id}`, "run", {
-    followup: true,
-    status: run.status
-  });
-  syncRunPrimitive(workspacePath, run, actor);
-  return run;
-}
-function stop(workspacePath, runId, actor) {
-  return setStatus(workspacePath, runId, actor, "cancelled", "Run cancelled by operator.");
-}
-function markRun(workspacePath, runId, actor, nextStatus, options = {}) {
-  const run = setStatus(workspacePath, runId, actor, nextStatus, `Run moved to ${nextStatus}.`);
-  if (options.output) run.output = options.output;
-  if (options.error) run.error = options.error;
-  const state = loadRuns(workspacePath);
-  const target = state.runs.find((entry) => entry.id === runId);
-  if (target) {
-    target.output = run.output;
-    target.error = run.error;
-    target.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    saveRuns(workspacePath, state);
-    syncRunPrimitive(workspacePath, target, actor);
-  }
-  return target ?? run;
-}
-function logs(workspacePath, runId) {
-  return status(workspacePath, runId).logs;
-}
-function listRuns(workspacePath, options = {}) {
-  const runs = loadRuns(workspacePath).runs.filter((run) => options.status ? run.status === options.status : true).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-  if (options.limit && options.limit > 0) {
-    return runs.slice(0, options.limit);
-  }
-  return runs;
-}
-function setStatus(workspacePath, runId, actor, statusValue, logMessage) {
-  const state = loadRuns(workspacePath);
-  const run = state.runs.find((entry) => entry.id === runId);
-  if (!run) throw new Error(`Run not found: ${runId}`);
-  assertRunStatusTransition(run.status, statusValue, runId);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  run.status = statusValue;
-  run.updatedAt = now;
-  run.logs.push({ ts: now, level: "info", message: logMessage });
-  saveRuns(workspacePath, state);
-  append(workspacePath, actor, "update", `.workgraph/runs/${run.id}`, "run", {
-    status: run.status
-  });
-  syncRunPrimitive(workspacePath, run, actor);
-  return run;
-}
-function runsPath(workspacePath) {
-  return path11.join(workspacePath, RUNS_FILE);
-}
-function loadRuns(workspacePath) {
-  const rPath = runsPath(workspacePath);
-  if (!fs11.existsSync(rPath)) {
-    const seeded = { version: 1, runs: [] };
-    saveRuns(workspacePath, seeded);
-    return seeded;
-  }
-  const raw = fs11.readFileSync(rPath, "utf-8");
-  const parsed = JSON.parse(raw);
-  return {
-    version: parsed.version ?? 1,
-    runs: parsed.runs ?? []
-  };
-}
-function saveRuns(workspacePath, value) {
-  const rPath = runsPath(workspacePath);
-  const dir = path11.dirname(rPath);
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
-  fs11.writeFileSync(rPath, JSON.stringify(value, null, 2) + "\n", "utf-8");
-}
-function getRun(workspacePath, runId) {
-  const state = loadRuns(workspacePath);
-  return state.runs.find((run) => run.id === runId) ?? null;
-}
-function ensureRunPrimitive(workspacePath, run, actor) {
-  const safeTitle = `${run.objective} (${run.id.slice(0, 8)})`;
-  create(
-    workspacePath,
-    "run",
-    {
-      title: safeTitle,
-      objective: run.objective,
-      runtime: run.adapter,
-      status: run.status,
-      run_id: run.id,
-      owner: run.actor,
-      tags: ["dispatch"]
-    },
-    `## Objective
-
-${run.objective}
-`,
-    actor
-  );
-}
-function syncRunPrimitive(workspacePath, run, actor) {
-  const runs = list(workspacePath, "run");
-  const existing = runs.find((entry) => String(entry.fields.run_id) === run.id);
-  if (!existing) return;
-  update(
-    workspacePath,
-    existing.path,
-    {
-      status: run.status,
-      runtime: run.adapter,
-      objective: run.objective,
-      owner: run.actor
-    },
-    renderRunBody(run),
-    actor
-  );
-}
-function renderRunBody(run) {
-  const lines = [
-    "## Objective",
-    "",
-    run.objective,
-    "",
-    "## Status",
-    "",
-    run.status,
-    "",
-    "## Logs",
-    "",
-    ...run.logs.slice(-20).map((entry) => `- ${entry.ts} [${entry.level}] ${entry.message}`),
-    ""
-  ];
-  if (run.output) {
-    lines.push("## Output");
-    lines.push("");
-    lines.push(run.output);
-    lines.push("");
-  }
-  if (run.error) {
-    lines.push("## Error");
-    lines.push("");
-    lines.push(run.error);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-var RUN_STATUS_TRANSITIONS = {
-  queued: ["running", "cancelled"],
-  running: ["succeeded", "failed", "cancelled"],
-  succeeded: [],
-  failed: [],
-  cancelled: []
-};
-function assertRunStatusTransition(from, to, runId) {
-  if (from === to) return;
-  const allowed = RUN_STATUS_TRANSITIONS[from] ?? [];
-  if (!allowed.includes(to)) {
-    throw new Error(`Invalid run transition for ${runId}: ${from} -> ${to}. Allowed: ${allowed.join(", ") || "none"}.`);
-  }
-}
-
-// src/onboard.ts
-var onboard_exports = {};
-__export(onboard_exports, {
-  onboardWorkspace: () => onboardWorkspace,
-  updateOnboardingStatus: () => updateOnboardingStatus
-});
-function onboardWorkspace(workspacePath, options) {
-  const spaces = options.spaces && options.spaces.length > 0 ? options.spaces : ["platform", "product", "operations"];
-  const spacesCreated = [];
-  for (const space of spaces) {
-    const title = titleCase2(space);
-    const created = create(
-      workspacePath,
-      "space",
-      {
-        title,
-        description: `${title} workspace lane`,
-        members: [options.actor],
-        tags: ["onboarded"]
-      },
-      `# ${title}
-
-Auto-created during onboarding.
-`,
-      options.actor
-    );
-    spacesCreated.push(created.path);
-  }
-  const threadsCreated = [];
-  if (options.createDemoThreads !== false) {
-    const templates = [
-      { title: "Review workspace policy gates", goal: "Validate sensitive transitions are governed.", space: spacesCreated[0] },
-      { title: "Configure board sync cadence", goal: "Set board update expectations for all agents.", space: spacesCreated[1] ?? spacesCreated[0] },
-      { title: "Establish daily checkpoint routine", goal: "Agents leave actionable hand-off notes.", space: spacesCreated[2] ?? spacesCreated[0] }
-    ];
-    for (const template of templates) {
-      const created = create(
-        workspacePath,
-        "thread",
-        {
-          title: template.title,
-          goal: template.goal,
-          status: "open",
-          priority: "medium",
-          space: template.space,
-          context_refs: [template.space],
-          tags: ["onboarding"]
-        },
-        `## Goal
-
-${template.goal}
-`,
-        options.actor
-      );
-      threadsCreated.push(created.path);
-    }
-  }
-  const boardResult = generateKanbanBoard(workspacePath, { outputPath: "ops/Onboarding Board.md" });
-  const commandCenterResult = generateCommandCenter(workspacePath, {
-    outputPath: "ops/Onboarding Command Center.md",
-    actor: options.actor
-  });
-  const checkpointResult = checkpoint(
-    workspacePath,
-    options.actor,
-    "Onboarding completed and workspace views initialized.",
-    {
-      next: ["Claim your next ready thread via `workgraph thread next --claim`"],
-      blocked: [],
-      tags: ["onboarding"]
-    }
-  );
-  const onboarding = create(
-    workspacePath,
-    "onboarding",
-    {
-      title: `Onboarding for ${options.actor}`,
-      actor: options.actor,
-      status: "active",
-      spaces: spacesCreated,
-      thread_refs: threadsCreated,
-      board: boardResult.outputPath,
-      command_center: commandCenterResult.outputPath,
-      tags: ["onboarding"]
-    },
-    [
-      "# Onboarding",
-      "",
-      `Actor: ${options.actor}`,
-      "",
-      "## Spaces",
-      "",
-      ...spacesCreated.map((space) => `- [[${space}]]`),
-      "",
-      "## Starter Threads",
-      "",
-      ...threadsCreated.map((threadRef) => `- [[${threadRef}]]`),
-      "",
-      `Board: [[${boardResult.outputPath}]]`,
-      `Command Center: [[${commandCenterResult.outputPath}]]`,
-      ""
-    ].join("\n"),
-    options.actor
-  );
-  return {
-    actor: options.actor,
-    spacesCreated,
-    threadsCreated,
-    boardPath: boardResult.outputPath,
-    commandCenterPath: commandCenterResult.outputPath,
-    checkpointPath: checkpointResult.path,
-    onboardingPath: onboarding.path
-  };
-}
-function updateOnboardingStatus(workspacePath, onboardingPath, status2, actor) {
-  const onboarding = read(workspacePath, onboardingPath);
-  if (!onboarding) throw new Error(`Onboarding primitive not found: ${onboardingPath}`);
-  if (onboarding.type !== "onboarding") {
-    throw new Error(`Target is not an onboarding primitive: ${onboardingPath}`);
-  }
-  const current = String(onboarding.fields.status ?? "active");
-  const allowed = ONBOARDING_STATUS_TRANSITIONS[current] ?? [];
-  if (!allowed.includes(status2)) {
-    throw new Error(`Invalid onboarding transition: ${current} -> ${status2}. Allowed: ${allowed.join(", ") || "none"}`);
-  }
-  return update(
-    workspacePath,
-    onboardingPath,
-    { status: status2 },
-    void 0,
-    actor
-  );
-}
-var ONBOARDING_STATUS_TRANSITIONS = {
-  active: ["paused", "completed"],
-  paused: ["active", "completed"],
-  completed: []
-};
-function titleCase2(value) {
-  return value.split(/[-_\s]/g).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
-}
-
-// src/search-qmd-adapter.ts
-var search_qmd_adapter_exports = {};
-__export(search_qmd_adapter_exports, {
-  search: () => search
-});
-function search(workspacePath, text, options = {}) {
-  const requestedMode = options.mode ?? "auto";
-  const qmdEnabled = process.env.WORKGRAPH_QMD_ENDPOINT && process.env.WORKGRAPH_QMD_ENDPOINT.trim().length > 0;
-  if (requestedMode === "qmd" && !qmdEnabled) {
-    const results = keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    });
-    return {
-      mode: "core",
-      query: text,
-      results,
-      fallbackReason: "QMD mode requested but WORKGRAPH_QMD_ENDPOINT is not configured."
-    };
-  }
-  if (requestedMode === "qmd" && qmdEnabled) {
-    const results = keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    });
-    return {
-      mode: "qmd",
-      query: text,
-      results,
-      fallbackReason: "QMD endpoint configured; using core-compatible local ranking in MVP."
-    };
-  }
-  if (requestedMode === "auto" && qmdEnabled) {
-    const results = keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    });
-    return {
-      mode: "qmd",
-      query: text,
-      results,
-      fallbackReason: "Auto mode selected; QMD endpoint detected; using core-compatible local ranking in MVP."
-    };
-  }
-  return {
-    mode: "core",
-    query: text,
-    results: keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    })
-  };
-}
-
-// src/trigger.ts
-var trigger_exports = {};
-__export(trigger_exports, {
-  fireTrigger: () => fireTrigger
-});
-import { createHash } from "crypto";
-function fireTrigger(workspacePath, triggerPath, options) {
-  const trigger = read(workspacePath, triggerPath);
-  if (!trigger) throw new Error(`Trigger not found: ${triggerPath}`);
-  if (trigger.type !== "trigger") throw new Error(`Target is not a trigger primitive: ${triggerPath}`);
-  const triggerStatus = String(trigger.fields.status ?? "draft");
-  if (!["approved", "active"].includes(triggerStatus)) {
-    throw new Error(`Trigger must be approved/active to fire. Current status: ${triggerStatus}`);
-  }
-  const objective = options.objective ?? `Trigger ${String(trigger.fields.title ?? triggerPath)} fired action ${String(trigger.fields.action ?? "run")}`;
-  const eventSeed = options.eventKey ?? (/* @__PURE__ */ new Date()).toISOString();
-  const idempotencyKey = buildIdempotencyKey(triggerPath, eventSeed, objective);
-  const run = createRun(workspacePath, {
-    actor: options.actor,
-    objective,
-    context: {
-      trigger_path: triggerPath,
-      trigger_event: String(trigger.fields.event ?? ""),
-      ...options.context
-    },
-    idempotencyKey
-  });
-  append(workspacePath, options.actor, "create", triggerPath, "trigger", {
-    fired: true,
-    event_key: eventSeed,
-    run_id: run.id,
-    idempotency_key: idempotencyKey
-  });
-  return {
-    triggerPath,
-    run,
-    idempotencyKey
-  };
-}
-function buildIdempotencyKey(triggerPath, eventSeed, objective) {
-  return createHash("sha256").update(`${triggerPath}:${eventSeed}:${objective}`).digest("hex").slice(0, 32);
-}
-
-export {
-  THREAD_STATUS_TRANSITIONS,
-  ledger_exports,
-  registry_exports,
-  graph_exports,
-  policy_exports,
-  store_exports,
-  thread_exports,
-  bases_exports,
-  workspace_exports,
-  command_center_exports,
-  skill_exports,
-  query_exports,
-  orientation_exports,
-  board_exports,
-  dispatch_exports,
-  onboard_exports,
-  search_qmd_adapter_exports,
-  trigger_exports
-};