@versatly/workgraph 1.1.0 → 1.2.0

package/dist/{chunk-OTSECVE5.js → chunk-G6B47IBD.js}

@@ -6035,7 +6035,10 @@ export {
   trigger_engine_exports,
   createThread,
   listReadyThreads,
+  listReadyThreadsInSpace,
+  claim,
   release,
+  done,
   thread_exports,
   thread_audit_exports,
   autonomy_exports,

package/dist/{chunk-TOFSHG5S.js → chunk-MCHTUXG2.js}

@@ -3,13 +3,16 @@ import {
   allClaims,
   append,
   checkpoint,
+  claim,
   create,
   createRun,
   createThread,
+  done,
   historyOf,
   keywordSearch,
   list,
   listReadyThreads,
+  listReadyThreadsInSpace,
   listRuns,
   listTypes,
   loadPolicyRegistry,
@@ -23,7 +26,7 @@ import {
   saveRegistry,
   stop,
   update
-} from "./chunk-OTSECVE5.js";
+} from "./chunk-G6B47IBD.js";
 
 // src/workspace.ts
 var workspace_exports = {};
@@ -300,7 +303,7 @@ function renderCommandCenter(input) {
   const claimsSection = [
     "## Active Claims",
     "",
-    ...input.claims.length > 0 ? input.claims.map((claim) => `- ${claim.owner} -> \`${claim.target}\``) : ["- None"],
+    ...input.claims.length > 0 ? input.claims.map((claim2) => `- ${claim2.owner} -> \`${claim2.target}\``) : ["- None"],
     ""
   ];
   const blockedSection = [
@@ -1610,6 +1613,311 @@ function supportedIntegrationList() {
   return Object.keys(INTEGRATIONS).sort().join(", ");
 }
 
+// src/swarm.ts
+var swarm_exports = {};
+__export(swarm_exports, {
+  createPlanTemplate: () => createPlanTemplate,
+  deployPlan: () => deployPlan,
+  getSwarmStatus: () => getSwarmStatus,
+  synthesize: () => synthesize,
+  validatePlan: () => validatePlan,
+  workerClaim: () => workerClaim,
+  workerComplete: () => workerComplete,
+  workerLoop: () => workerLoop
+});
+import * as fs7 from "fs";
+import * as path7 from "path";
+function createPlanTemplate(goal) {
+  return {
+    goal,
+    tasks: [],
+    phases: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    estimatedTotalMinutes: 0
+  };
+}
+function validatePlan(plan) {
+  const errors = [];
+  if (!plan.goal.title) errors.push("Goal title is required");
+  if (plan.tasks.length === 0) errors.push("Plan has no tasks");
+  if (plan.tasks.length > (plan.goal.maxTasks ?? 1e3)) {
+    errors.push(`Plan has ${plan.tasks.length} tasks, exceeds max ${plan.goal.maxTasks ?? 1e3}`);
+  }
+  const taskTitles = new Set(plan.tasks.map((t) => t.title));
+  for (const task of plan.tasks) {
+    for (const dep of task.dependsOn ?? []) {
+      if (!taskTitles.has(dep)) {
+        errors.push(`Task "${task.title}" depends on unknown task "${dep}"`);
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const depMap = /* @__PURE__ */ new Map();
+  for (const task of plan.tasks) {
+    depMap.set(task.title, task.dependsOn ?? []);
+  }
+  function hasCycle(node) {
+    if (stack.has(node)) return true;
+    if (visited.has(node)) return false;
+    visited.add(node);
+    stack.add(node);
+    for (const dep of depMap.get(node) ?? []) {
+      if (hasCycle(dep)) return true;
+    }
+    stack.delete(node);
+    return false;
+  }
+  for (const task of plan.tasks) {
+    visited.clear();
+    stack.clear();
+    if (hasCycle(task.title)) {
+      errors.push(`Circular dependency detected involving "${task.title}"`);
+      break;
+    }
+  }
+  for (const phase of plan.phases) {
+    for (const idx of phase.taskIndices) {
+      if (idx < 0 || idx >= plan.tasks.length) {
+        errors.push(`Phase "${phase.name}" references invalid task index ${idx}`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function deployPlan(workspacePath, plan, actor) {
+  const validation = validatePlan(plan);
+  if (!validation.valid) {
+    throw new Error(`Invalid plan: ${validation.errors.join("; ")}`);
+  }
+  const spaceSlug = slugify(`swarm-${plan.goal.title}`);
+  const spacePath = path7.join("spaces", `${spaceSlug}.md`);
+  const spaceFullPath = path7.join(workspacePath, spacePath);
+  if (!fs7.existsSync(spaceFullPath)) {
+    const spaceDir = path7.join(workspacePath, "spaces");
+    fs7.mkdirSync(spaceDir, { recursive: true });
+    const spaceFrontmatter = [
+      "---",
+      `title: "Swarm: ${plan.goal.title}"`,
+      `status: active`,
+      `created: '${(/* @__PURE__ */ new Date()).toISOString()}'`,
+      `updated: '${(/* @__PURE__ */ new Date()).toISOString()}'`,
+      "---",
+      "",
+      `# Swarm Space: ${plan.goal.title}`,
+      "",
+      plan.goal.description,
+      "",
+      `Total tasks: ${plan.tasks.length}`
+    ].join("\n");
+    fs7.writeFileSync(spaceFullPath, spaceFrontmatter);
+  }
+  const threadPaths = [];
+  const slugMap = /* @__PURE__ */ new Map();
+  for (const task of plan.tasks) {
+    const taskSlug = slugify(task.title);
+    slugMap.set(task.title, taskSlug);
+  }
+  for (const task of plan.tasks) {
+    const taskSlug = slugMap.get(task.title);
+    let body = `# ${task.title}
+
+${task.description}
+`;
+    if (task.dependsOn && task.dependsOn.length > 0) {
+      body += `
+## Dependencies
+`;
+      for (const dep of task.dependsOn) {
+        const depSlug = slugMap.get(dep);
+        if (depSlug) {
+          body += `- [[${depSlug}]]
+`;
+        }
+      }
+    }
+    body += `
+## Output
+
+_Agent writes result here._
+`;
+    if (task.tags && task.tags.length > 0) {
+      body += `
+Tags: ${task.tags.join(", ")}
+`;
+    }
+    const created = createThread(workspacePath, task.title, body, actor, {
+      priority: task.priority,
+      space: `spaces/${spaceSlug}`
+    });
+    threadPaths.push(created.path);
+  }
+  const deployment = {
+    planPath: path7.join(".workgraph", `swarm-${spaceSlug}.json`),
+    workspacePath,
+    threadPaths,
+    spaceSlug,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "deployed"
+  };
+  const manifestPath = path7.join(workspacePath, deployment.planPath);
+  fs7.mkdirSync(path7.dirname(manifestPath), { recursive: true });
+  fs7.writeFileSync(manifestPath, JSON.stringify({ plan, deployment }, null, 2));
+  append(workspacePath, actor, "create", deployment.planPath, "swarm");
+  return deployment;
+}
+function getSwarmStatus(workspacePath, spaceSlug) {
+  const manifestPath = path7.join(workspacePath, ".workgraph", `swarm-${spaceSlug}.json`);
+  if (!fs7.existsSync(manifestPath)) {
+    throw new Error(`No swarm deployment found for space "${spaceSlug}"`);
+  }
+  const manifest = JSON.parse(fs7.readFileSync(manifestPath, "utf-8"));
+  const deployment = manifest.deployment;
+  const threads = [];
+  let claimed = 0;
+  let done2 = 0;
+  let blocked = 0;
+  let open = 0;
+  for (const threadPath of deployment.threadPaths) {
+    const t = read(workspacePath, threadPath);
+    if (!t) continue;
+    const status = String(t.fields.status ?? "open");
+    const threadInfo = {
+      path: threadPath,
+      title: String(t.fields.title ?? ""),
+      status,
+      owner: t.fields.owner ? String(t.fields.owner) : void 0,
+      priority: String(t.fields.priority ?? "medium")
+    };
+    threads.push(threadInfo);
+    if (status === "done") done2++;
+    else if (status === "active") claimed++;
+    else if (status === "blocked") blocked++;
+    else open++;
+  }
+  const total = deployment.threadPaths.length;
+  const readyToClaim = open;
+  const percentComplete = total > 0 ? Math.round(done2 / total * 100) : 0;
+  if (done2 === total) deployment.status = "done";
+  else if (claimed > 0 || done2 > 0) deployment.status = "running";
+  return {
+    deployment,
+    total,
+    claimed,
+    done: done2,
+    blocked,
+    open,
+    readyToClaim,
+    percentComplete,
+    threads
+  };
+}
+function workerClaim(workspacePath, spaceSlug, agent) {
+  const ready = listReadyThreadsInSpace(workspacePath, `spaces/${spaceSlug}`);
+  if (ready.length === 0) return null;
+  const priorityOrder = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  ready.sort((a, b) => {
+    const aPri = priorityOrder[String(a.fields.priority)] ?? 2;
+    const bPri = priorityOrder[String(b.fields.priority)] ?? 2;
+    return aPri - bPri;
+  });
+  const target = ready[0];
+  return claim(workspacePath, target.path, agent);
+}
+function workerComplete(workspacePath, threadPath, agent, result) {
+  const t = read(workspacePath, threadPath);
+  if (!t) throw new Error(`Thread not found: ${threadPath}`);
+  const currentBody = t.body ?? "";
+  const updatedBody = currentBody.replace(
+    "_Agent writes result here._",
+    result
+  );
+  return done(workspacePath, threadPath, agent, updatedBody);
+}
+async function workerLoop(workspacePath, spaceSlug, agent, workFn, options) {
+  let completed = 0;
+  let errors = 0;
+  const maxTasks = options?.maxTasks ?? Infinity;
+  const delayMs = options?.delayMs ?? 1e3;
+  while (completed + errors < maxTasks) {
+    const claimed = workerClaim(workspacePath, spaceSlug, agent);
+    if (!claimed) break;
+    try {
+      const result = await workFn(claimed);
+      workerComplete(workspacePath, claimed.path, agent, result);
+      completed++;
+    } catch (err) {
+      errors++;
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      try {
+        update(workspacePath, claimed.path, {
+          status: "blocked"
+        }, `Error: ${errorMsg}`, agent);
+      } catch {
+      }
+    }
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return { completed, errors };
+}
+function synthesize(workspacePath, spaceSlug) {
+  const status = getSwarmStatus(workspacePath, spaceSlug);
+  const sections = [];
+  const manifestPath = path7.join(workspacePath, ".workgraph", `swarm-${spaceSlug}.json`);
+  const manifest = JSON.parse(fs7.readFileSync(manifestPath, "utf-8"));
+  const plan = manifest.plan;
+  sections.push(`# ${plan.goal.title}
+`);
+  sections.push(`${plan.goal.description}
+`);
+  sections.push(`---
+`);
+  for (const threadInfo of status.threads) {
+    const t = read(workspacePath, threadInfo.path);
+    if (!t) continue;
+    if (threadInfo.status !== "done") {
+      sections.push(`## [PENDING] ${threadInfo.title}
+
+_Not yet completed._
+`);
+      continue;
+    }
+    const body = t.body ?? "";
+    const result = body.replace(/^#\s+.*\n/, "").trim();
+    if (result && result !== "_Agent writes result here._") {
+      sections.push(`## ${threadInfo.title}
+
+${result}
+`);
+    } else {
+      sections.push(`## ${threadInfo.title}
+
+_Completed but no output found._
+`);
+    }
+  }
+  sections.push(`
+---
+`);
+  sections.push(`*Generated from swarm "${plan.goal.title}" \u2014 ${status.done}/${status.total} tasks completed.*
+`);
+  return {
+    markdown: sections.join("\n"),
+    completedCount: status.done,
+    totalCount: status.total
+  };
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").substring(0, 80);
+}
+
 // src/diagnostics/index.ts
 var diagnostics_exports = {};
 __export(diagnostics_exports, {
@@ -1625,8 +1933,8 @@ __export(diagnostics_exports, {
 });
 
 // src/diagnostics/doctor.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import YAML2 from "yaml";
 
 // src/diagnostics/format.ts
@@ -1690,7 +1998,7 @@ function inferPrimitiveTypeFromPath(targetPath) {
 }
 
 // src/diagnostics/primitives.ts
-import path7 from "path";
+import path8 from "path";
 function loadPrimitiveInventory(workspacePath) {
   const registry = loadRegistry(workspacePath);
   const allPrimitives = queryPrimitives(workspacePath);
@@ -1708,7 +2016,7 @@ function loadPrimitiveInventory(workspacePath) {
     const requiredFields = Object.entries(typeDef?.fields ?? {}).filter(([, fieldDef]) => fieldDef.required === true).map(([fieldName]) => fieldName);
     const presentCount = requiredFields.filter((fieldName) => hasRequiredValue(instance.fields[fieldName])).length;
     const frontmatterCompleteness = requiredFields.length === 0 ? 1 : presentCount / requiredFields.length;
-    const slug = path7.basename(instance.path, ".md");
+    const slug = path8.basename(instance.path, ".md");
     return {
       ...instance,
       slug,
@@ -2050,8 +2358,8 @@ function collectStaleRuns(workspacePath, staleAfterMs, now) {
 }
 function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
   const issues = [];
-  const manifestPath = path8.join(workspacePath, ".workgraph", "primitive-registry.yaml");
-  if (!fs7.existsSync(manifestPath)) {
+  const manifestPath = path9.join(workspacePath, ".workgraph", "primitive-registry.yaml");
+  if (!fs8.existsSync(manifestPath)) {
     issues.push({
       code: "broken-primitive-registry-reference",
       severity: "error",
@@ -2062,7 +2370,7 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
   }
   let parsed;
   try {
-    parsed = YAML2.parse(fs7.readFileSync(manifestPath, "utf-8"));
+    parsed = YAML2.parse(fs8.readFileSync(manifestPath, "utf-8"));
   } catch (error) {
     issues.push({
       code: "broken-primitive-registry-reference",
@@ -2114,7 +2422,7 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
         path: ".workgraph/primitive-registry.yaml"
       });
     }
-    if (!fs7.existsSync(path8.join(workspacePath, directory))) {
+    if (!fs8.existsSync(path9.join(workspacePath, directory))) {
       issues.push({
         code: "broken-primitive-registry-reference",
         severity: "error",
@@ -2149,8 +2457,8 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
 function collectEmptyPrimitiveDirectoryIssues(workspacePath, inventory) {
   const issues = [];
   for (const typeDef of inventory.typeDefs.values()) {
-    const directoryPath = path8.join(workspacePath, typeDef.directory);
-    if (!fs7.existsSync(directoryPath)) continue;
+    const directoryPath = path9.join(workspacePath, typeDef.directory);
+    if (!fs8.existsSync(directoryPath)) continue;
     const markdownCount = listMarkdownFilesRecursive(directoryPath).length;
     if (markdownCount > 0) continue;
     issues.push({
@@ -2179,10 +2487,10 @@ function removeOrphanLinks(workspacePath, orphanLinks) {
   }
   let removedLinks = 0;
   for (const [sourcePath, tokenSet] of tokensBySource.entries()) {
-    const absPath = path8.join(workspacePath, sourcePath);
-    if (!fs7.existsSync(absPath)) continue;
+    const absPath = path9.join(workspacePath, sourcePath);
+    if (!fs8.existsSync(absPath)) continue;
     try {
-      const raw = fs7.readFileSync(absPath, "utf-8");
+      const raw = fs8.readFileSync(absPath, "utf-8");
       let fileRemoved = 0;
       const updated = raw.replace(/\[\[([^[\]]+)\]\]/g, (token) => {
         if (!tokenSet.has(token)) return token;
@@ -2190,7 +2498,7 @@ function removeOrphanLinks(workspacePath, orphanLinks) {
         return "";
       });
       if (fileRemoved === 0) continue;
-      fs7.writeFileSync(absPath, updated, "utf-8");
+      fs8.writeFileSync(absPath, updated, "utf-8");
       removedLinks += fileRemoved;
       filesUpdated.push(sourcePath);
     } catch (error) {
@@ -2255,10 +2563,10 @@ function cancelStaleRuns(workspacePath, staleRuns, actor) {
   return { cancelled, errors };
 }
 function readDispatchRunsSnapshot(workspacePath) {
-  const runsPath = path8.join(workspacePath, ".workgraph", "dispatch-runs.json");
-  if (!fs7.existsSync(runsPath)) return [];
+  const runsPath = path9.join(workspacePath, ".workgraph", "dispatch-runs.json");
+  if (!fs8.existsSync(runsPath)) return [];
   try {
-    const parsed = JSON.parse(fs7.readFileSync(runsPath, "utf-8"));
+    const parsed = JSON.parse(fs8.readFileSync(runsPath, "utf-8"));
     return Array.isArray(parsed.runs) ? parsed.runs : [];
   } catch {
     return [];
@@ -2269,9 +2577,9 @@ function listMarkdownFilesRecursive(rootDirectory) {
   const stack = [rootDirectory];
   while (stack.length > 0) {
     const current = stack.pop();
-    const entries = fs7.readdirSync(current, { withFileTypes: true });
+    const entries = fs8.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
-      const absPath = path8.join(current, entry.name);
+      const absPath = path9.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(absPath);
         continue;
@@ -2415,7 +2723,7 @@ function toNullableString(value) {
 }
 
 // src/diagnostics/viz.ts
-import path9 from "path";
+import path10 from "path";
 var TYPE_COLORS = ["cyan", "magenta", "yellow", "green", "blue", "red"];
 function visualizeVaultGraph(workspacePath, options = {}) {
   const inventory = loadPrimitiveInventory(workspacePath);
@@ -2555,7 +2863,7 @@ function resolveFocusPath(focusInput, inventory) {
   const directCandidate = normalized.endsWith(".md") ? normalized : `${normalized}.md`;
   if (inventory.byPath.has(normalized)) return normalized;
   if (inventory.byPath.has(directCandidate)) return directCandidate;
-  const slug = path9.basename(normalized, ".md");
+  const slug = path10.basename(normalized, ".md");
   const candidates = inventory.slugToPaths.get(slug) ?? [];
   if (candidates.length === 1) return candidates[0];
   if (candidates.length > 1) {
@@ -2863,8 +3171,8 @@ __export(autonomy_daemon_exports, {
   startAutonomyDaemon: () => startAutonomyDaemon,
   stopAutonomyDaemon: () => stopAutonomyDaemon
 });
-import fs8 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path11 from "path";
 import { spawn } from "child_process";
 var DAEMON_DIR = ".workgraph/daemon";
 var AUTONOMY_PID_FILE = "autonomy.pid";
@@ -2873,29 +3181,29 @@ var AUTONOMY_LOG_FILE = "autonomy.log";
 var AUTONOMY_META_FILE = "autonomy-process.json";
 function startAutonomyDaemon(workspacePath, input) {
   const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path10.join(daemonDir, AUTONOMY_PID_FILE);
-  const heartbeatPath = input.heartbeatPath ? resolvePathWithinWorkspace4(workspacePath, input.heartbeatPath) : path10.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
-  const logPath = input.logPath ? resolvePathWithinWorkspace4(workspacePath, input.logPath) : path10.join(daemonDir, AUTONOMY_LOG_FILE);
-  const metaPath = path10.join(daemonDir, AUTONOMY_META_FILE);
+  const pidPath = path11.join(daemonDir, AUTONOMY_PID_FILE);
+  const heartbeatPath = input.heartbeatPath ? resolvePathWithinWorkspace4(workspacePath, input.heartbeatPath) : path11.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
+  const logPath = input.logPath ? resolvePathWithinWorkspace4(workspacePath, input.logPath) : path11.join(daemonDir, AUTONOMY_LOG_FILE);
+  const metaPath = path11.join(daemonDir, AUTONOMY_META_FILE);
   const existing = readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true });
   if (existing.running) {
     throw new Error(`Autonomy daemon already running (pid=${existing.pid}). Stop it before starting a new one.`);
   }
-  const logFd = fs8.openSync(logPath, "a");
+  const logFd = fs9.openSync(logPath, "a");
   const args = buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath);
   const child = spawn(process.execPath, args, {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: process.env
   });
-  fs8.closeSync(logFd);
+  fs9.closeSync(logFd);
   child.unref();
   if (!child.pid) {
     throw new Error("Failed to start autonomy daemon: missing child process pid.");
   }
-  fs8.writeFileSync(pidPath, `${child.pid}
+  fs9.writeFileSync(pidPath, `${child.pid}
 `, "utf-8");
-  fs8.writeFileSync(metaPath, JSON.stringify({
+  fs9.writeFileSync(metaPath, JSON.stringify({
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     pid: child.pid,
     args,
@@ -2929,9 +3237,9 @@ async function stopAutonomyDaemon(workspacePath, input = {}) {
     await waitForProcessExit(pid, 1500);
     stopped = !isProcessAlive(pid);
   }
-  const pidPath = path10.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
-  if (stopped && fs8.existsSync(pidPath)) {
-    fs8.rmSync(pidPath, { force: true });
+  const pidPath = path11.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
+  if (stopped && fs9.existsSync(pidPath)) {
+    fs9.rmSync(pidPath, { force: true });
   }
   return {
     stopped,
@@ -2942,14 +3250,14 @@ async function stopAutonomyDaemon(workspacePath, input = {}) {
 }
 function readAutonomyDaemonStatus(workspacePath, options = {}) {
   const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path10.join(daemonDir, AUTONOMY_PID_FILE);
-  const meta = readDaemonMeta(path10.join(daemonDir, AUTONOMY_META_FILE));
-  const logPath = meta?.logPath ? String(meta.logPath) : path10.join(daemonDir, AUTONOMY_LOG_FILE);
-  const heartbeatPath = meta?.heartbeatPath ? String(meta.heartbeatPath) : path10.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
+  const pidPath = path11.join(daemonDir, AUTONOMY_PID_FILE);
+  const meta = readDaemonMeta(path11.join(daemonDir, AUTONOMY_META_FILE));
+  const logPath = meta?.logPath ? String(meta.logPath) : path11.join(daemonDir, AUTONOMY_LOG_FILE);
+  const heartbeatPath = meta?.heartbeatPath ? String(meta.heartbeatPath) : path11.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
   const pid = readPid(pidPath);
   const running = pid ? isProcessAlive(pid) : false;
-  if (!running && pid && options.cleanupStalePidFile !== false && fs8.existsSync(pidPath)) {
-    fs8.rmSync(pidPath, { force: true });
+  if (!running && pid && options.cleanupStalePidFile !== false && fs9.existsSync(pidPath)) {
+    fs9.rmSync(pidPath, { force: true });
   }
   return {
     running,
@@ -2962,7 +3270,7 @@ function readAutonomyDaemonStatus(workspacePath, options = {}) {
 }
 function buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath) {
   const args = [
-    path10.resolve(input.cliEntrypointPath),
+    path11.resolve(input.cliEntrypointPath),
     "autonomy",
     "run",
     "-w",
@@ -3020,22 +3328,22 @@ function waitForProcessExit(pid, timeoutMs) {
   });
 }
 function ensureDaemonDir(workspacePath) {
-  const daemonDir = path10.join(workspacePath, DAEMON_DIR);
-  if (!fs8.existsSync(daemonDir)) fs8.mkdirSync(daemonDir, { recursive: true });
+  const daemonDir = path11.join(workspacePath, DAEMON_DIR);
+  if (!fs9.existsSync(daemonDir)) fs9.mkdirSync(daemonDir, { recursive: true });
   return daemonDir;
 }
 function readPid(pidPath) {
-  if (!fs8.existsSync(pidPath)) return void 0;
-  const raw = fs8.readFileSync(pidPath, "utf-8").trim();
+  if (!fs9.existsSync(pidPath)) return void 0;
+  const raw = fs9.readFileSync(pidPath, "utf-8").trim();
   if (!raw) return void 0;
   const parsed = Number(raw);
   if (!Number.isInteger(parsed) || parsed <= 0) return void 0;
   return parsed;
 }
 function readHeartbeat(heartbeatPath) {
-  if (!fs8.existsSync(heartbeatPath)) return void 0;
+  if (!fs9.existsSync(heartbeatPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs8.readFileSync(heartbeatPath, "utf-8"));
+    const parsed = JSON.parse(fs9.readFileSync(heartbeatPath, "utf-8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     return parsed;
   } catch {
@@ -3043,9 +3351,9 @@ function readHeartbeat(heartbeatPath) {
   }
 }
 function readDaemonMeta(metaPath) {
-  if (!fs8.existsSync(metaPath)) return void 0;
+  if (!fs9.existsSync(metaPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
+    const parsed = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
     return parsed;
   } catch {
@@ -3063,9 +3371,9 @@ function isProcessAlive(pid) {
 }
 function isZombieProcess(pid) {
   const statPath = `/proc/${pid}/stat`;
-  if (!fs8.existsSync(statPath)) return false;
+  if (!fs9.existsSync(statPath)) return false;
   try {
-    const stat = fs8.readFileSync(statPath, "utf-8");
+    const stat = fs9.readFileSync(statPath, "utf-8");
     const closingIdx = stat.indexOf(")");
     if (closingIdx === -1 || closingIdx + 2 >= stat.length) return false;
     const state = stat.slice(closingIdx + 2, closingIdx + 3);
@@ -3075,9 +3383,9 @@ function isZombieProcess(pid) {
   }
 }
 function resolvePathWithinWorkspace4(workspacePath, filePath) {
-  const base = path10.resolve(workspacePath);
-  const resolved = path10.resolve(base, filePath);
-  if (!resolved.startsWith(base + path10.sep) && resolved !== base) {
+  const base = path11.resolve(workspacePath);
+  const resolved = path11.resolve(base, filePath);
+  if (!resolved.startsWith(base + path11.sep) && resolved !== base) {
     throw new Error(`Invalid path outside workspace: ${filePath}`);
   }
   return resolved;
@@ -3102,6 +3410,7 @@ export {
   fetchSkillMarkdownFromUrl,
   clawdapus_exports,
   integration_exports,
+  swarm_exports,
   diagnostics_exports,
   autonomy_daemon_exports
 };

package/dist/cli.js

@@ -11,9 +11,10 @@ import {
   onboard_exports,
   search_qmd_adapter_exports,
   skill_exports,
+  swarm_exports,
   trigger_exports,
   workspace_exports
-} from "./chunk-TOFSHG5S.js";
+} from "./chunk-MCHTUXG2.js";
 import {
   autonomy_exports,
   dispatch_exports,
@@ -29,7 +30,7 @@ import {
   thread_audit_exports,
   thread_exports,
   trigger_engine_exports
-} from "./chunk-OTSECVE5.js";
+} from "./chunk-G6B47IBD.js";
 
 // src/cli.ts
 import fs from "fs";
@@ -1898,6 +1899,85 @@ addWorkspaceOption(
     readOnly: !!opts.readOnly
   });
 });
+var swarmCmd = program.command("swarm").description("Decompose goals into tasks and orchestrate agent swarms");
+addWorkspaceOption(
+  swarmCmd.command("deploy <planFile>").description("Deploy a swarm plan (JSON) into the workspace as threads").option("-a, --actor <name>", "Actor name", DEFAULT_ACTOR).option("--json", "Emit structured JSON output")
+).action(
+  (planFile, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const planPath = path.resolve(planFile);
+      const planData = JSON.parse(fs.readFileSync(planPath, "utf-8"));
+      return swarm_exports.deployPlan(workspacePath, planData, opts.actor);
+    },
+    (result) => [
+      `Swarm deployed: ${result.spaceSlug}`,
+      `Threads: ${result.threadPaths.length}`,
+      `Status: ${result.status}`
+    ]
+  )
+);
+addWorkspaceOption(
+  swarmCmd.command("status <spaceSlug>").description("Show swarm progress").option("--json", "Emit structured JSON output")
+).action(
+  (spaceSlug, opts) => runCommand(
+    opts,
+    () => swarm_exports.getSwarmStatus(resolveWorkspacePath(opts), spaceSlug),
+    (result) => [
+      `Swarm: ${result.deployment.spaceSlug} [${result.deployment.status}]`,
+      `Progress: ${result.done}/${result.total} (${result.percentComplete}%)`,
+      `Claimed: ${result.claimed} | Open: ${result.open} | Blocked: ${result.blocked}`,
+      `Ready to claim: ${result.readyToClaim}`
+    ]
+  )
+);
+addWorkspaceOption(
+  swarmCmd.command("claim <spaceSlug>").description("Claim the next available task in a swarm").option("-a, --actor <name>", "Worker agent name", DEFAULT_ACTOR).option("--json", "Emit structured JSON output")
+).action(
+  (spaceSlug, opts) => runCommand(
+    opts,
+    () => {
+      const result = swarm_exports.workerClaim(resolveWorkspacePath(opts), spaceSlug, opts.actor);
+      if (!result) return { claimed: false, message: "No tasks available" };
+      return { claimed: true, path: result.path, title: result.fields.title };
+    },
+    (result) => result.claimed ? [`Claimed: ${result.path} \u2014 ${result.title}`] : ["No tasks available to claim"]
+  )
+);
+addWorkspaceOption(
+  swarmCmd.command("complete <threadPath>").description("Mark a swarm task as done with result").option("-a, --actor <name>", "Worker agent name", DEFAULT_ACTOR).requiredOption("--result <text>", "Result text (or @file to read from file)").option("--json", "Emit structured JSON output")
+).action(
+  (threadPath, opts) => runCommand(
+    opts,
+    () => {
+      let resultText = opts.result;
+      if (resultText.startsWith("@")) {
+        resultText = fs.readFileSync(resultText.slice(1), "utf-8");
+      }
+      return swarm_exports.workerComplete(resolveWorkspacePath(opts), threadPath, opts.actor, resultText);
+    },
+    (result) => [`Completed: ${result.path}`]
+  )
+);
+addWorkspaceOption(
+  swarmCmd.command("synthesize <spaceSlug>").description("Merge all completed task results into a single document").option("-o, --output <file>", "Output file path").option("--json", "Emit structured JSON output")
+).action(
+  (spaceSlug, opts) => runCommand(
+    opts,
+    () => {
+      const result = swarm_exports.synthesize(resolveWorkspacePath(opts), spaceSlug);
+      if (opts.output) {
+        fs.writeFileSync(path.resolve(opts.output), result.markdown);
+      }
+      return result;
+    },
+    (result) => [
+      `Synthesized: ${result.completedCount}/${result.totalCount} tasks`,
+      opts.output ? `Written to: ${opts.output}` : result.markdown
+    ]
+  )
+);
 await program.parseAsync();
 function addWorkspaceOption(command) {
   return command.option("-w, --workspace <path>", "Workgraph workspace path").option("--vault <path>", "Alias for --workspace").option("--shared-vault <path>", "Shared vault path (e.g. mounted via Tailscale)").option("--dry-run", "Execute against a temporary workspace copy and discard changes");

package/dist/index.d.ts

@@ -1448,6 +1448,144 @@ declare function parseCronExpression(expression: string): CronSchedule;
 declare function matchesCronSchedule(schedule: CronSchedule, date: Date): boolean;
 declare function nextCronMatch(scheduleOrExpression: CronSchedule | string, after: Date, maxSearchMinutes?: number): Date | null;
 
+/**
+ * WorkGraph Swarm — Decompose goals into hundreds of tasks,
+ * spawn agent containers to claim and complete them, merge results.
+ *
+ * Architecture:
+ *   1. Planner: Takes a goal → decomposes into N threads with dependencies
+ *   2. Orchestrator: Spawns containers, each runs a worker that claims threads
+ *   3. Worker: Claims a thread, does work, writes result, marks done
+ *   4. Synthesizer: Watches for completion, merges results
+ */
+
+interface SwarmGoal {
+    title: string;
+    description: string;
+    outputFormat?: 'markdown' | 'json' | 'code';
+    maxTasks?: number;
+    maxConcurrent?: number;
+    tags?: string[];
+}
+interface SwarmTask {
+    title: string;
+    description: string;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    dependsOn?: string[];
+    estimatedMinutes?: number;
+    outputType?: string;
+    tags?: string[];
+}
+interface SwarmPlan {
+    goal: SwarmGoal;
+    tasks: SwarmTask[];
+    phases: SwarmPhase[];
+    createdAt: string;
+    estimatedTotalMinutes: number;
+}
+interface SwarmPhase {
+    name: string;
+    description: string;
+    taskIndices: number[];
+    parallel: boolean;
+}
+interface SwarmDeployment {
+    planPath: string;
+    workspacePath: string;
+    threadPaths: string[];
+    spaceSlug: string;
+    createdAt: string;
+    status: 'deployed' | 'running' | 'completing' | 'done' | 'failed';
+}
+interface SwarmStatus {
+    deployment: SwarmDeployment;
+    total: number;
+    claimed: number;
+    done: number;
+    blocked: number;
+    open: number;
+    readyToClaim: number;
+    percentComplete: number;
+    threads: Array<{
+        path: string;
+        title: string;
+        status: string;
+        owner?: string;
+        priority: string;
+    }>;
+}
+/**
+ * Generate a swarm plan from a goal description.
+ * This creates the plan structure — call deployPlan() to create actual threads.
+ *
+ * In production, pipe goal through an LLM for decomposition.
+ * This function provides the structured output format the LLM should produce.
+ */
+declare function createPlanTemplate(goal: SwarmGoal): SwarmPlan;
+/**
+ * Validate a swarm plan for internal consistency.
+ */
+declare function validatePlan(plan: SwarmPlan): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Deploy a swarm plan into a WorkGraph workspace.
+ * Creates a space for the swarm and threads for each task.
+ * Dependencies are encoded as wiki-links in thread bodies.
+ */
+declare function deployPlan(workspacePath: string, plan: SwarmPlan, actor: string): SwarmDeployment;
+/**
+ * Get the current status of a swarm deployment.
+ */
+declare function getSwarmStatus(workspacePath: string, spaceSlug: string): SwarmStatus;
+/**
+ * Worker claims the next available task in a swarm.
+ * Returns the thread to work on, or null if nothing available.
+ */
+declare function workerClaim(workspacePath: string, spaceSlug: string, agent: string): PrimitiveInstance | null;
+/**
+ * Worker completes a task, writing result to the thread body.
+ */
+declare function workerComplete(workspacePath: string, threadPath: string, agent: string, result: string): PrimitiveInstance;
+/**
+ * Worker loop: claim → work → complete → repeat until no tasks left.
+ * The workFn receives the thread and returns the result string.
+ */
+declare function workerLoop(workspacePath: string, spaceSlug: string, agent: string, workFn: (thread: PrimitiveInstance) => Promise<string>, options?: {
+    maxTasks?: number;
+    delayMs?: number;
+}): Promise<{
+    completed: number;
+    errors: number;
+}>;
+/**
+ * Collect all completed task results from a swarm into a single document.
+ */
+declare function synthesize(workspacePath: string, spaceSlug: string): {
+    markdown: string;
+    completedCount: number;
+    totalCount: number;
+};
+
+type swarm_SwarmDeployment = SwarmDeployment;
+type swarm_SwarmGoal = SwarmGoal;
+type swarm_SwarmPhase = SwarmPhase;
+type swarm_SwarmPlan = SwarmPlan;
+type swarm_SwarmStatus = SwarmStatus;
+type swarm_SwarmTask = SwarmTask;
+declare const swarm_createPlanTemplate: typeof createPlanTemplate;
+declare const swarm_deployPlan: typeof deployPlan;
+declare const swarm_getSwarmStatus: typeof getSwarmStatus;
+declare const swarm_synthesize: typeof synthesize;
+declare const swarm_validatePlan: typeof validatePlan;
+declare const swarm_workerClaim: typeof workerClaim;
+declare const swarm_workerComplete: typeof workerComplete;
+declare const swarm_workerLoop: typeof workerLoop;
+declare namespace swarm {
+  export { type swarm_SwarmDeployment as SwarmDeployment, type swarm_SwarmGoal as SwarmGoal, type swarm_SwarmPhase as SwarmPhase, type swarm_SwarmPlan as SwarmPlan, type swarm_SwarmStatus as SwarmStatus, type swarm_SwarmTask as SwarmTask, swarm_createPlanTemplate as createPlanTemplate, swarm_deployPlan as deployPlan, swarm_getSwarmStatus as getSwarmStatus, swarm_synthesize as synthesize, swarm_validatePlan as validatePlan, swarm_workerClaim as workerClaim, swarm_workerComplete as workerComplete, swarm_workerLoop as workerLoop };
+}
+
 type DoctorSeverity = 'warning' | 'error';
 interface DoctorIssue {
     code: string;
@@ -1780,4 +1918,4 @@ declare class CursorCloudAdapter implements DispatchAdapter {
     execute(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
 }
 
-export { type CronField, type CronSchedule, CursorCloudAdapter, type DispatchAdapter, type DispatchAdapterCreateInput, type DispatchAdapterExecutionInput, type DispatchAdapterExecutionResult, type DispatchAdapterLogEntry, type DispatchAdapterRunStatus, type DispatchRun, type FieldDefinition, type InstallSkillIntegrationOptions, type InstallSkillIntegrationResult, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, type SkillIntegrationProvider, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphLensDescriptor, type WorkgraphLensId, type WorkgraphLensItem, type WorkgraphLensOptions, type WorkgraphLensResult, type WorkgraphLensSection, type WorkgraphMaterializeLensOptions, type WorkgraphMaterializedLensResult, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, agent, autonomy, autonomyDaemon, bases, board, claimLease, clawdapus, commandCenter, index as diagnostics, dispatch, fetchSkillMarkdownFromUrl, gate, graph, installSkillIntegration, integration, ledger, lens, matchesCronSchedule, nextCronMatch, onboard, orientation, parseCronExpression, policy, query, registry, searchQmdAdapter, skill, store, thread, threadAudit, trigger, triggerEngine, workspace };
+export { type CronField, type CronSchedule, CursorCloudAdapter, type DispatchAdapter, type DispatchAdapterCreateInput, type DispatchAdapterExecutionInput, type DispatchAdapterExecutionResult, type DispatchAdapterLogEntry, type DispatchAdapterRunStatus, type DispatchRun, type FieldDefinition, type InstallSkillIntegrationOptions, type InstallSkillIntegrationResult, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, type SkillIntegrationProvider, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphLensDescriptor, type WorkgraphLensId, type WorkgraphLensItem, type WorkgraphLensOptions, type WorkgraphLensResult, type WorkgraphLensSection, type WorkgraphMaterializeLensOptions, type WorkgraphMaterializedLensResult, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, agent, autonomy, autonomyDaemon, bases, board, claimLease, clawdapus, commandCenter, index as diagnostics, dispatch, fetchSkillMarkdownFromUrl, gate, graph, installSkillIntegration, integration, ledger, lens, matchesCronSchedule, nextCronMatch, onboard, orientation, parseCronExpression, policy, query, registry, searchQmdAdapter, skill, store, swarm, thread, threadAudit, trigger, triggerEngine, workspace };

package/dist/index.js

@@ -13,9 +13,10 @@ import {
   onboard_exports,
   search_qmd_adapter_exports,
   skill_exports,
+  swarm_exports,
   trigger_exports,
   workspace_exports
-} from "./chunk-TOFSHG5S.js";
+} from "./chunk-MCHTUXG2.js";
 import {
   CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
@@ -37,7 +38,7 @@ import {
   thread_audit_exports,
   thread_exports,
   trigger_engine_exports
-} from "./chunk-OTSECVE5.js";
+} from "./chunk-G6B47IBD.js";
 export {
   CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
@@ -70,6 +71,7 @@ export {
   search_qmd_adapter_exports as searchQmdAdapter,
   skill_exports as skill,
   store_exports as store,
+  swarm_exports as swarm,
   thread_exports as thread,
   thread_audit_exports as threadAudit,
   trigger_exports as trigger,

package/dist/mcp-server.js

@@ -1,7 +1,7 @@
 import {
   createWorkgraphMcpServer,
   startWorkgraphMcpServer
-} from "./chunk-OTSECVE5.js";
+} from "./chunk-G6B47IBD.js";
 export {
   createWorkgraphMcpServer,
   startWorkgraphMcpServer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatly/workgraph",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Agent-first workgraph workspace for multi-agent coordination with dynamic primitives, append-only ledger, and markdown-native storage.",
   "workspaces": [
     "packages/*"