lua-cli 3.32.1 → 3.32.3

package/dist/api-exports.js

@@ -90,9 +90,9 @@ function mcpActionTokens(action) {
   return action.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
 }
 function isReviewableMcpDraftTool(tool) {
-  const sep = tool.indexOf("_");
-  if (sep <= 0 || sep >= tool.length - 1) return false;
-  const action = tool.slice(sep + 1);
+  const sep4 = tool.indexOf("_");
+  if (sep4 <= 0 || sep4 >= tool.length - 1) return false;
+  const action = tool.slice(sep4 + 1);
   const tokens = mcpActionTokens(action);
   if (!tokens.includes("draft") && !tokens.includes("drafts")) return false;
   return !MCP_TOOL_READ_VERB_RE.test(action);
@@ -356,6 +356,9 @@ function isDesktopFileSessionId(value3) {
 function isImplicitModelSelectionSource(source) {
   return source !== void 0 && IMPLICIT_MODEL_SELECTION_SOURCES.includes(source);
 }
+function isPlatformFallbackModelSource(source) {
+  return source === PLATFORM_FALLBACK_MODEL_SOURCE;
+}
 function resolveRequireToolApproval(rules) {
   const raw = rules?.requireToolApproval ?? rules?.requireApproval;
   if (raw === void 0 || raw === null) return void 0;
@@ -395,14 +398,14 @@ async function readCoreDrainingRetryDelayMs(response) {
   return coreDrainingRetryDelayMs(response.headers.get("Retry-After"));
 }
 function waitForCoreDrain(delayMs, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     if (signal?.aborted) {
       reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve();
+      resolve3();
     }, delayMs);
     function onAbort() {
       clearTimeout(timer);
@@ -535,6 +538,75 @@ function isKnownProfile(profiles, profileId) {
 function hasCapability(profiles, profileId, required) {
   return capabilitiesFor(profiles, profileId).includes(required);
 }
+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);
+  }
+}
+function assertNever(id) {
+  throw new Error(`workflowJobId: unknown wake kind ${JSON.stringify(id)}`);
+}
+function agentStepJobId(msg) {
+  return `${msg.runId}_${msg.stepId}_${msg.attempt}_x${msg.executionId}`;
+}
+function heavyStepJobId(msg) {
+  return `${msg.runId}_${msg.stepId}_${msg.attempt}_x${msg.executionId}`;
+}
+function jobSpawnJobId(msg) {
+  return `${msg.runId}_${msg.stepId}_${msg.attempt}_s${msg.segment}_${msg.executionId}`;
+}
+function exportAutoJobId(exportId, suffix) {
+  return suffix ? `${exportId}:${suffix}` : exportId;
+}
 function isSystemRun(identity) {
   return identity.userId.startsWith(SYSTEM_USER_PREFIX);
 }
@@ -581,6 +653,75 @@ function scheduledTimeKey(scheduledTime) {
 function scheduledWorkflowRunIdForTime(jobId, scheduledTime) {
   return scheduledWorkflowRunId(jobId, scheduledTime);
 }
+function workflowRetryMaxAttemptsMessage(got) {
+  const tail = got === void 0 ? "" : ` (got ${JSON.stringify(got)})`;
+  return `\`retry.maxAttempts\` must be an integer ${WORKFLOW_RETRY_MIN_ATTEMPTS}..${WORKFLOW_RETRY_MAX_ATTEMPTS}${tail}`;
+}
+function isWithinWorkflowRetryAttempts(value3) {
+  return typeof value3 === "number" && Number.isInteger(value3) && value3 >= WORKFLOW_RETRY_MIN_ATTEMPTS && value3 <= WORKFLOW_RETRY_MAX_ATTEMPTS;
+}
+function workflowRetryUnknownMembersMessage(keys) {
+  const named = keys.map((k) => {
+    const engine = WORKFLOW_RETRY_ENGINE_KEYS.includes(k);
+    return `\`${k}\`${engine ? " (engine-owned \u2014 stamped by resetAttempts, never authored)" : ""}`;
+  });
+  return `\`retry\` has no member ${named.join(", ")}; members: ${WORKFLOW_RETRY_POLICY_KEYS.join(", ")}`;
+}
+function unknownWorkflowRetryMembers(retry) {
+  if (!retry || typeof retry !== "object" || Array.isArray(retry)) return [];
+  return Object.keys(retry).filter((k) => !WORKFLOW_RETRY_POLICY_KEYS.includes(k));
+}
+function authoredRetryPolicy(retry) {
+  if (!retry || typeof retry !== "object" || Array.isArray(retry)) return void 0;
+  const src = retry;
+  const out = {};
+  for (const k of WORKFLOW_RETRY_POLICY_KEYS) if (src[k] !== void 0) out[k] = src[k];
+  return Object.keys(out).length ? out : void 0;
+}
+function retryBudgetBaseAttempt(row) {
+  const base = row.retry?.budgetBaseAttempt;
+  return typeof base === "number" && Number.isSafeInteger(base) && base > 0 ? base : 0;
+}
+function retryBudgetAttempt(row) {
+  return Math.max(0, row.attempt - retryBudgetBaseAttempt(row));
+}
+function retryBudgetMaxAttempts(row) {
+  const max = row.retry?.maxAttempts;
+  return typeof max === "number" && Number.isFinite(max) && max >= 1 ? max : 1;
+}
+function retryBudgetRemaining(row) {
+  return retryBudgetAttempt(row) < retryBudgetMaxAttempts(row);
+}
+function retriesRemaining(row) {
+  return Math.max(0, retryBudgetMaxAttempts(row) - retryBudgetAttempt(row));
+}
+function isWithinWorkflowJobRange(member, value3) {
+  const { min, max } = WORKFLOW_JOB_RANGES[member];
+  return typeof value3 === "number" && Number.isInteger(value3) && value3 >= min && value3 <= max;
+}
+function workflowJobRangeMessage(member) {
+  const { min, max } = WORKFLOW_JOB_RANGES[member];
+  return `\`${member}\` must be an integer ${min}..${max}`;
+}
+function isWorkflowSingleStepType(type) {
+  return typeof type === "string" && WORKFLOW_SINGLE_STEP_TYPES.includes(type);
+}
+function isWorkflowHitlEntryType(type) {
+  return typeof type === "string" && WORKFLOW_HITL_ENTRY_TYPES.includes(type);
+}
+function isWorkflowArmEntryType(type) {
+  return typeof type === "string" && WORKFLOW_ARM_ENTRY_TYPES.includes(type);
+}
+function workflowContainerRunsHitlArm(container) {
+  return typeof container === "string" && WORKFLOW_HITL_ARM_CONTAINERS.includes(container);
+}
+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\``;
+}
+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\``;
+}
 function groupCount(re) {
   let n2 = GROUP_COUNT.get(re);
   if (n2 === void 0) {
@@ -589,6 +730,9 @@ function groupCount(re) {
   }
   return n2;
 }
+function isWorkflowSecretKey(key) {
+  return WORKFLOW_SECRET_KEY_RE.test(key);
+}
 function applyPatterns(text, patterns) {
   let out = text;
   for (const { re, suffix } of patterns) {
@@ -611,8 +755,15 @@ function scrubSecretText(text) {
   if (typeof text !== "string" || text.length < 4) return text;
   return applyPatterns(applyPatterns(text, SECRET_LITERAL_PATTERNS), SECRET_PAIR_PATTERNS);
 }
+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`;
+}
 function scrubSecretLines(lines) {
-  return lines.map((l) => typeof l === "string" ? scrubSecretText(l) : l);
+  return lines.map((l) => typeof l === "string" ? scrubSecretText(boundScrubInput(l)) : l);
 }
 function messageText(value3) {
   if (typeof value3 === "string") return value3;
@@ -629,11 +780,14 @@ function messageText(value3) {
   return value3 === void 0 || value3 === null ? "" : String(value3);
 }
 function scrubProviderMessage(raw, max = PROVIDER_MESSAGE_MAX_CHARS) {
-  const text = messageText(raw).replace(/\s+/g, " ").trim();
+  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;
 }
+function scrubStepErrorMessage(raw) {
+  return scrubProviderMessage(raw, ERROR_MESSAGE_MAX_CHARS);
+}
 function isWorkflowAuditEvent(action) {
   return typeof action === "string" && WORKFLOW_AUDIT_EVENTS.includes(action);
 }
@@ -728,7 +882,66 @@ ${PREAMBLE}
 
 ${items.join("\n\n")}`;
 }
-var __defProp2, __name2, CHANNEL_SEND_CHANNELS, REVIEWABLE_ACTION_EXECUTE_TOOL_ALLOWLIST, REVIEWABLE_MCP_SEND_TOOL_SUFFIX, MCP_TOOL_READ_VERB_RE, MCP_DRAFT_CREATE_VERBS, NON_INTERACTIVE_CHANNELS, RICH_PARTS_MESSAGE_ID_PREFIX, SCREENSHOT_MESSAGE_ID_PREFIX, BROWSER_COMMANDS, BROWSER_COMMAND_NAMES, DESKTOP_FILE_COMMANDS, DESKTOP_FILE_COMMAND_SET, REASONING_EFFORT_VALUES, IMPLICIT_MODEL_SELECTION_SOURCES, AGENT_NAME_TOKEN, DEFAULT_PERSONA_GUIDE, PERSONAL_SPACE_STARTING_PERSONA, CORE_DRAINING_CODE, CORE_DRAINING_DEFAULT_RETRY_MS, CORE_DRAINING_MAX_RETRY_MS, VoiceNameSchema, PluginProviderSchema, RealtimeProviderSchema, PluginClassSchema, ModelDescriptorSchema, InferenceModelSchema, PluginModelSchema, RealtimeModelSchema, LuaVoiceModelSchema, TurnDetectionSchema, InterruptionSchema, BuiltinAudioClipSchema, AudioConfigSchema, BackgroundAudioEntrySchema, BackgroundAudioSchema, LuaVoiceConfigInnerSchema, LuaVoiceConfigSchema, LuaVoiceRefSchema, LUA_JOB_DEFAULT_TIMEOUT_SECONDS, LUA_JOB_MIN_TIMEOUT_SECONDS, LUA_JOB_MAX_TIMEOUT_SECONDS, TEMPLATE_TRIGGER_URL_ENV_PREFIX, SUBJECT_TYPES, SubjectTypeSchema, CREDENTIAL_TYPES, CredentialTypeSchema, DEVICE_OPERATIONS, DeviceOperationSchema, DEVICE_SCOPE_BY_OPERATION, DeviceBindingSchema, IdSchema, PrincipalDescriptorSchema, ActorDescriptorSchema, PrincipalOwnerSchema, CredentialLifecycleSchema, GeneralCredentialDescriptorSchema, DeviceCredentialDescriptorSchema, GeneralPrincipalContextSchema, DeviceCredentialPrincipalContextSchema, RawPrincipalContextSchema, PrincipalContextSchema, DeviceCredentialClaimSchema, LUA_CLIENT_HEADER, LUA_CLIENT_APPS, SEMVER_PATTERN, WEB_RELEASE_PATTERN, CLIENT_HEADER_PATTERN, AUTHZ_PROJECTION_VERSION, ProjectedScopeSchema, DisplayRoleSchema, AuthorizationPrincipalSchema, CredentialContextSchema, ProjectionAnomalySchema, ProjectedOrgSchema, ProjectedResourceSchema, CapabilityProfilesSchema, RoleCatalogSchema, EffectiveAuthorizationSchema, ResourcePageSchema, SYSTEM_USER_PREFIX, WORKFLOW_RUN_IN_FLIGHT, WORKFLOW_RUN_IDLE, WORKFLOW_RUN_TERMINAL, WORKFLOW_RUN_STATUSES, WORKFLOW_STEP_STATUSES, WORKFLOW_STEP_IN_FLIGHT, ARCHIVE_WINDOW_MARGIN_DAYS, WORKFLOW_ORG_PURGING_TTL_S, WORKFLOW_ORG_PURGE_FORCE_AFTER_MS, IDEMPOTENCY_HOLDING_STATUSES, WORKFLOW_SCHEDULED_RUN_ID_PREFIX, CLOUD_TASK_RUN_ID_PREFIX, WORKFLOW_OPERATION_ID_PREFIX, WORKFLOW_CONNECTION_KEY_RE, WORKFLOW_SIGNAL_PAYLOAD_MAX_BYTES, REDACTED_PLACEHOLDER, PROVIDER_MESSAGE_MAX_CHARS, SECRET_LITERAL_PATTERNS, SECRET_NAME, SECRET_PAIR_PATTERNS, GROUP_COUNT, WORKFLOW_AUDIT_EVENTS, WORKFLOW_AUDIT_METADATA_MAX_BYTES, INDENT, WRAP_WIDTH, NOUNS, GET_TOOL_NAMES, PREAMBLE;
+function workflowApprovalDecisionOf(resumeData) {
+  if (resumeData.timedOut === true) return "timed_out";
+  return resumeData.approved === true ? "approved" : "denied";
+}
+function workflowApprovalOutput(resumeData) {
+  const decision = typeof resumeData.decision === "string" ? resumeData.decision : workflowApprovalDecisionOf(resumeData);
+  const note = typeof resumeData.note === "string" && resumeData.note.trim() !== "" ? resumeData.note : void 0;
+  const text = typeof resumeData.text === "string" ? resumeData.text : note ?? decision;
+  return {
+    ...resumeData,
+    decision,
+    text
+  };
+}
+function isWorkflowApprovalOutput(value3) {
+  if (typeof value3 !== "object" || value3 === null || Array.isArray(value3)) return false;
+  const v = value3;
+  return typeof v.approved === "boolean" && WORKFLOW_APPROVAL_OUTPUT_DECISIONS.includes(v.decision) && typeof v.text === "string";
+}
+function extractSingleJsonValue(text) {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed) return {
+    reason: "reply is empty"
+  };
+  const fenced = [
+    ...trimmed.matchAll(JSON_FENCE_RE)
+  ];
+  if (fenced.length > 1) return {
+    reason: "reply carries more than one fenced block"
+  };
+  const candidate = fenced.length === 1 ? fenced[0][1].trim() : trimmed;
+  try {
+    return {
+      value: JSON.parse(candidate)
+    };
+  } catch {
+    if (fenced.length === 1) return {
+      reason: "fenced block is not valid JSON"
+    };
+  }
+  const opens = [
+    trimmed.indexOf("{"),
+    trimmed.indexOf("[")
+  ].filter((i) => i !== -1);
+  const start = opens.length ? Math.min(...opens) : -1;
+  const end = Math.max(trimmed.lastIndexOf("}"), trimmed.lastIndexOf("]"));
+  if (start === -1 || end <= start) return {
+    reason: "reply is not JSON"
+  };
+  try {
+    return {
+      value: JSON.parse(trimmed.slice(start, end + 1))
+    };
+  } catch {
+    return {
+      reason: "reply does not contain a single JSON value"
+    };
+  }
+}
+var __defProp2, __name2, CHANNEL_SEND_CHANNELS, REVIEWABLE_ACTION_EXECUTE_TOOL_ALLOWLIST, REVIEWABLE_MCP_SEND_TOOL_SUFFIX, MCP_TOOL_READ_VERB_RE, MCP_DRAFT_CREATE_VERBS, NON_INTERACTIVE_CHANNELS, RICH_PARTS_MESSAGE_ID_PREFIX, SCREENSHOT_MESSAGE_ID_PREFIX, BROWSER_COMMANDS, BROWSER_COMMAND_NAMES, DESKTOP_FILE_COMMANDS, DESKTOP_FILE_COMMAND_SET, REASONING_EFFORT_VALUES, IMPLICIT_MODEL_SELECTION_SOURCES, PLATFORM_FALLBACK_MODEL_SOURCE, AGENT_NAME_TOKEN, DEFAULT_PERSONA_GUIDE, PERSONAL_SPACE_STARTING_PERSONA, CORE_DRAINING_CODE, CORE_DRAINING_DEFAULT_RETRY_MS, CORE_DRAINING_MAX_RETRY_MS, VoiceNameSchema, PluginProviderSchema, RealtimeProviderSchema, PluginClassSchema, ModelDescriptorSchema, InferenceModelSchema, PluginModelSchema, RealtimeModelSchema, LuaVoiceModelSchema, TurnDetectionSchema, InterruptionSchema, BuiltinAudioClipSchema, AudioConfigSchema, BackgroundAudioEntrySchema, BackgroundAudioSchema, LuaVoiceConfigInnerSchema, LuaVoiceConfigSchema, LuaVoiceRefSchema, LUA_JOB_DEFAULT_TIMEOUT_SECONDS, LUA_JOB_MIN_TIMEOUT_SECONDS, LUA_JOB_MAX_TIMEOUT_SECONDS, TEMPLATE_TRIGGER_URL_ENV_PREFIX, SUBJECT_TYPES, SubjectTypeSchema, CREDENTIAL_TYPES, CredentialTypeSchema, DEVICE_OPERATIONS, DeviceOperationSchema, DEVICE_SCOPE_BY_OPERATION, DeviceBindingSchema, IdSchema, PrincipalDescriptorSchema, ActorDescriptorSchema, PrincipalOwnerSchema, CredentialLifecycleSchema, GeneralCredentialDescriptorSchema, DeviceCredentialDescriptorSchema, GeneralPrincipalContextSchema, DeviceCredentialPrincipalContextSchema, RawPrincipalContextSchema, PrincipalContextSchema, DeviceCredentialClaimSchema, LUA_CLIENT_HEADER, LUA_CLIENT_APPS, SEMVER_PATTERN, WEB_RELEASE_PATTERN, CLIENT_HEADER_PATTERN, AUTHZ_PROJECTION_VERSION, ProjectedScopeSchema, DisplayRoleSchema, AuthorizationPrincipalSchema, CredentialContextSchema, ProjectionAnomalySchema, ProjectedOrgSchema, ProjectedResourceSchema, CapabilityProfilesSchema, RoleCatalogSchema, EffectiveAuthorizationSchema, ResourcePageSchema, SYSTEM_USER_PREFIX, WORKFLOW_RUN_IN_FLIGHT, WORKFLOW_RUN_IDLE, WORKFLOW_RUN_TERMINAL, WORKFLOW_RUN_STATUSES, WORKFLOW_STEP_STATUSES, WORKFLOW_STEP_IN_FLIGHT, ARCHIVE_WINDOW_MARGIN_DAYS, WORKFLOW_ORG_PURGING_TTL_S, WORKFLOW_ORG_PURGE_FORCE_AFTER_MS, IDEMPOTENCY_HOLDING_STATUSES, WORKFLOW_SCHEDULED_RUN_ID_PREFIX, CLOUD_TASK_RUN_ID_PREFIX, WORKFLOW_OPERATION_ID_PREFIX, WORKFLOW_CONNECTION_KEY_RE, WORKFLOW_SIGNAL_PAYLOAD_MAX_BYTES, WORKFLOW_RESOLVE_OUTPUT_MAX_BYTES, WORKFLOW_RETRY_BACKOFFS, WORKFLOW_RETRY_MIN_ATTEMPTS, WORKFLOW_RETRY_POLICY_KEYS, WORKFLOW_RETRY_MAX_ATTEMPTS, WORKFLOW_RETRY_ENGINE_KEYS, WORKFLOW_JOB_RESOURCES, WORKFLOW_SIDE_EFFECTS, WORKFLOW_JOB_RANGES, WORKFLOW_JOB_RANGE_MEMBERS, WORKFLOW_SINGLE_STEP_TYPES, WORKFLOW_HITL_ENTRY_TYPES, WORKFLOW_ARM_ENTRY_TYPES, WORKFLOW_HITL_ARM_CONTAINERS, WORKFLOW_GRAPH_ENTRY_STEP_KINDS, WORKFLOW_ARM_ENTRY_STEP_KINDS, WORKFLOW_BUDGET_MAX_DURATION_SECONDS, REDACTED_PLACEHOLDER, PROVIDER_MESSAGE_MAX_CHARS, ERROR_MESSAGE_MAX_CHARS, SECRET_LITERAL_PATTERNS, SECRET_NAME, SECRET_PAIR_PATTERNS, GROUP_COUNT, WORKFLOW_SECRET_KEY_RE, WORKFLOW_RESERVED_SECRET_KEYS, SCRUB_INPUT_MAX_CHARS, SCRUB_CUT_BACKOFF_CHARS, WORKFLOW_AUDIT_EVENTS, WORKFLOW_AUDIT_METADATA_MAX_BYTES, INDENT, WRAP_WIDTH, NOUNS, GET_TOOL_NAMES, PREAMBLE, WORKFLOW_APPROVAL_OUTPUT_DECISIONS, WORKFLOW_APPROVAL_OUTPUT_SCHEMA, JSON_FENCE_RE;
 var init_dist = __esm({
   "../shared-types/dist/index.mjs"() {
     "use strict";
@@ -1059,6 +1272,9 @@ var init_dist = __esm({
     ];
     __name(isImplicitModelSelectionSource, "isImplicitModelSelectionSource");
     __name2(isImplicitModelSelectionSource, "isImplicitModelSelectionSource");
+    PLATFORM_FALLBACK_MODEL_SOURCE = "platform-fallback";
+    __name(isPlatformFallbackModelSource, "isPlatformFallbackModelSource");
+    __name2(isPlatformFallbackModelSource, "isPlatformFallbackModelSource");
     __name(resolveRequireToolApproval, "resolveRequireToolApproval");
     __name2(resolveRequireToolApproval, "resolveRequireToolApproval");
     AGENT_NAME_TOKEN = "[Your Agent Name]";
@@ -1711,6 +1927,18 @@ This text is who you are for this person. As you learn them, their name, their w
     __name2(isKnownProfile, "isKnownProfile");
     __name(hasCapability, "hasCapability");
     __name2(hasCapability, "hasCapability");
+    __name(workflowJobId, "workflowJobId");
+    __name2(workflowJobId, "workflowJobId");
+    __name(assertNever, "assertNever");
+    __name2(assertNever, "assertNever");
+    __name(agentStepJobId, "agentStepJobId");
+    __name2(agentStepJobId, "agentStepJobId");
+    __name(heavyStepJobId, "heavyStepJobId");
+    __name2(heavyStepJobId, "heavyStepJobId");
+    __name(jobSpawnJobId, "jobSpawnJobId");
+    __name2(jobSpawnJobId, "jobSpawnJobId");
+    __name(exportAutoJobId, "exportAutoJobId");
+    __name2(exportAutoJobId, "exportAutoJobId");
     SYSTEM_USER_PREFIX = "system:";
     __name(isSystemRun, "isSystemRun");
     __name2(isSystemRun, "isSystemRun");
@@ -1796,8 +2024,130 @@ This text is who you are for this person. As you learn them, their name, their w
     __name(scheduledWorkflowRunIdForTime, "scheduledWorkflowRunIdForTime");
     __name2(scheduledWorkflowRunIdForTime, "scheduledWorkflowRunIdForTime");
     WORKFLOW_SIGNAL_PAYLOAD_MAX_BYTES = 64 * 1024;
+    WORKFLOW_RESOLVE_OUTPUT_MAX_BYTES = 256 * 1024;
+    WORKFLOW_RETRY_BACKOFFS = [
+      "fixed",
+      "exponential"
+    ];
+    WORKFLOW_RETRY_MIN_ATTEMPTS = 1;
+    WORKFLOW_RETRY_POLICY_KEYS = [
+      "maxAttempts",
+      "backoffSeconds",
+      "backoff",
+      "maxBackoffSeconds"
+    ];
+    WORKFLOW_RETRY_MAX_ATTEMPTS = 20;
+    __name(workflowRetryMaxAttemptsMessage, "workflowRetryMaxAttemptsMessage");
+    __name2(workflowRetryMaxAttemptsMessage, "workflowRetryMaxAttemptsMessage");
+    __name(isWithinWorkflowRetryAttempts, "isWithinWorkflowRetryAttempts");
+    __name2(isWithinWorkflowRetryAttempts, "isWithinWorkflowRetryAttempts");
+    WORKFLOW_RETRY_ENGINE_KEYS = [
+      "budgetBaseAttempt"
+    ];
+    __name(workflowRetryUnknownMembersMessage, "workflowRetryUnknownMembersMessage");
+    __name2(workflowRetryUnknownMembersMessage, "workflowRetryUnknownMembersMessage");
+    __name(unknownWorkflowRetryMembers, "unknownWorkflowRetryMembers");
+    __name2(unknownWorkflowRetryMembers, "unknownWorkflowRetryMembers");
+    __name(authoredRetryPolicy, "authoredRetryPolicy");
+    __name2(authoredRetryPolicy, "authoredRetryPolicy");
+    __name(retryBudgetBaseAttempt, "retryBudgetBaseAttempt");
+    __name2(retryBudgetBaseAttempt, "retryBudgetBaseAttempt");
+    __name(retryBudgetAttempt, "retryBudgetAttempt");
+    __name2(retryBudgetAttempt, "retryBudgetAttempt");
+    __name(retryBudgetMaxAttempts, "retryBudgetMaxAttempts");
+    __name2(retryBudgetMaxAttempts, "retryBudgetMaxAttempts");
+    __name(retryBudgetRemaining, "retryBudgetRemaining");
+    __name2(retryBudgetRemaining, "retryBudgetRemaining");
+    __name(retriesRemaining, "retriesRemaining");
+    __name2(retriesRemaining, "retriesRemaining");
+    WORKFLOW_JOB_RESOURCES = [
+      "small",
+      "medium",
+      "large"
+    ];
+    WORKFLOW_SIDE_EFFECTS = [
+      "none",
+      "external"
+    ];
+    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
+      })
+    });
+    WORKFLOW_JOB_RANGE_MEMBERS = Object.keys(WORKFLOW_JOB_RANGES);
+    __name(isWithinWorkflowJobRange, "isWithinWorkflowJobRange");
+    __name2(isWithinWorkflowJobRange, "isWithinWorkflowJobRange");
+    __name(workflowJobRangeMessage, "workflowJobRangeMessage");
+    __name2(workflowJobRangeMessage, "workflowJobRangeMessage");
+    WORKFLOW_SINGLE_STEP_TYPES = [
+      "agent",
+      "tool",
+      "workflow",
+      "step"
+    ];
+    WORKFLOW_HITL_ENTRY_TYPES = [
+      "approval",
+      "waitForSignal"
+    ];
+    WORKFLOW_ARM_ENTRY_TYPES = [
+      ...WORKFLOW_SINGLE_STEP_TYPES,
+      ...WORKFLOW_HITL_ENTRY_TYPES
+    ];
+    WORKFLOW_HITL_ARM_CONTAINERS = [
+      "parallel",
+      "conditional",
+      "foreach"
+    ];
+    __name(isWorkflowSingleStepType, "isWorkflowSingleStepType");
+    __name2(isWorkflowSingleStepType, "isWorkflowSingleStepType");
+    __name(isWorkflowHitlEntryType, "isWorkflowHitlEntryType");
+    __name2(isWorkflowHitlEntryType, "isWorkflowHitlEntryType");
+    __name(isWorkflowArmEntryType, "isWorkflowArmEntryType");
+    __name2(isWorkflowArmEntryType, "isWorkflowArmEntryType");
+    __name(workflowContainerRunsHitlArm, "workflowContainerRunsHitlArm");
+    __name2(workflowContainerRunsHitlArm, "workflowContainerRunsHitlArm");
+    __name(workflowHitlArmUnsupportedMessage, "workflowHitlArmUnsupportedMessage");
+    __name2(workflowHitlArmUnsupportedMessage, "workflowHitlArmUnsupportedMessage");
+    __name(workflowHitlArmShapeMessage, "workflowHitlArmShapeMessage");
+    __name2(workflowHitlArmShapeMessage, "workflowHitlArmShapeMessage");
+    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"
+    });
+    WORKFLOW_ARM_ENTRY_STEP_KINDS = Object.freeze(Object.fromEntries(WORKFLOW_ARM_ENTRY_TYPES.map((t) => [
+      t,
+      WORKFLOW_GRAPH_ENTRY_STEP_KINDS[t]
+    ])));
+    WORKFLOW_BUDGET_MAX_DURATION_SECONDS = Object.freeze({
+      min: 60,
+      max: 2592e3
+    });
     REDACTED_PLACEHOLDER = "[REDACTED]";
     PROVIDER_MESSAGE_MAX_CHARS = 300;
+    ERROR_MESSAGE_MAX_CHARS = 2e3;
     SECRET_LITERAL_PATTERNS = [
       {
         re: /\b(github_pat_)[A-Za-z0-9_]{16,}/g
@@ -1808,6 +2158,10 @@ This text is who you are for this person. As you learn them, their name, their w
       {
         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
       },
@@ -1844,8 +2198,15 @@ This text is who you are for this person. As you learn them, their name, their w
       // `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-]+[_-])?${SECRET_NAME}|[A-Za-z0-9-]+_key)(["']?\\s*[:=]\\s*["']?)((?:basic\\s+|bearer\\s+|token\\s+)?)(?!\\[REDACTED\\])[^\\s"',;)}&]{4,}`, "gi")
+        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`
       {
@@ -1864,16 +2225,47 @@ This text is who you are for this person. As you learn them, their name, their w
     GROUP_COUNT = /* @__PURE__ */ new WeakMap();
     __name(groupCount, "groupCount");
     __name2(groupCount, "groupCount");
+    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;
+    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"
+    ]);
+    __name(isWorkflowSecretKey, "isWorkflowSecretKey");
+    __name2(isWorkflowSecretKey, "isWorkflowSecretKey");
     __name(applyPatterns, "applyPatterns");
     __name2(applyPatterns, "applyPatterns");
     __name(scrubSecretText, "scrubSecretText");
     __name2(scrubSecretText, "scrubSecretText");
+    SCRUB_INPUT_MAX_CHARS = 16 * 1024;
+    SCRUB_CUT_BACKOFF_CHARS = 256;
+    __name(boundScrubInput, "boundScrubInput");
+    __name2(boundScrubInput, "boundScrubInput");
     __name(scrubSecretLines, "scrubSecretLines");
     __name2(scrubSecretLines, "scrubSecretLines");
     __name(messageText, "messageText");
     __name2(messageText, "messageText");
     __name(scrubProviderMessage, "scrubProviderMessage");
     __name2(scrubProviderMessage, "scrubProviderMessage");
+    __name(scrubStepErrorMessage, "scrubStepErrorMessage");
+    __name2(scrubStepErrorMessage, "scrubStepErrorMessage");
     WORKFLOW_AUDIT_EVENTS = [
       // --- definitions / versions / templates (13, 11 §11.11.5) ---
       "workflow.published",
@@ -1940,6 +2332,8 @@ This text is who you are for this person. As you learn them, their name, their w
       "workflow.goal.resumed",
       "workflow.goal.done",
       "workflow.goal.closed",
+      // LUA-760: an ended goal's cadence Job retired (deleted) — inline on done / closed, by R21 / R28, or by sweep #30
+      "workflow.goal.job_retired",
       // --- org policy (02 §2.10 / 09 R23) ---
       "workflow.policy.retention_changed",
       "workflow.policy.pacing_changed",
@@ -1989,6 +2383,79 @@ listed here; never invent a target.`;
     __name2(reachingIt, "reachingIt");
     __name(renderTargetsBlock, "renderTargetsBlock");
     __name2(renderTargetsBlock, "renderTargetsBlock");
+    WORKFLOW_APPROVAL_OUTPUT_DECISIONS = [
+      "approved",
+      "denied",
+      "timed_out"
+    ];
+    WORKFLOW_APPROVAL_OUTPUT_SCHEMA = {
+      type: "object",
+      properties: {
+        approved: {
+          type: "boolean"
+        },
+        decision: {
+          type: "string",
+          enum: [
+            ...WORKFLOW_APPROVAL_OUTPUT_DECISIONS
+          ]
+        },
+        /** the approver's note when given, else the decision word — what `${stepResults.<id>.text}` reads */
+        text: {
+          type: "string"
+        },
+        note: {
+          type: "string"
+        },
+        editedPayload: {},
+        editRevision: {
+          type: "integer"
+        },
+        decidedBy: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string"
+            },
+            kind: {
+              type: "string"
+            }
+          }
+        },
+        timedOut: {
+          type: "boolean"
+        },
+        escalations: {
+          type: "integer"
+        },
+        evidence: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        items: {
+          type: "array",
+          items: {
+            type: "object"
+          }
+        }
+      },
+      required: [
+        "approved",
+        "decision",
+        "text"
+      ]
+    };
+    __name(workflowApprovalDecisionOf, "workflowApprovalDecisionOf");
+    __name2(workflowApprovalDecisionOf, "workflowApprovalDecisionOf");
+    __name(workflowApprovalOutput, "workflowApprovalOutput");
+    __name2(workflowApprovalOutput, "workflowApprovalOutput");
+    __name(isWorkflowApprovalOutput, "isWorkflowApprovalOutput");
+    __name2(isWorkflowApprovalOutput, "isWorkflowApprovalOutput");
+    JSON_FENCE_RE = /```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n?```/g;
+    __name(extractSingleJsonValue, "extractSingleJsonValue");
+    __name2(extractSingleJsonValue, "extractSingleJsonValue");
   }
 });
 
@@ -1997,151 +2464,375 @@ import { createHash } from "crypto";
 import { z as z4 } from "zod";
 import { z as z22 } from "zod";
 import { createHash as createHash2 } from "crypto";
-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} }`;
-}
-function fillPolicy(node, defaultTimeout) {
-  if (node.tier === void 0 && node.workspace !== void 0 && node.workspace !== "inherit") node.tier = "job";
-  if (node.timeoutSeconds === void 0) node.timeoutSeconds = node.tier === "job" ? WORKFLOW_JOB_DEFAULT_TIMEOUT_SECONDS : defaultTimeout;
-  if (node.retry === void 0) node.retry = {
-    maxAttempts: 1
-  };
-  if (node.onError === void 0) node.onError = "fail";
-  if ((node.type === "step" || node.type === "tool") && node.sideEffects === void 0) node.sideEffects = "none";
+function isMapConfigObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function fillSingle(node) {
-  switch (node.type) {
-    case "step": {
-      fillPolicy(node, WORKFLOW_STEP_DEFAULT_TIMEOUT_SECONDS);
-      const s = node;
-      if (s.resumeTimeoutHours === void 0) s.resumeTimeoutHours = WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS;
-      if (s.onSuspendTimeout === void 0) s.onSuspendTimeout = "fail";
-      return;
-    }
-    case "agent":
-      fillPolicy(node, WORKFLOW_AGENT_DEFAULT_TIMEOUT_SECONDS);
-      return;
-    case "tool":
-      fillPolicy(node, WORKFLOW_STEP_DEFAULT_TIMEOUT_SECONDS);
-      return;
-    case "workflow":
-      if (node.workflowId === WORKFLOW_ARM_SUBRUN_ID && Array.isArray(node.graph) && node.graph[1]) fillSingle(node.graph[1]);
-      return;
+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.`);
   }
-}
-function fillArm(arm) {
-  if (arm.type !== "mapping") fillSingle(arm);
-}
-function fillEntry(entry) {
-  switch (entry.type) {
-    case "step":
-    case "agent":
-    case "tool":
-    case "workflow":
-      fillSingle(entry);
-      return;
-    case "parallel":
-      entry.steps.forEach(fillSingle);
-      return;
-    case "conditional": {
-      const c = entry;
-      if (c.exclusive === void 0) c.exclusive = false;
-      c.steps.forEach(fillArm);
-      if (c.otherwise) fillArm(c.otherwise);
-      return;
-    }
-    case "foreach": {
-      const f = 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);
-      return;
-    }
-    case "loop": {
-      const l = entry;
-      if (l.maxIterations === void 0) l.maxIterations = WORKFLOW_LOOP_DEFAULT_MAX_ITERATIONS;
-      fillSingle(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
-      ];
-      return;
-    }
-    case "mapping":
-    case "sleep":
-    case "sleepUntil":
-      return;
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Stored mapping step "${stepId}" has invalid JSON mapConfig: ${e.message}`);
   }
 }
-function withDefaultsFilled(g) {
-  const out = clone(g);
-  out.definition.graph.forEach(fillEntry);
-  return out;
-}
-function isConnectionKeyShaped(value22) {
-  return WORKFLOW_CONNECTION_KEY_RE.test(value22) && !CONNECTION_ID_HEX_RE.test(value22);
+function mapConfigWire(raw) {
+  if (typeof raw === "string") return raw;
+  if (isMapConfigObject(raw)) return canonicalJson(raw);
+  return void 0;
 }
-function connectionKeyUndeclaredMessage(path3, key) {
-  return `${path3} '${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`;
+function describeBadPlaceholder(template22, idx, rawExpr) {
+  return `Template placeholder #${idx} (\${${rawExpr}}) in '${template22}'`;
 }
-function classifyModelProvider(model) {
-  const m = (model ?? "").trim().toLowerCase();
-  if (!m) return null;
-  if (/^(anthropic\/|claude)/.test(m)) return "anthropic";
-  if (/^(openai\/|gpt-|o[1-9](-|$)|chatgpt)/.test(m)) return "openai";
-  if (/^(google\/|gemini)/.test(m)) return "google";
-  return null;
+function parseTemplatePlaceholder(rawExpr) {
+  const dot = rawExpr.indexOf(".");
+  return {
+    scope: dot === -1 ? rawExpr : rawExpr.slice(0, dot),
+    rest: dot === -1 ? "" : rawExpr.slice(dot + 1)
+  };
 }
-function schemaAtPath(schema, path3) {
-  let cur = schema;
-  if (!cur || typeof cur !== "object") return void 0;
-  for (const seg of path3.split(".").filter(Boolean)) {
-    const props = cur.properties;
-    const next = props?.[seg];
-    if (!next || typeof next !== "object") return void 0;
-    cur = next;
+function traverseMappingPath(root, path3, errorLabel) {
+  if (path3 === "" || path3 === ".") return root;
+  const parts = path3.split(".");
+  let value22 = root;
+  for (const part of parts) {
+    if (typeof value22 === "object" && value22 !== null) value22 = value22[part];
+    else throw new WorkflowTemplateError(`Invalid path ${path3} in ${errorLabel}`, path3);
   }
-  return cur;
-}
-function templateStepRefs(text) {
-  const ids = [];
-  for (const m of text.matchAll(TEMPLATE_STEP_REF)) ids.push(m[1]);
-  return ids;
+  return value22;
 }
-function mapConfigStepRefs(raw) {
-  if (!raw) return [];
-  let cfg;
-  try {
-    cfg = typeof raw === "string" ? JSON.parse(raw) : raw;
-  } catch {
-    return [];
-  }
-  const ids = [];
-  for (const d of Object.values(cfg)) {
-    if (!d || typeof d !== "object") continue;
-    const desc = d;
-    if (desc.step !== void 0) ids.push(...Array.isArray(desc.step) ? desc.step : [
-      desc.step
-    ]);
-    if (typeof desc.template === "string") ids.push(...templateStepRefs(desc.template));
+function stringifyTemplateValue(v, template22, idx, rawExpr) {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "object") {
+    try {
+      return JSON.stringify(v);
+    } catch (err) {
+      throw new WorkflowTemplateError(`${describeBadPlaceholder(template22, idx, rawExpr)} resolved to a value that could not be JSON-stringified (${err.message}).`, rawExpr);
+    }
   }
-  return ids;
+  return String(v);
+}
+function escapeFence(content) {
+  return content.replace(/<\/lua-data/g, "<\\/lua-data");
+}
+function fenceBlock(name, source, content) {
+  return `<lua-data name="${name}" source="${source}" untrusted="true">${escapeFence(content)}</lua-data>`;
+}
+function renderTemplate(template22, ctx, opts) {
+  let idx = 0;
+  return template22.replace(TEMPLATE_PLACEHOLDER, (_match, rawExpr) => {
+    idx += 1;
+    const { scope, rest } = parseTemplatePlaceholder(rawExpr);
+    const label = describeBadPlaceholder(template22, idx, rawExpr);
+    let rendered;
+    let source;
+    switch (scope) {
+      case "initData":
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.initData, rest, label), template22, idx, rawExpr);
+        source = "initData";
+        break;
+      case "state":
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.state, rest, label), template22, idx, rawExpr);
+        source = "state";
+        break;
+      case "requestContext":
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.requestContext, rest, label), template22, idx, rawExpr);
+        source = "requestContext";
+        break;
+      case "stepResults": {
+        const innerDot = rest.indexOf(".");
+        const stepId = innerDot === -1 ? rest : rest.slice(0, innerDot);
+        const subPath = innerDot === -1 ? "" : rest.slice(innerDot + 1);
+        if (!stepId) throw new WorkflowTemplateError(`${label} must name a step: \${stepResults.<stepId>.<path>}.`, rawExpr);
+        if (!(stepId in ctx.stepResults) || ctx.stepResults[stepId] == null) {
+          throw new WorkflowTemplateError(`${label} references stepResults.${stepId} but step "${stepId}" has no resolvable output (not an ancestor, not run, failed, or produced no output).`, rawExpr);
+        }
+        rendered = stringifyTemplateValue(traverseMappingPath(ctx.stepResults[stepId], subPath, label), template22, idx, rawExpr);
+        source = `step:${stepId}`;
+        break;
+      }
+      default:
+        throw new WorkflowTemplateError(`${label} references unknown namespace "${scope}". Use one of: ${TEMPLATE_NAMESPACES.join(", ")}.`, rawExpr);
+    }
+    return opts.fenced ? fenceBlock(rawExpr, source, rendered) : rendered;
+  });
+}
+function isMapDescriptor(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const d = v;
+  const keys = Object.keys(d);
+  const only = /* @__PURE__ */ __name3((...allowed) => keys.every((k) => allowed.includes(k)), "only");
+  if ("value" in d) return keys.length === 1;
+  if ("template" in d) return keys.length === 1 && typeof d.template === "string";
+  if ("requestContextPath" in d) return keys.length === 1 && typeof d.requestContextPath === "string";
+  if ("knowledge" in d) return keys.length === 1 && typeof d.knowledge === "object" && d.knowledge !== null;
+  if ("initData" in d) return d.initData === true && typeof d.path === "string" && only("initData", "path");
+  if ("step" in d) {
+    const stepOk = typeof d.step === "string" || Array.isArray(d.step) && d.step.every((x) => typeof x === "string");
+    return stepOk && typeof d.path === "string" && only("step", "path", "rows");
+  }
+  return false;
+}
+function malformedMapMembers(cfg) {
+  if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) return [];
+  const out = [];
+  for (const [member, v] of Object.entries(cfg)) {
+    if (!v || typeof v !== "object" || Array.isArray(v) || isMapDescriptor(v)) continue;
+    const keys = Object.keys(v).filter((k) => MAP_DESCRIPTOR_KEYS.includes(k));
+    if (keys.length > 0) out.push({
+      member,
+      keys
+    });
+  }
+  return out;
+}
+function mapMemberMalformedMessage(id, m) {
+  const keys = m.keys.map((k) => `\`${k}\``).join(", ");
+  return `"${id}".${m.member} carries descriptor key${m.keys.length === 1 ? "" : "s"} ${keys} but is not an exact binding form ({initData:true, path} | {step, path[, rows]} | {value} | {template} | {requestContextPath} | {knowledge}) \u2014 it is passed to the step verbatim as a literal; fix the descriptor, or wrap it in {value: \u2026} if the literal is intended`;
+}
+function resolveDescriptor(key, m, ctx) {
+  if (!isMapDescriptor(m)) return {
+    value: m
+  };
+  try {
+    if ("value" in m) return {
+      value: m.value
+    };
+    if ("template" in m && typeof m.template === "string") {
+      return {
+        value: renderTemplate(m.template, ctx, {
+          fenced: false
+        })
+      };
+    }
+    if ("knowledge" in m || "rows" in m && m.rows !== void 0) {
+      return {
+        error: "binding_unresolved",
+        key
+      };
+    }
+    if ("requestContextPath" in m) {
+      const label = `requestContext path for key "${key}"`;
+      return {
+        value: traverseMappingPath(ctx.requestContext, m.requestContextPath, label)
+      };
+    }
+    if ("path" in m) {
+      const source = "initData" in m && m.initData ? "initData" : "step";
+      if (source === "initData") {
+        return {
+          value: traverseMappingPath(ctx.initData, m.path, `initData for key "${key}"`)
+        };
+      }
+      const stepRef = m.step;
+      const candidates = Array.isArray(stepRef) ? stepRef : [
+        stepRef
+      ];
+      const stepId = candidates.find((s) => ctx.stepResults[s] !== void 0 && ctx.stepResults[s] !== null);
+      if (stepId === void 0) return {
+        error: "binding_unresolved",
+        key
+      };
+      return {
+        value: traverseMappingPath(ctx.stepResults[stepId], m.path, `step ${candidates.join("|")} for key "${key}"`)
+      };
+    }
+    return {
+      error: "binding_unresolved",
+      key
+    };
+  } catch (err) {
+    if (err instanceof WorkflowTemplateError) return {
+      error: "binding_unresolved",
+      key
+    };
+    throw err;
+  }
+}
+function resolveMapping(cfg, ctx) {
+  const keys = Object.keys(cfg);
+  if (keys.length === 1 && keys[0] === "") {
+    return resolveDescriptor("", cfg[""], ctx);
+  }
+  const result = {};
+  for (const key of keys) {
+    const resolved = resolveDescriptor(key, cfg[key], ctx);
+    if ("error" in resolved) return resolved;
+    result[key] = resolved.value;
+  }
+  return {
+    value: result
+  };
+}
+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(".");
+}
+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;
+}
+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} }`;
+}
+function fillPolicy(node, defaultTimeout) {
+  if (node.tier === void 0 && node.workspace !== void 0 && node.workspace !== "inherit") node.tier = "job";
+  if (node.timeoutSeconds === void 0) node.timeoutSeconds = node.tier === "job" ? WORKFLOW_JOB_DEFAULT_TIMEOUT_SECONDS : defaultTimeout;
+  if (node.retry === void 0) node.retry = {
+    maxAttempts: 1
+  };
+  if (node.onError === void 0) node.onError = "fail";
+  if ((node.type === "step" || node.type === "tool") && node.sideEffects === void 0) node.sideEffects = "none";
+}
+function fillSingle(node) {
+  switch (node.type) {
+    case "step": {
+      fillPolicy(node, WORKFLOW_STEP_DEFAULT_TIMEOUT_SECONDS);
+      const s = node;
+      if (s.resumeTimeoutHours === void 0) s.resumeTimeoutHours = WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS;
+      if (s.onSuspendTimeout === void 0) s.onSuspendTimeout = "fail";
+      return;
+    }
+    case "agent":
+      fillPolicy(node, WORKFLOW_AGENT_DEFAULT_TIMEOUT_SECONDS);
+      return;
+    case "tool":
+      fillPolicy(node, WORKFLOW_STEP_DEFAULT_TIMEOUT_SECONDS);
+      return;
+    case "workflow":
+      if (node.workflowId === WORKFLOW_ARM_SUBRUN_ID && Array.isArray(node.graph) && node.graph[1]) fillSingle(node.graph[1]);
+      return;
+  }
+}
+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
+  ];
+}
+function fillArm(arm) {
+  if (arm.type === "mapping") return;
+  if (isHitlNode(arm)) fillHitl(arm);
+  else fillSingle(arm);
+}
+function fillEntry(entry) {
+  switch (entry.type) {
+    case "step":
+    case "agent":
+    case "tool":
+    case "workflow":
+      fillSingle(entry);
+      return;
+    case "parallel":
+      entry.steps.forEach(fillArm);
+      return;
+    case "conditional": {
+      const c = entry;
+      if (c.exclusive === void 0) c.exclusive = false;
+      c.steps.forEach(fillArm);
+      if (c.otherwise) fillArm(c.otherwise);
+      return;
+    }
+    case "foreach": {
+      const f = 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;
+      fillArm(f.step);
+      return;
+    }
+    case "loop": {
+      const l = entry;
+      if (l.maxIterations === void 0) l.maxIterations = WORKFLOW_LOOP_DEFAULT_MAX_ITERATIONS;
+      fillArm(l.step);
+      return;
+    }
+    case "approval":
+    case "waitForSignal":
+      fillHitl(entry);
+      return;
+    case "mapping":
+    case "sleep":
+    case "sleepUntil":
+      return;
+  }
+}
+function withDefaultsFilled(g) {
+  const out = clone(g);
+  out.definition.graph.forEach(fillEntry);
+  return out;
+}
+function isConnectionKeyShaped(value22) {
+  return WORKFLOW_CONNECTION_KEY_RE.test(value22) && !CONNECTION_ID_HEX_RE.test(value22);
+}
+function connectionKeyUndeclaredMessage(path3, key) {
+  return `${path3} '${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`;
+}
+function classifyModelProvider(model) {
+  const m = (model ?? "").trim().toLowerCase();
+  if (!m) return null;
+  if (/^(anthropic\/|claude)/.test(m)) return "anthropic";
+  if (/^(openai\/|gpt-|o[1-9](-|$)|chatgpt)/.test(m)) return "openai";
+  if (/^(google\/|gemini)/.test(m)) return "google";
+  return null;
+}
+function schemaAtPath(schema, path3) {
+  let cur = schema;
+  if (!cur || typeof cur !== "object") return void 0;
+  for (const seg of path3.split(".").filter(Boolean)) {
+    const props = cur.properties;
+    const next = props?.[seg];
+    if (!next || typeof next !== "object") return void 0;
+    cur = next;
+  }
+  return cur;
+}
+function templateStepRefs(text) {
+  const ids = [];
+  for (const m of text.matchAll(TEMPLATE_STEP_REF)) ids.push(m[1]);
+  return ids;
+}
+function readMapConfig(raw) {
+  if (!raw) return void 0;
+  if (typeof raw !== "string") return raw;
+  try {
+    const cfg = JSON.parse(raw);
+    return cfg && typeof cfg === "object" && !Array.isArray(cfg) ? cfg : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function mapConfigStepRefs(raw) {
+  const cfg = readMapConfig(raw);
+  if (!cfg) return [];
+  const ids = [];
+  for (const d of Object.values(cfg)) {
+    if (!isMapDescriptor(d)) continue;
+    if ("step" in d) ids.push(...Array.isArray(d.step) ? d.step : [
+      d.step
+    ]);
+    if ("template" in d) ids.push(...templateStepRefs(d.template));
+  }
+  return ids;
 }
 function nodeStepRefs(entry) {
   switch (entry.type) {
@@ -2202,6 +2893,16 @@ 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");
@@ -2254,8 +2955,16 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     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'`, `${path3}.retry.backoff`, id);
+    const unknown = unknownWorkflowRetryMembers(r);
+    if (unknown.length) err("invalid-envelope", workflowRetryUnknownMembersMessage(unknown), `${path3}.retry`, id);
+    if (r.maxAttempts !== void 0 && !isWithinWorkflowRetryAttempts(r.maxAttempts)) {
+      const over = typeof r.maxAttempts === "number" && r.maxAttempts > WORKFLOW_RETRY_MAX_ATTEMPTS;
+      err(over ? "cap-exceeded" : "invalid-envelope", workflowRetryMaxAttemptsMessage(r.maxAttempts), `${path3}.retry.maxAttempts`, 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}`, `${path3}.retry.backoff`, id);
     }
     if (r.backoffSeconds !== void 0 && r.backoffSeconds < 0) {
       err("backoff-invalid", "retry.backoffSeconds must be \u2265 0", `${path3}.retry.backoffSeconds`, id);
@@ -2394,6 +3103,21 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     const schema = node.type === "step" ? node.step.outputSchema : node.type === "agent" ? node.outputSchema : void 0;
     if (schema !== void 0) outputSchemas.set(singleId(node), schema);
   }, "recordOutputSchema");
+  const checkMapMembers = /* @__PURE__ */ __name3((cfg, basePath, id) => {
+    for (const m of malformedMapMembers(cfg)) {
+      warn(MAP_MEMBER_MALFORMED_CODE, mapMemberMalformedMessage(id, m), `${basePath}.${m.member}`, id);
+    }
+  }, "checkMapMembers");
+  const checkInputShape = /* @__PURE__ */ __name3((node, path3) => {
+    if (node.type !== "tool" && node.type !== "workflow") return;
+    const input = node.input;
+    if (input === void 0) return;
+    if (input !== null && typeof input === "object" && !Array.isArray(input)) {
+      checkMapMembers(input, `${path3}.input`, node.id);
+      return;
+    }
+    err("invalid-envelope", `\`input\` must be an object map \u2014 each member a binding descriptor ({initData:true, path} | {step, path} | {value} | {template} | {requestContextPath}) or a JSON literal (got ${JSON.stringify(input)})`, `${path3}.input`, node.id);
+  }, "checkInputShape");
   const checkSingle = /* @__PURE__ */ __name3((node, path3, depth) => {
     recordOutputSchema(node);
     if (node.type === "workflow" && node.workflowId === WORKFLOW_ARM_SUBRUN_ID) {
@@ -2407,8 +3131,13 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         err("container-arm-empty", "a bare mapping arm has nothing to run", `${path3}.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"), `${path3}.graph.1`, inner.id);
+        return;
+      }
       upstream.add(singleId(body[1]));
-      checkArm(body[0], `${path3}.graph.0`, depth);
+      checkArm(body[0], `${path3}.graph.0`, depth, "parallel");
       checkSingle(body[1], `${path3}.graph.1`, depth);
       upstream.add(body[0].id);
       upstream.add(singleId(body[1]));
@@ -2416,6 +3145,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
     }
     checkId(singleId(node), path3);
     checkPolicyEnums(node, path3);
+    checkInputShape(node, path3);
     checkTimeout(node, path3);
     checkTier(node, path3);
     checkRetry(node, path3);
@@ -2440,20 +3170,72 @@ 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}`, path3, 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`, path3, 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`, path3, singleId(node));
       }
     }
-  }, "checkSingle");
-  const checkArm = /* @__PURE__ */ __name3((arm, path3, depth) => {
+  }, "checkSingle");
+  const checkHitl = /* @__PURE__ */ __name3((node, path3) => {
+    if (node.type === "waitForSignal") {
+      const w = node;
+      checkId(w.id, path3);
+      if (typeof w.signal !== "string" || w.signal.length === 0) err("invalid-envelope", "waitForSignal.signal is required", `${path3}.signal`, w.id);
+      return;
+    }
+    const a = node;
+    checkId(a.id, path3);
+    if (a.approver === "creator" && a.excludeInitiator === true) {
+      err("approver-excludes-only-candidate", "approver:'creator' with excludeInitiator:true always excludes the only candidate", path3, a.id);
+    }
+    if (a.fourEyes !== void 0 && a.editable !== true) {
+      err("four-eyes-requires-editable", "`fourEyes` requires editable:true", `${path3}.fourEyes`, a.id);
+    }
+    if ((a.editablePaths !== void 0 || a.editedPayloadSchema !== void 0) && a.editable !== true) {
+      err("editable-path-invalid", "`editablePaths` / `editedPayloadSchema` require editable:true", `${path3}.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`, `${path3}.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", `${path3}.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", `${path3}.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`, path3, a.id);
+      }
+    }
+  }, "checkHitl");
+  const checkHitlArm = /* @__PURE__ */ __name3((node, path3, container) => {
+    if (!workflowContainerRunsHitlArm(container)) {
+      checkId(node.id, path3);
+      err("node-type-unsupported-in-container", workflowHitlArmUnsupportedMessage(node.type, node.id, container), path3, node.id);
+      return;
+    }
+    checkHitl(node, path3);
+  }, "checkHitlArm");
+  const checkArm = /* @__PURE__ */ __name3((arm, path3, depth, container) => {
     if (arm.type === "mapping") {
       checkId(arm.id, path3);
+      checkMapMembers(readMapConfig(arm.mapConfig), `${path3}.mapConfig`, arm.id);
       for (const ref of nodeStepRefs(arm)) {
         if (!upstream.has(ref)) err("template-reference-unresolved", `"${arm.id}" references stepResults.${ref}, which is not upstream`, path3, arm.id);
       }
       return;
     }
+    if (isHitlNode(arm)) {
+      checkHitlArm(arm, path3, container);
+      return;
+    }
     checkSingle(arm, path3, depth);
   }, "checkArm");
   graph.forEach((entry, i) => {
@@ -2469,6 +3251,7 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         break;
       case "mapping":
         checkId(entry.id, path3);
+        checkMapMembers(readMapConfig(entry.mapConfig), `${path3}.mapConfig`, entry.id);
         for (const ref of nodeStepRefs(entry)) {
           if (!upstream.has(ref)) err("template-reference-unresolved", `"${entry.id}" references stepResults.${ref}, which is not upstream`, path3, entry.id);
         }
@@ -2503,18 +3286,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", path3);
         if (worktreeArms.length === 0 && p.merge) err("merge-requires-worktree-arms", "`merge` needs at least one worktree arm", path3);
         if (worktreeArms.length > WORKFLOW_JOB_MAX_WORKTREE_ARMS) err("worktree-arms-exceed-cap", `at most ${WORKFLOW_JOB_MAX_WORKTREE_ARMS} worktree arms per parallel`, path3);
-        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");
@@ -2531,11 +3311,11 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
           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", `${path3}.predicates.${j}`);
         });
         c.steps.forEach((arm, j) => {
-          checkArm(arm, `${path3}.steps.${j}`, 1);
+          checkArm(arm, `${path3}.steps.${j}`, 1, "conditional");
           declared.push(armId(arm));
         });
         if (c.otherwise) {
-          checkArm(c.otherwise, `${path3}.otherwise`, 1);
+          checkArm(c.otherwise, `${path3}.otherwise`, 1, "conditional");
           declared.push(armId(c.otherwise));
         }
         break;
@@ -2558,8 +3338,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}]`, `${path3}.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" ? `${path3}.opts.chunk` : `${path3}.opts.chunk.size`);
           }
         }
         if (o.rateLimit !== void 0) {
@@ -2576,12 +3357,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);
@@ -2593,8 +3369,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`, `${path3}.step`, singleId(f.step));
         }
         if (bodyType === "mapping") err("container-arm-empty", "a foreach body needs a step, not a bare mapping", `${path3}.step`);
-        else if (bodyType === "approval" || bodyType === "waitForSignal") err("approval-inside-container", "approval / waitForSignal are top-level only in v1", `${path3}.step`);
-        else {
+        else if (isHitlNode(f.step)) {
+          if (o.chunk !== void 0) {
+            checkId(f.step.id, `${path3}.step`);
+            err("node-type-unsupported-in-container", workflowHitlArmShapeMessage(f.step.type, f.step.id, "chunked-foreach"), `${path3}.step`, f.step.id);
+          } else checkHitlArm(f.step, `${path3}.step`, "foreach");
+          declared.push(f.step.id);
+        } else {
           checkSingle(f.step, `${path3}.step`, o.chunk ? 2 : 1);
           declared.push(singleId(f.step));
         }
@@ -2611,52 +3392,20 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
         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", `${path3}.predicate`);
         const bodyType = l.step.type;
         if (bodyType === "mapping") err("container-arm-empty", "a loop body needs a step, not a bare mapping", `${path3}.step`);
-        else if (bodyType === "approval" || bodyType === "waitForSignal") err("approval-inside-container", "approval / waitForSignal are top-level only in v1", `${path3}.step`);
-        else {
+        else if (isHitlNode(l.step)) {
+          checkHitlArm(l.step, `${path3}.step`, "loop");
+          declared.push(l.step.id);
+        } else {
           checkSingle(l.step, `${path3}.step`, 1);
           declared.push(singleId(l.step));
         }
         break;
       }
-      case "approval": {
-        const a = entry;
-        checkId(a.id, path3);
-        if (a.approver === "creator" && a.excludeInitiator === true) {
-          err("approver-excludes-only-candidate", "approver:'creator' with excludeInitiator:true always excludes the only candidate", path3, a.id);
-        }
-        if (a.fourEyes !== void 0 && a.editable !== true) {
-          err("four-eyes-requires-editable", "`fourEyes` requires editable:true", `${path3}.fourEyes`, a.id);
-        }
-        if ((a.editablePaths !== void 0 || a.editedPayloadSchema !== void 0) && a.editable !== true) {
-          err("editable-path-invalid", "`editablePaths` / `editedPayloadSchema` require editable:true", `${path3}.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`, `${path3}.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", `${path3}.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", `${path3}.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`, path3, a.id);
-          }
-        }
-        declared.push(a.id);
-        break;
-      }
-      case "waitForSignal": {
-        const w = entry;
-        checkId(w.id, path3);
-        if (typeof w.signal !== "string" || w.signal.length === 0) err("invalid-envelope", "waitForSignal.signal is required", `${path3}.signal`, w.id);
-        declared.push(w.id);
+      case "approval":
+      case "waitForSignal":
+        checkHitl(entry, path3);
+        declared.push(entry.id);
         break;
-      }
       default:
         err("invalid-envelope", `unknown entry type "${entry.type}"`, path3);
     }
@@ -2745,10 +3494,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,
@@ -2773,9 +3522,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,
@@ -2788,24 +3536,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,
@@ -2843,9 +3579,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
             ],
@@ -3022,250 +3758,96 @@ function compare(op, left, right) {
         return left < right;
       case "lte":
         return left <= right;
-      case "gt":
-        return left > right;
-      case "gte":
-        return left >= right;
-    }
-  }
-  return false;
-}
-function derivePredicateLabel(pred, maxLength = 80) {
-  const raw = renderPredicate(pred);
-  if (raw.length <= maxLength) return raw;
-  return raw.slice(0, maxLength - 1) + "\u2026";
-}
-function renderPredicate(pred) {
-  switch (pred.op) {
-    case "and":
-    case "or":
-      return pred.args.map((arg) => wrapLabel(arg, renderPredicate(arg))).join(pred.op === "and" ? " AND " : " OR ");
-    case "not":
-      return `NOT ${wrapLabel(pred.arg, renderPredicate(pred.arg))}`;
-    case "exists":
-      return `${pred.path} exists`;
-    case "notExists":
-      return `${pred.path} missing`;
-    case "truthy":
-      return `${renderRef(pred.value)} is truthy`;
-    case "falsy":
-      return `${renderRef(pred.value)} is falsy`;
-    case "in":
-      return `${renderRef(pred.value)} in ${JSON.stringify(pred.set)}`;
-    case "notIn":
-      return `${renderRef(pred.value)} not in ${JSON.stringify(pred.set)}`;
-    case "eq":
-      return `${renderRef(pred.left)} == ${renderRef(pred.right)}`;
-    case "ne":
-      return `${renderRef(pred.left)} != ${renderRef(pred.right)}`;
-    case "lt":
-      return `${renderRef(pred.left)} < ${renderRef(pred.right)}`;
-    case "lte":
-      return `${renderRef(pred.left)} <= ${renderRef(pred.right)}`;
-    case "gt":
-      return `${renderRef(pred.left)} > ${renderRef(pred.right)}`;
-    case "gte":
-      return `${renderRef(pred.left)} >= ${renderRef(pred.right)}`;
-  }
-}
-function wrapLabel(child, rendered) {
-  return child.op === "and" || child.op === "or" || child.op === "not" ? `(${rendered})` : rendered;
-}
-function renderRef(ref) {
-  if ("literal" in ref) return JSON.stringify(ref.literal);
-  return ref.path;
-}
-function step(s) {
-  const id = stepIdOf(s);
-  return {
-    path: /* @__PURE__ */ __name3((p) => ({
-      path: p === "" ? `stepResults.${id}` : `stepResults.${id}.${p}`
-    }), "path")
-  };
-}
-function stepOf(id) {
-  return step(id);
-}
-function init(path3) {
-  return {
-    path: path3 === "" ? "initData" : `initData.${path3}`
-  };
-}
-function state(path3) {
-  return {
-    path: path3 === "" ? "state" : `state.${path3}`
-  };
-}
-function lit(v) {
-  return {
-    literal: v
-  };
-}
-function toPathOrLiteral(v) {
-  if (typeof v === "object" && v !== null) {
-    if ("path" in v) return {
-      path: v.path
-    };
-    if ("literal" in v) return {
-      literal: v.literal
-    };
-  }
-  return {
-    literal: v
-  };
-}
-function parseMapConfig(raw, stepId) {
-  try {
-    return JSON.parse(raw);
-  } catch (e) {
-    throw new Error(`Stored mapping step "${stepId}" has invalid JSON mapConfig: ${e.message}`);
-  }
-}
-function describeBadPlaceholder(template22, idx, rawExpr) {
-  return `Template placeholder #${idx} (\${${rawExpr}}) in '${template22}'`;
-}
-function parseTemplatePlaceholder(rawExpr) {
-  const dot = rawExpr.indexOf(".");
-  return {
-    scope: dot === -1 ? rawExpr : rawExpr.slice(0, dot),
-    rest: dot === -1 ? "" : rawExpr.slice(dot + 1)
-  };
-}
-function traverseMappingPath(root, path3, errorLabel) {
-  if (path3 === "" || path3 === ".") return root;
-  const parts = path3.split(".");
-  let value22 = root;
-  for (const part of parts) {
-    if (typeof value22 === "object" && value22 !== null) value22 = value22[part];
-    else throw new WorkflowTemplateError(`Invalid path ${path3} in ${errorLabel}`, path3);
-  }
-  return value22;
-}
-function stringifyTemplateValue(v, template22, idx, rawExpr) {
-  if (v === null || v === void 0) return "";
-  if (typeof v === "object") {
-    try {
-      return JSON.stringify(v);
-    } catch (err) {
-      throw new WorkflowTemplateError(`${describeBadPlaceholder(template22, idx, rawExpr)} resolved to a value that could not be JSON-stringified (${err.message}).`, rawExpr);
-    }
-  }
-  return String(v);
-}
-function escapeFence(content) {
-  return content.replace(/<\/lua-data/g, "<\\/lua-data");
-}
-function fenceBlock(name, source, content) {
-  return `<lua-data name="${name}" source="${source}" untrusted="true">${escapeFence(content)}</lua-data>`;
-}
-function renderTemplate(template22, ctx, opts) {
-  let idx = 0;
-  return template22.replace(TEMPLATE_PLACEHOLDER, (_match, rawExpr) => {
-    idx += 1;
-    const { scope, rest } = parseTemplatePlaceholder(rawExpr);
-    const label = describeBadPlaceholder(template22, idx, rawExpr);
-    let rendered;
-    let source;
-    switch (scope) {
-      case "initData":
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.initData, rest, label), template22, idx, rawExpr);
-        source = "initData";
-        break;
-      case "state":
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.state, rest, label), template22, idx, rawExpr);
-        source = "state";
-        break;
-      case "requestContext":
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.requestContext, rest, label), template22, idx, rawExpr);
-        source = "requestContext";
-        break;
-      case "stepResults": {
-        const innerDot = rest.indexOf(".");
-        const stepId = innerDot === -1 ? rest : rest.slice(0, innerDot);
-        const subPath = innerDot === -1 ? "" : rest.slice(innerDot + 1);
-        if (!stepId) throw new WorkflowTemplateError(`${label} must name a step: \${stepResults.<stepId>.<path>}.`, rawExpr);
-        if (!(stepId in ctx.stepResults) || ctx.stepResults[stepId] == null) {
-          throw new WorkflowTemplateError(`${label} references stepResults.${stepId} but step "${stepId}" has no resolvable output (not an ancestor, not run, failed, or produced no output).`, rawExpr);
-        }
-        rendered = stringifyTemplateValue(traverseMappingPath(ctx.stepResults[stepId], subPath, label), template22, idx, rawExpr);
-        source = `step:${stepId}`;
-        break;
-      }
-      default:
-        throw new WorkflowTemplateError(`${label} references unknown namespace "${scope}". Use one of: ${TEMPLATE_NAMESPACES.join(", ")}.`, rawExpr);
-    }
-    return opts.fenced ? fenceBlock(rawExpr, source, rendered) : rendered;
-  });
-}
-function resolveDescriptor(key, m, ctx) {
-  try {
-    if ("value" in m) return {
-      value: m.value
-    };
-    if ("template" in m && typeof m.template === "string") {
-      return {
-        value: renderTemplate(m.template, ctx, {
-          fenced: false
-        })
-      };
-    }
-    if ("knowledge" in m || "rows" in m && m.rows !== void 0) {
-      return {
-        error: "binding_unresolved",
-        key
-      };
-    }
-    if ("requestContextPath" in m) {
-      const label = `requestContext path for key "${key}"`;
-      return {
-        value: traverseMappingPath(ctx.requestContext, m.requestContextPath, label)
-      };
-    }
-    if ("path" in m) {
-      const source = "initData" in m && m.initData ? "initData" : "step";
-      if (source === "initData") {
-        return {
-          value: traverseMappingPath(ctx.initData, m.path, `initData for key "${key}"`)
-        };
-      }
-      const stepRef = m.step;
-      const candidates = Array.isArray(stepRef) ? stepRef : [
-        stepRef
-      ];
-      const stepId = candidates.find((s) => ctx.stepResults[s] !== void 0 && ctx.stepResults[s] !== null);
-      if (stepId === void 0) return {
-        error: "binding_unresolved",
-        key
-      };
-      return {
-        value: traverseMappingPath(ctx.stepResults[stepId], m.path, `step ${candidates.join("|")} for key "${key}"`)
-      };
+      case "gt":
+        return left > right;
+      case "gte":
+        return left >= right;
     }
-    return {
-      error: "binding_unresolved",
-      key
-    };
-  } catch (err) {
-    if (err instanceof WorkflowTemplateError) return {
-      error: "binding_unresolved",
-      key
-    };
-    throw err;
   }
+  return false;
 }
-function resolveMapping(cfg, ctx) {
-  const keys = Object.keys(cfg);
-  if (keys.length === 1 && keys[0] === "") {
-    return resolveDescriptor("", cfg[""], ctx);
+function derivePredicateLabel(pred, maxLength = 80) {
+  const raw = renderPredicate(pred);
+  if (raw.length <= maxLength) return raw;
+  return raw.slice(0, maxLength - 1) + "\u2026";
+}
+function renderPredicate(pred) {
+  switch (pred.op) {
+    case "and":
+    case "or":
+      return pred.args.map((arg) => wrapLabel(arg, renderPredicate(arg))).join(pred.op === "and" ? " AND " : " OR ");
+    case "not":
+      return `NOT ${wrapLabel(pred.arg, renderPredicate(pred.arg))}`;
+    case "exists":
+      return `${pred.path} exists`;
+    case "notExists":
+      return `${pred.path} missing`;
+    case "truthy":
+      return `${renderRef(pred.value)} is truthy`;
+    case "falsy":
+      return `${renderRef(pred.value)} is falsy`;
+    case "in":
+      return `${renderRef(pred.value)} in ${JSON.stringify(pred.set)}`;
+    case "notIn":
+      return `${renderRef(pred.value)} not in ${JSON.stringify(pred.set)}`;
+    case "eq":
+      return `${renderRef(pred.left)} == ${renderRef(pred.right)}`;
+    case "ne":
+      return `${renderRef(pred.left)} != ${renderRef(pred.right)}`;
+    case "lt":
+      return `${renderRef(pred.left)} < ${renderRef(pred.right)}`;
+    case "lte":
+      return `${renderRef(pred.left)} <= ${renderRef(pred.right)}`;
+    case "gt":
+      return `${renderRef(pred.left)} > ${renderRef(pred.right)}`;
+    case "gte":
+      return `${renderRef(pred.left)} >= ${renderRef(pred.right)}`;
   }
-  const result = {};
-  for (const key of keys) {
-    const resolved = resolveDescriptor(key, cfg[key], ctx);
-    if ("error" in resolved) return resolved;
-    result[key] = resolved.value;
+}
+function wrapLabel(child, rendered) {
+  return child.op === "and" || child.op === "or" || child.op === "not" ? `(${rendered})` : rendered;
+}
+function renderRef(ref) {
+  if ("literal" in ref) return JSON.stringify(ref.literal);
+  return ref.path;
+}
+function step(s) {
+  const id = stepIdOf(s);
+  return {
+    path: /* @__PURE__ */ __name3((p) => ({
+      path: p === "" ? `stepResults.${id}` : `stepResults.${id}.${p}`
+    }), "path")
+  };
+}
+function stepOf(id) {
+  return step(id);
+}
+function init(path3) {
+  return {
+    path: path3 === "" ? "initData" : `initData.${path3}`
+  };
+}
+function state(path3) {
+  return {
+    path: path3 === "" ? "state" : `state.${path3}`
+  };
+}
+function lit(v) {
+  return {
+    literal: v
+  };
+}
+function toPathOrLiteral(v) {
+  if (typeof v === "object" && v !== null) {
+    if ("path" in v) return {
+      path: v.path
+    };
+    if ("literal" in v) return {
+      literal: v.literal
+    };
   }
   return {
-    value: result
+    literal: v
   };
 }
 function continuedFailureValue(error, killReason) {
@@ -3367,7 +3949,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 resolve3 = /* @__PURE__ */ __name3((ref, i, allowMapping, container) => {
     if ("node" in ref) {
       if (ref.node.type === "mapping" && !allowMapping) {
         issues.push({
@@ -3384,7 +3987,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 })/workflow(\u2026)`,
+        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
       });
@@ -3399,6 +4002,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({
@@ -3412,23 +4020,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) {
+      resolve3(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;
@@ -3437,7 +4053,7 @@ function resolvePlacements(calls) {
   const graph = [];
   const lookup = /* @__PURE__ */ __name3((ref) => {
     const n2 = "node" in ref ? ref.node : declared.get(ref.ref)?.node;
-    if (!n2 || !ref.armMap || n2.type === "mapping") return n2;
+    if (!n2 || !ref.armMap || n2.type === "mapping" || isHitlNode2(n2)) return n2;
     return lowerContainerArm(ref.armMap, n2);
   }, "lookup");
   calls.forEach((call, i) => {
@@ -3517,6 +4133,57 @@ function resolvePlacements(calls) {
     issues
   };
 }
+function isConditionalJoinId(stepId) {
+  return CONDITIONAL_JOIN_ID.test(stepId);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function leafValue(row) {
+  if (row.status === "completed") return row.output === void 0 ? null : row.output;
+  return continuedFailureValue(row.error, row.killReason);
+}
+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));
+}
+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)
+  };
+}
+function subrunSettledOutput(child) {
+  if (child.output !== void 0) return child.output;
+  return deriveRunOutput(child.steps ?? [])?.output ?? null;
+}
 function seedLedgerFromRun(run, steps, targetPlan, opts = {}) {
   const byId = /* @__PURE__ */ new Map();
   for (const s of steps) {
@@ -3539,15 +4206,15 @@ function seedLedgerFromRun(run, steps, targetPlan, opts = {}) {
       parent
     ] : [];
   }, "dependsOf");
-  const walk2 = [
+  const walk22 = [
     ...targetPlan.order
   ];
   for (const s of steps) {
-    if (!known.has(s.stepId) && parentOf(s.stepId) && known.has(parentOf(s.stepId)) && !walk2.includes(s.stepId)) {
-      walk2.push(s.stepId);
+    if (!known.has(s.stepId) && parentOf(s.stepId) && known.has(parentOf(s.stepId)) && !walk22.includes(s.stepId)) {
+      walk22.push(s.stepId);
     }
   }
-  for (const id of walk2) {
+  for (const id of walk22) {
     const row = byId.get(id);
     if (!row || row.status !== "completed") continue;
     if (!dependsOf(id).every((d) => seededIds.has(d))) {
@@ -3667,6 +4334,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 {
@@ -3708,7 +4384,7 @@ function ancestorResults(plan, id, rows22) {
     }
     return hit;
   }, "take");
-  const walk2 = /* @__PURE__ */ __name3((ids) => {
+  const walk22 = /* @__PURE__ */ __name3((ids) => {
     for (const dep of ids) {
       if (seen.has(dep)) continue;
       seen.add(dep);
@@ -3733,10 +4409,10 @@ function ancestorResults(plan, id, rows22) {
           }
         }
       }
-      walk2(node.dependsOn);
+      walk22(node.dependsOn);
     }
   }, "walk");
-  walk2(plan.steps[id]?.dependsOn ?? []);
+  walk22(plan.steps[id]?.dependsOn ?? []);
   return out;
 }
 function inferTaken(entry, rows22) {
@@ -3808,21 +4484,86 @@ function runCounts(counts) {
     pending: n(c.pending) + n(c.ready) + n(c.waiting)
   };
 }
-function runUsage(run) {
+function isPricedStepReceipt(receipt) {
+  return typeof receipt?.multiplier === "number" && Number.isFinite(receipt.multiplier);
+}
+function receiptEngine(engine) {
+  if (engine === "actions") return "seat";
+  if (engine === "credits") return "legacy";
+  return void 0;
+}
+function receiptTier(tier) {
+  return tier === "light" || tier === "standard" || tier === "heavy" ? tier : void 0;
+}
+function stepBillingView(receipt) {
+  const engine = receiptEngine(receipt?.engine);
+  if (!receipt || engine === void 0) return void 0;
+  return pruneUndefined({
+    engine,
+    attempt: typeof receipt.attempt === "number" ? receipt.attempt : void 0,
+    credits: typeof receipt.credits === "number" ? receipt.credits : void 0,
+    actions: typeof receipt.actionsEstimate === "number" ? receipt.actionsEstimate : void 0,
+    model: typeof receipt.model === "string" ? receipt.model : void 0,
+    tier: receiptTier(receipt.tier),
+    multiplier: typeof receipt.multiplier === "number" ? receipt.multiplier : void 0,
+    byok: typeof receipt.byok === "boolean" ? receipt.byok : void 0,
+    calibrated: typeof receipt.calibrated === "boolean" ? receipt.calibrated : void 0
+  });
+}
+function runUsage(run, receipts) {
+  const actions = n(run.budget?.spent?.actionsEstimate);
+  const stamped = run.budget?.engine;
+  const priced = (receipts ?? []).filter(isPricedStepReceipt);
+  const engine = stamped === "seat" || stamped === "legacy" ? stamped : actions > 0 || priced.some((r) => r.engine === "actions") ? "seat" : priced.some((r) => r.engine === "credits") ? "legacy" : void 0;
+  const seat = engine === "seat";
+  const metering = engine ? "priced" : "flat";
   return {
     creditsUsed: run.budget?.spent?.credits ?? 0,
     actionsEstimate: run.budget?.spent?.actionsEstimate ?? 0,
+    ...seat ? {
+      actionsUsed: actions
+    } : {},
+    metering,
+    ...engine ? {
+      engine
+    } : {},
     steps: run.budget?.spent?.steps ?? 0,
     inputTokens: run.usage?.inputTokens ?? 0,
     outputTokens: run.usage?.outputTokens ?? 0
   };
 }
+function runBudgetCap(budget) {
+  const cap = budget?.maxCredits;
+  return typeof cap === "number" && Number.isFinite(cap) && cap > 0 ? cap : void 0;
+}
+function runBudgetRemaining(budget) {
+  const cap = runBudgetCap(budget);
+  if (cap === void 0) return void 0;
+  const spent = budget?.spent;
+  return Math.max(0, cap - n(spent?.credits) - n(spent?.actionsEstimate) - n(budget?.reserved));
+}
 function runCancelView(cancel) {
   if (!cancel) return void 0;
   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
+    } : {}
   };
 }
 function runWorkspaceView(ws) {
@@ -3841,7 +4582,6 @@ function runWorkspaceView(ws) {
 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,
@@ -3853,7 +4593,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,
@@ -3876,9 +4623,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",
@@ -3897,6 +4646,49 @@ function toWorkflowRunSummary(run) {
     hasOutput: run.hasOutput === true || run.output !== void 0 || run.outputRef !== void 0 ? true : void 0
   });
 }
+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;
+}
+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
+  };
+}
 function timeZoneSupported(tz) {
   if (typeof tz !== "string" || !tz) return false;
   const intl = Intl;
@@ -4360,6 +5152,22 @@ function rebaseItemPointer(pointer, itemsPath, index) {
   const base = `/${itemsPath.split(".").map(escapePointer).join("/")}/${index}`;
   return pointer === "/" || pointer === "" ? base : `${base}${pointer}`;
 }
+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
+  };
+}
 function bindingRootsOk(template22) {
   const refs = [
     ...template22.matchAll(/\$\{\s*([A-Za-z_$][\w$]*)/g)
@@ -4384,7 +5192,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", path3, `at most ${APPROVER_SPEC_MAX_USERS} users`);
-      else push("approver-invalid", path3, r.error.issues[0]?.message ?? "invalid approver");
+      else {
+        const refusal = describeApproverSpecRefusal(spec);
+        issues.push({
+          code: "approver-invalid",
+          path: path3,
+          severity: "error",
+          message: refusal.message,
+          repair: {
+            approver: refusal.approver,
+            written: refusal.written
+          }
+        });
+      }
       return;
     }
     const s = r.data;
@@ -4452,7 +5272,7 @@ function liftRenderedApprover(row, rendered) {
 }
 function collectEnvTemplateKeys(value22) {
   const keys = /* @__PURE__ */ new Set();
-  const walk2 = /* @__PURE__ */ __name3((v) => {
+  const walk22 = /* @__PURE__ */ __name3((v) => {
     if (isEnvRef(v)) {
       keys.add(v.__envRef);
       return;
@@ -4460,26 +5280,26 @@ function collectEnvTemplateKeys(value22) {
     if (typeof v === "string") {
       if (looksLikeEmbeddedJson(v)) {
         try {
-          walk2(JSON.parse(v));
+          walk22(JSON.parse(v));
         } catch {
         }
       }
       return;
     }
     if (Array.isArray(v)) {
-      for (const e of v) walk2(e);
+      for (const e of v) walk22(e);
       return;
     }
-    if (v && typeof v === "object") for (const e of Object.values(v)) walk2(e);
+    if (v && typeof v === "object") for (const e of Object.values(v)) walk22(e);
   }, "walk");
-  walk2(value22);
+  walk22(value22);
   return [
     ...keys
   ].sort();
 }
 function substituteEnvRefs(value22, overlay) {
   const missing = /* @__PURE__ */ new Set();
-  const walk2 = /* @__PURE__ */ __name3((v, slot = false) => {
+  const walk22 = /* @__PURE__ */ __name3((v, slot = false) => {
     if (isEnvRef(v)) {
       if (Object.prototype.hasOwnProperty.call(overlay, v.__envRef)) {
         const s = overlay[v.__envRef];
@@ -4496,22 +5316,22 @@ function substituteEnvRefs(value22, overlay) {
         const cfg = JSON.parse(v);
         if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) return v;
         const out = {};
-        for (const [k, e] of Object.entries(cfg)) out[k] = walk2(e, true);
+        for (const [k, e] of Object.entries(cfg)) out[k] = walk22(e, true);
         return canonicalJson(out);
       } catch {
         return v;
       }
     }
-    if (Array.isArray(v)) return v.map((e) => walk2(e));
+    if (Array.isArray(v)) return v.map((e) => walk22(e));
     if (v && typeof v === "object") {
       const out = {};
-      for (const [k, e] of Object.entries(v)) out[k] = walk2(e);
+      for (const [k, e] of Object.entries(v)) out[k] = walk22(e);
       return out;
     }
     return v;
   }, "walk");
   return {
-    value: walk2(value22),
+    value: walk22(value22),
     missing: [
       ...missing
     ].sort()
@@ -4740,26 +5560,115 @@ function needsInheritedWorkspace(graph) {
   }
   return false;
 }
-var __defProp3, __name3, WORKFLOW_SIDE_EFFECTS, WORKFLOW_JOB_RESOURCES, SideEffectsSchema, JobResourcesSchema, WORKFLOW_ARM_SUBRUN_ID, SLEEP_UNTIL_REPLACEMENT, WORKFLOW_CAPS_DEFAULT, WORKFLOW_STEP_DEFAULT_TIMEOUT_SECONDS, WORKFLOW_AGENT_DEFAULT_TIMEOUT_SECONDS, WORKFLOW_JOB_DEFAULT_TIMEOUT_SECONDS, WORKFLOW_FOREACH_DEFAULT_CONCURRENCY, WORKFLOW_FOREACH_DEFAULT_MAX_ITEMS, WORKFLOW_LOOP_DEFAULT_MAX_ITERATIONS, WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS, WORKFLOW_SIGNAL_DEFAULT_SOURCES, clone, CONNECTION_ID_HEX_RE, WORKFLOW_JOB_TOOLS, WORKFLOW_JOB_MAX_WORKTREE_ARMS, workspaceOf, mountsWorkspace, isJobTier, jobToolsOf, schemaIsArray, singleId, armId, TEMPLATE_STEP_REF, EDITABLE_PATH_RE, PREDICATE_OPS, isPredicateScalar, GRAPH_HASH_PREFIX, WorkflowPlanError, SINGLE_STEP_KINDS, isSingleStep, singleStepId, joinIdOf, containerIdOf, PATH_PLACEHOLDER, MISSING, stepIdOf, cmp, eq, ne, gt, gte, lt, lte, inSet, notIn, exists, notExists, truthy, falsy, and, or, not, WorkflowTemplateError, TEMPLATE_PLACEHOLDER, TEMPLATE_NAMESPACES, fromInit, fromStep, value, template, fromRequest, rows, fromKnowledge, CONTINUED_FAILURE_TAG, CONTINUED_FAILURE_DEFAULT_CODE, CONTINUED_FAILURE_OUTPUT_SCHEMA, CONTINUED_FAILURE_LEAF_PATHS, nodeIdOf, branchArmId, canonical, sortKeys, JOIN, entryOfJoin, FORCE_CANCEL_STALE_MS, TERMINAL, IN_FLIGHT, n, MAX_HOLIDAYS, MAX_WALK_DAYS, HHMM, YMD, MS_PER_MIN, MS_PER_DAY, MON_FRI, supportedTz, fmtCache, WEEKDAYS, JSON_PATCH_OPS, JSON_PATCH_MAX_OPS, JSON_PATCH_MAX_VALUE_BYTES, JSON_PATCH_MAX_TOTAL_BYTES, SEGMENT_RE, APPROVER_SPEC_MAX_USERS, ESCALATION_MAX_HOPS, TemplateBindingSchema, ApproverSpecSchema, FourEyesSchema, EscalationHopSchema, TerminalOutcomeSchema, ApprovalOnTimeoutSchema, BINDING_ROOTS, WORKFLOW_ENV_OVERLAY_MAX_KEYS, WORKFLOW_ENV_OVERLAY_MAX_VALUE_BYTES, WORKFLOW_ENV_TEMPLATE_SECRET_KEY_RE, isEnvRef, looksLikeEmbeddedJson, ZERO, isRecord2;
+var __defProp3, __name3, WorkflowTemplateError, TEMPLATE_PLACEHOLDER, TEMPLATE_NAMESPACES, MAP_DESCRIPTOR_KEYS, MAP_MEMBER_MALFORMED_CODE, fromInit, fromStep, value, template, fromRequest, rows, fromKnowledge, SideEffectsSchema, JobResourcesSchema, WORKFLOW_ARM_SUBRUN_ID, WORKSPACE_TEMPLATE_EXPR_RE, SLEEP_UNTIL_REPLACEMENT, WORKFLOW_CAPS_DEFAULT, WORKFLOW_STEP_DEFAULT_TIMEOUT_SECONDS, WORKFLOW_AGENT_DEFAULT_TIMEOUT_SECONDS, WORKFLOW_JOB_DEFAULT_TIMEOUT_SECONDS, WORKFLOW_FOREACH_DEFAULT_CONCURRENCY, WORKFLOW_FOREACH_DEFAULT_MAX_ITEMS, WORKFLOW_LOOP_DEFAULT_MAX_ITERATIONS, WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS, WORKFLOW_SIGNAL_DEFAULT_SOURCES, clone, CONNECTION_ID_HEX_RE, WORKFLOW_JOB_TOOLS, WORKFLOW_JOB_MAX_WORKTREE_ARMS, workspaceOf, mountsWorkspace, isJobTier, jobToolsOf, schemaIsArray, isHitlNode, isSingleStep, singleId, armId, TEMPLATE_STEP_REF, EDITABLE_PATH_RE, PREDICATE_OPS, isPredicateScalar, GRAPH_HASH_PREFIX, WorkflowPlanError, isArmStep, armStepId, armStepKind, joinIdOf, containerIdOf, PATH_PLACEHOLDER, MISSING, stepIdOf, cmp, eq, ne, gt, gte, lt, lte, inSet, notIn, exists, notExists, truthy, falsy, and, or, not, CONTINUED_FAILURE_TAG, CONTINUED_FAILURE_DEFAULT_CODE, CONTINUED_FAILURE_OUTPUT_SCHEMA, CONTINUED_FAILURE_LEAF_PATHS, isHitlNode2, nodeIdOf, GOAL_JUDGE_STEP_ID, NON_LEAF_KINDS, CONDITIONAL_JOIN_ID, branchArmId, canonical, sortKeys, JOIN, entryOfJoin, FORCE_CANCEL_STALE_MS, TERMINAL, IN_FLIGHT, n, STEP_ERROR_DETAIL_KEYS, STEP_ERROR_DETAIL_MAX_BYTES, DETAIL_MAX_DEPTH, DETAIL_MAX_ITEMS, MAX_HOLIDAYS, MAX_WALK_DAYS, HHMM, YMD, MS_PER_MIN, MS_PER_DAY, MON_FRI, supportedTz, fmtCache, WEEKDAYS, JSON_PATCH_OPS, JSON_PATCH_MAX_OPS, JSON_PATCH_MAX_VALUE_BYTES, JSON_PATCH_MAX_TOTAL_BYTES, SEGMENT_RE, APPROVER_SPEC_MAX_USERS, ESCALATION_MAX_HOPS, TemplateBindingSchema, ApproverSpecSchema, FourEyesSchema, EscalationHopSchema, TerminalOutcomeSchema, ApprovalOnTimeoutSchema, APPROVER_SPEC_SHAPES, APPROVER_WRITTEN_MAX, USER_ID_SHAPED_RE, BINDING_ROOTS, WORKFLOW_ENV_OVERLAY_MAX_KEYS, WORKFLOW_ENV_OVERLAY_MAX_VALUE_BYTES, WORKFLOW_ENV_TEMPLATE_SECRET_KEY_RE, isEnvRef, looksLikeEmbeddedJson, ZERO, isRecord2;
 var init_dist2 = __esm({
   "../workflow-graph/dist/index.mjs"() {
     "use strict";
     init_dist();
     init_dist();
+    init_dist();
+    init_dist();
+    init_dist();
+    init_dist();
+    init_dist();
     __defProp3 = Object.defineProperty;
     __name3 = /* @__PURE__ */ __name((target, value22) => __defProp3(target, "name", { value: value22, configurable: true }), "__name");
-    WORKFLOW_SIDE_EFFECTS = [
-      "none",
-      "external"
+    WorkflowTemplateError = class extends Error {
+      static {
+        __name(this, "WorkflowTemplateError");
+      }
+      static {
+        __name3(this, "WorkflowTemplateError");
+      }
+      placeholder;
+      constructor(message, placeholder) {
+        super(message), this.placeholder = placeholder;
+        this.name = "WorkflowTemplateError";
+      }
+    };
+    __name(isMapConfigObject, "isMapConfigObject");
+    __name3(isMapConfigObject, "isMapConfigObject");
+    __name(parseMapConfig, "parseMapConfig");
+    __name3(parseMapConfig, "parseMapConfig");
+    __name(mapConfigWire, "mapConfigWire");
+    __name3(mapConfigWire, "mapConfigWire");
+    TEMPLATE_PLACEHOLDER = /\$\{([^}]*)\}/g;
+    TEMPLATE_NAMESPACES = [
+      "initData",
+      "state",
+      "requestContext",
+      "stepResults"
     ];
-    WORKFLOW_JOB_RESOURCES = [
-      "small",
-      "medium",
-      "large"
+    __name(describeBadPlaceholder, "describeBadPlaceholder");
+    __name3(describeBadPlaceholder, "describeBadPlaceholder");
+    __name(parseTemplatePlaceholder, "parseTemplatePlaceholder");
+    __name3(parseTemplatePlaceholder, "parseTemplatePlaceholder");
+    __name(traverseMappingPath, "traverseMappingPath");
+    __name3(traverseMappingPath, "traverseMappingPath");
+    __name(stringifyTemplateValue, "stringifyTemplateValue");
+    __name3(stringifyTemplateValue, "stringifyTemplateValue");
+    __name(escapeFence, "escapeFence");
+    __name3(escapeFence, "escapeFence");
+    __name(fenceBlock, "fenceBlock");
+    __name3(fenceBlock, "fenceBlock");
+    __name(renderTemplate, "renderTemplate");
+    __name3(renderTemplate, "renderTemplate");
+    __name(isMapDescriptor, "isMapDescriptor");
+    __name3(isMapDescriptor, "isMapDescriptor");
+    MAP_DESCRIPTOR_KEYS = [
+      "step",
+      "path",
+      "initData",
+      "value",
+      "template",
+      "requestContextPath",
+      "knowledge"
     ];
+    MAP_MEMBER_MALFORMED_CODE = "map-member-malformed";
+    __name(malformedMapMembers, "malformedMapMembers");
+    __name3(malformedMapMembers, "malformedMapMembers");
+    __name(mapMemberMalformedMessage, "mapMemberMalformedMessage");
+    __name3(mapMemberMalformedMessage, "mapMemberMalformedMessage");
+    __name(resolveDescriptor, "resolveDescriptor");
+    __name3(resolveDescriptor, "resolveDescriptor");
+    __name(resolveMapping, "resolveMapping");
+    __name3(resolveMapping, "resolveMapping");
+    fromInit = /* @__PURE__ */ __name3((path3) => ({
+      initData: true,
+      path: path3
+    }), "fromInit");
+    fromStep = /* @__PURE__ */ __name3((s, path3 = "") => {
+      const idOf = /* @__PURE__ */ __name3((x) => typeof x === "string" ? x : x.id, "idOf");
+      return {
+        step: Array.isArray(s) ? s.map(idOf) : idOf(s),
+        path: path3
+      };
+    }, "fromStep");
+    value = /* @__PURE__ */ __name3((v) => ({
+      value: v
+    }), "value");
+    template = /* @__PURE__ */ __name3((s) => ({
+      template: s
+    }), "template");
+    fromRequest = /* @__PURE__ */ __name3((path3) => ({
+      requestContextPath: path3
+    }), "fromRequest");
+    rows = /* @__PURE__ */ __name3((s, path3, page) => ({
+      step: typeof s === "string" ? s : s.id,
+      path: path3,
+      rows: page
+    }), "rows");
+    fromKnowledge = /* @__PURE__ */ __name3((k) => ({
+      knowledge: k
+    }), "fromKnowledge");
     SideEffectsSchema = z4.enum(WORKFLOW_SIDE_EFFECTS);
     JobResourcesSchema = z4.enum(WORKFLOW_JOB_RESOURCES);
     WORKFLOW_ARM_SUBRUN_ID = "$arm";
+    WORKSPACE_TEMPLATE_EXPR_RE = /^\$\{\s*(?:initData|input)\.([^}]+?)\s*\}$/;
+    __name(workspaceTemplatePath, "workspaceTemplatePath");
+    __name3(workspaceTemplatePath, "workspaceTemplatePath");
+    __name(retryBackoffs, "retryBackoffs");
+    __name3(retryBackoffs, "retryBackoffs");
     SLEEP_UNTIL_REPLACEMENT = Object.freeze({
       type: "sleep",
       duration: 6e4
@@ -4795,6 +5704,8 @@ var init_dist2 = __esm({
     __name3(fillPolicy, "fillPolicy");
     __name(fillSingle, "fillSingle");
     __name3(fillSingle, "fillSingle");
+    __name(fillHitl, "fillHitl");
+    __name3(fillHitl, "fillHitl");
     __name(fillArm, "fillArm");
     __name3(fillArm, "fillArm");
     __name(fillEntry, "fillEntry");
@@ -4838,11 +5749,15 @@ var init_dist2 = __esm({
       if (t === void 0) return void 0;
       return Array.isArray(t) ? t.includes("array") : t === "array";
     }, "schemaIsArray");
+    isHitlNode = /* @__PURE__ */ __name3((n2) => isWorkflowHitlEntryType(n2.type), "isHitlNode");
+    isSingleStep = /* @__PURE__ */ __name3((n2) => !isHitlNode(n2), "isSingleStep");
     singleId = /* @__PURE__ */ __name3((s) => s.type === "step" ? s.step.id : s.id, "singleId");
     armId = /* @__PURE__ */ __name3((a) => a.type === "mapping" ? a.id : singleId(a), "armId");
     TEMPLATE_STEP_REF = /\$\{\s*stepResults\.([A-Za-z0-9_\-]+)/g;
     __name(templateStepRefs, "templateStepRefs");
     __name3(templateStepRefs, "templateStepRefs");
+    __name(readMapConfig, "readMapConfig");
+    __name3(readMapConfig, "readMapConfig");
     __name(mapConfigStepRefs, "mapConfigStepRefs");
     __name3(mapConfigStepRefs, "mapConfigStepRefs");
     __name(nodeStepRefs, "nodeStepRefs");
@@ -4892,14 +5807,9 @@ var init_dist2 = __esm({
         this.name = "WorkflowPlanError";
       }
     };
-    SINGLE_STEP_KINDS = {
-      step: "code",
-      agent: "agent",
-      tool: "tool",
-      workflow: "subrun"
-    };
-    isSingleStep = /* @__PURE__ */ __name3((e) => e.type === "step" || e.type === "agent" || e.type === "tool" || e.type === "workflow", "isSingleStep");
-    singleStepId = /* @__PURE__ */ __name3((e) => e.type === "step" ? e.step.id : e.id, "singleStepId");
+    isArmStep = /* @__PURE__ */ __name3((e) => isWorkflowArmEntryType(e.type), "isArmStep");
+    armStepId = /* @__PURE__ */ __name3((e) => e.type === "step" ? e.step.id : e.id, "armStepId");
+    armStepKind = /* @__PURE__ */ __name3((e) => WORKFLOW_ARM_ENTRY_STEP_KINDS[e.type], "armStepKind");
     joinIdOf = /* @__PURE__ */ __name3((entryId) => `${entryId}.join`, "joinIdOf");
     containerIdOf = /* @__PURE__ */ __name3((type, entryIndex) => `${type}@${entryIndex}`, "containerIdOf");
     __name(compilePlan, "compilePlan");
@@ -4994,74 +5904,6 @@ var init_dist2 = __esm({
       op: "not",
       arg
     }), "not");
-    WorkflowTemplateError = class extends Error {
-      static {
-        __name(this, "WorkflowTemplateError");
-      }
-      static {
-        __name3(this, "WorkflowTemplateError");
-      }
-      placeholder;
-      constructor(message, placeholder) {
-        super(message), this.placeholder = placeholder;
-        this.name = "WorkflowTemplateError";
-      }
-    };
-    __name(parseMapConfig, "parseMapConfig");
-    __name3(parseMapConfig, "parseMapConfig");
-    TEMPLATE_PLACEHOLDER = /\$\{([^}]*)\}/g;
-    TEMPLATE_NAMESPACES = [
-      "initData",
-      "state",
-      "requestContext",
-      "stepResults"
-    ];
-    __name(describeBadPlaceholder, "describeBadPlaceholder");
-    __name3(describeBadPlaceholder, "describeBadPlaceholder");
-    __name(parseTemplatePlaceholder, "parseTemplatePlaceholder");
-    __name3(parseTemplatePlaceholder, "parseTemplatePlaceholder");
-    __name(traverseMappingPath, "traverseMappingPath");
-    __name3(traverseMappingPath, "traverseMappingPath");
-    __name(stringifyTemplateValue, "stringifyTemplateValue");
-    __name3(stringifyTemplateValue, "stringifyTemplateValue");
-    __name(escapeFence, "escapeFence");
-    __name3(escapeFence, "escapeFence");
-    __name(fenceBlock, "fenceBlock");
-    __name3(fenceBlock, "fenceBlock");
-    __name(renderTemplate, "renderTemplate");
-    __name3(renderTemplate, "renderTemplate");
-    __name(resolveDescriptor, "resolveDescriptor");
-    __name3(resolveDescriptor, "resolveDescriptor");
-    __name(resolveMapping, "resolveMapping");
-    __name3(resolveMapping, "resolveMapping");
-    fromInit = /* @__PURE__ */ __name3((path3) => ({
-      initData: true,
-      path: path3
-    }), "fromInit");
-    fromStep = /* @__PURE__ */ __name3((s, path3 = "") => {
-      const idOf = /* @__PURE__ */ __name3((x) => typeof x === "string" ? x : x.id, "idOf");
-      return {
-        step: Array.isArray(s) ? s.map(idOf) : idOf(s),
-        path: path3
-      };
-    }, "fromStep");
-    value = /* @__PURE__ */ __name3((v) => ({
-      value: v
-    }), "value");
-    template = /* @__PURE__ */ __name3((s) => ({
-      template: s
-    }), "template");
-    fromRequest = /* @__PURE__ */ __name3((path3) => ({
-      requestContextPath: path3
-    }), "fromRequest");
-    rows = /* @__PURE__ */ __name3((s, path3, page) => ({
-      step: typeof s === "string" ? s : s.id,
-      path: path3,
-      rows: page
-    }), "rows");
-    fromKnowledge = /* @__PURE__ */ __name3((k) => ({
-      knowledge: k
-    }), "fromKnowledge");
     CONTINUED_FAILURE_TAG = "continued_failure";
     CONTINUED_FAILURE_DEFAULT_CODE = "step_failed";
     CONTINUED_FAILURE_OUTPUT_SCHEMA = Object.freeze({
@@ -5113,6 +5955,7 @@ var init_dist2 = __esm({
     __name3(continuedFailureValue, "continuedFailureValue");
     __name(isContinuedFailureValue, "isContinuedFailureValue");
     __name3(isContinuedFailureValue, "isContinuedFailureValue");
+    isHitlNode2 = /* @__PURE__ */ __name3((n2) => isWorkflowHitlEntryType(n2.type), "isHitlNode");
     __name(lowerContainerArm, "lowerContainerArm");
     __name3(lowerContainerArm, "lowerContainerArm");
     nodeIdOf = /* @__PURE__ */ __name3((n2) => n2.type === "step" ? n2.step.id : n2.id, "nodeIdOf");
@@ -5120,6 +5963,24 @@ var init_dist2 = __esm({
     __name3(entryIds, "entryIds");
     __name(resolvePlacements, "resolvePlacements");
     __name3(resolvePlacements, "resolvePlacements");
+    GOAL_JUDGE_STEP_ID = "__goal_judge";
+    NON_LEAF_KINDS = /* @__PURE__ */ new Set([
+      "foreach",
+      "branch"
+    ]);
+    CONDITIONAL_JOIN_ID = /^conditional@\d+\.join$/;
+    __name(isConditionalJoinId, "isConditionalJoinId");
+    __name3(isConditionalJoinId, "isConditionalJoinId");
+    __name(isPlainObject, "isPlainObject");
+    __name3(isPlainObject, "isPlainObject");
+    __name(leafValue, "leafValue");
+    __name3(leafValue, "leafValue");
+    __name(runOutputLeaves, "runOutputLeaves");
+    __name3(runOutputLeaves, "runOutputLeaves");
+    __name(deriveRunOutput, "deriveRunOutput");
+    __name3(deriveRunOutput, "deriveRunOutput");
+    __name(subrunSettledOutput, "subrunSettledOutput");
+    __name3(subrunSettledOutput, "subrunSettledOutput");
     __name(seedLedgerFromRun, "seedLedgerFromRun");
     __name3(seedLedgerFromRun, "seedLedgerFromRun");
     branchArmId = /* @__PURE__ */ __name3((arm) => arm.type === "step" ? arm.step.id : arm.id, "branchArmId");
@@ -5168,14 +6029,63 @@ var init_dist2 = __esm({
     n = /* @__PURE__ */ __name3((v) => typeof v === "number" && Number.isFinite(v) ? v : 0, "n");
     __name(runCounts, "runCounts");
     __name3(runCounts, "runCounts");
+    __name(isPricedStepReceipt, "isPricedStepReceipt");
+    __name3(isPricedStepReceipt, "isPricedStepReceipt");
+    __name(receiptEngine, "receiptEngine");
+    __name3(receiptEngine, "receiptEngine");
+    __name(receiptTier, "receiptTier");
+    __name3(receiptTier, "receiptTier");
+    __name(stepBillingView, "stepBillingView");
+    __name3(stepBillingView, "stepBillingView");
     __name(runUsage, "runUsage");
     __name3(runUsage, "runUsage");
+    __name(runBudgetCap, "runBudgetCap");
+    __name3(runBudgetCap, "runBudgetCap");
+    __name(runBudgetRemaining, "runBudgetRemaining");
+    __name3(runBudgetRemaining, "runBudgetRemaining");
     __name(runCancelView, "runCancelView");
     __name3(runCancelView, "runCancelView");
     __name(runWorkspaceView, "runWorkspaceView");
     __name3(runWorkspaceView, "runWorkspaceView");
     __name(toWorkflowRunSummary, "toWorkflowRunSummary");
     __name3(toWorkflowRunSummary, "toWorkflowRunSummary");
+    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"
+    ];
+    STEP_ERROR_DETAIL_MAX_BYTES = 8 * 1024;
+    DETAIL_MAX_DEPTH = 4;
+    DETAIL_MAX_ITEMS = 100;
+    __name(scrubDetailValue, "scrubDetailValue");
+    __name3(scrubDetailValue, "scrubDetailValue");
+    __name(stepErrorDetail, "stepErrorDetail");
+    __name3(stepErrorDetail, "stepErrorDetail");
     MAX_HOLIDAYS = 366;
     MAX_WALK_DAYS = 400;
     HHMM = /^([01]\d|2[0-3]):([0-5]\d)$/;
@@ -5321,6 +6231,18 @@ var init_dist2 = __esm({
         EscalationHopSchema
       ])).min(1).max(ESCALATION_MAX_HOPS + 1)
     ]);
+    APPROVER_SPEC_SHAPES = [
+      "'creator'",
+      "'org-admins'",
+      "{users:[userId, \u2026]}",
+      "{role:roleName}",
+      "{group:groupName}",
+      "{governance:{policyId}}"
+    ];
+    APPROVER_WRITTEN_MAX = 120;
+    USER_ID_SHAPED_RE = /^[^\s@]{1,128}$/;
+    __name(describeApproverSpecRefusal, "describeApproverSpecRefusal");
+    __name3(describeApproverSpecRefusal, "describeApproverSpecRefusal");
     BINDING_ROOTS = [
       "initData",
       "stepResults",
@@ -5476,7 +6398,12 @@ function materializeEntry(entry, steps) {
   }
 }
 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);
 }
 function createWorkflow(cfg) {
@@ -5510,10 +6437,11 @@ function defineWorkflow(cfg, build) {
   if (!(wf instanceof LuaWorkflow)) throw new LuaWorkflowBuildError("invalid-envelope", "defineWorkflow: the build callback must return `wf\u2026.commit()`");
   return wf;
 }
-var init2, state2, lit2, eq2, ne2, gt2, gte2, lt2, lte2, inSet2, notIn2, exists2, notExists2, truthy2, falsy2, and2, or2, not2, fromInit2, fromStep2, value2, template2, fromRequest2, rows2, fromKnowledge2, LuaWorkflowBuildError, STEP_ID_RE, WORKFLOW_NAME_RE, WORKFLOW_MAX_PARALLEL_ARMS, WORKFLOW_MAX_FOREACH_CONCURRENCY, WORKFLOW_MAX_FOREACH_ITEMS, WORKFLOW_WORKER_MAX_TIMEOUT_SECONDS, WORKFLOW_JOB_SEGMENT_MAX_SECONDS, WORKFLOW_JOB_MAX_TIMEOUT_SECONDS, WORKFLOW_LOOP_INTERVAL_MAX_SECONDS, WORKFLOW_FOREACH_RATE_MAX_PER_SECOND, WORKFLOW_SPECIALIST_ROLE_MAX_INSTRUCTIONS, WORKFLOW_DEFAULT_MAX_DURATION_SECONDS, WORKFLOW_HITL_MAX_DURATION_SECONDS, SECRET_KEY_RE, isZod, defined, templateText, assertNoClosure, assertPredicate, assertRetry, assertTimeout, envRefKeys, refToDescriptor, __workflowCommitHook, LuaWorkflow, WorkflowBuilderImpl, EDITABLE_PATH_RE2;
+var init2, state2, lit2, eq2, ne2, gt2, gte2, lt2, lte2, inSet2, notIn2, exists2, notExists2, truthy2, falsy2, and2, or2, not2, fromInit2, fromStep2, value2, template2, fromRequest2, rows2, fromKnowledge2, LuaWorkflowBuildError, STEP_ID_RE, WORKFLOW_NAME_RE, WORKFLOW_MAX_PARALLEL_ARMS, WORKFLOW_MAX_FOREACH_CONCURRENCY, WORKFLOW_MAX_FOREACH_ITEMS, WORKFLOW_WORKER_MAX_TIMEOUT_SECONDS, WORKFLOW_JOB_SEGMENT_MAX_SECONDS, WORKFLOW_JOB_MAX_TIMEOUT_SECONDS, WORKFLOW_LOOP_INTERVAL_MAX_SECONDS, WORKFLOW_FOREACH_RATE_MAX_PER_SECOND, WORKFLOW_SPECIALIST_ROLE_MAX_INSTRUCTIONS, WORKFLOW_DEFAULT_MAX_DURATION_SECONDS, WORKFLOW_HITL_MAX_DURATION_SECONDS, SECRET_KEY_RE, isZod, defined, templateText, assertNoClosure, assertPredicate, assertRetry, assertTimeout, envRefKeys, refToDescriptor, __workflowCommitHook, LuaWorkflow, isHitlEntry, WorkflowBuilderImpl, EDITABLE_PATH_RE2;
 var init_workflow = __esm({
   "src/types/workflow.ts"() {
     "use strict";
+    init_dist();
     init_dist2();
     __name(createStep, "createStep");
     __name(step2, "step");
@@ -5596,7 +6524,8 @@ var init_workflow = __esm({
     }, "assertPredicate");
     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 (typeof r.maxAttempts === "number" && r.maxAttempts > WORKFLOW_RETRY_MAX_ATTEMPTS) throw new LuaWorkflowBuildError("cap-exceeded", `"${id}": ${workflowRetryMaxAttemptsMessage(r.maxAttempts)}`);
+      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`);
@@ -5718,6 +6647,7 @@ var init_workflow = __esm({
     };
     __name(stepNodeOf, "stepNodeOf");
     __name(materializeEntry, "materializeEntry");
+    isHitlEntry = /* @__PURE__ */ __name((n2) => isWorkflowHitlEntryType(n2?.type), "isHitlEntry");
     __name(graphHasHitl, "graphHasHitl");
     WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
       static {
@@ -5770,7 +6700,6 @@ var init_workflow = __esm({
           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);
@@ -5788,8 +6717,9 @@ var init_workflow = __esm({
         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)
@@ -5990,17 +6920,13 @@ var init_workflow = __esm({
         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.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`);
-        }
-        if (opts.maxMessages !== void 0) {
-          if (tier !== "job") throw new LuaWorkflowBuildError("max-turns-requires-job-tier", `"${id}": maxMessages is only legal on a tier:'job' agent step`);
-          if (!Number.isInteger(opts.maxMessages) || opts.maxMessages < 1 || opts.maxMessages > 5e3) throw new LuaWorkflowBuildError("max-turns-invalid", `"${id}": maxMessages must be an integer 1..5000`);
-        }
-        if (opts.maxInputTokens !== void 0) {
-          if (tier !== "job") throw new LuaWorkflowBuildError("max-turns-requires-job-tier", `"${id}": maxInputTokens is only legal on a tier:'job' agent step`);
-          if (!Number.isInteger(opts.maxInputTokens) || opts.maxInputTokens < 1e6 || opts.maxInputTokens > 5e8) throw new LuaWorkflowBuildError("max-turns-invalid", `"${id}": maxInputTokens must be an integer 1000000..500000000`);
+        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,
@@ -6152,8 +7078,8 @@ var init_workflow = __esm({
           itemTimeout: opts.itemTimeout
         });
         return this.push({
-          kind: "entry",
-          entry: node
+          kind: "declare",
+          node
         });
       }
       waitForSignal(id, opts) {
@@ -6171,12 +7097,13 @@ var init_workflow = __esm({
           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") {
@@ -6198,7 +7125,8 @@ var init_workflow = __esm({
           id,
           workflowId: name,
           input,
-          workspace: opts?.workspace
+          workspace: opts?.workspace,
+          retry: opts?.retry
         });
         return this.push({
           kind: "declare",
@@ -6212,7 +7140,7 @@ var init_workflow = __esm({
         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 })/workflow(\u2026) 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`);
@@ -6366,6 +7294,74 @@ var init_auth_error = __esm({
   }
 });
 
+// src/errors/cli.error.ts
+function isAccessDeniedError(error) {
+  if (CliError.isCliError(error)) return error.statusCode === 403;
+  return error instanceof Error && error.message.startsWith("Access denied (403)");
+}
+var CLI_EXIT, CliError;
+var init_cli_error = __esm({
+  "src/errors/cli.error.ts"() {
+    "use strict";
+    init_auth_error();
+    CLI_EXIT = {
+      OK: 0,
+      ERROR: 1,
+      USAGE: 2,
+      NOT_FOUND: 3,
+      AUTH: 9,
+      FORBIDDEN: 10,
+      UNAVAILABLE: 11
+    };
+    CliError = class _CliError extends Error {
+      static {
+        __name(this, "CliError");
+      }
+      isCliError = true;
+      code;
+      exitCode;
+      hint;
+      statusCode;
+      constructor(code, message, options = {}) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.exitCode = options.exitCode ?? CLI_EXIT.ERROR;
+        this.hint = options.hint;
+        this.statusCode = options.statusCode;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _CliError);
+      }
+      /** Bad arguments, an unknown action, no project — exit 2. */
+      static usage(message, hint) {
+        return new _CliError("usage", message, {
+          exitCode: CLI_EXIT.USAGE,
+          hint
+        });
+      }
+      /** The named thing does not exist — exit 3. */
+      static notFound(message, hint) {
+        return new _CliError("not_found", message, {
+          exitCode: CLI_EXIT.NOT_FOUND,
+          hint,
+          statusCode: 404
+        });
+      }
+      /** The credential may not do this — exit 10. */
+      static forbidden(message, hint) {
+        return new _CliError("forbidden", message, {
+          exitCode: CLI_EXIT.FORBIDDEN,
+          hint,
+          statusCode: 403
+        });
+      }
+      static isCliError(error) {
+        return error instanceof _CliError || typeof error === "object" && error !== null && error.isCliError === true;
+      }
+    };
+    __name(isAccessDeniedError, "isAccessDeniedError");
+  }
+});
+
 // src/utils/package-root.ts
 import { readFileSync, existsSync } from "fs";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -6610,7 +7606,7 @@ var init_firebase_session_store = __esm({
     }), "currentFirebaseSessionEnvironment");
     __name(environmentKey, "environmentKey");
     __name(isMissing, "isMissing");
-    wait = /* @__PURE__ */ __name((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)), "wait");
+    wait = /* @__PURE__ */ __name((milliseconds) => new Promise((resolve3) => setTimeout(resolve3, milliseconds)), "wait");
     FirebaseSessionStore = class {
       static {
         __name(this, "FirebaseSessionStore");
@@ -6878,13 +7874,13 @@ async function* parseSseStream(body, signal) {
       buffer += decoder.decode(value3, {
         stream: true
       });
-      let sep = buffer.search(/\r?\n\r?\n/);
-      while (sep !== -1) {
-        const block = buffer.slice(0, sep);
-        buffer = buffer.slice(sep).replace(/^\r?\n\r?\n/, "");
+      let sep4 = buffer.search(/\r?\n\r?\n/);
+      while (sep4 !== -1) {
+        const block = buffer.slice(0, sep4);
+        buffer = buffer.slice(sep4).replace(/^\r?\n\r?\n/, "");
         const frame = flush(block);
         if (frame) yield frame;
-        sep = buffer.search(/\r?\n\r?\n/);
+        sep4 = buffer.search(/\r?\n\r?\n/);
       }
     }
     if (buffer.trim()) {
@@ -6892,6 +7888,10 @@ async function* parseSseStream(body, signal) {
       if (frame) yield frame;
     }
   } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
     try {
       reader.releaseLock();
     } catch {
@@ -6921,6 +7921,7 @@ var init_http_client = __esm({
     "use strict";
     init_dist();
     init_auth_error();
+    init_cli_error();
     init_lua_fetch();
     init_request_credential();
     DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
@@ -6984,7 +7985,7 @@ var init_http_client = __esm({
           if (AuthenticationError.isAuthenticationError(error)) {
             throw error;
           }
-          if (error instanceof Error && error.message.startsWith("Access denied (403)")) {
+          if (isAccessDeniedError(error)) {
             throw error;
           }
           if (error instanceof DOMException && error.name === "AbortError") {
@@ -7032,8 +8033,11 @@ var init_http_client = __esm({
         }
         if (response.status === 403) {
           const detail = errorData.message || "You do not have permission to access this resource.";
-          throw new Error(`Access denied (403): ${detail}
-Check that your Lua login has access to this agent or organization.`);
+          throw new CliError("forbidden", `Access denied (403): ${detail}`, {
+            exitCode: CLI_EXIT.FORBIDDEN,
+            statusCode: 403,
+            hint: "Check that your Lua login has access to this agent or organization."
+          });
         }
         return {
           success: false,
@@ -7103,7 +8107,7 @@ Check that your Lua login has access to this agent or organization.`);
           if (attempt < maxRetries) {
             const serverDelay = Number(lastResult?.error?.retryAfterSeconds ?? 0) * 1e3;
             const backoff = Math.max(this.calculateBackoff(attempt), serverDelay);
-            await new Promise((resolve) => setTimeout(resolve, backoff));
+            await new Promise((resolve3) => setTimeout(resolve3, backoff));
           }
         }
         return lastResult;
@@ -7152,7 +8156,7 @@ Check that your Lua login has access to this agent or organization.`);
       async httpPostCoreDrainRetry(url, data, headers) {
         const first = await this.httpPostOnce(url, data, headers);
         if (!isCoreDrainApiError(first.error)) return first;
-        await new Promise((resolve) => setTimeout(resolve, coreDrainApiRetryDelayMs(first.error)));
+        await new Promise((resolve3) => setTimeout(resolve3, coreDrainApiRetryDelayMs(first.error)));
         return this.httpPostOnce(url, data, headers);
       }
       /**
@@ -7275,6 +8279,7 @@ var init_auth = __esm({
     init_auth_api_service();
     init_constants();
     init_auth_error();
+    init_cli_error();
   }
 });
 
@@ -7502,6 +8507,9 @@ function buildSourceArchive(files) {
   const gz = zlib.gzipSync(Buffer.from(json, "utf-8"));
   return gz.toString("base64");
 }
+function getPrimitivesByKind(manifest, kind) {
+  return manifest.primitives.filter((p) => p.kind === kind);
+}
 function findPrimitive(manifest, name, kind) {
   return manifest.primitives.find((p) => {
     if (kind && p.kind !== kind) return false;
@@ -7522,15 +8530,565 @@ var init_artifact_loader = __esm({
     __name(loadOriginalSource, "loadOriginalSource");
     __name(normalizeEntryFile, "normalizeEntryFile");
     __name(buildSourceArchive, "buildSourceArchive");
+    __name(getPrimitivesByKind, "getPrimitivesByKind");
     __name(findPrimitive, "findPrimitive");
   }
 });
 
+// ../shared-source-sync/dist/index.mjs
+import { createHash as createHash4 } from "crypto";
+import { extname } from "path";
+import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join4, sep } from "path";
+import { gunzipSync, gzipSync } from "zlib";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync22, statSync as statSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join22, resolve, sep as sep2 } from "path";
+import { posix } from "path";
+import { mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync32, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname22, join as join32, resolve as resolve2, sep as sep3 } from "path";
+import { gunzipSync as gunzipSync2, gzipSync as gzipSync2 } from "zlib";
+function hashContentTruncated(content) {
+  return createHash4("sha256").update(content).digest("hex").slice(0, FILE_HASH_LENGTH);
+}
+function sha256Hex(content) {
+  return createHash4("sha256").update(content).digest("hex");
+}
+function matchesFileHash(hash, plaintext) {
+  if (!/^(?:[a-f0-9]{16}|[a-f0-9]{64})$/.test(hash)) return false;
+  if (sha256Hex(plaintext).startsWith(hash)) return true;
+  return sha256Hex(plaintext.toString("utf-8")).startsWith(hash);
+}
+function combineFileHashes(files) {
+  const sorted = [
+    ...files
+  ].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return sha256Hex(sorted.map((f) => f.hash).join("|"));
+}
+function shouldSkipDirectory(name) {
+  return SKIP_DIRECTORIES.has(name);
+}
+function shouldSkipFile(filePathOrName) {
+  return filePathOrName.includes("node_modules") || filePathOrName.includes(".test.") || filePathOrName.includes(".spec.") || filePathOrName.includes("__tests__") || filePathOrName.endsWith(".d.ts") || filePathOrName.endsWith(".map") || filePathOrName.startsWith(".") || filePathOrName === "package-lock.json" || filePathOrName === "yarn.lock" || filePathOrName === "pnpm-lock.yaml";
+}
+function classifyFile(relPath) {
+  return KIND_BY_EXT[extname(relPath)] ?? "other";
+}
+function walkWorkspace(rootDir, opts = {}) {
+  const maxBytes = opts.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+  const refs = [];
+  const contentByHash = /* @__PURE__ */ new Map();
+  let totalSize = 0;
+  const visit = /* @__PURE__ */ __name4((relPrefix) => {
+    const absDir = relPrefix ? join4(rootDir, relPrefix) : rootDir;
+    let entries;
+    try {
+      entries = readdirSync(absDir, {
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (shouldSkipDirectory(entry.name)) continue;
+        if (shouldSkipFile(entry.name)) continue;
+        visit(relPrefix ? `${relPrefix}${sep}${entry.name}` : entry.name);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (shouldSkipFile(entry.name)) continue;
+      const rel = (relPrefix ? `${relPrefix}${sep}${entry.name}` : entry.name).split(sep).join("/");
+      const abs = join4(rootDir, rel);
+      let stats;
+      try {
+        stats = statSync(abs);
+      } catch {
+        continue;
+      }
+      if (stats.size > maxBytes) continue;
+      let content;
+      try {
+        content = readFileSync3(abs);
+      } catch {
+        continue;
+      }
+      const hash = hashContentTruncated(content.toString("utf-8"));
+      refs.push({
+        relativePath: rel,
+        hash,
+        size: stats.size,
+        type: classifyFile(rel)
+      });
+      if (!contentByHash.has(hash)) contentByHash.set(hash, content);
+      totalSize += stats.size;
+    }
+  }, "visit");
+  visit("");
+  refs.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  const projectHash = combineFileHashes(refs);
+  return {
+    files: refs,
+    projectHash,
+    totalSize,
+    contentByHash
+  };
+}
+async function uploadBlobs(opts) {
+  const fetchFn = opts.fetch ?? fetch;
+  const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
+  const hashes = Object.keys(opts.uploadUrls);
+  for (let i = 0; i < hashes.length; i += concurrency) {
+    const batch = hashes.slice(i, i + concurrency);
+    await Promise.all(batch.map(async (hash) => {
+      const buf = opts.contentByHash.get(hash);
+      if (!buf) {
+        throw new Error(`uploadBlobs: no content for hash ${hash.slice(0, 12)}\u2026`);
+      }
+      const compressed = gzipSync(buf);
+      const res = await fetchFn(opts.uploadUrls[hash], {
+        method: "PUT",
+        body: compressed,
+        headers: {
+          "Content-Type": "application/octet-stream"
+        }
+      });
+      if (!res.ok) {
+        throw new Error(`S3 upload failed for ${hash.slice(0, 12)}\u2026: ${res.status} ${res.statusText}`);
+      }
+    }));
+  }
+  return hashes.length;
+}
+function decodeBlob(buf) {
+  if (buf.length >= 2 && buf[0] === 31 && buf[1] === 139) {
+    try {
+      return gunzipSync(buf);
+    } catch {
+      return buf;
+    }
+  }
+  return buf;
+}
+function verifyDownloaded(hash, plaintext) {
+  if (!matchesFileHash(hash, plaintext)) {
+    throw new Error(`Blob ${hash.slice(0, 12)}\u2026 failed integrity verification: its content does not hash to its key (refusing to restore it)`);
+  }
+  return plaintext;
+}
+async function downloadBlobs(opts) {
+  const fetchFn = opts.fetch ?? fetch;
+  const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
+  const out = /* @__PURE__ */ new Map();
+  const entries = Object.entries(opts.urls);
+  for (let i = 0; i < entries.length; i += concurrency) {
+    const batch = entries.slice(i, i + concurrency);
+    const downloaded = await Promise.all(batch.map(async ([hash, url]) => {
+      const res = await fetchFn(url);
+      if (!res.ok) {
+        throw new Error(`S3 download failed for ${hash.slice(0, 12)}\u2026: ${res.status} ${res.statusText}`);
+      }
+      const ab = await res.arrayBuffer();
+      const buf = Buffer.from(ab);
+      return [
+        hash,
+        verifyDownloaded(hash, decodeBlob(buf))
+      ];
+    }));
+    for (const [hash, buf] of downloaded) out.set(hash, buf);
+  }
+  return out;
+}
+function resolveBackupFileTarget(file, targetDir) {
+  const base = resolve(targetDir);
+  const sandboxed = file.external ? join22(base, ".lua", "external", file.relativePath) : join22(base, file.relativePath);
+  const resolved = resolve(sandboxed);
+  if (resolved !== base && !resolved.startsWith(base + sep2)) {
+    throw new Error(`Backup entry escapes target directory: ${file.relativePath}`);
+  }
+  return resolved;
+}
+function restoreFromBlobs(manifest, blobs, targetDir, opts = {}) {
+  let filesWritten = 0;
+  let filesUnchanged = 0;
+  let filesSkipped = 0;
+  for (const file of manifest.files) {
+    const content = blobs.get(file.hash);
+    if (!content) {
+      throw new Error(`Blob not found for hash: ${file.hash} (${file.relativePath})`);
+    }
+    const targetPath = resolveBackupFileTarget(file, targetDir);
+    if (existsSync2(targetPath)) {
+      const sameSize = statSync2(targetPath).size === content.length;
+      if (sameSize && readFileSync22(targetPath).equals(content)) {
+        filesUnchanged++;
+        continue;
+      }
+      if (!opts.overwrite) {
+        filesSkipped++;
+        continue;
+      }
+    }
+    mkdirSync(dirname2(targetPath), {
+      recursive: true
+    });
+    writeFileSync(targetPath, content);
+    filesWritten++;
+  }
+  return {
+    filesWritten,
+    filesUnchanged,
+    filesSkipped
+  };
+}
+function normalizeWorkspaceRelativePath(value3) {
+  if (!value3 || value3.includes("\0")) return void 0;
+  const withPortableSeparators = value3.replace(/\\/g, "/");
+  if (withPortableSeparators.startsWith("/") || WINDOWS_ABSOLUTE_PATH.test(withPortableSeparators)) return void 0;
+  const normalized = posix.normalize(withPortableSeparators);
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) return void 0;
+  return normalized;
+}
+function isCredentialPersistencePath(value3) {
+  const normalized = normalizeWorkspaceRelativePath(value3);
+  return normalized !== void 0 && CREDENTIAL_PATHS.has(normalized.toLowerCase());
+}
+async function pushAgentBackup(opts) {
+  const snapshot = walkWorkspace(opts.workspaceDir, opts.walkOptions);
+  const client = new BackupHttpClient(opts.http);
+  const uniqueHashes = [
+    ...new Set(snapshot.files.map((f) => f.hash))
+  ];
+  let filesUploaded = 0;
+  if (uniqueHashes.length > 0) {
+    const checked = await client.checkBlobsExist(uniqueHashes);
+    if (checked.missing.length > 0) {
+      const urls = await client.getBlobUploadUrls(checked.missing);
+      filesUploaded = await uploadBlobs({
+        uploadUrls: urls.urls,
+        contentByHash: snapshot.contentByHash,
+        fetch: opts.http.fetch,
+        concurrency: opts.concurrency
+      });
+    }
+  }
+  const metadata = await client.saveManifest({
+    projectHash: snapshot.projectHash,
+    files: snapshot.files,
+    version: opts.version,
+    orgId: opts.orgId,
+    createdBy: opts.createdBy ?? "cli",
+    triggeredBy: opts.triggeredBy
+  });
+  return {
+    projectHash: snapshot.projectHash,
+    fileCount: snapshot.files.length,
+    filesUploaded,
+    activeVersion: metadata.activeVersion,
+    metadata,
+    files: snapshot.files
+  };
+}
+async function pullAgentBackup(opts) {
+  const client = new BackupHttpClient(opts.http);
+  const manifest = await client.getManifest();
+  const uniqueHashes = [
+    ...new Set(manifest.files.map((f) => f.hash))
+  ];
+  const blobs = uniqueHashes.length ? await (async () => {
+    const urls = await client.getBlobUrls(uniqueHashes);
+    return downloadBlobs({
+      urls: urls.urls,
+      fetch: opts.http.fetch,
+      concurrency: opts.concurrency
+    });
+  })() : /* @__PURE__ */ new Map();
+  const result = restoreFromBlobs(manifest, blobs, opts.targetDir, opts.restore);
+  return {
+    ...result,
+    manifest
+  };
+}
+function encodeWorkspaceArchive(workspaceDir) {
+  const files = {};
+  try {
+    walk2(workspaceDir, "", files);
+  } catch {
+    return null;
+  }
+  if (Object.keys(files).length === 0) return null;
+  const gz = gzipSync2(Buffer.from(JSON.stringify(files), "utf8"));
+  return gz.toString("base64");
+}
+function decodeWorkspaceArchive(archive, schemaVersion) {
+  if (schemaVersion !== void 0 && schemaVersion !== ARCHIVE_SCHEMA_VERSION) {
+    throw new Error(`Unsupported archive schema version: ${schemaVersion} (expected ${ARCHIVE_SCHEMA_VERSION})`);
+  }
+  const raw = gunzipSync2(Buffer.from(archive, "base64")).toString("utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Decoded archive is not a JSON object map");
+  }
+  return parsed;
+}
+function writeArchiveToWorkspace(workspaceDir, files) {
+  const writes = [];
+  for (const [relPath, content] of Object.entries(files)) {
+    const normalized = normalizeWorkspaceRelativePath(relPath);
+    if (!normalized) throw new Error(`Refusing to write invalid archived path: ${relPath}`);
+    if (isCredentialPersistencePath(normalized)) {
+      throw new Error(`Refusing to restore credential file: ${normalized}`);
+    }
+    writes.push({
+      path: resolve2(workspaceDir, normalized),
+      content
+    });
+  }
+  for (const write of writes) {
+    mkdirSync2(dirname22(write.path), {
+      recursive: true
+    });
+    writeFileSync2(write.path, write.content, "utf8");
+  }
+}
+function walk2(root, prefix, out) {
+  const dir = prefix ? join32(root, prefix) : root;
+  const entries = readdirSync2(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (shouldSkipDirectory(entry.name) || ARCHIVE_ONLY_SKIP_DIRECTORIES.has(entry.name) || shouldSkipFile(entry.name)) continue;
+      walk2(root, prefix ? `${prefix}${sep3}${entry.name}` : entry.name, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (shouldSkipFile(entry.name)) continue;
+    const relPath = (prefix ? `${prefix}${sep3}${entry.name}` : entry.name).split(sep3).join("/");
+    const abs = join32(dir, entry.name);
+    if (statSync3(abs).size > DEFAULT_MAX_FILE_BYTES) continue;
+    try {
+      out[relPath] = readFileSync32(abs, "utf8");
+    } catch {
+    }
+  }
+}
+var __defProp4, __name4, FILE_HASH_LENGTH, SKIP_DIRECTORIES, ARCHIVE_ONLY_SKIP_DIRECTORIES, DEFAULT_MAX_FILE_BYTES, KIND_BY_EXT, CHECK_BLOBS_MAX_HASHES, BackupHttpError, BackupHttpClient, DEFAULT_CONCURRENCY, CREDENTIAL_PATHS, WINDOWS_ABSOLUTE_PATH, ARCHIVE_SCHEMA_VERSION;
+var init_dist3 = __esm({
+  "../shared-source-sync/dist/index.mjs"() {
+    "use strict";
+    __defProp4 = Object.defineProperty;
+    __name4 = /* @__PURE__ */ __name((target, value3) => __defProp4(target, "name", { value: value3, configurable: true }), "__name");
+    FILE_HASH_LENGTH = 16;
+    __name(hashContentTruncated, "hashContentTruncated");
+    __name4(hashContentTruncated, "hashContentTruncated");
+    __name(sha256Hex, "sha256Hex");
+    __name4(sha256Hex, "sha256Hex");
+    __name(matchesFileHash, "matchesFileHash");
+    __name4(matchesFileHash, "matchesFileHash");
+    __name(combineFileHashes, "combineFileHashes");
+    __name4(combineFileHashes, "combineFileHashes");
+    SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "dist-v2",
+      ".git",
+      ".lua",
+      ".temp",
+      "coverage",
+      ".next",
+      ".turbo"
+    ]);
+    ARCHIVE_ONLY_SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+      "build"
+    ]);
+    DEFAULT_MAX_FILE_BYTES = 256 * 1024;
+    __name(shouldSkipDirectory, "shouldSkipDirectory");
+    __name4(shouldSkipDirectory, "shouldSkipDirectory");
+    __name(shouldSkipFile, "shouldSkipFile");
+    __name4(shouldSkipFile, "shouldSkipFile");
+    KIND_BY_EXT = {
+      ".ts": "source",
+      ".tsx": "source",
+      ".js": "source",
+      ".jsx": "source",
+      ".yaml": "config",
+      ".yml": "config",
+      ".json": "config",
+      ".toml": "config"
+    };
+    __name(classifyFile, "classifyFile");
+    __name4(classifyFile, "classifyFile");
+    __name(walkWorkspace, "walkWorkspace");
+    __name4(walkWorkspace, "walkWorkspace");
+    CHECK_BLOBS_MAX_HASHES = 500;
+    BackupHttpError = class extends Error {
+      static {
+        __name(this, "BackupHttpError");
+      }
+      static {
+        __name4(this, "BackupHttpError");
+      }
+      status;
+      endpoint;
+      body;
+      constructor(message, status, endpoint, body) {
+        super(message), this.status = status, this.endpoint = endpoint, this.body = body;
+        this.name = "BackupHttpError";
+      }
+    };
+    BackupHttpClient = class {
+      static {
+        __name(this, "BackupHttpClient");
+      }
+      static {
+        __name4(this, "BackupHttpClient");
+      }
+      options;
+      fetchFn;
+      constructor(options) {
+        this.options = options;
+        this.fetchFn = options.fetch ?? fetch;
+      }
+      url(path3) {
+        const base = this.options.baseUrl.replace(/\/$/, "");
+        return `${base}/developer/agents/${encodeURIComponent(this.options.agentId)}${path3}`;
+      }
+      async json(method, path3, body) {
+        const endpoint = this.url(path3);
+        const res = await this.fetchFn(endpoint, {
+          method,
+          headers: {
+            Authorization: this.options.authHeader,
+            ...body !== void 0 ? {
+              "Content-Type": "application/json"
+            } : {},
+            Accept: "application/json"
+          },
+          body: body !== void 0 ? JSON.stringify(body) : void 0
+        });
+        if (!res.ok) {
+          let text2;
+          try {
+            text2 = await res.text();
+          } catch {
+            text2 = void 0;
+          }
+          throw new BackupHttpError(`Backup request failed: ${method} ${path3} \u2192 ${res.status} ${res.statusText}`, res.status, endpoint, text2);
+        }
+        const text = await res.text();
+        if (!text) return void 0;
+        return JSON.parse(text);
+      }
+      /**
+      * `POST /backup/check-blobs` — returns existing vs missing partition.
+      *
+      * LUA-675: the server caps one request at `CHECK_BLOBS_MAX_HASHES`; a
+      * larger set is sent in sequential chunks and the partitions merged, so a
+      * big workspace still pushes and the client never fans out on its own.
+      */
+      async checkBlobsExist(hashes) {
+        if (hashes.length <= CHECK_BLOBS_MAX_HASHES) {
+          return this.json("POST", "/backup/check-blobs", {
+            hashes
+          });
+        }
+        const merged = {
+          missing: [],
+          existing: [],
+          results: {}
+        };
+        let unverified;
+        for (let i = 0; i < hashes.length; i += CHECK_BLOBS_MAX_HASHES) {
+          const part = await this.json("POST", "/backup/check-blobs", {
+            hashes: hashes.slice(i, i + CHECK_BLOBS_MAX_HASHES)
+          });
+          merged.missing.push(...part.missing);
+          merged.existing.push(...part.existing);
+          Object.assign(merged.results, part.results);
+          if (part.unverified) unverified = [
+            ...unverified ?? [],
+            ...part.unverified
+          ];
+        }
+        return unverified ? {
+          ...merged,
+          unverified
+        } : merged;
+      }
+      /** `POST /backup/blob-upload-urls` — presigned S3 PUT URLs. */
+      getBlobUploadUrls(hashes) {
+        return this.json("POST", "/backup/blob-upload-urls", {
+          hashes
+        });
+      }
+      /** `POST /backup/blob-urls` — presigned S3 GET URLs (for restore). */
+      getBlobUrls(hashes) {
+        return this.json("POST", "/backup/blob-urls", {
+          hashes
+        });
+      }
+      /** `POST /backup/manifest` — final step in a push; returns server metadata. */
+      saveManifest(data) {
+        return this.json("POST", "/backup/manifest", data);
+      }
+      /** `GET /backup` — metadata only, no file list. */
+      getMetadata() {
+        return this.json("GET", "/backup");
+      }
+      /** `GET /backup/manifest` — metadata + file list. */
+      getManifest() {
+        return this.json("GET", "/backup/manifest");
+      }
+      /** `GET /backup/check/:hash` — fast freshness probe. */
+      checkBackupExists(hash) {
+        return this.json("GET", `/backup/check/${encodeURIComponent(hash)}`);
+      }
+    };
+    DEFAULT_CONCURRENCY = 10;
+    __name(uploadBlobs, "uploadBlobs");
+    __name4(uploadBlobs, "uploadBlobs");
+    __name(decodeBlob, "decodeBlob");
+    __name4(decodeBlob, "decodeBlob");
+    __name(verifyDownloaded, "verifyDownloaded");
+    __name4(verifyDownloaded, "verifyDownloaded");
+    __name(downloadBlobs, "downloadBlobs");
+    __name4(downloadBlobs, "downloadBlobs");
+    __name(resolveBackupFileTarget, "resolveBackupFileTarget");
+    __name4(resolveBackupFileTarget, "resolveBackupFileTarget");
+    __name(restoreFromBlobs, "restoreFromBlobs");
+    __name4(restoreFromBlobs, "restoreFromBlobs");
+    CREDENTIAL_PATHS = /* @__PURE__ */ new Set([
+      ".env",
+      ".lua/config.json",
+      ".claude/settings.local.json"
+    ]);
+    WINDOWS_ABSOLUTE_PATH = /^[a-z]:\//i;
+    __name(normalizeWorkspaceRelativePath, "normalizeWorkspaceRelativePath");
+    __name4(normalizeWorkspaceRelativePath, "normalizeWorkspaceRelativePath");
+    __name(isCredentialPersistencePath, "isCredentialPersistencePath");
+    __name4(isCredentialPersistencePath, "isCredentialPersistencePath");
+    __name(pushAgentBackup, "pushAgentBackup");
+    __name4(pushAgentBackup, "pushAgentBackup");
+    __name(pullAgentBackup, "pullAgentBackup");
+    __name4(pullAgentBackup, "pullAgentBackup");
+    ARCHIVE_SCHEMA_VERSION = 1;
+    __name(encodeWorkspaceArchive, "encodeWorkspaceArchive");
+    __name4(encodeWorkspaceArchive, "encodeWorkspaceArchive");
+    __name(decodeWorkspaceArchive, "decodeWorkspaceArchive");
+    __name4(decodeWorkspaceArchive, "decodeWorkspaceArchive");
+    __name(writeArchiveToWorkspace, "writeArchiveToWorkspace");
+    __name4(writeArchiveToWorkspace, "writeArchiveToWorkspace");
+    __name(walk2, "walk");
+    __name4(walk2, "walk");
+  }
+});
+
 // src/api/backup.api.service.ts
 var init_backup_api_service = __esm({
   "src/api/backup.api.service.ts"() {
     "use strict";
     init_http_client();
+    init_dist3();
   }
 });
 
@@ -7619,6 +9177,7 @@ var init_base_handler = __esm({
     init_bundle_upload();
     init_semver();
     init_auth_error();
+    init_cli_error();
     DEFAULT_VERSION = SKILL_DEFAULTS.VERSION;
     BaseVersionedHandler = class {
       static {
@@ -7700,7 +9259,7 @@ var init_base_handler = __esm({
             serverItems
           };
         } catch (error) {
-          if (AuthenticationError.isAuthenticationError(error)) throw error;
+          if (AuthenticationError.isAuthenticationError(error) || isAccessDeniedError(error)) throw error;
           return {
             serverItems: null,
             fetchError: error instanceof Error ? error.message : String(error)
@@ -7730,13 +9289,24 @@ var init_base_handler = __esm({
           }
           const yamlItems = this.getFromYaml(config);
           const { yamlById, yamlByName, serverByName } = this.buildMaps(serverData.serverItems, yamlItems);
+          const idField = this.yamlConfig.idField;
+          const manifestNames = manifest ? new Set(getPrimitivesByKind(manifest, this.kind).map((p) => p.name)) : /* @__PURE__ */ new Set();
+          for (const stale of this.staleYamlRows(yamlItems, serverData.serverItems, manifestNames)) {
+            const idx = yamlItems.indexOf(stale);
+            if (idx < 0) continue;
+            const { [idField]: goneId, ...rest } = stale;
+            yamlItems[idx] = rest;
+            yamlUpdated = true;
+            const msg = `\u2139\uFE0F  ${this.displayName} "${stale.name}" (${goneId}) no longer exists on the server \u2014 re-registering it`;
+            messages.push(msg);
+            console.log(msg);
+          }
           const orphans = serverData.serverItems.filter((item) => {
             const id = item.id;
             const name = item.name;
             return !yamlById.has(id) && !yamlByName.has(name) && this.isActive(item) && this.shouldConsiderForOrphan(item);
           });
           if (orphans.length > 0) {
-            const idField = this.yamlConfig.idField;
             const stubs = orphans.map((item) => this.cleanItem({
               name: item.name,
               version: this.getActiveVersion(item) || DEFAULT_VERSION,
@@ -7779,6 +9349,7 @@ var init_base_handler = __esm({
             console.log(`\u2705 Server ${this.displayNamePlural} and YAML are fully in sync`);
           }
         } catch (error) {
+          if (AuthenticationError.isAuthenticationError(error) || isAccessDeniedError(error)) throw error;
           console.error(`\u274C Error syncing server ${this.displayNamePlural}:`, error);
         }
         return {
@@ -7835,6 +9406,7 @@ var init_base_handler = __esm({
               console.error(`   \u274C Failed to create "${item.name}" - no ID returned`);
             }
           } catch (error) {
+            if (AuthenticationError.isAuthenticationError(error) || isAccessDeniedError(error)) throw error;
             console.error(`   \u274C Failed to create "${item.name}": ${error instanceof Error ? error.message : error}`);
           }
         }
@@ -7969,6 +9541,15 @@ var init_base_handler = __esm({
       getItemId(item) {
         return item[this.yamlConfig.idField] || "";
       }
+      /**
+      * LUA-750: the yaml rows whose server id is gone (deleted server-side) and which `applySyncToYaml` should
+      * re-register. Default none — a handler whose `fetchFromServer` lists EVERY live row of its kind for the
+      * agent overrides this (a kind whose list omits inactive rows must not, or it would duplicate them).
+      * `manifestNames` is the set of primitives in local code: only those are worth re-creating.
+      */
+      staleYamlRows(_yamlItems, _serverItems, _manifestNames) {
+        return [];
+      }
       buildMaps(serverItems, yamlItems) {
         const yamlById = /* @__PURE__ */ new Map();
         const yamlByName = /* @__PURE__ */ new Map();
@@ -8367,6 +9948,7 @@ var init_cli = __esm({
   "src/utils/cli.ts"() {
     "use strict";
     init_auth_error();
+    init_cli_error();
     init_version_check();
     init_package_root();
     init_analytics();
@@ -8386,6 +9968,7 @@ var init_command_utils = __esm({
     init_request_credential();
     init_files();
     init_cli();
+    init_cli_error();
     __name(requireAuth, "requireAuth");
   }
 });
@@ -11934,7 +13517,10 @@ var init_workflow_api_service = __esm({
       async getRunReplayBundle(runId) {
         return this.httpGet(`${this.runs}/${runId}/journal?format=replay`, await this.auth());
       }
-      /** R11 — cancel (`mode:'request'` default; `'force'` after `forceAvailableAt`, 409 `FORCE_NOT_YET_AVAILABLE` before). */
+      /**
+      * R11 — cancel (`mode:'request'` default). A `'force'` before `forceAvailableAt` is the 200 verdict
+      * `{ transitioned:false, nextAction:'cancel_again', forceAvailableAt }` (PRO-979) — never a 409 (LUA-748).
+      */
       async cancelRun(runId, data = {}) {
         return this.httpPost(`${this.runs}/${runId}/cancel`, data, await this.auth());
       }
@@ -12013,6 +13599,14 @@ var init_workflow_api_service = __esm({
       async closeGoal(goalId, data = {}) {
         return this.httpPost(`${this.goals}/${encodeURIComponent(goalId)}/close`, data, await this.auth());
       }
+      /** LUA-749 R63 — edit (objective / judge / cadence / caps / note); a `budget` / `max_runs` park re-arms when the cap clears (`rearmed:true`). */
+      async updateGoal(goalId, data) {
+        return this.httpPatch(`${this.goals}/${encodeURIComponent(goalId)}`, data, await this.auth());
+      }
+      /** LUA-749 R64 — raise `maxTotalCredits` / `maxRuns` (increases only; 400 `GOAL_RAISE_BELOW_SPENT{field, value, spent}`). */
+      async raiseGoal(goalId, data) {
+        return this.httpPost(`${this.goals}/${encodeURIComponent(goalId)}/raise`, data, await this.auth());
+      }
       // ─── Schedules (R4-MF-2 list/get + R28 delete — `/workflows/:agentId/schedules`; LUA-627 stanza) ───
       /** Schedule tree (09 §9.5 — the write-only R27/R56/R28 family plus the R4-MF-2 read rows). */
       get schedules() {
@@ -12026,7 +13620,7 @@ var init_workflow_api_service = __esm({
       async getSchedule(jobId) {
         return this.httpGet(`${this.schedules}/${encodeURIComponent(jobId)}`, await this.auth());
       }
-      /** R28 — delete a schedule Job (404 `SCHEDULE_NOT_FOUND`). The CLI refuses a goal-owned job BEFORE this call (`goal_schedule`). */
+      /** R28 — delete a schedule Job (404 `SCHEDULE_NOT_FOUND`). The CLI refuses a LIVE goal's job BEFORE this call (`goal_schedule`); an ended goal's lingering Job is retired here (LUA-760). */
       async deleteSchedule(jobId) {
         return this.httpDelete(`${this.schedules}/${encodeURIComponent(jobId)}`, await this.auth());
       }