@versatly/workgraph 1.2.0 → 1.3.1

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

@@ -622,8 +622,7 @@ var BUILT_IN_TYPES = [
       proposed_at: { type: "date" },
       promoted_at: { type: "date" },
       depends_on: { type: "list", default: [], description: "Skill dependencies by slug or path" },
-      distribution: { type: "string", default: "tailscale-shared-vault", description: "Distribution channel for skill usage" },
-      tailscale_path: { type: "string", description: "Shared vault path over Tailscale" },
+      distribution: { type: "string", default: "shared-vault", description: "Distribution channel for skill usage" },
       tags: { type: "list", default: [] },
       created: { type: "date", required: true },
       updated: { type: "date", required: true }
@@ -841,8 +840,24 @@ function ensureBuiltIns(registry) {
   for (const t of BUILT_IN_TYPES) {
     if (!registry.types[t.name]) {
       registry.types[t.name] = t;
+      continue;
+    }
+    const existing = registry.types[t.name];
+    if (existing.builtIn) {
+      registry.types[t.name] = {
+        ...existing,
+        description: t.description,
+        directory: t.directory,
+        fields: {
+          ...existing.fields,
+          ...t.fields
+        }
+      };
     }
   }
+  if (registry.types.skill?.builtIn && "tailscale_path" in registry.types.skill.fields) {
+    delete registry.types.skill.fields.tailscale_path;
+  }
   return registry;
 }
 
@@ -4163,6 +4178,9 @@ function asDate(value) {
   return new Date(timestamp);
 }
 
+// src/adapter-shell-worker.ts
+import { spawn } from "child_process";
+
 // src/orientation.ts
 var orientation_exports = {};
 __export(orientation_exports, {
@@ -4564,9 +4582,523 @@ function renderSummary(data) {
   return lines.join("\n");
 }
 
+// src/adapter-shell-worker.ts
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var MAX_CAPTURE_CHARS = 12e3;
+var ShellWorkerAdapter = class {
+  name = "shell-worker";
+  fallback = new CursorCloudAdapter();
+  async create(_input) {
+    return { runId: "shell-worker-managed", status: "queued" };
+  }
+  async status(runId) {
+    return { runId, status: "running" };
+  }
+  async followup(runId, _actor, _input) {
+    return { runId, status: "running" };
+  }
+  async stop(runId, _actor) {
+    return { runId, status: "cancelled" };
+  }
+  async logs(_runId) {
+    return [];
+  }
+  async execute(input) {
+    const command = readString(input.context?.shell_command);
+    if (!command) {
+      return this.fallback.execute(input);
+    }
+    const shellCwd = readString(input.context?.shell_cwd) ?? input.workspacePath;
+    const timeoutMs = clampInt(readNumber(input.context?.shell_timeout_ms), DEFAULT_TIMEOUT_MS, 1e3, 60 * 60 * 1e3);
+    const shellEnv = readEnv(input.context?.shell_env);
+    const logs2 = [];
+    const startedAt = Date.now();
+    const outputParts = [];
+    const errorParts = [];
+    pushLog2(logs2, "info", `shell-worker starting command: ${command}`);
+    pushLog2(logs2, "info", `shell-worker cwd: ${shellCwd}`);
+    const result = await runShellCommand({
+      command,
+      cwd: shellCwd,
+      timeoutMs,
+      env: shellEnv,
+      isCancelled: input.isCancelled,
+      onStdout: (chunk) => {
+        outputParts.push(chunk);
+        pushLog2(logs2, "info", `[stdout] ${chunk.trimEnd()}`);
+      },
+      onStderr: (chunk) => {
+        errorParts.push(chunk);
+        pushLog2(logs2, "warn", `[stderr] ${chunk.trimEnd()}`);
+      }
+    });
+    const elapsedMs = Date.now() - startedAt;
+    const stdout = truncateText(outputParts.join(""), MAX_CAPTURE_CHARS);
+    const stderr = truncateText(errorParts.join(""), MAX_CAPTURE_CHARS);
+    if (result.cancelled) {
+      pushLog2(logs2, "warn", `shell-worker command cancelled after ${elapsedMs}ms`);
+      return {
+        status: "cancelled",
+        output: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, true),
+        logs: logs2
+      };
+    }
+    if (result.timedOut) {
+      pushLog2(logs2, "error", `shell-worker command timed out after ${elapsedMs}ms`);
+      return {
+        status: "failed",
+        error: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
+        logs: logs2
+      };
+    }
+    if (result.exitCode !== 0) {
+      pushLog2(logs2, "error", `shell-worker command failed with exit code ${result.exitCode}`);
+      return {
+        status: "failed",
+        error: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
+        logs: logs2
+      };
+    }
+    pushLog2(logs2, "info", `shell-worker command succeeded in ${elapsedMs}ms`);
+    return {
+      status: "succeeded",
+      output: formatShellOutput(command, result.exitCode, stdout, stderr, elapsedMs, false),
+      logs: logs2,
+      metrics: {
+        elapsedMs,
+        exitCode: result.exitCode,
+        adapter: "shell-worker"
+      }
+    };
+  }
+};
+async function runShellCommand(options) {
+  return new Promise((resolve) => {
+    const child = spawn(options.command, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let resolved = false;
+    let timedOut = false;
+    let cancelled = false;
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 1500).unref();
+    }, options.timeoutMs);
+    const cancelWatcher = setInterval(() => {
+      if (options.isCancelled?.()) {
+        cancelled = true;
+        child.kill("SIGTERM");
+      }
+    }, 200);
+    cancelWatcher.unref();
+    child.stdout.on("data", (chunk) => {
+      options.onStdout(chunk.toString("utf-8"));
+    });
+    child.stderr.on("data", (chunk) => {
+      options.onStderr(chunk.toString("utf-8"));
+    });
+    child.on("close", (code) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutHandle);
+      clearInterval(cancelWatcher);
+      resolve({
+        exitCode: typeof code === "number" ? code : 1,
+        timedOut,
+        cancelled
+      });
+    });
+    child.on("error", () => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutHandle);
+      clearInterval(cancelWatcher);
+      resolve({
+        exitCode: 1,
+        timedOut,
+        cancelled
+      });
+    });
+  });
+}
+function pushLog2(target, level, message) {
+  target.push({
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message
+  });
+}
+function readEnv(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const input = value;
+  const result = {};
+  for (const [key, raw] of Object.entries(input)) {
+    if (!key) continue;
+    if (raw === void 0 || raw === null) continue;
+    result[key] = String(raw);
+  }
+  return result;
+}
+function readString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function clampInt(value, fallback, min, max) {
+  const raw = typeof value === "number" ? Math.trunc(value) : fallback;
+  return Math.min(max, Math.max(min, raw));
+}
+function truncateText(value, limit) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}
+...[truncated]`;
+}
+function formatShellOutput(command, exitCode, stdout, stderr, elapsedMs, cancelled) {
+  const lines = [
+    "Shell worker execution summary",
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    `Elapsed ms: ${elapsedMs}`,
+    `Cancelled: ${cancelled ? "yes" : "no"}`,
+    "",
+    "STDOUT:",
+    stdout || "(empty)",
+    "",
+    "STDERR:",
+    stderr || "(empty)"
+  ];
+  return lines.join("\n");
+}
+
+// src/adapter-claude-code.ts
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  shellWorker = new ShellWorkerAdapter();
+  async create(input) {
+    return this.shellWorker.create(input);
+  }
+  async status(runId) {
+    return this.shellWorker.status(runId);
+  }
+  async followup(runId, actor, input) {
+    return this.shellWorker.followup(runId, actor, input);
+  }
+  async stop(runId, actor) {
+    return this.shellWorker.stop(runId, actor);
+  }
+  async logs(runId) {
+    return this.shellWorker.logs(runId);
+  }
+  async execute(input) {
+    const template = readString2(input.context?.claude_command_template) ?? process.env.WORKGRAPH_CLAUDE_COMMAND_TEMPLATE;
+    if (!template) {
+      return {
+        status: "failed",
+        error: [
+          "claude-code adapter requires a command template.",
+          "Set context.claude_command_template or WORKGRAPH_CLAUDE_COMMAND_TEMPLATE.",
+          "Template tokens: {workspace}, {run_id}, {actor}, {objective}, {prompt}, {prompt_shell}.",
+          "Example: claude -p {prompt_shell}"
+        ].join(" "),
+        logs: [
+          {
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "error",
+            message: "Missing Claude command template."
+          }
+        ]
+      };
+    }
+    const prompt = buildPrompt(input);
+    const command = applyTemplate(template, {
+      workspace: input.workspacePath,
+      run_id: input.runId,
+      actor: input.actor,
+      objective: input.objective,
+      prompt,
+      prompt_shell: quoteForShell(prompt)
+    });
+    const context = {
+      ...input.context,
+      shell_command: command,
+      shell_cwd: readString2(input.context?.shell_cwd) ?? input.workspacePath,
+      shell_timeout_ms: input.context?.shell_timeout_ms ?? process.env.WORKGRAPH_CLAUDE_TIMEOUT_MS
+    };
+    const result = await this.shellWorker.execute({
+      ...input,
+      context
+    });
+    const logs2 = [
+      {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        message: "claude-code adapter dispatched shell execution from command template."
+      },
+      ...result.logs ?? []
+    ];
+    return {
+      ...result,
+      logs: logs2,
+      metrics: {
+        ...result.metrics ?? {},
+        adapter: "claude-code"
+      }
+    };
+  }
+};
+function buildPrompt(input) {
+  const extraInstructions = readString2(input.context?.claude_instructions);
+  const sections = [
+    `Workgraph run id: ${input.runId}`,
+    `Actor: ${input.actor}`,
+    `Objective: ${input.objective}`,
+    `Workspace: ${input.workspacePath}`
+  ];
+  if (extraInstructions) {
+    sections.push(`Instructions: ${extraInstructions}`);
+  }
+  return sections.join("\n");
+}
+function applyTemplate(template, values) {
+  let rendered = template;
+  for (const [key, value] of Object.entries(values)) {
+    rendered = rendered.replaceAll(`{${key}}`, value);
+  }
+  return rendered;
+}
+function quoteForShell(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function readString2(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+
+// src/adapter-http-webhook.ts
+var DEFAULT_POLL_MS = 1e3;
+var DEFAULT_MAX_WAIT_MS = 9e4;
+var HttpWebhookAdapter = class {
+  name = "http-webhook";
+  async create(_input) {
+    return { runId: "http-webhook-managed", status: "queued" };
+  }
+  async status(runId) {
+    return { runId, status: "running" };
+  }
+  async followup(runId, _actor, _input) {
+    return { runId, status: "running" };
+  }
+  async stop(runId, _actor) {
+    return { runId, status: "cancelled" };
+  }
+  async logs(_runId) {
+    return [];
+  }
+  async execute(input) {
+    const logs2 = [];
+    const webhookUrl = resolveUrl(input.context?.webhook_url, process.env.WORKGRAPH_DISPATCH_WEBHOOK_URL);
+    if (!webhookUrl) {
+      return {
+        status: "failed",
+        error: "http-webhook adapter requires context.webhook_url or WORKGRAPH_DISPATCH_WEBHOOK_URL.",
+        logs: logs2
+      };
+    }
+    const token = readString3(input.context?.webhook_token) ?? process.env.WORKGRAPH_DISPATCH_WEBHOOK_TOKEN;
+    const headers = {
+      "content-type": "application/json",
+      ...extractHeaders(input.context?.webhook_headers),
+      ...token ? { authorization: `Bearer ${token}` } : {}
+    };
+    const payload = {
+      runId: input.runId,
+      actor: input.actor,
+      objective: input.objective,
+      workspacePath: input.workspacePath,
+      context: input.context ?? {},
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    pushLog3(logs2, "info", `http-webhook posting run ${input.runId} to ${webhookUrl}`);
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    const rawText = await response.text();
+    const parsed = safeParseJson(rawText);
+    pushLog3(logs2, response.ok ? "info" : "error", `http-webhook response status: ${response.status}`);
+    if (!response.ok) {
+      return {
+        status: "failed",
+        error: `http-webhook request failed (${response.status}): ${rawText || response.statusText}`,
+        logs: logs2
+      };
+    }
+    const immediateStatus = normalizeRunStatus(parsed?.status);
+    if (immediateStatus && isTerminalStatus(immediateStatus)) {
+      return {
+        status: immediateStatus,
+        output: typeof parsed?.output === "string" ? parsed.output : rawText,
+        error: typeof parsed?.error === "string" ? parsed.error : void 0,
+        logs: logs2,
+        metrics: {
+          adapter: "http-webhook",
+          httpStatus: response.status
+        }
+      };
+    }
+    const pollUrl = resolveUrl(parsed?.pollUrl, input.context?.webhook_status_url, process.env.WORKGRAPH_DISPATCH_WEBHOOK_STATUS_URL);
+    if (!pollUrl) {
+      return {
+        status: "succeeded",
+        output: rawText || "http-webhook acknowledged run successfully.",
+        logs: logs2,
+        metrics: {
+          adapter: "http-webhook",
+          httpStatus: response.status
+        }
+      };
+    }
+    const pollMs = clampInt2(readNumber2(input.context?.webhook_poll_ms), DEFAULT_POLL_MS, 200, 3e4);
+    const maxWaitMs = clampInt2(readNumber2(input.context?.webhook_max_wait_ms), DEFAULT_MAX_WAIT_MS, 1e3, 15 * 6e4);
+    const startedAt = Date.now();
+    pushLog3(logs2, "info", `http-webhook polling status from ${pollUrl}`);
+    while (Date.now() - startedAt < maxWaitMs) {
+      if (input.isCancelled?.()) {
+        pushLog3(logs2, "warn", "http-webhook run cancelled while polling");
+        return {
+          status: "cancelled",
+          output: "http-webhook polling cancelled by dispatcher.",
+          logs: logs2
+        };
+      }
+      const pollResponse = await fetch(pollUrl, {
+        method: "GET",
+        headers: {
+          ...headers
+        }
+      });
+      const pollText = await pollResponse.text();
+      const pollJson = safeParseJson(pollText);
+      const pollStatus = normalizeRunStatus(pollJson?.status);
+      pushLog3(logs2, "info", `poll status=${pollResponse.status} run_status=${pollStatus ?? "unknown"}`);
+      if (pollStatus && isTerminalStatus(pollStatus)) {
+        return {
+          status: pollStatus,
+          output: typeof pollJson?.output === "string" ? pollJson.output : pollText,
+          error: typeof pollJson?.error === "string" ? pollJson.error : void 0,
+          logs: logs2,
+          metrics: {
+            adapter: "http-webhook",
+            pollUrl,
+            pollHttpStatus: pollResponse.status,
+            elapsedMs: Date.now() - startedAt
+          }
+        };
+      }
+      await sleep3(pollMs);
+    }
+    return {
+      status: "failed",
+      error: `http-webhook polling exceeded timeout (${maxWaitMs}ms) for run ${input.runId}.`,
+      logs: logs2
+    };
+  }
+};
+function pushLog3(target, level, message) {
+  target.push({
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message
+  });
+}
+function readString3(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveUrl(...values) {
+  for (const value of values) {
+    const parsed = readString3(value);
+    if (!parsed) continue;
+    try {
+      const url = new URL(parsed);
+      if (url.protocol === "http:" || url.protocol === "https:") {
+        return url.toString();
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function extractHeaders(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+  const record = input;
+  const out = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (!key || value === void 0 || value === null) continue;
+    out[key.toLowerCase()] = String(value);
+  }
+  return out;
+}
+function safeParseJson(value) {
+  if (!value || !value.trim()) return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function normalizeRunStatus(value) {
+  const normalized = String(value ?? "").toLowerCase();
+  if (normalized === "queued" || normalized === "running" || normalized === "succeeded" || normalized === "failed" || normalized === "cancelled") {
+    return normalized;
+  }
+  return void 0;
+}
+function isTerminalStatus(status2) {
+  return status2 === "succeeded" || status2 === "failed" || status2 === "cancelled";
+}
+function readNumber2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function clampInt2(value, fallback, min, max) {
+  const raw = typeof value === "number" ? Math.trunc(value) : fallback;
+  return Math.min(max, Math.max(min, raw));
+}
+function sleep3(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
 // src/runtime-adapter-registry.ts
 var adapterFactories = /* @__PURE__ */ new Map([
-  ["cursor-cloud", () => new CursorCloudAdapter()]
+  ["claude-code", () => new ClaudeCodeAdapter()],
+  ["cursor-cloud", () => new CursorCloudAdapter()],
+  ["http-webhook", () => new HttpWebhookAdapter()],
+  ["shell-worker", () => new ShellWorkerAdapter()]
 ]);
 function resolveDispatchAdapter(name) {
   const safeName = normalizeName(name);
@@ -5049,9 +5581,9 @@ function resolveThreadRef2(threadRef) {
 // src/autonomy.ts
 async function runAutonomyLoop(workspacePath, options) {
   const watch = options.watch === true;
-  const pollMs = clampInt(options.pollMs, 2e3, 100, 6e4);
-  const maxCycles = clampInt(options.maxCycles, watch ? Number.MAX_SAFE_INTEGER : 20, 1, Number.MAX_SAFE_INTEGER);
-  const maxIdleCycles = clampInt(options.maxIdleCycles, watch ? Number.MAX_SAFE_INTEGER : 2, 1, Number.MAX_SAFE_INTEGER);
+  const pollMs = clampInt3(options.pollMs, 2e3, 100, 6e4);
+  const maxCycles = clampInt3(options.maxCycles, watch ? Number.MAX_SAFE_INTEGER : 20, 1, Number.MAX_SAFE_INTEGER);
+  const maxIdleCycles = clampInt3(options.maxIdleCycles, watch ? Number.MAX_SAFE_INTEGER : 2, 1, Number.MAX_SAFE_INTEGER);
   const cycles = [];
   let idleCycles = 0;
   for (let cycle = 1; cycle <= maxCycles; cycle++) {
@@ -5110,7 +5642,7 @@ async function runAutonomyLoop(workspacePath, options) {
     if (cycle >= maxCycles) {
       break;
     }
-    await sleep3(pollMs);
+    await sleep4(pollMs);
   }
   const finalReadyThreads = (options.space ? listReadyThreadsInSpace(workspacePath, options.space) : listReadyThreads(workspacePath)).length;
   writeHeartbeat(options.heartbeatFile, {
@@ -5124,11 +5656,11 @@ async function runAutonomyLoop(workspacePath, options) {
     finalDriftOk: true
   };
 }
-function clampInt(value, fallback, min, max) {
+function clampInt3(value, fallback, min, max) {
   const raw = typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback;
   return Math.min(max, Math.max(min, raw));
 }
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });

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

@@ -26,7 +26,7 @@ import {
   saveRegistry,
   stop,
   update
-} from "./chunk-G6B47IBD.js";
+} from "./chunk-BJVBE7F4.js";
 
 // src/workspace.ts
 var workspace_exports = {};
@@ -363,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 ?? []
@@ -379,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 ?? []

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   swarm_exports,
   trigger_exports,
   workspace_exports
-} from "./chunk-MCHTUXG2.js";
+} from "./chunk-NGRQ6T4O.js";
 import {
   autonomy_exports,
   dispatch_exports,
@@ -30,7 +30,7 @@ import {
   thread_audit_exports,
   thread_exports,
   trigger_engine_exports
-} from "./chunk-G6B47IBD.js";
+} from "./chunk-BJVBE7F4.js";
 
 // src/cli.ts
 import fs from "fs";

package/dist/index.d.ts

@@ -614,11 +614,11 @@ interface WriteSkillOptions {
     version?: string;
     status?: 'draft' | 'proposed' | 'active' | 'deprecated' | 'archived';
     distribution?: string;
-    tailscalePath?: string;
     reviewers?: string[];
     tags?: string[];
     dependsOn?: string[];
     expectedUpdatedAt?: string;
+    tailscalePath?: string;
 }
 interface ProposeSkillOptions {
     proposalThread?: string;

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   swarm_exports,
   trigger_exports,
   workspace_exports
-} from "./chunk-MCHTUXG2.js";
+} from "./chunk-NGRQ6T4O.js";
 import {
   CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
@@ -38,7 +38,7 @@ import {
   thread_audit_exports,
   thread_exports,
   trigger_engine_exports
-} from "./chunk-G6B47IBD.js";
+} from "./chunk-BJVBE7F4.js";
 export {
   CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,

package/dist/mcp-server.js

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

package/package.json

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