botmux-workflow-core 3.10.0

package/dist/cjs/schema.cjs

@@ -0,0 +1,1190 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/workflow-core/src/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  DEFAULT_HUMAN_GATE_OPTIONS: () => DEFAULT_HUMAN_GATE_OPTIONS,
+  DEFAULT_NODE_TIMEOUT_SEC: () => DEFAULT_NODE_TIMEOUT_SEC,
+  DEFAULT_REVISIT_BUDGET_PER_PAIR: () => DEFAULT_REVISIT_BUDGET_PER_PAIR,
+  DEFAULT_REVISIT_BUDGET_PER_RUN: () => DEFAULT_REVISIT_BUDGET_PER_RUN,
+  DagValidationError: () => DagValidationError,
+  MAX_HUMAN_GATE_OPTIONS: () => MAX_HUMAN_GATE_OPTIONS,
+  MAX_HUMAN_GATE_OPTION_LENGTH: () => MAX_HUMAN_GATE_OPTION_LENGTH,
+  MAX_LOOP_ITERATIONS: () => MAX_LOOP_ITERATIONS,
+  MAX_NODE_TIMEOUT_SEC: () => MAX_NODE_TIMEOUT_SEC,
+  MAX_OVERRIDE_MODEL_LENGTH: () => MAX_OVERRIDE_MODEL_LENGTH,
+  MAX_OVERRIDE_SYSTEM_PROMPT_APPEND: () => MAX_OVERRIDE_SYSTEM_PROMPT_APPEND,
+  NODE_KINDS: () => NODE_KINDS,
+  RESULT_ENUM_MAX_VALUES: () => RESULT_ENUM_MAX_VALUES,
+  RESULT_ENUM_MAX_VALUE_LENGTH: () => RESULT_ENUM_MAX_VALUE_LENGTH,
+  RESULT_SCHEMA_MAX_BYTES: () => RESULT_SCHEMA_MAX_BYTES,
+  RESULT_SCHEMA_MAX_PROPERTIES: () => RESULT_SCHEMA_MAX_PROPERTIES,
+  V3_DAG_SEGMENT_RE: () => V3_DAG_SEGMENT_RE,
+  V3_HOST_EXECUTORS: () => V3_HOST_EXECUTORS,
+  isGoalNode: () => isGoalNode,
+  isHostNode: () => isHostNode,
+  isLoopNode: () => isLoopNode,
+  loopInstanceId: () => loopInstanceId,
+  topologicalOrder: () => topologicalOrder,
+  validateDag: () => validateDag
+});
+module.exports = __toCommonJS(schema_exports);
+
+// src/workflows/v3/host-bindings.ts
+var V3HostBindingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "V3HostBindingError";
+  }
+};
+var RESULT_MARKER = ".result.";
+var PATH_SEGMENT_RE = /^[A-Za-z0-9_-]+$/;
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var STRING_MARKER_SOURCE = "\\$\\{([^{}]+)\\}";
+var stringMarkerRe = () => new RegExp(STRING_MARKER_SOURCE, "g");
+function parseV3HostBindingRef(ref) {
+  if (ref.startsWith("params.")) {
+    return { kind: "params", path: parsePath(ref.slice("params.".length), ref) };
+  }
+  if (ref.startsWith("context.")) {
+    return { kind: "context", path: parsePath(ref.slice("context.".length), ref) };
+  }
+  const resultAt = ref.indexOf(RESULT_MARKER);
+  if (resultAt <= 0) {
+    throw new V3HostBindingError(
+      `unsupported host binding ${JSON.stringify(ref)}; expected params.<path>, context.<path>, or <nodeId>.result.<path>`
+    );
+  }
+  const nodeId = ref.slice(0, resultAt);
+  if (!/^[A-Za-z0-9._-]+$/.test(nodeId)) {
+    throw new V3HostBindingError(`host binding ${JSON.stringify(ref)} has an invalid node id`);
+  }
+  return {
+    kind: "result",
+    nodeId,
+    path: parsePath(ref.slice(resultAt + RESULT_MARKER.length), ref)
+  };
+}
+function parsePath(raw, ref) {
+  if (!raw) throw new V3HostBindingError(`host binding ${JSON.stringify(ref)} has an empty path`);
+  const path = raw.split(".");
+  for (const segment of path) {
+    if (!PATH_SEGMENT_RE.test(segment) || FORBIDDEN_SEGMENTS.has(segment)) {
+      throw new V3HostBindingError(
+        `host binding ${JSON.stringify(ref)} has unsafe/invalid path segment ${JSON.stringify(segment)}`
+      );
+    }
+  }
+  return path;
+}
+function isExactRefObject(value) {
+  if (!isRecord(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 1 && keys[0] === "$ref" && typeof value.$ref === "string";
+}
+function collectV3HostBindingRefs(template) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (raw) => {
+    const parsed = parseV3HostBindingRef(raw);
+    const key = JSON.stringify(parsed);
+    if (!seen.has(key)) {
+      seen.add(key);
+      refs.push(parsed);
+    }
+  };
+  const walk = (value, path) => {
+    if (typeof value === "string") {
+      if (!value.includes("${")) return;
+      const covered = new Array(value.length).fill(false);
+      const markerRe = stringMarkerRe();
+      for (let match = markerRe.exec(value); match; match = markerRe.exec(value)) {
+        add(match[1]);
+        for (let i = match.index; i < match.index + match[0].length; i++) covered[i] = true;
+      }
+      for (let i = value.indexOf("${"); i >= 0; i = value.indexOf("${", i + 2)) {
+        if (!covered[i]) throw new V3HostBindingError(`malformed host binding marker at ${path}`);
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((child, index) => walk(child, `${path}[${index}]`));
+      return;
+    }
+    if (!isRecord(value)) {
+      if (value === null || typeof value === "number" || typeof value === "boolean") return;
+      throw new V3HostBindingError(`host input at ${path} must be finite JSON`);
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "$ref")) {
+      if (!isExactRefObject(value)) {
+        throw new V3HostBindingError(
+          `host input at ${path} must use $ref as the exact object { "$ref": "..." }`
+        );
+      }
+      add(value.$ref);
+      return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+      if (FORBIDDEN_SEGMENTS.has(key)) {
+        throw new V3HostBindingError(`host input at ${path} uses forbidden key ${JSON.stringify(key)}`);
+      }
+      walk(child, `${path}.${key}`);
+    }
+  };
+  walk(template, "input");
+  return refs;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/workflows/v3/dag.ts
+var NODE_KINDS = ["goal", "host", "loop"];
+var V3_HOST_EXECUTORS = ["feishu-send", "feishu-reply", "botmux-schedule"];
+var DEFAULT_NODE_TIMEOUT_SEC = 1800;
+var MAX_NODE_TIMEOUT_SEC = 14400;
+var DEFAULT_HUMAN_GATE_OPTIONS = ["approve", "reject"];
+var MAX_HUMAN_GATE_OPTIONS = 8;
+var MAX_HUMAN_GATE_OPTION_LENGTH = 32;
+var MAX_OVERRIDE_MODEL_LENGTH = 64;
+var MAX_OVERRIDE_SYSTEM_PROMPT_APPEND = 8e3;
+var RESULT_FIELD_TYPES = ["string", "number", "boolean", "array", "object"];
+var RESULT_SCHEMA_MAX_PROPERTIES = 32;
+var RESULT_SCHEMA_MAX_BYTES = 4096;
+var RESULT_ENUM_MAX_VALUES = 16;
+var RESULT_ENUM_MAX_VALUE_LENGTH = 64;
+var MAX_LOOP_ITERATIONS = 20;
+var DEFAULT_REVISIT_BUDGET_PER_PAIR = 1;
+var DEFAULT_REVISIT_BUDGET_PER_RUN = 8;
+var LOOP_WHEN_OPERATORS = ["equals", "notEquals", "gt", "gte", "lt", "lte"];
+function isGoalNode(node) {
+  return node.type === "goal" && typeof node.goal === "string" && node.goal.length > 0;
+}
+function isHostNode(node) {
+  return node.type === "host" && typeof node.executor === "string" && V3_HOST_EXECUTORS.includes(node.executor) && node.humanGate !== null;
+}
+function isLoopNode(node) {
+  return node.type === "loop";
+}
+function loopInstanceId(loopId, iteration, bodyNodeId) {
+  return `${loopId}.i${String(iteration).padStart(3, "0")}.${bodyNodeId}`;
+}
+var DagValidationError = class extends Error {
+  constructor(problems) {
+    super(`Invalid v3 dag.json:
+  - ${problems.join("\n  - ")}`);
+    this.problems = problems;
+    this.name = "DagValidationError";
+  }
+  problems;
+};
+var V3_DAG_SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
+var SEGMENT_RE = V3_DAG_SEGMENT_RE;
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateDag(raw) {
+  const problems = [];
+  if (!isObject(raw)) {
+    throw new DagValidationError(["root must be a JSON object"]);
+  }
+  if (typeof raw.runId !== "string" || !SEGMENT_RE.test(raw.runId)) {
+    problems.push(`runId must be a path-safe string matching ${SEGMENT_RE} (got ${JSON.stringify(raw.runId)})`);
+  }
+  if (!Array.isArray(raw.nodes) || raw.nodes.length === 0) {
+    throw new DagValidationError([...problems, "nodes must be a non-empty array"]);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const nodes = [];
+  const pendingWhens = [];
+  for (let i = 0; i < raw.nodes.length; i++) {
+    const n = raw.nodes[i];
+    const where = `nodes[${i}]`;
+    if (!isObject(n)) {
+      problems.push(`${where} must be an object`);
+      continue;
+    }
+    const id = n.id;
+    if (typeof id !== "string" || !SEGMENT_RE.test(id)) {
+      problems.push(`${where}.id must be a path-safe string matching ${SEGMENT_RE} (got ${JSON.stringify(id)})`);
+      continue;
+    }
+    if (ids.has(id)) {
+      problems.push(`duplicate node id "${id}"`);
+      continue;
+    }
+    ids.add(id);
+    const type = n.type;
+    if (type !== "goal" && type !== "host" && type !== "loop") {
+      problems.push(`node "${id}".type must be one of ${NODE_KINDS.join(" | ")} (got ${JSON.stringify(type)})`);
+      continue;
+    }
+    const depends = normDepends(n.depends, `node "${id}"`, problems, { ownerId: id, list: pendingWhens });
+    const fromList = depends.map((d) => d.from);
+    if (fromList.includes(id)) problems.push(`node "${id}" depends on itself`);
+    if (new Set(fromList).size !== fromList.length) problems.push(`node "${id}".depends has duplicates`);
+    const triggerRule = normTriggerRule(n.triggerRule, depends.length, `node "${id}"`, problems);
+    const inputs = normInputs(n.inputs, id, problems);
+    if (type === "loop") {
+      const loopFields = normLoopFields(n, id, problems);
+      if (loopFields) {
+        nodes.push({
+          id,
+          type,
+          goal: typeof n.goal === "string" ? n.goal : void 0,
+          bot: typeof n.bot === "string" ? n.bot : void 0,
+          depends,
+          triggerRule,
+          inputs,
+          humanGate: null,
+          ...loopFields
+        });
+      }
+      continue;
+    }
+    if (type === "host") {
+      if (n.goal !== void 0) problems.push(`host node "${id}".goal is not supported`);
+      if (n.bot !== void 0) problems.push(`host node "${id}".bot is not supported \u2014 host nodes do not spawn a CLI`);
+      if (n.override !== void 0) problems.push(`host node "${id}".override is not supported`);
+      if (n.revisitTo !== void 0) problems.push(`host node "${id}".revisitTo is not supported`);
+      if (n.resultSchema !== void 0) {
+        problems.push(`host node "${id}".resultSchema is not supported \u2014 host output uses the trusted executor result contract`);
+      }
+      if (inputs.length > 0) {
+        problems.push(`host node "${id}".inputs must be empty \u2014 use typed bindings in host input`);
+      }
+      if (triggerRule !== void 0 && triggerRule !== "all_success") {
+        problems.push(
+          `host node "${id}".triggerRule must be "all_success"; P0 host bindings do not accept skipped/omitted dependencies`
+        );
+      }
+      const executor = typeof n.executor === "string" ? n.executor : "";
+      if (!V3_HOST_EXECUTORS.includes(executor)) {
+        problems.push(
+          `host node "${id}".executor must be one of ${V3_HOST_EXECUTORS.join(" | ")} (got ${JSON.stringify(n.executor)})`
+        );
+      }
+      if (!Object.prototype.hasOwnProperty.call(n, "input")) {
+        problems.push(`host node "${id}".input is required`);
+      } else {
+        validateHostInputShape(executor, n.input, id, problems);
+        try {
+          collectV3HostBindingRefs(n.input);
+        } catch (err) {
+          problems.push(
+            `host node "${id}".input is invalid: ${err instanceof V3HostBindingError ? err.message : String(err)}`
+          );
+        }
+      }
+      if (n.timeoutSec !== void 0) {
+        problems.push(
+          `host node "${id}".timeoutSec is not supported \u2014 abandoning an in-flight provider call would make its effect outcome unknown`
+        );
+      }
+      const humanGate2 = normHumanGate(n.humanGate, `host node "${id}"`, problems);
+      if (!humanGate2) {
+        problems.push(
+          `host node "${id}" must declare a humanGate; v3 P0 does not allow ungated external side effects`
+        );
+      } else {
+        if (!humanGate2.options?.includes("approve")) {
+          problems.push(
+            `host node "${id}".humanGate.options must include "approve" explicitly; host side effects cannot use an implicit first-option approval`
+          );
+        }
+        if (humanGate2.approveOptions?.length !== 1 || humanGate2.approveOptions[0] !== "approve") {
+          problems.push(
+            `host node "${id}".humanGate.approveOptions must be exactly ["approve"]; custom-labelled choices cannot authorize a host side effect`
+          );
+        }
+      }
+      nodes.push({
+        id,
+        type,
+        executor,
+        input: n.input,
+        depends,
+        triggerRule,
+        inputs: [],
+        humanGate: humanGate2
+      });
+      continue;
+    }
+    if (typeof n.goal !== "string" || n.goal.trim() === "") {
+      problems.push(`goal node "${id}".goal must be a non-empty string`);
+    }
+    const timeoutSec = normTimeoutSec(n.timeoutSec, `node "${id}"`, problems);
+    const resultSchema = normResultSchema(n.resultSchema, id, problems);
+    const humanGate = normHumanGate(n.humanGate, `node "${id}"`, problems);
+    const override = normOverride(n.override, `node "${id}"`, problems);
+    const revisitTo = normRevisitTo(n.revisitTo, id, problems);
+    nodes.push({
+      id,
+      type,
+      goal: typeof n.goal === "string" ? n.goal : void 0,
+      bot: typeof n.bot === "string" ? n.bot : void 0,
+      depends,
+      triggerRule,
+      override,
+      inputs,
+      timeoutSec,
+      humanGate,
+      resultSchema,
+      ...revisitTo ? { revisitTo } : {}
+    });
+  }
+  for (const node of nodes) {
+    for (const dep of node.depends) {
+      if (!ids.has(dep.from)) problems.push(`node "${node.id}" depends on unknown node "${dep.from}"`);
+    }
+    for (const inp of node.inputs) {
+      if (!ids.has(inp.from)) {
+        problems.push(`node "${node.id}".inputs references unknown node "${inp.from}"`);
+      } else if (!node.depends.some((d) => d.from === inp.from)) {
+        problems.push(`node "${node.id}".inputs.from "${inp.from}" must also be in depends`);
+      }
+    }
+    if (node.type === "host") {
+      try {
+        for (const ref of collectV3HostBindingRefs(node.input)) {
+          if (ref.kind !== "result") continue;
+          if (!ids.has(ref.nodeId)) {
+            problems.push(`host node "${node.id}".input references unknown result node "${ref.nodeId}"`);
+          } else if (!node.depends.some((dep) => dep.from === ref.nodeId)) {
+            problems.push(
+              `host node "${node.id}".input result source "${ref.nodeId}" must also be in depends`
+            );
+          } else if (!node.depends.some((dep) => dep.from === ref.nodeId && dep.when === void 0)) {
+            problems.push(
+              `host node "${node.id}".input result source "${ref.nodeId}" must use an unconditional depends edge; P0 host bindings do not accept omitted conditional inputs`
+            );
+          }
+        }
+      } catch {
+      }
+    }
+    if (node.revisitTo && node.revisitTo.length > 0) {
+      const ancestors = ancestorsOf(node.id, nodes);
+      for (const target of node.revisitTo) {
+        if (!ids.has(target)) {
+          problems.push(`node "${node.id}".revisitTo references unknown node "${target}"`);
+        } else if (target === node.id) {
+          problems.push(`node "${node.id}".revisitTo cannot point at itself`);
+        } else if (!ancestors.has(target)) {
+          problems.push(
+            `node "${node.id}".revisitTo "${target}" must be an ancestor (reachable via depends) \u2014 revisit only jumps backward`
+          );
+        }
+      }
+    }
+  }
+  for (const requester of nodes) {
+    for (const target of requester.revisitTo ?? []) {
+      const cone = downstreamCone(target, nodes);
+      for (const nodeId of cone) {
+        if (nodeByIdUnsafe(nodes, nodeId)?.type === "host") {
+          problems.push(
+            `node "${requester.id}".revisitTo "${target}" would replay host node "${nodeId}"; host nodes are not allowed in a revisit cone`
+          );
+        }
+      }
+    }
+  }
+  const nodeById = new Map(nodes.map((nn) => [nn.id, nn]));
+  for (const pw of pendingWhens) {
+    const source = nodeById.get(pw.ref.from);
+    if (!source) continue;
+    if (source.type !== "goal") {
+      problems.push(
+        `${pw.where}: conditional edge source "${pw.ref.from}" must be a goal node (P0 forbids loop sources \u2014 add a verifier goal after the loop and branch on ITS result)`
+      );
+      continue;
+    }
+    if (!source.resultSchema) {
+      problems.push(
+        `${pw.where}: conditional edge source "${pw.ref.from}" must declare a resultSchema \u2014 the predicate reads its structured result`
+      );
+      continue;
+    }
+    const when = normLoopExitWhen(pw.raw, source.resultSchema, pw.where, problems);
+    if (when) pw.ref.when = when;
+  }
+  for (const node of nodes) {
+    if (node.type !== "loop") continue;
+    for (const other of ids) {
+      if (other !== node.id && other.startsWith(`${node.id}.`)) {
+        problems.push(
+          `node id "${other}" collides with loop "${node.id}" expansion namespace ("${node.id}.*")`
+        );
+      }
+    }
+  }
+  if (problems.length > 0) throw new DagValidationError(problems);
+  const dag = { runId: raw.runId, nodes };
+  topologicalOrder(dag);
+  return dag;
+}
+function validateHostInputShape(executor, input, nodeId, problems) {
+  if (!isObject(input) || Object.prototype.hasOwnProperty.call(input, "$ref")) {
+    problems.push(`host node "${nodeId}".input must be an object with explicit executor fields`);
+    return;
+  }
+  const shape = {
+    "feishu-send": {
+      required: ["larkAppId", "chatId", "content"],
+      allowed: ["larkAppId", "chatId", "content", "msgType"]
+    },
+    "feishu-reply": {
+      required: ["larkAppId", "rootMessageId", "content"],
+      allowed: ["larkAppId", "rootMessageId", "content", "msgType", "replyInThread"]
+    },
+    "botmux-schedule": {
+      required: ["name", "schedule", "prompt", "workingDir", "chatId", "chatType", "larkAppId"],
+      allowed: [
+        "name",
+        "schedule",
+        "prompt",
+        "workingDir",
+        "chatId",
+        "chatType",
+        "rootMessageId",
+        "scope",
+        "larkAppId",
+        "repeat",
+        "deliver"
+      ]
+    }
+  };
+  const expected = shape[executor];
+  if (!expected) return;
+  for (const field of expected.required) {
+    if (!Object.prototype.hasOwnProperty.call(input, field)) {
+      problems.push(`host node "${nodeId}".input.${field} is required for ${executor}`);
+    }
+  }
+  for (const field of Object.keys(input)) {
+    if (!expected.allowed.includes(field)) {
+      problems.push(`host node "${nodeId}".input.${field} is not supported by ${executor}`);
+    }
+  }
+  const identity = executor === "feishu-send" ? { larkAppId: "larkAppId", chatId: "chatId" } : executor === "feishu-reply" ? { larkAppId: "larkAppId", rootMessageId: "rootMessageId" } : { larkAppId: "larkAppId", chatId: "chatId", chatType: "chatType" };
+  if (executor === "botmux-schedule" && Object.prototype.hasOwnProperty.call(input, "rootMessageId")) {
+    identity.rootMessageId = "rootMessageId";
+  }
+  if (executor === "botmux-schedule" && Object.prototype.hasOwnProperty.call(input, "deliver") && input.deliver !== "origin" && input.deliver !== "new-topic") {
+    problems.push(
+      `host node "${nodeId}".input.deliver must be "origin" or "new-topic"; v3 P0 does not support local-only schedule delivery`
+    );
+  }
+  for (const [field, contextName] of Object.entries(identity)) {
+    const value = input[field];
+    if (!isObject(value) || Object.keys(value).length !== 1 || value.$ref !== `context.${contextName}`) {
+      problems.push(
+        `host node "${nodeId}".input.${field} must be exact { "$ref": "context.${contextName}" }; IM host effects cannot target another bot/chat`
+      );
+    }
+  }
+}
+function normHumanGate(raw, where, problems) {
+  if (raw == null) return null;
+  if (!isObject(raw) || typeof raw.prompt !== "string" || raw.prompt.trim() === "") {
+    problems.push(`${where}.humanGate must be { prompt: <non-empty string>, options?, approveOptions?, approvers? } or null`);
+    return null;
+  }
+  let options = [...DEFAULT_HUMAN_GATE_OPTIONS];
+  if (raw.options !== void 0) {
+    if (!Array.isArray(raw.options)) {
+      problems.push(`${where}.humanGate.options must be a non-empty string array`);
+    } else {
+      const parsed = parseUniqueStringList(
+        raw.options,
+        `${where}.humanGate.options`,
+        problems,
+        { allowEmptyList: false, maxItems: MAX_HUMAN_GATE_OPTIONS, maxLength: MAX_HUMAN_GATE_OPTION_LENGTH }
+      );
+      if (parsed) options = parsed;
+    }
+  }
+  let approveOptions;
+  if (raw.approveOptions !== void 0) {
+    if (!Array.isArray(raw.approveOptions)) {
+      problems.push(`${where}.humanGate.approveOptions must be a non-empty string array`);
+    } else {
+      approveOptions = parseUniqueStringList(
+        raw.approveOptions,
+        `${where}.humanGate.approveOptions`,
+        problems,
+        { allowEmptyList: false, maxLength: MAX_HUMAN_GATE_OPTION_LENGTH }
+      );
+    }
+  }
+  approveOptions ??= options.includes("approve") ? ["approve"] : [options[0]];
+  for (const opt of approveOptions) {
+    if (!options.includes(opt)) {
+      problems.push(`${where}.humanGate.approveOptions value ${JSON.stringify(opt)} must also appear in options`);
+    }
+  }
+  let approvers = [];
+  if (raw.approvers !== void 0) {
+    if (!Array.isArray(raw.approvers)) {
+      problems.push(`${where}.humanGate.approvers must be a string array`);
+    } else {
+      approvers = parseUniqueStringList(
+        raw.approvers,
+        `${where}.humanGate.approvers`,
+        problems,
+        { allowEmptyList: true }
+      ) ?? [];
+    }
+  }
+  return { prompt: raw.prompt, options, approveOptions, approvers };
+}
+function parseUniqueStringList(raw, where, problems, opts) {
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (!opts.allowEmptyList && raw.length === 0) {
+    problems.push(`${where} must not be empty`);
+  }
+  if (opts.maxItems !== void 0 && raw.length > opts.maxItems) {
+    problems.push(`${where} supports at most ${opts.maxItems} entries`);
+  }
+  for (const item of raw) {
+    if (typeof item !== "string" || item.trim() === "") {
+      problems.push(`${where} entries must be non-empty strings`);
+      continue;
+    }
+    if (opts.maxLength !== void 0 && item.length > opts.maxLength) {
+      problems.push(`${where} entry ${JSON.stringify(item)} exceeds ${opts.maxLength} characters`);
+    }
+    if (seen.has(item)) {
+      problems.push(`${where} has duplicate value ${JSON.stringify(item)}`);
+      continue;
+    }
+    seen.add(item);
+    values.push(item);
+  }
+  return problems.some((p) => p.startsWith(where)) ? void 0 : values;
+}
+function normDepends(v, where, problems, whenSink) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) {
+    problems.push(`${where}.depends must be an array of nodeId strings or { from, when? } objects`);
+    return [];
+  }
+  const out = [];
+  for (let j = 0; j < v.length; j++) {
+    const entry = v[j];
+    if (typeof entry === "string") {
+      out.push({ from: entry });
+      continue;
+    }
+    if (isObject(entry) && typeof entry.from === "string") {
+      const extra = Object.keys(entry).filter((k) => k !== "from" && k !== "when");
+      if (extra.length > 0) {
+        problems.push(`${where}.depends[${j}] has unsupported key(s): ${extra.join(", ")} (allowed: from, when)`);
+        continue;
+      }
+      const ref = { from: entry.from };
+      if (entry.when !== void 0) {
+        if (!whenSink) {
+          problems.push(`${where}.depends[${j}].when: conditional edges are not supported inside a loop body (first cut)`);
+          continue;
+        }
+        if (!isObject(entry.when)) {
+          problems.push(`${where}.depends[${j}].when must be an object`);
+          continue;
+        }
+        whenSink.list.push({
+          where: `${where}.depends[${j}].when (edge "${entry.from}" -> "${whenSink.ownerId}")`,
+          ref,
+          raw: entry.when
+        });
+      }
+      out.push(ref);
+      continue;
+    }
+    problems.push(`${where}.depends[${j}] must be a nodeId string or { from, when? }`);
+  }
+  return out;
+}
+function normTriggerRule(v, indegree, where, problems) {
+  if (v === void 0) return void 0;
+  if (v === "all_success" || v === "one_success") {
+    if (indegree === 0) {
+      problems.push(`${where}.triggerRule requires at least one incoming edge (depends is empty)`);
+      return void 0;
+    }
+    return v;
+  }
+  if (isObject(v)) {
+    const extra = Object.keys(v).filter((k) => k !== "quorum");
+    if (extra.length > 0) {
+      problems.push(`${where}.triggerRule object only supports { quorum: N } (got extra: ${extra.join(", ")})`);
+      return void 0;
+    }
+    if (indegree === 0) {
+      problems.push(`${where}.triggerRule requires at least one incoming edge (depends is empty)`);
+      return void 0;
+    }
+    const q = v.quorum;
+    if (typeof q !== "number" || !Number.isInteger(q) || q < 1 || q > indegree) {
+      problems.push(`${where}.triggerRule.quorum must be an integer in [1, ${indegree}] (got ${JSON.stringify(q)})`);
+      return void 0;
+    }
+    return { quorum: q };
+  }
+  problems.push(`${where}.triggerRule must be 'all_success' | 'one_success' | { quorum: N }`);
+  return void 0;
+}
+function normOverride(v, where, problems) {
+  if (v === void 0 || v === null) return void 0;
+  if (!isObject(v)) {
+    problems.push(`${where}.override must be an object`);
+    return void 0;
+  }
+  const known = /* @__PURE__ */ new Set(["model", "systemPromptAppend"]);
+  const extra = Object.keys(v).filter((k) => !known.has(k));
+  if (extra.length > 0) {
+    const hints = [];
+    if (extra.includes("toolsSubset")) hints.push("toolsSubset is deferred \u2014 P2b");
+    if (extra.includes("permissionMode")) {
+      hints.push("permissionMode was removed \u2014 v3 workflow workers always require CLI bypass; delete this key");
+    }
+    const hint = hints.length > 0 ? ` (${hints.join("; ")})` : "";
+    problems.push(`${where}.override has unsupported key(s): ${extra.join(", ")}${hint} (allowed: model, systemPromptAppend)`);
+    return void 0;
+  }
+  const out = {};
+  if (v.model !== void 0) {
+    if (typeof v.model !== "string" || v.model.trim() === "" || v.model.length > MAX_OVERRIDE_MODEL_LENGTH) {
+      problems.push(`${where}.override.model must be a non-empty string \u2264${MAX_OVERRIDE_MODEL_LENGTH} chars`);
+      return void 0;
+    }
+    out.model = v.model.trim();
+  }
+  if (v.systemPromptAppend !== void 0) {
+    if (typeof v.systemPromptAppend !== "string" || v.systemPromptAppend.trim() === "" || Buffer.byteLength(v.systemPromptAppend, "utf-8") > MAX_OVERRIDE_SYSTEM_PROMPT_APPEND) {
+      problems.push(`${where}.override.systemPromptAppend must be a non-empty string \u2264${MAX_OVERRIDE_SYSTEM_PROMPT_APPEND} bytes`);
+      return void 0;
+    }
+    out.systemPromptAppend = v.systemPromptAppend;
+  }
+  if (Object.keys(out).length === 0) {
+    problems.push(`${where}.override must set at least one of model / systemPromptAppend`);
+    return void 0;
+  }
+  return out;
+}
+function normTimeoutSec(v, where, problems) {
+  if (v === void 0) return void 0;
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) {
+    problems.push(`${where}.timeoutSec must be a positive number`);
+    return void 0;
+  }
+  if (v > MAX_NODE_TIMEOUT_SEC) {
+    problems.push(`${where}.timeoutSec ${v} exceeds the ${MAX_NODE_TIMEOUT_SEC}s (4h) ceiling`);
+    return void 0;
+  }
+  return v;
+}
+function normRevisitTo(v, id, problems) {
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v)) {
+    problems.push(`node "${id}".revisitTo must be an array of node ids`);
+    return void 0;
+  }
+  const out = [];
+  for (const entry of v) {
+    if (typeof entry !== "string" || entry.trim() === "") {
+      problems.push(`node "${id}".revisitTo entries must be non-empty node-id strings`);
+      continue;
+    }
+    out.push(entry);
+  }
+  if (new Set(out).size !== out.length) problems.push(`node "${id}".revisitTo has duplicates`);
+  return out.length > 0 ? out : void 0;
+}
+function ancestorsOf(nodeId, nodes) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...byId.get(nodeId)?.depends.map((d) => d.from) ?? []];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    if (seen.has(cur)) continue;
+    seen.add(cur);
+    for (const dep of byId.get(cur)?.depends ?? []) queue.push(dep.from);
+  }
+  return seen;
+}
+function downstreamCone(nodeId, nodes) {
+  const seen = /* @__PURE__ */ new Set([nodeId]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const node of nodes) {
+      if (seen.has(node.id)) continue;
+      if (node.depends.some((dep) => seen.has(dep.from))) {
+        seen.add(node.id);
+        changed = true;
+      }
+    }
+  }
+  return seen;
+}
+function nodeByIdUnsafe(nodes, nodeId) {
+  return nodes.find((node) => node.id === nodeId);
+}
+function normLoopFields(n, id, problems) {
+  const where = `loop node "${id}"`;
+  const before = problems.length;
+  if (n.timeoutSec !== void 0) {
+    problems.push(`${where}.timeoutSec is not supported \u2014 set timeoutSec on body nodes instead`);
+  }
+  if (n.resultSchema !== void 0) {
+    problems.push(`${where}.resultSchema is not supported \u2014 declare it on the exit body node`);
+  }
+  if (n.humanGate != null) {
+    problems.push(`${where}.humanGate is not supported (first cut) \u2014 gate an upstream node instead`);
+  }
+  if (n.onExhausted !== void 0 && n.onExhausted !== "blocked") {
+    problems.push(`${where}.onExhausted only supports "blocked"`);
+  }
+  if (n.sessionPolicy !== void 0 && n.sessionPolicy !== "fresh") {
+    problems.push(`${where}.sessionPolicy only supports "fresh" (resumeWithinLoop is deferred)`);
+  }
+  if (n.override !== void 0) {
+    problems.push(`${where}.override is not supported \u2014 a loop composite never spawns a worker; set override on body nodes instead`);
+  }
+  let maxIterations;
+  if (typeof n.maxIterations !== "number" || !Number.isInteger(n.maxIterations) || n.maxIterations < 1) {
+    problems.push(`${where}.maxIterations must be a positive integer`);
+  } else if (n.maxIterations > MAX_LOOP_ITERATIONS) {
+    problems.push(`${where}.maxIterations ${n.maxIterations} exceeds the ${MAX_LOOP_ITERATIONS} ceiling`);
+  } else {
+    maxIterations = n.maxIterations;
+  }
+  const bodyRaw = n.body;
+  if (!isObject(bodyRaw) || !Array.isArray(bodyRaw.nodes) || bodyRaw.nodes.length === 0) {
+    problems.push(`${where}.body.nodes must be a non-empty array`);
+    return void 0;
+  }
+  const bodyBefore = problems.length;
+  const bodyIds = /* @__PURE__ */ new Set();
+  const bodyNodes = [];
+  for (let j = 0; j < bodyRaw.nodes.length; j++) {
+    const b = bodyRaw.nodes[j];
+    const bwhere = `${where}.body.nodes[${j}]`;
+    if (!isObject(b)) {
+      problems.push(`${bwhere} must be an object`);
+      continue;
+    }
+    const bid = b.id;
+    if (typeof bid !== "string" || !SEGMENT_RE.test(bid)) {
+      problems.push(`${bwhere}.id must be a path-safe string matching ${SEGMENT_RE} (got ${JSON.stringify(bid)})`);
+      continue;
+    }
+    if (bodyIds.has(bid)) {
+      problems.push(`${where}.body has duplicate node id "${bid}"`);
+      continue;
+    }
+    bodyIds.add(bid);
+    if (b.type !== "goal") {
+      problems.push(`${where}.body node "${bid}": only "goal" nodes are allowed in a loop body (no nested loops, no host)`);
+      continue;
+    }
+    if (typeof b.goal !== "string" || b.goal.trim() === "") {
+      problems.push(`${where}.body node "${bid}".goal must be a non-empty string`);
+    }
+    if (b.humanGate != null) {
+      problems.push(`${where}.body node "${bid}".humanGate is not supported inside a loop body (first cut)`);
+    }
+    if (b.triggerRule !== void 0) {
+      problems.push(`${where}.body node "${bid}".triggerRule is not supported inside a loop body (first cut)`);
+    }
+    const bdepends = normDepends(b.depends, `${where}.body node "${bid}"`, problems);
+    const bFromList = bdepends.map((d) => d.from);
+    if (bFromList.includes(bid)) problems.push(`${where}.body node "${bid}" depends on itself`);
+    if (new Set(bFromList).size !== bFromList.length) problems.push(`${where}.body node "${bid}".depends has duplicates`);
+    const binputs = normInputs(b.inputs, `${id}.body.${bid}`, problems);
+    const btimeout = normTimeoutSec(b.timeoutSec, `${where}.body node "${bid}"`, problems);
+    const bschema = normResultSchema(b.resultSchema, `${id}.body.${bid}`, problems);
+    const boverride = normOverride(b.override, `${where}.body node "${bid}"`, problems);
+    bodyNodes.push({
+      id: bid,
+      type: "goal",
+      goal: typeof b.goal === "string" ? b.goal : void 0,
+      bot: typeof b.bot === "string" ? b.bot : void 0,
+      depends: bdepends,
+      override: boverride,
+      inputs: binputs,
+      timeoutSec: btimeout,
+      humanGate: null,
+      resultSchema: bschema
+    });
+  }
+  for (const bn of bodyNodes) {
+    for (const dep of bn.depends) {
+      if (!bodyIds.has(dep.from)) problems.push(`${where}.body node "${bn.id}" depends on unknown body node "${dep.from}"`);
+    }
+    for (const inp of bn.inputs) {
+      if (!bodyIds.has(inp.from)) {
+        problems.push(`${where}.body node "${bn.id}".inputs references unknown body node "${inp.from}"`);
+      } else if (!bn.depends.some((d) => d.from === inp.from)) {
+        problems.push(`${where}.body node "${bn.id}".inputs.from "${inp.from}" must also be in depends`);
+      }
+    }
+  }
+  if (problems.length === bodyBefore && bodyNodes.length === bodyRaw.nodes.length) {
+    try {
+      topologicalOrder({ runId: "body", nodes: bodyNodes });
+    } catch (err) {
+      if (err instanceof DagValidationError) {
+        for (const p of err.problems) problems.push(`${where}.body: ${p}`);
+      } else {
+        throw err;
+      }
+    }
+  }
+  let exit;
+  const exitRaw = n.exit;
+  if (!isObject(exitRaw) || typeof exitRaw.node !== "string" || !isObject(exitRaw.when)) {
+    problems.push(`${where}.exit must be { node: <bodyId>, when: { path, <operator> } }`);
+  } else if (!bodyIds.has(exitRaw.node)) {
+    problems.push(`${where}.exit.node "${exitRaw.node}" is not a body node`);
+  } else {
+    const exitNode = bodyNodes.find((b) => b.id === exitRaw.node);
+    if (!exitNode?.resultSchema) {
+      problems.push(`${where}.exit.node "${exitRaw.node}" must declare a resultSchema \u2014 the exit decision reads its structured result`);
+    } else {
+      const when = normLoopExitWhen(exitRaw.when, exitNode.resultSchema, `${where}.exit.when`, problems);
+      if (when) exit = { node: exitRaw.node, when };
+    }
+  }
+  const feedback = [];
+  if (n.feedback !== void 0) {
+    if (!Array.isArray(n.feedback) || n.feedback.some((x) => typeof x !== "string")) {
+      problems.push(`${where}.feedback must be an array of strings`);
+    } else {
+      for (const ref of n.feedback) {
+        const dot = ref.lastIndexOf(".");
+        const bodyId = dot > 0 ? ref.slice(0, dot) : "";
+        const kind = dot > 0 ? ref.slice(dot + 1) : "";
+        if (!bodyIds.has(bodyId) || !["result", "files", "manifest"].includes(kind)) {
+          problems.push(`${where}.feedback "${ref}" must be <bodyId>.result | <bodyId>.files | <bodyId>.manifest`);
+          continue;
+        }
+        if (kind === "result" && !bodyNodes.find((b) => b.id === bodyId)?.resultSchema) {
+          problems.push(`${where}.feedback "${ref}" requires body node "${bodyId}" to declare a resultSchema`);
+          continue;
+        }
+        if (feedback.includes(ref)) {
+          problems.push(`${where}.feedback has duplicate "${ref}"`);
+          continue;
+        }
+        feedback.push(ref);
+      }
+    }
+  }
+  let output;
+  if (n.output !== void 0) {
+    if (!isObject(n.output) || typeof n.output.from !== "string" || !bodyIds.has(n.output.from)) {
+      problems.push(`${where}.output must be { from: <bodyId> }`);
+    } else {
+      output = { from: n.output.from };
+    }
+  } else if (exit) {
+    output = { from: exit.node };
+  }
+  if (problems.length > before || maxIterations === void 0 || !exit || !output) return void 0;
+  return {
+    maxIterations,
+    body: { nodes: bodyNodes },
+    exit,
+    feedback,
+    output,
+    onExhausted: "blocked",
+    sessionPolicy: "fresh"
+  };
+}
+function normLoopExitWhen(v, schema, where, problems) {
+  const unknown = Object.keys(v).filter((k) => k !== "path" && !LOOP_WHEN_OPERATORS.includes(k));
+  if (unknown.length > 0) {
+    problems.push(`${where} has unsupported keyword(s): ${unknown.join(", ")} (allowed: path + one of ${LOOP_WHEN_OPERATORS.join("/")})`);
+    return void 0;
+  }
+  const m = typeof v.path === "string" ? /^result\.([A-Za-z0-9_-]+)$/.exec(v.path) : null;
+  if (!m) {
+    problems.push(`${where}.path must be "result.<key>" (the resultSchema subset is flat \u2014 no deeper paths)`);
+    return void 0;
+  }
+  const key = m[1];
+  const prop = schema.properties[key];
+  if (!prop) {
+    problems.push(`${where}.path references "${key}", which is not declared in the exit node's resultSchema`);
+    return void 0;
+  }
+  if (!(schema.required ?? []).includes(key)) {
+    problems.push(`${where}.path references "${key}", which must be in the exit node's resultSchema.required (otherwise the field may be absent at runtime)`);
+    return void 0;
+  }
+  const ops = LOOP_WHEN_OPERATORS.filter((op2) => v[op2] !== void 0);
+  if (ops.length !== 1) {
+    problems.push(`${where} must set exactly ONE operator (${LOOP_WHEN_OPERATORS.join("/")})`);
+    return void 0;
+  }
+  const op = ops[0];
+  const operand = v[op];
+  if (prop.type === "array" || prop.type === "object") {
+    problems.push(`${where}: cannot compare "${key}" \u2014 exit predicates only support string/number/boolean fields`);
+    return void 0;
+  }
+  if (op === "gt" || op === "gte" || op === "lt" || op === "lte") {
+    if (prop.type !== "number") {
+      problems.push(`${where}.${op} requires "${key}" to be a number field (it is ${prop.type})`);
+      return void 0;
+    }
+    if (typeof operand !== "number" || !Number.isFinite(operand)) {
+      problems.push(`${where}.${op} must be a finite number`);
+      return void 0;
+    }
+  } else {
+    if (typeof operand !== prop.type) {
+      problems.push(`${where}.${op} must be a ${prop.type} to match "${key}"`);
+      return void 0;
+    }
+    if (prop.type === "string" && prop.enum && !prop.enum.includes(operand)) {
+      problems.push(
+        `${where}.${op} value ${JSON.stringify(operand)} is not in "${key}"'s enum [${prop.enum.join(", ")}]`
+      );
+      return void 0;
+    }
+  }
+  return { path: v.path, [op]: operand };
+}
+function normResultSchema(v, id, problems) {
+  if (v === void 0 || v === null) return void 0;
+  const where = `node "${id}".resultSchema`;
+  if (!isObject(v)) {
+    problems.push(`${where} must be an object`);
+    return void 0;
+  }
+  const knownTop = /* @__PURE__ */ new Set(["type", "properties", "required"]);
+  for (const key of Object.keys(v)) {
+    if (!knownTop.has(key)) {
+      problems.push(`${where} has unsupported keyword "${key}" (subset allows: type/properties/required)`);
+      return void 0;
+    }
+  }
+  if (v.type !== "object") {
+    problems.push(`${where}.type must be "object"`);
+    return void 0;
+  }
+  if (!isObject(v.properties) || Object.keys(v.properties).length === 0) {
+    problems.push(`${where}.properties must be a non-empty object`);
+    return void 0;
+  }
+  const props = Object.entries(v.properties);
+  if (props.length > RESULT_SCHEMA_MAX_PROPERTIES) {
+    problems.push(`${where} has ${props.length} properties (max ${RESULT_SCHEMA_MAX_PROPERTIES})`);
+    return void 0;
+  }
+  const properties = {};
+  for (const [name, spec] of props) {
+    if (!isObject(spec)) {
+      problems.push(`${where}.properties.${name} must be an object`);
+      return void 0;
+    }
+    for (const key of Object.keys(spec)) {
+      if (key !== "type" && key !== "enum") {
+        problems.push(`${where}.properties.${name} has unsupported keyword "${key}" (subset allows: type, enum)`);
+        return void 0;
+      }
+    }
+    if (!RESULT_FIELD_TYPES.includes(spec.type)) {
+      problems.push(`${where}.properties.${name}.type must be one of ${RESULT_FIELD_TYPES.join(" | ")}`);
+      return void 0;
+    }
+    let enumValues;
+    if (spec.enum !== void 0) {
+      if (spec.type !== "string") {
+        problems.push(`${where}.properties.${name}.enum is only supported on string fields (it is ${String(spec.type)})`);
+        return void 0;
+      }
+      if (!Array.isArray(spec.enum) || spec.enum.length === 0 || spec.enum.some((x) => typeof x !== "string" || x.length === 0)) {
+        problems.push(`${where}.properties.${name}.enum must be a non-empty array of non-empty strings`);
+        return void 0;
+      }
+      if (spec.enum.length > RESULT_ENUM_MAX_VALUES) {
+        problems.push(`${where}.properties.${name}.enum has ${spec.enum.length} values (max ${RESULT_ENUM_MAX_VALUES})`);
+        return void 0;
+      }
+      if (new Set(spec.enum).size !== spec.enum.length) {
+        problems.push(`${where}.properties.${name}.enum has duplicates`);
+        return void 0;
+      }
+      const tooLong = spec.enum.filter((x) => x.length > RESULT_ENUM_MAX_VALUE_LENGTH);
+      if (tooLong.length > 0) {
+        problems.push(`${where}.properties.${name}.enum value(s) exceed ${RESULT_ENUM_MAX_VALUE_LENGTH} chars: ${tooLong.join(", ")}`);
+        return void 0;
+      }
+      enumValues = spec.enum;
+    }
+    properties[name] = enumValues ? { type: spec.type, enum: enumValues } : { type: spec.type };
+  }
+  let required;
+  if (v.required !== void 0) {
+    if (!Array.isArray(v.required) || v.required.some((x) => typeof x !== "string")) {
+      problems.push(`${where}.required must be an array of strings`);
+      return void 0;
+    }
+    const unknown = v.required.filter((r) => !(r in properties));
+    if (unknown.length > 0) {
+      problems.push(`${where}.required references undeclared properties: ${unknown.join(", ")}`);
+      return void 0;
+    }
+    if (new Set(v.required).size !== v.required.length) {
+      problems.push(`${where}.required has duplicates`);
+      return void 0;
+    }
+    required = v.required;
+  }
+  const schema = required ? { type: "object", properties, required } : { type: "object", properties };
+  const bytes = Buffer.byteLength(JSON.stringify(schema), "utf-8");
+  if (bytes > RESULT_SCHEMA_MAX_BYTES) {
+    problems.push(`${where} serializes to ${bytes} bytes (max ${RESULT_SCHEMA_MAX_BYTES})`);
+    return void 0;
+  }
+  return schema;
+}
+function normInputs(v, id, problems) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) {
+    problems.push(`node "${id}".inputs must be an array`);
+    return [];
+  }
+  const out = [];
+  for (let j = 0; j < v.length; j++) {
+    const inp = v[j];
+    if (!isObject(inp) || typeof inp.from !== "string") {
+      problems.push(`node "${id}".inputs[${j}] must be { from: <nodeId>, select? }`);
+      continue;
+    }
+    const extra = Object.keys(inp).filter((k) => k !== "from" && k !== "select");
+    if (extra.length > 0) {
+      problems.push(`node "${id}".inputs[${j}] has unsupported key(s): ${extra.join(", ")} (allowed: from, select)`);
+      continue;
+    }
+    if (inp.select === void 0) {
+      out.push({ from: inp.from });
+      continue;
+    }
+    if (!isObject(inp.select)) {
+      problems.push(`node "${id}".inputs[${j}].select must be { name: <string> } or { path: <string> }`);
+      continue;
+    }
+    const selKeys = Object.keys(inp.select);
+    const badKeys = selKeys.filter((k) => k !== "name" && k !== "path");
+    if (badKeys.length > 0 || selKeys.length !== 1) {
+      problems.push(`node "${id}".inputs[${j}].select must set exactly ONE of name / path`);
+      continue;
+    }
+    const selVal = inp.select.name ?? inp.select.path;
+    if (typeof selVal !== "string" || selVal.trim() === "") {
+      problems.push(`node "${id}".inputs[${j}].select.${selKeys[0]} must be a non-empty string`);
+      continue;
+    }
+    out.push({
+      from: inp.from,
+      select: inp.select.name !== void 0 ? { name: selVal } : { path: selVal }
+    });
+  }
+  return out;
+}
+function topologicalOrder(dag) {
+  const indeg = /* @__PURE__ */ new Map();
+  const adj = /* @__PURE__ */ new Map();
+  for (const node of dag.nodes) {
+    indeg.set(node.id, indeg.get(node.id) ?? 0);
+    if (!adj.has(node.id)) adj.set(node.id, []);
+  }
+  for (const node of dag.nodes) {
+    for (const dep of node.depends) {
+      indeg.set(node.id, (indeg.get(node.id) ?? 0) + 1);
+      adj.get(dep.from).push(node.id);
+    }
+  }
+  const ready = [...indeg.entries()].filter(([, d]) => d === 0).map(([id]) => id).sort();
+  const order = [];
+  while (ready.length > 0) {
+    const id = ready.shift();
+    order.push(id);
+    for (const next of adj.get(id) ?? []) {
+      const d = indeg.get(next) - 1;
+      indeg.set(next, d);
+      if (d === 0) {
+        const pos = lowerBound(ready, next);
+        ready.splice(pos, 0, next);
+      }
+    }
+  }
+  if (order.length !== dag.nodes.length) {
+    const stuck = dag.nodes.map((n) => n.id).filter((id) => !order.includes(id));
+    throw new DagValidationError([`dag has a cycle among nodes: ${stuck.join(", ")}`]);
+  }
+  return order;
+}
+function lowerBound(arr, x) {
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (arr[mid] < x) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_HUMAN_GATE_OPTIONS,
+  DEFAULT_NODE_TIMEOUT_SEC,
+  DEFAULT_REVISIT_BUDGET_PER_PAIR,
+  DEFAULT_REVISIT_BUDGET_PER_RUN,
+  DagValidationError,
+  MAX_HUMAN_GATE_OPTIONS,
+  MAX_HUMAN_GATE_OPTION_LENGTH,
+  MAX_LOOP_ITERATIONS,
+  MAX_NODE_TIMEOUT_SEC,
+  MAX_OVERRIDE_MODEL_LENGTH,
+  MAX_OVERRIDE_SYSTEM_PROMPT_APPEND,
+  NODE_KINDS,
+  RESULT_ENUM_MAX_VALUES,
+  RESULT_ENUM_MAX_VALUE_LENGTH,
+  RESULT_SCHEMA_MAX_BYTES,
+  RESULT_SCHEMA_MAX_PROPERTIES,
+  V3_DAG_SEGMENT_RE,
+  V3_HOST_EXECUTORS,
+  isGoalNode,
+  isHostNode,
+  isLoopNode,
+  loopInstanceId,
+  topologicalOrder,
+  validateDag
+});
+//# sourceMappingURL=schema.cjs.map