@openhorizon/workflows 0.1.0

package/dist/cli.js

@@ -0,0 +1,2162 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/runners/cursor.ts
+import { Agent, CursorAgentError } from "@cursor/sdk";
+
+// src/runtime/prompts.ts
+var SUBAGENT_CONTRACT_TEXT = `You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.
+
+CRITICAL: Your final text response is returned **verbatim** as a string to the calling script — it is your return value, not a message to a human.
+- Output the literal result (data, JSON, text). Do NOT output confirmations like "Done." or "Sent."
+- If asked for JSON, return ONLY the raw JSON — no code fences, no prose, no markdown.
+- Do NOT address the user. Put your answer in your final text response.
+- Be concise. The script will parse your output.`;
+var SUBAGENT_CONTRACT_SCHEMA = `You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.
+
+CRITICAL: You MUST call the StructuredOutput tool exactly once to return your final answer. The tool's input schema defines the required shape.
+- Do your work (read files, run commands, etc.), then call StructuredOutput with your answer.
+- Do NOT put your answer in a text response. The script reads ONLY the StructuredOutput tool call.
+- If the schema validation fails, read the error and call StructuredOutput again with a corrected shape.
+- After calling StructuredOutput successfully, end your turn. No acknowledgment needed.`;
+var SUBAGENT_STOP_NUDGE = `You did not call StructuredOutput. You MUST call StructuredOutput to return your answer — the tool input IS your answer. Call it now.`;
+var AGENT_CAP_MESSAGE = `Workflow agent() call cap reached (1000). This usually means a loop using budget.remaining() never terminates because no token budget was set — remaining() returns Infinity when budget.total is null. Add a hard iteration cap to the loop, or pass a token budget.`;
+var budgetExceededMessage = (spent, total) => `Workflow token budget exceeded (${spent.toLocaleString()} / ${total.toLocaleString()} output tokens). Stopping further agent() calls. In-flight agents will complete; their results are preserved.`;
+var ERR_PARALLEL_NOT_ARRAY = `parallel() expects an array of functions`;
+var ERR_PARALLEL_NOT_FUNCTIONS = `parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)`;
+var ERR_PIPELINE_NOT_ARRAY = `pipeline() expects an array as the first argument`;
+var ERR_PIPELINE_STAGES = `pipeline() stages must be functions: pipeline(items, item => ..., result => ...)`;
+var ERR_ISOLATION_REMOTE = `agent({isolation:'remote'}) is not available in this build`;
+var ERR_WORKFLOW_ABORTED = `Workflow aborted`;
+var ERR_NO_STRUCTURED_OUTPUT = `agent({schema}): subagent completed without calling StructuredOutput (after 2 in-conversation nudges)`;
+var ERR_WORKFLOW_HOOK_UNAVAILABLE = `workflow() is not available in this build — inline the child workflow's agents directly.`;
+var ERR_AGENT_TYPE_UNAVAILABLE = `agent({agentType}) is not available in this build — omit agentType.`;
+var WORKFLOW_TOOL_DESCRIPTION = `Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a run ID. Poll workflow_status({runId}) for live progress, or call workflow_wait({runId}) to block until it finishes (re-call it if it returns while the run is still going).
+
+A workflow structures work across many agents — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps). The script is where you encode that structure: what fans out, what verifies, what synthesizes.
+
+Workflows can spawn dozens of agents and consume a large amount of tokens. Only launch one when the user asked for multi-agent orchestration (or a workflow by name) or has agreed to the scale; otherwise describe what a workflow could do and ask first.
+
+The right move is often **hybrid**: scout inline first (list the files, find the channels, scope the diff) to discover the work-list, then launch a workflow to pipeline over it. For larger work, run several workflows in sequence — read each result before deciding the next phase.
+
+Pass the script inline via \`script\`. Every invocation persists its script to a file and returns the path in the tool result. To iterate on a workflow, edit that file and re-invoke with \`{scriptPath: "<path>"}\` instead of resending the full script.
+
+Every script must begin with \`export const meta = {...}\`:
+  export const meta = {
+    name: 'find-flaky-tests',
+    description: 'Find flaky tests and propose fixes',   // one-line summary
+    phases: [                                            // one entry per phase() call
+      { title: 'Scan', detail: 'grep test logs for retries' },
+      { title: 'Fix', detail: 'one agent per flaky test' },
+    ],
+  }
+  // script body starts here — use agent()/parallel()/pipeline()/phase()/log()
+  phase('Scan')
+  const flaky = await agent('grep CI logs for retry markers', {schema: FLAKY_SCHEMA})
+  ...
+
+The \`meta\` object must be a PURE LITERAL — no variables, function calls, spreads, or template interpolation. Required fields: \`name\`, \`description\`. Optional: \`whenToUse\`, \`phases\`. Use the SAME phase titles in meta.phases as in phase() calls — titles are matched exactly.
+
+Script body hooks:
+- agent(prompt: string, opts?: {label?: string, phase?: string, schema?: object, model?: string, isolation?: 'worktree'}): Promise<any> — spawn a subagent. Without schema, returns its final text as a string. With schema (a JSON Schema object), the subagent is forced to call a StructuredOutput tool and agent() returns the validated object — no parsing needed. Returns null if the subagent dies on a terminal error after retries (filter with .filter(Boolean)). opts.label overrides the display label. opts.phase explicitly assigns this agent to a progress group (use this inside pipeline()/parallel() stages to avoid races on the global phase() state). opts.model overrides the model for this agent call; omit it to use the server's default model. opts.isolation: 'worktree' runs the agent in a fresh git worktree — use ONLY when agents mutate files in parallel and would otherwise conflict; the worktree is auto-removed if unchanged.
+- pipeline(items, stage1, stage2, ...): Promise<any[]> — run each item through all stages independently, NO barrier between stages. Item A can be in stage 3 while item B is still in stage 1. This is the DEFAULT for multi-stage work. Wall-clock = slowest single-item chain, not sum-of-slowest-per-stage. Every stage callback receives (prevResult, originalItem, index). A stage that throws drops that item to \`null\` and skips its remaining stages.
+- parallel(thunks: Array<() => Promise<any>>): Promise<any[]> — run tasks concurrently. This is a BARRIER: awaits all thunks before returning. A thunk that throws resolves to \`null\` in the result array — the call itself never rejects, so \`.filter(Boolean)\` before using the results. Use ONLY when you genuinely need all results together.
+- log(message: string): void — emit a progress message (shown in workflow_status output)
+- phase(title: string): void — start a new phase; subsequent agent() calls are grouped under this title
+- args: any — the value passed as the workflow tool's \`args\` input, verbatim (undefined if not provided). Pass arrays/objects as actual JSON values, NOT as a JSON-encoded string.
+- budget: {total: number|null, spent(): number, remaining(): number} — this run's output-token budget (from the workflow tool's \`tokenBudget\` input; total is null when none was set). The target is a HARD ceiling: once spent() reaches total, further agent() calls throw. Use for dynamic loops: \`while (budget.total && budget.remaining() > 50_000) { ... }\`.
+
+Subagents are told their final text IS the return value (not a human-facing message), so they return raw data. For structured output, use the schema option — validation happens at the tool boundary so the subagent retries on mismatch.
+
+Scripts are plain JavaScript, NOT TypeScript — type annotations, interfaces, and generics fail to parse. The script body runs in an async context — use await directly. Standard JS built-ins (JSON, Math, Array, etc.) are available — EXCEPT \`Date.now()\`/\`Math.random()\`/argless \`new Date()\`, which throw (they would break resume); pass timestamps in via \`args\` and for randomness vary the agent prompt/label by index. No filesystem or Node.js API access.
+
+DEFAULT TO pipeline(). Only reach for a barrier (parallel between stages) when stage N needs cross-item context from ALL of stage N-1 (dedup/merge across the full set, early-exit on zero total, prompts that reference "the other findings"). "I need to flatten/map/filter first" is NOT a reason — do it inside a pipeline stage.
+
+Concurrent agent() calls are capped per workflow — excess calls queue and run as slots free up. You can still pass 100 items to parallel()/pipeline() and they all complete. Total agent count across a workflow's lifetime is capped at 1000. A single parallel()/pipeline() call accepts at most 4096 items; passing more is an explicit error, not a silent truncation.
+
+The canonical multi-stage pattern — pipeline by default, each dimension verifies as soon as its review completes:
+  export const meta = {
+    name: 'review-changes',
+    description: 'Review changed files across dimensions, verify each finding',
+    phases: [{ title: 'Review' }, { title: 'Verify' }],
+  }
+  const DIMENSIONS = [{key: 'bugs', prompt: '...'}, {key: 'perf', prompt: '...'}]
+  const results = await pipeline(
+    DIMENSIONS,
+    d => agent(d.prompt, {label: \`review:\${d.key}\`, phase: 'Review', schema: FINDINGS_SCHEMA}),
+    review => parallel(review.findings.map(f => () =>
+      agent(\`Adversarially verify: \${f.title}\`, {label: \`verify:\${f.file}\`, phase: 'Verify', schema: VERDICT_SCHEMA})
+        .then(v => ({...f, verdict: v}))
+    ))
+  )
+  return { confirmed: results.flat().filter(Boolean).filter(f => f.verdict?.isReal) }
+
+Quality patterns — pick by task and compose freely:
+- Adversarial verify: spawn N independent skeptics per finding, each prompted to REFUTE. Kill if the majority refute.
+- Perspective-diverse verify: give each verifier a distinct lens (correctness, security, perf, does-it-reproduce) instead of N identical refuters.
+- Judge panel: generate N independent attempts from different angles, score with parallel judges, synthesize from the winner.
+- Loop-until-dry: for unknown-size discovery, keep spawning finders until K consecutive rounds return nothing new.
+- Completeness critic: a final agent that asks "what's missing?" — what it finds becomes the next round of work.
+- No silent caps: if a workflow bounds coverage (top-N, sampling), log() what was dropped.
+
+Use this tool for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.
+
+## Resume
+
+The tool result includes a runId. To resume after a stop, failure, or script edit, relaunch with workflow({scriptPath, resumeFromRunId}) — the longest unchanged prefix of agent() calls returns cached results instantly; the first edited/new call and everything after it runs live. Same script + same args → 100% cache hit. Stop a still-running workflow first with workflow_stop({runId}).`;
+
+// src/runners/cursor.ts
+var disposeAgent = async (agent) => {
+  const sym = Symbol.asyncDispose;
+  if (sym === undefined)
+    return;
+  const dispose = agent[sym];
+  if (typeof dispose === "function") {
+    await dispose.call(agent);
+  }
+};
+var makeCursorRunner = (config) => ({
+  run: async (params) => {
+    let outputTokens = 0;
+    let toolCalls = 0;
+    let structured;
+    let structuredFound = false;
+    const structuredOutputTool = params.schema !== undefined ? {
+      description: "Return your final answer. The input schema defines the required shape. Call exactly once.",
+      inputSchema: params.schema,
+      execute: (args) => {
+        const verdict = params.validate?.(args) ?? { ok: true };
+        if (verdict.ok) {
+          structured = args;
+          structuredFound = true;
+          return "Structured output recorded.";
+        }
+        return {
+          content: [{ type: "text", text: verdict.message }],
+          isError: true
+        };
+      }
+    } : undefined;
+    const onDelta = ({ update }) => {
+      params.onActivity?.();
+      if (update.type === "tool-call-completed")
+        toolCalls += 1;
+      if (update.type === "turn-ended") {
+        const out = update.usage?.outputTokens;
+        if (typeof out === "number" && out > 0) {
+          outputTokens += out;
+          params.onTokens?.(out);
+        }
+      }
+    };
+    let agent;
+    let currentRun;
+    const onAbort = () => {
+      currentRun?.cancel().catch(() => {});
+    };
+    try {
+      if (params.signal.aborted) {
+        return { text: "", aborted: true, outputTokens, toolCalls };
+      }
+      params.signal.addEventListener("abort", onAbort, { once: true });
+      agent = await Agent.create({
+        ...config.apiKey !== undefined ? { apiKey: config.apiKey } : {},
+        model: { id: params.model ?? config.defaultModel },
+        local: {
+          cwd: params.cwd,
+          ...structuredOutputTool !== undefined ? { customTools: { StructuredOutput: structuredOutputTool } } : {}
+        }
+      });
+      const promptText = `${params.contract}
+
+---
+
+Task:
+${params.prompt}`;
+      let message = promptText;
+      let nudges = 0;
+      for (;; ) {
+        const run = await agent.send(message, { onDelta });
+        currentRun = run;
+        if (params.signal.aborted)
+          onAbort();
+        const result = await run.wait();
+        currentRun = undefined;
+        if (result.status === "cancelled") {
+          return params.signal.aborted ? {
+            text: result.result ?? "",
+            aborted: true,
+            outputTokens,
+            toolCalls
+          } : {
+            text: result.result ?? "",
+            apiError: "run cancelled",
+            outputTokens,
+            toolCalls
+          };
+        }
+        if (result.status !== "finished") {
+          return {
+            text: result.result ?? "",
+            apiError: `Cursor run ended with status "${result.status}"`,
+            outputTokens,
+            toolCalls
+          };
+        }
+        if (params.schema !== undefined && !structuredFound && nudges < 2) {
+          nudges += 1;
+          message = SUBAGENT_STOP_NUDGE;
+          continue;
+        }
+        return {
+          text: result.result ?? "",
+          ...structuredFound ? { structured } : {},
+          outputTokens,
+          toolCalls
+        };
+      }
+    } catch (err) {
+      if (params.signal.aborted) {
+        return { text: "", aborted: true, outputTokens, toolCalls };
+      }
+      const message = err instanceof CursorAgentError ? err.message : err instanceof Error ? err.message : String(err);
+      return { text: "", apiError: message, outputTokens, toolCalls };
+    } finally {
+      params.signal.removeEventListener("abort", onAbort);
+      if (agent !== undefined)
+        await disposeAgent(agent).catch(() => {});
+    }
+  }
+});
+
+// src/runtime/constants.ts
+import { cpus } from "node:os";
+var AGENT_CAP = 1000;
+var DEFAULT_STALL_MS = 180000;
+var MAX_STALL_RETRIES = 5;
+var THROTTLE_BACKOFF_MS = 45000;
+var SYNC_RUN_TIMEOUT_MS = 30000;
+var MAX_VM_BOUNDARY_ITEMS = 4096;
+var PREVIEW_TRUNCATE = 400;
+var MAX_SCRIPT_BYTES = 524288;
+var LOG_BUFFER_CAP = 1000;
+var CACHE_KEY_PREFIX = "v2";
+var RESULT_TEXT_CAP = 8000;
+var concurrencyCap = (cores) => Math.min(16, Math.max(2, cores - 2));
+var envConcurrency = Number(process.env["WORKFLOWS_MAX_CONCURRENCY"]);
+var LOCAL_CONCURRENCY = Number.isInteger(envConcurrency) && envConcurrency > 0 ? envConcurrency : concurrencyCap(cpus().length);
+var DETERMINISM_RE = /\bDate\s*\.\s*now\b|\bMath\s*\.\s*random\b|\bnew\s+Date\s*\(\s*\)/;
+var previewTruncate = (x) => {
+  const s = typeof x === "string" ? x : JSON.stringify(x);
+  const str = s ?? "";
+  return str.length > PREVIEW_TRUNCATE ? str.slice(0, PREVIEW_TRUNCATE) + "…" : str;
+};
+var DEFAULT_MODEL = process.env["WORKFLOWS_MODEL"] ?? "auto";
+
+// src/runtime/orchestrator.ts
+import { writeFileSync } from "node:fs";
+
+// src/runtime/journal.ts
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CANON_KEYS = ["schema", "model", "isolation", "agentType"];
+var sortedClone = (value) => {
+  if (typeof value === "function")
+    return;
+  if (Array.isArray(value)) {
+    const out = [];
+    const rawLength = value.length;
+    const length = Number.isSafeInteger(rawLength) ? rawLength : 0;
+    for (let i = 0;i < length; i++)
+      out[i] = sortedClone(value[i]);
+    return out;
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      if (key === "__proto__")
+        continue;
+      out[key] = sortedClone(value[key]);
+    }
+    return out;
+  }
+  return value;
+};
+var canonOpts = (opts) => {
+  if (!opts)
+    return "{}";
+  const picked = {};
+  for (const key of CANON_KEYS) {
+    const value = opts[key];
+    if (value === undefined || typeof value === "function")
+      continue;
+    picked[key] = value;
+  }
+  return JSON.stringify(sortedClone(picked));
+};
+var cacheKey = (prompt, opts, prevKey) => {
+  const h = createHash("sha256");
+  h.update(prevKey);
+  h.update("\x00");
+  h.update(prompt);
+  h.update("\x00");
+  h.update(canonOpts(opts));
+  return `${CACHE_KEY_PREFIX}:` + h.digest("hex");
+};
+var buildReplayMap = (entries) => {
+  const results = new Map;
+  const started = new Map;
+  for (const e of entries) {
+    if (e.type === "result") {
+      results.set(e.key, e);
+    } else {
+      const list = started.get(e.key) ?? [];
+      list.push(e);
+      started.set(e.key, list);
+    }
+  }
+  return { results, started };
+};
+var RUN_ID_RE = /^wf_[a-z0-9-]{6,}$/;
+var mintRunId = (resumeFromRunId) => resumeFromRunId ?? "wf_" + randomUUID().slice(0, 12);
+var stateHome = () => process.env["OPENHORIZON_WORKFLOWS_DIR"] ?? join(homedir(), ".openhorizon", "workflows");
+var runDirFor = (runId) => join(stateHome(), "runs", runId);
+var journalPathFor = (runDir) => join(runDir, "journal.jsonl");
+var scriptPathFor = (runDir) => join(runDir, "script.js");
+var statePathFor = (runDir) => join(runDir, "state.json");
+var resultPathFor = (runDir) => join(runDir, "result.json");
+var progressPathFor = (runDir) => join(runDir, "progress.jsonl");
+var ensureRunDir = (runDir) => {
+  try {
+    mkdirSync(runDir, { recursive: true, mode: 448 });
+  } catch {}
+};
+var appendJsonl = (path, row) => {
+  try {
+    appendFileSync(path, JSON.stringify(row) + `
+`);
+  } catch {}
+};
+var makeJournal = (journalPath) => ({
+  append: (entry) => appendJsonl(journalPath, entry)
+});
+var readJournal = (journalPath) => {
+  if (!existsSync(journalPath))
+    return [];
+  let raw;
+  try {
+    raw = readFileSync(journalPath, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(`
+`)) {
+    const t = line.trim();
+    if (t.length === 0)
+      continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {}
+  }
+  return out;
+};
+
+// src/runtime/sandbox.ts
+import vm from "node:vm";
+import * as acorn from "acorn";
+var RESERVED_IDENTIFIER_PREFIX = "__wRg$";
+var vmBoundaryError = (message, name = "Error", stack) => {
+  const toString = () => `${name}: ${message}`;
+  Object.setPrototypeOf(toString, null);
+  return Object.assign(Object.create(null), {
+    name,
+    message,
+    stack: stack ?? `${name}: ${message}`,
+    toString
+  });
+};
+var hostErrorInfo = (err) => {
+  let msg;
+  try {
+    const m = err?.message;
+    msg = typeof m === "string" ? m : typeof err === "string" ? err : "<non-string error>";
+  } catch {
+    msg = "<unprintable thrown value>";
+  }
+  let name = "Error";
+  try {
+    const n = err?.name;
+    if (typeof n === "string")
+      name = n;
+  } catch {}
+  let stack;
+  try {
+    const s = err?.stack;
+    if (typeof s === "string")
+      stack = s;
+  } catch {}
+  return { msg, name, stack };
+};
+var boundaryErrorInfo = (err) => {
+  let name = "";
+  try {
+    const n = err?.name;
+    if (typeof n === "string")
+      name = n;
+  } catch {}
+  let msg;
+  try {
+    const m = err?.message;
+    msg = typeof m === "string" ? m : typeof err === "string" ? err : "<non-string reason>";
+  } catch {
+    msg = "<unprintable>";
+  }
+  return { name, msg };
+};
+var sanitizeHostSyncFn = (fn) => {
+  const wrapped = (...args) => {
+    try {
+      return fn(...args);
+    } catch (err) {
+      const { msg, name, stack } = hostErrorInfo(err);
+      throw vmBoundaryError(msg, name, stack);
+    }
+  };
+  Object.setPrototypeOf(wrapped, null);
+  return wrapped;
+};
+var sanitizeHostAsyncFn = (fn) => {
+  const wrapped = async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (err) {
+      const { msg, name, stack } = hostErrorInfo(err);
+      throw vmBoundaryError(msg, name, stack);
+    }
+  };
+  Object.setPrototypeOf(wrapped, null);
+  return wrapped;
+};
+var nullProtoHostFn = (fn) => {
+  Object.setPrototypeOf(fn, null);
+  try {
+    delete fn.constructor;
+  } catch {}
+  try {
+    delete fn.prototype;
+  } catch {}
+  return fn;
+};
+var isNode = (v) => typeof v === "object" && v !== null && typeof v.type === "string";
+var walkWithAncestors = (node, visit, ancestors) => {
+  visit(node, ancestors);
+  ancestors.push(node);
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "range")
+      continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (isNode(child))
+          walkWithAncestors(child, visit, ancestors);
+      }
+    } else if (isNode(value)) {
+      walkWithAncestors(value, visit, ancestors);
+    }
+  }
+  ancestors.pop();
+};
+var nearestFunction = (ancestors) => {
+  for (let i = ancestors.length - 1;i >= 0; i--) {
+    const node = ancestors[i];
+    if (node !== undefined && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")) {
+      return node;
+    }
+  }
+  return;
+};
+var REWRITE_PREFIX = `(async () => {'use strict';
+`;
+var REWRITE_SUFFIX = `
+})()`;
+var rewriteAwaits = (body) => {
+  const wrapped = `${REWRITE_PREFIX}${body}${REWRITE_SUFFIX}`;
+  const ast = acorn.parse(wrapped, {
+    ecmaVersion: "latest",
+    sourceType: "script",
+    allowHashBang: true
+  });
+  const edits = [];
+  const wrapSpan = (node) => {
+    if (!node)
+      return;
+    edits.push([node.start, ` ${RESERVED_IDENTIFIER_PREFIX}((`], [node.end, "))"]);
+  };
+  walkWithAncestors(ast, (node, ancestors) => {
+    if (typeof node.name === "string" && node.name.startsWith(RESERVED_IDENTIFIER_PREFIX)) {
+      throw new SyntaxError(`Identifier '${node.name}' is reserved.`);
+    }
+    switch (node.type) {
+      case "WithStatement":
+        throw new SyntaxError("'with' statements are not supported in workflow scripts.");
+      case "VariableDeclaration":
+        if (node.kind === "await using") {
+          throw new SyntaxError("'await using' declarations are not supported in workflow scripts.");
+        }
+        break;
+      case "AwaitExpression":
+        wrapSpan(node.argument);
+        break;
+      case "ArrowFunctionExpression":
+        if (node.async === true && node.expression === true) {
+          wrapSpan(node.body);
+        }
+        break;
+      case "ForOfStatement":
+        if (node.await === true) {
+          edits.push([node.right.start, ` ${RESERVED_IDENTIFIER_PREFIX}a((`], [node.right.end, "))"]);
+        }
+        break;
+      case "ReturnStatement": {
+        const fn = nearestFunction(ancestors);
+        if (fn?.async !== true)
+          break;
+        if (fn.generator === true) {
+          if (node.argument) {
+            edits.push([node.argument.start, ` await ${RESERVED_IDENTIFIER_PREFIX}((`], [node.argument.end, "))"]);
+          }
+        } else {
+          wrapSpan(node.argument);
+        }
+        break;
+      }
+      case "YieldExpression": {
+        const fn = nearestFunction(ancestors);
+        if (!(fn?.async === true && fn.generator === true))
+          break;
+        if (node.delegate === true) {
+          if (node.argument) {
+            edits.push([node.argument.start, ` ${RESERVED_IDENTIFIER_PREFIX}a((`], [node.argument.end, "))"]);
+          }
+        } else {
+          wrapSpan(node.argument);
+        }
+        break;
+      }
+    }
+  }, []);
+  if (edits.length === 0)
+    return body;
+  edits.sort((a, b) => b[0] - a[0]);
+  let out = wrapped;
+  for (const [pos, text] of edits) {
+    out = out.slice(0, pos) + text + out.slice(pos);
+  }
+  return out.slice(REWRITE_PREFIX.length, out.length - REWRITE_SUFFIX.length);
+};
+var P = RESERVED_IDENTIFIER_PREFIX;
+var ASYNC_ITERATOR_HELPER = `${P}it => ({[Symbol.asyncIterator](){const ${P}ai = ${P}it[Symbol.asyncIterator];if (${P}ai != null && typeof ${P}ai !== 'function') throw new TypeError('@@asyncIterator is not a function');const ${P}i = ${P}ai != null ? ${P}ai.call(${P}it) : ${P}it[Symbol.iterator]();if (${P}i === null || (typeof ${P}i !== 'object' && typeof ${P}i !== 'function')) throw new TypeError('Iterator is not an object');const ${P}nxt = ${P}i.next;if (typeof ${P}nxt !== 'function') throw new TypeError('Iterator.next is not a function');const ${P}ret = ${P}i.return;const ${P}thr = ${P}i.throw;const ${P}w = s => ${P}(s).then(s => { if (s === null || (typeof s !== 'object' && typeof s !== 'function')) throw new TypeError('Iterator result is not an object'); const done = s.done; return ${P}(s.value).then(value => ({value, done})) });return {next:v=>${P}w(${P}nxt.call(${P}i,v)),return:v=>${P}w(typeof ${P}ret==='function'?${P}ret.call(${P}i,v):{value:v,done:true}),throw:e=>typeof ${P}thr==='function'?${P}w(${P}thr.call(${P}i,e)):${P}(typeof ${P}ret==='function'?${P}ret.call(${P}i):undefined).then(()=>{throw new TypeError('The iterator does not provide a throw method')})}}})`;
+var compileScript = (scriptBody) => {
+  try {
+    Function(`async function _check() {'use strict';
+${scriptBody}
+}`);
+    const rewritten = rewriteAwaits(scriptBody);
+    const source = `((${P} => ((${P}a) => async () => {'use strict';
+${rewritten}
+})(${ASYNC_ITERATOR_HELPER}))(Promise.resolve.bind(Promise)))()`;
+    return {
+      ok: true,
+      vmScript: new vm.Script(source, {
+        filename: "workflow.js",
+        importModuleDynamically: () => {
+          throw vmBoundaryError("import() is not available in workflow scripts.");
+        }
+      })
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `SyntaxError: ${msg}` };
+  }
+};
+var NOW_ERR = "Date.now() / new Date() are unavailable in workflow scripts (breaks resume). Stamp results after the workflow returns, or pass timestamps via args.";
+var RANDOM_ERR = "Math.random() is unavailable in workflow scripts (breaks resume). For N independent samples, include the index in the agent label or prompt.";
+var CLOCK_SHIM_SRC = `(() => {
+      const NOW_ERR = ${JSON.stringify(NOW_ERR)};
+      const RANDOM_ERR = ${JSON.stringify(RANDOM_ERR)};
+      Math.random = function random() { throw new Error(RANDOM_ERR) };
+      const RealDate = Date;
+      RealDate.now = function now() { throw new Error(NOW_ERR) };
+      function ShimDate(...a) {
+        if (!new.target) throw new Error(NOW_ERR); // bare Date() → now-string
+        if (a.length === 0) throw new Error(NOW_ERR);
+        return Reflect.construct(RealDate, a, new.target);
+      }
+      ShimDate.now = RealDate.now;
+      ShimDate.parse = RealDate.parse;
+      ShimDate.UTC = RealDate.UTC;
+      ShimDate.prototype = RealDate.prototype;
+      // Close the (new Date(x)).constructor backdoor to RealDate.now — point
+      // .constructor at the shim, then freeze RealDate so it can't be undone.
+      RealDate.prototype.constructor = ShimDate;
+      Object.freeze(RealDate);
+      globalThis.Date = ShimDate;
+    })()`;
+var HARDEN_SRC = `(() => {
+    Object.defineProperty(Error, 'prepareStackTrace', {
+      value: (err, sites) => String(err.stack ?? err),
+      writable: false, configurable: false,
+    });
+    // Delete globals with no REPL use case that either run callbacks on the
+    // host event loop outside any try/catch (FinalizationRegistry — same
+    // DoS shape as a throwing setTimeout callback) or expose shared-memory
+    // primitives (Atomics/SharedArrayBuffer — no cross-realm use, pure
+    // attack-surface reduction).
+    for (const g of ['ShadowRealm', 'WebAssembly', 'FinalizationRegistry',
+                     'WeakRef', 'Atomics', 'SharedArrayBuffer',
+                     'queueMicrotask',
+                     // eval is NOT deleted here — hardenVMIntrinsics is
+                     // shared with REPLTool (codeGeneration:{strings:true}).
+                     // WorkflowTool blocks eval via codeGeneration:false.
+                     // JSC debug/shell globals — present only if
+                     // JSC_useDollarVM=1 or similar, but $vm is a full
+                     // escape (createGlobalObject, addressOf, runScript).
+                     '$vm', 'gc', 'edenGC', 'fullGC', 'print', 'readFile',
+                     'Loader']) {
+      delete globalThis[g];
+    }
+    // SES-style enable-property-override: convert common shadowed data props
+    // to accessors whose setter defineProperty's onto the receiver. Otherwise
+    // freezing makes them non-writable, and [[Set]] on an instance (e.g.
+    // "this.name='X'" in an Error subclass ctor) throws in strict / no-ops in
+    // sloppy — the TC39 "override mistake".
+    function enableOverride(proto, key) {
+      const d = Object.getOwnPropertyDescriptor(proto, key);
+      if (!d || 'get' in d) return;
+      const v = d.value;
+      Object.defineProperty(proto, key, {
+        get() { return v },
+        set(nv) {
+          if (this === proto) return;
+          Object.defineProperty(this, key, { value: nv, writable: true, enumerable: true, configurable: true });
+        },
+        enumerable: d.enumerable, configurable: true,
+      });
+    }
+    const errorCtors = [Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError, AggregateError, globalThis.SuppressedError].filter(Boolean);
+    const errorProtos = errorCtors.map(C => C.prototype);
+    for (const [proto, keys] of [
+      // All Object.prototype data props — Object.assign({}, {propertyIsEnumerable:x})
+      // and friends would otherwise throw post-freeze. Accessor props (__proto__,
+      // __define/lookupGetter__) are skipped by the 'get' in d guard above.
+      [Object.prototype, Object.getOwnPropertyNames(Object.prototype)],
+      [Function.prototype, ['toString', 'constructor', 'name', 'length']],
+      [Array.prototype, ['toString', 'constructor']],
+      [Date.prototype, ['toString', 'toLocaleString', 'valueOf', 'constructor']],
+      ...errorProtos.map(p => [p, ['name', 'message', 'toString', 'constructor']]),
+    ]) for (const k of keys) enableOverride(proto, k);
+    // Error subclasses each have their own .prototype; freezing only Error
+    // leaves TypeError.prototype.then etc. writable. SuppressedError is
+    // from the explicit-resource-management proposal (bun/JSC ship it).
+    for (const C of [Promise, Object, Array, Function, globalThis.Iterator,
+                     Map, Set, WeakMap, WeakSet,
+                     String, Number, Boolean, Symbol, BigInt,
+                     Date, RegExp, ArrayBuffer, DataView,
+                     ...errorCtors,
+                     typeof URL !== 'undefined' ? URL : undefined,
+                    ].filter(Boolean)) {
+      Object.freeze(C);
+      Object.freeze(C.prototype);
+    }
+    // %TypedArray% (shared prototype of all typed arrays) + each concrete.
+    for (const C of [Object.getPrototypeOf(Int8Array),
+                     Int8Array, Uint8Array, Uint8ClampedArray,
+                     Int16Array, Uint16Array, Int32Array, Uint32Array,
+                     globalThis.Float16Array, Float32Array, Float64Array,
+                     BigInt64Array, BigUint64Array].filter(Boolean)) {
+      Object.freeze(C);
+      Object.freeze(C.prototype);
+    }
+    // %AsyncFunction%, %GeneratorFunction%, %AsyncGeneratorFunction% and
+    // their .prototype are not reachable as globals — walk from instances.
+    for (const f of [async()=>{}, function*(){}, async function*(){}]) {
+      Object.freeze(f.constructor);
+      Object.freeze(f.constructor.prototype);
+    }
+    for (const C of [globalThis.DisposableStack, globalThis.AsyncDisposableStack,
+                     globalThis.Intl].filter(Boolean)) {
+      Object.freeze(C);
+      if (C.prototype) Object.freeze(C.prototype);
+    }
+    // Namespace objects (no .prototype) — VM code could otherwise set
+    // JSON.then/Math.then/Reflect.then and any host await on the namespace
+    // object (or on a VM value that aliases it) becomes a thenable escape.
+    // Proxy has no .prototype but freeze closes Proxy.revocable tampering.
+    for (const ns of [JSON, Math, Reflect, Proxy]) Object.freeze(ns);
+    // globalThis can't be frozen (populateContext writes to it), but pinning
+    // .then as non-configurable undefined prevents the sandbox object itself
+    // from becoming a thenable via direct assignment, defineProperty, or
+    // registerTool('then',...).
+    Object.defineProperty(globalThis, 'then', {
+      value: undefined, writable: false, configurable: false,
+    });
+    // Intl.* sub-constructors each have their own .prototype — freezing the
+    // Intl namespace above does NOT freeze Intl.Collator.prototype etc.
+    // Same own-property-.then escape shape as Promise.prototype.then if any
+    // host code ever awaits an Intl.* instance.
+    if (typeof Intl !== 'undefined') {
+      for (const k of Object.getOwnPropertyNames(Intl)) {
+        const C = Intl[k];
+        if (typeof C === 'function') {
+          Object.freeze(C);
+          if (C.prototype) Object.freeze(C.prototype);
+        }
+      }
+    }
+    for (const it of [
+      [][Symbol.iterator](),
+      ''[Symbol.iterator](),
+      new Map()[Symbol.iterator](),
+      new Set()[Symbol.iterator](),
+      'a'.matchAll(/a/g),
+      // Iterator helpers (map/from) are stage-4 but guard for older runtimes.
+      ...(typeof Iterator !== 'undefined' && Iterator.from ? [
+        [].values().map(x=>x),
+        // %WrapForValidIteratorPrototype% — Iterator.from(non-Iterator) wraps
+        // via a distinct intrinsic prototype not reachable from any other path.
+        Iterator.from({next:()=>({done:true})}),
+      ] : []),
+      (function*(){})(),
+      (async function*(){})(),
+      // %SegmentsPrototype% + %SegmentIteratorPrototype% — host for..of on a
+      // VM Segments object would otherwise see a writable .then on the chain.
+      ...(typeof Intl !== 'undefined' && Intl.Segmenter ? (s => [s, s[Symbol.iterator]()])(new Intl.Segmenter().segment('a')) : []),
+    ]) {
+      for (let p = Object.getPrototypeOf(it); p; p = Object.getPrototypeOf(p)) {
+        Object.freeze(p);
+      }
+    }
+    })()`;
+var createSandboxContext = (contextObject) => {
+  const ctx = vm.createContext(contextObject, {
+    codeGeneration: { strings: false, wasm: false }
+  });
+  vm.runInContext(CLOCK_SHIM_SRC, ctx);
+  vm.runInContext(HARDEN_SRC, ctx);
+  return ctx;
+};
+var makeInContextHookWrapper = (ctx) => vm.runInContext("(hostFn => async (...a) => hostFn(...a))", ctx);
+var makeInContextApplier = (ctx) => vm.runInContext("((fn, ...args) => fn(...args))", ctx);
+var makeBoxedSettler = (ctx) => vm.runInContext("(async v => ({__proto__: null, v: await v}))", ctx);
+var makeInContextInvoker = (ctx) => vm.runInContext("(fn => { fn() })", ctx);
+var makeInContextCloner = (ctx) => vm.runInContext(`(() => {
+      const _WeakMap = WeakMap, _isArray = Array.isArray,
+            _keys = Object.keys, _defineProperty = Object.defineProperty,
+            _Error = Error, _isSafeInteger = Number.isSafeInteger,
+            _Symbol = Symbol
+      // Module-private symbol tagging the boundary-cap error so the
+      // per-element/per-key catch blocks below can tell it apart from an
+      // INCIDENTAL throw (a hostile getter / Proxy trap on a single value).
+      // The cap error must propagate out of the whole clone at any nesting
+      // depth (matching top-level behavior); incidental throws still degrade
+      // that one slot to undefined. The symbol is unreachable from user code,
+      // so it can't be forged; the isCap read is wrapped so a hostile thrown
+      // value's get trap can at most fake "true" (→ benign propagation),
+      // never run code we act on.
+      const _CAP = _Symbol('vmArrayCap')
+      function capErr(msg) {
+        const e = new _Error(msg)
+        try { e[_CAP] = true } catch {}
+        return e
+      }
+      function isCap(e) {
+        try { return typeof e === 'object' && e !== null && e[_CAP] === true } catch { return false }
+      }
+      return (hostVal) => {
+        const seen = new _WeakMap()
+        function c(v) {
+          if (typeof v === 'function') return undefined
+          if (v === null || typeof v !== 'object') return v
+          const hit = seen.get(v); if (hit !== undefined) return hit
+          if (_isArray(v)) {
+            // Read length ONCE — re-reading v.length per iteration lets a
+            // Proxy length getter that increments make i < len never false
+            // (infinite host-thread hang outside the VM sync-timeout).
+            const len = v.length
+            if (typeof len !== 'number' || !_isSafeInteger(len)) {
+              throw capErr('array length is not a safe integer across the workflow VM boundary')
+            }
+            if (len > ${MAX_VM_BOUNDARY_ITEMS}) {
+              throw capErr('array length ' + len + ' exceeds the maximum of ${MAX_VM_BOUNDARY_ITEMS} supported across the workflow VM boundary')
+            }
+            const out = []; seen.set(v, out)
+            for (let i = 0; i < len; i++) {
+              try { out[i] = c(v[i]) } catch (e) { if (isCap(e)) throw e; out[i] = undefined }
+            }
+            return out
+          }
+          const out = {}; seen.set(v, out)
+          let ks; try { ks = _keys(v) } catch { return out }
+          for (const k of ks) {
+            if (k === '__proto__') continue
+            try {
+              const vk = v[k]
+              if (typeof vk === 'function') continue
+              _defineProperty(out, k, { value: c(vk), writable: true, enumerable: true, configurable: true })
+            } catch (e) { if (isCap(e)) throw e }
+          }
+          return out
+        }
+        return c(hostVal)
+      }
+    })()`, ctx);
+var cloneJsonIntoContext = (ctx, json) => vm.runInContext(`JSON.parse(${JSON.stringify(json)})`, ctx);
+var makeDeterministicTimers = (signal) => {
+  const pending = new Set;
+  let invoke = (fn) => fn();
+  signal?.addEventListener("abort", () => {
+    for (const id of pending)
+      clearTimeout(id);
+    pending.clear();
+  }, { once: true });
+  return {
+    setTimeout: sanitizeHostSyncFn((cb, ms) => {
+      if (signal?.aborted)
+        return 0;
+      const id = Number(setTimeout(() => {
+        try {
+          invoke(cb);
+        } catch {}
+      }, ms));
+      pending.add(id);
+      return id;
+    }),
+    clearTimeout: sanitizeHostSyncFn((id) => {
+      pending.delete(id);
+      clearTimeout(id);
+    }),
+    bindVMInvoke: (fn) => {
+      invoke = fn;
+    }
+  };
+};
+var makeConsoleShim = (log) => {
+  const fmt = (args) => args.map((a) => {
+    if (typeof a === "string")
+      return a;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return `[${typeof a}]`;
+    }
+  }).join(" ");
+  const sink = (prefix) => sanitizeHostSyncFn((...args) => log(prefix + fmt(args)));
+  return Object.assign(Object.create(null), {
+    log: sink(""),
+    info: sink(""),
+    debug: sink(""),
+    error: sink("[error] "),
+    warn: sink("[warn] ")
+  });
+};
+var VM_ARRAY_CAP = Symbol("vmArrayCap");
+var capError = (message) => {
+  const e = new Error(message);
+  try {
+    e[VM_ARRAY_CAP] = true;
+  } catch {}
+  return e;
+};
+var isCapError = (e) => {
+  try {
+    return typeof e === "object" && e !== null && e[VM_ARRAY_CAP] === true;
+  } catch {
+    return false;
+  }
+};
+var readBoundaryArrayLength = (arr) => {
+  let len;
+  try {
+    len = arr.length;
+  } catch {
+    throw new Error("unable to read array length across the workflow VM boundary");
+  }
+  if (typeof len !== "number" || !Number.isSafeInteger(len)) {
+    throw capError("array length is not a safe integer across the workflow VM boundary");
+  }
+  if (len > MAX_VM_BOUNDARY_ITEMS) {
+    throw capError(`array length ${len} exceeds the maximum of ${MAX_VM_BOUNDARY_ITEMS} supported across the workflow VM boundary`);
+  }
+  return len;
+};
+var extractBoundaryArray = (value) => {
+  if (value === null || typeof value !== "object")
+    return [];
+  const len = readBoundaryArrayLength(value);
+  const out = [];
+  for (let i = 0;i < len; i++) {
+    try {
+      out[i] = value[i];
+    } catch {
+      out[i] = undefined;
+    }
+  }
+  return out;
+};
+var hostSafeCopy = (value, seen = new WeakMap) => {
+  if (typeof value === "function")
+    return;
+  if (value === null || typeof value !== "object")
+    return value;
+  const hit = seen.get(value);
+  if (hit !== undefined)
+    return hit;
+  if (Array.isArray(value)) {
+    const out2 = [];
+    seen.set(value, out2);
+    const len = readBoundaryArrayLength(value);
+    for (let i = 0;i < len; i++) {
+      try {
+        out2[i] = hostSafeCopy(value[i], seen);
+      } catch (e) {
+        if (isCapError(e))
+          throw e;
+        out2[i] = undefined;
+      }
+    }
+    return out2;
+  }
+  const out = {};
+  seen.set(value, out);
+  let keys;
+  try {
+    keys = Object.keys(value);
+  } catch {
+    return out;
+  }
+  for (const k of keys) {
+    if (k === "__proto__")
+      continue;
+    try {
+      const v = value[k];
+      if (typeof v === "function")
+        continue;
+      out[k] = hostSafeCopy(v, seen);
+    } catch (e) {
+      if (isCapError(e))
+        throw e;
+    }
+  }
+  return out;
+};
+var runScript = (vmScript, ctx, syncTimeoutMs = SYNC_RUN_TIMEOUT_MS) => vmScript.runInContext(ctx, { timeout: syncTimeoutMs });
+var describeScriptError = (err, frames = 5) => {
+  if (!(err instanceof Error))
+    return String(err);
+  if (!err.stack)
+    return err.message;
+  const lines = err.stack.split(`
+`);
+  const head = lines[0] ?? err.message;
+  const atFrames = lines.slice(1).filter((l) => l.trim().startsWith("at "));
+  if (atFrames.length <= frames)
+    return err.stack;
+  return [head, ...atFrames.slice(0, frames)].join(`
+`);
+};
+var formatScriptError = (err) => {
+  let stack;
+  try {
+    const s = err?.stack;
+    stack = typeof s === "string" ? s : undefined;
+  } catch {
+    stack = undefined;
+  }
+  try {
+    if (stack !== undefined) {
+      const lines = stack.split(`
+`);
+      const atFrames = lines.slice(1).filter((l) => l.trim().startsWith("at "));
+      return atFrames.length <= 5 ? stack : [lines[0] ?? "", ...atFrames.slice(0, 5)].join(`
+`);
+    }
+    return describeScriptError(err);
+  } catch {
+    return "<unprintable error>";
+  }
+};
+
+// src/runtime/semaphore.ts
+var makeSemaphore = (permits) => {
+  let free = Math.max(1, permits);
+  const queue = [];
+  const acquire = () => new Promise((resolve) => {
+    if (free > 0) {
+      free -= 1;
+      resolve();
+      return;
+    }
+    queue.push(() => {
+      resolve();
+    });
+  });
+  const release = () => {
+    const next = queue.shift();
+    if (next !== undefined) {
+      next();
+      return;
+    }
+    free += 1;
+  };
+  return {
+    withPermit: async (fn) => {
+      await acquire();
+      try {
+        return await fn();
+      } finally {
+        release();
+      }
+    }
+  };
+};
+
+// src/runtime/structuredSchema.ts
+import { Ajv } from "ajv";
+var compile = (schema) => {
+  try {
+    const ajv = new Ajv({ allErrors: true });
+    if (!ajv.validateSchema(schema)) {
+      return { error: ajv.errorsText(ajv.errors) };
+    }
+    const validateFn = ajv.compile(schema);
+    return {
+      validate: (input) => {
+        if (validateFn(input))
+          return { ok: true };
+        const detail = validateFn.errors?.map((e) => `${e.instancePath || "root"}: ${e.message}`).join(", ");
+        return {
+          ok: false,
+          message: `Output does not match required schema: ${detail}`
+        };
+      }
+    };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+};
+var memo = new WeakMap;
+var compileStructuredSchema = (schema) => {
+  if (typeof schema !== "object" || schema === null)
+    return compile(schema);
+  const hit = memo.get(schema);
+  if (hit !== undefined)
+    return hit;
+  const compiled = compile(schema);
+  memo.set(schema, compiled);
+  return compiled;
+};
+
+// src/runtime/types.ts
+class WorkflowAgentCapError extends Error {
+  name = "WorkflowAgentCapError";
+  constructor() {
+    super(AGENT_CAP_MESSAGE);
+  }
+}
+
+class WorkflowBudgetExceededError extends Error {
+  name = "WorkflowBudgetExceededError";
+  spent;
+  total;
+  constructor(spent, total) {
+    super(budgetExceededMessage(spent, total));
+    this.spent = spent;
+    this.total = total;
+  }
+}
+
+// src/runtime/worktree.ts
+import { execFile } from "node:child_process";
+import { join as join2 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var git = async (cwd, args) => {
+  const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return stdout;
+};
+var worktreePromptSuffix = (path) => `
+
+You are running in an isolated git worktree at ${path}. Do all of your work inside this directory — changes here do not affect the main checkout until merged.`;
+var createWorktree = async (repoCwd, runDir, agentIndex) => {
+  const path = join2(runDir, "worktrees", `wf-${agentIndex}`);
+  await git(repoCwd, ["worktree", "add", "--detach", path, "HEAD"]);
+  return {
+    path,
+    cleanupIfClean: async () => {
+      try {
+        const status = await git(path, ["status", "--porcelain"]);
+        if (status.trim().length > 0)
+          return;
+        await git(repoCwd, ["worktree", "remove", "--force", path]);
+      } catch {}
+    }
+  };
+};
+
+// src/runtime/orchestrator.ts
+var applyEvent = (s, event) => {
+  if (event.type === "workflow_log") {
+    const logs = s.logs.length >= LOG_BUFFER_CAP ? [...s.logs.slice(1), event.message] : [...s.logs, event.message];
+    return { ...s, logs };
+  }
+  if (event.type === "workflow_phase") {
+    if (s.phases.includes(event.title))
+      return s;
+    return { ...s, phases: [...s.phases, event.title] };
+  }
+  const agents = [...s.agents];
+  const at = agents.findIndex((a) => a.index === event.index);
+  const prev = at >= 0 ? agents[at] : undefined;
+  const next = {
+    index: event.index,
+    label: event.label,
+    ...event.phaseTitle !== undefined ? { phaseTitle: event.phaseTitle } : prev?.phaseTitle !== undefined ? { phaseTitle: prev.phaseTitle } : {},
+    state: event.state === "start" ? "running" : event.state === "done" ? "done" : "error",
+    ...event.cached !== undefined ? { cached: event.cached } : {},
+    ...event.tokens !== undefined ? { tokens: event.tokens } : {},
+    ...event.toolCalls !== undefined ? { toolCalls: event.toolCalls } : {},
+    ...event.error !== undefined ? { error: event.error } : {}
+  };
+  if (at >= 0)
+    agents[at] = next;
+  else
+    agents.push(next);
+  return { ...s, agents };
+};
+var createWorkflowHost = (config) => {
+  const { runner, registry, defaultModel } = config;
+  const launch = (params) => {
+    const { runId } = params;
+    const runDir = runDirFor(runId);
+    ensureRunDir(runDir);
+    const journalPath = journalPathFor(runDir);
+    const progressPath = progressPathFor(runDir);
+    const replay = params.resumeFromRunId !== undefined ? buildReplayMap(readJournal(journalPath)) : null;
+    const journal = makeJournal(journalPath);
+    const taskId = "w" + runId.replace(/^wf_/, "").slice(0, 8);
+    const initial = {
+      taskId,
+      runId,
+      status: "running",
+      name: params.parsed.meta.name,
+      description: params.parsed.meta.description,
+      runDir,
+      scriptPath: params.scriptPath,
+      cwd: params.cwd,
+      startTime: Date.now(),
+      agentCount: 0,
+      tokensSpent: 0,
+      phases: (params.parsed.meta.phases ?? []).map((p) => p.title),
+      agents: [],
+      logs: [],
+      failures: []
+    };
+    const abort = registry.register(initial);
+    runWorkflowBody({
+      config,
+      params,
+      runDir,
+      progressPath,
+      journal,
+      replay,
+      abort,
+      runner,
+      defaultModel
+    }).catch((err) => {
+      registry.patch(runId, (s) => s.status === "running" ? {
+        ...s,
+        status: "failed",
+        endTime: Date.now(),
+        error: err instanceof Error ? err.message : String(err)
+      } : s);
+    });
+    return { taskId, runId, runDir };
+  };
+  return { launch };
+};
+var runWorkflowBody = async (a) => {
+  const { config, params, runDir, progressPath, journal, abort, runner } = a;
+  const { registry } = config;
+  const runId = params.runId;
+  const compiled = compileScript(params.parsed.scriptBody);
+  if (!compiled.ok) {
+    registry.patch(runId, (s) => ({
+      ...s,
+      status: "failed",
+      endTime: Date.now(),
+      error: compiled.error
+    }));
+    return;
+  }
+  let agentCount = 0;
+  let prevKey = "";
+  let journalDirty = a.replay === null;
+  let tokensSpent = 0;
+  const failures = [];
+  const phaseIndexByTitle = new Map;
+  let nextPhaseIndex = 0;
+  let currentPhase;
+  let settle = async (v) => ({ v: await v });
+  let callInContext = (fn, ...args) => fn(...args);
+  let cloneIntoVm = (v) => structuredClone(v);
+  const sleep0 = () => new Promise((resolve) => setTimeout(resolve, 0));
+  const sleepAbortable = (ms) => new Promise((resolve) => {
+    const t = setTimeout(() => {
+      abort.signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      resolve();
+    };
+    abort.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  for (const p of params.parsed.meta.phases ?? []) {
+    if (!phaseIndexByTitle.has(p.title)) {
+      phaseIndexByTitle.set(p.title, nextPhaseIndex++);
+    }
+  }
+  const emit = (event) => {
+    appendJsonl(progressPath, { ts: Date.now(), ...event });
+    registry.patch(runId, (s) => applyEvent(s, event));
+  };
+  const resolvePhase = (title) => {
+    let idx = phaseIndexByTitle.get(title);
+    if (idx === undefined) {
+      idx = nextPhaseIndex++;
+      phaseIndexByTitle.set(title, idx);
+    }
+    emit({ type: "workflow_phase", index: idx, title });
+    return idx;
+  };
+  const phase = (title) => {
+    currentPhase = String(title);
+    resolvePhase(currentPhase);
+  };
+  const log = (message) => {
+    emit({ type: "workflow_log", message: String(message) });
+  };
+  const recordFailure = (message) => {
+    failures.push(message);
+    registry.patch(runId, (s) => ({
+      ...s,
+      failures: [...s.failures, message]
+    }));
+  };
+  const checkCap = () => {
+    if (agentCount >= AGENT_CAP)
+      throw new WorkflowAgentCapError;
+  };
+  const checkBudget = () => {
+    const total = params.tokenBudgetTotal;
+    if (total !== null && total > 0 && tokensSpent >= total) {
+      throw new WorkflowBudgetExceededError(tokensSpent, total);
+    }
+  };
+  const onTokens = (delta) => {
+    tokensSpent += delta;
+  };
+  const localSem = makeSemaphore(config.maxConcurrency ?? LOCAL_CONCURRENCY);
+  const worktreeSem = makeSemaphore(1);
+  const runOneAgent = async (index, prompt, opts, label, phaseTitle, phaseIndex, stallMs) => {
+    if (opts.isolation === "remote")
+      throw new Error(ERR_ISOLATION_REMOTE);
+    if (opts.agentType !== undefined) {
+      throw new Error(ERR_AGENT_TYPE_UNAVAILABLE);
+    }
+    const hasSchema = opts.schema !== undefined;
+    const contract = hasSchema ? SUBAGENT_CONTRACT_SCHEMA : SUBAGENT_CONTRACT_TEXT;
+    const model = opts.model ?? config.defaultModel;
+    const agentId = `${runId}-a${index}`;
+    let validate;
+    let schemaDoc;
+    if (hasSchema) {
+      const compiledSchema = compileStructuredSchema(opts.schema);
+      if ("error" in compiledSchema) {
+        throw new TypeError(`agent({schema}) received an invalid JSON Schema: ${compiledSchema.error}`);
+      }
+      validate = compiledSchema.validate;
+      schemaDoc = opts.schema !== null && typeof opts.schema === "object" ? opts.schema : undefined;
+    }
+    let effCwd = params.cwd;
+    let effPrompt = prompt;
+    let worktree;
+    if (opts.isolation === "worktree") {
+      try {
+        worktree = await worktreeSem.withPermit(() => createWorktree(params.cwd, runDir, index));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`agent({isolation:'worktree'}): ${msg}`);
+      }
+      effCwd = worktree.path;
+      effPrompt = prompt + worktreePromptSuffix(worktree.path);
+    }
+    const attempt = async () => {
+      const attemptAbort = new AbortController;
+      const onRunAbort = () => attemptAbort.abort();
+      abort.signal.addEventListener("abort", onRunAbort, { once: true });
+      let watchdog;
+      const resetWatchdog = () => {
+        if (watchdog !== undefined)
+          clearTimeout(watchdog);
+        if (stallMs > 0) {
+          watchdog = setTimeout(() => attemptAbort.abort(), stallMs);
+        }
+      };
+      resetWatchdog();
+      try {
+        return await runner.run({
+          prompt: effPrompt,
+          contract,
+          cwd: effCwd,
+          ...opts.model !== undefined ? { model: opts.model } : {},
+          ...schemaDoc !== undefined ? { schema: schemaDoc } : {},
+          ...validate !== undefined ? { validate } : {},
+          signal: attemptAbort.signal,
+          onActivity: resetWatchdog,
+          onTokens
+        });
+      } finally {
+        if (watchdog !== undefined)
+          clearTimeout(watchdog);
+        abort.signal.removeEventListener("abort", onRunAbort);
+      }
+    };
+    try {
+      let result = await attempt();
+      let attemptNo = 1;
+      if (abort.signal.aborted)
+        return new Promise(() => {});
+      const degraded = !hasSchema && result.aborted !== true && result.apiError === undefined && result.outputTokens < 50 && result.text.trim().length === 0;
+      if (degraded) {
+        emit({
+          type: "workflow_log",
+          message: `[throttle] retrying agent ${index} after backoff`
+        });
+        await sleepAbortable(THROTTLE_BACKOFF_MS);
+        if (abort.signal.aborted)
+          return new Promise(() => {});
+        attemptNo += 1;
+        result = await attempt();
+      }
+      let stallRetries = 0;
+      while (result.aborted === true && !abort.signal.aborted && stallRetries < MAX_STALL_RETRIES) {
+        stallRetries += 1;
+        attemptNo += 1;
+        emit({
+          type: "workflow_log",
+          message: `[stall] retrying agent ${index} (attempt ${attemptNo})`
+        });
+        result = await attempt();
+      }
+      if (abort.signal.aborted)
+        return new Promise(() => {});
+      if (result.aborted === true) {
+        throw new Error(`agent stalled on all ${stallRetries + 1} attempts (no progress for ${stallMs}ms each)`);
+      }
+      if (result.apiError !== undefined) {
+        emit({
+          type: "workflow_agent",
+          index,
+          label,
+          phaseIndex,
+          ...phaseTitle !== undefined ? { phaseTitle } : {},
+          agentId,
+          model,
+          state: "error",
+          error: result.apiError,
+          tokens: result.outputTokens,
+          toolCalls: result.toolCalls
+        });
+        const failed = `[${label}] failed: ${result.apiError}`;
+        recordFailure(failed);
+        emit({ type: "workflow_log", message: failed });
+        return null;
+      }
+      emit({
+        type: "workflow_agent",
+        index,
+        label,
+        phaseIndex,
+        ...phaseTitle !== undefined ? { phaseTitle } : {},
+        agentId,
+        model,
+        state: "done",
+        tokens: result.outputTokens,
+        toolCalls: result.toolCalls,
+        resultPreview: previewTruncate(hasSchema ? result.structured : result.text)
+      });
+      registry.patch(runId, (s) => ({ ...s, tokensSpent }));
+      if (hasSchema) {
+        if (result.structured === undefined) {
+          throw new Error(ERR_NO_STRUCTURED_OUTPUT);
+        }
+        return cloneIntoVm(result.structured);
+      }
+      return result.text;
+    } finally {
+      if (worktree !== undefined)
+        await worktree.cleanupIfClean();
+    }
+  };
+  const schemaCopies = new WeakMap;
+  const agent = async (prompt, optsRaw) => {
+    let schemaObj;
+    try {
+      const s = optsRaw?.schema;
+      if (s !== null && typeof s === "object")
+        schemaObj = s;
+    } catch {}
+    const opts = hostSafeCopy(optsRaw);
+    if (opts !== undefined && schemaObj !== undefined) {
+      let copied = schemaCopies.get(schemaObj);
+      if (copied === undefined) {
+        copied = hostSafeCopy(schemaObj);
+        schemaCopies.set(schemaObj, copied);
+      }
+      opts.schema = copied;
+    }
+    if (abort.signal.aborted)
+      return new Promise(() => {});
+    try {
+      checkCap();
+      checkBudget();
+    } catch (err) {
+      await sleep0();
+      throw err;
+    }
+    const index = ++agentCount;
+    registry.patch(runId, (s) => ({ ...s, agentCount }));
+    const promptStr = String(prompt);
+    const label = opts?.label != null ? String(opts.label) : promptStr.slice(0, 60).replace(/\s+/g, " ").trim();
+    const phaseTitle = opts?.phase != null ? String(opts.phase) : currentPhase;
+    const phaseIndex = phaseTitle !== undefined ? resolvePhase(phaseTitle) : -1;
+    const stallMs = opts?.stallMs != null ? Number(opts.stallMs) : DEFAULT_STALL_MS;
+    const key = cacheKey(promptStr, opts ?? {}, prevKey);
+    prevKey = key;
+    if (!journalDirty && a.replay && a.replay.results.has(key)) {
+      const cached = a.replay.results.get(key).result;
+      emit({
+        type: "workflow_agent",
+        index,
+        label,
+        ...phaseTitle !== undefined ? { phaseTitle } : {},
+        phaseIndex,
+        state: "done",
+        cached: true,
+        resultPreview: previewTruncate(cached)
+      });
+      return cloneIntoVm(cached);
+    }
+    journalDirty = true;
+    emit({
+      type: "workflow_agent",
+      index,
+      label,
+      ...phaseTitle !== undefined ? { phaseTitle } : {},
+      phaseIndex,
+      promptPreview: previewTruncate(promptStr),
+      model: opts?.model ?? a.defaultModel,
+      state: "start"
+    });
+    const agentId = `${runId}-a${index}`;
+    return localSem.withPermit(async () => {
+      journal.append({ type: "started", key, agentId });
+      const value = await runOneAgent(index, promptStr, opts ?? {}, label, phaseTitle, phaseIndex, stallMs);
+      if (value !== null) {
+        journal.append({ type: "result", key, agentId, result: value });
+      }
+      return value;
+    }).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      emit({
+        type: "workflow_agent",
+        index,
+        label,
+        ...phaseTitle !== undefined ? { phaseTitle } : {},
+        phaseIndex,
+        state: "error",
+        error: msg
+      });
+      throw err;
+    });
+  };
+  const mapSettledSlots = (hookName, settled) => {
+    let dropped = 0;
+    const out = settled.map((s, i) => {
+      if (s.status === "fulfilled")
+        return s.value.v;
+      const { name, msg } = boundaryErrorInfo(s.reason);
+      if (name === "WorkflowBudgetExceededError") {
+        dropped += 1;
+        return null;
+      }
+      const line = `${hookName}[${i}] failed: ${msg}`;
+      recordFailure(line);
+      emit({ type: "workflow_log", message: line });
+      return null;
+    });
+    if (dropped > 0) {
+      recordFailure(`${hookName}: ${dropped} ${dropped === 1 ? "slot" : "slots"} dropped — token budget exceeded`);
+    }
+    return out;
+  };
+  const parallel = async (thunksRaw) => {
+    if (abort.signal.aborted)
+      return new Promise(() => {});
+    await sleep0();
+    if (!Array.isArray(thunksRaw))
+      throw new TypeError(ERR_PARALLEL_NOT_ARRAY);
+    const thunks = extractBoundaryArray(thunksRaw);
+    if (thunks.length === 0)
+      return cloneIntoVm([]);
+    checkCap();
+    checkBudget();
+    for (const t of thunks) {
+      if (typeof t !== "function") {
+        throw new TypeError(ERR_PARALLEL_NOT_FUNCTIONS);
+      }
+    }
+    const settled = await Promise.allSettled(thunks.map((t) => settle(callInContext(t))));
+    return cloneIntoVm(mapSettledSlots("parallel", settled));
+  };
+  const pipeline = async (itemsRaw, ...stagesRaw) => {
+    if (abort.signal.aborted)
+      return new Promise(() => {});
+    await sleep0();
+    if (!Array.isArray(itemsRaw))
+      throw new TypeError(ERR_PIPELINE_NOT_ARRAY);
+    const items = extractBoundaryArray(itemsRaw);
+    const stages = extractBoundaryArray(stagesRaw);
+    if (items.length === 0)
+      return cloneIntoVm([]);
+    checkCap();
+    checkBudget();
+    for (const stage of stages) {
+      if (typeof stage !== "function") {
+        throw new TypeError(ERR_PIPELINE_STAGES);
+      }
+    }
+    const settled = await Promise.allSettled(items.map(async (item, index) => {
+      let acc = await settle(item);
+      for (const stage of stages) {
+        if (acc.v === null)
+          break;
+        acc = await settle(callInContext(stage, acc.v, item, index));
+      }
+      return acc;
+    }));
+    return cloneIntoVm(mapSettledSlots("pipeline", settled));
+  };
+  const workflowHook = () => Promise.reject(new Error(ERR_WORKFLOW_HOOK_UNAVAILABLE));
+  const budget = Object.freeze(Object.assign(Object.create(null), {
+    total: params.tokenBudgetTotal,
+    spent: sanitizeHostSyncFn(() => tokensSpent),
+    remaining: sanitizeHostSyncFn(() => params.tokenBudgetTotal == null ? Infinity : Math.max(0, params.tokenBudgetTotal - tokensSpent))
+  }));
+  const consoleShim = makeConsoleShim(log);
+  const timers = makeDeterministicTimers(abort.signal);
+  const ctx = createSandboxContext(Object.assign(Object.create(null), {
+    log: sanitizeHostSyncFn(log),
+    phase: sanitizeHostSyncFn(phase),
+    budget,
+    console: consoleShim,
+    setTimeout: timers.setTimeout,
+    clearTimeout: timers.clearTimeout
+  }));
+  timers.bindVMInvoke(makeInContextInvoker(ctx));
+  const wrapHook = makeInContextHookWrapper(ctx);
+  for (const [name, hook] of [
+    ["agent", agent],
+    ["parallel", parallel],
+    ["pipeline", pipeline],
+    ["workflow", workflowHook]
+  ]) {
+    Object.defineProperty(ctx, name, {
+      value: wrapHook(sanitizeHostAsyncFn(nullProtoHostFn(hook))),
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  {
+    const json = params.args === undefined ? undefined : JSON.stringify(params.args);
+    Object.defineProperty(ctx, "args", {
+      value: json === undefined ? undefined : cloneJsonIntoContext(ctx, json),
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  settle = makeBoxedSettler(ctx);
+  callInContext = makeInContextApplier(ctx);
+  cloneIntoVm = makeInContextCloner(ctx);
+  const outcome = await (async () => {
+    let removeAbortListener;
+    try {
+      const raw = runScript(compiled.vmScript, ctx);
+      const boxed = settle(raw);
+      boxed.catch(() => {});
+      const abortPromise = new Promise((_, reject) => {
+        const onAbort = () => reject(new Error(ERR_WORKFLOW_ABORTED));
+        if (abort.signal.aborted) {
+          onAbort();
+          return;
+        }
+        abort.signal.addEventListener("abort", onAbort, { once: true });
+        removeAbortListener = () => abort.signal.removeEventListener("abort", onAbort);
+      });
+      const value = (await Promise.race([boxed, abortPromise])).v;
+      let cloned;
+      try {
+        cloned = structuredClone(value);
+      } catch (err) {
+        if (value === null || typeof value !== "object")
+          throw err;
+        cloned = JSON.parse(JSON.stringify(value, (_k, v) => typeof v === "function" ? undefined : v) ?? "null");
+      }
+      JSON.stringify(cloned);
+      return { ok: true, result: cloned };
+    } catch (err) {
+      return { ok: false, error: formatScriptError(err) };
+    } finally {
+      removeAbortListener?.();
+    }
+  })();
+  if (outcome.ok) {
+    try {
+      writeFileSync(resultPathFor(runDir), JSON.stringify(outcome.result ?? null, null, 2), "utf8");
+    } catch {}
+  }
+  registry.patch(runId, (s) => {
+    if (s.status !== "running")
+      return { ...s, agentCount, tokensSpent };
+    return {
+      ...s,
+      status: abort.signal.aborted ? "stopped" : outcome.ok ? "completed" : "failed",
+      endTime: Date.now(),
+      agentCount,
+      tokensSpent,
+      ...outcome.ok ? { result: outcome.result } : { error: outcome.error }
+    };
+  });
+};
+
+// src/runtime/runs.ts
+import { readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var TERMINAL = new Set([
+  "completed",
+  "failed",
+  "stopped"
+]);
+var isTerminal = (status) => TERMINAL.has(status);
+var persistSnapshot = (state) => {
+  try {
+    writeFileSync2(statePathFor(state.runDir), JSON.stringify(state, null, 2), "utf8");
+  } catch {}
+};
+var rehydrate = (runs) => {
+  let entries;
+  try {
+    entries = readdirSync(join3(stateHome(), "runs"));
+  } catch {
+    return;
+  }
+  for (const runId of entries) {
+    try {
+      const raw = readFileSync2(statePathFor(runDirFor(runId)), "utf8");
+      const state = JSON.parse(raw);
+      if (runs.has(state.runId))
+        continue;
+      const fixed = state.status === "running" ? {
+        ...state,
+        status: "failed",
+        error: "workflow process exited before completion — resume with workflow({scriptPath, resumeFromRunId})"
+      } : state;
+      if (fixed !== state)
+        persistSnapshot(fixed);
+      runs.set(fixed.runId, {
+        state: fixed,
+        abort: new AbortController,
+        waiters: []
+      });
+    } catch {}
+  }
+};
+var createRunRegistry = () => {
+  const runs = new Map;
+  rehydrate(runs);
+  const get = (runId) => runs.get(runId)?.state;
+  const patch = (runId, f) => {
+    const rec = runs.get(runId);
+    if (rec === undefined)
+      return;
+    const wasTerminal = isTerminal(rec.state.status);
+    rec.state = f(rec.state);
+    persistSnapshot(rec.state);
+    if (!wasTerminal && isTerminal(rec.state.status)) {
+      const waiters = rec.waiters.splice(0);
+      for (const w of waiters)
+        w();
+    }
+  };
+  return {
+    register: (state) => {
+      const abort = new AbortController;
+      runs.set(state.runId, { state, abort, waiters: [] });
+      persistSnapshot(state);
+      return abort;
+    },
+    get,
+    list: () => Array.from(runs.values()).map((r) => r.state),
+    patch,
+    stop: (runId) => {
+      const rec = runs.get(runId);
+      if (rec === undefined)
+        return false;
+      if (isTerminal(rec.state.status))
+        return false;
+      rec.abort.abort();
+      patch(runId, (s) => ({ ...s, status: "stopped", endTime: Date.now() }));
+      return true;
+    },
+    isRunning: (runId) => {
+      const rec = runs.get(runId);
+      return rec !== undefined && rec.state.status === "running";
+    },
+    waitForTerminal: (runId, timeoutMs) => {
+      const rec = runs.get(runId);
+      if (rec === undefined)
+        return Promise.resolve(undefined);
+      if (isTerminal(rec.state.status))
+        return Promise.resolve(rec.state);
+      return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          resolve(runs.get(runId)?.state);
+        };
+        const timer = setTimeout(finish, timeoutMs);
+        rec.waiters.push(finish);
+      });
+    }
+  };
+};
+
+// src/server.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/runtime/meta.ts
+import * as acorn2 from "acorn";
+var TS_HINT = "Workflow scripts must be plain JavaScript — TypeScript syntax (type annotations, interfaces, generics) fails to parse.";
+var evalLiteral = (node) => {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "TemplateLiteral": {
+      if (node.expressions.length > 0) {
+        throw new Error("non-literal node type in meta: TemplateLiteral");
+      }
+      return node.quasis.map((q) => q.value.cooked).join("");
+    }
+    case "ArrayExpression": {
+      const out = [];
+      for (const el of node.elements) {
+        if (el === null) {
+          throw new Error("non-literal node type in meta: SparseElement");
+        }
+        if (el.type === "SpreadElement") {
+          throw new Error("non-literal node type in meta: SpreadElement");
+        }
+        out.push(evalLiteral(el));
+      }
+      return out;
+    }
+    case "ObjectExpression": {
+      const out = {};
+      for (const prop of node.properties) {
+        if (prop.type !== "Property") {
+          throw new Error("non-literal node type in meta: " + prop.type);
+        }
+        if (prop.computed || prop.method || prop.kind !== "init") {
+          throw new Error("non-literal node type in meta: ComputedOrMethod");
+        }
+        const key = prop.key.type === "Identifier" ? prop.key.name : evalLiteral(prop.key);
+        out[key] = evalLiteral(prop.value);
+      }
+      return out;
+    }
+    case "UnaryExpression": {
+      if (node.operator === "-" && node.argument.type === "Literal" && typeof node.argument.value === "number") {
+        return -node.argument.value;
+      }
+      throw new Error("non-literal node type in meta: UnaryExpression");
+    }
+    default:
+      throw new Error("non-literal node type in meta: " + node.type);
+  }
+};
+var nonEmptyString = (v) => typeof v === "string" && v.length > 0;
+var shapePhases = (raw) => {
+  if (!Array.isArray(raw))
+    return;
+  const out = [];
+  for (const entry of raw) {
+    if (entry && typeof entry === "object" && nonEmptyString(entry["title"])) {
+      const e = entry;
+      const phase = {
+        title: e["title"],
+        ...typeof e["detail"] === "string" ? { detail: e["detail"] } : {},
+        ...typeof e["model"] === "string" ? { model: e["model"] } : {}
+      };
+      out.push(phase);
+    }
+  }
+  return out.length > 0 ? out : undefined;
+};
+var shapeMeta = (raw) => {
+  const obj = raw ?? {};
+  if (!nonEmptyString(obj["name"])) {
+    throw new Error("meta.name must be a non-empty string");
+  }
+  if (!nonEmptyString(obj["description"])) {
+    throw new Error("meta.description must be a non-empty string");
+  }
+  const title = obj["title"];
+  if (title !== undefined && !nonEmptyString(title)) {
+    throw new Error("meta.title must be a non-empty string");
+  }
+  const phases = shapePhases(obj["phases"]);
+  return {
+    name: obj["name"],
+    description: obj["description"],
+    ...typeof title === "string" ? { title } : {},
+    ...typeof obj["whenToUse"] === "string" ? { whenToUse: obj["whenToUse"] } : {},
+    ...phases ? { phases } : {}
+  };
+};
+var parseWorkflowScript = (script) => {
+  if (script.length > MAX_SCRIPT_BYTES) {
+    throw new Error(`Script exceeds ${MAX_SCRIPT_BYTES} bytes`);
+  }
+  let program;
+  try {
+    program = acorn2.parse(script, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowAwaitOutsideFunction: true,
+      allowReturnOutsideFunction: true
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`${msg}. ${TS_HINT}`);
+  }
+  const first = program.body[0];
+  const META_FIRST_ERR = "`export const meta = { name, description, phases }` must be the FIRST statement in the script";
+  if (!first || first.type !== "ExportNamedDeclaration") {
+    throw new Error(META_FIRST_ERR);
+  }
+  const decl = first.declaration;
+  if (!decl || decl.type !== "VariableDeclaration" || decl.kind !== "const") {
+    throw new Error(META_FIRST_ERR);
+  }
+  const declarator = decl.declarations?.[0];
+  if (!declarator || declarator.id?.type !== "Identifier" || declarator.id.name !== "meta" || !declarator.init || declarator.init.type !== "ObjectExpression") {
+    throw new Error(META_FIRST_ERR);
+  }
+  let rawMeta;
+  try {
+    rawMeta = evalLiteral(declarator.init);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error("meta must be a pure literal: " + msg);
+  }
+  const meta = shapeMeta(rawMeta);
+  const metaEnd = first.end;
+  const scriptBody = script.slice(metaEnd).replace(/^[\s;]+/, "");
+  return { meta, scriptBody };
+};
+
+// src/server.ts
+var DETERMINISM_MESSAGE = "Workflow scripts must be deterministic: Date.now()/Math.random()/new Date() are unavailable (breaks resume). Stamp results after the workflow returns, or pass timestamps via args.";
+var textResult = (text, isError = false) => ({
+  content: [{ type: "text", text }],
+  ...isError ? { isError: true } : {}
+});
+var elapsedSeconds = (s) => Math.round(((s.endTime ?? Date.now()) - s.startTime) / 1000);
+var renderAgentLine = (a) => {
+  const marks = {
+    running: "[run ]",
+    done: "[done]",
+    error: "[fail]"
+  };
+  const cached = a.cached === true ? " (cached)" : "";
+  const tokens = a.tokens !== undefined && a.tokens > 0 ? ` ${(a.tokens / 1000).toFixed(1)}k tok` : "";
+  const tools = a.toolCalls !== undefined && a.toolCalls > 0 ? ` ${a.toolCalls} tools` : "";
+  const error = a.error !== undefined ? ` — ${a.error}` : "";
+  return `  ${marks[a.state]} #${a.index} ${a.label}${cached}${tokens}${tools}${error}`;
+};
+var renderRunStatus = (s) => {
+  const lines = [];
+  lines.push(`${s.name} (${s.runId}) — ${s.status}, ${s.agentCount} agent${s.agentCount === 1 ? "" : "s"}, ${elapsedSeconds(s)}s${s.tokensSpent > 0 ? `, ${Math.round(s.tokensSpent / 1000)}k output tokens` : ""}`);
+  lines.push(s.description);
+  const byPhase = new Map;
+  for (const agent of s.agents) {
+    const list = byPhase.get(agent.phaseTitle) ?? [];
+    byPhase.set(agent.phaseTitle, [...list, agent]);
+  }
+  for (const title of [...s.phases, undefined]) {
+    const agents = byPhase.get(title);
+    if (agents === undefined || agents.length === 0)
+      continue;
+    byPhase.delete(title);
+    lines.push(title !== undefined ? `
+${title}:` : `
+(no phase):`);
+    for (const agent of agents)
+      lines.push(renderAgentLine(agent));
+  }
+  for (const [title, agents] of byPhase) {
+    lines.push(title !== undefined ? `
+${title}:` : `
+(no phase):`);
+    for (const agent of agents)
+      lines.push(renderAgentLine(agent));
+  }
+  if (s.logs.length > 0) {
+    lines.push(`
+Recent log:`);
+    for (const message of s.logs.slice(-10))
+      lines.push(`  ${message}`);
+  }
+  if (s.failures.length > 0) {
+    lines.push(`
+Failures:`);
+    for (const failure of s.failures)
+      lines.push(`  ${failure}`);
+  }
+  if (s.status === "completed") {
+    const json = JSON.stringify(s.result ?? null, null, 2);
+    const capped = json.length > RESULT_TEXT_CAP ? json.slice(0, RESULT_TEXT_CAP) + `
+… [truncated — full result at ${resultPathFor(s.runDir)}]` : json;
+    lines.push(`
+Result:`);
+    lines.push(capped);
+  }
+  if (s.status === "failed" && s.error !== undefined) {
+    lines.push(`
+Error: ${s.error}`);
+  }
+  if (s.status === "failed" || s.status === "stopped") {
+    lines.push(`
+Resume with workflow({scriptPath: "${s.scriptPath}", resumeFromRunId: "${s.runId}"}) — completed agent() calls replay from cache.`);
+  }
+  if (s.status === "running") {
+    lines.push(`
+Still running. Poll workflow_status({runId: "${s.runId}"}) or workflow_wait({runId: "${s.runId}"}).`);
+  }
+  return lines.join(`
+`);
+};
+var createWorkflowMcpServer = (config) => {
+  const { host, registry } = config;
+  const server = new McpServer({
+    name: "openhorizon-workflows",
+    version: config.version
+  });
+  server.registerTool("workflow", {
+    title: "Launch workflow",
+    description: WORKFLOW_TOOL_DESCRIPTION,
+    inputSchema: {
+      script: z.string().max(MAX_SCRIPT_BYTES).optional().describe("Self-contained workflow script. Must begin with `export const meta = { name, description, phases }` (pure literal, no computed values) followed by the script body using agent()/parallel()/pipeline()/phase()."),
+      scriptPath: z.string().optional().describe("Path to a workflow script file on disk. Every invocation persists its script and returns the path in the tool result. To iterate, edit that file and re-invoke with the same `scriptPath` instead of re-sending the full script. Takes precedence over `script`."),
+      args: z.unknown().optional().describe("Optional input value exposed to the script as the global `args`, verbatim. Pass arrays/objects as actual JSON values, NOT as a JSON-encoded string — a stringified list breaks `args.filter`/`args.map` in the script."),
+      resumeFromRunId: z.string().regex(RUN_ID_RE).optional().describe("Run ID of a prior workflow invocation to resume from. Completed agent() calls with unchanged (prompt, opts) return their cached results instantly; only edited or new calls re-run. Stop a still-running run first (workflow_stop)."),
+      cwd: z.string().optional().describe("Working directory the subagents operate in. Defaults to the server's working directory."),
+      tokenBudget: z.number().int().positive().optional().describe("Output-token budget for this run (the script's `budget` global). Once spent() reaches this total, further agent() calls throw. Omit for no budget.")
+    }
+  }, (input) => {
+    let script;
+    if (input.scriptPath !== undefined) {
+      try {
+        script = readFileSync3(input.scriptPath, "utf8");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return textResult(`Could not read workflow scriptPath: ${msg}`, true);
+      }
+    } else if (input.script !== undefined) {
+      script = input.script;
+    } else {
+      return textResult("Must provide script or scriptPath", true);
+    }
+    if (input.script !== undefined && DETERMINISM_RE.test(input.script)) {
+      return textResult(DETERMINISM_MESSAGE, true);
+    }
+    let parsed;
+    try {
+      parsed = parseWorkflowScript(script);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return textResult(`Invalid workflow script: ${msg}`, true);
+    }
+    const compiled = compileScript(parsed.scriptBody);
+    if (!compiled.ok) {
+      return textResult(`Workflow script has a syntax error and was not launched:
+${compiled.error}`, true);
+    }
+    if (input.resumeFromRunId !== undefined && registry.isRunning(input.resumeFromRunId)) {
+      const taskId = registry.get(input.resumeFromRunId)?.taskId ?? "?";
+      return textResult(`Workflow ${input.resumeFromRunId} is still running (task ${taskId}). Stop it first with workflow_stop({runId: "${input.resumeFromRunId}"}) before resuming.`, true);
+    }
+    const runId = mintRunId(input.resumeFromRunId);
+    const runDir = runDirFor(runId);
+    ensureRunDir(runDir);
+    const persistedPath = scriptPathFor(runDir);
+    try {
+      writeFileSync3(persistedPath, script, "utf8");
+    } catch {}
+    const scriptPath = input.scriptPath ?? persistedPath;
+    const launchParams = {
+      parsed,
+      args: input.args,
+      cwd: input.cwd ?? config.cwd,
+      runId,
+      scriptPath,
+      ...input.resumeFromRunId !== undefined ? { resumeFromRunId: input.resumeFromRunId } : {},
+      tokenBudgetTotal: input.tokenBudget ?? null
+    };
+    const launched = host.launch(launchParams);
+    return textResult([
+      `Workflow launched in background. Task ID: ${launched.taskId}`,
+      `Summary: ${parsed.meta.description}`,
+      `Run dir: ${launched.runDir}`,
+      `Script file: ${scriptPath} (edit this file and re-invoke workflow with {scriptPath} to iterate)`,
+      `Run ID: ${launched.runId} (after a stop/failure/edit, resume with workflow({scriptPath, resumeFromRunId: "${launched.runId}"}) — unchanged agent() calls replay from cache)`,
+      ``,
+      `Poll workflow_status({runId: "${launched.runId}"}) for live progress, or workflow_wait({runId: "${launched.runId}"}) to block until it finishes.`
+    ].join(`
+`));
+  });
+  server.registerTool("workflow_status", {
+    title: "Workflow status",
+    description: "Progress snapshot of a workflow run: phases, per-agent states, recent log lines, failures, and (when finished) the script's return value. Without runId, lists all known runs.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      runId: z.string().optional().describe("The run to inspect. Omit to list all runs.")
+    }
+  }, (input) => {
+    if (input.runId === undefined) {
+      const runs = registry.list();
+      if (runs.length === 0)
+        return textResult("No workflow runs.");
+      const lines = [...runs].sort((a, b) => b.startTime - a.startTime).map((s) => `${s.runId}  ${s.status.padEnd(9)}  ${s.name} — ${s.agentCount} agent${s.agentCount === 1 ? "" : "s"}, ${elapsedSeconds(s)}s`);
+      return textResult(lines.join(`
+`));
+    }
+    const state = registry.get(input.runId);
+    if (state === undefined) {
+      return textResult(`No workflow run with run ID ${input.runId}.`, true);
+    }
+    return textResult(renderRunStatus(state));
+  });
+  server.registerTool("workflow_wait", {
+    title: "Wait for workflow",
+    description: "Block until the workflow reaches a terminal status (completed/failed/stopped) or the timeout elapses, then return the status snapshot. Capped per call to stay inside MCP client timeouts — if it returns while the run is still going, call it again.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      runId: z.string().describe("The run to wait for."),
+      timeoutSeconds: z.number().int().min(1).max(55).optional().describe("Max seconds to block (default 30, max 55).")
+    }
+  }, async (input) => {
+    const state = await registry.waitForTerminal(input.runId, (input.timeoutSeconds ?? 30) * 1000);
+    if (state === undefined) {
+      return textResult(`No workflow run with run ID ${input.runId}.`, true);
+    }
+    if (!isTerminal(state.status)) {
+      return textResult(`Workflow ${input.runId} is still running (${state.agentCount} agents so far, ${elapsedSeconds(state)}s elapsed). Call workflow_wait again.
+
+${renderRunStatus(state)}`);
+    }
+    return textResult(renderRunStatus(state));
+  });
+  server.registerTool("workflow_stop", {
+    title: "Stop workflow",
+    description: "Abort a running workflow. In-flight subagents are cancelled; completed agent() results stay in the journal, so the run can be resumed with workflow({scriptPath, resumeFromRunId}).",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      runId: z.string().describe("The run to stop.")
+    }
+  }, (input) => {
+    const stopped = registry.stop(input.runId);
+    return stopped ? textResult(`Workflow ${input.runId} stopped. Resume later with workflow({scriptPath, resumeFromRunId: "${input.runId}"}).`) : textResult(`No running workflow with run ID ${input.runId}.`, true);
+  });
+  return server;
+};
+
+// src/cli.ts
+var VERSION = "0.1.0";
+console.log = console.error.bind(console);
+console.info = console.error.bind(console);
+console.debug = console.error.bind(console);
+process.on("uncaughtException", (err) => {
+  console.error("[openhorizon-workflows] uncaught exception:", err);
+});
+process.on("unhandledRejection", (reason) => {
+  console.error("[openhorizon-workflows] unhandled rejection:", reason);
+});
+var main = async () => {
+  if (process.env["CURSOR_API_KEY"] === undefined) {
+    console.error("[openhorizon-workflows] CURSOR_API_KEY is not set — agent() calls will fail until it is provided.");
+  }
+  const registry = createRunRegistry();
+  const runner = makeCursorRunner({
+    ...process.env["CURSOR_API_KEY"] !== undefined ? { apiKey: process.env["CURSOR_API_KEY"] } : {},
+    defaultModel: DEFAULT_MODEL
+  });
+  const host = createWorkflowHost({
+    runner,
+    registry,
+    defaultModel: DEFAULT_MODEL
+  });
+  const server = createWorkflowMcpServer({
+    host,
+    registry,
+    cwd: process.cwd(),
+    version: VERSION
+  });
+  const shutdown = () => {
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  console.error(`[openhorizon-workflows] MCP server ready (model: ${DEFAULT_MODEL}, cwd: ${process.cwd()})`);
+};
+main().catch((err) => {
+  console.error("[openhorizon-workflows] fatal:", err);
+  process.exit(1);
+});