@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-subagents/src/workflows/scripted-workflow.js

@@ -1,13 +1,24 @@
-import { readFileSync } from "node:fs";
+import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, resolve as resolvePath } from "node:path";
 import { Worker } from "node:worker_threads";
 import { DEFAULT_GLOBAL_CONCURRENCY_LIMIT, Semaphore } from "../runs/shared/parallel-utils.js";
 import { HOST_STEP_MAX_COUNT } from "../runs/shared/host-step-status.js";
-import { classifyTaskMutationIntent } from "../runs/shared/task-intent.js";
+import { describeGateAcceptanceConflict, parseGateInput } from "../runs/shared/acceptance.js";
 import { normalizeWorkflowHostCommandParams } from "./host-command.js";
 const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const BASE_REF_VALIDATION_ERROR = "baseRef must be a valid Git ref: use HEAD or a supported named ref (for example, refs/heads/main). Full 40/64-character commit IDs and revision expressions are unsupported.";
+function validGitRef(ref) {
+  if (typeof ref !== "string" || !ref || ref === "@" || Buffer.byteLength(ref, "utf-8") > 1024 || ref.startsWith("/") || ref.endsWith("/") || ref.includes("//") || ref.includes("..") || ref.includes("@{"))
+    return false;
+  if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu.test(ref))
+    return false;
+  if (/[[\]\\~^:?*\u0000-\u0020\u007f]/u.test(ref) || ref.endsWith(".") || ref.endsWith(".lock"))
+    return false;
+  return ref.split("/").every((component) => component.length > 0 && component !== "." && component !== ".." && !component.startsWith(".") && !component.endsWith(".") && !component.endsWith(".lock"));
+}
 const requireFromPackage = createRequire(import.meta.url);
+const WORKFLOW_ASSEMBLY_FLUSH_TIMEOUT_MS = 5000;
 const WORKER_SOURCE = String.raw`
 const { parentPort, workerData } = require("node:worker_threads");
 const vm = require("node:vm");
@@ -35,6 +46,12 @@ let suppressNativePromiseConsumption = 0;
 const activeNativePromises = [];
 const pending = new Map();
 const runKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function validGitRef(ref) {
+  if (typeof ref !== "string" || !ref || ref === "@" || new TextEncoder().encode(ref).length > 1024 || ref.startsWith("/") || ref.endsWith("/") || ref.includes("//") || ref.includes("..") || ref.includes("@{")) return false;
+  if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu.test(ref)) return false;
+  if (/[[\]\\~^:?*\u0000-\u0020\u007f]/u.test(ref) || ref.endsWith(".") || ref.endsWith(".lock")) return false;
+  return ref.split("/").every((component) => component.length > 0 && component !== "." && component !== ".." && !component.startsWith(".") && !component.endsWith(".") && !component.endsWith(".lock"));
+}
 const trackedPromiseTrackers = new WeakMap();
 const trackedPromiseTargets = new WeakMap();
 let nativePromiseTrackers = new WeakMap();
@@ -47,6 +64,12 @@ function stableRunJson(value) {
   return JSON.stringify(value) ?? "undefined";
 }
 
+function canonicalRunParams(params) {
+  if (params.gate === undefined || params.acceptance !== false) return params;
+  const { acceptance: _acceptance, ...withoutAcceptance } = params;
+  return withoutAcceptance;
+}
+
 function isDirectWorkflowScriptPromiseHandlerCall() {
   const stack = new Error().stack;
   if (typeof stack !== "string") return false;
@@ -338,8 +361,8 @@ function laneStageRecord(stageKey, child, forcedState) {
   const ok = result?.ok === true;
   const verdict = laneStageVerdict(result);
   const blocked = laneStageIsBlocked(result);
-  const state = forcedState ?? (result?.stopped ? "stopped" : result?.detached ? "detached" : ok ? blocked ? "blocked" : "completed" : "failed");
-  const error = state !== "completed"
+  const state = forcedState ?? (result?.state === "running" ? "running" : result?.stopped ? "stopped" : result?.detached ? "detached" : ok ? blocked ? "blocked" : "completed" : "failed");
+  const error = state !== "completed" && state !== "running"
     ? state === "blocked" && blocked
       ? "Stage returned a blocked verdict."
       : typeof result?.error === "string"
@@ -418,7 +441,7 @@ function validateLaneSpecs(laneSpecs) {
       validateLaneStageBounds(validationParams, stageLabel);
       validateRunCall(generatedKey, validationParams, stageLabel, validationFingerprints);
       const existingFingerprint = runFingerprints.get(generatedKey);
-      if (existingFingerprint !== undefined && (resume === "previous" || existingFingerprint !== stableRunJson(params))) {
+      if (existingFingerprint !== undefined && (resume === "previous" || existingFingerprint !== stableRunJson(canonicalRunParams(params)))) {
         throw new Error("runs.lanes generated child key '" + generatedKey + "' is already used with incompatible launch params.");
       }
       stages.push({ key: stageKey, generatedKey, resume, params });
@@ -504,7 +527,7 @@ function runLanes(laneSpecs) {
       generatedKey: stage.generatedKey,
       ...workflowPlanStringMetadata(stage.params),
       ...(typeof stage.params.as === "string" && stage.params.as.trim() ? { outputName: stage.params.as.trim() } : {}),
-      ...(stage.params.outputSchema !== undefined ? { structured: true } : {}),
+      ...(stage.params.outputSchema ? { structured: true } : {}),
     })),
   })) });
   const firstItems = lanes.map((lane) => {
@@ -587,19 +610,54 @@ function validateLaneMetadata(value, label, workflowKey) {
   }
 }
 
+// Mirrors parseGateInput in src/runs/shared/acceptance.ts; the sandbox cannot import it.
+function describeGateShapeError(gate) {
+  const shape = "gate must be a non-empty command string or { command, output?: \"json\", schema?, timeoutMs? }.";
+  if (typeof gate === "string") return gate.trim() ? undefined : shape;
+  if (!gate || typeof gate !== "object" || Array.isArray(gate)) return shape;
+  for (const key of Object.keys(gate)) {
+    if (!["command", "output", "schema", "timeoutMs"].includes(key)) return "gate." + key + " is not supported.";
+  }
+  if (typeof gate.command !== "string" || !gate.command.trim()) return shape;
+  if (gate.output !== undefined && gate.output !== "json") return "gate.output must be \"json\" when present.";
+  if (gate.schema !== undefined) {
+    if (gate.output !== "json") return "gate.schema requires gate.output: \"json\".";
+    if (!gate.schema || typeof gate.schema !== "object" || Array.isArray(gate.schema)) return "gate.schema must be a JSON Schema object.";
+  }
+  if (gate.timeoutMs !== undefined && (!Number.isInteger(gate.timeoutMs) || gate.timeoutMs < 1)) return "gate.timeoutMs must be an integer >= 1.";
+  return undefined;
+}
+
+function describeGateAcceptanceConflict(gate, acceptance) {
+  const render = (value) => {
+    let encoded;
+    try {
+      encoded = JSON.stringify(value) ?? String(value);
+    } catch {
+      encoded = String(value);
+    }
+    return encoded.length > 120 ? encoded.slice(0, 120) + "..." : encoded;
+  };
+  return " Both fields were present: gate=" + render(gate) + " acceptance=" + render(acceptance) + ".";
+}
+
 function validateRunCall(key, params, label, fingerprints) {
   if (typeof key !== "string" || !runKeyPattern.test(key)) throw new Error(label + " has an invalid key.");
   if (hostKeys.has(key)) throw new Error("Workflow key '" + key + "' is already used by runs.host.");
   if (!params || typeof params !== "object" || Array.isArray(params)) throw new Error(label + " requires a params object.");
-  if (Object.prototype.hasOwnProperty.call(params, "action") || Object.prototype.hasOwnProperty.call(params, "workflowScript") || Object.prototype.hasOwnProperty.call(params, "tasks") || Object.prototype.hasOwnProperty.call(params, "chain") || Object.prototype.hasOwnProperty.call(params, "parallel") || Object.prototype.hasOwnProperty.call(params, "concurrency") || Object.prototype.hasOwnProperty.call(params, "chainDir")) {
+  if (Object.prototype.hasOwnProperty.call(params, "action") || Object.prototype.hasOwnProperty.call(params, "workflowScript") || Object.prototype.hasOwnProperty.call(params, "globalConcurrencyLimit") || Object.prototype.hasOwnProperty.call(params, "maxSubagentSpawnsPerRun") || Object.prototype.hasOwnProperty.call(params, "tasks") || Object.prototype.hasOwnProperty.call(params, "chain") || Object.prototype.hasOwnProperty.call(params, "parallel") || Object.prototype.hasOwnProperty.call(params, "concurrency") || Object.prototype.hasOwnProperty.call(params, "chainDir")) {
     const hint = label === "runs.run" ? "; use runs.all(...) and JavaScript control flow for orchestration." : ".";
     throw new Error(label + " accepts one child via { agent, task } and execution controls only" + hint);
   }
   if (Object.prototype.hasOwnProperty.call(params, "clarify")) throw new Error(label + " does not support clarify UI.");
   if (params.worktree !== undefined && typeof params.worktree !== "boolean") throw new Error(label + " worktree must be true or false.");
+  if (params.baseRef !== undefined && (typeof params.baseRef !== "string" || !validGitRef(params.baseRef))) throw new Error(label + " baseRef must be a valid Git ref: use HEAD or a supported named ref (for example, refs/heads/main). Full 40/64-character commit IDs and revision expressions are unsupported.");
   validateLaneMetadata(params.lane, label + " lane", key);
-  if (params.gate !== undefined && (typeof params.gate !== "string" || !params.gate.trim())) throw new Error(label + " gate must be a non-empty command string.");
-  if (params.gate !== undefined && params.acceptance !== undefined) throw new Error(label + " gate cannot be combined with acceptance; use one gate command or acceptance.verify.");
+  if (params.gate !== undefined) {
+    const gateError = describeGateShapeError(params.gate);
+    if (gateError) throw new Error(label + " " + gateError);
+  }
+  if (params.gate !== undefined && params.acceptance !== undefined && params.acceptance !== false) throw new Error(label + " gate cannot be combined with acceptance; use one gate command or acceptance.verify." + describeGateAcceptanceConflict(params.gate, params.acceptance));
   if (params.gate !== undefined && params.resume !== undefined) throw new Error(label + " gate is not supported with retained resume.");
   if (params.extensionBindings !== undefined && params.resume !== undefined) throw new Error(label + " extensionBindings is not supported with retained resume; resume uses the original retained child binding.");
   if (params.resume !== undefined && typeof params.resume !== "string") {
@@ -616,7 +674,7 @@ function validateRunCall(key, params, label, fingerprints) {
   if (params.resume !== undefined && (typeof params.task !== "string" || !params.task.trim())) throw new Error(label + " resume requires a non-empty task follow-up.");
   validateExtensionBindings(params.extensionBindings, label);
   assertJsonValue(params, label + " params");
-  const fingerprint = stableRunJson(params);
+  const fingerprint = stableRunJson(canonicalRunParams(params));
   const existing = fingerprints.get(key);
   if (existing !== undefined && existing !== fingerprint) throw new Error("Duplicate workflow key '" + key + "' used with incompatible launch params.");
   fingerprints.set(key, fingerprint);
@@ -647,8 +705,26 @@ function validateHostCommand(key, params) {
   hostKeys.add(key);
 }
 
+const RUNS_ALL_PERMISSIVE_WARNING = "runs.all received runs.run(...) launch promise(s) or thenable(s). Those children were already launched individually, so runs.all cannot apply batch fingerprint validation, batch grouping in the fleet view, or collectFailure semantics; a failed child will throw at the runs.all boundary instead of returning as { ok: false }. To get full runs.all semantics, pass config objects: runs.all(items.map((item) => ({ key: item.key, agent: item.agent, task: item.task }))).";
+
+function runsAllItemThenableInfo(item, index) {
+  if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+  if (typeof item.then !== "function") return null;
+  const tracker = promiseObservationTracker(item);
+  const observation = tracker && Array.isArray(tracker.observations) ? tracker.observations.find((entry) => entry && entry.operation === "run") : undefined;
+  return {
+    key: observation && typeof observation.key === "string" ? observation.key : ("runs.all[" + index + "]"),
+    callId: observation && typeof observation.callId === "number" ? observation.callId : null,
+    promise: item,
+  };
+}
+
+let warnedPermissiveRunsAll = false;
+
 function launchRunsAll(items, generatedLaneKeys) {
   if (!Array.isArray(items)) throw new Error("runs.all(items) requires an array.");
+  const anyThenable = items.some((item, index) => runsAllItemThenableInfo(item, index) !== null);
+  if (anyThenable) return launchRunsAllPermissive(items);
   const fingerprints = new Map(runFingerprints);
   const calls = [];
   for (let index = 0; index < items.length; index++) {
@@ -665,6 +741,33 @@ function launchRunsAll(items, generatedLaneKeys) {
   return { calls, launched };
 }
 
+function launchRunsAllPermissive(items) {
+  if (!warnedPermissiveRunsAll) {
+    warnedPermissiveRunsAll = true;
+    try { capturedConsole.warn(RUNS_ALL_PERMISSIVE_WARNING); } catch { /* console emission is best-effort */ }
+  }
+  const fingerprints = new Map(runFingerprints);
+  const calls = [];
+  const launched = [];
+  for (let index = 0; index < items.length; index++) {
+    if (!Object.prototype.hasOwnProperty.call(items, index)) throw new Error("runs.all items must not contain sparse entries.");
+    const item = items[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error("runs.all item " + index + " must be an object or a runs.run(...) launch promise.");
+    const thenable = runsAllItemThenableInfo(item, index);
+    if (thenable) {
+      calls.push({ key: thenable.key, params: {} });
+      launched.push(thenable);
+      continue;
+    }
+    const { key, ...params } = item;
+    validateRunCall(key, params, "runs.all item " + index, fingerprints);
+    calls.push({ key, params });
+    launched.push(null);
+  }
+  runFingerprints = fingerprints;
+  return { calls, launched: launched.map((entry, index) => entry ?? runHostCall(calls[index].key, calls[index].params, false, undefined)) };
+}
+
 const runs = Object.freeze({
   run(key, params) {
     validateRunCall(key, params, "runs.run", runFingerprints);
@@ -673,7 +776,7 @@ const runs = Object.freeze({
   },
   all(items) {
     const { calls, launched } = launchRunsAll(items);
-    return trackRunObservation(launched.map(({ key, callId }) => ({ key, operation: "run", callId })), Promise.all(launched.map(({ promise }) => promise)).then((results) => wrapRunsAllResults(results.map(decorateWorkflowChildResult), calls.map(({ key }) => key))));
+    return trackRunObservation(launched.map(({ key, callId }) => ({ key, operation: "run", callId })), trackPromiseCombinator(launched.map(({ promise }) => promise), (values) => Promise.all(values).then((results) => wrapRunsAllResults(results.map(decorateWorkflowChildResult), calls.map(({ key }) => key)))));
   },
   lanes(laneSpecs) {
     return runLanes(laneSpecs);
@@ -847,6 +950,12 @@ function omitUndefinedWorkflowValues(value, seen = new Set()) {
   return normalized;
 }
 
+function deepFreezeWorkflowArgs(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const entry of Object.values(value)) deepFreezeWorkflowArgs(entry);
+  return Object.freeze(value);
+}
+
 parentPort.on("message", async (message) => {
   if (message.type === "response") {
     const entry = pending.get(message.callId);
@@ -866,6 +975,9 @@ parentPort.on("message", async (message) => {
     if (message.stateEnabled) sandbox.state = state;
     const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
     contextObjectPrototype = vm.runInContext("Object.prototype", context);
+    // Rebuild args inside the VM realm: a worker-realm object would expose the worker's unrestricted
+    // Function through args.constructor.constructor, bypassing codeGeneration.strings: false.
+    sandbox.args = deepFreezeWorkflowArgs(vm.runInContext("JSON.parse", context)(JSON.stringify(message.args ?? {})));
     let compiled;
     try {
       assertPortableWorkflowScript(message.script);
@@ -1019,7 +1131,7 @@ function isExplicitReadOnlyRecoveryReview(params) {
   const taskDestructiveCommandText = task.replace(RECOVERY_REVIEW_BLOCKED_CONTEXT_FRAGMENT_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_EVIDENCE_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKED_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTEXT_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_LISTED_BLOCKED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKS_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_EXAMPLES_LIKE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_QUOTED_VISIBLE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_PROMPTS_LIKE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_MUTATIONS_BROADER_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_COVERAGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_FOLLOWED_BY_NAMED_RM_PATTERN, " ");
   const taskDashLiveActionText = task.replace(RECOVERY_REVIEW_DELIVERABLE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTEXT_OBJECT_PATTERN, " ").replace(RECOVERY_REVIEW_MUTATION_NOUN_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_PRIOR_FIX_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_DETECTION_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_PATTERN_CHANGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_PATTERN_CHANGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_VALIDATION_EVIDENCE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTRACT_PROHIBITION_PATTERN, " ").replace(RECOVERY_REVIEW_ONLY_REVIEW_CONTRACT_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKED_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTEXT_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_LISTED_BLOCKED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKS_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_EXAMPLES_LIKE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_QUOTED_VISIBLE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_PROMPTS_LIKE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_MUTATIONS_BROADER_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_COVERAGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_ANAPHORIC_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_FOLLOWED_BY_ANAPHORIC_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKED_LIVE_VARIANT_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_ANAPHORIC_REFERENCES_CONTEXT_PATTERN, " ");
   const taskMutationText = task.replace(RECOVERY_REVIEW_DELIVERABLE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTEXT_OBJECT_PATTERN, " ").replace(RECOVERY_REVIEW_MUTATION_NOUN_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_PRIOR_FIX_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_DETECTION_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_PATTERN_CHANGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_PATTERN_CHANGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_VALIDATION_EVIDENCE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTRACT_PROHIBITION_PATTERN, " ").replace(RECOVERY_REVIEW_ONLY_REVIEW_CONTRACT_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKED_CONTEXT_FRAGMENT_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_EVIDENCE_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKED_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_CONTEXT_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_LISTED_BLOCKED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKS_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_EXAMPLES_LIKE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_QUOTED_VISIBLE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_PROMPTS_LIKE_BLOCKED_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_MUTATIONS_BROADER_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_GIT_COVERAGE_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_QUOTED_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_ANAPHORIC_EXAMPLE_PATTERN, " ").replace(RECOVERY_REVIEW_REGRESSION_FOLLOWED_BY_ANAPHORIC_PATTERN, " ").replace(RECOVERY_REVIEW_BLOCKED_LIVE_VARIANT_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_ANAPHORIC_REFERENCES_CONTEXT_PATTERN, " ").replace(RECOVERY_REVIEW_NO_ANAPHORIC_MUTATION_CLAUSE_PATTERN, " ").replace(RECOVERY_REVIEW_NO_DELEGATION_CLAUSE_PATTERN, " ").replace(RECOVERY_REVIEW_NO_MUTATION_CLAUSE_PATTERN, " ").replace(new RegExp(RECOVERY_REVIEW_READ_ONLY_PATTERN.source, "gi"), " ");
-  return params.acceptance === false && agent !== "" && /\b(?:advisor|oracle|review|reviewer)\b/i.test(agent) && RECOVERY_REVIEW_READ_ONLY_PATTERN.test(task) && !RECOVERY_REVIEW_DESTRUCTIVE_COMMAND_PATTERN.test(taskDestructiveCommandText) && !RECOVERY_REVIEW_MUTATION_VERB_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_DELEGATION_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_ANAPHORIC_MUTATION_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_DESTRUCTIVE_COMMAND_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_DASH_LIVE_ACTION_PATTERN.test(taskDashLiveActionText) && classifyTaskMutationIntent(agent, task).kind === "read-only";
+  return params.acceptance === false && agent !== "" && /\b(?:advisor|oracle|review|reviewer)\b/i.test(agent) && RECOVERY_REVIEW_READ_ONLY_PATTERN.test(task) && !RECOVERY_REVIEW_DESTRUCTIVE_COMMAND_PATTERN.test(taskDestructiveCommandText) && !RECOVERY_REVIEW_MUTATION_VERB_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_DELEGATION_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_ANAPHORIC_MUTATION_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_DESTRUCTIVE_COMMAND_PATTERN.test(taskMutationText) && !RECOVERY_REVIEW_DASH_LIVE_ACTION_PATTERN.test(taskDashLiveActionText);
 }
 function recoveryBarrierMessage(sourceKey, target) {
   return `Run '${target}' cannot launch after run '${sourceKey}' returned rejected acceptance recovery; only explicit read-only review children with acceptance:false may follow.`;
@@ -1111,7 +1223,7 @@ function workflowReturnRecoveryHint(children) {
     const fields = [child.runId ? `runId=${child.runId.slice(0, 500)}` : undefined, child.outputReference ? `outputReference=${child.outputReference.slice(0, 500)}` : undefined, child.artifactPaths[0] ? `artifact=${child.artifactPaths[0].slice(0, 500)}` : undefined].filter((field) => field !== undefined);
     return `'${child.key}'${fields.length > 0 ? ` (${fields.join(", ")})` : ""}`;
   });
-  return ` Child work completed before return serialization failed. Recover outputs from: ${references.join(", ")}${children.length > references.length ? `, and ${children.length - references.length} more` : ""}. Return a plain projection such as { runId: child.runId, ok: child.ok, outputReference: child.outputReference }.`;
+  return ` ${children.some((child) => child.state === "running") ? "Child calls returned before return serialization failed; launch receipts do not prove completion." : "Child work completed before return serialization failed."} Recover outputs from: ${references.join(", ")}${children.length > references.length ? `, and ${children.length - references.length} more` : ""}. Return a plain projection such as { runId: child.runId, ok: child.ok, outputReference: child.outputReference }.`;
 }
 export function previewSimpleWorkflowRun(script) {
   const body = script?.match(/^\s*return\s+(?:await\s+)?runs\.run\s*\(\s*(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[^`$\\]*`)\s*,\s*\{([\s\S]*)\}\s*\)\s*;?\s*$/)?.[1];
@@ -1144,6 +1256,12 @@ function stableJson(value) {
     return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
   return JSON.stringify(value) ?? "undefined";
 }
+function canonicalRunParams(params) {
+  if (params.gate === undefined || params.acceptance !== false)
+    return params;
+  const { acceptance: _acceptance, ...withoutAcceptance } = params;
+  return withoutAcceptance;
+}
 function validateKey(value, owner = "runs.run") {
   if (typeof value !== "string" || !KEY_PATTERN.test(value)) {
     throw new Error(`${owner} key must be 1-128 characters using letters, numbers, '.', '_' or '-', and start with a letter or number.`);
@@ -1237,6 +1355,72 @@ function walkAst(node, visit, includeNestedFunctions = true) {
       walkAst(child, visit, includeNestedFunctions);
   }
 }
+function bindingPatternContainsName(node, name) {
+  if (!astNode(node))
+    return false;
+  if (node.type === "Identifier")
+    return node.name === name;
+  if (node.type === "RestElement")
+    return bindingPatternContainsName(node.argument, name);
+  if (node.type === "AssignmentPattern")
+    return bindingPatternContainsName(node.left, name);
+  if (node.type === "ArrayPattern" && Array.isArray(node.elements))
+    return node.elements.some((element) => bindingPatternContainsName(element, name));
+  if (node.type === "ObjectPattern" && Array.isArray(node.properties))
+    return node.properties.some((property) => {
+      if (!astNode(property))
+        return false;
+      return property.type === "RestElement" ? bindingPatternContainsName(property.argument, name) : property.type === "Property" && bindingPatternContainsName(property.value, name);
+    });
+  return false;
+}
+function definitelyReassignsBinding(node, name) {
+  let assignment = node;
+  while (astNode(assignment) && assignment.type === "AssignmentExpression" && assignment.operator !== "&&=" && assignment.operator !== "||=" && assignment.operator !== "??=") {
+    if (bindingPatternContainsName(assignment.left, name))
+      return true;
+    assignment = assignment.right;
+  }
+  return false;
+}
+function lexicalDeclarationContainsName(node, name) {
+  if (!astNode(node))
+    return false;
+  if (node.type === "VariableDeclaration" && node.kind !== "var" && Array.isArray(node.declarations)) {
+    return node.declarations.some((declaration) => astNode(declaration) && bindingPatternContainsName(declaration.id, name));
+  }
+  return (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && bindingPatternContainsName(node.id, name);
+}
+function scopeShadowsIdentifier(node, name) {
+  if (node.type === "BlockStatement" && Array.isArray(node.body))
+    return node.body.some((statement) => lexicalDeclarationContainsName(statement, name));
+  if (node.type === "CatchClause")
+    return bindingPatternContainsName(node.param, name);
+  if (node.type === "ForStatement")
+    return lexicalDeclarationContainsName(node.init, name);
+  if (node.type === "ForInStatement" || node.type === "ForOfStatement")
+    return lexicalDeclarationContainsName(node.left, name);
+  if (node.type === "SwitchStatement" && Array.isArray(node.cases)) {
+    return node.cases.some((entry) => astNode(entry) && Array.isArray(entry.consequent) && entry.consequent.some((statement) => lexicalDeclarationContainsName(statement, name)));
+  }
+  return false;
+}
+function walkAstWithoutShadowedIdentifier(node, name, visit) {
+  if (Array.isArray(node)) {
+    for (const item of node)
+      walkAstWithoutShadowedIdentifier(item, name, visit);
+    return;
+  }
+  if (!astNode(node) || scopeShadowsIdentifier(node, name))
+    return;
+  visit(node);
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")
+    return;
+  for (const [key, child] of Object.entries(node)) {
+    if (!AST_LOCATION_KEYS.has(key))
+      walkAstWithoutShadowedIdentifier(child, name, visit);
+  }
+}
 function definitelyNonJson(node, normalizeUndefined = false) {
   if (node.type === "Literal") {
     if (typeof node.bigint === "string")
@@ -1264,7 +1448,7 @@ function definitelyNonJson(node, normalizeUndefined = false) {
   if (node.type === "ObjectExpression" && Array.isArray(node.properties)) {
     const values = new Map;
     for (const property of node.properties) {
-      if (!astNode(property) || property.type !== "Property" || !astNode(property.value))
+      if (!astNode(property) || property.type !== "Property" || !astNode(property.value) || property.kind !== "init")
         return;
       const key = staticPropertyKey(property);
       if (key === undefined)
@@ -1294,6 +1478,29 @@ function directObjectPropertyValue(node, name) {
   }
   return value;
 }
+function validateStaticBaseRef(params, owner) {
+  if (params.type !== "ObjectExpression" || !Array.isArray(params.properties))
+    return [];
+  for (let index = params.properties.length - 1;index >= 0; index--) {
+    const property = params.properties[index];
+    if (!astNode(property) || property.type !== "Property")
+      return [];
+    const key = staticPropertyKey(property);
+    if (key === undefined)
+      return [];
+    if (key !== "baseRef")
+      continue;
+    if (property.kind !== "init" || !astNode(property.value))
+      return [];
+    const valueNode = property.value;
+    const value = literalString(valueNode);
+    if ((value !== undefined || valueNode.type === "Literal") && !validGitRef(value)) {
+      return [{ message: `${owner} ${BASE_REF_VALIDATION_ERROR}`, ...nodeLocation(valueNode) }];
+    }
+    return [];
+  }
+  return [];
+}
 function directRunsAllKeys(call) {
   const args = Array.isArray(call.arguments) ? call.arguments : [];
   const items = astNode(args[0]) && args[0].type === "ArrayExpression" && Array.isArray(args[0].elements) ? args[0].elements : [];
@@ -1305,7 +1512,134 @@ function directRunsAllKeys(call) {
     return keyNode && key !== undefined ? [{ key, node: keyNode }] : [];
   });
 }
-export function validateWorkflowScript(script) {
+function containsWorkflowLaunch(node) {
+  let found = false;
+  walkAst(node, (candidate) => {
+    if (directRunsCall(candidate, "run") || directRunsCall(candidate, "all") || directRunsCall(candidate, "lanes"))
+      found = true;
+  });
+  return found;
+}
+function containsRunsIdentifier(node) {
+  let found = false;
+  walkAst(node, (candidate) => {
+    if (candidate.type === "Identifier" && candidate.name === "runs")
+      found = true;
+  });
+  return found;
+}
+function invalidatesRunsBinding(workflowBody) {
+  let invalidated = false;
+  walkAst(workflowBody, (node) => {
+    if ((node.type === "VariableDeclarator" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression") && containsRunsIdentifier(node.id))
+      invalidated = true;
+    if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && Array.isArray(node.params) && node.params.some(containsRunsIdentifier))
+      invalidated = true;
+    if (node.type === "CatchClause" && containsRunsIdentifier(node.param))
+      invalidated = true;
+    if ((node.type === "AssignmentExpression" || node.type === "UpdateExpression") && containsRunsIdentifier(node.left ?? node.argument))
+      invalidated = true;
+  });
+  return invalidated;
+}
+function containsAbruptControl(node) {
+  let found = false;
+  walkAst(node, (candidate) => {
+    if (candidate !== node && (candidate.type === "ReturnStatement" || candidate.type === "ThrowStatement" || candidate.type === "BreakStatement" || candidate.type === "ContinueStatement"))
+      found = true;
+  }, false);
+  return found;
+}
+function directLaunchCall(expression) {
+  if (!astNode(expression))
+    return;
+  const candidate = expression.type === "AwaitExpression" && astNode(expression.argument) ? expression.argument : expression;
+  return directRunsCall(candidate, "run") || directRunsCall(candidate, "all") ? candidate : undefined;
+}
+function staticWorkflowLaunchPlan(workflowBody) {
+  if (workflowBody.type !== "BlockStatement" || !Array.isArray(workflowBody.body) || invalidatesRunsBinding(workflowBody)) {
+    return { keys: [], dynamic: containsWorkflowLaunch(workflowBody) };
+  }
+  const keys = new Set;
+  let dynamic = false;
+  let remainderUncertain = false;
+  const addCall = (call) => {
+    const args = Array.isArray(call.arguments) ? call.arguments : [];
+    let nestedLaunch = false;
+    for (const argument of args)
+      walkAst(argument, (node) => {
+        if (node !== call && (directRunsCall(node, "run") || directRunsCall(node, "all") || directRunsCall(node, "lanes")))
+          nestedLaunch = true;
+      });
+    if (nestedLaunch) {
+      dynamic = true;
+      return;
+    }
+    if (directRunsCall(call, "run")) {
+      const key = literalString(args[0]);
+      if (key === undefined)
+        dynamic = true;
+      else
+        keys.add(key);
+      return;
+    }
+    const array = astNode(args[0]) && args[0].type === "ArrayExpression" && Array.isArray(args[0].elements) ? args[0] : undefined;
+    if (!array) {
+      dynamic = true;
+      return;
+    }
+    const batchKeys = [];
+    for (const item of array.elements) {
+      if (!astNode(item) || item.type !== "ObjectExpression" || !Array.isArray(item.properties) || item.properties.some((property) => !astNode(property) || property.type !== "Property" || staticPropertyKey(property) === undefined)) {
+        dynamic = true;
+        return;
+      }
+      const key = literalString(directObjectPropertyValue(item, "key"));
+      if (key === undefined) {
+        dynamic = true;
+        return;
+      }
+      batchKeys.push(key);
+    }
+    for (const key of batchKeys)
+      keys.add(key);
+  };
+  for (const statement of workflowBody.body) {
+    if (!astNode(statement))
+      continue;
+    if (remainderUncertain) {
+      if (containsWorkflowLaunch(statement))
+        dynamic = true;
+      continue;
+    }
+    const expressions = [];
+    if (statement.type === "VariableDeclaration" && Array.isArray(statement.declarations)) {
+      for (const declaration of statement.declarations)
+        if (astNode(declaration))
+          expressions.push(declaration.init);
+    } else if (statement.type === "ExpressionStatement")
+      expressions.push(statement.expression);
+    else if (statement.type === "ReturnStatement" || statement.type === "ThrowStatement")
+      expressions.push(statement.argument);
+    let handledLaunch = false;
+    for (const expression of expressions) {
+      const call = directLaunchCall(expression);
+      if (call) {
+        addCall(call);
+        handledLaunch = true;
+      } else if (containsWorkflowLaunch(expression))
+        dynamic = true;
+    }
+    if (!handledLaunch && expressions.length === 0 && containsWorkflowLaunch(statement))
+      dynamic = true;
+    if (statement.type === "ReturnStatement" || statement.type === "ThrowStatement")
+      remainderUncertain = true;
+    else if (containsAbruptControl(statement))
+      remainderUncertain = true;
+  }
+  return { keys: [...keys], dynamic };
+}
+export function validateWorkflowScript(script, options = {}) {
   const errors = [];
   if (!script.trim())
     return { ok: false, errors: [{ message: "workflowScript must not be empty." }] };
@@ -1333,6 +1667,7 @@ ${script}
       if (keyNode && key !== undefined && !KEY_PATTERN.test(key))
         errors.push({ message: "runs.run key must be 1-128 characters using letters, numbers, '.', '_' or '-', and start with a letter or number.", ...nodeLocation(keyNode) });
       if (astNode(args[1])) {
+        errors.push(...validateStaticBaseRef(args[1], "runs.run"));
         const message = definitelyNonJson(args[1]);
         if (message)
           errors.push({ message: `runs.run params are invalid: ${message}.`, ...nodeLocation(args[1]) });
@@ -1346,6 +1681,7 @@ ${script}
       if (astNode(args[0]) && args[0].type === "ArrayExpression" && Array.isArray(args[0].elements)) {
         for (const item of args[0].elements)
           if (astNode(item)) {
+            errors.push(...validateStaticBaseRef(item, "runs.all item"));
             const message = definitelyNonJson(item);
             if (message)
               errors.push({ message: `runs.all item params are invalid: ${message}.`, ...nodeLocation(item) });
@@ -1374,28 +1710,48 @@ ${script}
       if (!astNode(statement) || statement.type !== "VariableDeclaration" || !Array.isArray(statement.declarations))
         continue;
       for (const declaration of statement.declarations) {
-        if (!astNode(declaration) || !astNode(declaration.id) || declaration.id.type !== "Identifier" || !astNode(declaration.init) || declaration.init.type !== "AwaitExpression" || !directRunsCall(declaration.init.argument, "all"))
+        if (!astNode(declaration) || !astNode(declaration.id) || declaration.id.type !== "Identifier" || !astNode(declaration.init) || declaration.init.type !== "AwaitExpression" || !astNode(declaration.init.argument) || !directRunsCall(declaration.init.argument, "all"))
           continue;
         const name = declaration.id.name;
+        const laterStatements = workflowBody.body.slice(statementIndex + 1);
         const keys = new Set(directRunsAllKeys(declaration.init.argument).map((entry) => entry.key));
         if (keys.size === 0)
           continue;
         const args = Array.isArray(declaration.init.argument.arguments) ? declaration.init.argument.arguments : [];
         const itemCount = astNode(args[0]) && args[0].type === "ArrayExpression" && Array.isArray(args[0].elements) ? args[0].elements.length : 0;
         const arrayResultShape = Array.from({ length: itemCount });
-        for (const later of workflowBody.body.slice(statementIndex + 1))
-          walkAst(later, (node) => {
+        for (const later of laterStatements) {
+          walkAstWithoutShadowedIdentifier(later, name, (node) => {
             if (node.type !== "MemberExpression" || !astNode(node.object) || node.object.type !== "Identifier" || node.object.name !== name)
               return;
             const property = node.computed === true ? literalString(node.property) : astNode(node.property) && node.property.type === "Identifier" ? node.property.name : undefined;
             if (property && keys.has(property) && !(property in arrayResultShape))
               errors.push({ message: `runs.all returns an ordered array; '${name}.${property}' is keyed access. Use an index, destructuring, or map(...).`, ...nodeLocation(node) });
-          }, false);
+          });
+          if (statement.kind !== "const" && astNode(later) && later.type === "ExpressionStatement" && definitelyReassignsBinding(later.expression, name))
+            break;
+        }
       }
     }
   }
+  const warnings = [];
+  if (options.maxSubagentSpawnsPerRun !== undefined) {
+    const plan = staticWorkflowLaunchPlan(workflowBody);
+    if (plan.keys.length > options.maxSubagentSpawnsPerRun) {
+      errors.push({
+        kind: "spawn-budget",
+        message: `workflowScript statically requires child launches ${plan.keys.map((key) => `'${key}'`).join(", ")}; minimum required: ${plan.keys.length}; configured: ${options.maxSubagentSpawnsPerRun}.`
+      });
+    }
+    if (plan.dynamic) {
+      warnings.push({
+        kind: "dynamic-spawn-count",
+        message: `workflowScript contains dynamic child launches; static validation proved ${plan.keys.length} launch(es), so runtime fan-out enforcement remains authoritative for the configured budget of ${options.maxSubagentSpawnsPerRun}.`
+      });
+    }
+  }
   const unique = errors.filter((error, index) => errors.findIndex((candidate) => candidate.message === error.message && candidate.line === error.line && candidate.column === error.column) === index);
-  return { ok: unique.length === 0, errors: unique };
+  return { ok: unique.length === 0, errors: unique, ...warnings.length > 0 ? { warnings } : {} };
 }
 function workflowStringMetadata(params) {
   return {
@@ -1418,7 +1774,7 @@ function resolveWorkflowParserEntry() {
     }
   }
 }
-const AUTO_RESUME_PARAM_KEYS = ["acceptance", "agentContract", "index", "intercomBridge", "label", "lane", "maxRuntimeMs", "output", "outputMode", "outputSchema", "phase", "skill", "skills", "task", "timeoutMs", "toolBudget", "worktree"];
+const AUTO_RESUME_PARAM_KEYS = ["acceptance", "agentContract", "baseRef", "index", "intercomBridge", "label", "lane", "maxRuntimeMs", "output", "outputMode", "outputSchema", "phase", "skill", "skills", "task", "timeoutMs", "toolBudget", "worktree"];
 function isZeroUsage(usage) {
   if (!isRecord(usage))
     return false;
@@ -1426,7 +1782,7 @@ function isZeroUsage(usage) {
   return (usage.input ?? 0) === 0 && (usage.output ?? 0) === 0 && (usage.cacheRead ?? 0) === 0 && (usage.cacheWrite ?? 0) === 0 && (!isRecord(cost) || (cost.total ?? 0) === 0);
 }
 function setupAbortResumeParams(params, result, signal) {
-  if (signal.aborted || result.ok || result.stopped || result.interrupted || !result.runId)
+  if (signal.aborted || result.state === "running" || result.ok || result.stopped || result.interrupted || !result.runId)
     return;
   const childResult = Array.isArray(result.results) && result.results.length === 1 && isRecord(result.results[0]) ? result.results[0] : undefined;
   const error = typeof childResult?.error === "string" ? childResult.error : result.error;
@@ -1459,10 +1815,37 @@ export async function runWorkflowScript(options) {
     throw new Error("workflowScript must not be empty.");
   if (options.timeoutMs !== undefined && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1))
     throw new Error("workflow script timeout must be a positive integer.");
-  if (options.globalConcurrencyLimit !== undefined && (!Number.isInteger(options.globalConcurrencyLimit) || options.globalConcurrencyLimit < 1)) {
+  if (options.globalConcurrencyLimit !== undefined && (!Number.isSafeInteger(options.globalConcurrencyLimit) || options.globalConcurrencyLimit < 1)) {
     throw new Error("workflow script global concurrency limit must be a positive integer.");
   }
   const launchSemaphore = new Semaphore(options.globalConcurrencyLimit ?? DEFAULT_GLOBAL_CONCURRENCY_LIMIT);
+  if (options.processCwd !== undefined) {
+    let staleCwd = false;
+    try {
+      realpathSync(process.cwd());
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+      if (code !== "ENOENT")
+        throw new Error("Workflow current cwd could not be validated.", { cause: error });
+      staleCwd = true;
+    }
+    try {
+      if (staleCwd)
+        process.chdir(options.processCwd);
+      else {
+        const target = realpathSync(options.processCwd);
+        if (!statSync(target).isDirectory()) {
+          const error = new Error(`ENOTDIR: not a directory, access '${target}'`);
+          error.code = "ENOTDIR";
+          throw error;
+        }
+        accessSync(target, constants.X_OK);
+      }
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`Workflow process cwd is unavailable: ${options.processCwd}: ${detail}`, { cause: error });
+    }
+  }
   let acornPath;
   try {
     acornPath = resolveWorkflowParserEntry();
@@ -1488,6 +1871,9 @@ export async function runWorkflowScript(options) {
   let acceptanceRecoveryBarrier;
   let settled = false;
   let finishing = false;
+  let assemblyAbortRequested = false;
+  let assemblyFlushTimer;
+  let abortError;
   const partial = () => ({ emits, console: consoleEntries, trace, children: childOrder.flatMap((key) => {
     const child = children.get(key);
     return child ? [child] : [];
@@ -1547,12 +1933,35 @@ export async function runWorkflowScript(options) {
     traceChanged();
     return true;
   };
+  const notifyChildSettled = (key, result) => {
+    if (result.state === "running" || !options.onChildSettled || !options.workflowRunId)
+      return;
+    const outcome = result.ok ? "completed" : result.stopped ? "stopped" : result.detached ? "paused" : "failed";
+    const outputReference = result.outputReference ?? result.outputArtifactPath;
+    try {
+      options.onChildSettled({
+        workflowRunId: options.workflowRunId,
+        childKey: key,
+        ...result.runId ? { childRunId: result.runId } : {},
+        outcome,
+        ...outputReference ? { outputReference } : {},
+        ...!result.ok && result.error ? { error: result.error } : {},
+        workflowRunning: !settled && !finishing
+      });
+    } catch (error) {
+      console.error("Workflow onChildSettled callback failed:", error);
+    }
+  };
   options.registerStopChild?.(stopChild);
   return await new Promise((resolve, reject) => {
     const finish = (outcome) => {
       if (settled || finishing)
         return;
       finishing = true;
+      if (assemblyFlushTimer !== undefined) {
+        clearTimeout(assemblyFlushTimer);
+        assemblyFlushTimer = undefined;
+      }
       childController.abort("error" in outcome ? outcome.error : new Error("Workflow script completed."));
       Promise.allSettled([...steers.values(), ...hostCalls.values()].map(({ promise }) => promise)).then(() => {
         if (settled)
@@ -1582,6 +1991,23 @@ export async function runWorkflowScript(options) {
     const onAbort = () => {
       const signalReason = options.signal?.reason;
       const error = signalReason instanceof Error ? signalReason : typeof signalReason === "string" ? new Error(signalReason) : new Error("Workflow script aborted.");
+      if (finishing)
+        return;
+      abortError = error;
+      const allChildrenSettled = launches.size > 0 && [...launches.keys()].every((key) => children.has(key));
+      let mayFlushAssembly = false;
+      try {
+        mayFlushAssembly = options.continueAfterAbortWhenChildrenSettled?.(error) === true;
+      } catch (callbackError) {
+        const callbackMessage = callbackError instanceof Error ? callbackError.message : String(callbackError);
+        return finish({ error: new Error(`Workflow assembly flush eligibility failed: ${callbackMessage}`) });
+      }
+      if (mayFlushAssembly && allChildrenSettled) {
+        assemblyAbortRequested = true;
+        childController.abort(error);
+        assemblyFlushTimer = setTimeout(() => finish({ error }), WORKFLOW_ASSEMBLY_FLUSH_TIMEOUT_MS);
+        return;
+      }
       for (const key of launches.keys()) {
         if (children.has(key))
           continue;
@@ -1684,6 +2110,8 @@ export async function runWorkflowScript(options) {
       }
       if (message.type !== "call" || typeof message.callId !== "number" || typeof message.method !== "string" || !isRecord(message.args))
         return;
+      if (assemblyAbortRequested)
+        return finish({ error: abortError ?? new Error("Workflow context was replaced or reloaded.") });
       const respond = (promise, responsePath, onBoundaryError) => {
         promise.then((value) => {
           if (settled)
@@ -1850,7 +2278,7 @@ export async function runWorkflowScript(options) {
       const callObserved = observedRunCalls.delete(message.callId);
       const deliver = (promise) => collectFailure ? promise : promise.then((result) => {
         const recoverableAcceptanceMetadata = result.recovery?.status === "available-for-review" && result.recovery.reason === "acceptance-metadata-rejected";
-        if (!result.ok && !result.stopped && !recoverableAcceptanceMetadata) {
+        if (!result.ok && result.state !== "running" && !result.stopped && !recoverableAcceptanceMetadata) {
           const childError = new Error(result.detached ? `Run '${key}' detached: ${result.error ?? result.output}` : `Run '${key}' failed: ${result.error ?? result.output}`);
           if (result.detached)
             childError.workflowErrorKind = "detached-child";
@@ -1858,7 +2286,7 @@ export async function runWorkflowScript(options) {
         }
         return result;
       });
-      const fingerprint = stableJson(params);
+      const fingerprint = stableJson(canonicalRunParams(params));
       const existing = launches.get(key);
       if (existing) {
         if (existing.fingerprint !== fingerprint)
@@ -1886,11 +2314,16 @@ export async function runWorkflowScript(options) {
       if (params.worktree !== undefined && typeof params.worktree !== "boolean") {
         return respond(Promise.reject(new Error(`runs.run('${key}') worktree must be true or false.`)));
       }
-      if (params.gate !== undefined && (typeof params.gate !== "string" || !params.gate.trim())) {
-        return respond(Promise.reject(new Error(`runs.run('${key}') gate must be a non-empty command string.`)));
+      if (params.baseRef !== undefined && (typeof params.baseRef !== "string" || !validGitRef(params.baseRef))) {
+        return respond(Promise.reject(new Error(`runs.run('${key}') ${BASE_REF_VALIDATION_ERROR}`)));
       }
-      if (params.gate !== undefined && params.acceptance !== undefined) {
-        return respond(Promise.reject(new Error(`runs.run('${key}') gate cannot be combined with acceptance; use one gate command or acceptance.verify.`)));
+      if (params.gate !== undefined) {
+        const parsedGate = parseGateInput(params.gate);
+        if (!parsedGate.ok)
+          return respond(Promise.reject(new Error(`runs.run('${key}') ${parsedGate.error}`)));
+      }
+      if (params.gate !== undefined && params.acceptance !== undefined && params.acceptance !== false) {
+        return respond(Promise.reject(new Error(`runs.run('${key}') gate cannot be combined with acceptance; use one gate command or acceptance.verify.` + describeGateAcceptanceConflict(params.gate, params.acceptance))));
       }
       if (params.gate !== undefined && params.resume !== undefined) {
         return respond(Promise.reject(new Error(`runs.run('${key}') gate is not supported with retained resume.`)));
@@ -1926,7 +2359,7 @@ export async function runWorkflowScript(options) {
             return;
           for (const call of calls)
             assertRecoveryBarrierAllowsRun(call.key, call.params);
-          return options.admit?.(calls);
+          return options.admit?.(calls, childController.signal);
         });
         if (batch)
           batchAdmissions.set(batch.id, admission);
@@ -1941,10 +2374,11 @@ export async function runWorkflowScript(options) {
         const childStopController = new AbortController;
         childStopControllers.set(key, childStopController);
         const childSignal = combinedAbortSignal([childController.signal, childStopController.signal]);
-        const resolvedResumeValue = resumeReference ? await Promise.resolve().then(() => {
+        const resumeInput = resumeReference ?? (typeof params.resume === "string" && options.resolveResume ? params.resume : undefined);
+        const resolvedResumeValue = resumeInput ? await Promise.resolve().then(() => {
           if (!options.resolveResume)
             throw new Error("Keyed workflow receipt resume is unavailable in this host.");
-          return options.resolveResume(resumeReference, childSignal);
+          return options.resolveResume(resumeInput, childSignal, typeof params.index === "number" ? params.index : undefined);
         }) : undefined;
         const resolvedResume = typeof resolvedResumeValue === "string" ? resolvedResumeValue : isRecord(resolvedResumeValue) && typeof resolvedResumeValue.runId === "string" ? resolvedResumeValue.runId : undefined;
         if (resumeReference && (typeof resolvedResume !== "string" || !resolvedResume.trim()))
@@ -1955,6 +2389,11 @@ export async function runWorkflowScript(options) {
           resolvedResumeLineage = [...new Set(lineage.length ? lineage : [resolvedResumeId])];
           if (resolvedResumeLineage.at(-1) !== resolvedResumeId)
             resolvedResumeLineage.push(resolvedResumeId);
+          if (typeof resumeInput === "string") {
+            const predecessor = [...children.values()].find((child) => child.runId === resolvedResumeId);
+            if (predecessor?.continuation && predecessor.continuation.runIds.at(-1) === resolvedResumeId)
+              resolvedResumeLineage = predecessor.continuation.runIds;
+          }
         }
         const launchParams = resolvedResumeId ? { ...params, resume: resolvedResumeId } : params;
         await launchSemaphore.acquire();
@@ -1975,8 +2414,13 @@ export async function runWorkflowScript(options) {
         } finally {
           launchSemaphore.release();
         }
+      }, (error) => {
+        if (!childController.signal.aborted)
+          throw error;
+        const reason = childController.signal.reason;
+        return stoppedChildResult(key, reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Workflow script aborted.");
       }).then((result) => {
-        let normalized = !result.ok && !result.error ? { ...result, error: result.output } : result;
+        let normalized = !result.ok && result.state !== "running" && !result.error ? { ...result, error: result.output } : result;
         if (resolvedResumeLineage?.length && normalized.runId) {
           normalized = { ...normalized, continuation: { runIds: [...new Set([...resolvedResumeLineage, normalized.runId])] } };
         }
@@ -1985,9 +2429,10 @@ export async function runWorkflowScript(options) {
           return children.get(key) ?? normalized;
         children.set(key, normalized);
         recordAcceptanceRecoveryBarrier(key, normalized);
-        const state = normalized.ok ? "completed" : normalized.stopped ? "stopped" : normalized.detached ? "detached" : "failed";
-        trace.push({ operation: "run", key, state, durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), ...generatedLaneKey ? { generatedLaneKey } : {}, ...normalized.agent ? { agent: normalized.agent } : {}, ...normalized.runId ? { runId: normalized.runId } : {}, ...!normalized.ok ? { error: normalized.error ?? normalized.output } : {} });
+        const state = normalized.state === "running" ? "started" : normalized.ok ? "completed" : normalized.stopped ? "stopped" : normalized.detached ? "detached" : "failed";
+        trace.push({ operation: "run", key, state, durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), ...generatedLaneKey ? { generatedLaneKey } : {}, ...normalized.agent ? { agent: normalized.agent } : {}, ...normalized.runId ? { runId: normalized.runId } : {}, ...!normalized.ok && normalized.state !== "running" ? { error: normalized.error ?? normalized.output } : {} });
         traceChanged();
+        notifyChildSettled(key, normalized);
         return normalized;
       }, (error) => {
         const text = error instanceof Error ? error.message : String(error);
@@ -1998,6 +2443,7 @@ export async function runWorkflowScript(options) {
         children.set(key, failure);
         trace.push({ operation: "run", key, state: "failed", durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), ...generatedLaneKey ? { generatedLaneKey } : {}, error: text });
         traceChanged();
+        notifyChildSettled(key, failure);
         return failure;
       });
       launches.set(key, { fingerprint, promise, observed: callObserved, ...generatedLaneKey ? { generatedLaneKey } : {} });
@@ -2006,6 +2452,6 @@ export async function runWorkflowScript(options) {
       traceChanged();
       respond(deliver(promise), `runs.run('${key}') result`, (error) => children.set(key, responseBoundaryFailure(key, error)));
     });
-    worker.postMessage({ type: "start", script: options.script, stateEnabled: options.state !== undefined });
+    worker.postMessage({ type: "start", script: options.script, ...options.args ? { args: options.args } : {}, stateEnabled: options.state !== undefined });
   });
 }