@desplega.ai/agent-swarm 1.167.0 → 1.169.0

package/dist/cli-s0k2j7q9.js

@@ -0,0 +1,2084 @@
+import {
+  DEFAULT_MODEL,
+  resolveCredential
+} from "./cli-7mhy3ths.js";
+import {
+  getSlackApp
+} from "./cli-e5qk3m2a.js";
+import {
+  claimApprovalCancellationNotification,
+  completeApprovalCancellationNotificationClaim,
+  createTaskExtended,
+  getTaskById,
+  init_db1 as init_db,
+  releaseApprovalCancellationNotificationClaim
+} from "./cli-rg1c8ccw.js";
+import {
+  TERMINAL_TASK_STATUSES,
+  init_types
+} from "./cli-xvdgasgy.js";
+import {
+  init_resolver,
+  resolveTemplate
+} from "./cli-5c2j5yvx.js";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  getOpenRouterAttributionHeaders,
+  getOpenRouterBaseUrl,
+  init_openrouter_base_url
+} from "./cli-a35hzdve.js";
+import {
+  getAppUrl,
+  init_constants
+} from "./cli-gd4favx9.js";
+import {
+  init_zod
+} from "./cli-sd0mxa3c.js";
+import {
+  exports_external
+} from "./cli-w5e1d1vv.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-wt7ccy4r.js";
+import {
+  __require
+} from "./cli-bc05qbss.js";
+
+// src/workflows/approval-notifications.ts
+init_db();
+init_resolver();
+init_types();
+init_secret_scrubber();
+async function postApprovalCancellationUpdates(approvals, reason, client = getSlackApp()?.client) {
+  if (!client)
+    return;
+  const text = `This approval is no longer actionable: ${reason}`;
+  for (const approval of approvals) {
+    const channels = approval.notificationChannels;
+    const slackThreads = (channels ?? []).filter((notification) => notification.channel === "slack" && notification.messageTs);
+    if (slackThreads.length === 0)
+      continue;
+    for (const notification of slackThreads) {
+      if (notification.channel !== "slack" || !notification.messageTs)
+        continue;
+      const notificationKey = `${notification.target}:${notification.messageTs}`;
+      const claim = await claimApprovalCancellationNotification(approval.id, notificationKey);
+      if (!claim)
+        continue;
+      try {
+        await client.chat.postMessage({
+          channel: notification.target,
+          thread_ts: notification.messageTs,
+          text,
+          unfurl_links: false,
+          unfurl_media: false
+        });
+        await completeApprovalCancellationNotificationClaim(approval.id, notificationKey, claim.leaseToken);
+      } catch (error) {
+        await releaseApprovalCancellationNotificationClaim(approval.id, notificationKey, claim.leaseToken);
+        console.error(`[HITL] Failed to post cancellation update for approval ${approval.id}:`, scrubSecrets(error instanceof Error ? error.message : String(error)));
+      }
+    }
+  }
+}
+async function createApprovalFollowUpTask(request, templateEventType) {
+  if (request.workflowRunId || !request.sourceTaskId)
+    return false;
+  const sourceTask = await getTaskById(request.sourceTaskId);
+  if (!sourceTask)
+    return false;
+  if (templateEventType === "hitl.timeout" && TERMINAL_TASK_STATUSES.includes(sourceTask.status)) {
+    return false;
+  }
+  const { text: taskText } = templateEventType === "hitl.follow_up" ? resolveTemplate("hitl.follow_up", {
+    request_id: request.id,
+    title: request.title,
+    status: request.status,
+    responses: formatResponses(request.questions, request.responses ?? {})
+  }) : resolveTemplate("hitl.timeout", {
+    request_id: request.id,
+    title: request.title,
+    expires_at: request.expiresAt ?? "",
+    reason: request.resolutionReason ?? ""
+  });
+  await createTaskExtended(taskText, {
+    agentId: sourceTask.agentId,
+    routingReason: sourceTask.agentId ? "continuity" : undefined,
+    routingSource: sourceTask.agentId ? "engine_default" : undefined,
+    parentTaskId: request.sourceTaskId,
+    source: "system",
+    taskType: "hitl-follow-up",
+    tags: ["hitl", "follow-up"],
+    slackChannelId: sourceTask.slackChannelId ?? undefined,
+    slackThreadTs: sourceTask.slackThreadTs ?? undefined,
+    slackUserId: sourceTask.slackUserId ?? undefined
+  });
+  return true;
+}
+function formatResponses(questions, responses) {
+  return questions.map((q) => {
+    const answer = responses[q.id];
+    let answerText;
+    if (answer == null) {
+      answerText = "(no answer)";
+    } else if (q.type === "approval") {
+      const a = answer;
+      answerText = a.approved ? "Approved" : "Rejected";
+      if (a.comment)
+        answerText += ` — ${a.comment}`;
+    } else if (typeof answer === "object") {
+      answerText = JSON.stringify(answer);
+    } else {
+      answerText = String(answer);
+    }
+    return `- ${q.label}: ${answerText}`;
+  }).join(`
+`);
+}
+
+// src/workflows/executors/system-one-decision.ts
+init_zod();
+init_openrouter_base_url();
+init_secret_scrubber();
+
+// src/workflows/executors/base.ts
+class BaseExecutor {
+  deps;
+  retryPolicy;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async checkReadiness(_nodes) {
+    return [];
+  }
+  resolveApproval(_parkedOutput, _approval) {
+    return null;
+  }
+  async run(input) {
+    const configResult = this.configSchema.safeParse(input.config);
+    if (!configResult.success) {
+      return {
+        status: "failed",
+        error: `Input validation failed: ${configResult.error.message}`
+      };
+    }
+    let result;
+    try {
+      result = await this.execute(configResult.data, input.context, input.meta);
+    } catch (err) {
+      return {
+        status: "failed",
+        error: `Executor threw: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (result.status === "success" && result.output !== undefined) {
+      const outputResult = this.outputSchema.safeParse(result.output);
+      if (!outputResult.success) {
+        return {
+          status: "failed",
+          error: `Output validation failed: ${outputResult.error.message}`
+        };
+      }
+    }
+    return result;
+  }
+}
+
+// src/workflows/executors/human-in-the-loop.ts
+init_zod();
+init_constants();
+init_secret_scrubber();
+var SelectOptionSchema = exports_external.object({
+  value: exports_external.string(),
+  label: exports_external.string(),
+  description: exports_external.string().optional()
+});
+var QuestionSchema = exports_external.discriminatedUnion("type", [
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("approval"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional()
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("text"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    placeholder: exports_external.string().optional(),
+    multiline: exports_external.boolean().optional()
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("single-select"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    options: exports_external.array(SelectOptionSchema)
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("multi-select"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    options: exports_external.array(SelectOptionSchema),
+    minSelections: exports_external.number().int().min(0).optional(),
+    maxSelections: exports_external.number().int().min(1).optional()
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("boolean"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    defaultValue: exports_external.boolean().optional()
+  })
+]);
+var ApproverConfigSchema = exports_external.object({
+  users: exports_external.array(exports_external.string()).optional(),
+  roles: exports_external.array(exports_external.string()).optional(),
+  policy: exports_external.union([exports_external.literal("any"), exports_external.literal("all"), exports_external.object({ min: exports_external.number().int().min(1) })])
+});
+var NotificationConfigSchema = exports_external.object({
+  channel: exports_external.enum(["slack", "email"]),
+  target: exports_external.string()
+});
+var HITLTimeoutSchema = exports_external.object({
+  seconds: exports_external.number().int().min(1),
+  action: exports_external.literal("reject")
+});
+var DYNAMIC_QUESTIONS_TOKEN_RE = /^\{\{[^}]+\}\}$/;
+var MAX_HITL_QUESTIONS = 100;
+var SLACK_SECTION_TEXT_LIMIT = 3000;
+var MAX_REPORTED_ISSUES = 5;
+var HITLConfigSchema = exports_external.object({
+  title: exports_external.string(),
+  questions: exports_external.union([
+    exports_external.array(QuestionSchema).min(1),
+    exports_external.string().regex(DYNAMIC_QUESTIONS_TOKEN_RE, "questions must be an array or one exact {{interpolation}} token")
+  ]),
+  approvers: ApproverConfigSchema,
+  timeout: HITLTimeoutSchema.optional(),
+  notifications: exports_external.array(NotificationConfigSchema).optional()
+});
+var HITLOutputSchema = exports_external.object({
+  requestId: exports_external.string().uuid(),
+  status: exports_external.string(),
+  responses: exports_external.record(exports_external.string(), exports_external.unknown()).nullable()
+});
+function resolveHitlQuestions(value) {
+  const fail = (reason) => ({
+    ok: false,
+    error: `human-in-the-loop questions ${reason}`
+  });
+  if (typeof value === "string") {
+    return fail(value.trim() === "" ? "resolved to an empty value: the {{token}} did not resolve (check the node's inputs mapping and the upstream output)" : "resolved to a string; they must resolve to an array of question objects (use one exact {{token}} pointing at an array)");
+  }
+  if (!Array.isArray(value)) {
+    return fail(`must resolve to an array of question objects, got ${value === null ? "null" : typeof value}`);
+  }
+  if (value.length === 0) {
+    return fail("resolved to an empty array; refusing to create an approval card with no questions");
+  }
+  if (value.length > MAX_HITL_QUESTIONS) {
+    return fail(`resolved to ${value.length} questions, over the limit of ${MAX_HITL_QUESTIONS} per card; split or group them upstream`);
+  }
+  const issues = [];
+  const questions = [];
+  const seenIds = new Set;
+  value.forEach((raw, index) => {
+    const parsed = QuestionSchema.safeParse(raw);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        const path = issue.path.length > 0 ? `.${issue.path.map(String).join(".")}` : "";
+        issues.push(`[${index}]${path}: ${issue.message}`);
+      }
+      return;
+    }
+    const question = parsed.data;
+    if (question.id.trim() === "") {
+      issues.push(`[${index}].id: must be a non-empty string`);
+    } else if (seenIds.has(question.id)) {
+      issues.push(`[${index}].id: duplicate id "${question.id}" (responses are keyed by id)`);
+    }
+    seenIds.add(question.id);
+    if ((question.type === "single-select" || question.type === "multi-select") && question.options.length === 0) {
+      issues.push(`[${index}].options: a ${question.type} question needs at least one option`);
+    }
+    questions.push(question);
+  });
+  if (issues.length > 0) {
+    const shown = issues.slice(0, MAX_REPORTED_ISSUES).join("; ");
+    const more = issues.length > MAX_REPORTED_ISSUES ? `; and ${issues.length - MAX_REPORTED_ISSUES} more issue(s)` : "";
+    return fail(`are invalid: ${shown}${more}`);
+  }
+  return { ok: true, questions };
+}
+function escapeSlackMrkdwn(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function buildSlackQuestionsSummary(questions, timeoutText = "") {
+  const header = `*Questions:*
+`;
+  const lines = questions.map((q) => `• ${escapeSlackMrkdwn(q.label.replace(/\s+/g, " ").trim())}`);
+  const fits = (shown, omitted) => {
+    const tail = omitted > 0 ? `
+_…and ${omitted} more. Answer all of them on the dashboard._` : "";
+    const text = `${header}${shown.join(`
+`)}${tail}${timeoutText}`;
+    return text.length <= SLACK_SECTION_TEXT_LIMIT ? text : null;
+  };
+  const full = fits(lines, 0);
+  if (full)
+    return full;
+  for (let count = lines.length - 1;count >= 0; count--) {
+    const text = fits(lines.slice(0, count), lines.length - count);
+    if (text)
+      return text;
+  }
+  return `${header}_${questions.length} questions. Answer them on the dashboard._`;
+}
+
+class HumanInTheLoopExecutor extends BaseExecutor {
+  type = "human-in-the-loop";
+  mode = "async";
+  configSchema = HITLConfigSchema;
+  outputSchema = HITLOutputSchema;
+  async run(input) {
+    const resolved = resolveHitlQuestions(input.config?.questions);
+    if (!resolved.ok)
+      return { status: "failed", error: resolved.error };
+    return super.run({ ...input, config: { ...input.config, questions: resolved.questions } });
+  }
+  async execute(config, _context, meta) {
+    const { db } = this.deps;
+    const existing = await db.getApprovalRequestByStepId(meta.stepId);
+    if (existing) {
+      if (existing.status !== "pending") {
+        if (existing.status === "cancelled") {
+          return {
+            status: "failed",
+            error: `Approval request was cancelled: ${existing.resolutionReason ?? "workflow run cancelled"}`
+          };
+        }
+        const nextPort = existing.status === "timeout" ? "timeout" : existing.status === "rejected" ? "rejected" : "approved";
+        return {
+          status: "success",
+          output: {
+            requestId: existing.id,
+            status: existing.status,
+            responses: existing.responses
+          },
+          nextPort
+        };
+      }
+      return {
+        status: "success",
+        async: true,
+        waitFor: "approval.resolved",
+        correlationId: existing.id
+      };
+    }
+    if (!Array.isArray(config.questions)) {
+      return { status: "failed", error: "human-in-the-loop questions did not resolve to an array" };
+    }
+    const requestId = crypto.randomUUID();
+    const created = await db.createApprovalRequest({
+      id: requestId,
+      title: config.title,
+      questions: config.questions,
+      approvers: config.approvers,
+      workflowRunId: meta.runId,
+      workflowRunStepId: meta.stepId,
+      timeoutSeconds: config.timeout?.seconds,
+      notificationChannels: config.notifications,
+      createdBy: meta.requestedByUserId,
+      requireActionableWorkflow: true
+    });
+    if (created.status === "cancelled") {
+      return {
+        status: "success",
+        async: true,
+        waitFor: "approval.resolved",
+        correlationId: requestId
+      };
+    }
+    if (config.notifications?.length) {
+      this.dispatchNotifications(requestId, config, db).catch((err) => {
+        console.error("[HITL] Unexpected error dispatching notifications:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+      });
+    }
+    return {
+      status: "success",
+      async: true,
+      waitFor: "approval.resolved",
+      correlationId: requestId
+    };
+  }
+  async dispatchNotifications(requestId, config, db) {
+    if (!config.notifications?.length)
+      return;
+    const approvalUrl = `${getAppUrl()}/approval-requests/${requestId}`;
+    const updatedChannels = [...config.notifications];
+    let updated = false;
+    for (let i = 0;i < config.notifications.length; i++) {
+      const notification = config.notifications[i];
+      if (notification.channel === "email") {
+        console.warn(`[HITL] Email notifications not yet supported (target: ${notification.target})`);
+        continue;
+      }
+      if (notification.channel === "slack") {
+        try {
+          const { getSlackApp: getSlackApp2 } = await import("./app-80w6qspx.js");
+          const slackApp = getSlackApp2();
+          if (!slackApp) {
+            console.warn("[HITL] Slack not initialized — cannot send notification");
+            continue;
+          }
+          const questions = Array.isArray(config.questions) ? config.questions : [];
+          const questionsText = buildSlackQuestionsSummary(questions);
+          const timeoutCaption = config.timeout ? [
+            {
+              type: "context",
+              elements: [
+                {
+                  type: "mrkdwn",
+                  text: `⏱ Timeout: ${formatTimeout(config.timeout.seconds)} — times out if not responded`
+                }
+              ]
+            }
+          ] : [];
+          const blocks = [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: `\uD83D\uDD14 *Approval Required: ${config.title}*`
+              }
+            },
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: questionsText
+              }
+            },
+            {
+              type: "actions",
+              elements: [
+                {
+                  type: "button",
+                  text: { type: "plain_text", text: "Review & Respond" },
+                  url: approvalUrl,
+                  style: "primary"
+                }
+              ]
+            },
+            ...timeoutCaption
+          ];
+          const result = await slackApp.client.chat.postMessage({
+            channel: notification.target,
+            text: `Approval Required: ${config.title} — ${approvalUrl}`,
+            unfurl_links: false,
+            unfurl_media: false,
+            blocks
+          });
+          if (result.ts) {
+            updatedChannels[i] = { ...notification, messageTs: result.ts };
+            updated = true;
+          }
+          console.log(`[HITL] Slack notification sent to ${notification.target} for request ${requestId}`);
+        } catch (err) {
+          console.error(`[HITL] Failed to send Slack notification to ${notification.target}:`, scrubSecrets(err instanceof Error ? err.message : String(err)));
+        }
+      }
+    }
+    if (updated) {
+      try {
+        await db.updateApprovalRequestNotifications(requestId, updatedChannels);
+        const latest = await db.getApprovalRequestById(requestId);
+        if (latest?.status === "cancelled") {
+          await postApprovalCancellationUpdates([latest], latest.resolutionReason ?? "Workflow run cancelled");
+        }
+      } catch (err) {
+        console.error("[HITL] Failed to update notification channels in DB:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+      }
+    }
+  }
+}
+function formatTimeout(seconds) {
+  if (seconds < 60)
+    return `${seconds}s`;
+  if (seconds < 3600)
+    return `${Math.round(seconds / 60)}m`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.round(seconds % 3600 / 60);
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+}
+
+// src/workflows/executors/system-one-providers.ts
+init_openrouter_base_url();
+
+// src/workflows/executors/system-one-wire.ts
+class SystemOneWireError extends Error {
+}
+var VALIDATION_PREFIX = "SystemOne response failed validation: ";
+function wireContractError(message) {
+  throw new SystemOneWireError(`${VALIDATION_PREFIX}${message}`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var SYSTEM_ONE_WIRE = {
+  buildRequest: (config, model) => ({
+    state: config.state,
+    ...model === undefined ? {} : { model },
+    questions: config.questions
+  }),
+  toSystemOne: (body) => body
+};
+var CLOUDFLARE_WIRE = {
+  buildRequest: SYSTEM_ONE_WIRE.buildRequest,
+  toSystemOne(body) {
+    if (!isRecord(body))
+      wireContractError("response body must be a JSON object");
+    if (body.success !== true) {
+      const code = cloudflareErrorCode(body);
+      throw new SystemOneWireError(`Cloudflare Workers AI reported a failed run${code ? ` (${code})` : ""}. No decision was made.`);
+    }
+    if (!isRecord(body.result))
+      wireContractError("Cloudflare response is missing its result");
+    return body.result;
+  }
+};
+var ERROR_CODE_RE = /^[A-Za-z0-9._:-]{1,64}$/;
+function cloudflareErrorCode(body) {
+  const first = Array.isArray(body.errors) ? body.errors[0] : undefined;
+  const code = isRecord(first) ? first.code : undefined;
+  if (typeof code === "number" && Number.isSafeInteger(code))
+    return String(code);
+  return typeof code === "string" && ERROR_CODE_RE.test(code) ? code : undefined;
+}
+
+// src/workflows/executors/system-one-openai-wire.ts
+function entryText(entry) {
+  if (entry === undefined || entry === null)
+    return;
+  return typeof entry === "string" ? entry : JSON.stringify(entry);
+}
+function openaiInput(state) {
+  if (typeof state === "string")
+    return state;
+  if (Array.isArray(state)) {
+    return [
+      {
+        role: "user",
+        content: state.map((text) => ({ type: "input_text", text: String(text) }))
+      }
+    ];
+  }
+  return JSON.stringify(state);
+}
+function openaiQuestion(name, question) {
+  const instructions = entryText(question.instructions) ?? "";
+  switch (question.type) {
+    case "noul": {
+      const whenTrue = entryText(question.criteria?.true);
+      const whenFalse = entryText(question.criteria?.false);
+      const parts = [instructions];
+      if (whenTrue)
+        parts.push(`True when: ${whenTrue}`);
+      if (whenFalse)
+        parts.push(`False when: ${whenFalse}`);
+      return { type: "predicate", name, instructions: parts.join(`
+
+`) };
+    }
+    case "choice":
+      return {
+        type: "choice",
+        name,
+        instructions,
+        choices: Object.entries(question.criteria).map(([value, entry]) => {
+          const description = entryText(entry);
+          return description === undefined ? { value } : { value, description };
+        })
+      };
+    case "score":
+      return {
+        type: "score",
+        name,
+        instructions,
+        levels: question.criteria.map((entry, index) => ({
+          label: entryText(entry) ?? String(index)
+        }))
+      };
+  }
+}
+function probabilityMap(value, at) {
+  if (!Array.isArray(value))
+    return value;
+  const out = {};
+  for (const item of value) {
+    if (!isRecord(item) || typeof item.value !== "string" && typeof item.value !== "number") {
+      wireContractError(`${at} entries must carry a string or number value`);
+    }
+    const key = String(item.value);
+    if (Object.hasOwn(out, key))
+      wireContractError(`${at} lists an option twice`);
+    out[key] = item.probability;
+  }
+  return out;
+}
+function toSystemOneAnswer(id, question, raw) {
+  const at = `answer "${id}".probabilities`;
+  switch (raw.type) {
+    case "predicate":
+      return { type: "noul", noul: raw.probability };
+    case "choice":
+      return {
+        type: "choice",
+        choice: raw.choice,
+        probabilities: probabilityMap(raw.probabilities, at),
+        confidence: raw.confidence
+      };
+    case "score":
+      return {
+        type: "score",
+        score: raw.score,
+        probabilities: probabilityMap(raw.probabilities, at),
+        legend: question.type === "score" ? Object.fromEntries(question.criteria.map((entry, index) => [String(index), entry])) : undefined,
+        confidence: raw.confidence
+      };
+    default:
+      return raw;
+  }
+}
+var OPENAI_DECISIONS_WIRE = {
+  buildRequest: (config, model) => ({
+    ...model === undefined ? {} : { model },
+    input: openaiInput(config.state),
+    questions: Object.entries(config.questions).map(([name, question]) => openaiQuestion(name, question))
+  }),
+  toSystemOne(body, { questions }) {
+    if (!isRecord(body))
+      wireContractError("response body must be a JSON object");
+    if (!Array.isArray(body.answers))
+      wireContractError("response is missing the answers array");
+    const byName = new Map;
+    for (const answer of body.answers) {
+      if (!isRecord(answer) || typeof answer.name !== "string") {
+        wireContractError("every answer must be an object naming its question");
+      }
+      if (!Object.hasOwn(questions, answer.name)) {
+        wireContractError("response contains an answer for an undeclared question");
+      }
+      if (byName.has(answer.name)) {
+        wireContractError(`response answers question "${answer.name}" twice`);
+      }
+      byName.set(answer.name, answer);
+    }
+    const refused = [...byName.values()].filter((answer) => answer.type === "refusal").map((answer) => `"${answer.name}"`);
+    if (refused.length > 0) {
+      throw new SystemOneWireError(`OpenAI refused question${refused.length > 1 ? "s" : ""} ${refused.join(", ")}; no decision was made`);
+    }
+    const answers = {};
+    for (const [id, answer] of byName) {
+      const question = questions[id];
+      if (question)
+        answers[id] = toSystemOneAnswer(id, question, answer);
+    }
+    const usage = isRecord(body.usage) ? { input_tokens: body.usage.input_tokens, output_tokens: body.usage.output_tokens } : body.usage;
+    return { model: body.model, answers, usage };
+  }
+};
+
+// src/workflows/executors/workflow-llm.ts
+init_openrouter_base_url();
+async function resolveWorkflowLlmConfig(requestedModel, env = process.env, options = {}) {
+  const credential = await resolveCredential({ env });
+  if (!credential) {
+    throw new Error("No workflow LLM credential found. Set OPENROUTER_API_KEY or OPENAI_API_KEY.");
+  }
+  if (options.requireKind && credential.kind !== options.requireKind) {
+    throw new Error(`No ${options.requireKind} credential found for this workflow LLM call.`);
+  }
+  if (credential.kind !== "openrouter" && credential.kind !== "openai") {
+    throw new Error(`Workflow LLM nodes do not support the resolved ${credential.kind} credential yet. Set OPENROUTER_API_KEY or OPENAI_API_KEY.`);
+  }
+  const providerPrefix = `${credential.kind}/`;
+  const model = requestedModel ?? DEFAULT_MODEL[credential.kind];
+  const baseURL = credential.kind === "openrouter" ? getOpenRouterBaseUrl(env) : undefined;
+  return {
+    apiKey: credential.apiKey,
+    baseURL,
+    headers: baseURL ? getOpenRouterAttributionHeaders(baseURL, env) : {},
+    model: model.startsWith(providerPrefix) ? model.slice(providerPrefix.length) : model
+  };
+}
+
+// src/workflows/executors/system-one-providers.ts
+var TYPESAFE_KEY = "TYPESAFE_API_KEY";
+var OPENROUTER_KEY = "OPENROUTER_API_KEY";
+var LAYA_KEY = "LAYA_API_KEY";
+var LAYA_URL_KEY = "LAYA_URL";
+var OPENAI_DECISIONS_KEY = "OPENAI_DECISIONS_API_KEY";
+var CLOUDFLARE_TOKEN_KEY = "CLOUDFLARE_API_TOKEN";
+var CLOUDFLARE_ACCOUNT_KEY = "CLOUDFLARE_ACCOUNT_ID";
+var CLOUDFLARE_ACCOUNT_RE = /^[0-9a-f]{32}$/;
+async function readGlobalConfig(db, key) {
+  const rows = await db.getSwarmConfigs({ scope: "global", key });
+  return rows.find((row) => row.scope === "global" && row.key === key)?.value;
+}
+var SYSTEM_ONE_PROVIDERS = {
+  typesafe: {
+    label: "TypeSafe",
+    keyName: TYPESAFE_KEY,
+    endpoint: "https://api.typesafe.ai/v1/systemone",
+    defaultModel: "jev-latest",
+    confidenceField: "confidence",
+    readKey: ({ db }) => readGlobalConfig(db, TYPESAFE_KEY)
+  },
+  openrouter: {
+    label: "OpenRouter",
+    keyName: OPENROUTER_KEY,
+    endpoint: "https://openrouter.ai/api/alpha/decisions",
+    defaultModel: "~typesafe/jev-latest",
+    confidenceField: "confidence",
+    deploymentProblem(env) {
+      return getOpenRouterBaseUrl(env) === DEFAULT_OPENROUTER_BASE_URL ? null : 'OPENROUTER_BASE_URL points at a gateway. SystemOne provider "openrouter" calls openrouter.ai directly and is not supported through a gateway; unset OPENROUTER_BASE_URL or use provider "typesafe".';
+    },
+    async readKey({ env }) {
+      try {
+        return (await resolveWorkflowLlmConfig(undefined, env, { requireKind: "openrouter" })).apiKey;
+      } catch {
+        return null;
+      }
+    }
+  },
+  laya: {
+    label: "laya",
+    keyName: LAYA_KEY,
+    endpoint: { configKey: LAYA_URL_KEY, path: "/v1/systemone" },
+    confidenceField: "answer_confidence",
+    readKey: ({ db }) => readGlobalConfig(db, LAYA_KEY)
+  },
+  openai: {
+    label: "OpenAI",
+    keyName: OPENAI_DECISIONS_KEY,
+    endpoint: "https://api.openai.com/v1/decisions",
+    defaultModel: "gpt-6-luna",
+    confidenceField: "confidence",
+    wire: OPENAI_DECISIONS_WIRE,
+    readKey: ({ db }) => readGlobalConfig(db, OPENAI_DECISIONS_KEY)
+  },
+  cloudflare: {
+    label: "Cloudflare Workers AI",
+    keyName: CLOUDFLARE_TOKEN_KEY,
+    endpoint: {
+      configKey: CLOUDFLARE_ACCOUNT_KEY,
+      describe: "the 32-character id of a Cloudflare account",
+      build: (accountId, model) => {
+        const id = accountId.trim();
+        return CLOUDFLARE_ACCOUNT_RE.test(id) ? `https://api.cloudflare.com/client/v4/accounts/${id}/ai/run/@cf/cloudflare/${model}` : null;
+      }
+    },
+    defaultModel: "clef",
+    allowedModels: ["clef", "clef-flash"],
+    limits: { maxQuestions: 64 },
+    confidenceField: "confidence",
+    wire: CLOUDFLARE_WIRE,
+    readKey: ({ db }) => readGlobalConfig(db, CLOUDFLARE_TOKEN_KEY)
+  }
+};
+var SYSTEM_ONE_PROVIDER_IDS = Object.keys(SYSTEM_ONE_PROVIDERS);
+var SYSTEM_ONE_DEFAULT_PROVIDER = "typesafe";
+function isSystemOneProviderId(value) {
+  return typeof value === "string" && Object.hasOwn(SYSTEM_ONE_PROVIDERS, value);
+}
+function systemOneProviderOf(config) {
+  if (config.provider === undefined)
+    return SYSTEM_ONE_DEFAULT_PROVIDER;
+  return isSystemOneProviderId(config.provider) ? config.provider : undefined;
+}
+var SET_IT = (keyName) => `Set ${keyName} as a global secret on the Secrets page (Settings > Secrets).`;
+var SET_URL = (configKey) => `Set ${configKey} as a global config value (set-config with scope global).`;
+function systemOneKeyMissingMessage(id) {
+  const { label, keyName } = SYSTEM_ONE_PROVIDERS[id];
+  return `${keyName} is not configured. SystemOne provider "${id}" needs a working ${label} API key. ${SET_IT(keyName)}`;
+}
+function systemOneKeyUnreadableMessage(id) {
+  return `Could not read ${SYSTEM_ONE_PROVIDERS[id].keyName} from swarm config`;
+}
+function systemOneKeyMalformedMessage(id) {
+  return `${SYSTEM_ONE_PROVIDERS[id].keyName} is not a valid bearer token value. ${SET_IT(SYSTEM_ONE_PROVIDERS[id].keyName)}`;
+}
+function systemOneKeyRejectedMessage(id, status, code) {
+  const { label, keyName } = SYSTEM_ONE_PROVIDERS[id];
+  const detail = code ? ` (${code})` : "";
+  return `${keyName} was rejected by ${label} (HTTP ${status}${detail}). ` + `The key is invalid, revoked, or lacks access to the model. Replace it on the Secrets page (Settings > Secrets). No decision was made.`;
+}
+function urlKeyOf(provider) {
+  return typeof provider.endpoint === "string" ? null : provider.endpoint.configKey;
+}
+function isBuiltEndpoint(endpoint) {
+  return typeof endpoint !== "string" && "build" in endpoint;
+}
+function urlDescriptionOf(provider) {
+  return isBuiltEndpoint(provider.endpoint) ? provider.endpoint.describe : `the URL of a ${provider.label} server`;
+}
+function systemOneUrlMissingMessage(id) {
+  const provider = SYSTEM_ONE_PROVIDERS[id];
+  const configKey = urlKeyOf(provider) ?? "";
+  return `${configKey} is not configured. SystemOne provider "${id}" needs ${urlDescriptionOf(provider)}. ${SET_URL(configKey)}`;
+}
+function systemOneUrlUnreadableMessage(id) {
+  return `Could not read ${urlKeyOf(SYSTEM_ONE_PROVIDERS[id]) ?? ""} from swarm config`;
+}
+function systemOneUrlInvalidMessage(id) {
+  const provider = SYSTEM_ONE_PROVIDERS[id];
+  const configKey = urlKeyOf(provider) ?? "";
+  if (isBuiltEndpoint(provider.endpoint)) {
+    return `${configKey} is not ${provider.endpoint.describe}. ${SET_URL(configKey)}`;
+  }
+  return `${configKey} is not a usable ${provider.label} server URL. It must be an https URL (http only for localhost) with no credentials, query, or fragment. ${SET_URL(configKey)}`;
+}
+function systemOneModelProblem(id, model) {
+  const { allowedModels } = SYSTEM_ONE_PROVIDERS[id];
+  if (!allowedModels || model !== undefined && allowedModels.includes(model))
+    return null;
+  return `SystemOne provider "${id}" serves only the models ${allowedModels.join(", ")}; set model to one of them or leave it unset.`;
+}
+function systemOneQuestionLimitProblem(id, count) {
+  const max = SYSTEM_ONE_PROVIDERS[id].limits?.maxQuestions;
+  return max !== undefined && count > max ? `SystemOne provider "${id}" takes at most ${max} questions per node; this node has ${count}.` : null;
+}
+function hasWhitespaceOrControl(value) {
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code <= 32 || code === 127)
+      return true;
+  }
+  return false;
+}
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+function systemOneEndpointFromBase(base, path) {
+  let url;
+  try {
+    url = new URL(base.trim());
+  } catch {
+    return null;
+  }
+  const secure = url.protocol === "https:";
+  const loopback = url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname);
+  if (!secure && !loopback)
+    return null;
+  if (url.username || url.password || url.search || url.hash)
+    return null;
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}${path}`;
+}
+async function resolveSystemOneTarget(id, ctx, overrides = {}) {
+  const provider = SYSTEM_ONE_PROVIDERS[id];
+  const deploymentProblem = provider.deploymentProblem?.(ctx.env);
+  if (deploymentProblem)
+    return { ok: false, error: deploymentProblem };
+  const errors = [];
+  let endpoint;
+  if (typeof provider.endpoint === "string") {
+    endpoint = provider.endpoint;
+  } else {
+    const { configKey } = provider.endpoint;
+    let base;
+    let readable = true;
+    try {
+      base = await (overrides.serverUrl ? overrides.serverUrl(id) : readGlobalConfig(ctx.db, configKey));
+    } catch {
+      readable = false;
+      errors.push(systemOneUrlUnreadableMessage(id));
+    }
+    if (readable) {
+      if (!base || base.trim() === "") {
+        errors.push(systemOneUrlMissingMessage(id));
+      } else {
+        const resolved = isBuiltEndpoint(provider.endpoint) ? provider.endpoint.build(base, overrides.model ?? provider.defaultModel ?? "") : systemOneEndpointFromBase(base, provider.endpoint.path);
+        if (resolved)
+          endpoint = resolved;
+        else
+          errors.push(systemOneUrlInvalidMessage(id));
+      }
+    }
+  }
+  let apiKey;
+  let keyProblem;
+  try {
+    apiKey = await (overrides.apiKey ? overrides.apiKey(id) : provider.readKey(ctx));
+  } catch {
+    keyProblem = systemOneKeyUnreadableMessage(id);
+  }
+  if (!keyProblem) {
+    if (!apiKey || apiKey.trim() === "")
+      keyProblem = systemOneKeyMissingMessage(id);
+    else if (hasWhitespaceOrControl(apiKey))
+      keyProblem = systemOneKeyMalformedMessage(id);
+  }
+  if (keyProblem)
+    errors.push(keyProblem);
+  if (errors.length > 0 || !endpoint || !apiKey)
+    return { ok: false, error: errors.join(" ") };
+  return { ok: true, apiKey, endpoint };
+}
+
+// src/workflows/executors/system-one-decision.ts
+var SYSTEM_ONE_DECISION_NODE_TYPE = "system-one-decision";
+var SYSTEM_ONE_ENDPOINT = SYSTEM_ONE_PROVIDERS.typesafe.endpoint;
+var SYSTEM_ONE_API_KEY_CONFIG_KEY = SYSTEM_ONE_PROVIDERS.typesafe.keyName;
+var SYSTEM_ONE_DEFAULT_TIMEOUT_MS = 30000;
+var SYSTEM_ONE_MIN_TIMEOUT_MS = 1000;
+var SYSTEM_ONE_MAX_TIMEOUT_MS = 300000;
+var SYSTEM_ONE_DEFAULT_MAX_RETRIES = 2;
+var SYSTEM_ONE_MAX_RETRIES_LIMIT = 3;
+var CHOICE_MIN_OPTIONS = 2;
+var CHOICE_MAX_OPTIONS = 255;
+var SCORE_MIN_LEVELS = 2;
+var SCORE_MAX_LEVELS = 10;
+var DEADLINE_MARGIN_MS = 250;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_CAP_MS = 8000;
+var DISTRIBUTION_TOLERANCE = 0.02;
+var MAX_RESPONSE_CHARS = 1048576;
+var MAX_ERROR_BODY_CHARS = 65536;
+var REVIEW_PORTS = ["approved", "rejected", "timeout"];
+var ENGINE_RETRY_DEFAULT = 3;
+var SystemOneEntrySchema = exports_external.union([
+  exports_external.string(),
+  exports_external.null(),
+  exports_external.array(exports_external.unknown()),
+  exports_external.record(exports_external.string(), exports_external.unknown())
+]);
+var SystemOneInstructionsSchema = SystemOneEntrySchema.refine((value) => value !== null && !(typeof value === "string" && value.trim() === ""), { message: "instructions must not be null or blank" });
+var SystemOneStateSchema = exports_external.union([
+  exports_external.string().min(1, "state must not be empty"),
+  exports_external.array(exports_external.string()).min(1, "state must not be an empty array"),
+  exports_external.record(exports_external.string(), exports_external.unknown())
+]);
+var NoulQuestionSchema = exports_external.strictObject({
+  type: exports_external.literal("noul"),
+  instructions: SystemOneInstructionsSchema,
+  criteria: exports_external.strictObject({ true: SystemOneEntrySchema.optional(), false: SystemOneEntrySchema.optional() }).refine((criteria) => criteria.true !== undefined || criteria.false !== undefined, {
+    message: "noul criteria must describe at least one of true / false"
+  }).optional()
+});
+var ChoiceQuestionSchema = exports_external.strictObject({
+  type: exports_external.literal("choice"),
+  instructions: SystemOneInstructionsSchema,
+  criteria: exports_external.record(exports_external.string().min(1), SystemOneEntrySchema).refine((criteria) => {
+    const count = Object.keys(criteria).length;
+    return count >= CHOICE_MIN_OPTIONS && count <= CHOICE_MAX_OPTIONS;
+  }, {
+    message: `choice criteria must define ${CHOICE_MIN_OPTIONS}-${CHOICE_MAX_OPTIONS} options`
+  })
+});
+var ScoreQuestionSchema = exports_external.strictObject({
+  type: exports_external.literal("score"),
+  instructions: SystemOneInstructionsSchema,
+  criteria: exports_external.array(SystemOneEntrySchema).min(SCORE_MIN_LEVELS).max(SCORE_MAX_LEVELS)
+});
+var SystemOneQuestionSchema = exports_external.discriminatedUnion("type", [
+  NoulQuestionSchema,
+  ChoiceQuestionSchema,
+  ScoreQuestionSchema
+]);
+var Unit = exports_external.number().min(0).max(1);
+var QUESTION_ID_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+var RESERVED_QUESTION_IDS = new Set([
+  ...Object.getOwnPropertyNames(Object.prototype),
+  "prototype"
+]);
+var SystemOnePrimitiveTypeSchema = exports_external.enum(["noul", "choice", "score"]);
+var HumanReviewSchema = exports_external.strictObject({
+  band: exports_external.strictObject({ min: Unit, max: Unit }).refine((band) => band.min <= band.max, { message: "band.min must not exceed band.max" }),
+  approvers: ApproverConfigSchema,
+  title: exports_external.string().min(1).optional(),
+  timeout: HITLTimeoutSchema.optional(),
+  notifications: exports_external.array(NotificationConfigSchema).optional()
+});
+var SystemOneDecisionConfigSchema = exports_external.strictObject({
+  provider: exports_external.enum(SYSTEM_ONE_PROVIDER_IDS).default(SYSTEM_ONE_DEFAULT_PROVIDER),
+  model: exports_external.string().min(1).optional(),
+  state: SystemOneStateSchema,
+  timeoutMs: exports_external.number().int().min(SYSTEM_ONE_MIN_TIMEOUT_MS).max(SYSTEM_ONE_MAX_TIMEOUT_MS).default(SYSTEM_ONE_DEFAULT_TIMEOUT_MS),
+  maxRetries: exports_external.number().int().min(0).max(SYSTEM_ONE_MAX_RETRIES_LIMIT).default(SYSTEM_ONE_DEFAULT_MAX_RETRIES),
+  questions: exports_external.record(exports_external.string().regex(QUESTION_ID_RE, "question ids must start with a letter or underscore and use only letters, digits, _ or -"), SystemOneQuestionSchema),
+  returns: exports_external.record(exports_external.string(), exports_external.strictObject({ type: SystemOnePrimitiveTypeSchema })),
+  humanReview: HumanReviewSchema.optional()
+}).superRefine((config, ctx) => {
+  const questionIds = Object.keys(config.questions);
+  if (questionIds.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["questions"],
+      message: "system-one-decision needs at least one question"
+    });
+  }
+  for (const id of questionIds) {
+    if (RESERVED_QUESTION_IDS.has(id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["questions", id],
+        message: `"${id}" is reserved and cannot be a question id`
+      });
+    }
+    const declared = Object.hasOwn(config.returns, id) ? config.returns[id] : undefined;
+    if (!declared) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["returns"],
+        message: `returns must declare question "${id}"`
+      });
+    } else if (declared.type !== config.questions[id]?.type) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["returns", id, "type"],
+        message: `returns.${id}.type is "${declared.type}" but question "${id}" is "${config.questions[id]?.type}"`
+      });
+    }
+  }
+  for (const id of Object.keys(config.returns)) {
+    if (!Object.hasOwn(config.questions, id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["returns", id],
+        message: `returns declares "${id}" but no question has that id`
+      });
+    }
+  }
+  const modelProblem = systemOneModelProblem(config.provider, config.model ?? SYSTEM_ONE_PROVIDERS[config.provider].defaultModel);
+  if (modelProblem)
+    ctx.addIssue({ code: "custom", path: ["model"], message: modelProblem });
+  const limitProblem = systemOneQuestionLimitProblem(config.provider, questionIds.length);
+  if (limitProblem)
+    ctx.addIssue({ code: "custom", path: ["questions"], message: limitProblem });
+});
+var NoulAnswerSchema = exports_external.strictObject({ type: exports_external.literal("noul"), noul: Unit });
+var ChoiceAnswerSchema = exports_external.strictObject({
+  type: exports_external.literal("choice"),
+  choice: exports_external.string(),
+  probabilities: exports_external.record(exports_external.string(), Unit),
+  confidence: Unit
+});
+var ScoreAnswerSchema = exports_external.strictObject({
+  type: exports_external.literal("score"),
+  score: exports_external.number(),
+  legend: exports_external.record(exports_external.string(), SystemOneEntrySchema),
+  probabilities: exports_external.record(exports_external.string(), Unit),
+  confidence: Unit
+});
+var SystemOneAnswerSchema = exports_external.discriminatedUnion("type", [
+  NoulAnswerSchema,
+  ChoiceAnswerSchema,
+  ScoreAnswerSchema
+]);
+var ReviewQuestionSchema = exports_external.strictObject({
+  confidence: Unit,
+  inBand: exports_external.boolean(),
+  decidedBy: exports_external.enum(["model", "human"]),
+  modelAnswer: exports_external.union([exports_external.string(), exports_external.number()]).optional()
+});
+var ReviewSchema = exports_external.strictObject({
+  status: exports_external.enum(["not_required", "pending", "approved", "rejected", "timeout"]),
+  approvalRequestId: exports_external.string().optional(),
+  reason: exports_external.string().optional(),
+  questions: exports_external.record(exports_external.string(), ReviewQuestionSchema)
+});
+var SystemOneDecisionOutputSchema = exports_external.object({
+  model: exports_external.string().min(1),
+  answers: exports_external.record(exports_external.string(), SystemOneAnswerSchema),
+  usage: exports_external.object({
+    input_tokens: exports_external.number().int().min(0),
+    output_tokens: exports_external.number().int().min(0)
+  }),
+  requestId: exports_external.string().optional(),
+  routing: exports_external.strictObject({ model: exports_external.string().min(1) }).optional(),
+  review: ReviewSchema.optional()
+});
+function systemOneRetryViolations(node) {
+  if (node.type !== SYSTEM_ONE_DECISION_NODE_TYPE)
+    return [];
+  const violations = [];
+  const attempts = (retry) => retry ? retry.maxRetries ?? ENGINE_RETRY_DEFAULT : 0;
+  if (attempts(node.retry) > 0) {
+    violations.push(`Node "${node.id}" (system-one-decision) must not set retry.maxRetries > 0: the system-one-decision executor retries transient transport errors itself (config.maxRetries), and engine retries would re-send rejected requests`);
+  }
+  if (attempts(node.validation?.retry) > 0) {
+    violations.push(`Node "${node.id}" (system-one-decision) must not set validation.retry.maxRetries > 0: a validation-driven retry would send another paid request`);
+  }
+  return violations;
+}
+function systemOneStaticShapeViolations(node) {
+  if (node.type !== SYSTEM_ONE_DECISION_NODE_TYPE)
+    return [];
+  const violations = [];
+  for (const field of ["questions", "returns"]) {
+    const value = node.config[field];
+    if (value !== undefined && (typeof value !== "object" || value === null || Array.isArray(value))) {
+      violations.push(`Node "${node.id}" (system-one-decision) config.${field} must be an object: question ids and return types are static, only state and descriptions may use {{tokens}}`);
+    }
+  }
+  const provider = node.config.provider;
+  if (typeof provider === "string" && provider.includes("{{")) {
+    violations.push(`Node "${node.id}" (system-one-decision) config.provider must be a literal (${SYSTEM_ONE_PROVIDER_IDS.join(", ")}), not a {{token}}: the provider decides which credential is checked before the run starts`);
+  }
+  if (isRecord2(node.config.humanReview) && node.next != null) {
+    if (typeof node.next === "string" || Array.isArray(node.next)) {
+      violations.push(`Node "${node.id}" (system-one-decision) sets humanReview, so next must map output ports (${REVIEW_PORTS.join(", ")}): a single or list next would run the same successors after a rejection or a timeout`);
+    } else {
+      const ports = Object.keys(node.next);
+      const unknown = ports.filter((port) => !REVIEW_PORTS.includes(port));
+      if (unknown.length > 0) {
+        violations.push(`Node "${node.id}" (system-one-decision) sets humanReview, so next ports must be ${REVIEW_PORTS.join(", ")}; got ${unknown.map((port) => `"${port}"`).join(", ")}`);
+      }
+      if (!ports.includes("approved")) {
+        violations.push(`Node "${node.id}" (system-one-decision) sets humanReview, so next must define the "approved" port: it carries every answer that is accepted, by the model or by a person`);
+      }
+    }
+  }
+  return violations;
+}
+function systemOneUnresolvedError(nodeId, tokens) {
+  const rendered = [...new Set(tokens)].map((token) => `{{${token}}}`).join(", ");
+  return `SystemOne Decision node "${nodeId}" has unresolved interpolation token(s): ${rendered}. ` + "No request was sent. Declare the value in the node's inputs mapping or fix the path.";
+}
+
+class SystemOneContractError extends Error {
+}
+function fail(message) {
+  throw new SystemOneContractError(message);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unit(value, what) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    fail(`${what} must be a finite number between 0 and 1`);
+  }
+  return value;
+}
+function distribution(value, keys, what) {
+  if (!isRecord2(value))
+    fail(`${what} must be an object`);
+  const actual = Object.keys(value);
+  const missing = keys.filter((key) => !Object.hasOwn(value, key));
+  const extra = actual.filter((key) => !keys.includes(key));
+  if (missing.length > 0 || extra.length > 0) {
+    fail(`${what} keys must be exactly the declared ${keys.length} option(s)` + (missing.length > 0 ? `; missing ${missing.length}` : "") + (extra.length > 0 ? `; ${extra.length} unexpected` : ""));
+  }
+  const out = {};
+  let sum = 0;
+  for (const key of keys) {
+    const p = unit(value[key], `${what}["${key}"]`);
+    out[key] = p;
+    sum += p;
+  }
+  if (Math.abs(sum - 1) > DISTRIBUTION_TOLERANCE) {
+    fail(`${what} must sum to 1 (within ${DISTRIBUTION_TOLERANCE})`);
+  }
+  return out;
+}
+function validateAnswer(id, question, raw, confidenceField) {
+  const at = `answer "${id}"`;
+  if (!isRecord2(raw))
+    fail(`${at} must be an object`);
+  if (raw.type !== question.type) {
+    fail(`${at} has type ${JSON.stringify(raw.type)} but the question declares "${question.type}"`);
+  }
+  switch (question.type) {
+    case "noul":
+      return { type: "noul", noul: unit(raw.noul, `${at}.noul`) };
+    case "choice": {
+      const options = Object.keys(question.criteria);
+      if (typeof raw.choice !== "string" || !Object.hasOwn(question.criteria, raw.choice)) {
+        fail(`${at}.choice is not one of the declared options`);
+      }
+      return {
+        type: "choice",
+        choice: raw.choice,
+        probabilities: distribution(raw.probabilities, options, `${at}.probabilities`),
+        confidence: unit(raw[confidenceField], `${at}.${confidenceField}`)
+      };
+    }
+    case "score": {
+      const indices = question.criteria.map((_, index) => String(index));
+      const top = indices.length - 1;
+      if (typeof raw.score !== "number" || !Number.isFinite(raw.score) || raw.score < 0 || raw.score > top) {
+        fail(`${at}.score must be a finite number between 0 and ${top}`);
+      }
+      if (!isRecord2(raw.legend))
+        fail(`${at}.legend must be an object`);
+      const legend = {};
+      for (const key of indices) {
+        if (!Object.hasOwn(raw.legend, key))
+          fail(`${at}.legend is missing level ${key}`);
+        const entry = SystemOneEntrySchema.safeParse(raw.legend[key]);
+        if (!entry.success)
+          fail(`${at}.legend["${key}"] must be a string, object, array, or null`);
+        legend[key] = entry.data;
+      }
+      return {
+        type: "score",
+        score: raw.score,
+        legend,
+        probabilities: distribution(raw.probabilities, indices, `${at}.probabilities`),
+        confidence: unit(raw[confidenceField], `${at}.${confidenceField}`)
+      };
+    }
+  }
+}
+var MAX_ROUTING_MODEL_CHARS = 128;
+function readRoutingModel(routing) {
+  if (!isRecord2(routing))
+    return;
+  const { model } = routing;
+  return typeof model === "string" && model !== "" && model.length <= MAX_ROUTING_MODEL_CHARS ? model : undefined;
+}
+function validateSystemOneResponse(questions, body, requestId, confidenceField = "confidence") {
+  if (!isRecord2(body))
+    fail("response body must be a JSON object");
+  if (typeof body.model !== "string" || body.model === "") {
+    fail("response is missing the model that produced the answers");
+  }
+  if (!isRecord2(body.answers))
+    fail("response is missing the answers object");
+  const usage = exports_external.object({ input_tokens: exports_external.number().int().min(0), output_tokens: exports_external.number().int().min(0) }).safeParse(body.usage);
+  if (!usage.success)
+    fail("response usage must report non-negative integer input_tokens and output_tokens");
+  const declared = Object.keys(questions);
+  const unexpected = Object.keys(body.answers).filter((id) => !Object.hasOwn(questions, id));
+  if (unexpected.length > 0)
+    fail(`response contains ${unexpected.length} answer(s) for undeclared questions`);
+  const answers = {};
+  for (const id of declared) {
+    if (!Object.hasOwn(body.answers, id))
+      fail(`response is missing the answer for question "${id}"`);
+    const question = questions[id];
+    if (!question)
+      fail(`question "${id}" is not defined`);
+    answers[id] = validateAnswer(id, question, body.answers[id], confidenceField);
+  }
+  if (declared.length === 0)
+    fail("a system-one-decision call needs at least one question");
+  const routingModel = readRoutingModel(body.routing);
+  return {
+    model: body.model,
+    answers,
+    usage: usage.data,
+    ...requestId ? { requestId } : {},
+    ...routingModel ? { routing: { model: routingModel } } : {}
+  };
+}
+var REVIEW_CONFIRM_ID = "$confirm";
+var REVIEW_STATE_CHARS = 2000;
+var REVIEW_LABEL_CHARS = 160;
+var REVIEW_OPTION_CHARS = 200;
+var round6 = (value) => Math.round(value * 1e6) / 1e6;
+function answerConfidence(answer) {
+  return answer.type === "noul" ? round6(Math.max(answer.noul, 1 - answer.noul)) : answer.confidence;
+}
+function clip(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function showEntry(entry, max) {
+  return clip(typeof entry === "string" ? entry : JSON.stringify(entry) ?? "", max);
+}
+function modelAnswerOf(answer) {
+  return answer.type === "choice" ? answer.choice : answer.type === "score" ? answer.score : answer.noul;
+}
+function buildReviewCard(nodeId, config, review, parked) {
+  const state = scrubSecrets(typeof config.state === "string" ? config.state : JSON.stringify(config.state) ?? "");
+  const questions = [
+    {
+      id: REVIEW_CONFIRM_ID,
+      type: "approval",
+      label: "Accept these answers and continue?",
+      required: true,
+      description: `Model ${parked.model}. Input: ${clip(state, REVIEW_STATE_CHARS)}`
+    }
+  ];
+  for (const [id, info] of Object.entries(parked.review?.questions ?? {})) {
+    if (!info.inBand)
+      continue;
+    const question = config.questions[id];
+    const answer = parked.answers[id];
+    if (!question || !answer)
+      continue;
+    const label = `${id}: ${showEntry(question.instructions, REVIEW_LABEL_CHARS)}`;
+    const said = `The model answered ${JSON.stringify(modelAnswerOf(answer))} at confidence ${info.confidence}.`;
+    if (question.type === "choice" && answer.type === "choice") {
+      questions.push({
+        id,
+        type: "single-select",
+        label,
+        required: false,
+        description: `${said} Leave empty to confirm it, or pick another option.`,
+        options: Object.entries(question.criteria).map(([value, entry]) => ({
+          value,
+          label: value,
+          ...typeof entry === "string" && entry ? { description: clip(entry, REVIEW_OPTION_CHARS) } : {}
+        }))
+      });
+    } else if (question.type === "score" && answer.type === "score") {
+      questions.push({
+        id,
+        type: "single-select",
+        label,
+        required: false,
+        description: `${said} Leave empty to confirm it, or pick a level.`,
+        options: question.criteria.map((entry, level) => ({
+          value: String(level),
+          label: `${level}: ${showEntry(entry, REVIEW_OPTION_CHARS)}`
+        }))
+      });
+    } else if (question.type === "noul" && answer.type === "noul") {
+      questions.push({
+        id,
+        type: "boolean",
+        label,
+        required: false,
+        defaultValue: answer.noul >= 0.5,
+        description: `${said} The switch starts on the side the model took.`
+      });
+    }
+  }
+  return {
+    title: review.title ?? `Review decision: ${nodeId}`,
+    questions,
+    approvers: review.approvers,
+    ...review.timeout ? { timeout: review.timeout } : {},
+    ...review.notifications ? { notifications: review.notifications } : {}
+  };
+}
+function readHumanAnswer(answer, response) {
+  if (response === undefined || response === null || response === "")
+    return { kind: "confirm" };
+  switch (answer.type) {
+    case "choice":
+      if (typeof response !== "string" || !Object.hasOwn(answer.probabilities, response)) {
+        return { kind: "invalid" };
+      }
+      return response === answer.choice ? { kind: "confirm" } : { kind: "override", answer: { ...answer, choice: response } };
+    case "score": {
+      if (typeof response !== "string" || !Object.hasOwn(answer.legend, response)) {
+        return { kind: "invalid" };
+      }
+      const level = Number(response);
+      return level === answer.score ? { kind: "confirm" } : { kind: "override", answer: { ...answer, score: level } };
+    }
+    case "noul":
+      if (typeof response !== "boolean")
+        return { kind: "invalid" };
+      return response === answer.noul >= 0.5 ? { kind: "confirm" } : { kind: "override", answer: { ...answer, noul: response ? 1 : 0 } };
+  }
+}
+function resolveReviewedDecision(parkedOutput, approval) {
+  const parked = SystemOneDecisionOutputSchema.safeParse(parkedOutput);
+  if (!parked.success || parked.data.review?.status !== "pending")
+    return null;
+  const decision = parked.data;
+  const parkedQuestions = decision.review?.questions ?? {};
+  const finish = (status, answers2, questions2, reason) => ({
+    output: {
+      ...decision,
+      answers: answers2,
+      review: {
+        status,
+        approvalRequestId: approval.requestId,
+        ...reason ? { reason } : {},
+        questions: questions2
+      }
+    },
+    nextPort: status
+  });
+  if (approval.status !== "approved") {
+    return finish(approval.status, decision.answers, parkedQuestions);
+  }
+  const answers = { ...decision.answers };
+  const questions = { ...parkedQuestions };
+  for (const [id, info] of Object.entries(parkedQuestions)) {
+    const modelAnswer = decision.answers[id];
+    if (!info.inBand || !modelAnswer)
+      continue;
+    const human = readHumanAnswer(modelAnswer, approval.responses?.[id]);
+    if (human.kind === "invalid") {
+      return finish("rejected", decision.answers, parkedQuestions, `The response for "${id}" is not one of its options`);
+    }
+    if (human.kind === "override")
+      answers[id] = human.answer;
+    questions[id] = { ...info, decidedBy: "human", modelAnswer: modelAnswerOf(modelAnswer) };
+  }
+  return finish("approved", answers, questions);
+}
+var REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+var ERROR_CODE_RE2 = /^[A-Za-z0-9._:-]{1,64}$/;
+function readRequestId(headers) {
+  const value = headers.get("x-request-id") ?? headers.get("request-id") ?? headers.get("cf-ray");
+  return value && REQUEST_ID_RE.test(value) ? value : undefined;
+}
+function parseRetryAfter(value, now) {
+  if (!value)
+    return;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed))
+    return Math.round(Number(trimmed) * 1000);
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
+}
+function readErrorCode(text) {
+  if (text.length === 0 || text.length > MAX_ERROR_BODY_CHARS)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (!isRecord2(parsed))
+    return;
+  const nested = isRecord2(parsed.error) ? parsed.error : undefined;
+  const detail = isRecord2(parsed.detail) ? parsed.detail : undefined;
+  for (const candidate of [
+    nested?.code,
+    nested?.type,
+    detail?.error_type,
+    parsed.code,
+    parsed.type
+  ]) {
+    if (typeof candidate === "string" && ERROR_CODE_RE2.test(candidate))
+      return candidate;
+  }
+  return cloudflareErrorCode(parsed);
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
+class SystemOneDecisionExecutor extends BaseExecutor {
+  options;
+  type = SYSTEM_ONE_DECISION_NODE_TYPE;
+  mode = "async";
+  configSchema = SystemOneDecisionConfigSchema;
+  outputSchema = SystemOneDecisionOutputSchema;
+  constructor(deps, options = {}) {
+    super(deps);
+    this.options = options;
+  }
+  providerContext() {
+    return { db: this.deps.db, env: this.options.env ?? process.env };
+  }
+  resolveTarget(id, model) {
+    return resolveSystemOneTarget(id, this.providerContext(), {
+      apiKey: this.options.getApiKey,
+      serverUrl: this.options.getServerUrl,
+      model
+    });
+  }
+  async checkReadiness(nodes) {
+    const nodeIdsByProvider = new Map;
+    for (const node of nodes) {
+      const id = systemOneProviderOf(node.config);
+      if (id)
+        nodeIdsByProvider.set(id, [...nodeIdsByProvider.get(id) ?? [], node.id]);
+    }
+    const problems = [];
+    for (const [id, nodeIds] of nodeIdsByProvider) {
+      const target = await this.resolveTarget(id);
+      if (!target.ok)
+        problems.push({ nodeIds, message: target.error });
+    }
+    return problems;
+  }
+  async execute(config, context, meta) {
+    if (config.humanReview) {
+      const existing = await this.deps.db.getApprovalRequestByStepId(meta.stepId);
+      if (existing) {
+        return this.handOffToReviewer(config, await this.readParked(meta.stepId), context, meta);
+      }
+    }
+    const providerId = config.provider;
+    const provider = SYSTEM_ONE_PROVIDERS[providerId];
+    const model = config.model ?? provider.defaultModel;
+    const modelProblem = systemOneModelProblem(providerId, model);
+    if (modelProblem)
+      return { status: "failed", error: modelProblem };
+    const target = await this.resolveTarget(providerId, model);
+    if (!target.ok)
+      return { status: "failed", error: target.error };
+    const { apiKey, endpoint } = target;
+    const wire = provider.wire ?? SYSTEM_ONE_WIRE;
+    const body = JSON.stringify(wire.buildRequest(config, model));
+    const scrub = (message) => message.split(apiKey).join("[REDACTED]");
+    const sent = await this.send(providerId, endpoint, apiKey, body, config.timeoutMs, config.maxRetries);
+    if (!sent.ok)
+      return { status: "failed", error: scrub(sent.error) };
+    let parsed;
+    try {
+      parsed = JSON.parse(sent.text);
+    } catch {
+      return { status: "failed", error: "SystemOne response was not valid JSON" };
+    }
+    let decision;
+    try {
+      decision = validateSystemOneResponse(config.questions, wire.toSystemOne(parsed, { questions: config.questions, model }), sent.requestId, provider.confidenceField);
+    } catch (err) {
+      if (err instanceof SystemOneWireError) {
+        const withId = sent.requestId ? `${err.message} [request ${sent.requestId}]` : err.message;
+        return { status: "failed", error: scrub(withId) };
+      }
+      if (err instanceof SystemOneContractError) {
+        return {
+          status: "failed",
+          error: scrub(`SystemOne response failed validation: ${err.message}`)
+        };
+      }
+      throw err;
+    }
+    if (!config.humanReview)
+      return { status: "success", output: decision };
+    return this.reviewDecision(config, config.humanReview, decision, context, meta);
+  }
+  async reviewDecision(config, review, decision, context, meta) {
+    const questions = {};
+    for (const [id, answer] of Object.entries(decision.answers)) {
+      const confidence = answerConfidence(answer);
+      questions[id] = {
+        confidence,
+        inBand: confidence >= review.band.min && confidence <= review.band.max,
+        decidedBy: "model"
+      };
+    }
+    if (!Object.values(questions).some((question) => question.inBand)) {
+      return {
+        status: "success",
+        output: { ...decision, review: { status: "not_required", questions } },
+        nextPort: "approved"
+      };
+    }
+    const parked = {
+      ...decision,
+      review: { status: "pending", questions }
+    };
+    await this.deps.db.updateWorkflowRunStep(meta.stepId, { output: parked });
+    return this.handOffToReviewer(config, parked, context, meta);
+  }
+  async readParked(stepId) {
+    const step = await this.deps.db.getWorkflowRunStep(stepId);
+    const parked = SystemOneDecisionOutputSchema.safeParse(step?.output);
+    return parked.success && parked.data.review?.status === "pending" ? parked.data : null;
+  }
+  async handOffToReviewer(config, parked, context, meta) {
+    if (!parked || !config.humanReview) {
+      return {
+        status: "failed",
+        error: "The decision this step parked with is missing, so its approval cannot be resumed. Run the node again."
+      };
+    }
+    const result = await new HumanInTheLoopExecutor(this.deps).run({
+      config: buildReviewCard(meta.nodeId, config, config.humanReview, parked),
+      context,
+      meta
+    });
+    if (result.status === "failed")
+      return { status: "failed", error: result.error };
+    if ("async" in result)
+      return result;
+    const answered = result.output;
+    const outcome = answered ? this.resolveApproval(parked, {
+      requestId: answered.requestId,
+      status: answered.status,
+      responses: answered.responses
+    }) : null;
+    if (!outcome) {
+      return {
+        status: "failed",
+        error: "The approval was answered but its result could not be applied"
+      };
+    }
+    return {
+      status: "success",
+      output: outcome.output,
+      nextPort: outcome.nextPort
+    };
+  }
+  resolveApproval(parkedOutput, approval) {
+    return resolveReviewedDecision(parkedOutput, approval);
+  }
+  async send(providerId, endpoint, apiKey, body, timeoutMs, maxRetries) {
+    const doFetch = this.options.fetch ?? fetch;
+    const sleep = this.options.sleep ?? defaultSleep;
+    const now = this.options.now ?? Date.now;
+    const random = this.options.random ?? Math.random;
+    const deadlineAt = now() + timeoutMs - DEADLINE_MARGIN_MS;
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), Math.max(0, deadlineAt - now()));
+    const timedOut = () => ({
+      ok: false,
+      error: `SystemOne request exceeded its ${timeoutMs}ms time budget`
+    });
+    try {
+      for (let attempt = 0;; attempt++) {
+        const result = await this.attemptOnce(doFetch, providerId, endpoint, apiKey, body, controller.signal, now);
+        if (result.kind === "ok") {
+          return { ok: true, text: result.text, requestId: result.requestId };
+        }
+        if (result.kind === "timeout" || controller.signal.aborted)
+          return timedOut();
+        const attempts = attempt + 1;
+        const suffix = attempts > 1 ? ` after ${attempts} attempts` : "";
+        if (!result.retryable || attempt >= maxRetries) {
+          return { ok: false, error: `${result.message}${suffix}` };
+        }
+        const backoff = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt);
+        const delay = result.retryAfterMs ?? Math.round(backoff * (0.5 + random() * 0.5));
+        if (delay >= deadlineAt - now()) {
+          return {
+            ok: false,
+            error: `${result.message}${suffix}; the ${delay}ms retry delay does not fit the ${timeoutMs}ms time budget`
+          };
+        }
+        await sleep(delay, controller.signal);
+        if (controller.signal.aborted)
+          return timedOut();
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async attemptOnce(doFetch, providerId, endpoint, apiKey, body, signal, now) {
+    let res;
+    try {
+      res = await doFetch(endpoint, {
+        method: "POST",
+        headers: {
+          ...getOpenRouterAttributionHeaders(endpoint, this.providerContext().env),
+          "content-type": "application/json",
+          accept: "application/json",
+          authorization: `Bearer ${apiKey}`
+        },
+        body,
+        redirect: "manual",
+        signal
+      });
+    } catch (err) {
+      if (signal.aborted)
+        return { kind: "timeout" };
+      const code2 = err?.code;
+      const detail2 = typeof code2 === "string" && /^[A-Z0-9_]{3,40}$/.test(code2) ? ` (${code2})` : "";
+      return {
+        kind: "fail",
+        message: `SystemOne request failed: network error${detail2}`,
+        retryable: true
+      };
+    }
+    const requestId = readRequestId(res.headers);
+    const withId = (message) => requestId ? `${message} [request ${requestId}]` : message;
+    if (res.status >= 200 && res.status < 300) {
+      let text;
+      try {
+        text = await res.text();
+      } catch {
+        if (signal.aborted)
+          return { kind: "timeout" };
+        return {
+          kind: "fail",
+          message: withId("SystemOne response body could not be read"),
+          retryable: true
+        };
+      }
+      if (text.length > MAX_RESPONSE_CHARS) {
+        return {
+          kind: "fail",
+          message: withId("SystemOne response exceeded the size limit"),
+          retryable: false
+        };
+      }
+      return { kind: "ok", text, requestId };
+    }
+    if (res.status >= 300 && res.status < 400) {
+      return {
+        kind: "fail",
+        message: withId(`SystemOne request was redirected (HTTP ${res.status}); redirects are refused`),
+        retryable: false
+      };
+    }
+    let errorText = "";
+    try {
+      errorText = await res.text();
+    } catch {
+      if (signal.aborted)
+        return { kind: "timeout" };
+    }
+    const code = readErrorCode(errorText);
+    if (res.status === 401 || res.status === 403) {
+      return {
+        kind: "fail",
+        message: withId(systemOneKeyRejectedMessage(providerId, res.status, code)),
+        retryable: false
+      };
+    }
+    const detail = code ? ` (${code})` : "";
+    const retryable = res.status === 408 || res.status === 429 || res.status >= 500;
+    return {
+      kind: "fail",
+      message: withId(`SystemOne API returned HTTP ${res.status}${detail}`),
+      retryable,
+      retryAfterMs: retryable ? parseRetryAfter(res.headers.get("retry-after"), now()) : undefined
+    };
+  }
+}
+
+// src/workflows/definition.ts
+function getNextTargets(next) {
+  if (typeof next === "string")
+    return [next];
+  if (Array.isArray(next))
+    return next;
+  return Object.values(next);
+}
+function generateEdges(def) {
+  const edges = [];
+  for (const node of def.nodes) {
+    if (!node.next)
+      continue;
+    if (typeof node.next === "string") {
+      edges.push({
+        id: `${node.id}→${node.next}`,
+        source: node.id,
+        target: node.next,
+        sourcePort: "default"
+      });
+    } else if (Array.isArray(node.next)) {
+      for (const targetId of node.next) {
+        edges.push({
+          id: `${node.id}→${targetId}`,
+          source: node.id,
+          target: targetId,
+          sourcePort: "default"
+        });
+      }
+    } else {
+      for (const [port, targetId] of Object.entries(node.next)) {
+        edges.push({
+          id: `${node.id}→${targetId}:${port}`,
+          source: node.id,
+          target: targetId,
+          sourcePort: port
+        });
+      }
+    }
+  }
+  return edges;
+}
+function findEntryNodes(def) {
+  const targets = new Set;
+  for (const node of def.nodes) {
+    if (!node.next)
+      continue;
+    for (const targetId of getNextTargets(node.next)) {
+      targets.add(targetId);
+    }
+  }
+  return def.nodes.filter((n) => !targets.has(n.id));
+}
+function resolveValidationPort(next, executorPort, validationPassed) {
+  if (validationPassed === undefined)
+    return executorPort;
+  if (!next || typeof next !== "object" || Array.isArray(next))
+    return executorPort;
+  if (executorPort && Object.hasOwn(next, executorPort))
+    return executorPort;
+  return validationPassed ? "pass" : "fail";
+}
+function getSuccessors(def, nodeId, port) {
+  const node = def.nodes.find((n) => n.id === nodeId);
+  if (!node?.next)
+    return [];
+  const targetIds = [];
+  if (typeof node.next === "string") {
+    targetIds.push(node.next);
+  } else if (Array.isArray(node.next)) {
+    targetIds.push(...node.next);
+  } else {
+    if (port) {
+      const targetId = node.next[port];
+      if (targetId)
+        targetIds.push(targetId);
+    } else {
+      targetIds.push(...Object.values(node.next));
+    }
+  }
+  return targetIds.map((id) => def.nodes.find((n) => n.id === id)).filter((n) => n != null);
+}
+function isUpstream(def, sourceId, targetId) {
+  const reverseDeps = new Map;
+  for (const node of def.nodes) {
+    if (!node.next)
+      continue;
+    for (const target of getNextTargets(node.next)) {
+      if (!reverseDeps.has(target))
+        reverseDeps.set(target, []);
+      reverseDeps.get(target).push(node.id);
+    }
+  }
+  const visited = new Set;
+  const queue = [targetId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const preds = reverseDeps.get(current) || [];
+    for (const pred of preds) {
+      if (visited.has(pred))
+        continue;
+      visited.add(pred);
+      if (pred === sourceId)
+        return true;
+      queue.push(pred);
+    }
+  }
+  return false;
+}
+function containsInterpolationToken(value) {
+  if (typeof value === "string")
+    return value.includes("{{") && value.includes("}}");
+  if (Array.isArray(value))
+    return value.some(containsInterpolationToken);
+  if (value && typeof value === "object") {
+    return Object.values(value).some(containsInterpolationToken);
+  }
+  return false;
+}
+function definitionNodeIds(def) {
+  return new Set(def.nodes.map((node) => node.id));
+}
+function validateDefinition(def, registry, options = {}) {
+  const errors = [];
+  const nodeIds = new Set(def.nodes.map((n) => n.id));
+  for (const node of def.nodes) {
+    if (node.id.includes("#") && !options.legacyNodeIds?.has(node.id)) {
+      errors.push(`Node "${node.id}" contains reserved character "#"`);
+    }
+    if (node.type === "human-in-the-loop" && typeof node.config.questions === "string" && !/^\{\{[^}]+\}\}$/.test(node.config.questions.trim())) {
+      errors.push(`Node "${node.id}" human-in-the-loop config.questions must be an array or one exact {{interpolation}} token`);
+    }
+    errors.push(...systemOneStaticShapeViolations(node), ...systemOneRetryViolations(node));
+    if (node.type === "foreach") {
+      validateForeachNode(node, errors);
+      if (node.id.includes("#")) {
+        errors.push(`Node "${node.id}" cannot be a foreach: its id contains "#", which is reserved for synthetic child ids`);
+      }
+      if (isUpstream(def, node.id, node.id)) {
+        errors.push("foreach inside a loop is not supported in v1");
+      }
+      const collidingSibling = def.nodes.find((other) => other.id !== node.id && other.id.startsWith(`${node.id}#`));
+      if (collidingSibling) {
+        errors.push(`Node "${node.id}" cannot be a foreach: node "${collidingSibling.id}" collides with its synthetic child id space ("${node.id}#…")`);
+      }
+    }
+  }
+  for (const node of def.nodes) {
+    if (!node.next)
+      continue;
+    if (typeof node.next === "string") {
+      if (!nodeIds.has(node.next)) {
+        errors.push(`Node "${node.id}" references non-existent next target "${node.next}"`);
+      }
+    } else if (Array.isArray(node.next)) {
+      for (const targetId of node.next) {
+        if (!nodeIds.has(targetId)) {
+          errors.push(`Node "${node.id}" fan-out references non-existent target "${targetId}"`);
+        }
+      }
+    } else {
+      for (const [port, targetId] of Object.entries(node.next)) {
+        if (!nodeIds.has(targetId)) {
+          errors.push(`Node "${node.id}" port "${port}" references non-existent target "${targetId}"`);
+        }
+      }
+    }
+  }
+  const entryNodes = findEntryNodes(def);
+  if (entryNodes.length === 0) {
+    errors.push("No entry node found (every node is a target of some other node)");
+  } else if (entryNodes.length > 1) {
+    const ids = entryNodes.map((n) => `"${n.id}"`).join(", ");
+    errors.push(`Multiple entry nodes found: ${ids} (expected exactly one)`);
+  }
+  if (entryNodes.length === 1) {
+    const reachable = new Set;
+    const queue = [entryNodes[0].id];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (reachable.has(current))
+        continue;
+      reachable.add(current);
+      const node = def.nodes.find((n) => n.id === current);
+      if (!node?.next)
+        continue;
+      for (const targetId of getNextTargets(node.next)) {
+        queue.push(targetId);
+      }
+    }
+    for (const node of def.nodes) {
+      if (!reachable.has(node.id)) {
+        errors.push(`Node "${node.id}" is unreachable from the entry node`);
+      }
+    }
+  }
+  if (registry) {
+    for (const node of def.nodes) {
+      if (!registry.has(node.type)) {
+        errors.push(`Node "${node.id}" uses unregistered executor type "${node.type}"`);
+        continue;
+      }
+      reportStaticConfigIssues(node, registry.get(node.type).configSchema, node.config, errors);
+      if (node.type === "foreach" && registry.has("agent-task")) {
+        const body = node.config.body;
+        const bodyConfig = typeof body === "object" && body !== null && !Array.isArray(body) ? body.config : undefined;
+        if (typeof bodyConfig === "object" && bodyConfig !== null && !Array.isArray(bodyConfig)) {
+          reportStaticConfigIssues(node, registry.get("agent-task").configSchema, bodyConfig, errors, "config.body.config");
+        }
+      }
+    }
+  }
+  for (const node of def.nodes) {
+    if (!node.inputs)
+      continue;
+    for (const [localName, sourcePath] of Object.entries(node.inputs)) {
+      const [sourceNodeId] = sourcePath.split(".");
+      if (!sourceNodeId)
+        continue;
+      if (sourceNodeId === "trigger" || sourceNodeId === "input" || sourceNodeId === "run") {
+        continue;
+      }
+      if (!nodeIds.has(sourceNodeId)) {
+        errors.push(`Node "${node.id}" input "${localName}" references non-existent node "${sourceNodeId}"`);
+        continue;
+      }
+      if (!isUpstream(def, sourceNodeId, node.id)) {
+        errors.push(`Node "${node.id}" input "${localName}" references "${sourceNodeId}" which is not upstream`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function reportStaticConfigIssues(node, schema, config, errors, pathPrefix = "config") {
+  const result = schema.safeParse(config);
+  if (result.success)
+    return;
+  for (const rawIssue of result.error?.issues ?? []) {
+    const issue = rawIssue;
+    const issuePath = issue.path.map(String);
+    const path = [pathPrefix, ...issuePath].join(".");
+    let value = config;
+    for (const segment of issue.path) {
+      if (value === null || typeof value !== "object") {
+        value = undefined;
+        break;
+      }
+      value = value[segment];
+    }
+    if (containsInterpolationToken(value))
+      continue;
+    const renderedValue = value === undefined ? "undefined" : JSON.stringify(value);
+    errors.push(`Node "${node.id}" (${node.type}) ${path} has invalid value ${renderedValue}: ${issue.message}`);
+  }
+}
+function validateForeachNode(node, errors) {
+  const config = node.config;
+  if (Object.hasOwn(config, "concurrency")) {
+    errors.push(`Node "${node.id}" foreach concurrency is not supported in v1`);
+  }
+  if (node.outputSchema !== undefined || node.validation !== undefined) {
+    errors.push(`Node "${node.id}" foreach node-level outputSchema/validation is not supported in v1`);
+  }
+  const over = config.over;
+  const isInterpolatedArray = typeof over === "string" && /^\{\{[^}]+\}\}$/.test(over.trim());
+  if (!Array.isArray(over) && !isInterpolatedArray) {
+    errors.push(`Node "${node.id}" foreach config.over must be an array or one exact {{interpolation}} token`);
+  }
+  if (typeof config.itemKey !== "string" || config.itemKey.length === 0) {
+    errors.push(`Node "${node.id}" foreach config.itemKey must be a non-empty string`);
+  }
+  const body = config.body;
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    errors.push(`Node "${node.id}" foreach config.body must be an object`);
+    return;
+  }
+  const bodyRecord = body;
+  if (bodyRecord.type !== "agent-task") {
+    errors.push(`Node "${node.id}" foreach config.body.type must be "agent-task" in v1`);
+  }
+  if (typeof bodyRecord.config !== "object" || bodyRecord.config === null || Array.isArray(bodyRecord.config)) {
+    errors.push(`Node "${node.id}" foreach config.body.config must be an object`);
+    return;
+  }
+  const bodyConfig = bodyRecord.config;
+  if (typeof bodyConfig.template !== "string") {
+    errors.push(`Node "${node.id}" foreach agent-task body.config.template must be a string`);
+  }
+}
+function applyDefinitionPatch(def, patch) {
+  const errors = [];
+  let nodes = [...def.nodes];
+  if (patch.delete?.length) {
+    const missing = patch.delete.filter((id) => !nodes.some((n) => n.id === id));
+    if (missing.length > 0) {
+      errors.push(`Cannot delete non-existent nodes: ${missing.join(", ")}`);
+    }
+    const toDelete = new Set(patch.delete);
+    nodes = nodes.filter((n) => !toDelete.has(n.id));
+  }
+  if (patch.create?.length) {
+    const existingIds = new Set(nodes.map((n) => n.id));
+    for (const newNode of patch.create) {
+      if (existingIds.has(newNode.id)) {
+        errors.push(`Cannot create node with duplicate ID: "${newNode.id}"`);
+        continue;
+      }
+      nodes.push(newNode);
+      existingIds.add(newNode.id);
+    }
+  }
+  if (patch.update?.length) {
+    for (const { nodeId, node: partial } of patch.update) {
+      const idx = nodes.findIndex((n) => n.id === nodeId);
+      if (idx === -1) {
+        errors.push(`Cannot update non-existent node: "${nodeId}"`);
+        continue;
+      }
+      const defined = {};
+      for (const [k, v] of Object.entries(partial)) {
+        if (v !== undefined)
+          defined[k] = v;
+      }
+      nodes[idx] = { ...nodes[idx], ...defined, id: nodeId };
+    }
+  }
+  const patchedDef = { ...def, nodes };
+  if (patch.onNodeFailure !== undefined) {
+    patchedDef.onNodeFailure = patch.onNodeFailure;
+  }
+  return { definition: patchedDef, errors };
+}
+
+export { BaseExecutor, postApprovalCancellationUpdates, createApprovalFollowUpTask, HumanInTheLoopExecutor, resolveWorkflowLlmConfig, SYSTEM_ONE_DECISION_NODE_TYPE, systemOneRetryViolations, systemOneUnresolvedError, SystemOneDecisionExecutor, getNextTargets, generateEdges, findEntryNodes, resolveValidationPort, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch };