@versatly/workgraph 0.3.0 → 1.0.0

package/dist/chunk-65ZMX2WM.js

@@ -1,2846 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/mcp-server.ts
-var mcp_server_exports = {};
-__export(mcp_server_exports, {
-  createWorkgraphMcpServer: () => createWorkgraphMcpServer,
-  startWorkgraphMcpServer: () => startWorkgraphMcpServer
-});
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// src/dispatch.ts
-var dispatch_exports = {};
-__export(dispatch_exports, {
-  createAndExecuteRun: () => createAndExecuteRun,
-  createRun: () => createRun,
-  executeRun: () => executeRun,
-  followup: () => followup,
-  listRuns: () => listRuns,
-  logs: () => logs,
-  markRun: () => markRun,
-  status: () => status,
-  stop: () => stop
-});
-import fs6 from "fs";
-import path6 from "path";
-import { randomUUID } from "crypto";
-
-// 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/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/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";
-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/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/orientation.ts
-var orientation_exports = {};
-__export(orientation_exports, {
-  brief: () => brief,
-  checkpoint: () => checkpoint,
-  intake: () => intake,
-  statusSnapshot: () => statusSnapshot
-});
-
-// 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/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
-});
-
-// src/types.ts
-var THREAD_STATUS_TRANSITIONS = {
-  open: ["active", "cancelled"],
-  active: ["blocked", "done", "cancelled", "open"],
-  blocked: ["active", "cancelled"],
-  done: [],
-  cancelled: ["open"]
-};
-
-// src/thread.ts
-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/orientation.ts
-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/adapter-cursor-cloud.ts
-var DEFAULT_MAX_STEPS = 200;
-var DEFAULT_STEP_DELAY_MS = 25;
-var DEFAULT_AGENT_COUNT = 3;
-var CursorCloudAdapter = class {
-  name = "cursor-cloud";
-  async create(_input) {
-    return {
-      runId: "adapter-managed",
-      status: "queued"
-    };
-  }
-  async status(runId) {
-    return { runId, status: "running" };
-  }
-  async followup(runId, _actor, _input) {
-    return { runId, status: "running" };
-  }
-  async stop(runId, _actor) {
-    return { runId, status: "cancelled" };
-  }
-  async logs(_runId) {
-    return [];
-  }
-  async execute(input) {
-    const start = Date.now();
-    const logs2 = [];
-    const agentPool = normalizeAgents(input.agents, input.actor);
-    const maxSteps = normalizeInt(input.maxSteps, DEFAULT_MAX_STEPS, 1, 5e3);
-    const stepDelayMs = normalizeInt(input.stepDelayMs, DEFAULT_STEP_DELAY_MS, 0, 5e3);
-    const claimedByAgent = {};
-    const completedByAgent = {};
-    let stepsExecuted = 0;
-    let completionCount = 0;
-    let failureCount = 0;
-    let cancelled = false;
-    for (const agent of agentPool) {
-      claimedByAgent[agent] = 0;
-      completedByAgent[agent] = 0;
-    }
-    pushLog(logs2, "info", `Run ${input.runId} started with agents: ${agentPool.join(", ")}`);
-    pushLog(logs2, "info", `Objective: ${input.objective}`);
-    while (stepsExecuted < maxSteps) {
-      if (input.isCancelled?.()) {
-        cancelled = true;
-        pushLog(logs2, "warn", `Run ${input.runId} received cancellation signal.`);
-        break;
-      }
-      const claimedThisRound = [];
-      for (const agent of agentPool) {
-        try {
-          const claimed = input.space ? claimNextReadyInSpace(input.workspacePath, agent, input.space) : claimNextReady(input.workspacePath, agent);
-          if (!claimed) {
-            continue;
-          }
-          const path7 = claimed.path;
-          const goal = String(claimed.fields.goal ?? claimed.fields.title ?? path7);
-          claimedThisRound.push({ agent, threadPath: path7, goal });
-          claimedByAgent[agent] += 1;
-          pushLog(logs2, "info", `${agent} claimed ${path7}`);
-        } catch (error) {
-          pushLog(logs2, "warn", `${agent} claim skipped: ${errorMessage(error)}`);
-        }
-      }
-      if (claimedThisRound.length === 0) {
-        const readyRemaining = listReady(input.workspacePath, input.space).length;
-        if (readyRemaining === 0) {
-          pushLog(logs2, "info", "No ready threads remaining; autonomous loop complete.");
-          break;
-        }
-        if (stepDelayMs > 0) {
-          await sleep(stepDelayMs);
-        }
-        continue;
-      }
-      await Promise.all(claimedThisRound.map(async (claimed) => {
-        if (input.isCancelled?.()) {
-          cancelled = true;
-          return;
-        }
-        if (stepDelayMs > 0) {
-          await sleep(stepDelayMs);
-        }
-        try {
-          done(
-            input.workspacePath,
-            claimed.threadPath,
-            claimed.agent,
-            `Completed by ${claimed.agent} during dispatch run ${input.runId}. Goal: ${claimed.goal}`
-          );
-          completionCount += 1;
-          completedByAgent[claimed.agent] += 1;
-          pushLog(logs2, "info", `${claimed.agent} completed ${claimed.threadPath}`);
-        } catch (error) {
-          failureCount += 1;
-          pushLog(logs2, "error", `${claimed.agent} failed to complete ${claimed.threadPath}: ${errorMessage(error)}`);
-        }
-      }));
-      stepsExecuted += claimedThisRound.length;
-      if (cancelled) break;
-    }
-    const readyAfter = listReady(input.workspacePath, input.space);
-    const activeAfter = input.space ? threadsInSpace(input.workspacePath, input.space).filter((candidate) => candidate.fields.status === "active") : activeThreads(input.workspacePath);
-    const openAfter = input.space ? threadsInSpace(input.workspacePath, input.space).filter((candidate) => candidate.fields.status === "open") : openThreads(input.workspacePath);
-    const blockedAfter = input.space ? threadsInSpace(input.workspacePath, input.space).filter((candidate) => candidate.fields.status === "blocked") : blockedThreads(input.workspacePath);
-    const elapsedMs = Date.now() - start;
-    const summary = renderSummary({
-      objective: input.objective,
-      runId: input.runId,
-      completed: completionCount,
-      failed: failureCount,
-      stepsExecuted,
-      readyRemaining: readyAfter.length,
-      openRemaining: openAfter.length,
-      blockedRemaining: blockedAfter.length,
-      activeRemaining: activeAfter.length,
-      elapsedMs,
-      claimedByAgent,
-      completedByAgent,
-      cancelled
-    });
-    if (input.createCheckpoint !== false) {
-      try {
-        checkpoint(
-          input.workspacePath,
-          input.actor,
-          `Dispatch run ${input.runId} completed autonomous execution.`,
-          {
-            next: readyAfter.slice(0, 10).map((entry) => entry.path),
-            blocked: blockedAfter.slice(0, 10).map((entry) => entry.path),
-            tags: ["dispatch", "autonomous-run"]
-          }
-        );
-        pushLog(logs2, "info", `Checkpoint recorded for run ${input.runId}.`);
-      } catch (error) {
-        pushLog(logs2, "warn", `Checkpoint creation skipped: ${errorMessage(error)}`);
-      }
-    }
-    if (cancelled) {
-      return {
-        status: "cancelled",
-        output: summary,
-        logs: logs2,
-        metrics: {
-          completed: completionCount,
-          failed: failureCount,
-          readyRemaining: readyAfter.length,
-          openRemaining: openAfter.length,
-          blockedRemaining: blockedAfter.length,
-          elapsedMs,
-          claimedByAgent,
-          completedByAgent
-        }
-      };
-    }
-    if (failureCount > 0) {
-      return {
-        status: "failed",
-        error: summary,
-        logs: logs2,
-        metrics: {
-          completed: completionCount,
-          failed: failureCount,
-          readyRemaining: readyAfter.length,
-          openRemaining: openAfter.length,
-          blockedRemaining: blockedAfter.length,
-          elapsedMs,
-          claimedByAgent,
-          completedByAgent
-        }
-      };
-    }
-    const status2 = readyAfter.length === 0 && activeAfter.length === 0 ? "succeeded" : "failed";
-    if (status2 === "failed") {
-      pushLog(logs2, "warn", "Execution stopped with actionable work still remaining.");
-    }
-    return {
-      status: status2,
-      output: summary,
-      logs: logs2,
-      metrics: {
-        completed: completionCount,
-        failed: failureCount,
-        readyRemaining: readyAfter.length,
-        openRemaining: openAfter.length,
-        blockedRemaining: blockedAfter.length,
-        elapsedMs,
-        claimedByAgent,
-        completedByAgent
-      }
-    };
-  }
-};
-function normalizeAgents(agents, actor) {
-  const fromInput = (agents ?? []).map((entry) => String(entry).trim()).filter(Boolean);
-  if (fromInput.length > 0) return [...new Set(fromInput)];
-  return Array.from({ length: DEFAULT_AGENT_COUNT }, (_, idx) => `${actor}-worker-${idx + 1}`);
-}
-function normalizeInt(rawValue, fallback, min, max) {
-  const value = Number.isFinite(rawValue) ? Number(rawValue) : fallback;
-  return Math.min(max, Math.max(min, Math.trunc(value)));
-}
-function pushLog(target, level, message) {
-  target.push({
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    level,
-    message
-  });
-}
-function listReady(workspacePath, space) {
-  return space ? listReadyThreadsInSpace(workspacePath, space) : listReadyThreads(workspacePath);
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function renderSummary(data) {
-  const lines = [
-    `Autonomous dispatch summary for ${data.runId}`,
-    `Objective: ${data.objective}`,
-    `Completed threads: ${data.completed}`,
-    `Failed completions: ${data.failed}`,
-    `Scheduler steps executed: ${data.stepsExecuted}`,
-    `Ready remaining: ${data.readyRemaining}`,
-    `Open remaining: ${data.openRemaining}`,
-    `Blocked remaining: ${data.blockedRemaining}`,
-    `Active remaining: ${data.activeRemaining}`,
-    `Elapsed ms: ${data.elapsedMs}`,
-    `Cancelled: ${data.cancelled ? "yes" : "no"}`,
-    "",
-    "Claims by agent:",
-    ...Object.entries(data.claimedByAgent).map(([agent, count]) => `- ${agent}: ${count}`),
-    "",
-    "Completions by agent:",
-    ...Object.entries(data.completedByAgent).map(([agent, count]) => `- ${agent}: ${count}`)
-  ];
-  return lines.join("\n");
-}
-
-// src/runtime-adapter-registry.ts
-var adapterFactories = /* @__PURE__ */ new Map([
-  ["cursor-cloud", () => new CursorCloudAdapter()]
-]);
-function resolveDispatchAdapter(name) {
-  const safeName = normalizeName(name);
-  const factory = adapterFactories.get(safeName);
-  if (!factory) {
-    throw new Error(`Unknown dispatch adapter "${name}". Registered adapters: ${listDispatchAdapters().join(", ") || "none"}.`);
-  }
-  return factory();
-}
-function listDispatchAdapters() {
-  return [...adapterFactories.keys()].sort((a, b) => a.localeCompare(b));
-}
-function normalizeName(name) {
-  return String(name || "").trim().toLowerCase();
-}
-
-// src/dispatch.ts
-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;
-  if (options.contextPatch && Object.keys(options.contextPatch).length > 0) {
-    run.context = {
-      ...run.context ?? {},
-      ...options.contextPatch
-    };
-  }
-  const state = loadRuns(workspacePath);
-  const target = state.runs.find((entry) => entry.id === runId);
-  if (target) {
-    target.output = run.output;
-    target.error = run.error;
-    target.context = run.context;
-    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;
-}
-async function executeRun(workspacePath, runId, input) {
-  const existing = status(workspacePath, runId);
-  if (!["queued", "running"].includes(existing.status)) {
-    throw new Error(`Run ${runId} is in terminal status "${existing.status}" and cannot be executed.`);
-  }
-  const adapter = resolveDispatchAdapter(existing.adapter);
-  if (!adapter.execute) {
-    throw new Error(`Dispatch adapter "${existing.adapter}" does not implement execute().`);
-  }
-  if (existing.status === "queued") {
-    setStatus(workspacePath, runId, input.actor, "running", `Run started on adapter "${existing.adapter}".`);
-  }
-  const execution = await adapter.execute({
-    workspacePath,
-    runId,
-    actor: input.actor,
-    objective: existing.objective,
-    context: existing.context,
-    agents: input.agents,
-    maxSteps: input.maxSteps,
-    stepDelayMs: input.stepDelayMs,
-    space: input.space,
-    createCheckpoint: input.createCheckpoint,
-    isCancelled: () => status(workspacePath, runId).status === "cancelled"
-  });
-  appendRunLogs(workspacePath, runId, input.actor, execution.logs);
-  const finalStatus = execution.status;
-  if (finalStatus === "queued" || finalStatus === "running") {
-    throw new Error(`Adapter returned invalid terminal status "${finalStatus}" for execute().`);
-  }
-  return markRun(workspacePath, runId, input.actor, finalStatus, {
-    output: execution.output,
-    error: execution.error,
-    contextPatch: execution.metrics ? { adapter_metrics: execution.metrics } : void 0
-  });
-}
-async function createAndExecuteRun(workspacePath, createInput, executeInput = {}) {
-  const run = createRun(workspacePath, createInput);
-  return executeRun(workspacePath, run.id, {
-    actor: createInput.actor,
-    ...executeInput
-  });
-}
-function appendRunLogs(workspacePath, runId, actor, logEntries) {
-  if (logEntries.length === 0) return;
-  const state = loadRuns(workspacePath);
-  const run = state.runs.find((entry) => entry.id === runId);
-  if (!run) throw new Error(`Run not found: ${runId}`);
-  run.logs.push(...logEntries);
-  run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  saveRuns(workspacePath, state);
-  append(workspacePath, actor, "update", `.workgraph/runs/${run.id}`, "run", {
-    log_append_count: logEntries.length
-  });
-  syncRunPrimitive(workspacePath, run, actor);
-}
-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 path6.join(workspacePath, RUNS_FILE);
-}
-function loadRuns(workspacePath) {
-  const rPath = runsPath(workspacePath);
-  if (!fs6.existsSync(rPath)) {
-    const seeded = { version: 1, runs: [] };
-    saveRuns(workspacePath, seeded);
-    return seeded;
-  }
-  const raw = fs6.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 = path6.dirname(rPath);
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  fs6.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)})`;
-  const runPrimitivePath = `runs/${run.id}.md`;
-  const existing = read(workspacePath, runPrimitivePath);
-  if (existing) return;
-  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,
-    { pathOverride: runPrimitivePath }
-  );
-}
-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("");
-  }
-  if (run.context && Object.keys(run.context).length > 0) {
-    lines.push("## Context");
-    lines.push("");
-    lines.push("```json");
-    lines.push(JSON.stringify(run.context, null, 2));
-    lines.push("```");
-    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/mcp-server.ts
-var DEFAULT_SERVER_NAME = "workgraph-mcp-server";
-var DEFAULT_SERVER_VERSION = "0.1.0";
-function createWorkgraphMcpServer(options) {
-  const server = new McpServer({
-    name: options.name ?? DEFAULT_SERVER_NAME,
-    version: options.version ?? DEFAULT_SERVER_VERSION
-  });
-  registerResources(server, options);
-  registerTools(server, options);
-  return server;
-}
-async function startWorkgraphMcpServer(options) {
-  const server = createWorkgraphMcpServer(options);
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  return server;
-}
-function registerResources(server, options) {
-  server.registerResource(
-    "workspace-status",
-    "workgraph://status",
-    {
-      title: "Workgraph Status Snapshot",
-      description: "Current thread/claim/primitive counts for the workspace.",
-      mimeType: "application/json"
-    },
-    async () => {
-      const snapshot = statusSnapshot(options.workspacePath);
-      return {
-        contents: [
-          {
-            uri: "workgraph://status",
-            mimeType: "application/json",
-            text: toPrettyJson(snapshot)
-          }
-        ]
-      };
-    }
-  );
-  server.registerResource(
-    "actor-brief",
-    new ResourceTemplate("workgraph://brief/{actor}", { list: void 0 }),
-    {
-      title: "Actor Brief",
-      description: "Actor-specific operational brief derived from workspace state.",
-      mimeType: "application/json"
-    },
-    async (uri, variables) => {
-      const actor = String(variables.actor ?? options.defaultActor ?? "anonymous");
-      const brief2 = brief(options.workspacePath, actor);
-      return {
-        contents: [
-          {
-            uri: uri.toString(),
-            mimeType: "application/json",
-            text: toPrettyJson(brief2)
-          }
-        ]
-      };
-    }
-  );
-}
-function registerTools(server, options) {
-  server.registerTool(
-    "workgraph_status",
-    {
-      title: "Workgraph Status",
-      description: "Return a compact status snapshot for the configured workspace.",
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async () => {
-      try {
-        const snapshot = statusSnapshot(options.workspacePath);
-        return okResult(snapshot, renderStatusSummary(snapshot));
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_brief",
-    {
-      title: "Workgraph Brief",
-      description: "Return actor-centric operational brief (claims, blockers, and next work).",
-      inputSchema: {
-        actor: z.string().optional(),
-        recentCount: z.number().int().min(1).max(100).optional(),
-        nextCount: z.number().int().min(1).max(100).optional()
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const brief2 = brief(options.workspacePath, actor, {
-          recentCount: args.recentCount,
-          nextCount: args.nextCount
-        });
-        return okResult(brief2, `Brief for ${actor}: claims=${brief2.myClaims.length}, blocked=${brief2.blockedThreads.length}`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_query",
-    {
-      title: "Workgraph Query",
-      description: "Query primitives using multi-field filters.",
-      inputSchema: {
-        type: z.string().optional(),
-        status: z.string().optional(),
-        owner: z.string().optional(),
-        tag: z.string().optional(),
-        text: z.string().optional(),
-        pathIncludes: z.string().optional(),
-        updatedAfter: z.string().optional(),
-        updatedBefore: z.string().optional(),
-        createdAfter: z.string().optional(),
-        createdBefore: z.string().optional(),
-        limit: z.number().int().min(0).max(1e3).optional(),
-        offset: z.number().int().min(0).max(1e4).optional()
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async (args) => {
-      try {
-        const results = queryPrimitives(options.workspacePath, {
-          type: args.type,
-          status: args.status,
-          owner: args.owner,
-          tag: args.tag,
-          text: args.text,
-          pathIncludes: args.pathIncludes,
-          updatedAfter: args.updatedAfter,
-          updatedBefore: args.updatedBefore,
-          createdAfter: args.createdAfter,
-          createdBefore: args.createdBefore,
-          limit: args.limit,
-          offset: args.offset
-        });
-        return okResult({ results, count: results.length }, `Query returned ${results.length} primitive(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_thread_list",
-    {
-      title: "Thread List",
-      description: "List workspace threads, optionally filtered by status/space/readiness.",
-      inputSchema: {
-        status: z.string().optional(),
-        readyOnly: z.boolean().optional(),
-        space: z.string().optional()
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async (args) => {
-      try {
-        let threads = args.space ? threadsInSpace(options.workspacePath, args.space) : list(options.workspacePath, "thread");
-        const readySet = new Set(
-          (args.space ? listReadyThreadsInSpace(options.workspacePath, args.space) : listReadyThreads(options.workspacePath)).map((entry) => entry.path)
-        );
-        if (args.status) {
-          threads = threads.filter((entry) => String(entry.fields.status) === args.status);
-        }
-        if (args.readyOnly) {
-          threads = threads.filter((entry) => readySet.has(entry.path));
-        }
-        const enriched = threads.map((entry) => ({
-          ...entry,
-          ready: readySet.has(entry.path)
-        }));
-        return okResult({ threads: enriched, count: enriched.length }, `Thread list returned ${enriched.length} item(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_thread_show",
-    {
-      title: "Thread Show",
-      description: "Read one thread and its ledger history.",
-      inputSchema: {
-        threadPath: z.string().min(1)
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async (args) => {
-      try {
-        const threadEntry = read(options.workspacePath, args.threadPath);
-        if (!threadEntry) {
-          return errorResult(`Thread not found: ${args.threadPath}`);
-        }
-        const history = historyOf(options.workspacePath, args.threadPath);
-        return okResult({ thread: threadEntry, history }, `Thread ${args.threadPath} has ${history.length} ledger event(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_ledger_recent",
-    {
-      title: "Ledger Recent",
-      description: "Read recent ledger events.",
-      inputSchema: {
-        count: z.number().int().min(1).max(500).optional(),
-        actor: z.string().optional()
-      },
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async (args) => {
-      try {
-        let entries = recent(options.workspacePath, args.count ?? 20);
-        if (args.actor) {
-          entries = entries.filter((entry) => entry.actor === args.actor);
-        }
-        return okResult({ entries, count: entries.length }, `Ledger returned ${entries.length} event(s).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_graph_hygiene",
-    {
-      title: "Graph Hygiene",
-      description: "Generate wiki-link graph hygiene report.",
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true
-      }
-    },
-    async () => {
-      try {
-        const report = graphHygieneReport(options.workspacePath);
-        return okResult(
-          report,
-          `Graph hygiene: nodes=${report.nodeCount}, edges=${report.edgeCount}, orphans=${report.orphanCount}, broken=${report.brokenLinkCount}`
-        );
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_thread_claim",
-    {
-      title: "Thread Claim",
-      description: "Claim a thread for an actor (policy-scoped write).",
-      inputSchema: {
-        threadPath: z.string().min(1),
-        actor: z.string().optional()
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["thread:claim", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = claim(options.workspacePath, args.threadPath, actor);
-        return okResult({ thread: updated }, `Claimed ${updated.path} as ${actor}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_thread_done",
-    {
-      title: "Thread Done",
-      description: "Mark a thread as done with output summary (policy-scoped write).",
-      inputSchema: {
-        threadPath: z.string().min(1),
-        actor: z.string().optional(),
-        output: z.string().optional()
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["thread:done", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const updated = done(options.workspacePath, args.threadPath, actor, args.output);
-        return okResult({ thread: updated }, `Marked ${updated.path} done as ${actor}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_checkpoint_create",
-    {
-      title: "Checkpoint Create",
-      description: "Create a checkpoint primitive for hand-off continuity (policy-scoped write).",
-      inputSchema: {
-        actor: z.string().optional(),
-        summary: z.string().min(1),
-        next: z.array(z.string()).optional(),
-        blocked: z.array(z.string()).optional(),
-        tags: z.array(z.string()).optional()
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["checkpoint:create", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const checkpoint2 = checkpoint(options.workspacePath, actor, args.summary, {
-          next: args.next,
-          blocked: args.blocked,
-          tags: args.tags
-        });
-        return okResult({ checkpoint: checkpoint2 }, `Created checkpoint ${checkpoint2.path}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_dispatch_create",
-    {
-      title: "Dispatch Create",
-      description: "Create a dispatch run request (policy-scoped write).",
-      inputSchema: {
-        actor: z.string().optional(),
-        objective: z.string().min(1),
-        adapter: z.string().optional(),
-        idempotencyKey: z.string().optional()
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["dispatch:run", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = createRun(options.workspacePath, {
-          actor,
-          objective: args.objective,
-          adapter: args.adapter,
-          idempotencyKey: args.idempotencyKey
-        });
-        return okResult({ run }, `Created run ${run.id} (${run.status}).`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_dispatch_execute",
-    {
-      title: "Dispatch Execute",
-      description: "Execute one queued/running run through its adapter (policy-scoped write).",
-      inputSchema: {
-        actor: z.string().optional(),
-        runId: z.string().min(1),
-        agents: z.array(z.string()).optional(),
-        maxSteps: z.number().int().min(1).max(5e3).optional(),
-        stepDelayMs: z.number().int().min(0).max(5e3).optional(),
-        space: z.string().optional(),
-        createCheckpoint: z.boolean().optional()
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["dispatch:run", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = await executeRun(options.workspacePath, args.runId, {
-          actor,
-          agents: args.agents,
-          maxSteps: args.maxSteps,
-          stepDelayMs: args.stepDelayMs,
-          space: args.space,
-          createCheckpoint: args.createCheckpoint
-        });
-        return okResult({ run }, `Executed run ${run.id} -> ${run.status}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_dispatch_followup",
-    {
-      title: "Dispatch Follow-up",
-      description: "Send follow-up input to a run (policy-scoped write).",
-      inputSchema: {
-        actor: z.string().optional(),
-        runId: z.string().min(1),
-        input: z.string().min(1)
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["dispatch:run", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = followup(options.workspacePath, args.runId, actor, args.input);
-        return okResult({ run }, `Follow-up recorded for ${run.id}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "workgraph_dispatch_stop",
-    {
-      title: "Dispatch Stop",
-      description: "Stop/cancel a run (policy-scoped write).",
-      inputSchema: {
-        actor: z.string().optional(),
-        runId: z.string().min(1)
-      },
-      annotations: {
-        destructiveHint: true,
-        idempotentHint: false
-      }
-    },
-    async (args) => {
-      try {
-        const actor = resolveActor(args.actor, options.defaultActor);
-        const gate = checkWriteGate(options, actor, ["dispatch:run", "mcp:write"]);
-        if (!gate.allowed) return errorResult(gate.reason);
-        const run = stop(options.workspacePath, args.runId, actor);
-        return okResult({ run }, `Stopped run ${run.id}.`);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-}
-function resolveActor(actor, defaultActor) {
-  const resolved = actor ?? defaultActor ?? "anonymous";
-  return String(resolved);
-}
-function checkWriteGate(options, actor, requiredCapabilities) {
-  if (options.readOnly) {
-    return {
-      allowed: false,
-      reason: "MCP server is configured read-only; write tool is disabled."
-    };
-  }
-  if (actor === "system") {
-    return { allowed: true };
-  }
-  const party = getParty(options.workspacePath, actor);
-  if (!party) {
-    return {
-      allowed: false,
-      reason: `Policy gate blocked MCP write: actor "${actor}" is not a registered party.`
-    };
-  }
-  const hasCapability = requiredCapabilities.some((capability) => party.capabilities.includes(capability));
-  if (!hasCapability) {
-    return {
-      allowed: false,
-      reason: `Policy gate blocked MCP write: actor "${actor}" lacks capabilities [${requiredCapabilities.join(", ")}].`
-    };
-  }
-  return { allowed: true };
-}
-function okResult(data, summary) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: `${summary}
-
-${toPrettyJson(data)}`
-      }
-    ],
-    structuredContent: data
-  };
-}
-function errorResult(error) {
-  const text = error instanceof Error ? error.message : String(error);
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text
-      }
-    ]
-  };
-}
-function toPrettyJson(value) {
-  return JSON.stringify(value, null, 2);
-}
-function renderStatusSummary(snapshot) {
-  return [
-    `threads(total=${snapshot.threads.total}, open=${snapshot.threads.open}, active=${snapshot.threads.active}, blocked=${snapshot.threads.blocked}, done=${snapshot.threads.done})`,
-    `claims(active=${snapshot.claims.active})`,
-    `primitives(total=${snapshot.primitives.total})`
-  ].join(" ");
-}
-
-export {
-  __export,
-  THREAD_STATUS_TRANSITIONS,
-  append,
-  historyOf,
-  allClaims,
-  recent,
-  ledger_exports,
-  loadRegistry,
-  saveRegistry,
-  listTypes,
-  registry_exports,
-  refreshWikiLinkGraphIndex,
-  graph_exports,
-  loadPolicyRegistry,
-  policy_exports,
-  create,
-  read,
-  list,
-  update,
-  store_exports,
-  createThread,
-  thread_exports,
-  keywordSearch,
-  query_exports,
-  checkpoint,
-  orientation_exports,
-  CursorCloudAdapter,
-  createRun,
-  dispatch_exports,
-  createWorkgraphMcpServer,
-  startWorkgraphMcpServer,
-  mcp_server_exports
-};