@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-VO4QXG2X.js

@@ -0,0 +1,1016 @@
+import {
+  ContinuationRefusalError,
+  executeWorkflow
+} from "./chunk-JQTF4R5L.js";
+import {
+  DEFAULT_MODEL,
+  answerGate,
+  loadAgentProfiles,
+  profileForGate,
+  readiness
+} from "./chunk-Q6MDDZMT.js";
+import {
+  compileExecutableWorkflowArtifact
+} from "./chunk-6PNJORFL.js";
+import {
+  parseDuration
+} from "./chunk-DIAA66GL.js";
+import {
+  isMultipleWorkflows,
+  parseWorkflow
+} from "./chunk-INDEVYEC.js";
+import {
+  validateWireValue
+} from "./chunk-O2U2LO57.js";
+import {
+  getErrorMessage
+} from "./chunk-DUO6H5PR.js";
+
+// 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 fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+function samePath(a, b) {
+  const norm = (p) => {
+    const resolved = path.resolve(p).split(path.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 path.join(rootDir, runId);
+  };
+  const recordFile = (runId) => path.join(runDir(runId), "run.json");
+  const claimFile = (runId) => path.join(runDir(runId), "claim.json");
+  const docFile = (runId, name) => {
+    checkDocName(name);
+    if (name.startsWith(EFFECT_DOC_PREFIX)) return path.join(runDir(runId), "effects", `${name.slice(EFFECT_DOC_PREFIX.length)}.json`);
+    return path.join(runDir(runId), `${name}.json`);
+  };
+  const readJson = (file) => {
+    if (!fs.existsSync(file)) return void 0;
+    try {
+      return JSON.parse(fs.readFileSync(file, "utf8"));
+    } catch {
+      return void 0;
+    }
+  };
+  const writeAtomic = (file, data) => {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${randomUUID()}`;
+    fs.writeFileSync(tmp, JSON.stringify(data));
+    fs.renameSync(tmp, file);
+  };
+  const standing = (c) => {
+    if (!c) return false;
+    if (Date.parse(c.expiresAt) <= Date.now()) return false;
+    if (c.host !== os.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 (!fs.existsSync(rootDir)) return [];
+      const wanted = filter.filePath ? path.resolve(filter.filePath) : void 0;
+      const records = [];
+      for (const entry of fs.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) {
+      fs.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) {
+      fs.rmSync(docFile(runId, name), { force: true });
+    },
+    async claim(runId, owner, ttlMs) {
+      const file = claimFile(runId);
+      const mine = { owner, pid: process.pid, host: os.hostname(), expiresAt: new Date(Date.now() + ttlMs).toISOString() };
+      fs.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 {
+            fs.renameSync(file, aside);
+          } catch (e) {
+            if (e.code !== "ENOENT") throw e;
+            continue;
+          }
+          fs.rmSync(aside, { force: true });
+        }
+        try {
+          fs.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) fs.rmSync(file, { force: true });
+    }
+  };
+}
+
+// src/coordinator/runs-dir.ts
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+function resolveProjectRoot(anchor) {
+  let current;
+  try {
+    current = fs2.statSync(anchor).isDirectory() ? path2.resolve(anchor) : path2.dirname(path2.resolve(anchor));
+  } catch {
+    current = path2.dirname(path2.resolve(anchor));
+  }
+  const root = path2.parse(current).root;
+  for (let dir = current; ; dir = path2.dirname(dir)) {
+    if (fs2.existsSync(path2.join(dir, "package.json")) || fs2.existsSync(path2.join(dir, ".fw"))) {
+      return dir;
+    }
+    if (dir === root || path2.dirname(dir) === dir) break;
+  }
+  return current;
+}
+function defaultRunsDir(anchor) {
+  if (process.env.FW_RUNS_DIR) return process.env.FW_RUNS_DIR;
+  if (anchor) return path2.join(resolveProjectRoot(anchor), ".fw", "runs");
+  return path2.join(os2.homedir(), ".fw", "runs");
+}
+
+// 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";
+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/params.ts
+function missingParams(ast, params) {
+  const given = params ?? {};
+  return Object.entries(ast.startPorts ?? {}).filter(([name, port]) => name !== "execute" && port.dataType !== "STEP" && !port.optional && port.defaultValue === void 0 && (!Object.hasOwn(given, name) || given[name] === void 0)).map(([name]) => name);
+}
+var MissingParamsError = class extends Error {
+  constructor(workflowName, missing) {
+    super(`${workflowName} needs ${missing.length === 1 ? "a parameter" : "parameters"} it was not given: ${missing.join(", ")}`);
+    this.workflowName = workflowName;
+    this.missing = missing;
+  }
+  workflowName;
+  missing;
+  name = "MissingParamsError";
+};
+
+// 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/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 os4 from "node:os";
+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 !== os4.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: os4.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;
+}
+async function autoAnswerAgentGates(coordinator, runId, opts) {
+  const max = opts.maxChain ?? 20;
+  for (let i = 0; i < max; i++) {
+    const view = await coordinator.get(runId);
+    if (!view) throw new Error(`no run with id ${runId}`);
+    if (view.status !== "waiting") return { stop: view.status, run: view };
+    const step = await answerAgentGate(coordinator, runId, opts);
+    const now = async () => await coordinator.get(runId) ?? view;
+    if (step.kind === "skip") {
+      const stop = step.why === "manual" ? "manual" : step.why === "no-profile" ? "no-profile" : step.why === "not-agent" ? "waiting-human" : step.why === "not-waiting" ? (await now()).status : "waiting-human";
+      return { stop, run: await now() };
+    }
+    if (step.kind === "not-ready") return { stop: "not-ready", run: await now() };
+    if (step.kind === "failed") return { stop: "agent-failed", run: await now() };
+    try {
+      await coordinator.resume({ runId, input: step.kind === "answer" ? { answer: step.answer } : { reject: step.reason } }, opts.drive);
+    } catch (e) {
+      if (await noteAnswerMisfit(coordinator, runId, e)) return { stop: "agent-failed", run: await now() };
+      throw e;
+    }
+  }
+  return { stop: "chain-limit", run: await coordinator.get(runId) };
+}
+
+// src/coordinator/memory-store.ts
+function createMemoryRunStore() {
+  const records = /* @__PURE__ */ new Map();
+  const docs = /* @__PURE__ */ new Map();
+  const claims = /* @__PURE__ */ new Map();
+  const copy = (v) => v === void 0 ? v : structuredClone(v);
+  const docsOf = (runId) => docs.get(runId) ?? docs.set(runId, /* @__PURE__ */ new Map()).get(runId);
+  return {
+    async get(runId) {
+      return copy(records.get(runId));
+    },
+    async put(record) {
+      records.set(record.runId, copy(record));
+    },
+    async list(filter = {}) {
+      return [...records.values()].filter((r) => !filter.filePath || r.filePath === filter.filePath).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map(copy);
+    },
+    async remove(runId) {
+      records.delete(runId);
+      docs.delete(runId);
+      claims.delete(runId);
+    },
+    async getDoc(runId, name) {
+      checkDocName(name);
+      return copy(docs.get(runId)?.get(name));
+    },
+    async putDoc(runId, name, data) {
+      checkDocName(name);
+      docsOf(runId).set(name, copy(data));
+    },
+    async deleteDoc(runId, name) {
+      checkDocName(name);
+      docs.get(runId)?.delete(name);
+    },
+    async claim(runId, owner, ttlMs) {
+      const c = claims.get(runId);
+      if (c && c.until > Date.now() && c.owner !== owner) return false;
+      claims.set(runId, { owner, until: Date.now() + ttlMs });
+      return true;
+    },
+    async release(runId, owner) {
+      if (claims.get(runId)?.owner === owner) claims.delete(runId);
+    }
+  };
+}
+
+export {
+  DOC_NAME,
+  RESERVED_DOCS,
+  EFFECT_DOC_PREFIX,
+  checkDocName,
+  RunBusyError,
+  createFileRunStore,
+  resolveProjectRoot,
+  defaultRunsDir,
+  computeBundleDigest,
+  createStoreEffectAdapter,
+  createFileEffectAdapter,
+  missingParams,
+  MissingParamsError,
+  labelGate,
+  dueFor,
+  ParseError,
+  AmbiguousWorkflowError,
+  RunNotFoundError,
+  RunNotWaitingError,
+  BundleChangedError,
+  MissingOutputsError,
+  InvalidAnswerError,
+  buildGateResolution,
+  createLocalCoordinator,
+  transcriptName,
+  agentOwnerDead,
+  isAnswering,
+  reclaimStaleAgentAnswers,
+  answerAgentGate,
+  noteAnswerMisfit,
+  autoAnswerAgentGates,
+  createMemoryRunStore
+};