@versatly/workgraph 1.0.0 → 1.2.0

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

@@ -3,12 +3,17 @@ import {
   allClaims,
   append,
   checkpoint,
+  claim,
   create,
   createRun,
   createThread,
+  done,
   historyOf,
   keywordSearch,
   list,
+  listReadyThreads,
+  listReadyThreadsInSpace,
+  listRuns,
   listTypes,
   loadPolicyRegistry,
   loadRegistry,
@@ -21,7 +26,7 @@ import {
   saveRegistry,
   stop,
   update
-} from "./chunk-R2MLGBHB.js";
+} from "./chunk-G6B47IBD.js";
 
 // src/workspace.ts
 var workspace_exports = {};
@@ -298,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 = [
@@ -532,14 +537,480 @@ function writeSkillManifest(workspacePath, slug, skill, actor) {
   fs4.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 
+// src/lens.ts
+var lens_exports = {};
+__export(lens_exports, {
+  generateContextLens: () => generateContextLens,
+  listContextLenses: () => listContextLenses,
+  materializeContextLens: () => materializeContextLens
+});
+import fs5 from "fs";
+import path5 from "path";
+var DEFAULT_LOOKBACK_HOURS = 24;
+var DEFAULT_STALE_HOURS = 24;
+var DEFAULT_LIMIT = 10;
+var PRIORITY_ORDER = {
+  urgent: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+var HIGH_RISK_PRIORITIES = /* @__PURE__ */ new Set(["urgent", "high"]);
+var HIGH_RISK_SEVERITIES = /* @__PURE__ */ new Set(["sev0", "sev1", "sev2"]);
+var BUILT_IN_LENSES = [
+  {
+    id: "my-work",
+    description: "Actor workload, blockers, stale claims, and ready-next queue"
+  },
+  {
+    id: "team-risk",
+    description: "High-risk blockers, stale active claims, failed runs, and incidents"
+  },
+  {
+    id: "customer-health",
+    description: "Customer-tagged delivery health, blockers, and related incidents"
+  },
+  {
+    id: "exec-brief",
+    description: "Top priorities, momentum, risks, and recent decisions"
+  }
+];
+function listContextLenses() {
+  return BUILT_IN_LENSES.map((lens) => ({ ...lens }));
+}
+function generateContextLens(workspacePath, lensId, options = {}) {
+  const normalizedLensId = normalizeLensId(lensId);
+  const normalizedOptions = normalizeLensOptions(options);
+  switch (normalizedLensId) {
+    case "my-work":
+      return buildMyWorkLens(workspacePath, normalizedOptions);
+    case "team-risk":
+      return buildTeamRiskLens(workspacePath, normalizedOptions);
+    case "customer-health":
+      return buildCustomerHealthLens(workspacePath, normalizedOptions);
+    case "exec-brief":
+      return buildExecBriefLens(workspacePath, normalizedOptions);
+    default:
+      return assertNever(normalizedLensId);
+  }
+}
+function materializeContextLens(workspacePath, lensId, options) {
+  const result = generateContextLens(workspacePath, lensId, options);
+  const absOutputPath = resolvePathWithinWorkspace2(workspacePath, options.outputPath);
+  const relOutputPath = path5.relative(workspacePath, absOutputPath).replace(/\\/g, "/");
+  const parentDir = path5.dirname(absOutputPath);
+  if (!fs5.existsSync(parentDir)) fs5.mkdirSync(parentDir, { recursive: true });
+  const existed = fs5.existsSync(absOutputPath);
+  fs5.writeFileSync(absOutputPath, result.markdown, "utf-8");
+  append(
+    workspacePath,
+    options.actor ?? result.actor ?? "system",
+    existed ? "update" : "create",
+    relOutputPath,
+    "lens",
+    {
+      lens: result.lens,
+      sections: result.sections.length
+    }
+  );
+  return {
+    ...result,
+    outputPath: relOutputPath,
+    created: !existed
+  };
+}
+function buildMyWorkLens(workspacePath, options) {
+  const actor = options.actor;
+  const nowMs = Date.now();
+  const staleCutoffMs = nowMs - options.staleHours * 60 * 60 * 1e3;
+  const claims = [...allClaims(workspacePath).entries()];
+  const myClaimedThreads = claims.filter(([, owner]) => owner === actor).map(([target]) => read(workspacePath, target)).filter((instance) => !!instance && instance.type === "thread").sort(compareThreadsByPriorityThenUpdated);
+  const myBlockedThreads = myClaimedThreads.filter((instance) => String(instance.fields.status ?? "") === "blocked").slice(0, options.limit);
+  const staleClaims = myClaimedThreads.filter((instance) => isStale(instance, staleCutoffMs)).slice(0, options.limit);
+  const nextReady = listReadyThreads(workspacePath).filter((instance) => !instance.fields.owner).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const sections = [
+    {
+      id: "my_claims",
+      title: `Claimed Threads (${actor})`,
+      items: myClaimedThreads.slice(0, options.limit).map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "my_blockers",
+      title: `Blocked Threads (${actor})`,
+      items: myBlockedThreads.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "stale_claims",
+      title: `Stale Claims (${options.staleHours}h+)`,
+      items: staleClaims.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "next_ready",
+      title: "Next Ready Threads",
+      items: nextReady.map((instance) => toThreadItem(instance, nowMs))
+    }
+  ];
+  return finalizeLensResult("my-work", {
+    actor,
+    options,
+    metrics: {
+      myClaims: myClaimedThreads.length,
+      blocked: myBlockedThreads.length,
+      staleClaims: staleClaims.length,
+      nextReady: nextReady.length
+    },
+    sections
+  });
+}
+function buildTeamRiskLens(workspacePath, options) {
+  const nowMs = Date.now();
+  const staleCutoffMs = nowMs - options.staleHours * 60 * 60 * 1e3;
+  const lookbackCutoffMs = nowMs - options.lookbackHours * 60 * 60 * 1e3;
+  const threads = list(workspacePath, "thread");
+  const blockedHighPriority = threads.filter((instance) => String(instance.fields.status ?? "") === "blocked").filter((instance) => HIGH_RISK_PRIORITIES.has(normalizePriority(instance.fields.priority))).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const staleActiveClaims = [...allClaims(workspacePath).entries()].map(([target, owner]) => ({ owner, instance: read(workspacePath, target) })).filter((entry) => !!entry.instance && entry.instance.type === "thread").filter((entry) => String(entry.instance.fields.status ?? "") === "active").filter((entry) => isStale(entry.instance, staleCutoffMs)).slice(0, options.limit);
+  const failedRuns = listRuns(workspacePath, { status: "failed" }).filter((run) => parseTimestamp(run.updatedAt) >= lookbackCutoffMs).slice(0, options.limit);
+  const highSeverityIncidents = list(workspacePath, "incident").filter((incident) => String(incident.fields.status ?? "") === "active").filter((incident) => HIGH_RISK_SEVERITIES.has(normalizeSeverity(incident.fields.severity))).slice(0, options.limit);
+  const sections = [
+    {
+      id: "blocked_high_priority_threads",
+      title: "High Priority Blocked Threads",
+      items: blockedHighPriority.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "stale_active_claims",
+      title: `Stale Active Claims (${options.staleHours}h+)`,
+      items: staleActiveClaims.map((entry) => ({
+        ...toThreadItem(entry.instance, nowMs),
+        owner: entry.owner
+      }))
+    },
+    {
+      id: "failed_runs",
+      title: `Failed Runs (${options.lookbackHours}h window)`,
+      items: failedRuns.map(toRunItem)
+    },
+    {
+      id: "active_high_severity_incidents",
+      title: "Active High-Severity Incidents",
+      items: highSeverityIncidents.map((incident) => toIncidentItem(incident, nowMs))
+    }
+  ];
+  return finalizeLensResult("team-risk", {
+    actor: options.actor,
+    options,
+    metrics: {
+      blockedHighPriority: blockedHighPriority.length,
+      staleActiveClaims: staleActiveClaims.length,
+      failedRuns: failedRuns.length,
+      activeHighSeverityIncidents: highSeverityIncidents.length
+    },
+    sections
+  });
+}
+function buildCustomerHealthLens(workspacePath, options) {
+  const nowMs = Date.now();
+  const customerThreads = list(workspacePath, "thread").filter(isCustomerLinked).sort(compareThreadsByPriorityThenUpdated);
+  const activeCustomerThreads = customerThreads.filter((instance) => ["open", "active"].includes(String(instance.fields.status ?? ""))).slice(0, options.limit);
+  const blockedCustomerThreads = customerThreads.filter((instance) => String(instance.fields.status ?? "") === "blocked").slice(0, options.limit);
+  const customerIncidents = list(workspacePath, "incident").filter((incident) => String(incident.fields.status ?? "") === "active").filter(isCustomerLinked).slice(0, options.limit);
+  const clients = list(workspacePath, "client").slice(0, options.limit);
+  const sections = [
+    {
+      id: "active_customer_threads",
+      title: "Active Customer Threads",
+      items: activeCustomerThreads.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "blocked_customer_threads",
+      title: "Blocked Customer Threads",
+      items: blockedCustomerThreads.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "customer_incidents",
+      title: "Customer Incidents",
+      items: customerIncidents.map((incident) => toIncidentItem(incident, nowMs))
+    },
+    {
+      id: "client_records",
+      title: "Client Records",
+      items: clients.map((instance) => ({
+        title: String(instance.fields.title ?? instance.path),
+        path: instance.path,
+        status: stringOrUndefined(instance.fields.status),
+        detail: stringOrUndefined(instance.fields.health ?? instance.fields.risk),
+        ageHours: ageHours(instance, nowMs)
+      }))
+    }
+  ];
+  return finalizeLensResult("customer-health", {
+    actor: options.actor,
+    options,
+    metrics: {
+      activeCustomerThreads: activeCustomerThreads.length,
+      blockedCustomerThreads: blockedCustomerThreads.length,
+      customerIncidents: customerIncidents.length,
+      clients: clients.length
+    },
+    sections
+  });
+}
+function buildExecBriefLens(workspacePath, options) {
+  const nowMs = Date.now();
+  const lookbackCutoffMs = nowMs - options.lookbackHours * 60 * 60 * 1e3;
+  const threads = list(workspacePath, "thread");
+  const topPriorities = threads.filter((instance) => ["open", "active"].includes(String(instance.fields.status ?? ""))).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const momentum = threads.filter((instance) => String(instance.fields.status ?? "") === "done").filter((instance) => parseTimestamp(instance.fields.updated) >= lookbackCutoffMs).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const blockedHighPriority = threads.filter((instance) => String(instance.fields.status ?? "") === "blocked").filter((instance) => HIGH_RISK_PRIORITIES.has(normalizePriority(instance.fields.priority))).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const failedRuns = listRuns(workspacePath, { status: "failed" }).filter((run) => parseTimestamp(run.updatedAt) >= lookbackCutoffMs).slice(0, options.limit);
+  const decisions = list(workspacePath, "decision").filter((instance) => ["proposed", "approved", "active"].includes(String(instance.fields.status ?? ""))).filter((instance) => parseTimestamp(instance.fields.updated ?? instance.fields.date) >= lookbackCutoffMs).slice(0, options.limit);
+  const sections = [
+    {
+      id: "top_priorities",
+      title: "Top Priorities",
+      items: topPriorities.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "momentum",
+      title: `Momentum (${options.lookbackHours}h completed)`,
+      items: momentum.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "key_risks",
+      title: "Key Risks",
+      items: [
+        ...blockedHighPriority.map((instance) => toThreadItem(instance, nowMs)),
+        ...failedRuns.map(toRunItem)
+      ].slice(0, options.limit)
+    },
+    {
+      id: "recent_decisions",
+      title: `Decisions (${options.lookbackHours}h window)`,
+      items: decisions.map((instance) => ({
+        title: String(instance.fields.title ?? instance.path),
+        path: instance.path,
+        status: stringOrUndefined(instance.fields.status),
+        detail: stringOrUndefined(instance.fields.date),
+        ageHours: ageHours(instance, nowMs)
+      }))
+    }
+  ];
+  return finalizeLensResult("exec-brief", {
+    actor: options.actor,
+    options,
+    metrics: {
+      topPriorities: topPriorities.length,
+      momentumDone: momentum.length,
+      risks: blockedHighPriority.length + failedRuns.length,
+      decisions: decisions.length
+    },
+    sections
+  });
+}
+function finalizeLensResult(lens, input) {
+  const base = {
+    lens,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    actor: input.actor,
+    options: {
+      lookbackHours: input.options.lookbackHours,
+      staleHours: input.options.staleHours,
+      limit: input.options.limit
+    },
+    metrics: input.metrics,
+    sections: input.sections
+  };
+  return {
+    ...base,
+    markdown: renderLensMarkdown(base)
+  };
+}
+function toThreadItem(instance, nowMs) {
+  return {
+    title: String(instance.fields.title ?? instance.path),
+    path: instance.path,
+    status: stringOrUndefined(instance.fields.status),
+    priority: stringOrUndefined(instance.fields.priority),
+    owner: stringOrUndefined(instance.fields.owner),
+    detail: renderThreadDependencies(instance),
+    ageHours: ageHours(instance, nowMs)
+  };
+}
+function toIncidentItem(instance, nowMs) {
+  return {
+    title: String(instance.fields.title ?? instance.path),
+    path: instance.path,
+    status: stringOrUndefined(instance.fields.status),
+    priority: stringOrUndefined(instance.fields.severity),
+    owner: stringOrUndefined(instance.fields.owner),
+    ageHours: ageHours(instance, nowMs)
+  };
+}
+function toRunItem(run) {
+  return {
+    title: run.objective,
+    path: `runs/${run.id}.md`,
+    status: run.status,
+    owner: run.actor,
+    detail: run.error ?? run.output,
+    ageHours: ageHoursFromIso(run.updatedAt)
+  };
+}
+function renderLensMarkdown(input) {
+  const lines = [
+    `# Workgraph Context Lens: ${input.lens}`,
+    "",
+    `Generated: ${input.generatedAt}`,
+    ...input.actor ? [`Actor: ${input.actor}`] : [],
+    `Lookback: ${input.options.lookbackHours}h`,
+    `Stale threshold: ${input.options.staleHours}h`,
+    `Section limit: ${input.options.limit}`,
+    "",
+    "## Metrics",
+    "",
+    ...Object.entries(input.metrics).map(([metric, value]) => `- ${metric}: ${value}`),
+    ""
+  ];
+  for (const section of input.sections) {
+    lines.push(`## ${section.title}`);
+    lines.push("");
+    if (section.items.length === 0) {
+      lines.push("- None");
+      lines.push("");
+      continue;
+    }
+    for (const item of section.items) {
+      lines.push(`- ${renderLensItem(item)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderLensItem(item) {
+  const components = [item.title];
+  if (item.path) components.push(`(\`${item.path}\`)`);
+  const metadata = [];
+  if (item.status) metadata.push(`status=${item.status}`);
+  if (item.priority) metadata.push(`priority=${item.priority}`);
+  if (item.owner) metadata.push(`owner=${item.owner}`);
+  if (typeof item.ageHours === "number") metadata.push(`age=${item.ageHours.toFixed(1)}h`);
+  if (metadata.length > 0) components.push(`[${metadata.join(", ")}]`);
+  if (item.detail) components.push(`- ${item.detail}`);
+  return components.join(" ");
+}
+function resolvePathWithinWorkspace2(workspacePath, outputPath) {
+  const base = path5.resolve(workspacePath);
+  const resolved = path5.resolve(base, outputPath);
+  if (!resolved.startsWith(base + path5.sep) && resolved !== base) {
+    throw new Error(`Invalid lens output path: ${outputPath}`);
+  }
+  return resolved;
+}
+function normalizeLensId(value) {
+  const normalized = String(value).trim().toLowerCase().replace(/^lens:\/\//, "");
+  if (normalized === "my-work") return "my-work";
+  if (normalized === "team-risk") return "team-risk";
+  if (normalized === "customer-health") return "customer-health";
+  if (normalized === "exec-brief") return "exec-brief";
+  const valid = BUILT_IN_LENSES.map((item) => item.id).join(", ");
+  throw new Error(`Unknown context lens "${value}". Valid lenses: ${valid}`);
+}
+function normalizeLensOptions(options) {
+  return {
+    actor: String(options.actor ?? "anonymous").trim() || "anonymous",
+    lookbackHours: parsePositiveNumber(options.lookbackHours, "lookbackHours", DEFAULT_LOOKBACK_HOURS),
+    staleHours: parsePositiveNumber(options.staleHours, "staleHours", DEFAULT_STALE_HOURS),
+    limit: parsePositiveInteger(options.limit, "limit", DEFAULT_LIMIT)
+  };
+}
+function parsePositiveNumber(value, fieldName, defaultValue) {
+  if (value === void 0 || value === null) return defaultValue;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${fieldName}: expected a positive number.`);
+  }
+  return parsed;
+}
+function parsePositiveInteger(value, fieldName, defaultValue) {
+  if (value === void 0 || value === null) return defaultValue;
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${fieldName}: expected a positive integer.`);
+  }
+  return parsed;
+}
+function compareThreadsByPriorityThenUpdated(a, b) {
+  const priorityDelta = rankPriority(a) - rankPriority(b);
+  if (priorityDelta !== 0) return priorityDelta;
+  return parseTimestamp(b.fields.updated) - parseTimestamp(a.fields.updated);
+}
+function rankPriority(instance) {
+  const priority = normalizePriority(instance.fields.priority);
+  return PRIORITY_ORDER[priority] ?? PRIORITY_ORDER.medium;
+}
+function normalizePriority(value) {
+  return String(value ?? "medium").trim().toLowerCase();
+}
+function normalizeSeverity(value) {
+  return String(value ?? "sev4").trim().toLowerCase();
+}
+function isStale(instance, staleCutoffMs) {
+  const updatedAt = parseTimestamp(instance.fields.updated ?? instance.fields.created);
+  if (!Number.isFinite(updatedAt)) return false;
+  return updatedAt <= staleCutoffMs;
+}
+function parseTimestamp(value) {
+  const parsed = Date.parse(String(value ?? ""));
+  return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+}
+function ageHours(instance, nowMs) {
+  const updatedAt = parseTimestamp(instance.fields.updated ?? instance.fields.created);
+  if (!Number.isFinite(updatedAt)) return void 0;
+  return Math.max(0, (nowMs - updatedAt) / (60 * 60 * 1e3));
+}
+function ageHoursFromIso(value) {
+  const nowMs = Date.now();
+  const ts = parseTimestamp(value);
+  if (!Number.isFinite(ts)) return void 0;
+  return Math.max(0, (nowMs - ts) / (60 * 60 * 1e3));
+}
+function renderThreadDependencies(instance) {
+  const deps = instance.fields.deps;
+  if (!Array.isArray(deps) || deps.length === 0) return void 0;
+  const visible = deps.slice(0, 3).map((value) => String(value));
+  const suffix = deps.length > visible.length ? ` +${deps.length - visible.length} more` : "";
+  return `deps: ${visible.join(", ")}${suffix}`;
+}
+function isCustomerLinked(instance) {
+  const tags = normalizeTags(instance.fields.tags);
+  if (tags.includes("customer") || tags.includes("client")) return true;
+  const candidateFields = ["client", "client_ref", "customer", "customer_ref", "account", "account_ref"];
+  return candidateFields.some((key) => {
+    const value = instance.fields[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+function normalizeTags(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => String(item).trim().toLowerCase()).filter(Boolean);
+}
+function stringOrUndefined(value) {
+  if (value === void 0 || value === null) return void 0;
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function assertNever(value) {
+  throw new Error(`Unhandled lens variant: ${String(value)}`);
+}
+
 // src/board.ts
 var board_exports = {};
 __export(board_exports, {
   generateKanbanBoard: () => generateKanbanBoard,
   syncKanbanBoard: () => syncKanbanBoard
 });
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function generateKanbanBoard(workspacePath, options = {}) {
   const threads = list(workspacePath, "thread");
   const grouped = groupThreads(threads);
@@ -555,12 +1026,12 @@ function generateKanbanBoard(workspacePath, options = {}) {
   }
   const content = renderKanbanMarkdown(lanes);
   const relOutputPath = options.outputPath ?? "ops/Workgraph Board.md";
-  const absOutputPath = resolvePathWithinWorkspace2(workspacePath, relOutputPath);
-  const parentDir = path5.dirname(absOutputPath);
-  if (!fs5.existsSync(parentDir)) fs5.mkdirSync(parentDir, { recursive: true });
-  fs5.writeFileSync(absOutputPath, content, "utf-8");
+  const absOutputPath = resolvePathWithinWorkspace3(workspacePath, relOutputPath);
+  const parentDir = path6.dirname(absOutputPath);
+  if (!fs6.existsSync(parentDir)) fs6.mkdirSync(parentDir, { recursive: true });
+  fs6.writeFileSync(absOutputPath, content, "utf-8");
   return {
-    outputPath: path5.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
+    outputPath: path6.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     counts: {
       backlog: grouped.open.length,
@@ -658,10 +1129,10 @@ function renderKanbanMarkdown(lanes) {
   lines.push("");
   return lines.join("\n");
 }
-function resolvePathWithinWorkspace2(workspacePath, outputPath) {
-  const base = path5.resolve(workspacePath);
-  const resolved = path5.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path5.sep) && resolved !== base) {
+function resolvePathWithinWorkspace3(workspacePath, outputPath) {
+  const base = path6.resolve(workspacePath);
+  const resolved = path6.resolve(base, outputPath);
+  if (!resolved.startsWith(base + path6.sep) && resolved !== base) {
     throw new Error(`Invalid board output path: ${outputPath}`);
   }
   return resolved;
@@ -1142,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, {
@@ -1157,8 +1933,8 @@ __export(diagnostics_exports, {
 });
 
 // src/diagnostics/doctor.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import YAML2 from "yaml";
 
 // src/diagnostics/format.ts
@@ -1222,7 +1998,7 @@ function inferPrimitiveTypeFromPath(targetPath) {
 }
 
 // src/diagnostics/primitives.ts
-import path6 from "path";
+import path8 from "path";
 function loadPrimitiveInventory(workspacePath) {
   const registry = loadRegistry(workspacePath);
   const allPrimitives = queryPrimitives(workspacePath);
@@ -1240,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 = path6.basename(instance.path, ".md");
+    const slug = path8.basename(instance.path, ".md");
     return {
       ...instance,
       slug,
@@ -1582,8 +2358,8 @@ function collectStaleRuns(workspacePath, staleAfterMs, now) {
 }
 function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
   const issues = [];
-  const manifestPath = path7.join(workspacePath, ".workgraph", "primitive-registry.yaml");
-  if (!fs6.existsSync(manifestPath)) {
+  const manifestPath = path9.join(workspacePath, ".workgraph", "primitive-registry.yaml");
+  if (!fs8.existsSync(manifestPath)) {
     issues.push({
       code: "broken-primitive-registry-reference",
       severity: "error",
@@ -1594,7 +2370,7 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
   }
   let parsed;
   try {
-    parsed = YAML2.parse(fs6.readFileSync(manifestPath, "utf-8"));
+    parsed = YAML2.parse(fs8.readFileSync(manifestPath, "utf-8"));
   } catch (error) {
     issues.push({
       code: "broken-primitive-registry-reference",
@@ -1646,7 +2422,7 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
         path: ".workgraph/primitive-registry.yaml"
       });
     }
-    if (!fs6.existsSync(path7.join(workspacePath, directory))) {
+    if (!fs8.existsSync(path9.join(workspacePath, directory))) {
       issues.push({
         code: "broken-primitive-registry-reference",
         severity: "error",
@@ -1681,8 +2457,8 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
 function collectEmptyPrimitiveDirectoryIssues(workspacePath, inventory) {
   const issues = [];
   for (const typeDef of inventory.typeDefs.values()) {
-    const directoryPath = path7.join(workspacePath, typeDef.directory);
-    if (!fs6.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({
@@ -1711,10 +2487,10 @@ function removeOrphanLinks(workspacePath, orphanLinks) {
   }
   let removedLinks = 0;
   for (const [sourcePath, tokenSet] of tokensBySource.entries()) {
-    const absPath = path7.join(workspacePath, sourcePath);
-    if (!fs6.existsSync(absPath)) continue;
+    const absPath = path9.join(workspacePath, sourcePath);
+    if (!fs8.existsSync(absPath)) continue;
     try {
-      const raw = fs6.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;
@@ -1722,7 +2498,7 @@ function removeOrphanLinks(workspacePath, orphanLinks) {
         return "";
       });
       if (fileRemoved === 0) continue;
-      fs6.writeFileSync(absPath, updated, "utf-8");
+      fs8.writeFileSync(absPath, updated, "utf-8");
       removedLinks += fileRemoved;
       filesUpdated.push(sourcePath);
     } catch (error) {
@@ -1787,10 +2563,10 @@ function cancelStaleRuns(workspacePath, staleRuns, actor) {
   return { cancelled, errors };
 }
 function readDispatchRunsSnapshot(workspacePath) {
-  const runsPath = path7.join(workspacePath, ".workgraph", "dispatch-runs.json");
-  if (!fs6.existsSync(runsPath)) return [];
+  const runsPath = path9.join(workspacePath, ".workgraph", "dispatch-runs.json");
+  if (!fs8.existsSync(runsPath)) return [];
   try {
-    const parsed = JSON.parse(fs6.readFileSync(runsPath, "utf-8"));
+    const parsed = JSON.parse(fs8.readFileSync(runsPath, "utf-8"));
     return Array.isArray(parsed.runs) ? parsed.runs : [];
   } catch {
     return [];
@@ -1801,9 +2577,9 @@ function listMarkdownFilesRecursive(rootDirectory) {
   const stack = [rootDirectory];
   while (stack.length > 0) {
     const current = stack.pop();
-    const entries = fs6.readdirSync(current, { withFileTypes: true });
+    const entries = fs8.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
-      const absPath = path7.join(current, entry.name);
+      const absPath = path9.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(absPath);
         continue;
@@ -1947,7 +2723,7 @@ function toNullableString(value) {
 }
 
 // src/diagnostics/viz.ts
-import path8 from "path";
+import path10 from "path";
 var TYPE_COLORS = ["cyan", "magenta", "yellow", "green", "blue", "red"];
 function visualizeVaultGraph(workspacePath, options = {}) {
   const inventory = loadPrimitiveInventory(workspacePath);
@@ -2087,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 = path8.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) {
@@ -2395,8 +3171,8 @@ __export(autonomy_daemon_exports, {
   startAutonomyDaemon: () => startAutonomyDaemon,
   stopAutonomyDaemon: () => stopAutonomyDaemon
 });
-import fs7 from "fs";
-import path9 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";
@@ -2405,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 = path9.join(daemonDir, AUTONOMY_PID_FILE);
-  const heartbeatPath = input.heartbeatPath ? resolvePathWithinWorkspace3(workspacePath, input.heartbeatPath) : path9.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
-  const logPath = input.logPath ? resolvePathWithinWorkspace3(workspacePath, input.logPath) : path9.join(daemonDir, AUTONOMY_LOG_FILE);
-  const metaPath = path9.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 = fs7.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
   });
-  fs7.closeSync(logFd);
+  fs9.closeSync(logFd);
   child.unref();
   if (!child.pid) {
     throw new Error("Failed to start autonomy daemon: missing child process pid.");
   }
-  fs7.writeFileSync(pidPath, `${child.pid}
+  fs9.writeFileSync(pidPath, `${child.pid}
 `, "utf-8");
-  fs7.writeFileSync(metaPath, JSON.stringify({
+  fs9.writeFileSync(metaPath, JSON.stringify({
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     pid: child.pid,
     args,
@@ -2461,9 +3237,9 @@ async function stopAutonomyDaemon(workspacePath, input = {}) {
     await waitForProcessExit(pid, 1500);
     stopped = !isProcessAlive(pid);
   }
-  const pidPath = path9.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
-  if (stopped && fs7.existsSync(pidPath)) {
-    fs7.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,
@@ -2474,14 +3250,14 @@ async function stopAutonomyDaemon(workspacePath, input = {}) {
 }
 function readAutonomyDaemonStatus(workspacePath, options = {}) {
   const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path9.join(daemonDir, AUTONOMY_PID_FILE);
-  const meta = readDaemonMeta(path9.join(daemonDir, AUTONOMY_META_FILE));
-  const logPath = meta?.logPath ? String(meta.logPath) : path9.join(daemonDir, AUTONOMY_LOG_FILE);
-  const heartbeatPath = meta?.heartbeatPath ? String(meta.heartbeatPath) : path9.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 && fs7.existsSync(pidPath)) {
-    fs7.rmSync(pidPath, { force: true });
+  if (!running && pid && options.cleanupStalePidFile !== false && fs9.existsSync(pidPath)) {
+    fs9.rmSync(pidPath, { force: true });
   }
   return {
     running,
@@ -2494,7 +3270,7 @@ function readAutonomyDaemonStatus(workspacePath, options = {}) {
 }
 function buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath) {
   const args = [
-    path9.resolve(input.cliEntrypointPath),
+    path11.resolve(input.cliEntrypointPath),
     "autonomy",
     "run",
     "-w",
@@ -2552,22 +3328,22 @@ function waitForProcessExit(pid, timeoutMs) {
   });
 }
 function ensureDaemonDir(workspacePath) {
-  const daemonDir = path9.join(workspacePath, DAEMON_DIR);
-  if (!fs7.existsSync(daemonDir)) fs7.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 (!fs7.existsSync(pidPath)) return void 0;
-  const raw = fs7.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 (!fs7.existsSync(heartbeatPath)) return void 0;
+  if (!fs9.existsSync(heartbeatPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs7.readFileSync(heartbeatPath, "utf-8"));
+    const parsed = JSON.parse(fs9.readFileSync(heartbeatPath, "utf-8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     return parsed;
   } catch {
@@ -2575,9 +3351,9 @@ function readHeartbeat(heartbeatPath) {
   }
 }
 function readDaemonMeta(metaPath) {
-  if (!fs7.existsSync(metaPath)) return void 0;
+  if (!fs9.existsSync(metaPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs7.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 {
@@ -2595,9 +3371,9 @@ function isProcessAlive(pid) {
 }
 function isZombieProcess(pid) {
   const statPath = `/proc/${pid}/stat`;
-  if (!fs7.existsSync(statPath)) return false;
+  if (!fs9.existsSync(statPath)) return false;
   try {
-    const stat = fs7.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);
@@ -2606,10 +3382,10 @@ function isZombieProcess(pid) {
     return false;
   }
 }
-function resolvePathWithinWorkspace3(workspacePath, filePath) {
-  const base = path9.resolve(workspacePath);
-  const resolved = path9.resolve(base, filePath);
-  if (!resolved.startsWith(base + path9.sep) && resolved !== base) {
+function resolvePathWithinWorkspace4(workspacePath, filePath) {
+  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;
@@ -2624,6 +3400,7 @@ export {
   workspace_exports,
   command_center_exports,
   skill_exports,
+  lens_exports,
   board_exports,
   agent_exports,
   onboard_exports,
@@ -2633,6 +3410,7 @@ export {
   fetchSkillMarkdownFromUrl,
   clawdapus_exports,
   integration_exports,
+  swarm_exports,
   diagnostics_exports,
   autonomy_daemon_exports
 };