@versatly/workgraph 0.2.0 → 0.3.0

package/dist/{chunk-XUMA4O2Z.js → chunk-65ZMX2WM.js}

@@ -4,28 +4,32 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/types.ts
-var THREAD_STATUS_TRANSITIONS = {
-  open: ["active", "cancelled"],
-  active: ["blocked", "done", "cancelled", "open"],
-  blocked: ["active", "cancelled"],
-  done: [],
-  cancelled: ["open"]
-};
+// src/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/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  defineType: () => defineType,
-  extendType: () => extendType,
-  getType: () => getType,
-  listTypes: () => listTypes,
-  loadRegistry: () => loadRegistry,
-  registryPath: () => registryPath,
-  saveRegistry: () => saveRegistry
+// 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 fs2 from "fs";
-import path2 from "path";
+import fs6 from "fs";
+import path6 from "path";
+import { randomUUID } from "crypto";
 
 // src/ledger.ts
 var ledger_exports = {};
@@ -359,7 +363,37 @@ function stableStringify(value) {
   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 = [
@@ -690,24 +724,6 @@ function ensureBuiltIns(registry) {
   return registry;
 }
 
-// src/store.ts
-var store_exports = {};
-__export(store_exports, {
-  activeThreads: () => activeThreads,
-  blockedThreads: () => blockedThreads,
-  create: () => create,
-  findByField: () => findByField,
-  list: () => list,
-  openThreads: () => openThreads,
-  read: () => read,
-  remove: () => remove,
-  threadsInSpace: () => threadsInSpace,
-  update: () => update
-});
-import fs5 from "fs";
-import path5 from "path";
-import matter from "gray-matter";
-
 // src/graph.ts
 var graph_exports = {};
 __export(graph_exports, {
@@ -1270,6 +1286,81 @@ function validateRefValue(workspacePath, rawRef, allowedTypes) {
   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, {
@@ -1289,6 +1380,17 @@ __export(thread_exports, {
   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 ?? [];
@@ -1531,632 +1633,50 @@ function normalizeWorkspaceRef(value) {
   return unwrapped.endsWith(".md") ? unwrapped : `${unwrapped}.md`;
 }
 
-// src/workspace.ts
-var workspace_exports = {};
-__export(workspace_exports, {
-  initWorkspace: () => initWorkspace,
-  isWorkgraphWorkspace: () => isWorkgraphWorkspace,
-  workspaceConfigPath: () => workspaceConfigPath
-});
-import fs7 from "fs";
-import path7 from "path";
-
-// src/bases.ts
-var bases_exports = {};
-__export(bases_exports, {
-  generateBasesFromPrimitiveRegistry: () => generateBasesFromPrimitiveRegistry,
-  primitiveRegistryManifestPath: () => primitiveRegistryManifestPath,
-  readPrimitiveRegistryManifest: () => readPrimitiveRegistryManifest,
-  syncPrimitiveRegistryManifest: () => syncPrimitiveRegistryManifest
-});
-import fs6 from "fs";
-import path6 from "path";
-import YAML from "yaml";
-var REGISTRY_MANIFEST_FILE = ".workgraph/primitive-registry.yaml";
-var DEFAULT_BASES_DIR = ".workgraph/bases";
-function primitiveRegistryManifestPath(workspacePath) {
-  return path6.join(workspacePath, REGISTRY_MANIFEST_FILE);
-}
-function readPrimitiveRegistryManifest(workspacePath) {
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  if (!fs6.existsSync(manifestPath)) {
-    throw new Error(`Primitive registry manifest not found: ${manifestPath}`);
-  }
-  const raw = fs6.readFileSync(manifestPath, "utf-8");
-  return YAML.parse(raw);
-}
-function syncPrimitiveRegistryManifest(workspacePath) {
-  const registry = loadRegistry(workspacePath);
-  const manifest = {
-    version: 1,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    primitives: Object.values(registry.types).map((primitive) => ({
-      name: primitive.name,
-      directory: primitive.directory,
-      canonical: primitive.builtIn,
-      builtIn: primitive.builtIn,
-      fields: Object.entries(primitive.fields).map(([name, field]) => ({
-        name,
-        type: field.type,
-        ...field.required ? { required: true } : {},
-        ...field.description ? { description: field.description } : {}
-      }))
-    })).sort((a, b) => a.name.localeCompare(b.name))
-  };
-  const manifestPath = primitiveRegistryManifestPath(workspacePath);
-  ensureDirectory(path6.dirname(manifestPath));
-  fs6.writeFileSync(manifestPath, YAML.stringify(manifest), "utf-8");
-  return manifest;
-}
-function generateBasesFromPrimitiveRegistry(workspacePath, options = {}) {
-  const manifest = readPrimitiveRegistryManifest(workspacePath);
-  const includeNonCanonical = options.includeNonCanonical === true;
-  const outputDirectory = path6.join(workspacePath, options.outputDirectory ?? DEFAULT_BASES_DIR);
-  ensureDirectory(outputDirectory);
-  const generated = [];
-  const primitives = manifest.primitives.filter(
-    (primitive) => includeNonCanonical ? true : primitive.canonical
-  );
-  for (const primitive of primitives) {
-    const relBasePath = `${primitive.name}.base`;
-    const absBasePath = path6.join(outputDirectory, relBasePath);
-    const content = renderBaseFile(primitive);
-    fs6.writeFileSync(absBasePath, content, "utf-8");
-    generated.push(path6.relative(workspacePath, absBasePath).replace(/\\/g, "/"));
-  }
+// 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 {
-    outputDirectory: path6.relative(workspacePath, outputDirectory).replace(/\\/g, "/"),
-    generated: generated.sort()
-  };
-}
-function renderBaseFile(primitive) {
-  const columnFields = primitive.fields.map((field) => field.name).filter((name, idx, arr) => arr.indexOf(name) === idx);
-  const baseDoc = {
-    id: primitive.name,
-    title: `${titleCase(primitive.name)} Base`,
-    source: {
-      type: "folder",
-      path: primitive.directory,
-      extension: "md"
+    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
     },
-    views: [
-      {
-        id: "table",
-        type: "table",
-        name: "All",
-        columns: ["file.name", ...columnFields]
-      }
-    ]
-  };
-  return YAML.stringify(baseDoc);
-}
-function ensureDirectory(dirPath) {
-  if (!fs6.existsSync(dirPath)) fs6.mkdirSync(dirPath, { recursive: true });
-}
-function titleCase(value) {
-  return value.split(/[-_]/g).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join(" ");
-}
-
-// src/workspace.ts
-var WORKGRAPH_CONFIG_FILE = ".workgraph.json";
-function workspaceConfigPath(workspacePath) {
-  return path7.join(workspacePath, WORKGRAPH_CONFIG_FILE);
-}
-function isWorkgraphWorkspace(workspacePath) {
-  return fs7.existsSync(workspaceConfigPath(workspacePath));
-}
-function initWorkspace(targetPath, options = {}) {
-  const resolvedPath = path7.resolve(targetPath);
-  const configPath = workspaceConfigPath(resolvedPath);
-  if (fs7.existsSync(configPath)) {
-    throw new Error(`Workgraph workspace already initialized at ${resolvedPath}`);
-  }
-  const createdDirectories = [];
-  ensureDir(resolvedPath, createdDirectories);
-  ensureDir(path7.join(resolvedPath, ".workgraph"), createdDirectories);
-  const registry = loadRegistry(resolvedPath);
-  saveRegistry(resolvedPath, registry);
-  syncPrimitiveRegistryManifest(resolvedPath);
-  if (options.createTypeDirs !== false) {
-    const types = listTypes(resolvedPath);
-    for (const typeDef of types) {
-      ensureDir(path7.join(resolvedPath, typeDef.directory), createdDirectories);
+    claims: {
+      active: claims.size
+    },
+    primitives: {
+      total: allPrimitives.length,
+      byType
     }
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const config = {
-    name: options.name ?? path7.basename(resolvedPath),
-    version: "1.0.0",
-    mode: "workgraph",
-    createdAt: now,
-    updatedAt: now
   };
-  fs7.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  if (options.createReadme !== false) {
-    writeReadmeIfMissing(resolvedPath, config.name);
-  }
-  const bases = options.createBases === false ? { generated: [] } : generateBasesFromPrimitiveRegistry(resolvedPath);
-  loadPolicyRegistry(resolvedPath);
-  refreshWikiLinkGraphIndex(resolvedPath);
-  return {
-    workspacePath: resolvedPath,
-    configPath,
-    config,
-    createdDirectories,
-    seededTypes: listTypes(resolvedPath).map((t) => t.name),
-    generatedBases: bases.generated,
-    primitiveRegistryManifestPath: ".workgraph/primitive-registry.yaml"
-  };
-}
-function ensureDir(dirPath, createdDirectories) {
-  if (fs7.existsSync(dirPath)) return;
-  fs7.mkdirSync(dirPath, { recursive: true });
-  createdDirectories.push(dirPath);
 }
-function writeReadmeIfMissing(workspacePath, name) {
-  const readmePath = path7.join(workspacePath, "README.md");
-  if (fs7.existsSync(readmePath)) return;
-  const content = `# ${name}
-
-Agent-first workgraph workspace for multi-agent coordination.
-
-## Quickstart
-
-\`\`\`bash
-workgraph thread list --json
-workgraph thread next --claim --actor agent-a --json
-workgraph ledger show --count 20 --json
-\`\`\`
-`;
-  fs7.writeFileSync(readmePath, content, "utf-8");
-}
-
-// src/command-center.ts
-var command_center_exports = {};
-__export(command_center_exports, {
-  generateCommandCenter: () => generateCommandCenter
-});
-import fs8 from "fs";
-import path8 from "path";
-function generateCommandCenter(workspacePath, options = {}) {
-  const actor = options.actor ?? "system";
-  const recentCount = options.recentCount ?? 15;
-  const relOutputPath = options.outputPath ?? "Command Center.md";
-  const absOutputPath = resolvePathWithinWorkspace(workspacePath, relOutputPath);
-  const normalizedOutputPath = path8.relative(workspacePath, absOutputPath).replace(/\\/g, "/");
-  const allThreads = list(workspacePath, "thread");
-  const openThreads2 = allThreads.filter((thread) => thread.fields.status === "open");
-  const activeThreads2 = allThreads.filter((thread) => thread.fields.status === "active");
-  const blockedThreads2 = allThreads.filter((thread) => thread.fields.status === "blocked");
-  const doneThreads = allThreads.filter((thread) => thread.fields.status === "done");
-  const claims = allClaims(workspacePath);
-  const recentEvents = recent(workspacePath, recentCount);
-  const content = renderCommandCenter({
+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(),
-    openThreads: openThreads2,
-    activeThreads: activeThreads2,
-    blockedThreads: blockedThreads2,
-    doneThreads,
-    claims: [...claims.entries()].map(([target, owner]) => ({ target, owner })),
-    recentEvents
-  });
-  const parentDir = path8.dirname(absOutputPath);
-  if (!fs8.existsSync(parentDir)) fs8.mkdirSync(parentDir, { recursive: true });
-  const existed = fs8.existsSync(absOutputPath);
-  fs8.writeFileSync(absOutputPath, content, "utf-8");
-  append(
-    workspacePath,
     actor,
-    existed ? "update" : "create",
-    normalizedOutputPath,
-    "command-center",
-    {
-      generated: true,
-      open_threads: openThreads2.length,
-      active_claims: claims.size,
-      recent_events: recentEvents.length
-    }
-  );
-  return {
-    outputPath: normalizedOutputPath,
-    stats: {
-      totalThreads: allThreads.length,
-      openThreads: openThreads2.length,
-      activeThreads: activeThreads2.length,
-      blockedThreads: blockedThreads2.length,
-      doneThreads: doneThreads.length,
-      activeClaims: claims.size,
-      recentEvents: recentEvents.length
-    },
-    content
-  };
-}
-function resolvePathWithinWorkspace(workspacePath, outputPath) {
-  const base = path8.resolve(workspacePath);
-  const resolved = path8.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path8.sep) && resolved !== base) {
-    throw new Error(`Invalid command-center output path: ${outputPath}`);
-  }
-  return resolved;
-}
-function renderCommandCenter(input) {
-  const header = [
-    "# Workgraph Command Center",
-    "",
-    `Generated: ${input.generatedAt}`,
-    ""
-  ];
-  const statusBlock = [
-    "## Thread Status",
-    "",
-    `- Open: ${input.openThreads.length}`,
-    `- Active: ${input.activeThreads.length}`,
-    `- Blocked: ${input.blockedThreads.length}`,
-    `- Done: ${input.doneThreads.length}`,
-    ""
-  ];
-  const openTable = [
-    "## Open Threads",
-    "",
-    "| Priority | Title | Path |",
-    "|---|---|---|",
-    ...input.openThreads.length > 0 ? input.openThreads.map((thread) => `| ${String(thread.fields.priority ?? "medium")} | ${String(thread.fields.title ?? "Untitled")} | \`${thread.path}\` |`) : ["| - | None | - |"],
-    ""
-  ];
-  const claimsSection = [
-    "## Active Claims",
-    "",
-    ...input.claims.length > 0 ? input.claims.map((claim2) => `- ${claim2.owner} -> \`${claim2.target}\``) : ["- None"],
-    ""
-  ];
-  const blockedSection = [
-    "## Blocked Threads",
-    "",
-    ...input.blockedThreads.length > 0 ? input.blockedThreads.map((thread) => {
-      const deps = Array.isArray(thread.fields.deps) ? thread.fields.deps.join(", ") : "";
-      return `- ${String(thread.fields.title ?? thread.path)} (\`${thread.path}\`)${deps ? ` blocked by: ${deps}` : ""}`;
-    }) : ["- None"],
-    ""
-  ];
-  const recentSection = [
-    "## Recent Ledger Activity",
-    "",
-    ...input.recentEvents.length > 0 ? input.recentEvents.map((event) => `- ${event.ts} ${event.op} ${event.actor} -> \`${event.target}\``) : ["- No activity"],
-    ""
-  ];
-  return [
-    ...header,
-    ...statusBlock,
-    ...openTable,
-    ...claimsSection,
-    ...blockedSection,
-    ...recentSection
-  ].join("\n");
-}
-
-// src/skill.ts
-var skill_exports = {};
-__export(skill_exports, {
-  listSkills: () => listSkills,
-  loadSkill: () => loadSkill,
-  promoteSkill: () => promoteSkill,
-  proposeSkill: () => proposeSkill,
-  skillDiff: () => skillDiff,
-  skillHistory: () => skillHistory,
-  writeSkill: () => writeSkill
-});
-import fs9 from "fs";
-import path9 from "path";
-function writeSkill(workspacePath, title, body, actor, options = {}) {
-  const slug = skillSlug(title);
-  const bundleSkillPath = folderSkillPath(slug);
-  const legacyPath = legacySkillPath(slug);
-  const existing = read(workspacePath, bundleSkillPath) ?? read(workspacePath, legacyPath);
-  const status2 = options.status ?? existing?.fields.status ?? "draft";
-  if (existing && options.expectedUpdatedAt) {
-    const currentUpdatedAt = String(existing.fields.updated ?? "");
-    if (currentUpdatedAt !== options.expectedUpdatedAt) {
-      throw new Error(`Concurrent skill update detected for ${existing.path}. Expected updated="${options.expectedUpdatedAt}" but found "${currentUpdatedAt}".`);
-    }
-  }
-  if (!existing) {
-    ensureSkillBundleScaffold(workspacePath, slug);
-    const created = create(workspacePath, "skill", {
-      title,
-      owner: options.owner ?? actor,
-      version: options.version ?? "0.1.0",
-      status: status2,
-      distribution: options.distribution ?? "tailscale-shared-vault",
-      tailscale_path: options.tailscalePath,
-      reviewers: options.reviewers ?? [],
-      depends_on: options.dependsOn ?? [],
-      tags: options.tags ?? []
-    }, body, actor, {
-      pathOverride: bundleSkillPath
-    });
-    writeSkillManifest(workspacePath, slug, created, actor);
-    return created;
-  }
-  const updated = update(workspacePath, existing.path, {
-    title,
-    owner: options.owner ?? existing.fields.owner ?? actor,
-    version: options.version ?? existing.fields.version ?? "0.1.0",
-    status: status2,
-    distribution: options.distribution ?? existing.fields.distribution ?? "tailscale-shared-vault",
-    tailscale_path: options.tailscalePath ?? existing.fields.tailscale_path,
-    reviewers: options.reviewers ?? existing.fields.reviewers ?? [],
-    depends_on: options.dependsOn ?? existing.fields.depends_on ?? [],
-    tags: options.tags ?? existing.fields.tags ?? []
-  }, body, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-function loadSkill(workspacePath, skillRef) {
-  const normalizedCandidates = normalizeSkillRefCandidates(skillRef);
-  const skill = normalizedCandidates.map((candidate) => read(workspacePath, candidate)).find((entry) => entry !== null);
-  if (!skill) throw new Error(`Skill not found: ${skillRef}`);
-  if (skill.type !== "skill") throw new Error(`Target is not a skill primitive: ${skillRef}`);
-  return skill;
-}
-function listSkills(workspacePath, options = {}) {
-  let skills = list(workspacePath, "skill");
-  if (options.status) {
-    skills = skills.filter((skill) => skill.fields.status === options.status);
-  }
-  if (options.updatedSince) {
-    const threshold = Date.parse(options.updatedSince);
-    if (Number.isFinite(threshold)) {
-      skills = skills.filter((skill) => {
-        const updatedAt = Date.parse(String(skill.fields.updated ?? ""));
-        return Number.isFinite(updatedAt) && updatedAt >= threshold;
-      });
-    }
-  }
-  return skills;
-}
-function proposeSkill(workspacePath, skillRef, actor, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const slug = skillSlug(String(skill.fields.title ?? skillRef));
-  let proposalThread = options.proposalThread;
-  if (!proposalThread && options.createThreadIfMissing !== false) {
-    const createdThread = createThread(
-      workspacePath,
-      `Review skill: ${String(skill.fields.title)}`,
-      `Review and approve skill ${skill.path} for activation.`,
-      actor,
-      {
-        priority: "medium",
-        space: options.space,
-        context_refs: [skill.path]
-      }
-    );
-    proposalThread = createdThread.path;
-  }
-  const updated = update(workspacePath, skill.path, {
-    status: "proposed",
-    proposal_thread: proposalThread ?? skill.fields.proposal_thread,
-    proposed_at: (/* @__PURE__ */ new Date()).toISOString(),
-    reviewers: options.reviewers ?? skill.fields.reviewers ?? []
-  }, void 0, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-function skillHistory(workspacePath, skillRef, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const entries = historyOf(workspacePath, skill.path);
-  if (options.limit && options.limit > 0) {
-    return entries.slice(-options.limit);
-  }
-  return entries;
-}
-function skillDiff(workspacePath, skillRef) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const entries = historyOf(workspacePath, skill.path).filter((entry) => entry.op === "create" || entry.op === "update");
-  const latest = entries.length > 0 ? entries[entries.length - 1] : null;
-  const previous = entries.length > 1 ? entries[entries.length - 2] : null;
-  const changedFields = Array.isArray(latest?.data?.changed) ? latest.data.changed.map((value) => String(value)) : latest?.op === "create" ? Object.keys(skill.fields) : [];
-  return {
-    path: skill.path,
-    latestEntryTs: latest?.ts ?? null,
-    previousEntryTs: previous?.ts ?? null,
-    changedFields
-  };
-}
-function promoteSkill(workspacePath, skillRef, actor, options = {}) {
-  const skill = loadSkill(workspacePath, skillRef);
-  const slug = skillSlug(String(skill.fields.title ?? skillRef));
-  const currentVersion = String(skill.fields.version ?? "0.1.0");
-  const nextVersion = options.version ?? bumpPatchVersion(currentVersion);
-  const updated = update(workspacePath, skill.path, {
-    status: "active",
-    version: nextVersion,
-    promoted_at: (/* @__PURE__ */ new Date()).toISOString()
-  }, void 0, actor);
-  writeSkillManifest(workspacePath, slug, updated, actor);
-  return updated;
-}
-function skillSlug(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
-}
-function normalizeSkillRefCandidates(skillRef) {
-  const raw = skillRef.trim();
-  if (!raw) return [];
-  if (raw.includes("/")) {
-    const normalized = raw.endsWith(".md") ? raw : `${raw}.md`;
-    if (normalized.endsWith("/SKILL.md")) return [normalized];
-    if (normalized.endsWith("/SKILL")) return [`${normalized}.md`];
-    if (normalized.endsWith(".md")) {
-      const noExt = normalized.slice(0, -3);
-      return [normalized, `${noExt}/SKILL.md`];
-    }
-    return [normalized, `${normalized}/SKILL.md`];
-  }
-  const slug = skillSlug(raw);
-  return [folderSkillPath(slug), legacySkillPath(slug)];
-}
-function bumpPatchVersion(version) {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return "0.1.0";
-  const major = Number.parseInt(match[1], 10);
-  const minor = Number.parseInt(match[2], 10);
-  const patch = Number.parseInt(match[3], 10) + 1;
-  return `${major}.${minor}.${patch}`;
-}
-function folderSkillPath(slug) {
-  return `skills/${slug}/SKILL.md`;
-}
-function legacySkillPath(slug) {
-  return `skills/${slug}.md`;
-}
-function ensureSkillBundleScaffold(workspacePath, slug) {
-  const skillRoot = path9.join(workspacePath, "skills", slug);
-  fs9.mkdirSync(skillRoot, { recursive: true });
-  for (const subdir of ["scripts", "examples", "tests", "assets"]) {
-    fs9.mkdirSync(path9.join(skillRoot, subdir), { recursive: true });
-  }
-}
-function writeSkillManifest(workspacePath, slug, skill, actor) {
-  const manifestPath = path9.join(workspacePath, "skills", slug, "skill-manifest.json");
-  const dir = path9.dirname(manifestPath);
-  fs9.mkdirSync(dir, { recursive: true });
-  const manifest = {
-    version: 1,
-    slug,
-    title: String(skill.fields.title ?? slug),
-    primitivePath: skill.path,
-    owner: String(skill.fields.owner ?? actor),
-    skillVersion: String(skill.fields.version ?? "0.1.0"),
-    status: String(skill.fields.status ?? "draft"),
-    dependsOn: Array.isArray(skill.fields.depends_on) ? skill.fields.depends_on.map((value) => String(value)) : [],
-    components: {
-      skillDoc: "SKILL.md",
-      scriptsDir: "scripts/",
-      examplesDir: "examples/",
-      testsDir: "tests/",
-      assetsDir: "assets/"
-    },
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs9.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
-}
-
-// src/query.ts
-var query_exports = {};
-__export(query_exports, {
-  keywordSearch: () => keywordSearch,
-  queryPrimitives: () => queryPrimitives
-});
-function queryPrimitives(workspacePath, filters = {}) {
-  const typeNames = filters.type ? [filters.type] : listTypes(workspacePath).map((type) => type.name);
-  const all = typeNames.flatMap((typeName) => list(workspacePath, typeName));
-  const matched = all.filter((instance) => matchesFilters(instance, filters));
-  const offset = Math.max(0, filters.offset ?? 0);
-  const limited = filters.limit && filters.limit >= 0 ? matched.slice(offset, offset + filters.limit) : matched.slice(offset);
-  return limited;
-}
-function keywordSearch(workspacePath, text, filters = {}) {
-  return queryPrimitives(workspacePath, {
-    ...filters,
-    text
-  });
-}
-function matchesFilters(instance, filters) {
-  if (filters.status && String(instance.fields.status ?? "") !== filters.status) return false;
-  if (filters.owner && String(instance.fields.owner ?? "") !== filters.owner) return false;
-  if (filters.tag && !hasTag(instance, filters.tag)) return false;
-  if (filters.pathIncludes && !instance.path.includes(filters.pathIncludes)) return false;
-  if (filters.updatedAfter && !isDateOnOrAfter(instance.fields.updated, filters.updatedAfter)) return false;
-  if (filters.updatedBefore && !isDateOnOrBefore(instance.fields.updated, filters.updatedBefore)) return false;
-  if (filters.createdAfter && !isDateOnOrAfter(instance.fields.created, filters.createdAfter)) return false;
-  if (filters.createdBefore && !isDateOnOrBefore(instance.fields.created, filters.createdBefore)) return false;
-  if (filters.text && !containsText(instance, filters.text)) return false;
-  return true;
-}
-function hasTag(instance, tag) {
-  const tags = instance.fields.tags;
-  if (!Array.isArray(tags)) return false;
-  return tags.map((value) => String(value)).includes(tag);
-}
-function containsText(instance, text) {
-  const haystack = [
-    instance.path,
-    instance.type,
-    stringifyFields(instance.fields),
-    instance.body
-  ].join("\n").toLowerCase();
-  return haystack.includes(text.toLowerCase());
-}
-function stringifyFields(fields) {
-  try {
-    return JSON.stringify(fields);
-  } catch {
-    return "";
-  }
-}
-function isDateOnOrAfter(value, thresholdIso) {
-  const ts = Date.parse(String(value ?? ""));
-  const threshold = Date.parse(thresholdIso);
-  if (!Number.isFinite(ts) || !Number.isFinite(threshold)) return false;
-  return ts >= threshold;
-}
-function isDateOnOrBefore(value, thresholdIso) {
-  const ts = Date.parse(String(value ?? ""));
-  const threshold = Date.parse(thresholdIso);
-  if (!Number.isFinite(ts) || !Number.isFinite(threshold)) return false;
-  return ts <= threshold;
-}
-
-// src/orientation.ts
-var orientation_exports = {};
-__export(orientation_exports, {
-  brief: () => brief,
-  checkpoint: () => checkpoint,
-  intake: () => intake,
-  statusSnapshot: () => statusSnapshot
-});
-function statusSnapshot(workspacePath) {
-  const threads = list(workspacePath, "thread");
-  const allPrimitives = queryPrimitives(workspacePath);
-  const byType = allPrimitives.reduce((acc, instance) => {
-    acc[instance.type] = (acc[instance.type] ?? 0) + 1;
-    return acc;
-  }, {});
-  const claims = allClaims(workspacePath);
-  const ready = listReadyThreads(workspacePath);
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    threads: {
-      total: threads.length,
-      open: threads.filter((item) => item.fields.status === "open").length,
-      active: threads.filter((item) => item.fields.status === "active").length,
-      blocked: threads.filter((item) => item.fields.status === "blocked").length,
-      done: threads.filter((item) => item.fields.status === "done").length,
-      cancelled: threads.filter((item) => item.fields.status === "cancelled").length,
-      ready: ready.length
-    },
-    claims: {
-      active: claims.size
-    },
-    primitives: {
-      total: allPrimitives.length,
-      byType
-    }
-  };
-}
-function brief(workspacePath, actor, options = {}) {
-  const myClaims = [...allClaims(workspacePath).entries()].filter(([, owner]) => owner === actor).map(([target]) => read(workspacePath, target)).filter((instance) => instance !== null);
-  const myOpenThreads = queryPrimitives(workspacePath, {
-    type: "thread",
-    owner: actor
-  }).filter((instance) => ["open", "active"].includes(String(instance.fields.status)));
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    actor,
-    myClaims,
-    myOpenThreads,
-    blockedThreads: blockedThreads(workspacePath),
-    nextReadyThreads: listReadyThreads(workspacePath).slice(0, options.nextCount ?? 5),
-    recentActivity: recent(workspacePath, options.recentCount ?? 12)
+    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 = {}) {
@@ -2196,155 +1716,269 @@ function intake(workspacePath, actor, observation, options = {}) {
   });
 }
 
-// src/board.ts
-var board_exports = {};
-__export(board_exports, {
-  generateKanbanBoard: () => generateKanbanBoard,
-  syncKanbanBoard: () => syncKanbanBoard
-});
-import fs10 from "fs";
-import path10 from "path";
-function generateKanbanBoard(workspacePath, options = {}) {
-  const threads = list(workspacePath, "thread");
-  const grouped = groupThreads(threads);
-  const includeCancelled = options.includeCancelled === true;
-  const lanes = [
-    { title: "Backlog", items: grouped.open, checkChar: " " },
-    { title: "In Progress", items: grouped.active, checkChar: " " },
-    { title: "Blocked", items: grouped.blocked, checkChar: " " },
-    { title: "Done", items: grouped.done, checkChar: "x" }
-  ];
-  if (includeCancelled) {
-    lanes.push({ title: "Cancelled", items: grouped.cancelled, checkChar: "x" });
-  }
-  const content = renderKanbanMarkdown(lanes);
-  const relOutputPath = options.outputPath ?? "ops/Workgraph Board.md";
-  const absOutputPath = resolvePathWithinWorkspace2(workspacePath, relOutputPath);
-  const parentDir = path10.dirname(absOutputPath);
-  if (!fs10.existsSync(parentDir)) fs10.mkdirSync(parentDir, { recursive: true });
-  fs10.writeFileSync(absOutputPath, content, "utf-8");
-  return {
-    outputPath: path10.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    counts: {
-      backlog: grouped.open.length,
-      inProgress: grouped.active.length,
-      blocked: grouped.blocked.length,
-      done: grouped.done.length,
-      cancelled: grouped.cancelled.length
-    },
-    content
-  };
-}
-function syncKanbanBoard(workspacePath, options = {}) {
-  return generateKanbanBoard(workspacePath, options);
-}
-function groupThreads(threads) {
-  const groups = {
-    open: [],
-    active: [],
-    blocked: [],
-    done: [],
-    cancelled: []
-  };
-  for (const thread of threads) {
-    const status2 = String(thread.fields.status ?? "open");
-    switch (status2) {
-      case "active":
-        groups.active.push(thread);
-        break;
-      case "blocked":
-        groups.blocked.push(thread);
-        break;
-      case "done":
-        groups.done.push(thread);
-        break;
-      case "cancelled":
-        groups.cancelled.push(thread);
-        break;
-      case "open":
-      default:
-        groups.open.push(thread);
+// 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 byPriority = (a, b) => {
-    const rank = (value) => {
-      switch (String(value ?? "medium")) {
-        case "urgent":
-          return 0;
-        case "high":
-          return 1;
-        case "medium":
-          return 2;
-        case "low":
-          return 3;
-        default:
-          return 4;
+    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
       }
     };
-    return rank(a.fields.priority) - rank(b.fields.priority) || String(a.fields.title).localeCompare(String(b.fields.title));
-  };
-  groups.open.sort(byPriority);
-  groups.active.sort(byPriority);
-  groups.blocked.sort(byPriority);
-  groups.done.sort(byPriority);
-  groups.cancelled.sort(byPriority);
-  return groups;
-}
-function renderKanbanMarkdown(lanes) {
-  const settings = {
-    "kanban-plugin": "board"
-  };
+  }
+};
+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 = [
-    "---",
-    "kanban-plugin: board",
-    "---",
-    ""
+    `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}`)
   ];
-  for (const lane of lanes) {
-    lines.push(`## ${lane.title}`);
-    lines.push("");
-    for (const thread of lane.items) {
-      const title = String(thread.fields.title ?? thread.path);
-      const priority = String(thread.fields.priority ?? "medium");
-      lines.push(`- [${lane.checkChar}] [[${thread.path}|${title}]] (#${priority})`);
-    }
-    lines.push("");
-    lines.push("");
-    lines.push("");
-  }
-  lines.push("%% kanban:settings");
-  lines.push("```");
-  lines.push(JSON.stringify(settings));
-  lines.push("```");
-  lines.push("%%");
-  lines.push("");
   return lines.join("\n");
 }
-function resolvePathWithinWorkspace2(workspacePath, outputPath) {
-  const base = path10.resolve(workspacePath);
-  const resolved = path10.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path10.sep) && resolved !== base) {
-    throw new Error(`Invalid board output path: ${outputPath}`);
+
+// 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 resolved;
+  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 dispatch_exports = {};
-__export(dispatch_exports, {
-  createRun: () => createRun,
-  followup: () => followup,
-  listRuns: () => listRuns,
-  logs: () => logs,
-  markRun: () => markRun,
-  status: () => status,
-  stop: () => stop
-});
-import fs11 from "fs";
-import path11 from "path";
-import { randomUUID } from "crypto";
 var RUNS_FILE = ".workgraph/dispatch-runs.json";
 function createRun(workspacePath, input) {
   const state = loadRuns(workspacePath);
@@ -2410,11 +2044,18 @@ 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);
@@ -2431,6 +2072,62 @@ function listRuns(workspacePath, options = {}) {
   }
   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);
@@ -2448,16 +2145,16 @@ function setStatus(workspacePath, runId, actor, statusValue, logMessage) {
   return run;
 }
 function runsPath(workspacePath) {
-  return path11.join(workspacePath, RUNS_FILE);
+  return path6.join(workspacePath, RUNS_FILE);
 }
 function loadRuns(workspacePath) {
   const rPath = runsPath(workspacePath);
-  if (!fs11.existsSync(rPath)) {
+  if (!fs6.existsSync(rPath)) {
     const seeded = { version: 1, runs: [] };
     saveRuns(workspacePath, seeded);
     return seeded;
   }
-  const raw = fs11.readFileSync(rPath, "utf-8");
+  const raw = fs6.readFileSync(rPath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     version: parsed.version ?? 1,
@@ -2466,9 +2163,9 @@ function loadRuns(workspacePath) {
 }
 function saveRuns(workspacePath, value) {
   const rPath = runsPath(workspacePath);
-  const dir = path11.dirname(rPath);
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
-  fs11.writeFileSync(rPath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  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);
@@ -2476,6 +2173,9 @@ function getRun(workspacePath, runId) {
 }
 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",
@@ -2492,7 +2192,8 @@ function ensureRunPrimitive(workspacePath, run, actor) {
 
 ${run.objective}
 `,
-    actor
+    actor,
+    { pathOverride: runPrimitivePath }
   );
 }
 function syncRunPrimitive(workspacePath, run, actor) {
@@ -2539,6 +2240,14 @@ function renderRunBody(run) {
     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 = {
@@ -2556,262 +2265,582 @@ function assertRunStatusTransition(from, to, runId) {
   }
 }
 
-// src/onboard.ts
-var onboard_exports = {};
-__export(onboard_exports, {
-  onboardWorkspace: () => onboardWorkspace,
-  updateOnboardingStatus: () => updateOnboardingStatus
-});
-function onboardWorkspace(workspacePath, options) {
-  const spaces = options.spaces && options.spaces.length > 0 ? options.spaces : ["platform", "product", "operations"];
-  const spacesCreated = [];
-  for (const space of spaces) {
-    const title = titleCase2(space);
-    const created = create(
-      workspacePath,
-      "space",
-      {
-        title,
-        description: `${title} workspace lane`,
-        members: [options.actor],
-        tags: ["onboarded"]
-      },
-      `# ${title}
-
-Auto-created during onboarding.
-`,
-      options.actor
-    );
-    spacesCreated.push(created.path);
-  }
-  const threadsCreated = [];
-  if (options.createDemoThreads !== false) {
-    const templates = [
-      { title: "Review workspace policy gates", goal: "Validate sensitive transitions are governed.", space: spacesCreated[0] },
-      { title: "Configure board sync cadence", goal: "Set board update expectations for all agents.", space: spacesCreated[1] ?? spacesCreated[0] },
-      { title: "Establish daily checkpoint routine", goal: "Agents leave actionable hand-off notes.", space: spacesCreated[2] ?? spacesCreated[0] }
-    ];
-    for (const template of templates) {
-      const created = create(
-        workspacePath,
-        "thread",
-        {
-          title: template.title,
-          goal: template.goal,
-          status: "open",
-          priority: "medium",
-          space: template.space,
-          context_refs: [template.space],
-          tags: ["onboarding"]
-        },
-        `## Goal
-
-${template.goal}
-`,
-        options.actor
-      );
-      threadsCreated.push(created.path);
-    }
-  }
-  const boardResult = generateKanbanBoard(workspacePath, { outputPath: "ops/Onboarding Board.md" });
-  const commandCenterResult = generateCommandCenter(workspacePath, {
-    outputPath: "ops/Onboarding Command Center.md",
-    actor: options.actor
+// 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
   });
-  const checkpointResult = checkpoint(
-    workspacePath,
-    options.actor,
-    "Onboarding completed and workspace views initialized.",
+  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",
     {
-      next: ["Claim your next ready thread via `workgraph thread next --claim`"],
-      blocked: [],
-      tags: ["onboarding"]
+      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)
+          }
+        ]
+      };
     }
   );
-  const onboarding = create(
-    workspacePath,
-    "onboarding",
+  server.registerResource(
+    "actor-brief",
+    new ResourceTemplate("workgraph://brief/{actor}", { list: void 0 }),
     {
-      title: `Onboarding for ${options.actor}`,
-      actor: options.actor,
-      status: "active",
-      spaces: spacesCreated,
-      thread_refs: threadsCreated,
-      board: boardResult.outputPath,
-      command_center: commandCenterResult.outputPath,
-      tags: ["onboarding"]
+      title: "Actor Brief",
+      description: "Actor-specific operational brief derived from workspace state.",
+      mimeType: "application/json"
     },
-    [
-      "# Onboarding",
-      "",
-      `Actor: ${options.actor}`,
-      "",
-      "## Spaces",
-      "",
-      ...spacesCreated.map((space) => `- [[${space}]]`),
-      "",
-      "## Starter Threads",
-      "",
-      ...threadsCreated.map((threadRef) => `- [[${threadRef}]]`),
-      "",
-      `Board: [[${boardResult.outputPath}]]`,
-      `Command Center: [[${commandCenterResult.outputPath}]]`,
-      ""
-    ].join("\n"),
-    options.actor
+    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)
+          }
+        ]
+      };
+    }
   );
-  return {
-    actor: options.actor,
-    spacesCreated,
-    threadsCreated,
-    boardPath: boardResult.outputPath,
-    commandCenterPath: commandCenterResult.outputPath,
-    checkpointPath: checkpointResult.path,
-    onboardingPath: onboarding.path
-  };
 }
-function updateOnboardingStatus(workspacePath, onboardingPath, status2, actor) {
-  const onboarding = read(workspacePath, onboardingPath);
-  if (!onboarding) throw new Error(`Onboarding primitive not found: ${onboardingPath}`);
-  if (onboarding.type !== "onboarding") {
-    throw new Error(`Target is not an onboarding primitive: ${onboardingPath}`);
-  }
-  const current = String(onboarding.fields.status ?? "active");
-  const allowed = ONBOARDING_STATUS_TRANSITIONS[current] ?? [];
-  if (!allowed.includes(status2)) {
-    throw new Error(`Invalid onboarding transition: ${current} -> ${status2}. Allowed: ${allowed.join(", ") || "none"}`);
-  }
-  return update(
-    workspacePath,
-    onboardingPath,
-    { status: status2 },
-    void 0,
-    actor
+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);
+      }
+    }
   );
 }
-var ONBOARDING_STATUS_TRANSITIONS = {
-  active: ["paused", "completed"],
-  paused: ["active", "completed"],
-  completed: []
-};
-function titleCase2(value) {
-  return value.split(/[-_\s]/g).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+function resolveActor(actor, defaultActor) {
+  const resolved = actor ?? defaultActor ?? "anonymous";
+  return String(resolved);
 }
-
-// src/search-qmd-adapter.ts
-var search_qmd_adapter_exports = {};
-__export(search_qmd_adapter_exports, {
-  search: () => search
-});
-function search(workspacePath, text, options = {}) {
-  const requestedMode = options.mode ?? "auto";
-  const qmdEnabled = process.env.WORKGRAPH_QMD_ENDPOINT && process.env.WORKGRAPH_QMD_ENDPOINT.trim().length > 0;
-  if (requestedMode === "qmd" && !qmdEnabled) {
-    const results = keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    });
+function checkWriteGate(options, actor, requiredCapabilities) {
+  if (options.readOnly) {
     return {
-      mode: "core",
-      query: text,
-      results,
-      fallbackReason: "QMD mode requested but WORKGRAPH_QMD_ENDPOINT is not configured."
+      allowed: false,
+      reason: "MCP server is configured read-only; write tool is disabled."
     };
   }
-  if (requestedMode === "qmd" && qmdEnabled) {
-    const results = keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    });
+  if (actor === "system") {
+    return { allowed: true };
+  }
+  const party = getParty(options.workspacePath, actor);
+  if (!party) {
     return {
-      mode: "qmd",
-      query: text,
-      results,
-      fallbackReason: "QMD endpoint configured; using core-compatible local ranking in MVP."
+      allowed: false,
+      reason: `Policy gate blocked MCP write: actor "${actor}" is not a registered party.`
     };
   }
-  if (requestedMode === "auto" && qmdEnabled) {
-    const results = keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    });
+  const hasCapability = requiredCapabilities.some((capability) => party.capabilities.includes(capability));
+  if (!hasCapability) {
     return {
-      mode: "qmd",
-      query: text,
-      results,
-      fallbackReason: "Auto mode selected; QMD endpoint detected; using core-compatible local ranking in MVP."
+      allowed: false,
+      reason: `Policy gate blocked MCP write: actor "${actor}" lacks capabilities [${requiredCapabilities.join(", ")}].`
     };
   }
+  return { allowed: true };
+}
+function okResult(data, summary) {
   return {
-    mode: "core",
-    query: text,
-    results: keywordSearch(workspacePath, text, {
-      type: options.type,
-      limit: options.limit
-    })
+    content: [
+      {
+        type: "text",
+        text: `${summary}
+
+${toPrettyJson(data)}`
+      }
+    ],
+    structuredContent: data
   };
 }
-
-// src/trigger.ts
-var trigger_exports = {};
-__export(trigger_exports, {
-  fireTrigger: () => fireTrigger
-});
-import { createHash } from "crypto";
-function fireTrigger(workspacePath, triggerPath, options) {
-  const trigger = read(workspacePath, triggerPath);
-  if (!trigger) throw new Error(`Trigger not found: ${triggerPath}`);
-  if (trigger.type !== "trigger") throw new Error(`Target is not a trigger primitive: ${triggerPath}`);
-  const triggerStatus = String(trigger.fields.status ?? "draft");
-  if (!["approved", "active"].includes(triggerStatus)) {
-    throw new Error(`Trigger must be approved/active to fire. Current status: ${triggerStatus}`);
-  }
-  const objective = options.objective ?? `Trigger ${String(trigger.fields.title ?? triggerPath)} fired action ${String(trigger.fields.action ?? "run")}`;
-  const eventSeed = options.eventKey ?? (/* @__PURE__ */ new Date()).toISOString();
-  const idempotencyKey = buildIdempotencyKey(triggerPath, eventSeed, objective);
-  const run = createRun(workspacePath, {
-    actor: options.actor,
-    objective,
-    context: {
-      trigger_path: triggerPath,
-      trigger_event: String(trigger.fields.event ?? ""),
-      ...options.context
-    },
-    idempotencyKey
-  });
-  append(workspacePath, options.actor, "create", triggerPath, "trigger", {
-    fired: true,
-    event_key: eventSeed,
-    run_id: run.id,
-    idempotency_key: idempotencyKey
-  });
+function errorResult(error) {
+  const text = error instanceof Error ? error.message : String(error);
   return {
-    triggerPath,
-    run,
-    idempotencyKey
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ]
   };
 }
-function buildIdempotencyKey(triggerPath, eventSeed, objective) {
-  return createHash("sha256").update(`${triggerPath}:${eventSeed}:${objective}`).digest("hex").slice(0, 32);
+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,
-  bases_exports,
-  workspace_exports,
-  command_center_exports,
-  skill_exports,
+  keywordSearch,
   query_exports,
+  checkpoint,
   orientation_exports,
-  board_exports,
+  CursorCloudAdapter,
+  createRun,
   dispatch_exports,
-  onboard_exports,
-  search_qmd_adapter_exports,
-  trigger_exports
+  createWorkgraphMcpServer,
+  startWorkgraphMcpServer,
+  mcp_server_exports
 };