@tangle-network/agent-runtime 0.43.0 → 0.44.0

package/dist/workflow.js

@@ -0,0 +1,1779 @@
+import {
+  createSandboxForSpec,
+  describeSandboxPlacement,
+  extractLlmCallEvent,
+  runLoop
+} from "./chunk-S7JXV32P.js";
+import "./chunk-PY6NMZYX.js";
+import {
+  ValidationError
+} from "./chunk-SQSCRJ7U.js";
+import "./chunk-DGUM43GV.js";
+
+// src/workflow/agent-delegate.ts
+function createSandboxWorkflowAgentDelegate(options) {
+  return async (prompt, agentOptions, ctx) => {
+    if (!options.client || typeof options.client.create !== "function") {
+      throw new ValidationError("workflow sandbox agent: client.create is required");
+    }
+    const profile = resolveProfile(options.profile, prompt, agentOptions, ctx);
+    const agentRunName = agentOptions.label ?? profile.name ?? "workflow-agent";
+    const box = await createSandboxForSpec(
+      options.client,
+      {
+        profile,
+        name: agentRunName,
+        taskToPrompt: (value) => value,
+        sandboxOverrides: options.sandboxOverrides
+      },
+      ctx.signal
+    );
+    const placement = describeSandboxPlacement(options.client, box);
+    const stream = options.stream ?? "prompt";
+    const events = [];
+    const tokenUsage = { input: 0, output: 0 };
+    let costUsd = 0;
+    try {
+      const source = stream === "task" ? box.streamTask(prompt, {
+        ...resolveStreamOptions(options.taskOptions, prompt, agentOptions, ctx),
+        signal: ctx.signal
+      }) : box.streamPrompt(prompt, {
+        ...resolveStreamOptions(options.promptOptions, prompt, agentOptions, ctx),
+        signal: ctx.signal
+      });
+      for await (const event of source) {
+        events.push(event);
+        const llmCall = extractLlmCallEvent(event, agentRunName);
+        if (!llmCall) continue;
+        costUsd += llmCall.costUsd ?? 0;
+        tokenUsage.input += llmCall.tokensIn ?? 0;
+        tokenUsage.output += llmCall.tokensOut ?? 0;
+      }
+      const output = options.output ? options.output.parse(events) : parseSandboxAgentDefaultOutput(events);
+      const trace = {
+        prompt,
+        options: agentOptions,
+        ctx,
+        profile,
+        output,
+        events,
+        stream,
+        placement,
+        costUsd,
+        tokenUsage
+      };
+      return {
+        output,
+        costUsd,
+        tokenUsage,
+        trace: options.toTrace ? options.toTrace(trace) : defaultTrace(trace, options)
+      };
+    } finally {
+      if (options.deleteAfter) await box.delete();
+    }
+  };
+}
+function parseSandboxAgentDefaultOutput(events) {
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const event = events[i];
+    const data = asRecord(event?.data);
+    const text = firstString(data, ["finalText", "response", "text", "output", "content"]);
+    if (text !== void 0) return text;
+    if ("result" in data) return data.result;
+  }
+  throw new ValidationError(
+    "workflow sandbox agent emitted no parseable terminal output; pass an output adapter"
+  );
+}
+function resolveProfile(resolver, prompt, options, ctx) {
+  return typeof resolver === "function" ? resolver(prompt, options, ctx) : resolver;
+}
+function resolveStreamOptions(resolver, prompt, options, ctx) {
+  return typeof resolver === "function" ? resolver(prompt, options, ctx) : resolver;
+}
+function defaultTrace(trace, options) {
+  return {
+    stream: trace.stream,
+    placement: trace.placement.kind,
+    sandboxId: trace.placement.sandboxId,
+    fleetId: trace.placement.fleetId,
+    machineId: trace.placement.machineId,
+    profileName: trace.profile.name,
+    eventCount: trace.events.length,
+    eventTypes: trace.events.map((event) => String(event.type ?? "")),
+    ...options.includeEventsInTrace ? { events: trace.events } : {}
+  };
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function firstString(data, keys) {
+  for (const key of keys) {
+    const value = data[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+
+// src/workflow/budget.ts
+var WorkflowBudget = class {
+  total;
+  startedAt;
+  now;
+  costUsd = 0;
+  tokens = { input: 0, output: 0 };
+  agentCallCount = 0;
+  loopCallCount = 0;
+  constructor(total, now) {
+    this.total = total;
+    this.now = now;
+    this.startedAt = now();
+  }
+  spent() {
+    return {
+      costUsd: this.costUsd,
+      tokens: { ...this.tokens },
+      agentCalls: this.agentCallCount,
+      loopCalls: this.loopCallCount,
+      elapsedMs: this.elapsedMs()
+    };
+  }
+  remaining() {
+    const out = {};
+    if (this.total.maxCostUsd !== void 0) out.costUsd = this.total.maxCostUsd - this.costUsd;
+    if (this.total.maxTokens !== void 0) {
+      out.tokens = this.total.maxTokens - this.tokens.input - this.tokens.output;
+    }
+    if (this.total.maxAgentCalls !== void 0) {
+      out.agentCalls = this.total.maxAgentCalls - this.agentCallCount;
+    }
+    if (this.total.maxLoopCalls !== void 0) {
+      out.loopCalls = this.total.maxLoopCalls - this.loopCallCount;
+    }
+    if (this.total.maxWallMs !== void 0) out.wallMs = this.total.maxWallMs - this.elapsedMs();
+    return out;
+  }
+  nextAgentIndex() {
+    this.assertWall();
+    if (this.total.maxAgentCalls !== void 0 && this.agentCallCount >= this.total.maxAgentCalls) {
+      throw new ValidationError(
+        `workflow budget exhausted: maxAgentCalls=${this.total.maxAgentCalls}`
+      );
+    }
+    const index = this.agentCallCount;
+    this.agentCallCount += 1;
+    return index;
+  }
+  nextLoopIndex() {
+    this.assertWall();
+    if (this.total.maxLoopCalls !== void 0 && this.loopCallCount >= this.total.maxLoopCalls) {
+      throw new ValidationError(
+        `workflow budget exhausted: maxLoopCalls=${this.total.maxLoopCalls}`
+      );
+    }
+    const index = this.loopCallCount;
+    this.loopCallCount += 1;
+    return index;
+  }
+  assertFanout(count) {
+    if (!Number.isInteger(count) || count < 0) {
+      throw new ValidationError(
+        `workflow fanout count must be a non-negative integer, got ${count}`
+      );
+    }
+    if (this.total.maxFanout !== void 0 && count > this.total.maxFanout) {
+      throw new ValidationError(
+        `workflow fanout ${count} exceeds maxFanout=${this.total.maxFanout}`
+      );
+    }
+  }
+  observe(result) {
+    const costUsd = finiteNonNegative(result.costUsd ?? 0, "costUsd");
+    const tokenUsage = {
+      input: finiteNonNegative(result.tokenUsage?.input ?? 0, "tokenUsage.input"),
+      output: finiteNonNegative(result.tokenUsage?.output ?? 0, "tokenUsage.output")
+    };
+    const agentCalls = finiteNonNegativeInteger(result.agentCalls ?? 0, "agentCalls");
+    const loopCalls = finiteNonNegativeInteger(result.loopCalls ?? 0, "loopCalls");
+    this.costUsd += costUsd;
+    this.tokens.input += tokenUsage.input;
+    this.tokens.output += tokenUsage.output;
+    this.agentCallCount += agentCalls;
+    this.loopCallCount += loopCalls;
+    this.assertSpend();
+    return { costUsd, tokenUsage };
+  }
+  assertWall() {
+    if (this.total.maxWallMs !== void 0 && this.elapsedMs() > this.total.maxWallMs) {
+      throw new ValidationError(`workflow budget exhausted: maxWallMs=${this.total.maxWallMs}`);
+    }
+  }
+  remainingWallMs() {
+    if (this.total.maxWallMs === void 0) return void 0;
+    return Math.max(0, this.total.maxWallMs - this.elapsedMs());
+  }
+  elapsedMs() {
+    return Math.max(0, this.now() - this.startedAt);
+  }
+  assertSpend() {
+    if (this.total.maxCostUsd !== void 0 && this.costUsd > this.total.maxCostUsd) {
+      throw new ValidationError(`workflow budget exhausted: maxCostUsd=${this.total.maxCostUsd}`);
+    }
+    if (this.total.maxTokens !== void 0 && this.tokens.input + this.tokens.output > this.total.maxTokens) {
+      throw new ValidationError(`workflow budget exhausted: maxTokens=${this.total.maxTokens}`);
+    }
+  }
+};
+function finiteNonNegative(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new ValidationError(`workflow delegate returned invalid ${field}: ${value}`);
+  }
+  return value;
+}
+function finiteNonNegativeInteger(value, field) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new ValidationError(`workflow delegate returned invalid ${field}: ${value}`);
+  }
+  return value;
+}
+
+// src/workflow/loop-delegate.ts
+function createRunLoopWorkflowDelegate(options) {
+  return async (input, loopOptions, ctx) => {
+    const result = await runLoop(options.toRunLoopOptions(input, loopOptions, ctx));
+    return {
+      output: options.toOutput ? options.toOutput(result) : defaultOutput(result),
+      costUsd: result.costUsd,
+      tokenUsage: result.tokenUsage,
+      trace: options.toTrace ? options.toTrace(result) : defaultTrace2(result)
+    };
+  };
+}
+function defaultOutput(result) {
+  return result.winner?.output ?? {
+    decision: result.decision,
+    iterations: result.iterations.length
+  };
+}
+function defaultTrace2(result) {
+  return {
+    decision: result.decision,
+    iterations: result.iterations.length,
+    winnerIterationIndex: result.winner?.iterationIndex,
+    costUsd: result.costUsd,
+    tokenUsage: result.tokenUsage
+  };
+}
+
+// src/workflow/runtime.ts
+import { randomUUID } from "crypto";
+
+// src/workflow/schema.ts
+function validateJsonSchemaDefinition(schema, path = "$") {
+  const record = assertSchemaRecord(schema, path);
+  const type = record.type;
+  switch (type) {
+    case "string":
+      requireAllowedKeys(record, path, ["type", "minLength", "maxLength", "enum"]);
+      optionalNonNegativeNumber(record.minLength, `${path}.minLength`, { integer: true });
+      optionalNonNegativeNumber(record.maxLength, `${path}.maxLength`, { integer: true });
+      optionalEnum(record.enum, path, "string");
+      return;
+    case "number":
+    case "integer":
+      requireAllowedKeys(record, path, ["type", "minimum", "maximum", "enum"]);
+      optionalFiniteNumber(record.minimum, `${path}.minimum`);
+      optionalFiniteNumber(record.maximum, `${path}.maximum`);
+      optionalEnum(record.enum, path, type);
+      return;
+    case "boolean":
+      requireAllowedKeys(record, path, ["type", "enum"]);
+      optionalEnum(record.enum, path, "boolean");
+      return;
+    case "null":
+      requireAllowedKeys(record, path, ["type"]);
+      return;
+    case "array":
+      requireAllowedKeys(record, path, ["type", "items", "minItems", "maxItems"]);
+      optionalNonNegativeNumber(record.minItems, `${path}.minItems`, { integer: true });
+      optionalNonNegativeNumber(record.maxItems, `${path}.maxItems`, { integer: true });
+      if (record.items !== void 0) validateJsonSchemaDefinition(record.items, `${path}.items`);
+      return;
+    case "object": {
+      requireAllowedKeys(record, path, ["type", "properties", "required", "additionalProperties"]);
+      if (record.properties !== void 0) {
+        const properties = assertSchemaPlainRecord(record.properties, `${path}.properties`);
+        for (const [key, child] of Object.entries(properties)) {
+          validateJsonSchemaDefinition(child, `${path}.properties.${key}`);
+        }
+      }
+      if (record.required !== void 0) {
+        if (!Array.isArray(record.required)) {
+          throw new ValidationError(`${path}.required: expected string array`);
+        }
+        for (const [index, value] of record.required.entries()) {
+          if (typeof value !== "string" || value.length === 0) {
+            throw new ValidationError(`${path}.required[${index}]: expected non-empty string`);
+          }
+        }
+      }
+      if (record.additionalProperties !== void 0 && typeof record.additionalProperties !== "boolean") {
+        throw new ValidationError(`${path}.additionalProperties: expected boolean`);
+      }
+      return;
+    }
+    default:
+      throw new ValidationError(`${path}.type: expected supported JSON schema type`);
+  }
+}
+function validateJsonSchema(value, schema, path = "$") {
+  validateJsonSchemaDefinition(schema);
+  switch (schema.type) {
+    case "string":
+      assertType(typeof value === "string", path, "string");
+      if (schema.minLength !== void 0 && value.length < schema.minLength) {
+        throw new ValidationError(`${path}: expected string length >= ${schema.minLength}`);
+      }
+      if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+        throw new ValidationError(`${path}: expected string length <= ${schema.maxLength}`);
+      }
+      assertEnum(value, schema.enum, path);
+      return;
+    case "number":
+      assertType(typeof value === "number" && Number.isFinite(value), path, "number");
+      assertNumberBounds(value, schema.minimum, schema.maximum, path);
+      assertEnum(value, schema.enum, path);
+      return;
+    case "integer":
+      assertType(Number.isInteger(value), path, "integer");
+      assertNumberBounds(value, schema.minimum, schema.maximum, path);
+      assertEnum(value, schema.enum, path);
+      return;
+    case "boolean":
+      assertType(typeof value === "boolean", path, "boolean");
+      assertEnum(value, schema.enum, path);
+      return;
+    case "null":
+      assertType(value === null, path, "null");
+      return;
+    case "array":
+      assertType(Array.isArray(value), path, "array");
+      if (schema.minItems !== void 0 && value.length < schema.minItems) {
+        throw new ValidationError(`${path}: expected array length >= ${schema.minItems}`);
+      }
+      if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+        throw new ValidationError(`${path}: expected array length <= ${schema.maxItems}`);
+      }
+      if (schema.items) {
+        value.forEach((item, index) => {
+          validateJsonSchema(item, schema.items, `${path}[${index}]`);
+        });
+      }
+      return;
+    case "object":
+      assertPlainObject(value, path);
+      validateObject(value, schema, path);
+      return;
+  }
+}
+function validateObject(value, schema, path) {
+  for (const key of schema.required ?? []) {
+    if (!(key in value)) throw new ValidationError(`${path}: missing required property ${key}`);
+  }
+  const properties = schema.properties ?? {};
+  for (const [key, propSchema] of Object.entries(properties)) {
+    if (key in value) validateJsonSchema(value[key], propSchema, `${path}.${key}`);
+  }
+  if (schema.additionalProperties === false) {
+    for (const key of Object.keys(value)) {
+      if (!(key in properties)) throw new ValidationError(`${path}: unexpected property ${key}`);
+    }
+  }
+}
+function assertType(ok, path, expected) {
+  if (!ok) throw new ValidationError(`${path}: expected ${expected}`);
+}
+function assertPlainObject(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ValidationError(`${path}: expected object`);
+  }
+}
+function assertNumberBounds(value, minimum, maximum, path) {
+  if (minimum !== void 0 && value < minimum) {
+    throw new ValidationError(`${path}: expected number >= ${minimum}`);
+  }
+  if (maximum !== void 0 && value > maximum) {
+    throw new ValidationError(`${path}: expected number <= ${maximum}`);
+  }
+}
+function assertEnum(value, allowed, path) {
+  if (allowed && !allowed.includes(value)) {
+    throw new ValidationError(`${path}: expected one of ${allowed.map(String).join(", ")}`);
+  }
+}
+function assertSchemaRecord(value, path) {
+  const record = assertSchemaPlainRecord(value, path);
+  if (typeof record.type !== "string" || record.type.length === 0) {
+    throw new ValidationError(`${path}.type: expected non-empty string`);
+  }
+  return record;
+}
+function assertSchemaPlainRecord(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ValidationError(`${path}: expected object`);
+  }
+  return value;
+}
+function requireAllowedKeys(record, path, allowedKeys) {
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(record)) {
+    if (!allowed.has(key)) throw new ValidationError(`${path}.${key}: unsupported schema keyword`);
+  }
+}
+function optionalFiniteNumber(value, path) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new ValidationError(`${path}: expected finite number`);
+  }
+}
+function optionalNonNegativeNumber(value, path, options = {}) {
+  optionalFiniteNumber(value, path);
+  if (value === void 0) return;
+  if (value < 0) throw new ValidationError(`${path}: expected non-negative number`);
+  if (options.integer && !Number.isInteger(value)) {
+    throw new ValidationError(`${path}: expected integer`);
+  }
+}
+function optionalEnum(value, path, expected) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) throw new ValidationError(`${path}.enum: expected array`);
+  for (const [index, item] of value.entries()) {
+    const itemPath = `${path}.enum[${index}]`;
+    if (expected === "integer") {
+      if (!Number.isInteger(item)) throw new ValidationError(`${itemPath}: expected integer`);
+    } else if (expected === "number") {
+      if (typeof item !== "number" || !Number.isFinite(item)) {
+        throw new ValidationError(`${itemPath}: expected finite number`);
+      }
+    } else if (typeof item !== expected) {
+      throw new ValidationError(`${itemPath}: expected ${expected}`);
+    }
+  }
+}
+
+// src/workflow/options.ts
+function normalizeWorkflowAgentOptions(input) {
+  const record = normalizeOptionsRecord(input, "agent");
+  rejectUnknownOptionKeys(record, "agent", ["label", "metadata", "schema", "allowWorkflow"]);
+  const out = {};
+  const label = optionalStringOption(record.label, "agent.label");
+  if (label !== void 0) out.label = label;
+  const metadata = optionalJsonRecordOption(record.metadata, "agent.metadata");
+  if (metadata !== void 0) out.metadata = metadata;
+  const schema = optionalJsonSchemaOption(record.schema, "agent.schema");
+  if (schema !== void 0) out.schema = schema;
+  if (record.allowWorkflow !== void 0) {
+    if (typeof record.allowWorkflow !== "boolean") {
+      throw new ValidationError("agent.allowWorkflow: expected boolean");
+    }
+    out.allowWorkflow = record.allowWorkflow;
+  }
+  return out;
+}
+function normalizeWorkflowLoopOptions(input) {
+  const record = normalizeOptionsRecord(input, "loop");
+  rejectUnknownOptionKeys(record, "loop", ["label", "metadata", "schema"]);
+  return normalizeCheckpointLikeOptions(record, "loop");
+}
+function normalizeWorkflowCheckpointOptions(input, kind) {
+  const record = normalizeOptionsRecord(input, kind);
+  rejectUnknownOptionKeys(record, kind, ["label", "metadata", "schema"]);
+  return normalizeCheckpointLikeOptions(record, kind);
+}
+function normalizeCheckpointLikeOptions(record, kind) {
+  const out = {};
+  const label = optionalStringOption(record.label, `${kind}.label`);
+  if (label !== void 0) out.label = label;
+  const metadata = optionalJsonRecordOption(record.metadata, `${kind}.metadata`);
+  if (metadata !== void 0) out.metadata = metadata;
+  const schema = optionalJsonSchemaOption(record.schema, `${kind}.schema`);
+  if (schema !== void 0) out.schema = schema;
+  return out;
+}
+function cloneJsonRecord(value, path) {
+  const out = cloneJsonValue(value, path);
+  if (!out || typeof out !== "object" || Array.isArray(out)) {
+    throw new ValidationError(`${path}: expected object`);
+  }
+  return out;
+}
+function cloneJsonValue(value, path, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new ValidationError(`${path}: expected finite JSON number`);
+    return value;
+  }
+  if (value === void 0) {
+    throw new ValidationError(`${path}: expected JSON value, got undefined`);
+  }
+  if (typeof value !== "object") {
+    throw new ValidationError(`${path}: expected JSON value, got ${typeof value}`);
+  }
+  if (seen.has(value)) throw new ValidationError(`${path}: JSON value cannot contain cycles`);
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return cloneJsonArray(value, path, seen);
+    return clonePlainJsonObject(value, path, seen);
+  } finally {
+    seen.delete(value);
+  }
+}
+function cloneJsonArray(value, path, seen) {
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new ValidationError(`${path}: symbol properties are not JSON`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const out = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = descriptors[index];
+    if (!descriptor) throw new ValidationError(`${path}[${index}]: sparse arrays are not JSON`);
+    if (!("value" in descriptor)) {
+      throw new ValidationError(`${path}[${index}]: accessor properties are not allowed`);
+    }
+    out.push(cloneJsonValue(descriptor.value, `${path}[${index}]`, seen));
+  }
+  for (const key of Object.keys(descriptors)) {
+    if (!/^\d+$/.test(key) && key !== "length") {
+      throw new ValidationError(`${path}.${key}: array properties are not JSON`);
+    }
+  }
+  return out;
+}
+function clonePlainJsonObject(value, path, seen) {
+  if (Object.prototype.toString.call(value) !== "[object Object]") {
+    throw new ValidationError(`${path}: expected plain JSON object`);
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new ValidationError(`${path}: symbol properties are not JSON`);
+  }
+  const out = {};
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const [key, descriptor] of Object.entries(descriptors)) {
+    if (key === "__proto__" || key === "prototype" || key === "constructor") {
+      throw new ValidationError(`${path}.${key}: unsafe object key`);
+    }
+    if (!("value" in descriptor)) {
+      throw new ValidationError(`${path}.${key}: accessor properties are not allowed`);
+    }
+    out[key] = cloneJsonValue(descriptor.value, `${path}.${key}`, seen);
+  }
+  return out;
+}
+function normalizeOptionsRecord(input, kind) {
+  if (input === void 0) return {};
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new ValidationError(`${kind} options must be an object`);
+  }
+  return cloneJsonRecord(input, `${kind} options`);
+}
+function rejectUnknownOptionKeys(record, kind, allowedKeys) {
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(record)) {
+    if (!allowed.has(key)) throw new ValidationError(`${kind}.${key}: unsupported workflow option`);
+  }
+}
+function optionalStringOption(value, path) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ValidationError(`${path}: expected non-empty string`);
+  }
+  return value;
+}
+function optionalJsonRecordOption(value, path) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ValidationError(`${path}: expected object`);
+  }
+  return cloneJsonRecord(value, path);
+}
+function optionalJsonSchemaOption(value, path) {
+  if (value === void 0) return void 0;
+  const schema = cloneJsonValue(value, path);
+  validateJsonSchemaDefinition(schema, path);
+  return schema;
+}
+
+// src/workflow/realm.ts
+import vm from "vm";
+function installWorkflowGlobals(context, globals) {
+  const wrapAsync = async (run) => {
+    try {
+      return encodeBridgeSuccess(await run());
+    } catch (err) {
+      return encodeBridgeError(err);
+    }
+  };
+  const wrapSync = (run) => {
+    try {
+      return encodeBridgeSuccess(run());
+    } catch (err) {
+      return encodeBridgeError(err);
+    }
+  };
+  const install = vm.compileFunction(
+    `
+const __unwrap = (payload) => {
+  const envelope = JSON.parse(payload)
+  if (envelope.ok) return envelope.value
+  const error = new Error(envelope.error.message)
+  error.name = envelope.error.name || 'Error'
+  throw error
+}
+
+const __safeMath = Object.freeze({
+  abs: Math.abs,
+  ceil: Math.ceil,
+  floor: Math.floor,
+  max: Math.max,
+  min: Math.min,
+  pow: Math.pow,
+  round: Math.round,
+  sign: Math.sign,
+  sqrt: Math.sqrt,
+  trunc: Math.trunc,
+})
+
+Object.defineProperties(globalThis, {
+  agent: { value: async (...args) => __unwrap(await __agent(...args)), enumerable: true },
+  loop: { value: async (...args) => __unwrap(await __loop(...args)), enumerable: true },
+  verify: { value: async (...args) => __unwrap(await __verify(...args)), enumerable: true },
+  analyzeTrace: { value: async (...args) => __unwrap(await __analyzeTrace(...args)), enumerable: true },
+  review: { value: async (...args) => __unwrap(await __review(...args)), enumerable: true },
+  parallel: { value: async (...args) => __unwrap(await __parallel(...args)), enumerable: true },
+  pipeline: { value: async (...args) => __unwrap(await __pipeline(...args)), enumerable: true },
+  phase: { value: (...args) => __unwrap(__phase(...args)), enumerable: true },
+  log: { value: (...args) => __unwrap(__log(...args)), enumerable: true },
+  budget: {
+    value: Object.freeze({
+      get total() {
+        return __unwrap(__budgetTotal())
+      },
+      spent() {
+        return __unwrap(__budgetSpent())
+      },
+      remaining() {
+        return __unwrap(__budgetRemaining())
+      },
+    }),
+    enumerable: true,
+  },
+  Math: { value: __safeMath },
+  Date: { value: undefined },
+  Function: { value: undefined },
+  eval: { value: undefined },
+  fetch: { value: undefined },
+  XMLHttpRequest: { value: undefined },
+  WebSocket: { value: undefined },
+  WebAssembly: { value: undefined },
+  setTimeout: { value: undefined },
+  setInterval: { value: undefined },
+  setImmediate: { value: undefined },
+  queueMicrotask: { value: undefined },
+  process: { value: undefined },
+  require: { value: undefined },
+  module: { value: undefined },
+  exports: { value: undefined },
+  globalThis: { value: undefined },
+  window: { value: undefined },
+  document: { value: undefined },
+  self: { value: undefined },
+})
+`,
+    [
+      "__agent",
+      "__loop",
+      "__verify",
+      "__analyzeTrace",
+      "__review",
+      "__parallel",
+      "__pipeline",
+      "__phase",
+      "__log",
+      "__budgetTotal",
+      "__budgetSpent",
+      "__budgetRemaining"
+    ],
+    { parsingContext: context }
+  );
+  install(
+    (prompt, options) => wrapAsync(() => globals.agent(prompt, options)),
+    (input, options) => wrapAsync(() => globals.loop(input, options)),
+    (input, options) => wrapAsync(() => globals.verify(input, options)),
+    (input, options) => wrapAsync(() => globals.analyzeTrace(input, options)),
+    (input, options) => wrapAsync(() => globals.review(input, options)),
+    (thunks) => wrapAsync(() => globals.parallel(thunks)),
+    (items, ...stages) => wrapAsync(() => globals.pipeline(items, ...stages)),
+    (title) => wrapSync(() => globals.phase(title)),
+    (message) => wrapSync(() => globals.log(message)),
+    () => wrapSync(() => finiteCaps(globals.budget.total)),
+    () => wrapSync(() => globals.budget.spent()),
+    () => wrapSync(() => finiteRemaining(globals.budget.remaining()))
+  );
+}
+function normalizeRuntimeError(err) {
+  if (err instanceof Error) return err;
+  const message = errorMessage(err);
+  const name = errorName(err);
+  if (name === "ValidationError") return new ValidationError(message, { cause: err });
+  const out = new Error(message, { cause: err });
+  if (name) out.name = name;
+  return out;
+}
+function encodeBridgeSuccess(value) {
+  return JSON.stringify({ ok: true, value: toBridgeValue(value) });
+}
+function encodeBridgeError(err) {
+  return JSON.stringify({
+    ok: false,
+    error: {
+      name: errorName(err),
+      message: errorMessage(err)
+    }
+  });
+}
+function toBridgeValue(value, path = "$", seen = /* @__PURE__ */ new Set()) {
+  if (value === void 0) return void 0;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new ValidationError(`workflow bridge cannot return non-finite number at ${path}`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new ValidationError(`workflow bridge cannot return cycle at ${path}`);
+    seen.add(value);
+    const out = value.map((item, index) => toBridgeValue(item, `${path}[${index}]`, seen));
+    seen.delete(value);
+    return out;
+  }
+  if (typeof value === "object") {
+    if (Object.prototype.toString.call(value) !== "[object Object]") {
+      throw new ValidationError(`workflow bridge cannot return non-plain object at ${path}`);
+    }
+    if (seen.has(value)) throw new ValidationError(`workflow bridge cannot return cycle at ${path}`);
+    seen.add(value);
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (child === void 0) continue;
+      out[key] = toBridgeValue(child, `${path}.${key}`, seen);
+    }
+    seen.delete(value);
+    return out;
+  }
+  throw new ValidationError(`workflow bridge cannot return ${typeof value} at ${path}`);
+}
+function finiteCaps(caps) {
+  return finiteNumberRecord(caps);
+}
+function finiteRemaining(remaining) {
+  return finiteNumberRecord(remaining);
+}
+function finiteNumberRecord(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "number" && Number.isFinite(value)) out[key] = value;
+  }
+  return out;
+}
+function errorMessage(err) {
+  if (err && typeof err === "object" && "message" in err) {
+    const message = err.message;
+    if (typeof message === "string") return message;
+  }
+  return String(err);
+}
+function errorName(err) {
+  if (err && typeof err === "object" && "name" in err) {
+    const name = err.name;
+    if (typeof name === "string") return name;
+  }
+  return void 0;
+}
+
+// src/workflow/runtime-support.ts
+import vm2 from "vm";
+var DEFAULT_CAPS = {
+  maxCostUsd: Number.POSITIVE_INFINITY,
+  maxTokens: Number.POSITIVE_INFINITY,
+  maxWallMs: 10 * 6e4,
+  maxAgentCalls: 32,
+  maxLoopCalls: 16,
+  maxFanout: 8,
+  maxDepth: 1
+};
+async function runWorkflowBody(body, workflowName, globals, syncTimeoutMs = 1e3) {
+  const context = vm2.createContext(/* @__PURE__ */ Object.create(null), {
+    name: `workflow:${workflowName}`,
+    codeGeneration: { strings: false, wasm: false }
+  });
+  installWorkflowGlobals(context, globals);
+  const script = new vm2.Script(
+    `
+'use strict'
+const __workflowMain = async () => {
+${body}
+}
+__workflowMain()
+`,
+    { filename: `${workflowName}.workflow.js` }
+  );
+  return script.runInContext(context, { timeout: syncTimeoutMs });
+}
+function decodeWorkflowDelegateResult(result, options) {
+  if (options.schema) validateJsonSchema(result.output, options.schema);
+  return options.decode ? options.decode(result.output) : result.output;
+}
+function normalizeWorkflowCaps(caps = {}) {
+  return {
+    maxCostUsd: normalizeCap(caps.maxCostUsd, DEFAULT_CAPS.maxCostUsd, "maxCostUsd"),
+    maxTokens: normalizeCap(caps.maxTokens, DEFAULT_CAPS.maxTokens, "maxTokens"),
+    maxWallMs: normalizeCap(caps.maxWallMs, DEFAULT_CAPS.maxWallMs, "maxWallMs"),
+    maxAgentCalls: normalizeCap(caps.maxAgentCalls, DEFAULT_CAPS.maxAgentCalls, "maxAgentCalls", {
+      integer: true
+    }),
+    maxLoopCalls: normalizeCap(caps.maxLoopCalls, DEFAULT_CAPS.maxLoopCalls, "maxLoopCalls", {
+      integer: true
+    }),
+    maxFanout: normalizeCap(caps.maxFanout, DEFAULT_CAPS.maxFanout, "maxFanout", {
+      integer: true
+    }),
+    maxDepth: normalizeCap(caps.maxDepth, DEFAULT_CAPS.maxDepth, "maxDepth", { integer: true })
+  };
+}
+async function waitForWorkflowBudget(run, budget, signal, abortWorkflow, scope = "delegate") {
+  budget.assertWall();
+  const wallMs = budget.remainingWallMs();
+  if (signal?.aborted) throw new ValidationError(`workflow aborted before ${scope} completed`);
+  if (wallMs !== void 0 && wallMs <= 0) {
+    throw new ValidationError("workflow budget exhausted: maxWallMs reached");
+  }
+  const promise = run();
+  if (wallMs === void 0 || !Number.isFinite(wallMs)) return promise;
+  let timeout;
+  let abort;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(new ValidationError(`workflow ${scope} timed out`));
+          abortWorkflow?.();
+        }, wallMs);
+        abort = () => reject(new ValidationError(`workflow aborted before ${scope} completed`));
+        signal?.addEventListener("abort", abort, { once: true });
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    if (abort) signal?.removeEventListener("abort", abort);
+  }
+}
+function createWorkflowSignal(external) {
+  const controller = new AbortController();
+  const abort = () => {
+    if (!controller.signal.aborted) controller.abort();
+  };
+  if (external) {
+    if (external.aborted) {
+      abort();
+    } else {
+      external.addEventListener("abort", abort, { once: true });
+    }
+  }
+  return {
+    signal: controller.signal,
+    abort,
+    cleanup: () => external?.removeEventListener("abort", abort)
+  };
+}
+function checkpointStartedKind(kind) {
+  switch (kind) {
+    case "verifier":
+      return "workflow.verifier.started";
+    case "analyst":
+      return "workflow.analyst.started";
+    case "reviewer":
+      return "workflow.reviewer.started";
+  }
+}
+function checkpointEndedKind(kind) {
+  switch (kind) {
+    case "verifier":
+      return "workflow.verifier.ended";
+    case "analyst":
+      return "workflow.analyst.ended";
+    case "reviewer":
+      return "workflow.reviewer.ended";
+  }
+}
+function checkpointFailedKind(kind) {
+  switch (kind) {
+    case "verifier":
+      return "workflow.verifier.failed";
+    case "analyst":
+      return "workflow.analyst.failed";
+    case "reviewer":
+      return "workflow.reviewer.failed";
+  }
+}
+function assertWorkflowString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ValidationError(`workflow ${name} must be a non-empty string`);
+  }
+}
+function isRejected(settled) {
+  return settled.status === "rejected";
+}
+function fulfilledValues(settled) {
+  return settled.map((item) => item.value);
+}
+function normalizeCap(value, fallback, field, options = {}) {
+  const cap = value ?? fallback;
+  if (typeof cap !== "number" || Number.isNaN(cap) || cap < 0) {
+    throw new ValidationError(`workflow caps.${field} must be a non-negative number`);
+  }
+  if (options.integer && Number.isFinite(cap) && !Number.isInteger(cap)) {
+    throw new ValidationError(`workflow caps.${field} must be an integer`);
+  }
+  return cap;
+}
+
+// src/workflow/validate.ts
+import vm3 from "vm";
+var FORBIDDEN_BODY_PATTERNS = [
+  [/\bimport\b/, "import"],
+  [/\bexport\b/, "export"],
+  [/\brequire\b/, "require"],
+  [/\bprocess\b/, "process"],
+  [/\bDate\b/, "Date"],
+  [/\bFunction\b/, "Function"],
+  [/\beval\b/, "eval"],
+  [/\bfetch\b/, "fetch"],
+  [/\bXMLHttpRequest\b/, "XMLHttpRequest"],
+  [/\bWebSocket\b/, "WebSocket"],
+  [/\bsetTimeout\b/, "setTimeout"],
+  [/\bsetInterval\b/, "setInterval"],
+  [/\bsetImmediate\b/, "setImmediate"],
+  [/\bqueueMicrotask\b/, "queueMicrotask"],
+  [/\bglobalThis\b/, "globalThis"],
+  [/\bwindow\b/, "window"],
+  [/\bdocument\b/, "document"],
+  [/\bself\b/, "self"],
+  [/\bconstructor\b/, "constructor"],
+  [/\bprototype\b/, "prototype"],
+  [/\b__proto__\b/, "__proto__"],
+  [/\bmodule\b/, "module"],
+  [/\bexports\b/, "exports"],
+  [/\bwhile\b/, "while"],
+  [/\bdo\b/, "do"],
+  [/\bfor\s*\(/, "for-loop"],
+  [/\bMath\s*\.\s*random\b/, "Math.random"]
+];
+var FORBIDDEN_META_PATTERNS = [
+  [/\(/, "call expression"],
+  [/\bfunction\b/, "function"],
+  [/=>/, "arrow function"],
+  [/\bnew\b/, "new"],
+  [/\bclass\b/, "class"],
+  [/\.\.\./, "spread"],
+  [/`/, "template literal"],
+  [/\bconstructor\b/, "constructor"],
+  [/\bprototype\b/, "prototype"],
+  [/\b__proto__\b/, "__proto__"]
+];
+function parseWorkflowScript(source) {
+  if (typeof source !== "string" || source.trim().length === 0) {
+    throw new ValidationError("workflow source must be a non-empty string");
+  }
+  const marker = /^\s*export\s+const\s+meta\s*=\s*/.exec(source);
+  if (!marker) {
+    throw new ValidationError("workflow source must start with `export const meta = { ... }`");
+  }
+  const literalStart = marker[0].length;
+  const literalEnd = findObjectLiteralEnd(source, literalStart);
+  const literal = source.slice(literalStart, literalEnd);
+  const restStart = consumeOptionalSemicolon(source, literalEnd);
+  const body = source.slice(restStart).trim();
+  const meta = evaluateMetaLiteral(literal);
+  validateWorkflowBody(body);
+  return { meta, body };
+}
+function validateWorkflowBody(body) {
+  if (body.length === 0) {
+    throw new ValidationError("workflow body must not be empty");
+  }
+  if (body.includes("`")) {
+    throw new ValidationError("workflow body cannot use template literals");
+  }
+  const stripped = stripStringsAndComments(body);
+  for (const [pattern, label] of FORBIDDEN_BODY_PATTERNS) {
+    if (pattern.test(stripped)) {
+      throw new ValidationError(`workflow body uses forbidden capability: ${label}`);
+    }
+  }
+}
+function findObjectLiteralEnd(source, start) {
+  let i = start;
+  while (/\s/.test(source[i] ?? "")) i += 1;
+  if (source[i] !== "{") {
+    throw new ValidationError("workflow meta must be an object literal");
+  }
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (; i < source.length; i += 1) {
+    const ch = source[i];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "`") throw new ValidationError("workflow meta cannot use template literals");
+    if (ch === "{" || ch === "[") depth += 1;
+    if (ch === "}" || ch === "]") {
+      depth -= 1;
+      if (depth === 0) return i + 1;
+    }
+  }
+  throw new ValidationError("workflow meta object literal is not closed");
+}
+function consumeOptionalSemicolon(source, start) {
+  let i = start;
+  while (/\s/.test(source[i] ?? "")) i += 1;
+  if (source[i] === ";") return i + 1;
+  return i;
+}
+function evaluateMetaLiteral(literal) {
+  for (const [pattern, label] of FORBIDDEN_META_PATTERNS) {
+    if (pattern.test(literal)) {
+      throw new ValidationError(`workflow meta uses forbidden syntax: ${label}`);
+    }
+  }
+  let value;
+  try {
+    value = new vm3.Script(`(${literal})`).runInNewContext(/* @__PURE__ */ Object.create(null), {
+      timeout: 50,
+      contextCodeGeneration: { strings: false, wasm: false }
+    });
+  } catch (err) {
+    throw new ValidationError(
+      `workflow meta is not a parseable object literal: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ValidationError("workflow meta must evaluate to an object");
+  }
+  const raw = value;
+  if (typeof raw.name !== "string" || raw.name.trim().length === 0) {
+    throw new ValidationError("workflow meta.name must be a non-empty string");
+  }
+  if (typeof raw.description !== "string" || raw.description.trim().length === 0) {
+    throw new ValidationError("workflow meta.description must be a non-empty string");
+  }
+  const out = {
+    name: raw.name,
+    description: raw.description
+  };
+  if (raw.phases !== void 0) {
+    if (!Array.isArray(raw.phases))
+      throw new ValidationError("workflow meta.phases must be an array");
+    out.phases = raw.phases.map((phase, index) => {
+      if (!phase || typeof phase !== "object" || Array.isArray(phase)) {
+        throw new ValidationError(`workflow meta.phases[${index}] must be an object`);
+      }
+      const title = phase.title;
+      if (typeof title !== "string" || title.trim().length === 0) {
+        throw new ValidationError(`workflow meta.phases[${index}].title must be a non-empty string`);
+      }
+      return { title };
+    });
+  }
+  return out;
+}
+function stripStringsAndComments(source) {
+  let out = "";
+  let quote;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let i = 0; i < source.length; i += 1) {
+    const ch = source[i];
+    const next = source[i + 1];
+    if (lineComment) {
+      if (ch === "\n") {
+        lineComment = false;
+        out += "\n";
+      } else {
+        out += " ";
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (ch === "*" && next === "/") {
+        blockComment = false;
+        out += "  ";
+        i += 1;
+      } else {
+        out += ch === "\n" ? "\n" : " ";
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = void 0;
+      }
+      out += ch === "\n" ? "\n" : " ";
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      lineComment = true;
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      blockComment = true;
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      out += " ";
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+// src/workflow/runtime.ts
+async function runWorkflow(options) {
+  const parsed = parseWorkflowScript(options.source);
+  const runId = options.runId ?? `workflow-${randomUUID()}`;
+  const depth = options.depth ?? 0;
+  const caps = normalizeWorkflowCaps(options.caps);
+  if (depth > caps.maxDepth) {
+    throw new ValidationError(`workflow depth ${depth} exceeds maxDepth=${caps.maxDepth}`);
+  }
+  const now = options.now ?? Date.now;
+  const budget = new WorkflowBudget(caps, now);
+  const workflowSignal = createWorkflowSignal(options.signal);
+  const events = [];
+  const startedAt = now();
+  let currentPhase;
+  const checkpointCounts = {
+    verifier: 0,
+    analyst: 0,
+    reviewer: 0
+  };
+  const emit = async (event) => {
+    events.push(event);
+    await options.traceEmitter?.emit(event);
+  };
+  const delegateCtx = () => ({
+    workflowRunId: runId,
+    depth,
+    phase: currentPhase,
+    signal: workflowSignal.signal,
+    caps,
+    budget,
+    metadata: options.metadata
+  });
+  const emitNow = (event) => ({
+    ...event,
+    runId,
+    timestamp: now()
+  });
+  const emitDelegateFailure = async (kind, args) => {
+    const normalized = normalizeRuntimeError(args.err);
+    await emit(
+      emitNow({
+        kind,
+        payload: {
+          index: args.index,
+          label: args.label,
+          durationMs: now() - args.startedAt,
+          message: normalized.message,
+          code: normalized.name,
+          phase: currentPhase
+        }
+      })
+    );
+    throw normalized;
+  };
+  const globals = {
+    budget,
+    phase(title) {
+      assertWorkflowString(title, "phase title");
+      currentPhase = title;
+      void emit(emitNow({ kind: "workflow.phase", payload: { title } }));
+    },
+    log(message) {
+      assertWorkflowString(message, "log message");
+      void emit(emitNow({ kind: "workflow.log", payload: { message, phase: currentPhase } }));
+    },
+    async parallel(thunks) {
+      if (!Array.isArray(thunks)) throw new ValidationError("parallel() expects an array");
+      budget.assertFanout(thunks.length);
+      thunks.forEach((thunk, index) => {
+        if (typeof thunk !== "function") {
+          throw new ValidationError(`parallel() branch ${index} is not a function`);
+        }
+      });
+      const opStarted = now();
+      const operationPhase = currentPhase;
+      await emit(
+        emitNow({
+          kind: "workflow.parallel.started",
+          payload: { branchCount: thunks.length, phase: operationPhase }
+        })
+      );
+      let firstFailure;
+      const settled = await Promise.allSettled(
+        thunks.map(async (thunk, index) => {
+          const branchStarted = now();
+          await emit(
+            emitNow({
+              kind: "workflow.branch.started",
+              payload: { operation: "parallel", branchIndex: index, phase: operationPhase }
+            })
+          );
+          try {
+            const value = await thunk();
+            await emit(
+              emitNow({
+                kind: "workflow.branch.ended",
+                payload: {
+                  operation: "parallel",
+                  branchIndex: index,
+                  durationMs: now() - branchStarted,
+                  phase: operationPhase
+                }
+              })
+            );
+            return value;
+          } catch (err) {
+            const normalized = normalizeRuntimeError(err);
+            firstFailure ??= normalized;
+            workflowSignal.abort();
+            await emit(
+              emitNow({
+                kind: "workflow.branch.failed",
+                payload: {
+                  operation: "parallel",
+                  branchIndex: index,
+                  durationMs: now() - branchStarted,
+                  message: normalized.message,
+                  code: normalized.name,
+                  phase: operationPhase
+                }
+              })
+            );
+            throw normalized;
+          }
+        })
+      );
+      const rejected = settled.find(isRejected);
+      if (rejected) throw firstFailure ?? normalizeRuntimeError(rejected.reason);
+      await emit(
+        emitNow({
+          kind: "workflow.parallel.ended",
+          payload: {
+            branchCount: thunks.length,
+            durationMs: now() - opStarted,
+            phase: currentPhase
+          }
+        })
+      );
+      return fulfilledValues(settled);
+    },
+    async pipeline(items, ...stages) {
+      if (!Array.isArray(items)) throw new ValidationError("pipeline() expects an item array");
+      budget.assertFanout(items.length);
+      if (stages.length === 0) throw new ValidationError("pipeline() expects at least one stage");
+      stages.forEach((stage, index) => {
+        if (typeof stage !== "function") {
+          throw new ValidationError(`pipeline() stage ${index} is not a function`);
+        }
+      });
+      const opStarted = now();
+      const operationPhase = currentPhase;
+      await emit(
+        emitNow({
+          kind: "workflow.pipeline.started",
+          payload: { itemCount: items.length, stageCount: stages.length, phase: operationPhase }
+        })
+      );
+      let firstFailure;
+      const settled = await Promise.allSettled(
+        items.map(async (item, index) => {
+          const branchStarted = now();
+          await emit(
+            emitNow({
+              kind: "workflow.branch.started",
+              payload: {
+                operation: "pipeline",
+                branchIndex: index,
+                stageCount: stages.length,
+                phase: operationPhase
+              }
+            })
+          );
+          let stageIndex = -1;
+          try {
+            let value = item;
+            for (const stage of stages) {
+              stageIndex += 1;
+              value = await stage(value, item, index);
+            }
+            await emit(
+              emitNow({
+                kind: "workflow.branch.ended",
+                payload: {
+                  operation: "pipeline",
+                  branchIndex: index,
+                  durationMs: now() - branchStarted,
+                  stageCount: stages.length,
+                  phase: operationPhase
+                }
+              })
+            );
+            return value;
+          } catch (err) {
+            const normalized = normalizeRuntimeError(err);
+            firstFailure ??= normalized;
+            workflowSignal.abort();
+            await emit(
+              emitNow({
+                kind: "workflow.branch.failed",
+                payload: {
+                  operation: "pipeline",
+                  branchIndex: index,
+                  durationMs: now() - branchStarted,
+                  message: normalized.message,
+                  code: normalized.name,
+                  phase: operationPhase,
+                  ...stageIndex >= 0 ? { stageIndex } : {}
+                }
+              })
+            );
+            throw normalized;
+          }
+        })
+      );
+      const rejected = settled.find(isRejected);
+      if (rejected) throw firstFailure ?? normalizeRuntimeError(rejected.reason);
+      await emit(
+        emitNow({
+          kind: "workflow.pipeline.ended",
+          payload: {
+            itemCount: items.length,
+            stageCount: stages.length,
+            durationMs: now() - opStarted,
+            phase: currentPhase
+          }
+        })
+      );
+      return fulfilledValues(settled);
+    },
+    async agent(prompt, rawAgentOptions) {
+      assertWorkflowString(prompt, "agent prompt");
+      const agentOptions = normalizeWorkflowAgentOptions(rawAgentOptions);
+      const index = budget.nextAgentIndex();
+      const label = agentOptions.label;
+      const opStarted = now();
+      await emit(
+        emitNow({
+          kind: "workflow.agent.started",
+          payload: {
+            index,
+            label,
+            promptChars: prompt.length,
+            phase: currentPhase,
+            metadata: agentOptions.metadata
+          }
+        })
+      );
+      try {
+        const result = await waitForWorkflowBudget(
+          () => options.agent(prompt, agentOptions, delegateCtx()),
+          budget,
+          workflowSignal.signal,
+          workflowSignal.abort
+        );
+        const output = decodeWorkflowDelegateResult(result, agentOptions);
+        const usage = budget.observe(result);
+        await emit(
+          emitNow({
+            kind: "workflow.agent.ended",
+            payload: {
+              index,
+              label,
+              durationMs: now() - opStarted,
+              costUsd: usage.costUsd,
+              tokenUsage: usage.tokenUsage,
+              phase: currentPhase,
+              trace: result.trace
+            }
+          })
+        );
+        return output;
+      } catch (err) {
+        return emitDelegateFailure("workflow.agent.failed", {
+          err,
+          index,
+          label,
+          startedAt: opStarted
+        });
+      }
+    },
+    async loop(input, rawLoopOptions) {
+      if (!options.loop) throw new ValidationError("workflow loop() delegate is not configured");
+      const loopOptions = normalizeWorkflowLoopOptions(rawLoopOptions);
+      const index = budget.nextLoopIndex();
+      const label = loopOptions.label;
+      const opStarted = now();
+      await emit(
+        emitNow({
+          kind: "workflow.loop.started",
+          payload: {
+            index,
+            label,
+            phase: currentPhase,
+            metadata: loopOptions.metadata
+          }
+        })
+      );
+      try {
+        const result = await waitForWorkflowBudget(
+          () => options.loop(input, loopOptions, delegateCtx()),
+          budget,
+          workflowSignal.signal,
+          workflowSignal.abort
+        );
+        const output = decodeWorkflowDelegateResult(result, loopOptions);
+        const usage = budget.observe(result);
+        await emit(
+          emitNow({
+            kind: "workflow.loop.ended",
+            payload: {
+              index,
+              label,
+              durationMs: now() - opStarted,
+              costUsd: usage.costUsd,
+              tokenUsage: usage.tokenUsage,
+              phase: currentPhase,
+              trace: result.trace
+            }
+          })
+        );
+        return output;
+      } catch (err) {
+        return emitDelegateFailure("workflow.loop.failed", {
+          err,
+          index,
+          label,
+          startedAt: opStarted
+        });
+      }
+    },
+    verify(input, rawVerifierOptions) {
+      if (!options.verifier) {
+        throw new ValidationError("workflow verify() delegate is not configured");
+      }
+      const verifierOptions = normalizeWorkflowCheckpointOptions(rawVerifierOptions, "verify");
+      return runCheckpoint({
+        kind: "verifier",
+        input,
+        checkpointOptions: verifierOptions,
+        delegate: options.verifier
+      });
+    },
+    analyzeTrace(input, rawAnalystOptions) {
+      if (!options.analyst) {
+        throw new ValidationError("workflow analyzeTrace() delegate is not configured");
+      }
+      const analystOptions = normalizeWorkflowCheckpointOptions(rawAnalystOptions, "analyzeTrace");
+      return runCheckpoint({
+        kind: "analyst",
+        input,
+        checkpointOptions: analystOptions,
+        delegate: options.analyst
+      });
+    },
+    review(input, rawReviewerOptions) {
+      if (!options.reviewer) {
+        throw new ValidationError("workflow review() delegate is not configured");
+      }
+      const reviewerOptions = normalizeWorkflowCheckpointOptions(rawReviewerOptions, "review");
+      return runCheckpoint({
+        kind: "reviewer",
+        input,
+        checkpointOptions: reviewerOptions,
+        delegate: options.reviewer
+      });
+    }
+  };
+  async function runCheckpoint(args) {
+    const index = checkpointCounts[args.kind];
+    checkpointCounts[args.kind] += 1;
+    const label = args.checkpointOptions.label;
+    const opStarted = now();
+    await emit(
+      emitNow({
+        kind: checkpointStartedKind(args.kind),
+        payload: {
+          index,
+          label,
+          phase: currentPhase,
+          metadata: args.checkpointOptions.metadata
+        }
+      })
+    );
+    try {
+      const result = await waitForWorkflowBudget(
+        () => args.delegate(args.input, args.checkpointOptions, delegateCtx()),
+        budget,
+        workflowSignal.signal,
+        workflowSignal.abort
+      );
+      const output = decodeWorkflowDelegateResult(result, args.checkpointOptions);
+      const usage = budget.observe(result);
+      await emit(
+        emitNow({
+          kind: checkpointEndedKind(args.kind),
+          payload: {
+            index,
+            label,
+            durationMs: now() - opStarted,
+            costUsd: usage.costUsd,
+            tokenUsage: usage.tokenUsage,
+            phase: currentPhase,
+            trace: result.trace
+          }
+        })
+      );
+      return output;
+    } catch (err) {
+      return emitDelegateFailure(checkpointFailedKind(args.kind), {
+        err,
+        index,
+        label,
+        startedAt: opStarted
+      });
+    }
+  }
+  await emit(emitNow({ kind: "workflow.started", payload: { meta: parsed.meta, depth, caps } }));
+  try {
+    const output = await waitForWorkflowBudget(
+      () => runWorkflowBody(parsed.body, parsed.meta.name, globals, options.syncTimeoutMs),
+      budget,
+      options.signal,
+      workflowSignal.abort,
+      "body"
+    );
+    const spent = budget.spent();
+    const result = {
+      runId,
+      meta: parsed.meta,
+      output,
+      events,
+      durationMs: now() - startedAt,
+      costUsd: spent.costUsd,
+      tokenUsage: spent.tokens,
+      agentCalls: spent.agentCalls,
+      loopCalls: spent.loopCalls
+    };
+    await emit(
+      emitNow({
+        kind: "workflow.ended",
+        payload: {
+          durationMs: result.durationMs,
+          costUsd: result.costUsd,
+          tokenUsage: result.tokenUsage,
+          agentCalls: result.agentCalls,
+          loopCalls: result.loopCalls
+        }
+      })
+    );
+    return { ...result, events };
+  } catch (err) {
+    const normalized = normalizeRuntimeError(err);
+    workflowSignal.abort();
+    await emit(
+      emitNow({
+        kind: "workflow.failed",
+        payload: {
+          message: normalized.message,
+          code: normalized.name,
+          phase: currentPhase
+        }
+      })
+    );
+    throw normalized;
+  } finally {
+    workflowSignal.cleanup();
+  }
+}
+
+// src/workflow/nested-workflow-delegate.ts
+function createNestedWorkflowAgentDelegate(options) {
+  if (!options.agent) {
+    throw new ValidationError("nested workflow delegate: base agent delegate is required");
+  }
+  const delegate = async (prompt, agentOptions, ctx) => {
+    if (!agentOptions.allowWorkflow) return options.agent(prompt, agentOptions, ctx);
+    assertNestedDepth(ctx);
+    const input = {
+      source: prompt,
+      options: agentOptions,
+      parent: ctx
+    };
+    const caps = boundNestedCaps(resolveNestedCaps(options.caps, input), ctx);
+    const metadata = resolveMetadata(options.metadata, input);
+    const result = await runWorkflow({
+      source: prompt,
+      runId: options.runId?.(input),
+      depth: ctx.depth + 1,
+      caps,
+      metadata: {
+        parentWorkflowRunId: ctx.workflowRunId,
+        parentPhase: ctx.phase,
+        parentAgentLabel: agentOptions.label,
+        ...ctx.metadata ?? {},
+        ...metadata ?? {}
+      },
+      signal: ctx.signal,
+      agent: delegate,
+      loop: options.loop,
+      verifier: options.verifier,
+      analyst: options.analyst,
+      reviewer: options.reviewer,
+      traceEmitter: options.traceEmitter
+    });
+    return {
+      output: options.toOutput ? options.toOutput(result, input) : result.output,
+      costUsd: result.costUsd,
+      tokenUsage: result.tokenUsage,
+      agentCalls: result.agentCalls,
+      loopCalls: result.loopCalls,
+      trace: options.toTrace ? options.toTrace(result, input) : defaultTrace3(result, input, options)
+    };
+  };
+  return delegate;
+}
+function resolveNestedCaps(resolver, input) {
+  const caps = typeof resolver === "function" ? resolver(input) : resolver;
+  if (!caps || typeof caps !== "object") {
+    throw new ValidationError("nested workflow caps must be an object");
+  }
+  assertFiniteCap(caps.maxWallMs, "maxWallMs");
+  assertFiniteCap(caps.maxAgentCalls, "maxAgentCalls");
+  assertFiniteCap(caps.maxLoopCalls, "maxLoopCalls");
+  assertFiniteCap(caps.maxFanout, "maxFanout");
+  assertFiniteCap(caps.maxDepth, "maxDepth");
+  if (caps.maxCostUsd !== void 0) assertFiniteCap(caps.maxCostUsd, "maxCostUsd");
+  if (caps.maxTokens !== void 0) assertFiniteCap(caps.maxTokens, "maxTokens");
+  return caps;
+}
+function boundNestedCaps(caps, ctx) {
+  const remaining = ctx.budget.remaining();
+  return {
+    ...caps,
+    maxCostUsd: minOptionalCap(caps.maxCostUsd, remaining.costUsd),
+    maxTokens: minOptionalCap(caps.maxTokens, remaining.tokens),
+    maxWallMs: minRequiredCap(caps.maxWallMs, remaining.wallMs, "maxWallMs"),
+    maxAgentCalls: minRequiredCap(caps.maxAgentCalls, remaining.agentCalls, "maxAgentCalls"),
+    maxLoopCalls: minRequiredCap(caps.maxLoopCalls, remaining.loopCalls, "maxLoopCalls"),
+    maxFanout: minRequiredCap(caps.maxFanout, ctx.caps.maxFanout, "maxFanout"),
+    maxDepth: minRequiredCap(caps.maxDepth, ctx.caps.maxDepth, "maxDepth")
+  };
+}
+function assertNestedDepth(ctx) {
+  const maxDepth = ctx.caps.maxDepth;
+  if (typeof maxDepth !== "number" || !Number.isFinite(maxDepth)) {
+    throw new ValidationError("nested workflow parent caps.maxDepth must be finite");
+  }
+  const childDepth = ctx.depth + 1;
+  if (childDepth > maxDepth) {
+    throw new ValidationError(`nested workflow depth ${childDepth} exceeds maxDepth=${maxDepth}`);
+  }
+}
+function minRequiredCap(child, parent, field) {
+  assertFiniteCap(child, field);
+  if (parent === void 0 || !Number.isFinite(parent)) return child;
+  return Math.min(child, parent);
+}
+function minOptionalCap(child, parent) {
+  if (child !== void 0 && parent !== void 0 && Number.isFinite(parent)) {
+    return Math.min(child, parent);
+  }
+  if (child !== void 0) return child;
+  return parent !== void 0 && Number.isFinite(parent) ? parent : void 0;
+}
+function assertFiniteCap(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new ValidationError(`nested workflow caps.${field} must be a finite non-negative number`);
+  }
+  if ((field === "maxAgentCalls" || field === "maxLoopCalls" || field === "maxFanout" || field === "maxDepth") && !Number.isInteger(value)) {
+    throw new ValidationError(`nested workflow caps.${field} must be an integer`);
+  }
+}
+function resolveMetadata(resolver, input) {
+  return typeof resolver === "function" ? resolver(input) : resolver;
+}
+function defaultTrace3(result, input, options) {
+  return {
+    nested: true,
+    runId: result.runId,
+    parentRunId: input.parent.workflowRunId,
+    depth: input.parent.depth + 1,
+    metaName: result.meta.name,
+    eventCount: result.events.length,
+    eventKinds: result.events.map((event) => event.kind),
+    durationMs: result.durationMs,
+    costUsd: result.costUsd,
+    tokenUsage: result.tokenUsage,
+    agentCalls: result.agentCalls,
+    loopCalls: result.loopCalls,
+    ...options.includeEventsInTrace ? { events: result.events } : {}
+  };
+}
+export {
+  WorkflowBudget,
+  createNestedWorkflowAgentDelegate,
+  createRunLoopWorkflowDelegate,
+  createSandboxWorkflowAgentDelegate,
+  parseSandboxAgentDefaultOutput,
+  parseWorkflowScript,
+  runWorkflow,
+  validateJsonSchema,
+  validateWorkflowBody
+};
+//# sourceMappingURL=workflow.js.map