@versatly/workgraph 1.1.0 → 1.3.0

package/dist/{chunk-TOFSHG5S.js → chunk-NGRQ6T4O.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-BJVBE7F4.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 = [
@@ -360,8 +363,7 @@ function writeSkill(workspacePath, title, body, actor, options = {}) {
       owner: options.owner ?? actor,
       version: options.version ?? "0.1.0",
       status,
-      distribution: options.distribution ?? "tailscale-shared-vault",
-      tailscale_path: options.tailscalePath,
+      distribution: options.distribution ?? "shared-vault",
       reviewers: options.reviewers ?? [],
       depends_on: options.dependsOn ?? [],
       tags: options.tags ?? []
@@ -376,8 +378,7 @@ function writeSkill(workspacePath, title, body, actor, options = {}) {
     owner: options.owner ?? existing.fields.owner ?? actor,
     version: options.version ?? existing.fields.version ?? "0.1.0",
     status,
-    distribution: options.distribution ?? existing.fields.distribution ?? "tailscale-shared-vault",
-    tailscale_path: options.tailscalePath ?? existing.fields.tailscale_path,
+    distribution: options.distribution ?? existing.fields.distribution ?? "shared-vault",
     reviewers: options.reviewers ?? existing.fields.reviewers ?? [],
     depends_on: options.dependsOn ?? existing.fields.depends_on ?? [],
     tags: options.tags ?? existing.fields.tags ?? []
@@ -1610,6 +1611,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 +1931,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 +1996,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 +2014,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 +2356,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 +2368,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 +2420,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 +2455,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 +2485,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 +2496,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 +2561,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 +2575,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 +2721,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 +2861,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 +3169,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 +3179,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 +3235,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 +3248,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 +3268,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 +3326,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 +3349,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 +3369,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 +3381,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 +3408,7 @@ export {
   fetchSkillMarkdownFromUrl,
   clawdapus_exports,
   integration_exports,
+  swarm_exports,
   diagnostics_exports,
   autonomy_daemon_exports
 };