lua-cli 3.31.0 → 3.32.2

package/dist/workflow-builder.js

@@ -4,9 +4,6 @@ var __name = (target, value3) => __defProp(target, "name", { value: value3, conf
 // src/types/workflow.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
 
-// ../workflow-graph/dist/index.mjs
-import { createHash } from "crypto";
-
 // ../shared-types/dist/index.mjs
 import { z } from "zod";
 import { z as z2 } from "zod";
@@ -659,6 +656,12 @@ function isImplicitModelSelectionSource(source) {
 }
 __name(isImplicitModelSelectionSource, "isImplicitModelSelectionSource");
 __name2(isImplicitModelSelectionSource, "isImplicitModelSelectionSource");
+var PLATFORM_FALLBACK_MODEL_SOURCE = "platform-fallback";
+function isPlatformFallbackModelSource(source) {
+  return source === PLATFORM_FALLBACK_MODEL_SOURCE;
+}
+__name(isPlatformFallbackModelSource, "isPlatformFallbackModelSource");
+__name2(isPlatformFallbackModelSource, "isPlatformFallbackModelSource");
 function resolveRequireToolApproval(rules) {
   const raw = rules?.requireToolApproval ?? rules?.requireApproval;
   if (raw === void 0 || raw === null) return void 0;
@@ -1348,7 +1351,6 @@ function luaClientMetricLabels(client) {
   const canonical2 = parseLuaClientHeader(serializeLuaClientHeader(client));
   return {
     client_family: canonical2?.app ?? "unknown",
-    client_version: canonical2?.version ?? "unknown",
     client_attribution: canonical2?.attribution ?? "unknown"
   };
 }
@@ -1490,6 +1492,87 @@ function hasCapability(profiles, profileId, required) {
 }
 __name(hasCapability, "hasCapability");
 __name2(hasCapability, "hasCapability");
+function workflowJobId(id) {
+  switch (id.kind) {
+    case "start":
+      return `wft_${id.runId}_0`;
+    case "start-redrive":
+      return `wft_${id.runId}_start_r${id.now}`;
+    case "tick":
+      return `wft_${id.runId}_${id.seq}`;
+    case "timer":
+      return `wft_${id.runId}_timer_${id.stepId}_${id.attempt}`;
+    case "timer-remainder":
+      return `wft_${id.runId}_timer_${id.stepId}_${id.attempt}_r${id.now}`;
+    case "timer-deferral":
+      return `wft_${id.runId}_timer_${id.stepId}_${id.attempt}_d${id.now}`;
+    case "timer-sibling":
+      return `wft_${id.runId}_timer_${id.stepId}_${id.attempt}_w${id.now}`;
+    case "retry":
+      return `wft_${id.runId}_retry_${id.stepId}_${id.attempt}`;
+    case "respawn":
+      return `wft_${id.runId}_respawn_${id.stepId}_${id.attempt}_s${id.segment}_r${id.now}`;
+    case "redrive":
+      return `wft_${id.runId}_redrive_${id.stepId}_${id.attempt}_r${id.now}`;
+    case "redispatch":
+      return `wft_${id.runId}_redispatch_${id.stepId}_${id.attempt}_x${id.executionId ?? "none"}_r${id.now}`;
+    case "expiry":
+      return `wft_${id.runId}_expire_${id.stepId}_${id.attempt}_t${id.suspendedAt}${id.hop > 0 ? `_h${id.hop}` : ""}`;
+    case "step-terminal":
+      return `wft_${id.runId}_term_${id.stepId}_${id.attempt}_r${id.now}`;
+    case "handback":
+      return `wft_${id.runId}_handback_${id.stepId}_${id.attempt}_${id.now}`;
+    case "foreach-rate":
+      return `wft_${id.runId}_fe_${id.stepId}_${id.attempt}_${id.bucket}`;
+    case "budget-expiry":
+      return `wft_${id.runId}_expiry_budget_r${id.now}`;
+    case "budget-resume":
+      return `wft_${id.runId}_resume_budget_${id.now}`;
+    case "deadline":
+      return `wft_${id.runId}_deadline_${id.deadlineAt}`;
+    case "deadline-remainder":
+      return `wft_${id.runId}_deadline_${id.deadlineAt}_r${id.now}`;
+    case "readmit":
+      return `wft_${id.runId}_readmit_${id.now}`;
+    case "cancel":
+      return `wft_${id.runId}_cancel`;
+    case "reconcile":
+      return `wft_${id.runId}_reconcile_${id.now}`;
+    case "replay":
+      return `wft_${id.runId}_replay_g${id.leaseGeneration}`;
+    case "migration":
+      return `wfm_${id.migrationId}`;
+    default:
+      return assertNever(id);
+  }
+}
+__name(workflowJobId, "workflowJobId");
+__name2(workflowJobId, "workflowJobId");
+function assertNever(id) {
+  throw new Error(`workflowJobId: unknown wake kind ${JSON.stringify(id)}`);
+}
+__name(assertNever, "assertNever");
+__name2(assertNever, "assertNever");
+function agentStepJobId(msg) {
+  return `${msg.runId}_${msg.stepId}_${msg.attempt}_x${msg.executionId}`;
+}
+__name(agentStepJobId, "agentStepJobId");
+__name2(agentStepJobId, "agentStepJobId");
+function heavyStepJobId(msg) {
+  return `${msg.runId}_${msg.stepId}_${msg.attempt}_x${msg.executionId}`;
+}
+__name(heavyStepJobId, "heavyStepJobId");
+__name2(heavyStepJobId, "heavyStepJobId");
+function jobSpawnJobId(msg) {
+  return `${msg.runId}_${msg.stepId}_${msg.attempt}_s${msg.segment}_${msg.executionId}`;
+}
+__name(jobSpawnJobId, "jobSpawnJobId");
+__name2(jobSpawnJobId, "jobSpawnJobId");
+function exportAutoJobId(exportId, suffix) {
+  return suffix ? `${exportId}:${suffix}` : exportId;
+}
+__name(exportAutoJobId, "exportAutoJobId");
+__name2(exportAutoJobId, "exportAutoJobId");
 var SYSTEM_USER_PREFIX = "system:";
 function isSystemRun(identity) {
   return identity.userId.startsWith(SYSTEM_USER_PREFIX);
@@ -1528,6 +1611,27 @@ var WORKFLOW_RUN_STATUSES = [
   ...WORKFLOW_RUN_IDLE,
   ...WORKFLOW_RUN_TERMINAL
 ];
+var WORKFLOW_STEP_STATUSES = [
+  "pending",
+  "ready",
+  "waiting",
+  "dispatched",
+  "claimed",
+  "running",
+  "suspended",
+  "cancellation_requested",
+  "completed",
+  "failed",
+  "skipped",
+  "cancelled",
+  "timeout",
+  "reaped"
+];
+var WORKFLOW_STEP_IN_FLIGHT = [
+  "claimed",
+  "running",
+  "cancellation_requested"
+];
 var ARCHIVE_WINDOW_MARGIN_DAYS = 7;
 function shouldSkipArchive(run, manifestSha256, sinkSha256) {
   if (!run.completedAt || !run.exportedAt || run.exportedAt < run.completedAt) return false;
@@ -1588,6 +1692,7 @@ function workflowOrgSlotKey(orgId, kind) {
 }
 __name(workflowOrgSlotKey, "workflowOrgSlotKey");
 __name2(workflowOrgSlotKey, "workflowOrgSlotKey");
+var WORKFLOW_CONNECTION_KEY_RE = /^[a-z][a-z0-9_-]{0,63}$/;
 function scheduledTimeKey(scheduledTime) {
   return scheduledTime.replace(/[^0-9TZ]/g, "");
 }
@@ -1599,6 +1704,310 @@ function scheduledWorkflowRunIdForTime(jobId, scheduledTime) {
 __name(scheduledWorkflowRunIdForTime, "scheduledWorkflowRunIdForTime");
 __name2(scheduledWorkflowRunIdForTime, "scheduledWorkflowRunIdForTime");
 var WORKFLOW_SIGNAL_PAYLOAD_MAX_BYTES = 64 * 1024;
+var WORKFLOW_RESOLVE_OUTPUT_MAX_BYTES = 256 * 1024;
+var WORKFLOW_RETRY_BACKOFFS = [
+  "fixed",
+  "exponential"
+];
+var WORKFLOW_JOB_RESOURCES = [
+  "small",
+  "medium",
+  "large"
+];
+var WORKFLOW_SIDE_EFFECTS = [
+  "none",
+  "external"
+];
+var WORKFLOW_JOB_RANGES = Object.freeze({
+  /** Coding-turn cap (`claude -p --max-turns`); absent ⇒ the cluster default (LUA_WF_JOB_MAX_TURNS). */
+  maxTurns: Object.freeze({
+    min: 1,
+    max: 500
+  }),
+  /** Harness messages per attempt (one per content block); absent ⇒ the cluster default (400). */
+  maxMessages: Object.freeze({
+    min: 1,
+    max: 5e3
+  }),
+  /** Input-side tokens per attempt (prompt + cache); absent ⇒ the cluster default (4M — LUA-708, was 30M). */
+  maxInputTokens: Object.freeze({
+    min: 1e6,
+    max: 5e8
+  })
+});
+var WORKFLOW_JOB_RANGE_MEMBERS = Object.keys(WORKFLOW_JOB_RANGES);
+function isWithinWorkflowJobRange(member, value3) {
+  const { min, max } = WORKFLOW_JOB_RANGES[member];
+  return typeof value3 === "number" && Number.isInteger(value3) && value3 >= min && value3 <= max;
+}
+__name(isWithinWorkflowJobRange, "isWithinWorkflowJobRange");
+__name2(isWithinWorkflowJobRange, "isWithinWorkflowJobRange");
+function workflowJobRangeMessage(member) {
+  const { min, max } = WORKFLOW_JOB_RANGES[member];
+  return `\`${member}\` must be an integer ${min}..${max}`;
+}
+__name(workflowJobRangeMessage, "workflowJobRangeMessage");
+__name2(workflowJobRangeMessage, "workflowJobRangeMessage");
+var WORKFLOW_SINGLE_STEP_TYPES = [
+  "agent",
+  "tool",
+  "workflow",
+  "step"
+];
+var WORKFLOW_HITL_ENTRY_TYPES = [
+  "approval",
+  "waitForSignal"
+];
+var WORKFLOW_ARM_ENTRY_TYPES = [
+  ...WORKFLOW_SINGLE_STEP_TYPES,
+  ...WORKFLOW_HITL_ENTRY_TYPES
+];
+var WORKFLOW_HITL_ARM_CONTAINERS = [
+  "parallel",
+  "conditional",
+  "foreach"
+];
+function isWorkflowSingleStepType(type) {
+  return typeof type === "string" && WORKFLOW_SINGLE_STEP_TYPES.includes(type);
+}
+__name(isWorkflowSingleStepType, "isWorkflowSingleStepType");
+__name2(isWorkflowSingleStepType, "isWorkflowSingleStepType");
+function isWorkflowHitlEntryType(type) {
+  return typeof type === "string" && WORKFLOW_HITL_ENTRY_TYPES.includes(type);
+}
+__name(isWorkflowHitlEntryType, "isWorkflowHitlEntryType");
+__name2(isWorkflowHitlEntryType, "isWorkflowHitlEntryType");
+function isWorkflowArmEntryType(type) {
+  return typeof type === "string" && WORKFLOW_ARM_ENTRY_TYPES.includes(type);
+}
+__name(isWorkflowArmEntryType, "isWorkflowArmEntryType");
+__name2(isWorkflowArmEntryType, "isWorkflowArmEntryType");
+function workflowContainerRunsHitlArm(container) {
+  return typeof container === "string" && WORKFLOW_HITL_ARM_CONTAINERS.includes(container);
+}
+__name(workflowContainerRunsHitlArm, "workflowContainerRunsHitlArm");
+__name2(workflowContainerRunsHitlArm, "workflowContainerRunsHitlArm");
+function workflowHitlArmUnsupportedMessage(type, id, container) {
+  const legal = WORKFLOW_HITL_ARM_CONTAINERS.map((c) => `\`${c}\``).join(" / ");
+  return `the engine does not run \`${type}\` inside a \`${container}\` yet (node "${id}") \u2014 place it at the top level, as a ${legal} arm, or inside a child \`workflow\``;
+}
+__name(workflowHitlArmUnsupportedMessage, "workflowHitlArmUnsupportedMessage");
+__name2(workflowHitlArmUnsupportedMessage, "workflowHitlArmUnsupportedMessage");
+function workflowHitlArmShapeMessage(type, id, shape) {
+  return shape === "mapped-arm" ? `\`${type}\` arm "${id}" takes the previous output as its payload \u2014 it cannot head a [mapping, step] chain; map before the container instead` : `a chunked foreach hands each child a slice of items, not one \u2014 \`${type}\` body "${id}" takes one item; drop \`chunk\``;
+}
+__name(workflowHitlArmShapeMessage, "workflowHitlArmShapeMessage");
+__name2(workflowHitlArmShapeMessage, "workflowHitlArmShapeMessage");
+var WORKFLOW_GRAPH_ENTRY_STEP_KINDS = Object.freeze({
+  agent: "agent",
+  tool: "tool",
+  workflow: "subrun",
+  step: "code",
+  mapping: "map",
+  sleep: "sleep",
+  sleepUntil: "sleepUntil",
+  parallel: null,
+  conditional: "branch",
+  foreach: "foreach",
+  loop: "loop",
+  approval: "approval",
+  waitForSignal: "signal"
+});
+var WORKFLOW_ARM_ENTRY_STEP_KINDS = Object.freeze(Object.fromEntries(WORKFLOW_ARM_ENTRY_TYPES.map((t) => [
+  t,
+  WORKFLOW_GRAPH_ENTRY_STEP_KINDS[t]
+])));
+var WORKFLOW_BUDGET_MAX_DURATION_SECONDS = Object.freeze({
+  min: 60,
+  max: 2592e3
+});
+var REDACTED_PLACEHOLDER = "[REDACTED]";
+var PROVIDER_MESSAGE_MAX_CHARS = 300;
+var ERROR_MESSAGE_MAX_CHARS = 2e3;
+var SECRET_LITERAL_PATTERNS = [
+  {
+    re: /\b(github_pat_)[A-Za-z0-9_]{16,}/g
+  },
+  {
+    re: /\b(gh[pousr]_)[A-Za-z0-9]{16,}/g
+  },
+  {
+    re: /\b(glpat-)[A-Za-z0-9_-]{16,}/g
+  },
+  // LUA-696 review (3): the npm granular / classic token (`npm_` + 36 alphanumerics).
+  {
+    re: /\b(npm_)[A-Za-z0-9]{36}\b/g
+  },
+  {
+    re: /\b(sk-ant-)[A-Za-z0-9_-]{16,}/g
+  },
+  {
+    re: /\b(sk-)(?!ant-)[A-Za-z0-9_-]{20,}/g
+  },
+  {
+    re: /\b(AKIA)[A-Z0-9]{16}\b/g
+  },
+  {
+    re: /\b(xox[abprs]-)[A-Za-z0-9-]{10,}/g
+  },
+  {
+    re: /\b(AIza)[0-9A-Za-z_-]{35}/g
+  },
+  {
+    re: /\b(ya29\.)[A-Za-z0-9_-]{20,}/g
+  },
+  {
+    re: /\b(eyJ)[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g
+  },
+  {
+    re: /(-----BEGIN [A-Z ]*PRIVATE KEY-----)[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g
+  },
+  // `https://x-access-token:<token>@github.com/…` (the git credential shape the pod scrubbed already)
+  {
+    re: /\b(x-access-token:)[^@\s]+(@)/g,
+    suffix: true
+  }
+];
+var SECRET_NAME = "(?:authorization|proxy-authorization|x-api-key|x-wf-[a-z-]*key|x-internal-auth|api[_-]?key|apikey|access[_-]?key|secret[_-]?key|private[_-]?key|client[_-]?secret|secret|password|passwd|pwd|passphrase|token|credentials?)";
+var SECRET_PAIR_PATTERNS = [
+  // `Authorization: Bearer x`, `x-api-key: x`, `AWS_SECRET_ACCESS_KEY=x`, `SVC_JOB_KEY=x`, `"apiKey": "x"`,
+  // `FOO_TOKEN=x`, `secretKey=x`, `password=x`. Groups: the char before the name, the name, the separator
+  // (with its quotes), the scheme word — all kept; the value goes. A value a literal rule already replaced
+  // (`x-access-token:[REDACTED]@host`) is left alone so the host after it survives.
+  // LUA-696: the second lookahead keeps a scrubbed `Authorization: Bearer [REDACTED]` as it is — without it the
+  // optional scheme group backtracks to empty and `Bearer` itself becomes the value (`[REDACTED] [REDACTED]`).
+  // The scrub is applied more than once on purpose (the Job site at its copy, the outcome table at the row
+  // write, lua-api on the way out), so it must be idempotent.
+  // LUA-696 review (HIGH): the identifier prefix is BOUNDED (`{1,64}`) — unbounded, `[A-Za-z0-9-]+` made the
+  // scan quadratic on `-`-heavy text (100 KB of `-` took 12.7 s on the lua-core event loop; a worker-tier step
+  // can throw that). No identifier that names a credential is longer; the probe list is unchanged.
+  {
+    re: new RegExp(`(^|[^A-Za-z0-9])((?:[A-Za-z0-9-]{1,64}[_-])?${SECRET_NAME}|[A-Za-z0-9-]{1,64}_key)(["']?\\s*[:=]\\s*["']?)((?:basic\\s+|bearer\\s+|token\\s+)?)(?!\\[REDACTED\\]|(?:basic|bearer|token)\\s+\\[REDACTED\\])[^\\s"',;)}&]{4,}`, "gi")
+  },
+  // `?token=x`, `&key=x`, `&X-Amz-Signature=x`, `&sig=x`
+  {
+    re: /([?&](?:token|key|api[_-]?key|apikey|access[_-]?token|id[_-]?token|auth|sig|signature|secret|password|pwd|x-amz-signature|x-amz-credential|x-amz-security-token)=)[^&\s"'#]+/gi
+  },
+  // `mongodb+srv://user:pass@host`, `postgres://user:pass@host`, `https://user:pass@host`
+  {
+    re: /(\/\/[^\s/:@]+:)[^\s/@]+(@)/g,
+    suffix: true
+  },
+  // `Basic <base64>` / `bearer <short token>` (the literal list needs ≥ 16 chars; any case)
+  {
+    re: /\b((?:Basic|Bearer)\s+)(?!\[REDACTED\])[A-Za-z0-9+/=_.-]{8,}/gi
+  }
+];
+var GROUP_COUNT = /* @__PURE__ */ new WeakMap();
+function groupCount(re) {
+  let n2 = GROUP_COUNT.get(re);
+  if (n2 === void 0) {
+    n2 = new RegExp(`${re.source}|`, re.flags.replace("g", "")).exec("").length - 1;
+    GROUP_COUNT.set(re, n2);
+  }
+  return n2;
+}
+__name(groupCount, "groupCount");
+__name2(groupCount, "groupCount");
+var WORKFLOW_SECRET_KEY_RE = /(^|[_\-.\s])(secret|token|password|passwd|pwd|passphrase|api[_-]?key|apikey|access[_-]?key|secret[_-]?key|private[_-]?key|client[_-]?secret|authorization|auth[_-]?token|access[_-]?token|id[_-]?token|refresh[_-]?token|session[_-]?key|credential(s)?)([_\-.\s]|$)|^(secret|token|password|passwd|pwd|passphrase|apikey|authorization|credentials?)$/i;
+var WORKFLOW_RESERVED_SECRET_KEYS = Object.freeze([
+  "secret",
+  "token",
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "api_key",
+  "apikey",
+  "access_key",
+  "secret_key",
+  "private_key",
+  "client_secret",
+  "authorization",
+  "auth_token",
+  "access_token",
+  "id_token",
+  "refresh_token",
+  "session_key",
+  "credential",
+  "credentials"
+]);
+function isWorkflowSecretKey(key) {
+  return WORKFLOW_SECRET_KEY_RE.test(key);
+}
+__name(isWorkflowSecretKey, "isWorkflowSecretKey");
+__name2(isWorkflowSecretKey, "isWorkflowSecretKey");
+function applyPatterns(text, patterns) {
+  let out = text;
+  for (const { re, suffix } of patterns) {
+    re.lastIndex = 0;
+    if (!re.test(out)) continue;
+    re.lastIndex = 0;
+    const groups = groupCount(re);
+    out = out.replace(re, (...args) => {
+      const kept = args.slice(1, 1 + groups).map((g) => typeof g === "string" ? g : "");
+      if (suffix && kept.length > 0) {
+        const tail = kept[kept.length - 1];
+        return `${kept.slice(0, -1).join("")}${REDACTED_PLACEHOLDER}${tail}`;
+      }
+      return `${kept.join("")}${REDACTED_PLACEHOLDER}`;
+    });
+  }
+  return out;
+}
+__name(applyPatterns, "applyPatterns");
+__name2(applyPatterns, "applyPatterns");
+function scrubSecretText(text) {
+  if (typeof text !== "string" || text.length < 4) return text;
+  return applyPatterns(applyPatterns(text, SECRET_LITERAL_PATTERNS), SECRET_PAIR_PATTERNS);
+}
+__name(scrubSecretText, "scrubSecretText");
+__name2(scrubSecretText, "scrubSecretText");
+var SCRUB_INPUT_MAX_CHARS = 16 * 1024;
+var SCRUB_CUT_BACKOFF_CHARS = 256;
+function boundScrubInput(text, max = SCRUB_INPUT_MAX_CHARS) {
+  if (typeof text !== "string" || text.length <= max) return text;
+  const window = text.slice(Math.max(0, max - SCRUB_CUT_BACKOFF_CHARS), max);
+  const ws = window.search(/\s\S*$/);
+  const cut = ws >= 0 ? max - window.length + ws : max;
+  return `${text.slice(0, cut)}\u2026`;
+}
+__name(boundScrubInput, "boundScrubInput");
+__name2(boundScrubInput, "boundScrubInput");
+function scrubSecretLines(lines) {
+  return lines.map((l) => typeof l === "string" ? scrubSecretText(boundScrubInput(l)) : l);
+}
+__name(scrubSecretLines, "scrubSecretLines");
+__name2(scrubSecretLines, "scrubSecretLines");
+function messageText(value3) {
+  if (typeof value3 === "string") return value3;
+  if (value3 instanceof Error) return value3.message;
+  if (value3 && typeof value3 === "object") {
+    const m = value3.message;
+    if (typeof m === "string") return m;
+    try {
+      return JSON.stringify(value3);
+    } catch {
+      return "";
+    }
+  }
+  return value3 === void 0 || value3 === null ? "" : String(value3);
+}
+__name(messageText, "messageText");
+__name2(messageText, "messageText");
+function scrubProviderMessage(raw, max = PROVIDER_MESSAGE_MAX_CHARS) {
+  const text = boundScrubInput(messageText(raw)).replace(/\s+/g, " ").trim();
+  if (!text) return void 0;
+  const out = scrubSecretText(text);
+  return out.length > max ? `${out.slice(0, max - 1)}\u2026` : out;
+}
+__name(scrubProviderMessage, "scrubProviderMessage");
+__name2(scrubProviderMessage, "scrubProviderMessage");
+function scrubStepErrorMessage(raw) {
+  return scrubProviderMessage(raw, ERROR_MESSAGE_MAX_CHARS);
+}
+__name(scrubStepErrorMessage, "scrubStepErrorMessage");
+__name2(scrubStepErrorMessage, "scrubStepErrorMessage");
 var WORKFLOW_AUDIT_EVENTS = [
   // --- definitions / versions / templates (13, 11 §11.11.5) ---
   "workflow.published",
@@ -1810,11 +2219,42 @@ __name(renderTargetsBlock, "renderTargetsBlock");
 __name2(renderTargetsBlock, "renderTargetsBlock");
 
 // ../workflow-graph/dist/index.mjs
+import { createHash } from "crypto";
 import { z as z4 } from "zod";
+import { z as z22 } from "zod";
 import { createHash as createHash2 } from "crypto";
 var __defProp3 = Object.defineProperty;
 var __name3 = /* @__PURE__ */ __name((target, value22) => __defProp3(target, "name", { value: value22, configurable: true }), "__name");
+var SideEffectsSchema = z4.enum(WORKFLOW_SIDE_EFFECTS);
+var JobResourcesSchema = z4.enum(WORKFLOW_JOB_RESOURCES);
 var WORKFLOW_ARM_SUBRUN_ID = "$arm";
+var WORKSPACE_TEMPLATE_EXPR_RE = /^\$\{\s*(?:initData|input)\.([^}]+?)\s*\}$/;
+function workspaceTemplatePath(template22) {
+  const key = template22.trim();
+  const expr = WORKSPACE_TEMPLATE_EXPR_RE.exec(key);
+  if (expr) return expr[1].split(".");
+  if (key.includes("${")) return void 0;
+  return key.replace(/^(?:input|initData)\./, "").split(".");
+}
+__name(workspaceTemplatePath, "workspaceTemplatePath");
+__name3(workspaceTemplatePath, "workspaceTemplatePath");
+function retryBackoffs() {
+  if (!Array.isArray(WORKFLOW_RETRY_BACKOFFS)) {
+    throw new Error("@lua/shared-types.WORKFLOW_RETRY_BACKOFFS is not a tuple \u2014 a jest.mock('@lua/shared-types') must spread jest.requireActual('@lua/shared-types')");
+  }
+  return WORKFLOW_RETRY_BACKOFFS;
+}
+__name(retryBackoffs, "retryBackoffs");
+__name3(retryBackoffs, "retryBackoffs");
+var SLEEP_UNTIL_REPLACEMENT = Object.freeze({
+  type: "sleep",
+  duration: 6e4
+});
+function sleepUntilUnsupportedMessage(id) {
+  return `the engine does not execute \`sleepUntil\` yet (node "${id}") \u2014 replace it with a \`sleep\` node with a \`duration\` in ms, e.g. { type: 'sleep', id: '${id}', duration: ${SLEEP_UNTIL_REPLACEMENT.duration} }`;
+}
+__name(sleepUntilUnsupportedMessage, "sleepUntilUnsupportedMessage");
+__name3(sleepUntilUnsupportedMessage, "sleepUntilUnsupportedMessage");
 var WORKFLOW_CAPS_DEFAULT = Object.freeze({
   maxParallelArms: 16,
   maxForeachConcurrency: 16,
@@ -1873,8 +2313,30 @@ function fillSingle(node) {
 }
 __name(fillSingle, "fillSingle");
 __name3(fillSingle, "fillSingle");
+function fillHitl(node) {
+  if (node.type === "approval") {
+    const a = node;
+    if (a.approver === void 0) a.approver = "creator";
+    if (a.timeoutHours === void 0) a.timeoutHours = WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS;
+    if (a.onTimeout === void 0) a.onTimeout = "deny";
+    if (a.onDeny === void 0) a.onDeny = "continue";
+    if (a.excludeInitiator === void 0) a.excludeInitiator = false;
+    if (a.editable === void 0) a.editable = false;
+    return;
+  }
+  const w = node;
+  if (w.timeoutHours === void 0) w.timeoutHours = WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS;
+  if (w.onTimeout === void 0) w.onTimeout = "fail";
+  if (w.acceptedSources === void 0) w.acceptedSources = [
+    ...WORKFLOW_SIGNAL_DEFAULT_SOURCES
+  ];
+}
+__name(fillHitl, "fillHitl");
+__name3(fillHitl, "fillHitl");
 function fillArm(arm) {
-  if (arm.type !== "mapping") fillSingle(arm);
+  if (arm.type === "mapping") return;
+  if (isHitlNode(arm)) fillHitl(arm);
+  else fillSingle(arm);
 }
 __name(fillArm, "fillArm");
 __name3(fillArm, "fillArm");
@@ -1887,7 +2349,7 @@ function fillEntry(entry) {
       fillSingle(entry);
       return;
     case "parallel":
-      entry.steps.forEach(fillSingle);
+      entry.steps.forEach(fillArm);
       return;
     case "conditional": {
       const c = entry;
@@ -1901,34 +2363,19 @@ function fillEntry(entry) {
       f.opts = f.opts ?? {};
       if (f.opts.concurrency === void 0) f.opts.concurrency = WORKFLOW_FOREACH_DEFAULT_CONCURRENCY;
       if (f.opts.maxItems === void 0) f.opts.maxItems = WORKFLOW_FOREACH_DEFAULT_MAX_ITEMS;
-      fillSingle(f.step);
+      fillArm(f.step);
       return;
     }
     case "loop": {
       const l = entry;
       if (l.maxIterations === void 0) l.maxIterations = WORKFLOW_LOOP_DEFAULT_MAX_ITERATIONS;
-      fillSingle(l.step);
+      fillArm(l.step);
       return;
     }
-    case "approval": {
-      const a = entry;
-      if (a.approver === void 0) a.approver = "creator";
-      if (a.timeoutHours === void 0) a.timeoutHours = WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS;
-      if (a.onTimeout === void 0) a.onTimeout = "deny";
-      if (a.onDeny === void 0) a.onDeny = "continue";
-      if (a.excludeInitiator === void 0) a.excludeInitiator = false;
-      if (a.editable === void 0) a.editable = false;
-      return;
-    }
-    case "waitForSignal": {
-      const w = entry;
-      if (w.timeoutHours === void 0) w.timeoutHours = WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS;
-      if (w.onTimeout === void 0) w.onTimeout = "fail";
-      if (w.acceptedSources === void 0) w.acceptedSources = [
-        ...WORKFLOW_SIGNAL_DEFAULT_SOURCES
-      ];
+    case "approval":
+    case "waitForSignal":
+      fillHitl(entry);
       return;
-    }
     case "mapping":
     case "sleep":
     case "sleepUntil":
@@ -1944,6 +2391,17 @@ function withDefaultsFilled(g) {
 }
 __name(withDefaultsFilled, "withDefaultsFilled");
 __name3(withDefaultsFilled, "withDefaultsFilled");
+var CONNECTION_ID_HEX_RE = /^[0-9a-f]{24}$/;
+function isConnectionKeyShaped(value22) {
+  return WORKFLOW_CONNECTION_KEY_RE.test(value22) && !CONNECTION_ID_HEX_RE.test(value22);
+}
+__name(isConnectionKeyShaped, "isConnectionKeyShaped");
+__name3(isConnectionKeyShaped, "isConnectionKeyShaped");
+function connectionKeyUndeclaredMessage(path, key) {
+  return `${path} '${key}' is neither a connection id nor a declared connections[].key \u2014 declare it: connections: [{ key: '${key}', integrationType: '<catalog slug, e.g. github>' }] and it resolves on any agent`;
+}
+__name(connectionKeyUndeclaredMessage, "connectionKeyUndeclaredMessage");
+__name3(connectionKeyUndeclaredMessage, "connectionKeyUndeclaredMessage");
 var WORKFLOW_JOB_TOOLS = [
   "shell",
   "read",
@@ -1995,6 +2453,8 @@ var schemaIsArray = /* @__PURE__ */ __name3((schema) => {
   if (t === void 0) return void 0;
   return Array.isArray(t) ? t.includes("array") : t === "array";
 }, "schemaIsArray");
+var isHitlNode = /* @__PURE__ */ __name3((n2) => isWorkflowHitlEntryType(n2.type), "isHitlNode");
+var isSingleStep = /* @__PURE__ */ __name3((n2) => !isHitlNode(n2), "isSingleStep");
 var singleId = /* @__PURE__ */ __name3((s) => s.type === "step" ? s.step.id : s.id, "singleId");
 var armId = /* @__PURE__ */ __name3((a) => a.type === "mapping" ? a.id : singleId(a), "armId");
 var TEMPLATE_STEP_REF = /\$\{\s*stepResults\.([A-Za-z0-9_\-]+)/g;
@@ -2005,14 +2465,21 @@ function templateStepRefs(text) {
 }
 __name(templateStepRefs, "templateStepRefs");
 __name3(templateStepRefs, "templateStepRefs");
-function mapConfigStepRefs(raw) {
-  if (!raw) return [];
-  let cfg;
+function readMapConfig(raw) {
+  if (!raw) return void 0;
+  if (typeof raw !== "string") return raw;
   try {
-    cfg = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const cfg = JSON.parse(raw);
+    return cfg && typeof cfg === "object" && !Array.isArray(cfg) ? cfg : void 0;
   } catch {
-    return [];
+    return void 0;
   }
+}
+__name(readMapConfig, "readMapConfig");
+__name3(readMapConfig, "readMapConfig");
+function mapConfigStepRefs(raw) {
+  const cfg = readMapConfig(raw);
+  if (!cfg) return [];
   const ids = [];
   for (const d of Object.values(cfg)) {
     if (!d || typeof d !== "object") continue;
@@ -2087,6 +2554,43 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
   if (envelopeWorkspace?.backend && envelopeWorkspace.backend !== "ebs" && opts.policy?.workspaceBackends && !opts.policy.workspaceBackends.includes(envelopeWorkspace.backend)) {
     err("workspace-backend-unavailable", `workspace.backend '${envelopeWorkspace.backend}' is not enabled (LUA_WF_WORKSPACE_BACKENDS = ${opts.policy.workspaceBackends.join(",")}) \u2014 'ebs' is the normative fallback`, "workspace.backend");
   }
+  for (const member of [
+    "repo",
+    "ref"
+  ]) {
+    const v = envelopeWorkspace?.[member];
+    const tpl = v && typeof v === "object" && typeof v.template === "string" ? v.template : void 0;
+    if (tpl !== void 0 && workspaceTemplatePath(tpl) === void 0) {
+      warn("workspace-template-composite", `workspace.${member} template ${JSON.stringify(tpl)} is a composite \u2014 the engine binds one whole-string \${initData.<path>} (or an input.<path> key) and every start would fail workspace_provision_failed{binding_unresolved}; put the assembled value in the run input and bind that path`, `workspace.${member}`);
+    }
+  }
+  const declaredKeys = new Set(opts.connectionKeys ?? []);
+  if (g.connections !== void 0 && !Array.isArray(g.connections)) {
+    err("connection-declaration-invalid", "`connections` must be an array of { key, integrationType }", "connections");
+  }
+  (Array.isArray(g.connections) ? g.connections : []).forEach((c, i) => {
+    const path = `connections.${i}`;
+    const key = c?.key;
+    const integrationType = c?.integrationType;
+    if (typeof key !== "string" || !WORKFLOW_CONNECTION_KEY_RE.test(key)) {
+      err("connection-declaration-invalid", `connections[${i}].key must match ${WORKFLOW_CONNECTION_KEY_RE}`, `${path}.key`);
+      return;
+    }
+    if (declaredKeys.has(key)) {
+      err("connection-declaration-invalid", `connections[${i}].key "${key}" is declared twice`, `${path}.key`);
+      return;
+    }
+    if (typeof integrationType !== "string" || !integrationType.trim()) {
+      err("connection-declaration-invalid", `connections[${i}] ("${key}") needs an integrationType (the catalog slug, e.g. 'github')`, `${path}.integrationType`);
+      return;
+    }
+    declaredKeys.add(key);
+  });
+  const undeclaredKey = /* @__PURE__ */ __name3((ref) => typeof ref === "string" && !declaredKeys.has(ref) && isConnectionKeyShaped(ref) && opts.connectionIds?.has(ref) !== true, "undeclaredKey");
+  const credentialsRef = envelopeWorkspace?.credentialsRef;
+  if (undeclaredKey(credentialsRef)) {
+    err("connection-key-undeclared", connectionKeyUndeclaredMessage("workspace.credentialsRef", credentialsRef), "workspace.credentialsRef");
+  }
   const seen = /* @__PURE__ */ new Map();
   let nodeCount = 0;
   const upstream = /* @__PURE__ */ new Set();
@@ -2098,12 +2602,27 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
       seen.set(id, path);
     }
   }, "checkId");
+  const checkPolicyEnums = /* @__PURE__ */ __name3((node, path) => {
+    const id = singleId(node);
+    const check = /* @__PURE__ */ __name3((member, allowed) => {
+      const value22 = node[member];
+      if (value22 === void 0 || typeof value22 === "string" && allowed.includes(value22)) return;
+      err("invalid-envelope", `\`${member}\` must be ${allowed.map((a) => `'${a}'`).join(" | ")} (got ${JSON.stringify(value22)})`, `${path}.${member}`, id);
+    }, "check");
+    check("sideEffects", WORKFLOW_SIDE_EFFECTS);
+    check("jobResources", WORKFLOW_JOB_RESOURCES);
+  }, "checkPolicyEnums");
   const checkRetry = /* @__PURE__ */ __name3((node, path) => {
     const r = node.retry;
     if (!r) return;
     const id = singleId(node);
-    if (r.backoff !== void 0 && r.backoff !== "fixed" && r.backoff !== "exponential") {
-      err("backoff-invalid", `retry.backoff must be 'fixed' | 'exponential'`, `${path}.retry.backoff`, id);
+    const backoffs = retryBackoffs();
+    if (r.backoff !== void 0 && !backoffs.includes(r.backoff)) {
+      const list = backoffs.map((b) => `'${b}'`).join(" | ");
+      err("backoff-invalid", `retry.backoff must be ${list}`, `${path}.retry.backoff`, id);
+    }
+    if (r.backoffSeconds !== void 0 && r.backoffSeconds < 0) {
+      err("backoff-invalid", "retry.backoffSeconds must be \u2265 0", `${path}.retry.backoffSeconds`, id);
     }
     if (r.maxBackoffSeconds !== void 0) {
       if (r.backoff !== "exponential") {
@@ -2166,10 +2685,15 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
   }, "checkSpecialistRole");
   const checkRequiredConnections = /* @__PURE__ */ __name3((node, path) => {
     const required = node.requiredConnections;
-    if (!Array.isArray(required) || !opts.connectionIds) return;
-    const unknown = required.filter((c) => typeof c !== "string" || !opts.connectionIds.has(c));
+    if (!Array.isArray(required)) return;
+    const undeclared = required.filter(undeclaredKey);
+    if (undeclared.length) {
+      err("connection-key-undeclared", connectionKeyUndeclaredMessage(`${path}.requiredConnections`, undeclared[0]) + (undeclared.length > 1 ? ` (also undeclared: ${JSON.stringify(undeclared.slice(1))})` : ""), `${path}.requiredConnections`, singleId(node));
+    }
+    if (!opts.connectionIds) return;
+    const unknown = required.filter((c) => typeof c !== "string" || !declaredKeys.has(c) && !opts.connectionIds.has(c));
     if (unknown.length) {
-      err("required-connection-unknown", `requiredConnections ${JSON.stringify(unknown)} are not connections the owner can mount`, `${path}.requiredConnections`, singleId(node));
+      err("required-connection-unknown", `requiredConnections ${JSON.stringify(unknown)} are neither declared connections[].key values nor connections the owner can mount`, `${path}.requiredConnections`, singleId(node));
     }
   }, "checkRequiredConnections");
   const checkTier = /* @__PURE__ */ __name3((node, path) => {
@@ -2247,14 +2771,20 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         err("container-arm-empty", "a bare mapping arm has nothing to run", `${path}.graph.1`, node.id);
         return;
       }
+      const inner = body[1];
+      if (isHitlNode(inner)) {
+        err("node-type-unsupported-in-container", workflowHitlArmShapeMessage(inner.type, inner.id, "mapped-arm"), `${path}.graph.1`, inner.id);
+        return;
+      }
       upstream.add(singleId(body[1]));
-      checkArm(body[0], `${path}.graph.0`, depth);
+      checkArm(body[0], `${path}.graph.0`, depth, "parallel");
       checkSingle(body[1], `${path}.graph.1`, depth);
       upstream.add(body[0].id);
       upstream.add(singleId(body[1]));
       return;
     }
     checkId(singleId(node), path);
+    checkPolicyEnums(node, path);
     checkTimeout(node, path);
     checkTier(node, path);
     checkRetry(node, path);
@@ -2279,13 +2809,60 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     if (node.type === "workflow" && node.kind === "subrun" && depth > caps.maxNestingDepth) {
       err("cap-exceeded", `nesting depth ${depth} exceeds ${caps.maxNestingDepth}`, path, node.id);
     }
+    if (node.type === "workflow" && node.workflowId !== WORKFLOW_ARM_SUBRUN_ID && typeof g.definition?.id === "string" && node.workflowId === g.definition.id) {
+      err("subrun-cycle", `"${node.id}" starts "${node.workflowId}", which is this workflow itself`, path, node.id);
+    }
     for (const ref of nodeStepRefs(node)) {
       if (!upstream.has(ref)) {
         err("template-reference-unresolved", `"${singleId(node)}" references stepResults.${ref}, which is not upstream`, path, singleId(node));
       }
     }
   }, "checkSingle");
-  const checkArm = /* @__PURE__ */ __name3((arm, path, depth) => {
+  const checkHitl = /* @__PURE__ */ __name3((node, path) => {
+    if (node.type === "waitForSignal") {
+      const w = node;
+      checkId(w.id, path);
+      if (typeof w.signal !== "string" || w.signal.length === 0) err("invalid-envelope", "waitForSignal.signal is required", `${path}.signal`, w.id);
+      return;
+    }
+    const a = node;
+    checkId(a.id, path);
+    if (a.approver === "creator" && a.excludeInitiator === true) {
+      err("approver-excludes-only-candidate", "approver:'creator' with excludeInitiator:true always excludes the only candidate", path, a.id);
+    }
+    if (a.fourEyes !== void 0 && a.editable !== true) {
+      err("four-eyes-requires-editable", "`fourEyes` requires editable:true", `${path}.fourEyes`, a.id);
+    }
+    if ((a.editablePaths !== void 0 || a.editedPayloadSchema !== void 0) && a.editable !== true) {
+      err("editable-path-invalid", "`editablePaths` / `editedPayloadSchema` require editable:true", `${path}.editablePaths`, a.id);
+    }
+    for (const p of a.editablePaths ?? []) {
+      if (!EDITABLE_PATH_RE.test(p)) err("editable-path-invalid", `editablePaths entry "${p}" is outside the seg(.seg)*[*]/[n] grammar`, `${path}.editablePaths`, a.id);
+    }
+    if (Array.isArray(a.onTimeout)) {
+      const chain = a.onTimeout;
+      const hops = chain.filter((h) => typeof h === "object" && h !== null && "escalateTo" in h);
+      if (hops.length > 3) err("escalation-chain-too-long", "an onTimeout chain carries at most 3 escalation hops", `${path}.onTimeout`, a.id);
+      const last = chain[chain.length - 1];
+      if (last === void 0 || typeof last === "object" && last !== null && "escalateTo" in last) {
+        err("escalation-chain-not-terminal", "an onTimeout chain must end in a terminal member", `${path}.onTimeout`, a.id);
+      }
+    }
+    if (typeof a.details === "string") {
+      for (const ref of templateStepRefs(a.details)) {
+        if (!upstream.has(ref)) err("template-reference-unresolved", `"${a.id}" references stepResults.${ref}, which is not upstream`, path, a.id);
+      }
+    }
+  }, "checkHitl");
+  const checkHitlArm = /* @__PURE__ */ __name3((node, path, container) => {
+    if (!workflowContainerRunsHitlArm(container)) {
+      checkId(node.id, path);
+      err("node-type-unsupported-in-container", workflowHitlArmUnsupportedMessage(node.type, node.id, container), path, node.id);
+      return;
+    }
+    checkHitl(node, path);
+  }, "checkHitlArm");
+  const checkArm = /* @__PURE__ */ __name3((arm, path, depth, container) => {
     if (arm.type === "mapping") {
       checkId(arm.id, path);
       for (const ref of nodeStepRefs(arm)) {
@@ -2293,6 +2870,10 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
       }
       return;
     }
+    if (isHitlNode(arm)) {
+      checkHitlArm(arm, path, container);
+      return;
+    }
     checkSingle(arm, path, depth);
   }, "checkArm");
   graph.forEach((entry, i) => {
@@ -2321,6 +2902,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
       case "sleepUntil": {
         const s = entry;
         checkId(s.id, path);
+        err("node-type-unsupported-by-engine", sleepUntilUnsupportedMessage(s.id), path, s.id);
         if (s.date === void 0 === (s.dateFrom === void 0)) {
           err("invalid-envelope", "sleepUntil needs exactly one of `date` | `dateFrom`", path, s.id);
         }
@@ -2341,18 +2923,15 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
             err("mapping-placement", "a bare mapping cannot be a parallel arm \u2014 chain it as [map, step]", armPath);
             return;
           }
-          if (arm.type === "approval" || arm.type === "waitForSignal") {
-            err("approval-inside-container", "approval / waitForSignal are top-level only in v1", armPath);
-            return;
-          }
-          checkSingle(arm, armPath, 1);
+          checkArm(arm, armPath, 1, "parallel");
           declared.push(singleId(arm));
         });
-        const worktreeArms = p.steps.filter((a) => a.workspace?.isolation === "worktree");
+        const executableArms = p.steps.filter(isSingleStep);
+        const worktreeArms = executableArms.filter((a) => a.workspace?.isolation === "worktree");
         if (worktreeArms.length > 0 && !p.merge) err("worktree-arms-require-merge", "worktree arms need a `merge` policy", path);
         if (worktreeArms.length === 0 && p.merge) err("merge-requires-worktree-arms", "`merge` needs at least one worktree arm", path);
         if (worktreeArms.length > WORKFLOW_JOB_MAX_WORKTREE_ARMS) err("worktree-arms-exceed-cap", `at most ${WORKFLOW_JOB_MAX_WORKTREE_ARMS} worktree arms per parallel`, path);
-        const sharedArms = p.steps.filter((a) => {
+        const sharedArms = executableArms.filter((a) => {
           const w = workspaceOf(a);
           if (!w || w === "inherit" || w.isolation === "worktree") return false;
           return !(envelopeWorkspace?.backend === "efs" && w.mount === "ro");
@@ -2366,14 +2945,14 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
           err("invalid-envelope", "conditional.predicates must match conditional.steps one-to-one", path);
         }
         (c.predicates ?? []).forEach((p, j) => {
-          if (!isPredicate(p)) err("closure-predicate", "a conditional predicate must be a LuaPredicate object, not a function", `${path}.predicates.${j}`);
+          if (!isWellFormedPredicate(p)) err("closure-predicate", "a conditional predicate must be a well-formed LuaPredicate object ({op, left/right | value | path | args | arg}), not a function or an expression string", `${path}.predicates.${j}`);
         });
         c.steps.forEach((arm, j) => {
-          checkArm(arm, `${path}.steps.${j}`, 1);
+          checkArm(arm, `${path}.steps.${j}`, 1, "conditional");
           declared.push(armId(arm));
         });
         if (c.otherwise) {
-          checkArm(c.otherwise, `${path}.otherwise`, 1);
+          checkArm(c.otherwise, `${path}.otherwise`, 1, "conditional");
           declared.push(armId(c.otherwise));
         }
         break;
@@ -2396,8 +2975,9 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         }
         if (o.chunk !== void 0) {
           const max = o.maxItems ?? WORKFLOW_FOREACH_DEFAULT_MAX_ITEMS;
-          if (!Number.isInteger(o.chunk.size) || o.chunk.size < 1 || o.chunk.size > max) {
-            err("chunk-size-invalid", `foreach.chunk.size must be an integer in [1, ${max}]`, `${path}.opts.chunk.size`);
+          const size = typeof o.chunk === "number" ? o.chunk : o.chunk.size;
+          if (!Number.isInteger(size) || size < 1 || size > max) {
+            err("chunk-size-invalid", `foreach.chunk.size must be an integer in [1, ${max}]`, typeof o.chunk === "number" ? `${path}.opts.chunk` : `${path}.opts.chunk.size`);
           }
         }
         if (o.rateLimit !== void 0) {
@@ -2414,12 +2994,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         const bodyType = f.step.type;
         const prevEntry = i > 0 ? graph[i - 1] : void 0;
         if (bodyType !== "mapping" && prevEntry?.type === "mapping" && prevEntry.id === `${singleId(f.step)}_items`) {
-          let cfg;
-          try {
-            cfg = JSON.parse(prevEntry.mapConfig);
-          } catch {
-            cfg = void 0;
-          }
+          const cfg = readMapConfig(prevEntry.mapConfig);
           const d = cfg?.[""];
           let arrayLike;
           if (d && "value" in d) arrayLike = Array.isArray(d.value);
@@ -2431,8 +3006,13 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
           if (arrayLike === false) err("foreach-items-not-array", `foreach({items}) for "${singleId(f.step)}" binds a value that is not an array`, `${path}.step`, singleId(f.step));
         }
         if (bodyType === "mapping") err("container-arm-empty", "a foreach body needs a step, not a bare mapping", `${path}.step`);
-        else if (bodyType === "approval" || bodyType === "waitForSignal") err("approval-inside-container", "approval / waitForSignal are top-level only in v1", `${path}.step`);
-        else {
+        else if (isHitlNode(f.step)) {
+          if (o.chunk !== void 0) {
+            checkId(f.step.id, `${path}.step`);
+            err("node-type-unsupported-in-container", workflowHitlArmShapeMessage(f.step.type, f.step.id, "chunked-foreach"), `${path}.step`, f.step.id);
+          } else checkHitlArm(f.step, `${path}.step`, "foreach");
+          declared.push(f.step.id);
+        } else {
           checkSingle(f.step, `${path}.step`, o.chunk ? 2 : 1);
           declared.push(singleId(f.step));
         }
@@ -2446,55 +3026,23 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         if (l.intervalSeconds !== void 0 && (!Number.isInteger(l.intervalSeconds) || l.intervalSeconds < 1 || l.intervalSeconds > caps.maxLoopIntervalSeconds)) {
           err("loop-interval-out-of-range", `loop.intervalSeconds must be an integer in 1..${caps.maxLoopIntervalSeconds}`, `${path}.intervalSeconds`);
         }
-        if (!isPredicate(l.predicate)) err("closure-predicate", "a loop predicate must be a LuaPredicate object, not a function", `${path}.predicate`);
+        if (!isWellFormedPredicate(l.predicate)) err("closure-predicate", "a loop predicate must be a well-formed LuaPredicate object ({op, left/right | value | path | args | arg}), not a function or an expression string", `${path}.predicate`);
         const bodyType = l.step.type;
         if (bodyType === "mapping") err("container-arm-empty", "a loop body needs a step, not a bare mapping", `${path}.step`);
-        else if (bodyType === "approval" || bodyType === "waitForSignal") err("approval-inside-container", "approval / waitForSignal are top-level only in v1", `${path}.step`);
-        else {
+        else if (isHitlNode(l.step)) {
+          checkHitlArm(l.step, `${path}.step`, "loop");
+          declared.push(l.step.id);
+        } else {
           checkSingle(l.step, `${path}.step`, 1);
           declared.push(singleId(l.step));
         }
         break;
       }
-      case "approval": {
-        const a = entry;
-        checkId(a.id, path);
-        if (a.approver === "creator" && a.excludeInitiator === true) {
-          err("approver-excludes-only-candidate", "approver:'creator' with excludeInitiator:true always excludes the only candidate", path, a.id);
-        }
-        if (a.fourEyes !== void 0 && a.editable !== true) {
-          err("four-eyes-requires-editable", "`fourEyes` requires editable:true", `${path}.fourEyes`, a.id);
-        }
-        if ((a.editablePaths !== void 0 || a.editedPayloadSchema !== void 0) && a.editable !== true) {
-          err("editable-path-invalid", "`editablePaths` / `editedPayloadSchema` require editable:true", `${path}.editablePaths`, a.id);
-        }
-        for (const p of a.editablePaths ?? []) {
-          if (!EDITABLE_PATH_RE.test(p)) err("editable-path-invalid", `editablePaths entry "${p}" is outside the seg(.seg)*[*]/[n] grammar`, `${path}.editablePaths`, a.id);
-        }
-        if (Array.isArray(a.onTimeout)) {
-          const chain = a.onTimeout;
-          const hops = chain.filter((h) => typeof h === "object" && h !== null && "escalateTo" in h);
-          if (hops.length > 3) err("escalation-chain-too-long", "an onTimeout chain carries at most 3 escalation hops", `${path}.onTimeout`, a.id);
-          const last = chain[chain.length - 1];
-          if (last === void 0 || typeof last === "object" && last !== null && "escalateTo" in last) {
-            err("escalation-chain-not-terminal", "an onTimeout chain must end in a terminal member", `${path}.onTimeout`, a.id);
-          }
-        }
-        if (typeof a.details === "string") {
-          for (const ref of templateStepRefs(a.details)) {
-            if (!upstream.has(ref)) err("template-reference-unresolved", `"${a.id}" references stepResults.${ref}, which is not upstream`, path, a.id);
-          }
-        }
-        declared.push(a.id);
-        break;
-      }
-      case "waitForSignal": {
-        const w = entry;
-        checkId(w.id, path);
-        if (typeof w.signal !== "string" || w.signal.length === 0) err("invalid-envelope", "waitForSignal.signal is required", `${path}.signal`, w.id);
-        declared.push(w.id);
+      case "approval":
+      case "waitForSignal":
+        checkHitl(entry, path);
+        declared.push(entry.id);
         break;
-      }
       default:
         err("invalid-envelope", `unknown entry type "${entry.type}"`, path);
     }
@@ -2531,6 +3079,46 @@ function isPredicate(p) {
 }
 __name(isPredicate, "isPredicate");
 __name3(isPredicate, "isPredicate");
+var isPredicateScalar = /* @__PURE__ */ __name3((v) => v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean", "isPredicateScalar");
+function isPathOrLiteral(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const r = v;
+  if ("path" in r) return typeof r.path === "string" && r.path.length > 0;
+  return "literal" in r && isPredicateScalar(r.literal);
+}
+__name(isPathOrLiteral, "isPathOrLiteral");
+__name3(isPathOrLiteral, "isPathOrLiteral");
+function isWellFormedPredicate(p) {
+  if (!isPredicate(p)) return false;
+  const r = p;
+  switch (r.op) {
+    case "eq":
+    case "ne":
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+      return isPathOrLiteral(r.left) && isPathOrLiteral(r.right);
+    case "in":
+    case "notIn":
+      return isPathOrLiteral(r.value) && Array.isArray(r.set) && r.set.every(isPredicateScalar);
+    case "exists":
+    case "notExists":
+      return typeof r.path === "string" && r.path.length > 0;
+    case "truthy":
+    case "falsy":
+      return isPathOrLiteral(r.value);
+    case "and":
+    case "or":
+      return Array.isArray(r.args) && r.args.every(isWellFormedPredicate);
+    case "not":
+      return isWellFormedPredicate(r.arg);
+    default:
+      return false;
+  }
+}
+__name(isWellFormedPredicate, "isWellFormedPredicate");
+__name3(isWellFormedPredicate, "isWellFormedPredicate");
 var GRAPH_HASH_PREFIX = "sha256-cj1:";
 function canonicalJson(value22) {
   const seen = /* @__PURE__ */ new WeakSet();
@@ -2575,14 +3163,9 @@ var WorkflowPlanError = class extends Error {
     this.name = "WorkflowPlanError";
   }
 };
-var SINGLE_STEP_KINDS = {
-  step: "code",
-  agent: "agent",
-  tool: "tool",
-  workflow: "subrun"
-};
-var isSingleStep = /* @__PURE__ */ __name3((e) => e.type === "step" || e.type === "agent" || e.type === "tool" || e.type === "workflow", "isSingleStep");
-var singleStepId = /* @__PURE__ */ __name3((e) => e.type === "step" ? e.step.id : e.id, "singleStepId");
+var isArmStep = /* @__PURE__ */ __name3((e) => isWorkflowArmEntryType(e.type), "isArmStep");
+var armStepId = /* @__PURE__ */ __name3((e) => e.type === "step" ? e.step.id : e.id, "armStepId");
+var armStepKind = /* @__PURE__ */ __name3((e) => WORKFLOW_ARM_ENTRY_STEP_KINDS[e.type], "armStepKind");
 var joinIdOf = /* @__PURE__ */ __name3((entryId) => `${entryId}.join`, "joinIdOf");
 var containerIdOf = /* @__PURE__ */ __name3((type, entryIndex) => `${type}@${entryIndex}`, "containerIdOf");
 function compilePlan(g) {
@@ -2598,10 +3181,10 @@ function compilePlan(g) {
   let prevTails = [];
   const foreachJoinToEntry = /* @__PURE__ */ new Map();
   g.definition.graph.forEach((entry, entryIndex) => {
-    if (isSingleStep(entry)) {
-      const id = singleStepId(entry);
+    if (isArmStep(entry)) {
+      const id = armStepId(entry);
       addNode(id, {
-        kind: SINGLE_STEP_KINDS[entry.type],
+        kind: armStepKind(entry),
         dependsOn: prevTails,
         downstream: [],
         unsatisfiedDeps: prevTails.length,
@@ -2626,9 +3209,8 @@ function compilePlan(g) {
         ];
         return;
       case "sleep":
-      case "sleepUntil":
-      case "approval": {
-        const kind = entry.type === "approval" ? "approval" : entry.type;
+      case "sleepUntil": {
+        const kind = entry.type;
         addNode(entry.id, {
           kind,
           dependsOn: prevTails,
@@ -2641,24 +3223,12 @@ function compilePlan(g) {
         ];
         return;
       }
-      case "waitForSignal":
-        addNode(entry.id, {
-          kind: "signal",
-          dependsOn: prevTails,
-          downstream: [],
-          unsatisfiedDeps: prevTails.length,
-          entry
-        });
-        prevTails = [
-          entry.id
-        ];
-        return;
       case "parallel": {
         const entryId = containerIdOf("parallel", entryIndex);
         const childIds = entry.steps.map((arm) => {
-          const childId = singleStepId(arm);
+          const childId = armStepId(arm);
           addNode(childId, {
-            kind: SINGLE_STEP_KINDS[arm.type],
+            kind: armStepKind(arm),
             dependsOn: prevTails,
             downstream: [],
             unsatisfiedDeps: prevTails.length,
@@ -2696,9 +3266,9 @@ function compilePlan(g) {
           node.otherwise
         ] : node.steps;
         const childIds = arms.map((arm) => {
-          const childId = arm.type === "mapping" ? arm.id : singleStepId(arm);
+          const childId = arm.type === "mapping" ? arm.id : armStepId(arm);
           addNode(childId, {
-            kind: arm.type === "mapping" ? "map" : SINGLE_STEP_KINDS[arm.type],
+            kind: arm.type === "mapping" ? "map" : armStepKind(arm),
             dependsOn: [
               entryId
             ],
@@ -3072,7 +3642,16 @@ var WorkflowTemplateError = class extends Error {
     this.name = "WorkflowTemplateError";
   }
 };
+function isMapConfigObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+__name(isMapConfigObject, "isMapConfigObject");
+__name3(isMapConfigObject, "isMapConfigObject");
 function parseMapConfig(raw, stepId) {
+  if (isMapConfigObject(raw)) return raw;
+  if (typeof raw !== "string") {
+    throw new Error(`Stored mapping step "${stepId}" has a mapConfig that is neither a JSON string nor an object.`);
+  }
   try {
     return JSON.parse(raw);
   } catch (e) {
@@ -3081,6 +3660,13 @@ function parseMapConfig(raw, stepId) {
 }
 __name(parseMapConfig, "parseMapConfig");
 __name3(parseMapConfig, "parseMapConfig");
+function mapConfigWire(raw) {
+  if (typeof raw === "string") return raw;
+  if (isMapConfigObject(raw)) return canonicalJson(raw);
+  return void 0;
+}
+__name(mapConfigWire, "mapConfigWire");
+__name3(mapConfigWire, "mapConfigWire");
 var TEMPLATE_PLACEHOLDER = /\$\{([^}]*)\}/g;
 var TEMPLATE_NAMESPACES = [
   "initData",
@@ -3281,6 +3867,77 @@ var rows = /* @__PURE__ */ __name3((s, path, page) => ({
 var fromKnowledge = /* @__PURE__ */ __name3((k) => ({
   knowledge: k
 }), "fromKnowledge");
+var CONTINUED_FAILURE_TAG = "continued_failure";
+var CONTINUED_FAILURE_DEFAULT_CODE = "step_failed";
+var CONTINUED_FAILURE_OUTPUT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: {
+    __lua_workflow: {
+      type: "string",
+      const: CONTINUED_FAILURE_TAG
+    },
+    failed: {
+      type: "boolean",
+      const: true
+    },
+    error: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string"
+        },
+        message: {
+          type: "string"
+        }
+      },
+      required: [
+        "code",
+        "message"
+      ]
+    },
+    text: {
+      type: "string",
+      const: ""
+    }
+  },
+  required: [
+    "__lua_workflow",
+    "failed",
+    "error",
+    "text"
+  ]
+});
+var CONTINUED_FAILURE_LEAF_PATHS = Object.freeze([
+  "failed",
+  "error",
+  "error.code",
+  "error.message",
+  "text"
+]);
+function continuedFailureValue(error, killReason) {
+  const code = typeof error?.code === "string" && error.code || typeof killReason === "string" && killReason || CONTINUED_FAILURE_DEFAULT_CODE;
+  const message = typeof error?.message === "string" && error.message ? error.message : code;
+  return {
+    __lua_workflow: CONTINUED_FAILURE_TAG,
+    failed: true,
+    error: {
+      code,
+      message
+    },
+    text: ""
+  };
+}
+__name(continuedFailureValue, "continuedFailureValue");
+__name3(continuedFailureValue, "continuedFailureValue");
+function isContinuedFailureValue(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const o = v;
+  const err = o.error;
+  return o.__lua_workflow === CONTINUED_FAILURE_TAG && o.failed === true && o.text === "" && err !== null && typeof err === "object" && typeof err.code === "string" && typeof err.message === "string";
+}
+__name(isContinuedFailureValue, "isContinuedFailureValue");
+__name3(isContinuedFailureValue, "isContinuedFailureValue");
+var isHitlNode2 = /* @__PURE__ */ __name3((n2) => isWorkflowHitlEntryType(n2.type), "isHitlNode");
 function lowerContainerArm(mapping, step22) {
   const stepId = nodeIdOf(step22);
   return {
@@ -3296,7 +3953,7 @@ function lowerContainerArm(mapping, step22) {
 }
 __name(lowerContainerArm, "lowerContainerArm");
 __name3(lowerContainerArm, "lowerContainerArm");
-var nodeIdOf = /* @__PURE__ */ __name3((n) => n.type === "step" ? n.step.id : n.id, "nodeIdOf");
+var nodeIdOf = /* @__PURE__ */ __name3((n2) => n2.type === "step" ? n2.step.id : n2.id, "nodeIdOf");
 function entryIds(entry) {
   switch (entry.type) {
     case "parallel":
@@ -3366,7 +4023,28 @@ function resolvePlacements(calls) {
         break;
     }
   });
-  const resolve = /* @__PURE__ */ __name3((ref, i, allowMapping) => {
+  const hitlPlacementIssue = /* @__PURE__ */ __name3((node, ref, i, container) => {
+    if (!isHitlNode2(node)) return void 0;
+    const id = node.id;
+    if (ref.armMap) {
+      return {
+        code: "node-type-unsupported-in-container",
+        message: workflowHitlArmShapeMessage(node.type, id, "mapped-arm"),
+        callIndex: i,
+        stepId: id
+      };
+    }
+    if (container !== "place" && !workflowContainerRunsHitlArm(container)) {
+      return {
+        code: "node-type-unsupported-in-container",
+        message: workflowHitlArmUnsupportedMessage(node.type, id, container),
+        callIndex: i,
+        stepId: id
+      };
+    }
+    return void 0;
+  }, "hitlPlacementIssue");
+  const resolve = /* @__PURE__ */ __name3((ref, i, allowMapping, container) => {
     if ("node" in ref) {
       if (ref.node.type === "mapping" && !allowMapping) {
         issues.push({
@@ -3383,7 +4061,7 @@ function resolvePlacements(calls) {
     if (!d) {
       issues.push({
         code: "unknown-step-ref",
-        message: `"${ref.ref}" is not declared anywhere in the chain \u2014 declare it with agentStep/specialistStep/toolStep/map(\u2026, { id })`,
+        message: `"${ref.ref}" is not declared anywhere in the chain \u2014 declare it with agentStep/specialistStep/toolStep/map(\u2026, { id })/workflow(\u2026)/approval(\u2026)/waitForSignal(\u2026)`,
         callIndex: i,
         stepId: ref.ref
       });
@@ -3398,6 +4076,11 @@ function resolvePlacements(calls) {
       });
       return void 0;
     }
+    const hitl = hitlPlacementIssue(d.node, ref, i, container);
+    if (hitl) {
+      issues.push(hitl);
+      return void 0;
+    }
     const prior = placedBy.get(ref.ref);
     if (prior !== void 0 && prior !== i) {
       issues.push({
@@ -3411,23 +4094,31 @@ function resolvePlacements(calls) {
     placedBy.set(ref.ref, i);
     return d.node;
   }, "resolve");
+  const claim = /* @__PURE__ */ __name3((ref, i, allowMapping, container) => {
+    if ("ref" in ref) {
+      resolve(ref, i, allowMapping, container);
+      return;
+    }
+    const hitl = hitlPlacementIssue(ref.node, ref, i, container);
+    if (hitl) issues.push(hitl);
+  }, "claim");
   calls.forEach((call, i) => {
     switch (call.kind) {
       case "place":
-        resolve({
+        claim({
           ref: call.ref
-        }, i, false);
+        }, i, false, "place");
         break;
       case "parallel":
-        for (const arm of call.arms) if ("ref" in arm) resolve(arm, i, false);
+        for (const arm of call.arms) claim(arm, i, false, "parallel");
         break;
       case "conditional":
-        for (const a of call.arms) if ("ref" in a.target) resolve(a.target, i, true);
-        if (call.otherwise && "ref" in call.otherwise) resolve(call.otherwise, i, true);
+        for (const a of call.arms) claim(a.target, i, true, "conditional");
+        if (call.otherwise) claim(call.otherwise, i, true, "conditional");
         break;
       case "foreach":
       case "loop":
-        if ("ref" in call.body) resolve(call.body, i, false);
+        claim(call.body, i, false, call.kind);
         break;
       default:
         break;
@@ -3435,9 +4126,9 @@ function resolvePlacements(calls) {
   });
   const graph = [];
   const lookup = /* @__PURE__ */ __name3((ref) => {
-    const n = "node" in ref ? ref.node : declared.get(ref.ref)?.node;
-    if (!n || !ref.armMap || n.type === "mapping") return n;
-    return lowerContainerArm(ref.armMap, n);
+    const n2 = "node" in ref ? ref.node : declared.get(ref.ref)?.node;
+    if (!n2 || !ref.armMap || n2.type === "mapping" || isHitlNode2(n2)) return n2;
+    return lowerContainerArm(ref.armMap, n2);
   }, "lookup");
   calls.forEach((call, i) => {
     switch (call.kind) {
@@ -3456,7 +4147,7 @@ function resolvePlacements(calls) {
         return;
       }
       case "parallel": {
-        const steps = call.arms.map(lookup).filter((n) => !!n && n.type !== "mapping");
+        const steps = call.arms.map(lookup).filter((n2) => !!n2 && n2.type !== "mapping");
         const node = {
           type: "parallel",
           steps
@@ -3469,9 +4160,9 @@ function resolvePlacements(calls) {
         const steps = [];
         const predicates = [];
         for (const a of call.arms) {
-          const n = lookup(a.target);
-          if (!n) continue;
-          steps.push(n);
+          const n2 = lookup(a.target);
+          if (!n2) continue;
+          steps.push(n2);
           predicates.push(a.predicate);
         }
         const node = {
@@ -3518,6 +4209,75 @@ function resolvePlacements(calls) {
 }
 __name(resolvePlacements, "resolvePlacements");
 __name3(resolvePlacements, "resolvePlacements");
+var GOAL_JUDGE_STEP_ID = "__goal_judge";
+var NON_LEAF_KINDS = /* @__PURE__ */ new Set([
+  "foreach",
+  "branch"
+]);
+var CONDITIONAL_JOIN_ID = /^conditional@\d+\.join$/;
+function isConditionalJoinId(stepId) {
+  return CONDITIONAL_JOIN_ID.test(stepId);
+}
+__name(isConditionalJoinId, "isConditionalJoinId");
+__name3(isConditionalJoinId, "isConditionalJoinId");
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+__name(isPlainObject, "isPlainObject");
+__name3(isPlainObject, "isPlainObject");
+function leafValue(row) {
+  if (row.status === "completed") return row.output === void 0 ? null : row.output;
+  return continuedFailureValue(row.error, row.killReason);
+}
+__name(leafValue, "leafValue");
+__name3(leafValue, "leafValue");
+function runOutputLeaves(steps) {
+  const dependedOn = /* @__PURE__ */ new Set();
+  for (const s of steps) {
+    if (s.stepId === GOAL_JUDGE_STEP_ID) continue;
+    for (const d of s.dependsOn ?? []) dependedOn.add(d);
+  }
+  return steps.filter((s) => s.stepId !== GOAL_JUDGE_STEP_ID && !NON_LEAF_KINDS.has(s.kind ?? "") && s.foreachIndex === void 0 && s.loopParentId === void 0 && s.status !== "skipped" && !dependedOn.has(s.stepId));
+}
+__name(runOutputLeaves, "runOutputLeaves");
+__name3(runOutputLeaves, "runOutputLeaves");
+function deriveRunOutput(steps) {
+  const leaves = runOutputLeaves(steps);
+  if (leaves.length === 0) return void 0;
+  if (leaves.length === 1) {
+    const leaf = leaves[0];
+    const value22 = leafValue(leaf);
+    if (isConditionalJoinId(leaf.stepId) && isPlainObject(value22)) {
+      const keys = Object.keys(value22);
+      if (keys.length === 1) return {
+        output: value22[keys[0]],
+        leafIds: [
+          keys[0]
+        ]
+      };
+    }
+    return {
+      output: value22,
+      leafIds: [
+        leaf.stepId
+      ]
+    };
+  }
+  const output = {};
+  for (const leaf of leaves) output[leaf.stepId] = leafValue(leaf);
+  return {
+    output,
+    leafIds: leaves.map((l) => l.stepId)
+  };
+}
+__name(deriveRunOutput, "deriveRunOutput");
+__name3(deriveRunOutput, "deriveRunOutput");
+function subrunSettledOutput(child) {
+  if (child.output !== void 0) return child.output;
+  return deriveRunOutput(child.steps ?? [])?.output ?? null;
+}
+__name(subrunSettledOutput, "subrunSettledOutput");
+__name3(subrunSettledOutput, "subrunSettledOutput");
 function seedLedgerFromRun(run, steps, targetPlan, opts = {}) {
   const byId = /* @__PURE__ */ new Map();
   for (const s of steps) {
@@ -3579,7 +4339,35 @@ function seedLedgerFromRun(run, steps, targetPlan, opts = {}) {
 }
 __name(seedLedgerFromRun, "seedLedgerFromRun");
 __name3(seedLedgerFromRun, "seedLedgerFromRun");
-var armId2 = /* @__PURE__ */ __name3((arm) => arm.type === "step" ? arm.step.id : arm.id, "armId");
+var branchArmId = /* @__PURE__ */ __name3((arm) => arm.type === "step" ? arm.step.id : arm.id, "branchArmId");
+function branchSpecFromConditional(entry) {
+  return {
+    arms: entry.steps.map((arm, i) => ({
+      stepId: branchArmId(arm),
+      predicate: entry.predicates[i]
+    })),
+    ...entry.exclusive === true ? {
+      exclusive: true
+    } : {},
+    ...entry.otherwise ? {
+      otherwise: branchArmId(entry.otherwise)
+    } : {}
+  };
+}
+__name(branchSpecFromConditional, "branchSpecFromConditional");
+__name3(branchSpecFromConditional, "branchSpecFromConditional");
+function selectBranchArms(spec, ctx) {
+  const taken = [];
+  for (const arm of spec.arms) {
+    if (spec.exclusive && taken.length > 0) break;
+    const hit = arm.predicate ? evaluatePredicate(arm.predicate, ctx) : false;
+    if (hit) taken.push(arm.stepId);
+  }
+  if (taken.length === 0 && spec.otherwise) taken.push(spec.otherwise);
+  return taken;
+}
+__name(selectBranchArms, "selectBranchArms");
+__name3(selectBranchArms, "selectBranchArms");
 var canonical = /* @__PURE__ */ __name3((v) => JSON.stringify(sortKeys(v)), "canonical");
 var sortKeys = /* @__PURE__ */ __name3((v) => {
   if (Array.isArray(v)) return v.map(sortKeys);
@@ -3597,25 +4385,24 @@ function replayLedger(g, ledger) {
     r.stepId,
     r
   ]));
-  const stepResults = {};
-  for (const r of ledger.steps) if (r.status === "completed") stepResults[r.stepId] = r.output;
-  const ctx = {
+  const requestContext = {
+    runId: "replay",
+    workflowId: g.definition.id,
+    orgId: "",
+    agentId: "",
+    userId: "",
+    trigger: "sdk",
+    threadId: "replay",
+    depth: 0,
+    startedAt: 0,
+    ...ledger.requestContext
+  };
+  const ctxFor = /* @__PURE__ */ __name3((id) => ({
     initData: ledger.initData,
-    stepResults,
+    stepResults: ancestorResults(plan, id, rows22),
     state: ledger.state ?? {},
-    requestContext: {
-      runId: "replay",
-      workflowId: g.definition.id,
-      orgId: "",
-      agentId: "",
-      userId: "",
-      trigger: "sdk",
-      threadId: "replay",
-      depth: 0,
-      startedAt: 0,
-      ...ledger.requestContext
-    }
-  };
+    requestContext
+  }), "ctxFor");
   const verdicts = [];
   for (const id of plan.order) {
     const node = plan.steps[id];
@@ -3623,17 +4410,7 @@ function replayLedger(g, ledger) {
     if (!recorded || recorded.status === "pending" || recorded.status === "skipped") continue;
     if (node.kind === "branch") {
       const entry = node.entry;
-      const taken = [];
-      entry.steps.forEach((arm, i) => {
-        const pred = entry.predicates[i];
-        const hit = pred ? evaluatePredicate(pred, {
-          initData: ledger.initData,
-          stepResults,
-          state: ledger.state
-        }) : false;
-        if (hit && (!entry.exclusive || taken.length === 0)) taken.push(armId2(arm));
-      });
-      if (taken.length === 0 && entry.otherwise) taken.push(armId2(entry.otherwise));
+      const taken = selectBranchArms(branchSpecFromConditional(entry), ctxFor(id));
       const recordedTaken = recorded.taken ?? inferTaken(entry, rows22);
       verdicts.push({
         stepId: id,
@@ -3644,7 +4421,7 @@ function replayLedger(g, ledger) {
       });
     } else if (node.kind === "map" && !id.endsWith(".join") && recorded.status === "completed") {
       const entry = node.entry;
-      const resolved = resolveMapping(parseMapConfig(entry.mapConfig, id), ctx);
+      const resolved = resolveMapping(parseMapConfig(entry.mapConfig, id), ctxFor(id));
       const local = "error" in resolved ? {
         error: resolved.error,
         key: resolved.key
@@ -3659,7 +4436,7 @@ function replayLedger(g, ledger) {
     } else if (node.kind === "foreach") {
       const entry = node.entry;
       const source = node.dependsOn[0];
-      const items = source ? stepResults[source] : void 0;
+      const items = source ? ctxFor(id).stepResults[source] : void 0;
       const local = Array.isArray(items) ? items.length : void 0;
       const recordedCount = recorded.itemCount ?? countChildren(entry, rows22);
       verdicts.push({
@@ -3669,6 +4446,15 @@ function replayLedger(g, ledger) {
         local,
         diverged: recordedCount !== local
       });
+    } else if (node.kind === "subrun" && recorded.status === "completed" && recorded.child) {
+      const local = subrunSettledOutput(recorded.child);
+      verdicts.push({
+        stepId: id,
+        kind: "subrun",
+        recorded: recorded.output,
+        local,
+        diverged: canonical(recorded.output) !== canonical(local)
+      });
     }
   }
   return {
@@ -3678,6 +4464,77 @@ function replayLedger(g, ledger) {
 }
 __name(replayLedger, "replayLedger");
 __name3(replayLedger, "replayLedger");
+var JOIN = ".join";
+var entryOfJoin = /* @__PURE__ */ __name3((id) => id.endsWith(JOIN) ? id.slice(0, -JOIN.length) : void 0, "entryOfJoin");
+function replayResultOf(row, node) {
+  if (!row) return void 0;
+  if (row.status === "completed") return {
+    value: row.output
+  };
+  if (row.status === "failed") {
+    const onError = row.onError ?? node?.entry?.onError;
+    if (onError === "continue") return {
+      value: continuedFailureValue(row.error, row.killReason)
+    };
+  }
+  return void 0;
+}
+__name(replayResultOf, "replayResultOf");
+__name3(replayResultOf, "replayResultOf");
+function ancestorResults(plan, id, rows22) {
+  const out = {};
+  const joinAliased = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const take = /* @__PURE__ */ __name3((rowId) => {
+    const hit = replayResultOf(rows22.get(rowId), plan.steps[rowId]);
+    if (!hit) return void 0;
+    if (!joinAliased.has(rowId)) out[rowId] = hit.value;
+    const entryId = entryOfJoin(rowId);
+    if (entryId) {
+      out[entryId] = hit.value;
+      joinAliased.add(entryId);
+      const entryNode = plan.steps[entryId];
+      if (entryNode?.kind === "foreach") {
+        const body = branchArmId(entryNode.entry.step);
+        out[body] = hit.value;
+        joinAliased.add(body);
+      }
+    }
+    return hit;
+  }, "take");
+  const walk2 = /* @__PURE__ */ __name3((ids) => {
+    for (const dep of ids) {
+      if (seen.has(dep)) continue;
+      seen.add(dep);
+      take(dep);
+      const node = plan.steps[dep] ?? plan.steps[entryOfJoin(dep) ?? ""];
+      if (!node) continue;
+      if (node.kind === "foreach") {
+        const body = branchArmId(node.entry.step);
+        for (const rowId of rows22.keys()) if (rowId.startsWith(`${body}[`)) take(rowId);
+      } else if (node.kind === "loop") {
+        const body = branchArmId(node.entry.step);
+        let best = -1;
+        for (const rowId of rows22.keys()) {
+          if (!rowId.startsWith(`${body}#`)) continue;
+          const n2 = Number(rowId.slice(body.length + 1));
+          if (!Number.isInteger(n2)) continue;
+          const hit = take(rowId);
+          if (!hit) continue;
+          if (n2 > best) {
+            best = n2;
+            out[body] = hit.value;
+          }
+        }
+      }
+      walk2(node.dependsOn);
+    }
+  }, "walk");
+  walk2(plan.steps[id]?.dependsOn ?? []);
+  return out;
+}
+__name(ancestorResults, "ancestorResults");
+__name3(ancestorResults, "ancestorResults");
 function inferTaken(entry, rows22) {
   const arms = [
     ...entry.steps,
@@ -3685,7 +4542,7 @@ function inferTaken(entry, rows22) {
       entry.otherwise
     ] : []
   ];
-  return arms.map(armId2).filter((id) => {
+  return arms.map(branchArmId).filter((id) => {
     const r = rows22.get(id);
     return r !== void 0 && r.status !== "skipped" && r.status !== "pending";
   });
@@ -3693,10 +4550,10 @@ function inferTaken(entry, rows22) {
 __name(inferTaken, "inferTaken");
 __name3(inferTaken, "inferTaken");
 function countChildren(entry, rows22) {
-  const body = armId2(entry.step);
-  let n = 0;
-  for (const id of rows22.keys()) if (id.startsWith(`${body}[`)) n += 1;
-  return n;
+  const body = branchArmId(entry.step);
+  let n2 = 0;
+  for (const id of rows22.keys()) if (id.startsWith(`${body}[`)) n2 += 1;
+  return n2;
 }
 __name(countChildren, "countChildren");
 __name3(countChildren, "countChildren");
@@ -3713,21 +4570,58 @@ function pruneUndefined(o) {
 __name(pruneUndefined, "pruneUndefined");
 __name3(pruneUndefined, "pruneUndefined");
 function runNextAction(run) {
-  if (isTerminalRunStatus(run.status) || !run.cancel?.requestedAt) return "none";
+  if (isTerminalRunStatus(run.status)) return "none";
+  if (run.status === "suspended" && run.gate?.kind === "budget") return "raise_budget";
+  if (!run.cancel?.requestedAt) return "none";
   const forceAt = run.cancel.forceAfter ?? run.cancel.requestedAt + FORCE_CANCEL_STALE_MS;
   return Date.now() >= forceAt ? "force" : "cancel_again";
 }
 __name(runNextAction, "runNextAction");
 __name3(runNextAction, "runNextAction");
+var IN_FLIGHT = new Set(WORKFLOW_STEP_IN_FLIGHT);
+function emptyRunCounts() {
+  const out = {
+    total: 0,
+    inFlight: 0
+  };
+  for (const status of WORKFLOW_STEP_STATUSES) out[status] = 0;
+  return out;
+}
+__name(emptyRunCounts, "emptyRunCounts");
+__name3(emptyRunCounts, "emptyRunCounts");
+function runCountsFromStatusTally(tally) {
+  const out = emptyRunCounts();
+  for (const [status, n2] of Object.entries(tally)) {
+    if (!Number.isFinite(n2) || n2 <= 0) continue;
+    out.total += n2;
+    if (WORKFLOW_STEP_STATUSES.includes(status)) out[status] += n2;
+    if (IN_FLIGHT.has(status)) out.inFlight += n2;
+  }
+  return out;
+}
+__name(runCountsFromStatusTally, "runCountsFromStatusTally");
+__name3(runCountsFromStatusTally, "runCountsFromStatusTally");
+function runCountsFromStepStatuses(statuses) {
+  const tally = {};
+  for (const s of statuses) tally[s] = (tally[s] ?? 0) + 1;
+  return runCountsFromStatusTally(tally);
+}
+__name(runCountsFromStepStatuses, "runCountsFromStepStatuses");
+__name3(runCountsFromStepStatuses, "runCountsFromStepStatuses");
+var n = /* @__PURE__ */ __name3((v) => typeof v === "number" && Number.isFinite(v) ? v : 0, "n");
 function runCounts(counts) {
+  const c = counts ?? {};
+  const rawInFlight = c.dispatched !== void 0 || c.claimed !== void 0 || c.running !== void 0 || c.cancellation_requested !== void 0;
   return {
-    total: counts?.total ?? 0,
-    completed: counts?.completed ?? 0,
-    failed: counts?.failed ?? 0,
-    skipped: counts?.skipped ?? 0,
-    running: counts?.inFlight ?? 0,
-    suspended: counts?.suspended ?? 0,
-    pending: (counts?.pending ?? 0) + (counts?.ready ?? 0) + (counts?.waiting ?? 0)
+    total: n(c.total),
+    completed: n(c.completed),
+    failed: n(c.failed) + n(c.timeout) + n(c.reaped),
+    skipped: n(c.skipped),
+    // LUA-664: cancelled rows never ran — their own wire bucket, never a failure (the detail's map, verbatim).
+    cancelled: n(c.cancelled),
+    running: rawInFlight ? n(c.dispatched) + n(c.claimed) + n(c.running) + n(c.cancellation_requested) : n(c.inFlight),
+    suspended: n(c.suspended),
+    pending: n(c.pending) + n(c.ready) + n(c.waiting)
   };
 }
 __name(runCounts, "runCounts");
@@ -3748,7 +4642,23 @@ function runCancelView(cancel) {
   return {
     requestedAt: cancel.requestedAt,
     requestedBy: cancel.requestedBy ?? "",
-    forceAvailableAt: cancel.forceAfter ?? cancel.requestedAt + FORCE_CANCEL_STALE_MS
+    forceAvailableAt: cancel.forceAfter ?? cancel.requestedAt + FORCE_CANCEL_STALE_MS,
+    // LUA-686: the wall's own request (LUA-683 stamps `wall:true` from a system actor only) rides the wire, so a
+    // client can tell a wall-ended `timed_out` run's audit block from a cancel it should chip. Absent, never false.
+    ...cancel.wall === true ? {
+      wall: true
+    } : {},
+    // LUA-704: a forced terminal's audit — who forced it, when, and a human's own reason text (the run's `reason`
+    // is the terminal's). Absent on an unforced terminal, never null.
+    ...typeof cancel.forcedAt === "number" ? {
+      forcedAt: cancel.forcedAt
+    } : {},
+    ...typeof cancel.forcedBy === "string" && cancel.forcedBy ? {
+      forcedBy: cancel.forcedBy
+    } : {},
+    ...typeof cancel.forceReason === "string" && cancel.forceReason ? {
+      forceReason: cancel.forceReason
+    } : {}
   };
 }
 __name(runCancelView, "runCancelView");
@@ -3757,7 +4667,7 @@ function runWorkspaceView(ws) {
   if (!ws) return void 0;
   const w = ws;
   return pruneUndefined({
-    kind: w.kind ?? "empty",
+    kind: w.spec?.kind ?? w.kind ?? "empty",
     backend: w.backend,
     status: String(w.status ?? ""),
     branch: w.branch,
@@ -3771,7 +4681,6 @@ __name3(runWorkspaceView, "runWorkspaceView");
 function toWorkflowRunSummary(run) {
   const status = run.status;
   const principal = run.principal?.principal;
-  const gated = status === "gated" || status === "suspended";
   return pruneUndefined({
     runId: run.id,
     workflowId: run.workflowId,
@@ -3783,7 +4692,14 @@ function toWorkflowRunSummary(run) {
     orgId: run.orgId,
     spaceAgentId: run.spaceAgentId,
     status,
-    gate: gated ? run.gate : void 0,
+    // LUA-702 (pass-3B D6): the gate rides the wire whenever a NON-terminal doc carries one. In the LUA-681 window
+    // (an approval resolved beside an open exception park) the run is `running` AND still holds `gate{exception}`
+    // until the tick tail parks it back; projecting it only on gated|suspended hid that park from R4 / the CLI /
+    // the desktop (prod 2026-09-05: `status: running, gate: null`). A terminal doc carries no gate by contract
+    // (`terminalizeRun` drops `gate` / `suspendedFor` in every terminal write), but a row terminalized before that
+    // held — pre-LUA-677/694 docs, a script-tier backstop that passed no `unset` — may still carry a stale one:
+    // hidden here, so a `failed` run never reads "Needs a decision" on R3/R4 or the CLI (#2476 review).
+    gate: run.gate && !isTerminalRunStatus(status) ? run.gate : void 0,
     batchId: run.batchId,
     goalId: run.goalId,
     foreachOverflow: run.foreachOverflow,
@@ -3806,9 +4722,11 @@ function toWorkflowRunSummary(run) {
     principalKind: run.principalKind ?? "user",
     cancel: runCancelView(run.cancel),
     usage: runUsage(run),
+    // LUA-697: a row persisted before the write seams (#2406 / #2465 / the script tier) leaves scrubbed here too —
+    // idempotent on a scrubbed message, bounded input; an empty message falls back to the code.
     error: run.error ? {
       code: run.error.code ?? "error",
-      message: run.error.message ?? "",
+      message: scrubStepErrorMessage(run.error.message) ?? run.error.code ?? "error",
       stepId: run.error.stepId
     } : void 0,
     kind: "run",
@@ -3821,11 +4739,94 @@ function toWorkflowRunSummary(run) {
     eventSeq: run.eventSeq ?? 0,
     cancellable: !isTerminalRunStatus(status),
     nextAction: runNextAction(run),
-    workspace: runWorkspaceView(run.workspace)
+    workspace: runWorkspaceView(run.workspace),
+    // LUA-643: the runs list says a result exists; R4 `fields:'full'` (output-ACL gated, audited) serves it. The
+    // stamped flag is what a list page carries (it projects `output` out); the payload members cover R4's full row.
+    hasOutput: run.hasOutput === true || run.output !== void 0 || run.outputRef !== void 0 ? true : void 0
   });
 }
 __name(toWorkflowRunSummary, "toWorkflowRunSummary");
 __name3(toWorkflowRunSummary, "toWorkflowRunSummary");
+var STEP_ERROR_DETAIL_KEYS = [
+  "reason",
+  "key",
+  "integrationType",
+  "candidates",
+  "connectionId",
+  "status",
+  "code",
+  "providerStatus",
+  "model",
+  "turnIndex",
+  "message",
+  // LUA-655: `output_schema_invalid` — the Ajv issues ({path, message}, ≤ 20, scrubbed at the source too) and the
+  // in-session repair rounds the attempt spent.
+  "issues",
+  "repairRounds",
+  // LUA-669 (#2446 review 4): the subrun failures — `subrun_<status>` names the child run and how it ended
+  // (`childStatus`, `childReason: 'max_duration'` under `subrun_timed_out`), `subrun_depth_exceeded` its `depth` /
+  // `max`, and every refusal the target `workflowId`. Short scalars only: the child's whole `childError` and the
+  // cycle walk's `ancestors` stay off the wire — the child run's own R4 carries its error.
+  "childRunId",
+  "childStatus",
+  "childReason",
+  "max",
+  "depth",
+  "workflowId",
+  // LUA-696 (review 2): the `ctx.once` key of an `effect_in_doubt` park — the step site stamps it here (scrubbed)
+  // beside `park.effectKey`; a key is user text and leaves scrubbed like every other string leaf.
+  "effectKey"
+];
+var STEP_ERROR_DETAIL_MAX_BYTES = 8 * 1024;
+var DETAIL_MAX_DEPTH = 4;
+var DETAIL_MAX_ITEMS = 100;
+function scrubDetailValue(value22, depth) {
+  if (typeof value22 === "string") return scrubSecretText(value22);
+  if (typeof value22 === "number" || typeof value22 === "boolean" || value22 === null) return value22;
+  if (depth >= DETAIL_MAX_DEPTH) return void 0;
+  if (Array.isArray(value22)) {
+    return value22.slice(0, DETAIL_MAX_ITEMS).map((v) => scrubDetailValue(v, depth + 1)).filter((v) => v !== void 0);
+  }
+  if (typeof value22 === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value22)) {
+      const s = scrubDetailValue(v, depth + 1);
+      if (s !== void 0) out[k] = s;
+    }
+    return out;
+  }
+  return void 0;
+}
+__name(scrubDetailValue, "scrubDetailValue");
+__name3(scrubDetailValue, "scrubDetailValue");
+function stepErrorDetail(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const d = error.detail;
+  if (!d || typeof d !== "object" || Array.isArray(d)) return void 0;
+  const bag = d;
+  const out = {};
+  for (const k of STEP_ERROR_DETAIL_KEYS) {
+    if (!(k in bag)) continue;
+    const v = scrubDetailValue(bag[k], 1);
+    if (v !== void 0) out[k] = v;
+  }
+  if (!Object.keys(out).length) return void 0;
+  let bytes;
+  try {
+    bytes = new TextEncoder().encode(JSON.stringify(out)).length;
+  } catch {
+    return void 0;
+  }
+  if (bytes <= STEP_ERROR_DETAIL_MAX_BYTES) return out;
+  const scalars = Object.fromEntries(Object.entries(out).filter(([, v]) => v === null || typeof v !== "object"));
+  return {
+    ...scalars,
+    __truncated: true,
+    bytes
+  };
+}
+__name(stepErrorDetail, "stepErrorDetail");
+__name3(stepErrorDetail, "stepErrorDetail");
 var MAX_HOLIDAYS = 366;
 var MAX_WALK_DAYS = 400;
 var HHMM = /^([01]\d|2[0-3]):([0-5]\d)$/;
@@ -4382,58 +5383,86 @@ __name(rebaseItemPointer, "rebaseItemPointer");
 __name3(rebaseItemPointer, "rebaseItemPointer");
 var APPROVER_SPEC_MAX_USERS = 20;
 var ESCALATION_MAX_HOPS = 3;
-var TemplateBindingSchema = z4.object({
-  template: z4.string().min(1).max(2048)
+var TemplateBindingSchema = z22.object({
+  template: z22.string().min(1).max(2048)
 }).strict();
-var ApproverSpecSchema = z4.union([
-  z4.literal("creator"),
-  z4.literal("org-admins"),
-  z4.object({
-    users: z4.union([
-      z4.array(z4.string().min(1).max(128)).min(1).max(APPROVER_SPEC_MAX_USERS),
+var ApproverSpecSchema = z22.union([
+  z22.literal("creator"),
+  z22.literal("org-admins"),
+  z22.object({
+    users: z22.union([
+      z22.array(z22.string().min(1).max(128)).min(1).max(APPROVER_SPEC_MAX_USERS),
       TemplateBindingSchema
     ])
   }).strict(),
-  z4.object({
-    role: z4.union([
-      z4.string().min(1).max(128),
+  z22.object({
+    role: z22.union([
+      z22.string().min(1).max(128),
       TemplateBindingSchema
     ])
   }).strict(),
-  z4.object({
-    group: z4.union([
-      z4.string().min(1).max(128),
+  z22.object({
+    group: z22.union([
+      z22.string().min(1).max(128),
       TemplateBindingSchema
     ])
   }).strict(),
-  z4.object({
-    governance: z4.object({
-      policyId: z4.string().min(1).max(128)
+  z22.object({
+    governance: z22.object({
+      policyId: z22.string().min(1).max(128)
     }).strict()
   }).strict()
 ]);
-var FourEyesSchema = z4.object({
+var FourEyesSchema = z22.object({
   edit: ApproverSpecSchema,
   approve: ApproverSpecSchema
 }).strict();
-var EscalationHopSchema = z4.object({
+var EscalationHopSchema = z22.object({
   escalateTo: ApproverSpecSchema,
-  timeoutHours: z4.number().finite().min(1).max(720)
+  timeoutHours: z22.number().finite().min(1).max(720)
 }).strict();
-var TerminalOutcomeSchema = z4.enum([
+var TerminalOutcomeSchema = z22.enum([
   "deny",
   "cancel-run",
   "fail",
   "continue"
 ]);
-var ApprovalOnTimeoutSchema = z4.union([
+var ApprovalOnTimeoutSchema = z22.union([
   TerminalOutcomeSchema,
   EscalationHopSchema,
-  z4.array(z4.union([
+  z22.array(z22.union([
     TerminalOutcomeSchema,
     EscalationHopSchema
   ])).min(1).max(ESCALATION_MAX_HOPS + 1)
 ]);
+var APPROVER_SPEC_SHAPES = [
+  "'creator'",
+  "'org-admins'",
+  "{users:[userId, \u2026]}",
+  "{role:roleName}",
+  "{group:groupName}",
+  "{governance:{policyId}}"
+];
+var APPROVER_WRITTEN_MAX = 120;
+var USER_ID_SHAPED_RE = /^[^\s@]{1,128}$/;
+function describeApproverSpecRefusal(spec) {
+  const raw = spec === void 0 ? "undefined" : JSON.stringify(spec) ?? String(spec);
+  const written = raw.length > APPROVER_WRITTEN_MAX ? `${raw.slice(0, APPROVER_WRITTEN_MAX - 1)}\u2026` : raw;
+  const users = typeof spec === "object" && spec !== null ? spec.users : void 0;
+  const approver = typeof users === "string" && USER_ID_SHAPED_RE.test(users) ? {
+    users: [
+      users
+    ]
+  } : "creator";
+  const message = `approver ${written} is not an approver \u2014 legal: ${APPROVER_SPEC_SHAPES.join(" | ")}. 'creator' is the person who started the run: write approver:'creator' for "ask me" / "I approve"; {users:[\u2026]} takes user ids, never emails, names or {type:'user'}` + (approver === "creator" ? "" : `; here: approver:${JSON.stringify(approver)}`);
+  return {
+    approver,
+    written,
+    message
+  };
+}
+__name(describeApproverSpecRefusal, "describeApproverSpecRefusal");
+__name3(describeApproverSpecRefusal, "describeApproverSpecRefusal");
 var BINDING_ROOTS = [
   "initData",
   "stepResults",
@@ -4468,7 +5497,19 @@ function validateApproverBlock(node, opts = {
     if (!r.success) {
       const users = spec?.users;
       if (Array.isArray(users) && users.length > APPROVER_SPEC_MAX_USERS) push("cap-exceeded", path, `at most ${APPROVER_SPEC_MAX_USERS} users`);
-      else push("approver-invalid", path, r.error.issues[0]?.message ?? "invalid approver");
+      else {
+        const refusal = describeApproverSpecRefusal(spec);
+        issues.push({
+          code: "approver-invalid",
+          path,
+          severity: "error",
+          message: refusal.message,
+          repair: {
+            approver: refusal.approver,
+            written: refusal.written
+          }
+        });
+      }
       return;
     }
     const s = r.data;
@@ -4707,8 +5748,8 @@ __name(armEntry, "armEntry");
 __name3(armEntry, "armEntry");
 function ofEntry(e) {
   if (!e || typeof e !== "object") return ZERO;
-  const n = e;
-  switch (n.type) {
+  const n2 = e;
+  switch (n2.type) {
     case "agent":
       return {
         steps: {
@@ -4741,17 +5782,17 @@ function ofEntry(e) {
         agentCalls: 0
       };
     case "parallel": {
-      const arms = Array.isArray(n.steps) ? n.steps : [];
+      const arms = Array.isArray(n2.steps) ? n2.steps : [];
       return arms.map(armEntry).map(ofEntry).reduce(add, ZERO);
     }
     case "conditional": {
-      const arms = (Array.isArray(n.steps) ? n.steps : []).map(armEntry).map(ofEntry);
+      const arms = (Array.isArray(n2.steps) ? n2.steps : []).map(armEntry).map(ofEntry);
       if (arms.length === 0) return ZERO;
-      const hasOtherwise = n.otherwise !== void 0;
+      const hasOtherwise = n2.otherwise !== void 0;
       const minArm = arms.reduce((a, b) => b.credits.min < a.credits.min ? b : a);
       const maxArm = arms.reduce((a, b) => b.credits.max > a.credits.max ? b : a);
       const summed = arms.reduce(add, ZERO);
-      const max = n.exclusive === true ? maxArm : summed;
+      const max = n2.exclusive === true ? maxArm : summed;
       const min = hasOtherwise ? minArm : {
         ...ZERO
       };
@@ -4768,17 +5809,14 @@ function ofEntry(e) {
       };
     }
     case "foreach": {
-      const body = ofEntry(armEntry(n.step));
-      const opts = n.options ?? {};
-      const cap = typeof opts.maxItems === "number" && opts.maxItems > 0 ? opts.maxItems : 1;
+      const body = ofEntry(armEntry(n2.step));
+      const opts = n2.opts ?? {};
+      const cap = typeof opts.maxItems === "number" && opts.maxItems > 0 ? opts.maxItems : WORKFLOW_FOREACH_DEFAULT_MAX_ITEMS;
       return scale(body, 0, cap);
     }
-    case "loop":
-    case "dowhile":
-    case "dountil": {
-      const body = ofEntry(armEntry(n.step));
-      const opts = n.options ?? {};
-      const cap = typeof opts.maxIterations === "number" && opts.maxIterations > 0 ? opts.maxIterations : 1;
+    case "loop": {
+      const body = ofEntry(armEntry(n2.step));
+      const cap = typeof n2.maxIterations === "number" && n2.maxIterations > 0 ? n2.maxIterations : WORKFLOW_LOOP_DEFAULT_MAX_ITERATIONS;
       return scale(body, 1, cap);
     }
     default:
@@ -4813,6 +5851,67 @@ function estimateGraph(envelopeOrGraph) {
 }
 __name(estimateGraph, "estimateGraph");
 __name3(estimateGraph, "estimateGraph");
+var isRecord2 = /* @__PURE__ */ __name3((v) => !!v && typeof v === "object" && !Array.isArray(v), "isRecord");
+function* singleStepsOf(entry) {
+  if (!isRecord2(entry)) return;
+  switch (entry.type) {
+    case "step":
+    case "agent":
+    case "tool":
+      yield entry;
+      return;
+    case "workflow":
+      yield entry;
+      if (Array.isArray(entry.graph)) yield* singleStepsOf(entry.graph[1]);
+      return;
+    case "parallel":
+    case "conditional":
+      if (Array.isArray(entry.steps)) for (const arm of entry.steps) yield* singleStepsOf(arm);
+      yield* singleStepsOf(entry.otherwise);
+      return;
+    case "foreach":
+    case "loop":
+      yield* singleStepsOf(entry.step);
+      return;
+    default:
+      return;
+  }
+}
+__name(singleStepsOf, "singleStepsOf");
+__name3(singleStepsOf, "singleStepsOf");
+function entriesOf(graph) {
+  const definition = isRecord2(graph) ? graph.definition : void 0;
+  const entries = isRecord2(definition) ? definition.graph : void 0;
+  return Array.isArray(entries) ? entries : [];
+}
+__name(entriesOf, "entriesOf");
+__name3(entriesOf, "entriesOf");
+function inheritTargets(graphs) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const graph of graphs) {
+    for (const entry of entriesOf(graph)) {
+      for (const node of singleStepsOf(entry)) {
+        if (node.type === "workflow" && node.workspace === "inherit" && typeof node.workflowId === "string" && node.workflowId.length > 0) {
+          targets.add(node.workflowId);
+        }
+      }
+    }
+  }
+  return targets;
+}
+__name(inheritTargets, "inheritTargets");
+__name3(inheritTargets, "inheritTargets");
+function needsInheritedWorkspace(graph) {
+  if (!isRecord2(graph) || graph.workspace !== void 0) return false;
+  for (const entry of entriesOf(graph)) {
+    for (const node of singleStepsOf(entry)) {
+      if (node.workspace !== void 0 && node.workspace !== "inherit") return true;
+    }
+  }
+  return false;
+}
+__name(needsInheritedWorkspace, "needsInheritedWorkspace");
+__name3(needsInheritedWorkspace, "needsInheritedWorkspace");
 
 // src/types/workflow.ts
 function createStep(s) {
@@ -4922,7 +6021,7 @@ var assertPredicate = /* @__PURE__ */ __name((p, where) => {
 }, "assertPredicate");
 var assertRetry = /* @__PURE__ */ __name((r, id) => {
   if (!r) return;
-  if (r.backoff !== void 0 && r.backoff !== "fixed" && r.backoff !== "exponential") throw new LuaWorkflowBuildError("backoff-invalid", `"${id}": retry.backoff must be 'fixed' | 'exponential'`);
+  if (r.backoff !== void 0 && !WORKFLOW_RETRY_BACKOFFS.includes(r.backoff)) throw new LuaWorkflowBuildError("backoff-invalid", `"${id}": retry.backoff must be ${WORKFLOW_RETRY_BACKOFFS.map((b) => `'${b}'`).join(" | ")}`);
   if (r.maxBackoffSeconds !== void 0) {
     if (r.backoff !== "exponential") throw new LuaWorkflowBuildError("backoff-invalid", `"${id}": retry.maxBackoffSeconds is only meaningful with backoff:'exponential'`);
     if (r.maxBackoffSeconds <= 0 || r.backoffSeconds !== void 0 && r.maxBackoffSeconds < r.backoffSeconds) throw new LuaWorkflowBuildError("backoff-invalid", `"${id}": retry.maxBackoffSeconds must be > 0 and \u2265 backoffSeconds`);
@@ -5008,7 +6107,7 @@ var LuaWorkflow = class {
   getEnvTemplateKeys() {
     return this.built.envTemplateKeys;
   }
-  /** `.workflow(id, ref)` targets by name — `ManifestWorkflow.workflowRefs`. */
+  /** `.workflow(id, ref)` targets by name — `ManifestWorkflow.workflowRefs`; `workspace:'inherit'` marks the inherit children the compiler defers `workspace-not-declared` for. */
   getNestedWorkflowRefs() {
     return this.built.nestedRefs;
   }
@@ -5038,6 +6137,7 @@ var LuaWorkflow = class {
     };
     if (cfg.concurrencyPolicy !== void 0) envelope.concurrencyPolicy = cfg.concurrencyPolicy;
     if (cfg.workspace !== void 0) envelope.workspace = cfg.workspace;
+    if (cfg.connections !== void 0) envelope.connections = cfg.connections;
     return withDefaultsFilled(envelope);
   }
 };
@@ -5069,16 +6169,16 @@ function stepNodeOf(s) {
 }
 __name(stepNodeOf, "stepNodeOf");
 function materializeEntry(entry, steps) {
-  const single = /* @__PURE__ */ __name((n) => {
-    if (n.type === "step" && steps[n.step.id]) return stepNodeOf(steps[n.step.id]);
-    if (n.type === "workflow" && n.workflowId === WORKFLOW_ARM_SUBRUN_ID && n.graph) return {
-      ...n,
+  const single = /* @__PURE__ */ __name((n2) => {
+    if (n2.type === "step" && steps[n2.step.id]) return stepNodeOf(steps[n2.step.id]);
+    if (n2.type === "workflow" && n2.workflowId === WORKFLOW_ARM_SUBRUN_ID && n2.graph) return {
+      ...n2,
       graph: [
-        n.graph[0],
-        single(n.graph[1])
+        n2.graph[0],
+        single(n2.graph[1])
       ]
     };
-    return n;
+    return n2;
   }, "single");
   switch (entry.type) {
     case "step":
@@ -5109,8 +6209,14 @@ function materializeEntry(entry, steps) {
   }
 }
 __name(materializeEntry, "materializeEntry");
+var isHitlEntry = /* @__PURE__ */ __name((n2) => isWorkflowHitlEntryType(n2?.type), "isHitlEntry");
 function graphHasHitl(graph, steps) {
-  if (graph.some((e) => e.type === "approval" || e.type === "waitForSignal")) return true;
+  for (const e of graph) {
+    if (isHitlEntry(e)) return true;
+    if (e.type === "parallel" && e.steps.some(isHitlEntry)) return true;
+    if (e.type === "conditional" && (e.steps.some(isHitlEntry) || isHitlEntry(e.otherwise))) return true;
+    if ((e.type === "foreach" || e.type === "loop") && isHitlEntry(e.step)) return true;
+  }
   return Object.values(steps).some((s) => s.suspendSchema !== void 0);
 }
 __name(graphHasHitl, "graphHasHitl");
@@ -5143,7 +6249,6 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     if (this.steps[s.id] && this.steps[s.id] !== s) throw new LuaWorkflowBuildError("duplicate-step-id", `step id "${s.id}" is declared twice`);
     const tier = s.tier ?? (s.workspace ? "job" : void 0);
     if (s.workspace && s.tier !== void 0 && s.tier !== "job") throw new LuaWorkflowBuildError("workspace-requires-job-tier", `"${s.id}": a step mounting a workspace must be tier:'job'`);
-    if (s.workspace && !this.config.workspace) throw new LuaWorkflowBuildError("workspace-not-declared", `"${s.id}" mounts a workspace but createWorkflow declares none`);
     if (s.jobTools && tier !== "job") throw new LuaWorkflowBuildError("cap-exceeded", `"${s.id}": jobTools require tier:'job' (job-tools-require-job-tier)`);
     assertTimeout({
       id: s.id,
@@ -5166,7 +6271,6 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
       const [mapping, target] = arm;
       if (target === void 0 || arm.length < 2) throw new LuaWorkflowBuildError("container-arm-empty", `${where}: a bare mapping arm has nothing to run`);
       if (!mapping || typeof mapping !== "object" || Array.isArray(mapping)) throw new LuaWorkflowBuildError("mapping-placement", `${where}: the arm head must be a map config object`);
-      if (mapping.type === "approval" || target.type === "approval") throw new LuaWorkflowBuildError("approval-inside-container", `${where}: approval / waitForSignal are top-level only in v1`);
       assertNoClosure(mapping, `${where} arm map`);
       this.recordEnvRefs(mapping);
       const inner = this.armRef(target, where);
@@ -5184,8 +6288,9 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     if (typeof arm === "string") return {
       ref: arm
     };
-    if (arm && typeof arm === "object" && arm.type === "approval") {
-      throw new LuaWorkflowBuildError("approval-inside-container", `${where}: approval / waitForSignal are top-level only in v1`);
+    if (arm && typeof arm === "object" && isHitlEntry(arm)) {
+      const id = arm.id;
+      throw new LuaWorkflowBuildError("invalid-step", `${where}: an approval / waitForSignal arm is placed by id \u2014 declare it with .approval(${JSON.stringify(id ?? "id")}, \u2026) / .waitForSignal(\u2026) and pass the id string`);
     }
     return {
       node: this.registerStep(arm, where)
@@ -5384,12 +6489,15 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     }
     const tier = opts.tier ?? (opts.workspace ? "job" : void 0);
     if (opts.workspace && opts.tier !== void 0 && opts.tier !== "job") throw new LuaWorkflowBuildError("workspace-requires-job-tier", `"${id}": a step mounting a workspace must be tier:'job'`);
-    if (opts.workspace && !this.config.workspace) throw new LuaWorkflowBuildError("workspace-not-declared", `"${id}" mounts a workspace but createWorkflow declares none`);
     if (opts.harness !== void 0 && tier !== "job") throw new LuaWorkflowBuildError("harness-requires-job-tier", `"${id}": harness is only legal on a tier:'job' agent step`);
     if (opts.toolScope?.jobTools && tier !== "job") throw new LuaWorkflowBuildError("cap-exceeded", `"${id}": toolScope.jobTools require tier:'job' (job-tools-require-job-tier)`);
-    if (opts.maxTurns !== void 0) {
-      if (tier !== "job") throw new LuaWorkflowBuildError("max-turns-requires-job-tier", `"${id}": maxTurns is only legal on a tier:'job' agent step`);
-      if (!Number.isInteger(opts.maxTurns) || opts.maxTurns < 1 || opts.maxTurns > 500) throw new LuaWorkflowBuildError("max-turns-invalid", `"${id}": maxTurns must be an integer 1..500`);
+    for (const m of WORKFLOW_JOB_RANGE_MEMBERS) {
+      if (opts[m] === void 0) continue;
+      if (tier !== "job") throw new LuaWorkflowBuildError("max-turns-requires-job-tier", `"${id}": ${m} is only legal on a tier:'job' agent step`);
+      if (!isWithinWorkflowJobRange(m, opts[m])) {
+        const { min, max } = WORKFLOW_JOB_RANGES[m];
+        throw new LuaWorkflowBuildError("max-turns-invalid", `"${id}": ${m} must be an integer ${min}..${max}`);
+      }
     }
     assertTimeout({
       id,
@@ -5417,7 +6525,9 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
       workspace: opts.workspace,
       jobResources: opts.jobResources,
       harness: opts.harness,
-      maxTurns: opts.maxTurns
+      maxTurns: opts.maxTurns,
+      maxMessages: opts.maxMessages,
+      maxInputTokens: opts.maxInputTokens
     });
     return this.push({
       kind: "declare",
@@ -5539,8 +6649,8 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
       itemTimeout: opts.itemTimeout
     });
     return this.push({
-      kind: "entry",
-      entry: node
+      kind: "declare",
+      node
     });
   }
   waitForSignal(id, opts) {
@@ -5558,12 +6668,13 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
       acceptedSources: opts.acceptedSources
     });
     return this.push({
-      kind: "entry",
-      entry: node
+      kind: "declare",
+      node
     });
   }
   workflow(id, ref, input, opts) {
     this.assertId(id, "workflow()");
+    assertRetry(opts?.retry, id);
     const name = typeof ref === "string" ? ref : ref instanceof LuaWorkflow ? ref.getName() : void 0;
     if (!name) throw new LuaWorkflowBuildError("invalid-envelope", `workflow("${id}") needs a LuaWorkflow or a workflow name`);
     if (opts?.workspace === "inherit") {
@@ -5572,7 +6683,11 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     }
     assertNoClosure(input, `workflow("${id}").input`);
     this.recordEnvRefs(input);
-    this.nestedRefs.push({
+    this.nestedRefs.push(opts?.workspace === "inherit" ? {
+      id,
+      name,
+      workspace: "inherit"
+    } : {
       id,
       name
     });
@@ -5581,11 +6696,12 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
       id,
       workflowId: name,
       input,
-      workspace: opts?.workspace
+      workspace: opts?.workspace,
+      retry: opts?.retry
     });
     return this.push({
-      kind: "entry",
-      entry: node
+      kind: "declare",
+      node
     });
   }
   commit() {
@@ -5595,7 +6711,7 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     const { graph, issues } = resolvePlacements(this.calls);
     const fatal = issues[0];
     if (fatal) {
-      const hint = fatal.code === "unknown-step-ref" ? "a string StepRef must name an entry declared by agentStep/specialistStep/toolStep/map(\u2026, { id }) somewhere in the chain \u2014 before OR after the reference" : void 0;
+      const hint = fatal.code === "unknown-step-ref" ? "a string StepRef must name an entry declared by agentStep/specialistStep/toolStep/map(\u2026, { id })/workflow(\u2026)/approval(\u2026)/waitForSignal(\u2026) somewhere in the chain \u2014 before OR after the reference" : void 0;
       throw new LuaWorkflowBuildError(fatal.code, fatal.message, hint);
     }
     if (graph.length === 0) throw new LuaWorkflowBuildError("empty-graph", `workflow "${this.config.name}" has no entries`);
@@ -5608,7 +6724,8 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     if (graphHasHitl(graph, this.steps) && this.config.budget?.maxDurationSeconds === void 0) {
       this.warnings.push({
         code: "hitl-duration-defaulted",
-        message: `budget.maxDurationSeconds defaulted to ${WORKFLOW_HITL_MAX_DURATION_SECONDS} s (30 d) because the graph contains an approval / waitForSignal / suspend-capable step \u2014 set it explicitly to silence`
+        // LUA-668: names the workflow — two HITL workflows in one project printed two identical lines that read as a duplicate.
+        message: `workflow "${this.config.name}": budget.maxDurationSeconds defaulted to ${WORKFLOW_HITL_MAX_DURATION_SECONDS} s (30 d) because the graph contains an approval / waitForSignal / suspend-capable step \u2014 set it explicitly to silence`
       });
     }
     this.checkScheduleInput();
@@ -5671,8 +6788,8 @@ function createWorkflow(cfg) {
     if (v.roles.length > 20 || (v.users?.length ?? 0) > 50) throw new LuaWorkflowBuildError("cap-exceeded", "outputVisibility allows \u2264 20 roles and \u2264 50 users");
   }
   if (cfg.backfillOnEnable?.maxOccurrences !== void 0) {
-    const n = cfg.backfillOnEnable.maxOccurrences;
-    if (!Number.isInteger(n) || n < 1 || n > 200) throw new LuaWorkflowBuildError("invalid-envelope", "backfillOnEnable.maxOccurrences must be an integer in 1..200 (backfill-max-occurrences-out-of-range; the org maxBatchItems twin is checked at publish/R56)");
+    const n2 = cfg.backfillOnEnable.maxOccurrences;
+    if (!Number.isInteger(n2) || n2 < 1 || n2 > 200) throw new LuaWorkflowBuildError("invalid-envelope", "backfillOnEnable.maxOccurrences must be an integer in 1..200 (backfill-max-occurrences-out-of-range; the org maxBatchItems twin is checked at publish/R56)");
   }
   const keys = /* @__PURE__ */ new Set();
   envRefKeys(cfg.schedule, keys);