@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-YLSRZWFK.mjs

@@ -0,0 +1,2219 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  MissingParamsError,
+  missingParams
+} from "./flow-weaver-chunk-EKWF27G6.mjs";
+import {
+  DEFAULT_MAX_ITERATIONS,
+  DEFAULT_MODEL,
+  keyEnvOf,
+  loadAgentProfiles,
+  profileForGate,
+  readiness
+} from "./flow-weaver-chunk-TS5P3PIN.mjs";
+import {
+  ContinuationRefusalError,
+  executeWorkflow
+} from "./flow-weaver-chunk-GBUNNP33.mjs";
+import {
+  getAvailableWorkflows
+} from "./flow-weaver-chunk-NQKKWDGF.mjs";
+import {
+  DurableSourceProof,
+  applyDurableSourceProof,
+  compileWorkflow
+} from "./flow-weaver-chunk-V6DHWFQG.mjs";
+import {
+  GENERATOR_ABI,
+  graphIdentity,
+  validateWireValue
+} from "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  isMultipleWorkflows,
+  parseWorkflow,
+  parseWorkflowSourceAtPath
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import {
+  validateDurableClosure
+} from "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+
+// src/coordinator/runs-dir.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function resolveProjectRoot(anchor) {
+  let current;
+  try {
+    current = fs.statSync(anchor).isDirectory() ? path.resolve(anchor) : path.dirname(path.resolve(anchor));
+  } catch {
+    current = path.dirname(path.resolve(anchor));
+  }
+  const root = path.parse(current).root;
+  for (let dir = current; ; dir = path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "package.json")) || fs.existsSync(path.join(dir, ".fw"))) {
+      return dir;
+    }
+    if (dir === root || path.dirname(dir) === dir) break;
+  }
+  return current;
+}
+function defaultRunsDir(anchor) {
+  if (process.env.FW_RUNS_DIR) return process.env.FW_RUNS_DIR;
+  if (anchor) return path.join(resolveProjectRoot(anchor), ".fw", "runs");
+  return path.join(os.homedir(), ".fw", "runs");
+}
+
+// src/coordinator/run-store.ts
+import * as path6 from "node:path";
+
+// src/coordinator/run-context.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as os3 from "node:os";
+
+// src/coordinator/store.ts
+var DOC_NAME = /^[a-z0-9][a-z0-9_-]{0,80}$/i;
+var RESERVED_DOCS = ["continuation", "trace", "claim", "run"];
+var EFFECT_DOC_PREFIX = "effect-";
+function checkDocName(name) {
+  if (!DOC_NAME.test(name)) throw new Error(`not a valid document name: ${name}`);
+}
+var RunBusyError = class extends Error {
+  constructor(runId) {
+    super(`run ${runId} is being driven by another process. Try again shortly`);
+    this.runId = runId;
+  }
+  runId;
+  name = "RunBusyError";
+};
+
+// src/coordinator/file-store.ts
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+import { randomUUID } from "node:crypto";
+function samePath(a, b) {
+  const norm = (p) => {
+    const resolved = path2.resolve(p).split(path2.sep).join("/");
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  };
+  return norm(a) === norm(b);
+}
+var isRunSegment = (runId) => runId.length > 0 && runId.length <= 200 && runId !== "." && runId !== ".." && !/[/\\\0]/.test(runId);
+function createFileRunStore(rootDir) {
+  const runDir = (runId) => {
+    if (!isRunSegment(runId)) throw new Error(`not a valid run id for the file store: ${JSON.stringify(runId)}`);
+    return path2.join(rootDir, runId);
+  };
+  const recordFile = (runId) => path2.join(runDir(runId), "run.json");
+  const claimFile = (runId) => path2.join(runDir(runId), "claim.json");
+  const docFile = (runId, name) => {
+    checkDocName(name);
+    if (name.startsWith(EFFECT_DOC_PREFIX)) return path2.join(runDir(runId), "effects", `${name.slice(EFFECT_DOC_PREFIX.length)}.json`);
+    return path2.join(runDir(runId), `${name}.json`);
+  };
+  const readJson = (file) => {
+    if (!fs2.existsSync(file)) return void 0;
+    try {
+      return JSON.parse(fs2.readFileSync(file, "utf8"));
+    } catch {
+      return void 0;
+    }
+  };
+  const writeAtomic = (file, data) => {
+    fs2.mkdirSync(path2.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${randomUUID()}`;
+    fs2.writeFileSync(tmp, JSON.stringify(data));
+    fs2.renameSync(tmp, file);
+  };
+  const standing = (c) => {
+    if (!c) return false;
+    if (Date.parse(c.expiresAt) <= Date.now()) return false;
+    if (c.host !== os2.hostname() || c.pid === process.pid) return true;
+    try {
+      process.kill(c.pid, 0);
+      return true;
+    } catch (e) {
+      return e.code !== "ESRCH";
+    }
+  };
+  return {
+    async get(runId) {
+      return isRunSegment(runId) ? readJson(recordFile(runId)) : void 0;
+    },
+    async put(record) {
+      writeAtomic(recordFile(record.runId), record);
+    },
+    async list(filter = {}) {
+      if (!fs2.existsSync(rootDir)) return [];
+      const wanted = filter.filePath ? path2.resolve(filter.filePath) : void 0;
+      const records = [];
+      for (const entry of fs2.readdirSync(rootDir)) {
+        const record = readJson(recordFile(entry));
+        if (!record) continue;
+        if (wanted && !samePath(record.filePath, wanted)) continue;
+        records.push(record);
+      }
+      return records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    },
+    async remove(runId) {
+      fs2.rmSync(runDir(runId), { recursive: true, force: true });
+    },
+    async getDoc(runId, name) {
+      return isRunSegment(runId) ? readJson(docFile(runId, name)) : void 0;
+    },
+    async putDoc(runId, name, data) {
+      writeAtomic(docFile(runId, name), data);
+    },
+    async deleteDoc(runId, name) {
+      fs2.rmSync(docFile(runId, name), { force: true });
+    },
+    async claim(runId, owner, ttlMs) {
+      const file = claimFile(runId);
+      const mine = { owner, pid: process.pid, host: os2.hostname(), expiresAt: new Date(Date.now() + ttlMs).toISOString() };
+      fs2.mkdirSync(runDir(runId), { recursive: true });
+      for (let attempt = 0; attempt < 3; attempt++) {
+        const current = readJson(file);
+        if (standing(current) && current.owner !== owner) return false;
+        if (standing(current) && current.owner === owner) {
+          writeAtomic(file, mine);
+          return true;
+        }
+        if (current) {
+          const aside = `${file}.lapsed-${randomUUID().slice(0, 8)}`;
+          try {
+            fs2.renameSync(file, aside);
+          } catch (e) {
+            if (e.code !== "ENOENT") throw e;
+            continue;
+          }
+          fs2.rmSync(aside, { force: true });
+        }
+        try {
+          fs2.writeFileSync(file, JSON.stringify(mine), { flag: "wx" });
+          return true;
+        } catch (e) {
+          if (e.code !== "EEXIST") throw e;
+        }
+      }
+      return false;
+    },
+    async release(runId, owner) {
+      const file = claimFile(runId);
+      const current = readJson(file);
+      if (current?.owner === owner) fs2.rmSync(file, { force: true });
+    }
+  };
+}
+
+// src/coordinator/run-context.ts
+function createRunContext(options) {
+  const store = options.store ?? createFileRunStore(options.rootDir ?? defaultRunsDir());
+  const claimTtl = options.claimTtlMs ?? 60 * 60 * 1e3;
+  const instance = `${os3.hostname()}:${process.pid}:${randomUUID2().slice(0, 8)}`;
+  let uses = 0;
+  async function claimed(runId, work) {
+    const owner = `${instance}:${++uses}`;
+    if (!await store.claim(runId, owner, claimTtl)) throw new RunBusyError(runId);
+    try {
+      return await work();
+    } finally {
+      await store.release(runId, owner);
+    }
+  }
+  async function readRecord(runId) {
+    return store.get(runId);
+  }
+  return { store, claimed, readRecord };
+}
+
+// src/coordinator/run-start.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import * as path5 from "node:path";
+
+// src/coordinator/bundle-digest.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+
+// src/compiler/executable-artifact.ts
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
+import ts from "typescript";
+
+// src/runtime/executable-module-contract.ts
+var EXECUTABLE_WORKFLOW_MODULE_FORMAT = 1;
+var EXECUTABLE_WORKFLOW_METADATA_EXPORT = "__flowWeaverExecutableArtifact";
+
+// src/compiler/executable-artifact.ts
+async function compileExecutableWorkflowArtifact(request) {
+  if (request.workflowName.trim().length === 0) {
+    throw new Error("workflowName must be non-empty");
+  }
+  const workflows = getAvailableWorkflows(request.source);
+  if (!workflows.some((workflow) => workflow.functionName === request.workflowName)) {
+    throw new Error(`Workflow ${request.workflowName} is not declared by the artifact source`);
+  }
+  const directory = await mkdtemp(join3(tmpdir(), "flow-weaver-artifact-"));
+  const filePath = join3(directory, "workflow.ts");
+  try {
+    const durableSourceProof = request.durableValidationSource === void 0 ? void 0 : DurableSourceProof.create(
+      await parseWorkflowSourceAtPath(
+        request.durableValidationSource.sourcePath,
+        request.durableValidationSource.source,
+        {
+          workflowName: request.workflowName,
+          ...request.externalNodeTypes === void 0 ? {} : { externalNodeTypes: [...request.externalNodeTypes] },
+          ...request.durableValidationSource.resolveImport === void 0 ? {} : { sourceImportResolver: request.durableValidationSource.resolveImport },
+          ...request.durableValidationSource.loadSource === void 0 ? {} : { sourceOverrideLoader: request.durableValidationSource.loadSource }
+        }
+      ),
+      request.durableValidationSource.source
+    );
+    await writeFile(filePath, request.source, { encoding: "utf8", mode: 384 });
+    const metadata = await createExecutableWorkflowMetadata(
+      filePath,
+      request.workflowName,
+      request.externalNodeTypes,
+      durableSourceProof,
+      request.source
+    );
+    for (const workflow of workflows) {
+      await compileWorkflow(filePath, {
+        write: true,
+        inPlace: true,
+        parse: {
+          workflowName: workflow.functionName,
+          ...request.externalNodeTypes === void 0 ? {} : { externalNodeTypes: [...request.externalNodeTypes] }
+        },
+        // The deployed artifact keeps step instrumentation. A runtime may
+        // choose not to subscribe, but it must be able to report steps.
+        generate: { production: false },
+        ...durableSourceProof === void 0 ? {} : {
+          durableSourceProof,
+          durableFlattenedSource: request.source
+        }
+      });
+    }
+    const generated = await readFile(filePath, "utf8");
+    const transpiled = ts.transpileModule(generated, {
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ESNext,
+        esModuleInterop: true
+      }
+    }).outputText;
+    const metadataExport = `
+export const ${EXECUTABLE_WORKFLOW_METADATA_EXPORT} = Object.freeze(${JSON.stringify(metadata)});
+`;
+    return Object.freeze({
+      formatVersion: 1,
+      workflowName: request.workflowName,
+      code: `${transpiled}${metadataExport}`
+    });
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+async function createExecutableWorkflowMetadata(filePath, workflowName, externalNodeTypes, durableSourceProof, flattenedSource) {
+  const parsed = await parseWorkflow(filePath, {
+    workflowName,
+    projectDir: dirname3(filePath),
+    ...externalNodeTypes === void 0 ? {} : { externalNodeTypes: [...externalNodeTypes] }
+  });
+  if (parsed.errors.length > 0) {
+    throw new Error(`Cannot emit executable artifact metadata: ${parsed.errors.join("; ")}`);
+  }
+  if (durableSourceProof !== void 0) {
+    applyDurableSourceProof(durableSourceProof, parsed, flattenedSource);
+  }
+  validateDurableClosure(parsed.ast, parsed.allWorkflows);
+  const { graphFingerprint, continuationGraph, capabilities } = graphIdentity(parsed.ast, parsed.allWorkflows);
+  return Object.freeze({
+    formatVersion: EXECUTABLE_WORKFLOW_MODULE_FORMAT,
+    generatorAbi: GENERATOR_ABI,
+    workflowName,
+    workflowNames: parsed.allWorkflows.map((workflow) => workflow.functionName).sort(),
+    graphFingerprint,
+    continuationGraph,
+    capabilities
+  });
+}
+
+// src/coordinator/bundle-digest.ts
+var cache = /* @__PURE__ */ new Map();
+async function computeBundleDigest(filePath, workflowName) {
+  const stat = statSync2(filePath);
+  const key = `${filePath}\0${workflowName}`;
+  const hit = cache.get(key);
+  if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) return hit.digest;
+  const source = readFileSync2(filePath, "utf8");
+  const artifact = await compileExecutableWorkflowArtifact({ source, workflowName });
+  const digest = "sha256:" + createHash("sha256").update(artifact.code).digest("hex");
+  cache.set(key, { mtimeMs: stat.mtimeMs, size: stat.size, digest });
+  return digest;
+}
+
+// src/coordinator/effect-receipts.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as path3 from "node:path";
+var effectDoc = (operationKey) => `${EFFECT_DOC_PREFIX}${createHash2("sha256").update(operationKey).digest("hex")}`;
+function createStoreEffectAdapter(store, runId) {
+  return {
+    async recover(operationKey) {
+      let doc;
+      try {
+        doc = await store.getDoc(runId, effectDoc(operationKey));
+      } catch {
+        return { kind: "ambiguous" };
+      }
+      if (doc === void 0) return { kind: "not-committed" };
+      if (typeof doc !== "object" || doc === null || !("receipt" in doc)) return { kind: "ambiguous" };
+      const record = doc;
+      return { kind: "committed", receipt: record.receipt, result: record.result };
+    },
+    async commit(operationKey, address, execution) {
+      await store.putDoc(runId, effectDoc(operationKey), { operationKey, address, result: execution.result, receipt: execution.receipt });
+    }
+  };
+}
+function createFileEffectAdapter(runDir) {
+  return createStoreEffectAdapter(createFileRunStore(path3.dirname(runDir)), path3.basename(runDir));
+}
+
+// src/coordinator/gate-labeling.ts
+function labelGate(gate, ast) {
+  const instance = ast.instances.find((candidate) => candidate.id === gate.address.nodeId);
+  if (!instance) {
+    throw new Error(`gate node not found in workflow: ${gate.address.nodeId}`);
+  }
+  const nodeType = findNodeType(ast.nodeTypes, instance.nodeType, gate.address.nodeType);
+  if (!nodeType) {
+    throw new Error(
+      `node type not found for gate ${gate.address.nodeId}: ${instance.nodeType} / ${gate.address.nodeType}`
+    );
+  }
+  const names = dataPorts(nodeType.inputs);
+  const args = readArguments(gate.payload);
+  if (args.length !== names.length) {
+    throw new Error(
+      `gate payload has ${args.length} arguments but node type ${nodeType.name} declares ${names.length} inputs`
+    );
+  }
+  const inputs = {};
+  const absent = [];
+  names.forEach((name, index) => {
+    const argument = args[index];
+    if ("absent" in argument) {
+      inputs[name] = null;
+      absent.push(name);
+    } else {
+      inputs[name] = argument.value;
+    }
+  });
+  return {
+    inputs,
+    absent,
+    outputs: dataPorts(nodeType.outputs),
+    hasSuccessPort: nodeType.hasSuccessPort,
+    hasFailurePort: nodeType.hasFailurePort
+  };
+}
+var CONTROL_PORT_NAMES = /* @__PURE__ */ new Set(["execute", "onSuccess", "onFailure"]);
+function dataPorts(ports) {
+  return Object.keys(ports).filter(
+    (name) => !CONTROL_PORT_NAMES.has(name) && !ports[name].isControlFlow
+  );
+}
+function findNodeType(nodeTypes, instanceTypeName, functionName) {
+  return nodeTypes.find((candidate) => candidate.name === instanceTypeName) ?? nodeTypes.find((candidate) => candidate.functionName === functionName);
+}
+function readArguments(payload) {
+  if (typeof payload !== "object" || payload === null || !Array.isArray(payload.arguments)) {
+    throw new Error("gate payload is not a positional argument list");
+  }
+  return payload.arguments;
+}
+
+// src/coordinator/run-trace.ts
+function observe(options) {
+  const tracing = options?.trace === true || options?.onEvent !== void 0;
+  if (!tracing) return { kept: void 0, request: { includeTrace: false, production: true } };
+  const kept = [];
+  const onEvent = (event) => {
+    kept.push({ t: event.timestamp, e: event.data ?? event });
+    options?.onEvent?.(event);
+  };
+  return { kept, request: { includeTrace: true, production: false, onEvent } };
+}
+async function appendTrace(store, record, kept) {
+  if (!kept) return false;
+  const previous = await readTrace(store, record.runId);
+  await store.putDoc(record.runId, "trace", [...previous, ...kept]);
+  return true;
+}
+async function readTrace(store, runId) {
+  const doc = await store.getDoc(runId, "trace");
+  return Array.isArray(doc) ? doc : [];
+}
+function failedNodeIn(kept) {
+  if (!kept) return void 0;
+  for (let i = kept.length - 1; i >= 0; i--) {
+    const e = kept[i].e;
+    if (e?.type === "LOG_ERROR" && e.id) return e.id;
+    if (e?.type === "STATUS_CHANGED" && e.status === "FAILED" && e.id) return e.id;
+  }
+  return void 0;
+}
+
+// src/built-in-nodes/delay.ts
+function parseDuration(text) {
+  if (typeof text !== "string") return void 0;
+  const match = /^\s*(\d+)\s*(ms|s|m|h|d)\s*$/.exec(text);
+  if (!match) return void 0;
+  const units = { ms: 1, s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+  return Number(match[1]) * units[match[2]];
+}
+
+// src/coordinator/time.ts
+function dueFor(gate, now = Date.now()) {
+  if (gate.kind === "timer") {
+    const ms2 = parseDuration(gate.inputs.duration) ?? 0;
+    return { at: new Date(now + ms2).toISOString(), action: "wake" };
+  }
+  const ms = parseDuration(gate.inputs.timeout);
+  if (ms === void 0 || !gate.hasFailurePort) return void 0;
+  return { at: new Date(now + ms).toISOString(), action: "timeout" };
+}
+
+// src/coordinator/run-outcome.ts
+async function commit(store, record, outcome, ast, kept) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const traced = await appendTrace(store, record, kept);
+  if (outcome.kind === "yielded") {
+    const labeled = labelGate(outcome.gate, ast);
+    const gate = {
+      id: outcome.gate.id,
+      kind: outcome.gate.kind,
+      node: outcome.gate.address.nodeId,
+      nodeType: outcome.gate.address.nodeType,
+      ...labeled
+    };
+    const next2 = {
+      ...record,
+      traced,
+      status: "waiting",
+      gate,
+      continuation: outcome.continuation,
+      due: dueFor(gate),
+      result: void 0,
+      error: void 0,
+      updatedAt: now
+    };
+    if (next2.due === void 0) delete next2.due;
+    await store.put(next2);
+    return next2;
+  }
+  const next = {
+    ...record,
+    traced,
+    status: "completed",
+    gate: void 0,
+    continuation: void 0,
+    due: void 0,
+    result: outcome.result,
+    error: void 0,
+    updatedAt: now
+  };
+  await store.put(next);
+  await store.deleteDoc(record.runId, "continuation");
+  return next;
+}
+async function fail(store, record, error, options, kept) {
+  const traced = await appendTrace(store, record, kept);
+  const message = getErrorMessage(error);
+  const cancelled = options?.abortSignal?.aborted === true;
+  await store.put({
+    ...record,
+    traced,
+    status: cancelled ? "cancelled" : "failed",
+    gate: void 0,
+    continuation: void 0,
+    due: void 0,
+    result: void 0,
+    error: cancelled ? void 0 : message,
+    failedNode: cancelled ? void 0 : failedNodeIn(kept),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await store.deleteDoc(record.runId, "continuation");
+}
+
+// src/coordinator/run-views.ts
+function toView(record) {
+  const view = {
+    status: record.status,
+    runId: record.runId,
+    workflowName: record.workflowName
+  };
+  if (record.status === "waiting" && record.gate) {
+    view.gate = {
+      kind: record.gate.kind,
+      node: record.gate.node,
+      inputs: record.gate.inputs,
+      absent: record.gate.absent
+    };
+    if (record.due) view.due = record.due;
+  }
+  if (record.status === "completed") view.result = record.result;
+  if (record.status === "failed") view.error = record.error;
+  return view;
+}
+function toSummary(record) {
+  return {
+    status: record.status,
+    runId: record.runId,
+    workflowName: record.workflowName,
+    filePath: record.filePath,
+    gate: record.gate ? { kind: record.gate.kind, node: record.gate.node } : void 0,
+    due: record.due,
+    params: record.params,
+    failedNode: record.failedNode,
+    mocks: record.mocks,
+    source: record.source,
+    agents: record.agents,
+    agent: record.agent ? { status: record.agent.status, profile: record.agent.profile, node: record.agent.node } : void 0,
+    origin: record.origin,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+}
+
+// src/coordinator/workflow-selection.ts
+import * as path4 from "node:path";
+
+// src/coordinator/errors.ts
+var ParseError = class extends Error {
+  name = "ParseError";
+};
+var AmbiguousWorkflowError = class extends Error {
+  constructor(names) {
+    super(`file declares several workflows. Pass workflowName, one of: ${names.join(", ")}`);
+    this.names = names;
+  }
+  names;
+  name = "AmbiguousWorkflowError";
+};
+var RunNotFoundError = class extends Error {
+  name = "RunNotFoundError";
+  constructor(runId) {
+    super(`no run with id ${runId}`);
+  }
+};
+var RunNotWaitingError = class extends Error {
+  constructor(status) {
+    super(`run is ${status}, not waiting at a gate`);
+    this.status = status;
+  }
+  status;
+  name = "RunNotWaitingError";
+};
+var BundleChangedError = class extends Error {
+  name = "BundleChangedError";
+  constructor() {
+    super("workflow or its compiled output changed since the run paused. Start a new run");
+  }
+};
+
+// src/coordinator/workflow-selection.ts
+async function parseSelected(filePath, requested) {
+  const projectDir = path4.dirname(filePath);
+  const first = await parseWorkflow(filePath, { workflowName: requested, projectDir });
+  if (requested === void 0 && isMultipleWorkflows(first.errors)) throw new AmbiguousWorkflowError(first.availableWorkflows);
+  if (first.errors.length > 0) throw new ParseError(first.errors.join("\n"));
+  const available = first.availableWorkflows;
+  let workflowName = requested;
+  if (workflowName === void 0) {
+    if (available.length === 1) workflowName = available[0];
+    else throw new AmbiguousWorkflowError(available);
+  } else if (!available.includes(workflowName)) {
+    throw new ParseError(`workflow ${workflowName} not found. Available: ${available.join(", ")}`);
+  }
+  if (first.ast.functionName === workflowName) return { ast: first.ast, workflowName };
+  const second = await parseWorkflow(filePath, { workflowName, projectDir });
+  if (second.errors.length > 0) throw new ParseError(second.errors.join("\n"));
+  return { ast: second.ast, workflowName };
+}
+
+// src/coordinator/run-start.ts
+async function startRun(ctx, request, options) {
+  const { store, claimed } = ctx;
+  const filePath = path5.resolve(request.filePath);
+  const { ast, workflowName } = await parseSelected(filePath, request.workflowName);
+  const missing = missingParams(ast, request.params);
+  if (missing.length) throw new MissingParamsError(workflowName, missing);
+  const bundleDigest = await computeBundleDigest(filePath, workflowName);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    formatVersion: 1,
+    runId: request.runId ?? randomUUID3(),
+    filePath,
+    workflowName,
+    params: request.params ?? {},
+    bundleDigest,
+    status: "waiting",
+    ...request.mocks ? { mocks: request.mocks } : {},
+    ...request.source ? { source: request.source } : {},
+    ...request.agents ? { agents: request.agents } : {},
+    ...request.origin ? { origin: request.origin } : {},
+    createdAt: now,
+    updatedAt: now
+  };
+  return claimed(record.runId, async () => {
+    const { kept, request: observed } = observe(options);
+    let outcome;
+    try {
+      outcome = await executeWorkflow({
+        runId: record.runId,
+        bundleDigest,
+        filePath,
+        params: record.params,
+        workflowName,
+        mocks: record.mocks,
+        ...observed,
+        abortSignal: options?.abortSignal,
+        effectAdapter: createStoreEffectAdapter(store, record.runId)
+      });
+    } catch (error) {
+      await fail(store, record, error, options, kept);
+      throw error;
+    }
+    return toView(await commit(store, record, outcome, ast, kept));
+  });
+}
+
+// src/coordinator/gate-resolution.ts
+var MissingOutputsError = class extends Error {
+  constructor(missing) {
+    super(`answer is missing gate outputs: ${missing.join(", ")}`);
+    this.missing = missing;
+  }
+  missing;
+  name = "MissingOutputsError";
+};
+var InvalidAnswerError = class extends Error {
+  name = "InvalidAnswerError";
+};
+function buildGateResolution(gate, gateId, input) {
+  const value = {};
+  if ("reject" in input) {
+    if (gate.hasSuccessPort) value.onSuccess = false;
+    if (gate.hasFailurePort) value.onFailure = true;
+    for (const port of gate.outputs) value[port] = null;
+  } else {
+    if (gate.hasSuccessPort) value.onSuccess = true;
+    if (gate.hasFailurePort) value.onFailure = false;
+    Object.assign(value, dataPorts2(gate.outputs, input.answer));
+  }
+  try {
+    validateWireValue(value);
+  } catch (error) {
+    throw new InvalidAnswerError(getErrorMessage(error));
+  }
+  return { gateId, value };
+}
+function dataPorts2(outputs, answer) {
+  if (outputs.length === 0) {
+    if (answer !== null && answer !== void 0) {
+      throw new InvalidAnswerError("this gate has no data outputs, so answer must be null");
+    }
+    return {};
+  }
+  if (outputs.length === 1) {
+    return { [outputs[0]]: answer };
+  }
+  if (typeof answer !== "object" || answer === null || Array.isArray(answer)) {
+    throw new MissingOutputsError(outputs);
+  }
+  const record = answer;
+  const missing = outputs.filter((port) => !(port in record));
+  if (missing.length > 0) throw new MissingOutputsError(missing);
+  const picked = {};
+  for (const port of outputs) picked[port] = record[port];
+  return picked;
+}
+
+// src/coordinator/run-resume.ts
+async function resumable(ctx, request) {
+  const record = await ctx.readRecord(request.runId);
+  if (!record) throw new RunNotFoundError(request.runId);
+  if (record.status !== "waiting" || !record.gate) throw new RunNotWaitingError(record.status);
+  const digest = await computeBundleDigest(record.filePath, record.workflowName);
+  if (digest !== record.bundleDigest) throw new BundleChangedError();
+  buildGateResolution(record.gate, record.gate.id, request.input);
+  return record;
+}
+async function resumeRun(ctx, request, options) {
+  const { store, claimed, readRecord } = ctx;
+  const record = await resumable(ctx, request);
+  return claimed(record.runId, async () => {
+    const current = await readRecord(record.runId);
+    if (!current || current.status !== "waiting" || !current.gate) throw new RunNotWaitingError(current?.status ?? "cancelled");
+    const continuation = current.continuation ?? await store.getDoc(record.runId, "continuation");
+    if (!continuation) throw new RunNotWaitingError(current.status);
+    if (continuation.gateId !== current.gate.id) {
+      throw new ContinuationRefusalError({ accepted: false, reason: "stale-gate", message: `the run's record names gate ${current.gate.id} but its continuation is at gate ${continuation.gateId}` });
+    }
+    const resolution = buildGateResolution(current.gate, current.gate.id, request.input);
+    const { ast } = await parseSelected(record.filePath, record.workflowName);
+    const { kept, request: observed } = observe(options);
+    let outcome;
+    try {
+      outcome = await executeWorkflow({
+        runId: record.runId,
+        bundleDigest: record.bundleDigest,
+        filePath: record.filePath,
+        params: record.params,
+        workflowName: record.workflowName,
+        mocks: record.mocks,
+        ...observed,
+        abortSignal: options?.abortSignal,
+        continuation,
+        resolution,
+        effectAdapter: createStoreEffectAdapter(store, record.runId)
+      });
+    } catch (error) {
+      if (error instanceof ContinuationRefusalError) throw error;
+      await fail(store, current, error, options, kept);
+      throw error;
+    }
+    return toView(await commit(store, current, outcome, ast, kept));
+  });
+}
+
+// src/coordinator/run-ending.ts
+async function cancelRun(ctx, runId) {
+  const { store, claimed, readRecord } = ctx;
+  const record = await readRecord(runId);
+  if (!record) throw new RunNotFoundError(runId);
+  if (record.status !== "waiting") throw new RunNotWaitingError(record.status);
+  return claimed(runId, async () => {
+    const current = await readRecord(runId);
+    if (!current || current.status !== "waiting") throw new RunNotWaitingError(current?.status ?? "cancelled");
+    const next = {
+      ...current,
+      status: "cancelled",
+      gate: void 0,
+      continuation: void 0,
+      due: void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await store.put(next);
+    await store.deleteDoc(runId, "continuation");
+    return toView(next);
+  });
+}
+async function removeRun(ctx, runId) {
+  const record = await ctx.readRecord(runId);
+  if (!record) throw new RunNotFoundError(runId);
+  if (record.status === "waiting") throw new RunNotWaitingError(record.status);
+  await ctx.store.remove(runId);
+}
+
+// src/coordinator/run-annotations.ts
+async function setAgentNote(ctx, runId, note) {
+  const { store, claimed, readRecord } = ctx;
+  if (!await readRecord(runId)) throw new RunNotFoundError(runId);
+  return claimed(runId, async () => {
+    const record = await readRecord(runId);
+    if (!record) throw new RunNotFoundError(runId);
+    const next = { ...record, agent: note, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    if (note === void 0) delete next.agent;
+    await store.put(next);
+    return next;
+  });
+}
+async function keepDoc(ctx, runId, name, data) {
+  checkDocName(name);
+  if (RESERVED_DOCS.includes(name) || name.startsWith(EFFECT_DOC_PREFIX)) throw new Error(`${name} is a document the coordinator keeps itself`);
+  if (!await ctx.readRecord(runId)) throw new RunNotFoundError(runId);
+  await ctx.store.putDoc(runId, name, data);
+}
+async function keptDoc(ctx, runId, name) {
+  checkDocName(name);
+  return await ctx.store.getDoc(runId, name);
+}
+
+// src/coordinator/clock-tick.ts
+async function tickDue(store, resume, now) {
+  const result = { woke: [], timedOut: [], skipped: [] };
+  const at = new Date(now).toISOString();
+  for (const summary of await store.list()) {
+    if (summary.status !== "waiting" || !summary.due || summary.due.at > at) continue;
+    const { runId, due } = summary;
+    const input = due.action === "wake" ? { answer: summary.gate?.outputs.length ? at : null } : { reject: `no answer within ${String(summary.gate?.inputs.timeout ?? "the timeout")}` };
+    try {
+      const view = await resume({ runId, input });
+      (due.action === "wake" ? result.woke : result.timedOut).push(view);
+    } catch (error) {
+      const name = error instanceof Error ? error.name : "";
+      const reason = name === "RunBusyError" ? "busy" : name === "RunNotWaitingError" ? "not-waiting" : name === "BundleChangedError" ? "bundle-changed" : "failed";
+      result.skipped.push({ runId, reason, ...reason === "failed" ? { message: getErrorMessage(error) } : {} });
+    }
+  }
+  return result;
+}
+
+// src/coordinator/run-store.ts
+function createLocalCoordinator(options = {}) {
+  const ctx = createRunContext(options);
+  const { store, readRecord } = ctx;
+  return {
+    store,
+    start(request, options2) {
+      return startRun(ctx, request, options2);
+    },
+    checkResume: async (request) => {
+      await resumable(ctx, request);
+    },
+    resume(request, options2) {
+      return resumeRun(ctx, request, options2);
+    },
+    cancel(runId) {
+      return cancelRun(ctx, runId);
+    },
+    async get(runId) {
+      const record = await readRecord(runId);
+      return record ? toView(record) : void 0;
+    },
+    record: readRecord,
+    trace: (runId) => readTrace(store, runId),
+    remove(runId) {
+      return removeRun(ctx, runId);
+    },
+    setAgent(runId, note) {
+      return setAgentNote(ctx, runId, note);
+    },
+    keep(runId, name, data) {
+      return keepDoc(ctx, runId, name, data);
+    },
+    kept(runId, name) {
+      return keptDoc(ctx, runId, name);
+    },
+    // Through `this`, so each due run is resumed by the coordinator as it
+    // stands when the tick reaches it.
+    tick(now = Date.now()) {
+      return tickDue(store, (request) => this.resume(request), now);
+    },
+    async list(filter = {}) {
+      const records = await store.list(filter.filePath ? { filePath: path6.resolve(filter.filePath) } : {});
+      return records.map(toSummary);
+    }
+  };
+}
+
+// src/coordinator/agent-gate.ts
+import * as os5 from "node:os";
+
+// src/agent/agent-loop.ts
+var DEFAULT_MAX_ITERATIONS2 = 15;
+var TOOL_RESULT_CAP = 1e4;
+function truncateToolResult(result, cap = TOOL_RESULT_CAP) {
+  if (result.length <= cap) return result;
+  return `${result.slice(0, cap)}
+[truncated: ${result.length - cap} more characters]`;
+}
+async function runAgentLoop(provider, tools, executor, messages, options) {
+  const maxIterations = options?.maxIterations ?? DEFAULT_MAX_ITERATIONS2;
+  const signal = options?.signal;
+  const onStreamEvent = options?.onStreamEvent;
+  const onToolEvent = options?.onToolEvent;
+  const conversation = [...messages];
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheCreationTokens = 0;
+  let totalCostUsd = 0;
+  let toolCallCount = 0;
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    if (signal?.aborted) {
+      return buildResult(false, "Aborted", conversation, toolCallCount, totalPromptTokens, totalCompletionTokens, totalCacheReadTokens, totalCacheCreationTokens, totalCostUsd);
+    }
+    let text = "";
+    let finishReason = "stop";
+    const collectedToolCalls = [];
+    const activeToolNames = /* @__PURE__ */ new Map();
+    const stream = provider.stream(conversation, tools, {
+      systemPrompt: options?.systemPrompt,
+      model: options?.model,
+      maxTokens: options?.maxTokens,
+      signal,
+      executor,
+      onToolEvent
+    });
+    for await (const event of stream) {
+      onStreamEvent?.(event);
+      switch (event.type) {
+        case "text_delta":
+          text += event.text;
+          break;
+        case "thinking_delta":
+          break;
+        case "tool_use_start":
+          activeToolNames.set(event.id, event.name);
+          break;
+        case "tool_use_delta":
+          break;
+        case "tool_use_end":
+          collectedToolCalls.push({
+            id: event.id,
+            name: activeToolNames.get(event.id) ?? "unknown",
+            arguments: event.arguments
+          });
+          activeToolNames.delete(event.id);
+          break;
+        case "tool_result":
+          toolCallCount++;
+          break;
+        case "usage":
+          totalPromptTokens += event.promptTokens;
+          totalCompletionTokens += event.completionTokens;
+          totalCacheReadTokens += event.cacheReadTokens ?? 0;
+          totalCacheCreationTokens += event.cacheCreationTokens ?? 0;
+          if (event.costUsd != null) totalCostUsd = event.costUsd;
+          break;
+        case "message_stop":
+          finishReason = event.finishReason;
+          break;
+      }
+    }
+    if (collectedToolCalls.length > 0) {
+      conversation.push({
+        role: "assistant",
+        content: text || "",
+        toolCalls: collectedToolCalls
+      });
+    } else if (text) {
+      conversation.push({ role: "assistant", content: text });
+    }
+    if (finishReason !== "tool_calls" || collectedToolCalls.length === 0) {
+      if (options?.onTurnEnd) {
+        await options.onTurnEnd({
+          iteration,
+          maxIterations,
+          messages: conversation,
+          toolCallCount,
+          usage: { promptTokens: totalPromptTokens, completionTokens: totalCompletionTokens },
+          isFinalTurn: true
+        });
+      }
+      return buildResult(
+        finishReason !== "error",
+        text || "Task completed",
+        conversation,
+        toolCallCount,
+        totalPromptTokens,
+        totalCompletionTokens,
+        totalCacheReadTokens,
+        totalCacheCreationTokens,
+        totalCostUsd
+      );
+    }
+    for (const tc of collectedToolCalls) {
+      if (signal?.aborted) break;
+      toolCallCount++;
+      onToolEvent?.({ type: "tool_call_start", name: tc.name, args: tc.arguments });
+      let result;
+      let isError;
+      try {
+        const res = await executor(tc.name, tc.arguments);
+        result = res.result;
+        isError = res.isError;
+      } catch (err) {
+        result = getErrorMessage(err);
+        isError = true;
+      }
+      onToolEvent?.({ type: "tool_call_result", name: tc.name, args: tc.arguments, result: result.slice(0, 200), isError });
+      conversation.push({
+        role: "tool",
+        content: truncateToolResult(result),
+        toolCallId: tc.id
+      });
+    }
+    if (options?.onTurnEnd) {
+      const turnResult = await options.onTurnEnd({
+        iteration,
+        maxIterations,
+        messages: conversation,
+        toolCallCount,
+        usage: { promptTokens: totalPromptTokens, completionTokens: totalCompletionTokens },
+        isFinalTurn: false
+      });
+      if (turnResult?.continue === false) {
+        return buildResult(
+          true,
+          turnResult.injectMessage ?? "Stopped by hook",
+          conversation,
+          toolCallCount,
+          totalPromptTokens,
+          totalCompletionTokens,
+          totalCacheReadTokens,
+          totalCacheCreationTokens,
+          totalCostUsd
+        );
+      }
+      if (turnResult?.injectMessage) {
+        conversation.push({ role: "user", content: turnResult.injectMessage });
+      }
+    }
+  }
+  return buildResult(
+    false,
+    `Reached max iterations (${maxIterations})`,
+    conversation,
+    toolCallCount,
+    totalPromptTokens,
+    totalCompletionTokens,
+    totalCacheReadTokens,
+    totalCacheCreationTokens,
+    totalCostUsd
+  );
+}
+function buildResult(success, summary, messages, toolCallCount, promptTokens, completionTokens, cacheReadTokens = 0, cacheCreationTokens = 0, costUsd = 0) {
+  return {
+    success,
+    summary,
+    messages,
+    toolCallCount,
+    usage: { promptTokens, completionTokens, cacheReadTokens, cacheCreationTokens, costUsd }
+  };
+}
+
+// src/agent/providers/anthropic.ts
+function buildSystemBlocks(prompt) {
+  const blocks = [
+    { type: "text", text: prompt.prefix, cache_control: { type: "ephemeral" } }
+  ];
+  if (prompt.suffix) {
+    blocks.push({ type: "text", text: prompt.suffix });
+  }
+  return blocks;
+}
+var AnthropicProvider = class {
+  apiKey;
+  model;
+  maxTokens;
+  baseUrl;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("AnthropicProvider requires an API key");
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? DEFAULT_MODEL.anthropic;
+    this.maxTokens = options.maxTokens ?? 8192;
+    this.baseUrl = options.baseUrl ?? "https://api.anthropic.com";
+  }
+  async *stream(messages, tools, options) {
+    const model = options?.model ?? this.model;
+    const maxTokens = options?.maxTokens ?? this.maxTokens;
+    const apiMessages = messages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: m.toolCallId, content: m.content }]
+        };
+      }
+      if (m.role === "assistant" && m.toolCalls?.length) {
+        const blocks = [];
+        if (m.content) blocks.push({ type: "text", text: m.content });
+        for (const tc of m.toolCalls) {
+          blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
+        }
+        return { role: "assistant", content: blocks };
+      }
+      return { role: m.role, content: m.content };
+    });
+    const apiTools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema
+    }));
+    const body = JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      stream: true,
+      ...options?.systemPrompt ? { system: buildSystemBlocks(options.systemPrompt) } : {},
+      messages: apiMessages,
+      ...apiTools.length > 0 ? { tools: apiTools } : {}
+    });
+    const response = await fetch(`${this.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2025-04-15",
+        "content-type": "application/json"
+      },
+      body,
+      signal: options?.signal ?? AbortSignal.timeout(3e5)
+    });
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`Anthropic API error ${response.status}: ${err.slice(0, 200)}`);
+    }
+    if (!response.body) throw new Error("No response body");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const activeToolUses = /* @__PURE__ */ new Map();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const jsonStr = line.slice(6).trim();
+          if (jsonStr === "[DONE]") continue;
+          let event;
+          try {
+            event = JSON.parse(jsonStr);
+          } catch {
+            continue;
+          }
+          const eventType = event.type;
+          if (eventType === "content_block_start") {
+            const block = event.content_block;
+            const index = event.index;
+            if (block.type === "tool_use" && block.id && block.name) {
+              activeToolUses.set(index, { id: block.id, name: block.name, jsonChunks: [] });
+              yield { type: "tool_use_start", id: block.id, name: block.name };
+            }
+          }
+          if (eventType === "content_block_delta") {
+            const delta = event.delta;
+            const index = event.index;
+            if (delta.type === "text_delta" && delta.text) {
+              yield { type: "text_delta", text: delta.text };
+            }
+            if (delta.type === "thinking_delta" && delta.thinking) {
+              yield { type: "thinking_delta", text: delta.thinking };
+            }
+            if (delta.type === "input_json_delta" && delta.partial_json !== void 0) {
+              const active = activeToolUses.get(index);
+              if (active) {
+                active.jsonChunks.push(delta.partial_json);
+                yield { type: "tool_use_delta", id: active.id, partialJson: delta.partial_json };
+              }
+            }
+          }
+          if (eventType === "content_block_stop") {
+            const index = event.index;
+            const active = activeToolUses.get(index);
+            if (active) {
+              activeToolUses.delete(index);
+              let args = {};
+              try {
+                args = JSON.parse(active.jsonChunks.join(""));
+              } catch {
+              }
+              yield { type: "tool_use_end", id: active.id, arguments: args };
+            }
+          }
+          if (eventType === "message_start" && event.message?.usage) {
+            const usage = event.message.usage;
+            yield {
+              type: "usage",
+              promptTokens: usage.input_tokens ?? 0,
+              completionTokens: usage.output_tokens ?? 0
+            };
+          }
+          if (eventType === "message_delta") {
+            const delta = event.delta;
+            if (event.usage) {
+              const usage = event.usage;
+              yield {
+                type: "usage",
+                promptTokens: 0,
+                completionTokens: usage.output_tokens ?? 0
+              };
+            }
+            if (delta?.stop_reason === "tool_use") {
+              yield { type: "message_stop", finishReason: "tool_calls" };
+            } else if (delta?.stop_reason === "end_turn") {
+              yield { type: "message_stop", finishReason: "stop" };
+            } else if (delta?.stop_reason === "max_tokens") {
+              yield { type: "message_stop", finishReason: "length" };
+            } else if (delta?.stop_reason) {
+              yield { type: "message_stop", finishReason: "stop" };
+            }
+          }
+          if (eventType === "error") {
+            const errObj = event.error;
+            throw new Error(`Anthropic stream error: ${errObj?.message ?? "unknown"}`);
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+function createAnthropicProvider(options) {
+  return new AnthropicProvider(options);
+}
+
+// src/agent/types.ts
+function joinSplitPrompt(prompt) {
+  if (!prompt.suffix) return prompt.prefix;
+  return prompt.prefix + "\n\n" + prompt.suffix;
+}
+function stripMcpToolPrefix(name) {
+  return name.replace(/^mcp__[a-zA-Z0-9_-]+__/, "");
+}
+
+// src/agent/providers/openai-compat.ts
+var OpenAICompatProvider = class {
+  apiKey;
+  model;
+  maxTokens;
+  baseUrl;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("OpenAICompatProvider requires an API key");
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? "gpt-4o";
+    this.maxTokens = options.maxTokens ?? 4096;
+    this.baseUrl = (options.baseUrl ?? "https://api.openai.com").replace(/\/+$/, "");
+  }
+  async *stream(messages, tools, options) {
+    const model = options?.model ?? this.model;
+    const maxTokens = options?.maxTokens ?? this.maxTokens;
+    const apiMessages = messages.map((m) => formatMessage(m));
+    const apiTools = tools.length > 0 ? tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }
+    })) : void 0;
+    const body = {
+      model,
+      messages: [
+        ...options?.systemPrompt ? [{ role: "system", content: joinSplitPrompt(options.systemPrompt) }] : [],
+        ...apiMessages
+      ],
+      max_tokens: maxTokens,
+      stream: true,
+      // Without this OpenAI sends no usage on a stream, and token totals stay 0.
+      stream_options: { include_usage: true }
+    };
+    if (apiTools && apiTools.length > 0) {
+      body.tools = apiTools;
+    }
+    const response = await fetch(completionsUrl(this.baseUrl), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      yield { type: "text_delta", text: `OpenAI API error ${response.status}: ${errText.slice(0, 300)}` };
+      yield { type: "message_stop", finishReason: "error" };
+      return;
+    }
+    if (!response.body) {
+      yield { type: "message_stop", finishReason: "error" };
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let hasToolCalls = false;
+    const activeToolCalls = /* @__PURE__ */ new Map();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") {
+            for (const [, tc] of activeToolCalls) {
+              let args = {};
+              try {
+                args = JSON.parse(tc.argsJson);
+              } catch {
+              }
+              yield { type: "tool_use_end", id: tc.id, arguments: args };
+            }
+            yield { type: "message_stop", finishReason: hasToolCalls ? "tool_calls" : "stop" };
+            return;
+          }
+          let parsed;
+          try {
+            parsed = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (parsed.usage) {
+            const usage = parsed.usage;
+            yield {
+              type: "usage",
+              promptTokens: usage.prompt_tokens ?? 0,
+              completionTokens: usage.completion_tokens ?? 0
+            };
+          }
+          const choices = parsed.choices;
+          if (!choices || choices.length === 0) continue;
+          const choice = choices[0];
+          const delta = choice.delta;
+          if (!delta) continue;
+          if (delta.content && typeof delta.content === "string") {
+            yield { type: "text_delta", text: delta.content };
+          }
+          const toolCalls = delta.tool_calls;
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              const index = tc.index ?? 0;
+              const fn = tc.function;
+              if (tc.id) {
+                hasToolCalls = true;
+                const name = fn?.name ? String(fn.name) : "unknown";
+                activeToolCalls.set(index, { id: String(tc.id), name, argsJson: "" });
+                yield { type: "tool_use_start", id: String(tc.id), name };
+              }
+              if (fn?.arguments && typeof fn.arguments === "string") {
+                const existing = activeToolCalls.get(index);
+                if (existing) {
+                  existing.argsJson += fn.arguments;
+                  yield { type: "tool_use_delta", id: existing.id, partialJson: fn.arguments };
+                }
+              }
+            }
+          }
+          if (choice.finish_reason === "tool_calls") {
+            hasToolCalls = true;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    for (const [, tc] of activeToolCalls) {
+      let args = {};
+      try {
+        args = JSON.parse(tc.argsJson);
+      } catch {
+      }
+      yield { type: "tool_use_end", id: tc.id, arguments: args };
+    }
+    yield { type: "message_stop", finishReason: hasToolCalls ? "tool_calls" : "stop" };
+  }
+};
+function completionsUrl(baseUrl) {
+  const base = baseUrl.replace(/\/+$/, "");
+  return /\/v\d+$/.test(base) ? `${base}/chat/completions` : `${base}/v1/chat/completions`;
+}
+function formatMessage(m) {
+  if (m.role === "tool") {
+    return {
+      role: "tool",
+      tool_call_id: m.toolCallId,
+      content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+    };
+  }
+  if (m.role === "assistant" && m.toolCalls?.length) {
+    return {
+      role: "assistant",
+      content: typeof m.content === "string" && m.content ? m.content : null,
+      tool_calls: m.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+      }))
+    };
+  }
+  return {
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+  };
+}
+function createOpenAICompatProvider(options) {
+  return new OpenAICompatProvider(options);
+}
+
+// src/agent/providers/claude-cli.ts
+import { spawn as nodeSpawn } from "node:child_process";
+
+// src/agent/streaming.ts
+var StreamJsonParser = class {
+  constructor(pushEvent) {
+    this.pushEvent = pushEvent;
+  }
+  pushEvent;
+  hasAssistantText = false;
+  insideToolUse = false;
+  activeToolJsonChunks = /* @__PURE__ */ new Map();
+  /** Reset per-turn state. Call before starting a new turn in persistent sessions. */
+  reset() {
+    this.hasAssistantText = false;
+    this.insideToolUse = false;
+    this.activeToolJsonChunks.clear();
+  }
+  /** Whether any text_delta events have been emitted this turn. */
+  get hasText() {
+    return this.hasAssistantText;
+  }
+  /**
+   * Feed a single NDJSON line (without trailing newline).
+   * Parses and emits StreamEvent(s) via the callback.
+   */
+  feed(line) {
+    if (!line.trim()) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      if (line.trim() && !this.hasAssistantText) {
+        this.pushEvent({ type: "text_delta", text: line });
+      }
+      return;
+    }
+    if (event.type === "stream_event" && event.event) {
+      event = event.event;
+    }
+    this.processEvent(event);
+  }
+  processEvent(event) {
+    const block = event.content_block;
+    const delta = event.delta;
+    if (event.type === "content_block_start" && block?.type === "tool_use") {
+      this.insideToolUse = true;
+      const id = block.id || `cli-tool-${Date.now()}`;
+      const name = block.name || "unknown";
+      this.pushEvent({ type: "tool_use_start", id, name });
+      this.activeToolJsonChunks.set(id, { name, chunks: [] });
+      return;
+    }
+    if (event.type === "content_block_start" && block?.type === "text") {
+      this.insideToolUse = false;
+      return;
+    }
+    if (event.type === "content_block_delta" && delta?.type === "input_json_delta") {
+      const lastTool = [...this.activeToolJsonChunks.entries()].pop();
+      if (lastTool) lastTool[1].chunks.push(delta.partial_json || "");
+      return;
+    }
+    if (event.type === "content_block_delta" && delta?.type === "thinking_delta" && delta?.thinking) {
+      this.pushEvent({ type: "thinking_delta", text: delta.thinking });
+      return;
+    }
+    if (event.type === "content_block_delta" && delta?.text && !this.insideToolUse) {
+      this.hasAssistantText = true;
+      this.pushEvent({ type: "text_delta", text: delta.text });
+      return;
+    }
+    if (event.type === "content_block_stop" && this.insideToolUse) {
+      const lastTool = [...this.activeToolJsonChunks.entries()].pop();
+      if (lastTool) {
+        const [id, { chunks }] = lastTool;
+        let args = {};
+        try {
+          args = JSON.parse(chunks.join(""));
+        } catch {
+        }
+        this.pushEvent({ type: "tool_use_end", id, arguments: args });
+        this.activeToolJsonChunks.delete(id);
+      }
+      this.insideToolUse = false;
+      return;
+    }
+    if (event.type === "user" && event.message?.content) {
+      const content = event.message.content;
+      for (const contentBlock of content) {
+        if (contentBlock.type === "tool_result" && contentBlock.tool_use_id) {
+          const text = Array.isArray(contentBlock.content) ? contentBlock.content.map((c) => c.text || "").join("") : String(contentBlock.content || "");
+          this.pushEvent({
+            type: "tool_result",
+            id: contentBlock.tool_use_id,
+            result: text,
+            isError: !!contentBlock.is_error
+          });
+        }
+      }
+      return;
+    }
+    if (event.type === "message_start" && event.message?.usage) {
+      const usage = event.message.usage;
+      this.pushEvent({
+        type: "usage",
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0
+      });
+      return;
+    }
+    if (event.type === "message_delta" && event.usage) {
+      const usage = event.usage;
+      this.pushEvent({
+        type: "usage",
+        promptTokens: 0,
+        completionTokens: usage.output_tokens ?? 0
+      });
+      return;
+    }
+    if (event.type === "message_stop") {
+      this.pushEvent({ type: "message_stop", finishReason: "stop" });
+      return;
+    }
+    if (event.type === "result") {
+      if (event.is_error) {
+        this.pushEvent({ type: "message_stop", finishReason: "error" });
+        return;
+      }
+      if (event.result && !this.hasAssistantText) {
+        this.pushEvent({ type: "text_delta", text: event.result });
+      }
+      if (event.usage) {
+        const usage = event.usage;
+        this.pushEvent({
+          type: "usage",
+          promptTokens: usage.input_tokens ?? 0,
+          completionTokens: usage.output_tokens ?? 0,
+          cacheReadTokens: usage.cache_read_input_tokens ?? void 0,
+          cacheCreationTokens: usage.cache_creation_input_tokens ?? void 0,
+          costUsd: typeof event.total_cost_usd === "number" ? event.total_cost_usd : void 0
+        });
+      }
+      this.pushEvent({ type: "message_stop", finishReason: "stop" });
+      return;
+    }
+    if (event.type === "assistant") {
+      if (event.error === "authentication_failed") {
+        this.pushEvent({ type: "message_stop", finishReason: "error" });
+      }
+    }
+  }
+};
+
+// src/agent/mcp-bridge.ts
+import * as net from "node:net";
+import * as fs3 from "node:fs";
+import * as path7 from "node:path";
+import * as os4 from "node:os";
+import { fileURLToPath } from "node:url";
+async function createMcpBridge(tools, executor, onToolEvent, logger) {
+  const tmpDir = fs3.mkdtempSync(path7.join(os4.tmpdir(), "fw-mcp-bridge-"));
+  fs3.chmodSync(tmpDir, 448);
+  const socketPath = path7.join(tmpDir, "bridge.sock");
+  const defsPath = path7.join(tmpDir, "tools.json");
+  const configPath = path7.join(tmpDir, "mcp-config.json");
+  const mcpToolDefs = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema
+  }));
+  fs3.writeFileSync(defsPath, JSON.stringify(mcpToolDefs), "utf-8");
+  const __dirname = path7.dirname(fileURLToPath(import.meta.url));
+  const jsPath = path7.resolve(__dirname, "mcp-tool-server.js");
+  const tsPath = path7.resolve(__dirname, "mcp-tool-server.ts");
+  const scriptPath = fs3.existsSync(jsPath) ? jsPath : tsPath;
+  const mcpCommand = process.execPath;
+  let mcpArgs = [scriptPath];
+  if (scriptPath.endsWith(".ts")) {
+    const tsxCli = path7.resolve(__dirname, "../../node_modules/tsx/dist/cli.mjs");
+    if (fs3.existsSync(tsxCli)) {
+      mcpArgs = [tsxCli, scriptPath];
+    }
+  }
+  const mcpConfig = {
+    mcpServers: {
+      "fw-agent": {
+        type: "stdio",
+        command: mcpCommand,
+        args: mcpArgs,
+        env: {
+          FW_TOOL_SOCKET: socketPath,
+          FW_TOOL_DEFS: defsPath
+        }
+      }
+    }
+  };
+  fs3.writeFileSync(configPath, JSON.stringify(mcpConfig), "utf-8");
+  let currentExecutor = executor;
+  let currentOnToolEvent = onToolEvent;
+  const answer = async (line) => {
+    try {
+      const { name, args } = JSON.parse(line);
+      currentOnToolEvent?.({ type: "tool_call_start", name, args });
+      const { result, isError } = await currentExecutor(name, args);
+      currentOnToolEvent?.({ type: "tool_call_result", name, result, isError });
+      return JSON.stringify({ result, isError });
+    } catch (err) {
+      const msg = getErrorMessage(err);
+      try {
+        logger?.error("MCP bridge tool execution error", err);
+      } catch {
+      }
+      return JSON.stringify({ result: msg, isError: true });
+    }
+  };
+  const server = net.createServer((conn) => {
+    let buf = "";
+    conn.on("data", (chunk) => {
+      buf += chunk.toString();
+      const nlIdx = buf.indexOf("\n");
+      if (nlIdx === -1) return;
+      const line = buf.slice(0, nlIdx).trim();
+      buf = "";
+      answer(line).then((reply) => conn.end(reply)).catch(() => conn.destroy());
+    });
+  });
+  await new Promise((resolve6, reject) => {
+    server.on("error", reject);
+    server.listen(socketPath, () => resolve6());
+  });
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    server.close();
+    try {
+      fs3.unlinkSync(socketPath);
+    } catch {
+    }
+    try {
+      fs3.unlinkSync(defsPath);
+    } catch {
+    }
+    try {
+      fs3.unlinkSync(configPath);
+    } catch {
+    }
+    try {
+      fs3.rmdirSync(tmpDir);
+    } catch {
+    }
+  };
+  const setHandlers = (exec, onEvt) => {
+    currentExecutor = exec;
+    currentOnToolEvent = onEvt;
+  };
+  return { configPath, setHandlers, cleanup };
+}
+
+// src/agent/providers/claude-cli.ts
+var ClaudeCliProvider = class {
+  binPath;
+  cwd;
+  env;
+  model;
+  mcpConfigPath;
+  spawnFn;
+  timeout;
+  disallowedTools;
+  allowedTools;
+  constructor(options = {}) {
+    this.binPath = options.binPath ?? "claude";
+    this.cwd = options.cwd ?? process.cwd();
+    this.env = options.env ?? process.env;
+    this.model = options.model;
+    this.mcpConfigPath = options.mcpConfigPath;
+    this.disallowedTools = options.disallowedTools ?? [];
+    this.allowedTools = options.allowedTools;
+    this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
+    this.timeout = options.timeout ?? 6e5;
+  }
+  async *stream(messages, tools, options) {
+    const model = options?.model ?? this.model;
+    const prompt = formatPrompt(messages);
+    const systemPrompt = options?.systemPrompt ? joinSplitPrompt(options.systemPrompt) : void 0;
+    let bridge = null;
+    let mcpConfigPath = this.mcpConfigPath;
+    if (tools.length > 0 && !mcpConfigPath) {
+      const executor = options?.executor ?? (async () => ({ result: "Tool executor not provided", isError: true }));
+      bridge = await createMcpBridge(
+        tools,
+        executor,
+        options?.onToolEvent
+      );
+      mcpConfigPath = bridge.configPath;
+    }
+    const args = [
+      "-p",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      "--include-partial-messages",
+      "--setting-sources",
+      "user,local",
+      "--dangerously-skip-permissions",
+      "--permission-mode",
+      "bypassPermissions",
+      ...systemPrompt ? ["--system-prompt", systemPrompt] : [],
+      ...mcpConfigPath ? ["--mcp-config", mcpConfigPath, "--strict-mcp-config"] : [],
+      ...this.disallowedTools.length > 0 ? ["--disallowed-tools", this.disallowedTools.join(" ")] : [],
+      ...this.allowedTools ? ["--allowed-tools", this.allowedTools.join(" ")] : [],
+      ...model ? ["--model", model] : []
+    ];
+    const spawnResult = this.spawnFn(
+      this.binPath,
+      args,
+      { cwd: this.cwd, stdio: ["pipe", "pipe", "pipe"], env: this.env }
+    );
+    const child = "child" in spawnResult ? spawnResult.child : spawnResult;
+    const spawnCleanup = "cleanup" in spawnResult ? spawnResult.cleanup : void 0;
+    const signal = options?.signal;
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (!child.killed) child.kill("SIGKILL");
+          }, 2e3);
+        },
+        { once: true }
+      );
+    }
+    const timeout = options?.timeout ?? this.timeout;
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+    }, timeout);
+    child.stdin.write(prompt);
+    child.stdin.end();
+    const events = [];
+    let done = false;
+    const parser = new StreamJsonParser((event) => {
+      events.push(event);
+    });
+    let stderrBuf = "";
+    child.stderr.on("data", (chunk) => {
+      stderrBuf += chunk.toString();
+    });
+    let stdoutBuffer = "";
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        parser.feed(line);
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (stdoutBuffer.trim()) {
+        parser.feed(stdoutBuffer);
+      }
+      if (code !== 0 && !parser.hasText && stderrBuf.trim()) {
+        events.push({ type: "text_delta", text: `Claude CLI error: ${stderrBuf.trim().slice(0, 500)}` });
+      }
+      if (!events.some((e) => e.type === "message_stop")) {
+        events.push({ type: "message_stop", finishReason: code === 0 ? "stop" : "error" });
+      }
+      done = true;
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      events.push({ type: "message_stop", finishReason: "error" });
+      done = true;
+    });
+    try {
+      while (!done || events.length > 0) {
+        if (events.length > 0) {
+          yield events.shift();
+        } else {
+          await new Promise((r) => setTimeout(r, 10));
+        }
+      }
+    } finally {
+      bridge?.cleanup();
+      spawnCleanup?.();
+    }
+  }
+};
+function formatPrompt(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      parts.push(`User: ${typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)}
+`);
+    } else if (msg.role === "assistant") {
+      parts.push(`Assistant: ${typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)}
+`);
+    } else if (msg.role === "tool") {
+      parts.push(`Tool result (${msg.toolCallId}): ${typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)}
+`);
+    }
+  }
+  return parts.join("\n");
+}
+function createClaudeCliProvider(options) {
+  return new ClaudeCliProvider(options);
+}
+
+// src/agent/gate.ts
+var SUBMIT_TOOL = "submit_answer";
+var REJECT_TOOL = "reject";
+function providerFor(profile, env = process.env, cwd) {
+  const ready = readiness(profile, env);
+  if (!ready.ready) throw new Error(`agent profile ${profile.name} is not ready: ${ready.reason}`);
+  const model = profile.model || DEFAULT_MODEL[profile.provider] || void 0;
+  switch (profile.provider) {
+    case "anthropic":
+      return createAnthropicProvider({ apiKey: env[keyEnvOf(profile)], model, baseUrl: profile.baseUrl, maxTokens: profile.maxTokens });
+    case "openai":
+      return createOpenAICompatProvider({ apiKey: env[keyEnvOf(profile)] ?? "none", model, baseUrl: profile.baseUrl, maxTokens: profile.maxTokens });
+    case "claude-cli":
+      return createClaudeCliProvider({ binPath: profile.bin, model: model || void 0, cwd, env, allowedTools: [] });
+  }
+}
+function fieldToJsonSchema(f) {
+  if (!f) return {};
+  switch (f.type) {
+    case "string":
+      return { type: "string" };
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "enum":
+      return { enum: f.values };
+    case "array":
+      return { type: "array", items: fieldToJsonSchema(f.items) };
+    case "object": {
+      if (!f.fields) return { type: "object", additionalProperties: true, ...f.text ? { description: f.text } : {} };
+      const properties = {};
+      const required = [];
+      for (const [k, v] of Object.entries(f.fields)) {
+        properties[k] = fieldToJsonSchema(v);
+        if (!v.optional) required.push(k);
+      }
+      return { type: "object", properties, ...required.length ? { required } : {}, additionalProperties: false };
+    }
+    // An `any` field accepts every value, so its schema carries only the
+    // description. A field type this function does not know is treated the same.
+    case "any":
+    default:
+      return f.text ? { description: f.text } : {};
+  }
+}
+function answerTool(gate) {
+  const schemaOf = (o) => gate.outputSchema?.[o] ?? void 0;
+  const describe = (o) => gate.outputTypes?.[o] ? ` (${gate.outputTypes[o]})` : "";
+  if (gate.outputs.length === 0) {
+    return { tool: { name: SUBMIT_TOOL, description: "Mark the task as done. It has no result to return.", inputSchema: { type: "object", properties: {} } }, unwrap: () => null };
+  }
+  if (gate.outputs.length === 1) {
+    const o = gate.outputs[0];
+    const s = schemaOf(o);
+    const isObject = !s || s.type === "object" || s.type === "any";
+    if (isObject) {
+      const js = fieldToJsonSchema(s ?? { type: "object" });
+      const properties2 = js.properties ?? {};
+      const inputSchema = { type: "object", properties: properties2, ...js.required ? { required: js.required } : {}, ...js.additionalProperties === void 0 ? { additionalProperties: true } : { additionalProperties: js.additionalProperties } };
+      return { tool: { name: SUBMIT_TOOL, description: `Return the result of the task: the value for \`${o}\`${describe(o)}.`, inputSchema }, unwrap: (args) => args };
+    }
+    return {
+      tool: { name: SUBMIT_TOOL, description: `Return the result of the task as \`value\`: the gate's \`${o}\`${describe(o)}.`, inputSchema: { type: "object", properties: { value: fieldToJsonSchema(s) }, required: ["value"] } },
+      unwrap: (args) => args.value
+    };
+  }
+  const properties = {};
+  for (const o of gate.outputs) properties[o] = { ...fieldToJsonSchema(schemaOf(o)), ...gate.outputTypes?.[o] ? { description: gate.outputTypes[o] } : {} };
+  return {
+    tool: { name: SUBMIT_TOOL, description: `Return the result of the task: one value per output (${gate.outputs.join(", ")}).`, inputSchema: { type: "object", properties, required: [...gate.outputs] } },
+    unwrap: (args) => Object.fromEntries(gate.outputs.map((o) => [o, args[o]]))
+  };
+}
+var rejectTool = {
+  name: REJECT_TOOL,
+  description: "Give the task up. The workflow continues along its failure path. Say why in one sentence.",
+  inputSchema: { type: "object", properties: { reason: { type: "string" } }, required: ["reason"] }
+};
+function systemPromptFor(profile, workflow, gate) {
+  const lines = [
+    profile.system?.trim() ?? "",
+    `You are completing one step of the workflow "${workflow.name}"${workflow.description ? ` (${workflow.description})` : ""}: the agent gate "${gate.node}".`,
+    "You receive the gate's inputs as JSON: `agentId` names the task, `context` is the material to work from, `prompt` is the instruction when there is one.",
+    `Do the task, then call \`${SUBMIT_TOOL}\` exactly once with the result.${gate.hasFailurePort ? ` If the task cannot be done from what you were given, call \`${REJECT_TOOL}\` with a short reason instead.` : ""}`,
+    "Only the tool call counts. Anything you write in prose is discarded."
+  ];
+  return lines.filter(Boolean).join("\n\n");
+}
+function userMessageFor(gate) {
+  const shown = { ...gate.inputs };
+  const parts = [`Inputs:
+${JSON.stringify(shown, null, 2)}`];
+  if (typeof gate.inputs.prompt === "string" && gate.inputs.prompt.trim()) parts.push(`Instruction:
+${gate.inputs.prompt}`);
+  parts.push(`When done, call ${SUBMIT_TOOL}.`);
+  return parts.join("\n\n");
+}
+async function tryProfile(profile, env = process.env, opts = {}) {
+  const started = Date.now();
+  let provider;
+  try {
+    provider = opts.provider ?? providerFor(profile, env, opts.cwd);
+  } catch (e) {
+    return { ok: false, ms: Date.now() - started, error: getErrorMessage(e) };
+  }
+  try {
+    const result = await runAgentLoop(provider, [], async () => ({ result: "", isError: true }), [{ role: "user", content: "Reply with the single word OK." }], {
+      systemPrompt: { prefix: profile.system?.trim() || "You are a terse assistant.", suffix: "" },
+      maxIterations: 1,
+      maxTokens: Math.min(profile.maxTokens ?? 64, 256),
+      model: profile.model || void 0,
+      signal: opts.signal
+    });
+    const text = result.summary.trim();
+    const usage = { promptTokens: result.usage.promptTokens, completionTokens: result.usage.completionTokens, ...result.usage.costUsd ? { costUsd: result.usage.costUsd } : {} };
+    if (!result.success) return { ok: false, ms: Date.now() - started, text, usage, error: text || "the provider returned an error" };
+    return { ok: true, ms: Date.now() - started, text, usage };
+  } catch (e) {
+    return { ok: false, ms: Date.now() - started, error: getErrorMessage(e) };
+  }
+}
+function answerFromText(text, gate) {
+  const m = text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+  if (!m) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(m[1]);
+  } catch {
+    return void 0;
+  }
+  if (gate.outputs.length > 1) {
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+    if (!gate.outputs.every((o) => o in parsed)) return void 0;
+    return Object.fromEntries(gate.outputs.map((o) => [o, parsed[o]]));
+  }
+  if (gate.outputs.length === 1) {
+    const s = gate.outputSchema?.[gate.outputs[0]];
+    const one = parsed;
+    if (s && s.type !== "object" && s.type !== "any" && typeof one === "object" && one !== null && gate.outputs[0] in one) return one[gate.outputs[0]];
+    return parsed;
+  }
+  return null;
+}
+async function answerGate(opts) {
+  const { gate, workflow, profile } = opts;
+  const env = opts.env ?? process.env;
+  const provider = opts.provider ?? providerFor(profile, env, opts.cwd);
+  const started = Date.now();
+  const emit = (e) => opts.onEvent?.(e);
+  emit({ type: "agent", phase: "start", profile: profile.name, provider: profile.provider, model: profile.model || DEFAULT_MODEL[profile.provider] || void 0 });
+  const { tool, unwrap } = answerTool(gate);
+  const tools = gate.hasFailurePort ? [tool, rejectTool] : [tool];
+  let captured;
+  let usage = { promptTokens: 0, completionTokens: 0 };
+  let text = "";
+  const executor = async (rawName, args) => {
+    const name = stripMcpToolPrefix(rawName);
+    if (name === SUBMIT_TOOL) {
+      captured = { kind: "answer", answer: unwrap(args ?? {}) };
+      return { result: "Recorded. You are done.", isError: false };
+    }
+    if (name === REJECT_TOOL && gate.hasFailurePort) {
+      captured = { kind: "reject", reason: typeof args?.reason === "string" && args.reason.trim() ? args.reason : "rejected by the agent" };
+      return { result: "Recorded. You are done.", isError: false };
+    }
+    return { result: `Unknown tool ${name}. Call ${SUBMIT_TOOL}${gate.hasFailurePort ? ` or ${REJECT_TOOL}` : ""}.`, isError: true };
+  };
+  const onStreamEvent = (ev) => {
+    if (ev.type === "text_delta") {
+      text += ev.text;
+      emit({ type: "agent", phase: "text", text: ev.text });
+    } else if (ev.type === "thinking_delta") emit({ type: "agent", phase: "thinking", text: ev.text });
+    else if (ev.type === "usage") emit({ type: "agent", phase: "usage", promptTokens: ev.promptTokens, completionTokens: ev.completionTokens, costUsd: ev.costUsd });
+  };
+  const onToolEvent = (ev) => {
+    emit({ type: "agent", phase: "tool", stage: ev.type === "tool_call_start" ? "start" : "result", name: stripMcpToolPrefix(ev.name), args: ev.args, result: ev.result, isError: ev.isError });
+  };
+  const system = { prefix: systemPromptFor(profile, workflow, gate), suffix: "" };
+  const messages = [{ role: "user", content: userMessageFor(gate) }];
+  const maxIterations = profile.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const run = async (conversation, iterations) => runAgentLoop(provider, tools, executor, conversation, {
+    systemPrompt: system,
+    maxIterations: iterations,
+    maxTokens: profile.maxTokens,
+    model: profile.model || void 0,
+    signal: opts.signal,
+    onStreamEvent,
+    onToolEvent,
+    // Once the answer is in hand there is nothing more to ask. Stop before
+    // another model turn is paid for.
+    onTurnEnd: async () => captured ? { continue: false } : void 0
+  });
+  let transcript = messages;
+  let toolCalls = 0;
+  try {
+    let result = await run(messages, maxIterations);
+    transcript = result.messages;
+    toolCalls = result.toolCallCount;
+    usage = { promptTokens: result.usage.promptTokens, completionTokens: result.usage.completionTokens, ...result.usage.costUsd ? { costUsd: result.usage.costUsd } : {} };
+    if (!captured && result.success && !opts.signal?.aborted) {
+      const nudged = [...result.messages, { role: "user", content: `You have not called ${SUBMIT_TOOL}. Call it now with your result${gate.hasFailurePort ? `, or ${REJECT_TOOL} if you cannot` : ""}.` }];
+      result = await run(nudged, 2);
+      transcript = result.messages;
+      toolCalls += result.toolCallCount;
+      usage = { promptTokens: usage.promptTokens + result.usage.promptTokens, completionTokens: usage.completionTokens + result.usage.completionTokens, ...usage.costUsd || result.usage.costUsd ? { costUsd: (usage.costUsd ?? 0) + (result.usage.costUsd ?? 0) } : {} };
+    }
+    if (!captured) {
+      const fromText = answerFromText(text, gate);
+      if (fromText !== void 0) captured = { kind: "answer", answer: fromText };
+    }
+    if (!captured) {
+      captured = { kind: "failed", error: opts.signal?.aborted ? "stopped before an answer was submitted" : result.success ? `the model did not call ${SUBMIT_TOOL}` : result.summary };
+    }
+  } catch (e) {
+    captured = { kind: "failed", error: getErrorMessage(e) };
+  }
+  const ms = Date.now() - started;
+  emit({ type: "agent", phase: "done", outcome: captured.kind, ms, ...captured.kind === "failed" ? { error: captured.error } : {}, ...captured.kind === "reject" ? { reason: captured.reason } : {} });
+  return { outcome: captured, usage, toolCalls, ms, transcript, text };
+}
+
+// src/coordinator/agent-gate.ts
+function transcriptName(gateId) {
+  return `agent-${gateId.slice(0, 16)}`;
+}
+var ANSWER_ABANDONED_AFTER_MS = 60 * 60 * 1e3;
+function agentOwnerDead(note, now = Date.now()) {
+  const age = now - Date.parse(note.startedAt);
+  if (!note.owner || note.owner.host !== os5.hostname()) return age > ANSWER_ABANDONED_AFTER_MS;
+  if (note.owner.pid === process.pid) return false;
+  try {
+    process.kill(note.owner.pid, 0);
+    return false;
+  } catch (e) {
+    return e.code === "ESRCH";
+  }
+}
+function isAnswering(note, gateId) {
+  return !!note && note.status === "answering" && note.gateId === gateId && !agentOwnerDead(note);
+}
+async function reclaimStaleAgentAnswers(coordinator) {
+  const reclaimed = [];
+  for (const s of await coordinator.list()) {
+    if (s.status !== "waiting" || s.agent?.status !== "answering") continue;
+    const rec = await coordinator.record(s.runId);
+    if (!rec?.agent || rec.agent.status !== "answering" || !agentOwnerDead(rec.agent)) continue;
+    try {
+      await coordinator.setAgent(s.runId, { ...rec.agent, status: "failed", endedAt: (/* @__PURE__ */ new Date()).toISOString(), error: "the process answering this gate ended before it could answer" });
+    } catch (e) {
+      if (e instanceof RunBusyError) continue;
+      throw e;
+    }
+    reclaimed.push(s.runId);
+  }
+  return reclaimed;
+}
+async function answerAgentGate(coordinator, runId, opts) {
+  const rec = await coordinator.record(runId);
+  if (!rec || rec.status !== "waiting" || !rec.gate) return { kind: "skip", why: "not-waiting" };
+  if (rec.gate.kind !== "agent") return { kind: "skip", why: "not-agent" };
+  if (rec.agents === "manual") return { kind: "skip", why: "manual" };
+  if (isAnswering(rec.agent, rec.gate.id)) return { kind: "skip", why: "already-answering" };
+  const env = opts.env ?? process.env;
+  const profiles = opts.profiles ?? loadAgentProfiles(opts.projectDir);
+  const profile = profileForGate(profiles, { workflow: rec.workflowName, node: rec.gate.node, agentId: rec.gate.inputs.agentId });
+  if (!profile) return { kind: "skip", why: "no-profile" };
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const model = profile.model || DEFAULT_MODEL[profile.provider] || void 0;
+  const base = { gateId: rec.gate.id, node: rec.gate.node, profile: profile.name, provider: profile.provider, model, status: "answering", startedAt, owner: { pid: process.pid, host: os5.hostname() } };
+  const ready = readiness(profile, env);
+  if (!ready.ready) {
+    const note2 = { ...base, status: "failed", endedAt: startedAt, error: ready.reason };
+    await coordinator.setAgent(runId, note2);
+    return { kind: "not-ready", profile: profile.name, reason: ready.reason ?? "not ready", note: note2 };
+  }
+  await coordinator.setAgent(runId, base);
+  const shape = await opts.outputSchema?.(rec);
+  const result = await answerGate({
+    gate: { node: rec.gate.node, inputs: rec.gate.inputs, absent: rec.gate.absent, outputs: rec.gate.outputs, hasFailurePort: rec.gate.hasFailurePort, outputSchema: shape?.schema ?? null, outputTypes: shape?.types },
+    workflow: { name: rec.workflowName, description: opts.workflowDescription?.(rec) },
+    profile,
+    provider: opts.provider?.(profile, env),
+    env,
+    cwd: opts.projectDir,
+    signal: opts.signal,
+    onEvent: opts.onEvent
+  });
+  const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const transcript = {
+    gateId: rec.gate.id,
+    node: rec.gate.node,
+    profile: profile.name,
+    provider: profile.provider,
+    model,
+    startedAt,
+    endedAt,
+    ms: result.ms,
+    outcome: result.outcome,
+    usage: result.usage,
+    toolCalls: result.toolCalls,
+    text: result.text,
+    messages: result.transcript
+  };
+  if (!await coordinator.record(runId)) return { kind: "skip", why: "not-waiting" };
+  await coordinator.keep(runId, transcriptName(rec.gate.id), transcript);
+  const done = { ...base, endedAt, usage: result.usage, toolCalls: result.toolCalls };
+  if (result.outcome.kind === "answer") {
+    const note2 = { ...done, status: "answered" };
+    await coordinator.setAgent(runId, note2);
+    return { kind: "answer", profile: profile.name, answer: result.outcome.answer, note: note2 };
+  }
+  if (result.outcome.kind === "reject") {
+    const note2 = { ...done, status: "rejected", error: result.outcome.reason };
+    await coordinator.setAgent(runId, note2);
+    return { kind: "reject", profile: profile.name, reason: result.outcome.reason, note: note2 };
+  }
+  const note = { ...done, status: "failed", error: result.outcome.error };
+  await coordinator.setAgent(runId, note);
+  return { kind: "failed", profile: profile.name, error: result.outcome.error, note };
+}
+async function noteAnswerMisfit(coordinator, runId, error) {
+  if (!(error instanceof MissingOutputsError || error instanceof InvalidAnswerError)) return false;
+  const agent = (await coordinator.record(runId))?.agent;
+  if (!agent) return false;
+  try {
+    await coordinator.setAgent(runId, { ...agent, status: "failed", error: `the answer did not fit the gate: ${error.message}` });
+  } catch (e) {
+    if (!(e instanceof RunBusyError)) throw e;
+  }
+  return true;
+}
+
+export {
+  RunBusyError,
+  defaultRunsDir,
+  computeBundleDigest,
+  createFileEffectAdapter,
+  ParseError,
+  AmbiguousWorkflowError,
+  RunNotFoundError,
+  RunNotWaitingError,
+  BundleChangedError,
+  MissingOutputsError,
+  InvalidAnswerError,
+  createLocalCoordinator,
+  tryProfile,
+  transcriptName,
+  isAnswering,
+  reclaimStaleAgentAnswers,
+  answerAgentGate,
+  noteAnswerMisfit
+};