@qwen-code/qwen-code 0.23.2 → 0.23.3

package/chunks/{chunk-OXR34GCD.js → chunk-UKZ45TJL.js}

@@ -1,16 +1,50 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
+  AgentEventEmitter,
+  attachJsonlTranscriptWriter,
+  buildAgentTranscriptAttach,
+  deriveApprovalModeConfig,
+  deriveConfig,
+  deriveWorktreeConfig,
+  installSessionWorkflowRevisionWriteThrough,
   isActiveWorkflowStatus,
   isTerminalWorkflowStatus,
-  isWorkflowRunPersistenceActive
-} from "./chunk-HJ5UJQQL.js";
+  isWorkflowRunPersistenceActive,
+  rebuildToolRegistryOnOverride,
+  resolveExternalWorktreeDir,
+  toModelVisibleSubagentResult
+} from "./chunk-N7VWZDWW.js";
+import {
+  GitWorktreeService,
+  generateAgentWorktreeSlug,
+  writeWorktreeSessionMarker
+} from "./chunk-36HCNKDS.js";
+import {
+  parsePositiveIntegerEnv
+} from "./chunk-6PVPNMXU.js";
+import {
+  SUBAGENT_PLAN_LIFECYCLE_TOOLS
+} from "./chunk-PLLIWEM3.js";
+import {
+  runWithAgentContext
+} from "./chunk-U7O65WKL.js";
+import {
+  read,
+  writeLine
+} from "./chunk-HBU7EKY4.js";
 import {
   atomicWriteFile
 } from "./chunk-XFFRI3WM.js";
 import {
   stripAnsiAndControl
-} from "./chunk-7VEYUF3N.js";
+} from "./chunk-W5ZQMAEM.js";
+import {
+  SyntheticOutputTool
+} from "./chunk-HUXPEUFL.js";
+import {
+  ToolNames
+} from "./chunk-TP6FYVQT.js";
 import {
   Storage,
   createDebugLogger
@@ -1612,11 +1646,271 @@ function createWorkflowSandbox(opts) {
 }
 __name(createWorkflowSandbox, "createWorkflowSandbox");
 
+// packages/core/src/agents/runtime/workflow-budget.ts
+init_esbuild_shims();
+var debugLogger2 = createDebugLogger("WORKFLOW_BUDGET");
+var MAX_TOKENS_PER_WORKFLOW_ENV = "QWEN_CODE_MAX_TOKENS_PER_WORKFLOW";
+var HARD_MAX_TOKENS_CEILING = 1e8;
+function resolveMaxTokensPerWorkflow(env = process.env) {
+  const raw = env[MAX_TOKENS_PER_WORKFLOW_ENV];
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  const parsed = parsePositiveIntegerEnv(raw, 0);
+  if (parsed < 1) {
+    debugLogger2.warn(
+      `Invalid ${MAX_TOKENS_PER_WORKFLOW_ENV}=${JSON.stringify(raw)}, treating as unset (no cap)`
+    );
+    return null;
+  }
+  if (parsed > HARD_MAX_TOKENS_CEILING) {
+    debugLogger2.warn(
+      `${MAX_TOKENS_PER_WORKFLOW_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_TOKENS_CEILING}); clamping.`
+    );
+    return HARD_MAX_TOKENS_CEILING;
+  }
+  return parsed;
+}
+__name(resolveMaxTokensPerWorkflow, "resolveMaxTokensPerWorkflow");
+var WorkflowBudgetImpl = class _WorkflowBudgetImpl {
+  static {
+    __name(this, "WorkflowBudgetImpl");
+  }
+  total;
+  _spent;
+  constructor(total) {
+    this.total = total;
+    this._spent = 0;
+  }
+  spent() {
+    return this._spent;
+  }
+  remaining() {
+    if (this.total === null) return Infinity;
+    return Math.max(0, this.total - this._spent);
+  }
+  /**
+   * Host-side increment. NOT exposed to the script — the
+   * `WorkflowBudget` interface deliberately omits any setter so a
+   * malicious workflow cannot inflate / deflate the budget. Only the
+   * orchestrator (in `countedDispatch`) calls this after a dispatch
+   * resolves with the agent's output token count.
+   *
+   * Non-positive deltas are silently dropped (some dispatches return
+   * `output_tokens: 0` on early failures); negative deltas would be a
+   * caller bug and are also dropped rather than silently rewinding
+   * the counter.
+   */
+  recordSpent(deltaTokens) {
+    if (!Number.isFinite(deltaTokens) || deltaTokens <= 0) return;
+    this._spent += deltaTokens;
+  }
+  /**
+   * Factory: build a budget from the current environment. Convenience
+   * over `new WorkflowBudgetImpl(resolveMaxTokensPerWorkflow(env))`.
+   */
+  static fromEnv(env = process.env) {
+    return new _WorkflowBudgetImpl(resolveMaxTokensPerWorkflow(env));
+  }
+};
+var WorkflowBudgetExceededError = class extends Error {
+  static {
+    __name(this, "WorkflowBudgetExceededError");
+  }
+  name = "WorkflowBudgetExceededError";
+  runId;
+  budgetTotal;
+  spent;
+  constructor(runId, budgetTotal, spent) {
+    super(
+      `Workflow ${runId} exceeded the token budget (${spent} / ${budgetTotal} output tokens spent).`
+    );
+    this.runId = runId;
+    this.budgetTotal = budgetTotal;
+    this.spent = spent;
+  }
+};
+
+// packages/core/src/agents/runtime/workflow-stall.ts
+init_esbuild_shims();
+
+// packages/core/src/agents/runtime/workflow-agent-failure.ts
+init_esbuild_shims();
+var WorkflowAgentFailedError = class extends Error {
+  static {
+    __name(this, "WorkflowAgentFailedError");
+  }
+  name = "WorkflowAgentFailedError";
+  kind;
+  terminateMode;
+  constructor(message, kind, terminateMode) {
+    super(message);
+    this.kind = kind;
+    this.terminateMode = terminateMode;
+  }
+};
+function isWorkflowAgentFailedError(error) {
+  return typeof error === "object" && error !== null && error.name === "WorkflowAgentFailedError";
+}
+__name(isWorkflowAgentFailedError, "isWorkflowAgentFailedError");
+var WorkflowAgentCapExceededError = class extends Error {
+  static {
+    __name(this, "WorkflowAgentCapExceededError");
+  }
+  name = "WorkflowAgentCapExceededError";
+  constructor(maxAgents) {
+    super(
+      `Workflow exceeded the maximum of ${maxAgents} agent() calls per run.`
+    );
+  }
+};
+function isWorkflowRunLevelError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const name = error.name;
+  return name === "WorkflowBudgetExceededError" || name === "WorkflowAgentCapExceededError";
+}
+__name(isWorkflowRunLevelError, "isWorkflowRunLevelError");
+var WORKFLOW_ABORT_REASON_STALLED = "stalled";
+
+// packages/core/src/agents/runtime/workflow-stall.ts
+var DEFAULT_STALL_MS = 18e4;
+var MAX_STALL_ATTEMPTS = 3;
+var MAX_WORKFLOW_STALL_MS_ENV = "QWEN_CODE_WORKFLOW_STALL_SECONDS";
+function resolveStallMs(perCall, env = process.env) {
+  if (typeof perCall === "number" && Number.isFinite(perCall)) {
+    if (perCall === 0) return 0;
+    if (perCall > 0) return perCall;
+  }
+  const raw = env[MAX_WORKFLOW_STALL_MS_ENV];
+  const trimmed = raw?.trim();
+  if (trimmed) {
+    if (trimmed === "0") return 0;
+    const sec = parsePositiveIntegerEnv(trimmed, 0);
+    if (sec > 0) return sec * 1e3;
+  }
+  return DEFAULT_STALL_MS;
+}
+__name(resolveStallMs, "resolveStallMs");
+var debugLogger3 = createDebugLogger("WORKFLOW_STALL");
+function attachStallWatchdog(emitter, controller, stallMs) {
+  if (stallMs <= 0) {
+    return { stalled: /* @__PURE__ */ __name(() => false, "stalled"), dispose: /* @__PURE__ */ __name(() => {
+    }, "dispose") };
+  }
+  let inFlightTools = 0;
+  let fired = false;
+  let timer;
+  let disposed = false;
+  const clear = /* @__PURE__ */ __name(() => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }, "clear");
+  const arm = /* @__PURE__ */ __name(() => {
+    clear();
+    if (disposed || fired) return;
+    if (inFlightTools > 0) return;
+    timer = setTimeout(() => {
+      if (disposed || fired) return;
+      fired = true;
+      debugLogger3.warn(
+        `[Workflow] agent dispatch stalled \u2014 no progress for ${stallMs}ms; aborting.`
+      );
+      try {
+        controller.abort(WORKFLOW_ABORT_REASON_STALLED);
+      } catch (e) {
+        debugLogger3.warn("stall watchdog abort threw:", e);
+      }
+    }, stallMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  }, "arm");
+  const onActivity = /* @__PURE__ */ __name(() => arm(), "onActivity");
+  const onToolCall = /* @__PURE__ */ __name(() => {
+    inFlightTools += 1;
+    clear();
+  }, "onToolCall");
+  const onToolResult = /* @__PURE__ */ __name(() => {
+    inFlightTools = Math.max(0, inFlightTools - 1);
+    arm();
+  }, "onToolResult");
+  emitter.on("round_start" /* ROUND_START */, onActivity);
+  emitter.on("round_end" /* ROUND_END */, onActivity);
+  emitter.on("stream_text" /* STREAM_TEXT */, onActivity);
+  emitter.on("usage_metadata" /* USAGE_METADATA */, onActivity);
+  emitter.on("tool_call" /* TOOL_CALL */, onToolCall);
+  emitter.on("tool_result" /* TOOL_RESULT */, onToolResult);
+  return {
+    stalled: /* @__PURE__ */ __name(() => fired, "stalled"),
+    dispose: /* @__PURE__ */ __name(() => {
+      if (disposed) return;
+      disposed = true;
+      clear();
+      emitter.off("round_start" /* ROUND_START */, onActivity);
+      emitter.off("round_end" /* ROUND_END */, onActivity);
+      emitter.off("stream_text" /* STREAM_TEXT */, onActivity);
+      emitter.off("usage_metadata" /* USAGE_METADATA */, onActivity);
+      emitter.off("tool_call" /* TOOL_CALL */, onToolCall);
+      emitter.off("tool_result" /* TOOL_RESULT */, onToolResult);
+    }, "dispose")
+  };
+}
+__name(attachStallWatchdog, "attachStallWatchdog");
+async function runStallResilient(attemptFn, opts) {
+  const { stallMs, signal, label } = opts;
+  if (stallMs <= 0) {
+    const emitter = new AgentEventEmitter();
+    return attemptFn(signal ?? new AbortController().signal, emitter);
+  }
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    const controller = new AbortController();
+    let onParentAbort;
+    if (signal) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+      } else {
+        onParentAbort = /* @__PURE__ */ __name(() => controller.abort(signal.reason), "onParentAbort");
+        signal.addEventListener("abort", onParentAbort);
+      }
+    }
+    const emitter = new AgentEventEmitter();
+    const watchdog = attachStallWatchdog(emitter, controller, stallMs);
+    try {
+      return await attemptFn(controller.signal, emitter);
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      if (watchdog.stalled() && attempt < MAX_STALL_ATTEMPTS) {
+        debugLogger3.warn(
+          `[Workflow] agent "${label ?? "workflow-agent"}" stalled (attempt ${attempt}/${MAX_STALL_ATTEMPTS}) \u2014 retrying.`
+        );
+        continue;
+      }
+      if (watchdog.stalled()) {
+        throw new WorkflowAgentFailedError(
+          `agent "${label ?? "workflow-agent"}" stalled on all ${MAX_STALL_ATTEMPTS} attempts (no progress for ${stallMs}ms each).`,
+          "stalled"
+        );
+      }
+      throw err;
+    } finally {
+      watchdog.dispose();
+      if (onParentAbort && signal) {
+        signal.removeEventListener("abort", onParentAbort);
+      }
+    }
+  }
+}
+__name(runStallResilient, "runStallResilient");
+
 // packages/core/src/agents/runtime/workflow-saved.ts
 init_esbuild_shims();
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
-var debugLogger2 = createDebugLogger("WORKFLOW_SAVED");
+var debugLogger4 = createDebugLogger("WORKFLOW_SAVED");
 var WORKFLOW_NAME_PATTERN = /^[a-z][a-z0-9-]{0,40}$/;
 function validateWorkflowName(name) {
   if (!name) return "Workflow name is required.";
@@ -1646,7 +1940,7 @@ async function isSymlinkedRoot(dir) {
 __name(isSymlinkedRoot, "isSymlinkedRoot");
 async function listJsFiles(dir) {
   if (await isSymlinkedRoot(dir)) {
-    debugLogger2.warn(`refusing symlinked saved-workflow dir: ${dir}`);
+    debugLogger4.warn(`refusing symlinked saved-workflow dir: ${dir}`);
     return [];
   }
   try {
@@ -1662,7 +1956,7 @@ async function listJsFiles(dir) {
   } catch (e) {
     const code = e?.code;
     if (code !== "ENOENT") {
-      debugLogger2.warn(`listJsFiles failed for ${dir}: ${e}`);
+      debugLogger4.warn(`listJsFiles failed for ${dir}: ${e}`);
     }
     return [];
   }
@@ -1809,7 +2103,7 @@ __name(saveWorkflowScript, "saveWorkflowScript");
 var INLINE_RUN_ID_PATTERN = /^wf_[0-9a-f]+$/;
 async function persistInlineWorkflowScript(config, runId, script) {
   if (!INLINE_RUN_ID_PATTERN.test(runId)) {
-    debugLogger2.warn(`refusing to persist a script for run id: ${runId}`);
+    debugLogger4.warn(`refusing to persist a script for run id: ${runId}`);
     return null;
   }
   const storage = config.storage;
@@ -1818,7 +2112,7 @@ async function persistInlineWorkflowScript(config, runId, script) {
     const filePath = storage.getInlineWorkflowScriptPath(runId);
     const dir = path.dirname(filePath);
     if (await isSymlinkedRoot(storage.getGeneratedWorkflowsDir()) || await isSymlinkedRoot(dir)) {
-      debugLogger2.warn(
+      debugLogger4.warn(
         `refusing to persist an inline workflow script into a symlinked root: '${dir}'.`
       );
       return null;
@@ -1832,7 +2126,7 @@ async function persistInlineWorkflowScript(config, runId, script) {
     });
     return filePath;
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger4.warn(
       `failed to persist inline workflow script for ${runId}: ${error}`
     );
     return null;
@@ -1847,7 +2141,7 @@ async function deleteInlineWorkflowScript(config, runId) {
     await fs.rm(storage.getInlineWorkflowScriptPath(runId), { force: true });
     return true;
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger4.warn(
       `failed to delete inline workflow script for ${runId}: ${error}`
     );
     return false;
@@ -1855,11 +2149,1452 @@ async function deleteInlineWorkflowScript(config, runId) {
 }
 __name(deleteInlineWorkflowScript, "deleteInlineWorkflowScript");
 
-// packages/core/src/agents/workflow-snapshot.ts
+// packages/core/src/agents/runtime/workflow-orchestrator.ts
+init_esbuild_shims();
+import { randomBytes } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as os from "node:os";
+
+// packages/core/src/agents/runtime/workflow-journal.ts
 init_esbuild_shims();
-import { promises as fs2 } from "node:fs";
+import { createHash } from "node:crypto";
+import { constants, promises as fs2 } from "node:fs";
 import path2 from "node:path";
-var debugLogger3 = createDebugLogger("WORKFLOW_SNAPSHOT");
+var debugLogger5 = createDebugLogger("WORKFLOW_JOURNAL");
+var JOURNAL_KEY_VERSION = "v2";
+function canonicalizeAgentOpts(opts) {
+  const projected = {};
+  for (const k of [
+    "schema",
+    "model",
+    "isolation",
+    "agentType",
+    "workingDir"
+  ]) {
+    const v = opts[k];
+    if (v === void 0 || typeof v === "function") continue;
+    projected[k] = v;
+  }
+  const sortDeep = /* @__PURE__ */ __name((val) => {
+    if (typeof val === "function") return void 0;
+    if (Array.isArray(val)) return val.map(sortDeep);
+    if (val && typeof val === "object") {
+      const out = {};
+      for (const key of Object.keys(val).sort()) {
+        if (key === "__proto__") continue;
+        out[key] = sortDeep(val[key]);
+      }
+      return out;
+    }
+    return val;
+  }, "sortDeep");
+  try {
+    return JSON.stringify(sortDeep(projected));
+  } catch {
+    return "{}";
+  }
+}
+__name(canonicalizeAgentOpts, "canonicalizeAgentOpts");
+function deriveAgentKey(prefixHash, prompt, opts) {
+  const hash = createHash("sha256");
+  hash.update(prefixHash);
+  hash.update("\0");
+  hash.update(prompt);
+  hash.update("\0");
+  hash.update(canonicalizeAgentOpts(opts));
+  return `${JOURNAL_KEY_VERSION}:${hash.digest("hex")}`;
+}
+__name(deriveAgentKey, "deriveAgentKey");
+function deriveArgsSeed(args) {
+  const hash = createHash("sha256");
+  let serialized;
+  try {
+    serialized = JSON.stringify(args ?? null) ?? "null";
+  } catch {
+    serialized = "non-serializable-args";
+  }
+  hash.update(serialized);
+  return `${JOURNAL_KEY_VERSION}:${hash.digest("hex")}`;
+}
+__name(deriveArgsSeed, "deriveArgsSeed");
+function buildReplay(entries) {
+  const results = /* @__PURE__ */ new Map();
+  const started = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.type === "result") {
+      results.set(e.key, e);
+    } else if (e.type === "started") {
+      failed.delete(e.key);
+      const list = started.get(e.key);
+      if (list) list.push(e);
+      else started.set(e.key, [e]);
+    } else if (e.type === "failed") {
+      failed.add(e.key);
+    }
+  }
+  return { results, started, failed };
+}
+__name(buildReplay, "buildReplay");
+var WorkflowJournal = class {
+  constructor(journalPath, root = path2.dirname(path2.dirname(journalPath))) {
+    this.root = root;
+    this.path = journalPath;
+  }
+  static {
+    __name(this, "WorkflowJournal");
+  }
+  pending = Promise.resolve();
+  path;
+  async hasSymlinkedPath() {
+    if (await isSymlinkedRoot(this.root) || await isSymlinkedRoot(path2.dirname(this.path))) {
+      return true;
+    }
+    return fs2.lstat(this.path).then((stat) => stat.isSymbolicLink()).catch(() => false);
+  }
+  /** Ensure the advertised journal path exists without affecting the run. */
+  async ensureExists() {
+    try {
+      if (await this.hasSymlinkedPath()) return false;
+      await fs2.mkdir(path2.dirname(this.path), { recursive: true });
+      if (await this.hasSymlinkedPath()) return false;
+      const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+      const file = await fs2.open(
+        this.path,
+        constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | noFollow,
+        384
+      );
+      try {
+        await file.chmod(384);
+      } finally {
+        await file.close();
+      }
+      return true;
+    } catch (error) {
+      debugLogger5.warn(
+        `WorkflowJournal.ensureExists failed for ${this.path}: ${error}`
+      );
+      return false;
+    }
+  }
+  /** Remove a never-registered run's journal file, best-effort. */
+  async remove() {
+    try {
+      if (await this.hasSymlinkedPath()) return;
+      await fs2.rm(this.path, { force: true });
+      await fs2.rmdir(path2.dirname(this.path)).catch((error) => {
+        const code = error.code;
+        if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
+      });
+    } catch (error) {
+      debugLogger5.warn(
+        `WorkflowJournal.remove failed for ${this.path}: ${error}`
+      );
+    }
+  }
+  /** Load + parse all entries into replay maps. Empty maps if no file. */
+  async load() {
+    try {
+      const entries = await read(this.path);
+      return buildReplay(entries);
+    } catch (e) {
+      debugLogger5.warn(`WorkflowJournal.load failed for ${this.path}: ${e}`);
+      return { results: /* @__PURE__ */ new Map(), started: /* @__PURE__ */ new Map(), failed: /* @__PURE__ */ new Set() };
+    }
+  }
+  /** Append one entry. Rejects only on I/O error (callers `.catch`). */
+  append(entry) {
+    const operation = this.pending.then(() => writeLine(this.path, entry));
+    this.pending = operation.catch(() => void 0);
+    return operation;
+  }
+  /** Wait until every append issued so far has settled. */
+  drain() {
+    return this.pending;
+  }
+};
+
+// packages/core/src/agents/runtime/workflow-prompts.ts
+init_esbuild_shims();
+var WORKFLOW_SUBAGENT_SYSTEM_PROMPT = 'You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.\nCRITICAL: Your final text response is returned **verbatim** as a string to the calling script \u2014 it is your return value, not a message to a human.\n- Output the literal result (data, JSON, text). Do NOT output confirmations like "Done." or "Sent."\n- If asked for JSON, return ONLY the raw JSON \u2014 no code fences, no prose, no markdown.\n- Do NOT use SendUserMessage to deliver your answer. Put your answer in your final text response.\n- Be concise. The script will parse your output.';
+var WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA = "You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.\nCRITICAL: You MUST deliver your final answer by calling the `structured_output` tool with arguments that conform to its parameter schema. Plain-text final answers are DISCARDED \u2014 only a valid `structured_output` call returns a result to the calling script.\n- Use other tools (Read, Grep, etc.) to gather information first.\n- When ready, call `structured_output` ONCE with the conforming JSON object.\n- If validation fails, the error tells you what to fix. Try again with corrected fields.\n- After two failed attempts, the run terminates \u2014 get the arguments right.\n- Do NOT use SendUserMessage to deliver your answer.\n- Be concise; the script reads only the structured payload, not your prose.";
+
+// packages/core/src/agents/runtime/workflow-dispatch-scheduler.ts
+init_esbuild_shims();
+function abortError() {
+  return new DOMException("Workflow dispatch scheduler aborted.", "AbortError");
+}
+__name(abortError, "abortError");
+var WorkflowDispatchScheduler = class {
+  constructor(limit, signal, onStateChange) {
+    this.limit = limit;
+    this.signal = signal;
+    if (!Number.isInteger(limit) || limit < 1) {
+      throw new Error(
+        `Workflow dispatch limit must be a positive integer, got ${String(limit)}.`
+      );
+    }
+    if (onStateChange) this.stateListeners.add(onStateChange);
+    if (signal && !signal.aborted) {
+      signal.addEventListener("abort", () => this.abortPending(), {
+        once: true
+      });
+    }
+  }
+  static {
+    __name(this, "WorkflowDispatchScheduler");
+  }
+  state = "running";
+  inFlight = 0;
+  queue = [];
+  gateWaiters = [];
+  stateListeners = /* @__PURE__ */ new Set();
+  /**
+   * Subscribe to state transitions. Returns an unsubscribe function.
+   * The constructor callback (when given) is registered as the first
+   * listener; this method lets additional observers — e.g. the sandbox's
+   * pause-aware wall-clock watchdog — hook the same transitions.
+   */
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => {
+      this.stateListeners.delete(listener);
+    };
+  }
+  run(thunk) {
+    return new Promise((resolve2, reject) => {
+      if (this.signal?.aborted) {
+        reject(abortError());
+        return;
+      }
+      this.queue.push({
+        thunk,
+        resolve: resolve2,
+        reject
+      });
+      this.pump();
+    });
+  }
+  pause() {
+    if (this.state !== "running" || this.signal?.aborted) return false;
+    this.setState("pausing");
+    if (this.inFlight === 0) this.setState("paused");
+    return true;
+  }
+  resume() {
+    if (this.state !== "paused" || this.signal?.aborted) return false;
+    this.setState("running");
+    while (this.gateWaiters.length > 0) {
+      this.gateWaiters.shift().resolve();
+    }
+    this.pump();
+    return true;
+  }
+  waitUntilRunning() {
+    if (this.signal?.aborted) return Promise.reject(abortError());
+    if (this.state === "running") return Promise.resolve();
+    return new Promise((resolve2, reject) => {
+      this.gateWaiters.push({ resolve: resolve2, reject });
+    });
+  }
+  snapshot() {
+    return {
+      state: this.state,
+      queued: this.queue.length,
+      inFlight: this.inFlight
+    };
+  }
+  pump() {
+    while (this.state === "running" && this.inFlight < this.limit && this.queue.length > 0) {
+      const job = this.queue.shift();
+      if (this.signal?.aborted) {
+        job.reject(abortError());
+        continue;
+      }
+      this.inFlight++;
+      Promise.resolve().then(job.thunk).then(job.resolve, job.reject).finally(() => {
+        this.inFlight--;
+        if (this.state === "pausing" && this.inFlight === 0) {
+          this.setState("paused");
+        }
+        this.pump();
+      });
+    }
+  }
+  setState(state) {
+    if (this.state === state) return;
+    this.state = state;
+    const snapshot = this.snapshot();
+    for (const listener of [...this.stateListeners]) listener(snapshot);
+  }
+  abortPending() {
+    const error = abortError();
+    while (this.queue.length > 0) this.queue.shift().reject(error);
+    while (this.gateWaiters.length > 0) {
+      this.gateWaiters.shift().reject(error);
+    }
+  }
+};
+
+// packages/core/src/agents/runtime/workflow-orchestrator.ts
+var DEFAULT_MAX_AGENTS_PER_RUN = 1e3;
+var MAX_WORKFLOW_AGENTS_ENV = "QWEN_CODE_MAX_WORKFLOW_AGENTS";
+var HARD_MAX_AGENTS_PER_RUN_CEILING = 1e4;
+function resolveMaxAgentsPerRun(env = process.env) {
+  const raw = env[MAX_WORKFLOW_AGENTS_ENV];
+  if (raw === void 0 || raw.trim() === "") {
+    return DEFAULT_MAX_AGENTS_PER_RUN;
+  }
+  const parsed = parsePositiveIntegerEnv(raw, 0);
+  if (parsed < 1) {
+    debugLogger.warn(
+      `Invalid ${MAX_WORKFLOW_AGENTS_ENV}=${JSON.stringify(raw)}, using default (${DEFAULT_MAX_AGENTS_PER_RUN})`
+    );
+    return DEFAULT_MAX_AGENTS_PER_RUN;
+  }
+  if (parsed > HARD_MAX_AGENTS_PER_RUN_CEILING) {
+    debugLogger.warn(
+      `${MAX_WORKFLOW_AGENTS_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_AGENTS_PER_RUN_CEILING}); clamping.`
+    );
+    return HARD_MAX_AGENTS_PER_RUN_CEILING;
+  }
+  return parsed;
+}
+__name(resolveMaxAgentsPerRun, "resolveMaxAgentsPerRun");
+var MAX_WORKFLOW_CONCURRENCY_ENV = "QWEN_CODE_MAX_WORKFLOW_CONCURRENCY";
+var HARD_MAX_CONCURRENCY_CEILING = 64;
+function resolveConcurrencyLimit(env = process.env, availableParallelism2 = os.availableParallelism) {
+  const raw = env[MAX_WORKFLOW_CONCURRENCY_ENV];
+  if (raw !== void 0 && raw.trim() !== "") {
+    const parsed = parsePositiveIntegerEnv(raw, 0);
+    if (parsed >= 1) {
+      if (parsed > HARD_MAX_CONCURRENCY_CEILING) {
+        debugLogger.warn(
+          `${MAX_WORKFLOW_CONCURRENCY_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_CONCURRENCY_CEILING}); clamping.`
+        );
+        return HARD_MAX_CONCURRENCY_CEILING;
+      }
+      return parsed;
+    }
+    debugLogger.warn(
+      `Invalid ${MAX_WORKFLOW_CONCURRENCY_ENV}=${JSON.stringify(raw)}, using cpu-derived default`
+    );
+  }
+  return Math.max(2, Math.min(16, availableParallelism2() - 2));
+}
+__name(resolveConcurrencyLimit, "resolveConcurrencyLimit");
+var DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS = 50;
+var DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES = 10;
+var WORKFLOW_SUBAGENT_MAX_TURNS_ENV = "QWEN_CODE_WORKFLOW_AGENT_MAX_TURNS";
+var WORKFLOW_SUBAGENT_MAX_MINUTES_ENV = "QWEN_CODE_WORKFLOW_AGENT_MAX_MINUTES";
+var HARD_WORKFLOW_SUBAGENT_MAX_TURNS_CEILING = 500;
+var HARD_WORKFLOW_SUBAGENT_MAX_MINUTES_CEILING = 100;
+function resolveSubagentBound(envName, defaultValue, ceiling, env) {
+  const raw = env[envName];
+  if (raw === void 0 || raw.trim() === "") return defaultValue;
+  const parsed = parsePositiveIntegerEnv(raw, 0);
+  if (parsed < 1) {
+    debugLogger.warn(
+      `Invalid ${envName}=${JSON.stringify(raw)}, using default (${defaultValue})`
+    );
+    return defaultValue;
+  }
+  if (parsed > ceiling) {
+    debugLogger.warn(
+      `${envName}=${parsed} exceeds hard ceiling (${ceiling}); clamping.`
+    );
+    return ceiling;
+  }
+  return parsed;
+}
+__name(resolveSubagentBound, "resolveSubagentBound");
+function resolveSubagentMaxTurns(env = process.env, defaultValue = DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS) {
+  return resolveSubagentBound(
+    WORKFLOW_SUBAGENT_MAX_TURNS_ENV,
+    defaultValue,
+    HARD_WORKFLOW_SUBAGENT_MAX_TURNS_CEILING,
+    env
+  );
+}
+__name(resolveSubagentMaxTurns, "resolveSubagentMaxTurns");
+function resolveSubagentMaxTimeMinutes(env = process.env, defaultValue = DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES) {
+  return resolveSubagentBound(
+    WORKFLOW_SUBAGENT_MAX_MINUTES_ENV,
+    defaultValue,
+    HARD_WORKFLOW_SUBAGENT_MAX_MINUTES_CEILING,
+    env
+  );
+}
+__name(resolveSubagentMaxTimeMinutes, "resolveSubagentMaxTimeMinutes");
+var WORKFLOW_SUBAGENT_DISALLOWED_TOOLS = [
+  ToolNames.ASK_USER_QUESTION,
+  ToolNames.SEND_MESSAGE,
+  ToolNames.MONITOR,
+  ...SUBAGENT_PLAN_LIFECYCLE_TOOLS,
+  // AgentTool: workflow subagents must not spawn sub-agents even where
+  // maxSubagentDepth would permit nesting — a leaf-spawned agent would run
+  // outside the orchestrator's concurrency cap, agent counter, and token
+  // budget, and its result would bypass the script's return-value contract.
+  // The WorkflowTool itself is already excluded from every subagent; this
+  // closes the same loop for plain `agent` calls (review #6189).
+  ToolNames.AGENT
+];
+var WorkflowExecutionError = class extends Error {
+  constructor(message, phases, logs, meta = null) {
+    super(message);
+    this.phases = phases;
+    this.logs = logs;
+    this.meta = meta;
+  }
+  static {
+    __name(this, "WorkflowExecutionError");
+  }
+  name = "WorkflowExecutionError";
+};
+function generateRunId() {
+  return `wf_${randomBytes(8).toString("hex")}`;
+}
+__name(generateRunId, "generateRunId");
+function sanitizeForErrorMessage(value) {
+  return stripAnsiAndControl(value);
+}
+__name(sanitizeForErrorMessage, "sanitizeForErrorMessage");
+function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents, subagentBounds) {
+  return async (prompt, opts, dispatchId) => {
+    if (typeof prompt !== "string" || prompt.length === 0) {
+      throw new Error("agent() requires a non-empty string prompt.");
+    }
+    const stallMs = resolveStallMs(
+      typeof opts.stallMs === "number" ? opts.stallMs : void 0
+    );
+    const workflowAgentId = `workflow-agent-${randomBytes(8).toString("hex")}`;
+    const agentIdentity = await resolveWorkflowAgentIdentity(config, opts);
+    if (agentIdentity.resolvedAgentType?.executor !== void 0) {
+      throw new Error(
+        "Workflow agent() does not support external-executor agents: token budgets, schema output, and workflow tool restrictions cannot be enforced. Use an in-process agent definition instead."
+      );
+    }
+    let attempt = 0;
+    return runStallResilient(
+      async (attemptSignal, emitter) => {
+        attempt += 1;
+        const cleanupApprovalBridge = bridgeApprovalEvents?.(
+          emitter,
+          dispatchId
+        );
+        const cleanupTranscript = attachDispatchTranscript(
+          config,
+          workflowAgentId,
+          prompt,
+          agentIdentity.name,
+          emitter,
+          attempt
+        );
+        try {
+          return await runSingleDispatch(
+            config,
+            prompt,
+            opts,
+            attemptSignal,
+            emitter,
+            workflowAgentId,
+            agentIdentity,
+            onTokens,
+            subagentBounds
+          );
+        } finally {
+          cleanupTranscript();
+          cleanupApprovalBridge?.();
+        }
+      },
+      {
+        stallMs,
+        signal,
+        // The name can carry a model-authored agentType spelling — keep
+        // the stall log / abandoned error single-line the same way the
+        // "not found" throw site sanitizes it.
+        label: sanitizeForErrorMessage(agentIdentity.name)
+      }
+    );
+  };
+}
+__name(createProductionDispatch, "createProductionDispatch");
+async function resolveWorkflowAgentIdentity(config, opts) {
+  if (opts.agentType) {
+    const resolved = await config.getSubagentManager().findSubagentByName(opts.agentType);
+    if (resolved) {
+      return { name: resolved.name, resolvedAgentType: resolved };
+    }
+  }
+  if (typeof opts.label === "string" && opts.label) {
+    return { name: opts.label };
+  }
+  return { name: opts.agentType || "workflow-agent" };
+}
+__name(resolveWorkflowAgentIdentity, "resolveWorkflowAgentIdentity");
+function attachDispatchTranscript(config, agentId, prompt, agentName, emitter, attempt) {
+  const append = attempt > 1;
+  try {
+    const { jsonlPath, options } = buildAgentTranscriptAttach(config, agentId, {
+      agentName,
+      // The prompt the SCRIPT dispatched, seeded as the transcript's first
+      // user record — the same shape AgentTool writes, so a reader that
+      // recovers a launch prompt from a transcript needs no workflow-
+      // specific branch. A retry re-uses the first attempt's record rather
+      // than seeding a second one.
+      initialUserPrompt: append ? void 0 : prompt,
+      appendToExisting: append,
+      retryAttempt: append ? attempt : void 0
+    });
+    return attachJsonlTranscriptWriter(emitter, jsonlPath, options).cleanup;
+  } catch (error) {
+    debugLogger.warn(
+      `[Workflow] failed to attach transcript for ${agentId}: ${error}`
+    );
+    return () => {
+    };
+  }
+}
+__name(attachDispatchTranscript, "attachDispatchTranscript");
+function terminalDispatchError(workflowAgentId, mode) {
+  const message = `Workflow subagent ${workflowAgentId} did not complete (terminate mode: ${mode}).`;
+  switch (mode) {
+    case "MAX_TURNS" /* MAX_TURNS */:
+      return new WorkflowAgentFailedError(message, "max_turns", mode);
+    case "TIMEOUT" /* TIMEOUT */:
+      return new WorkflowAgentFailedError(message, "timeout", mode);
+    case "ERROR" /* ERROR */:
+      return new WorkflowAgentFailedError(message, "error", mode);
+    default:
+      return new Error(message);
+  }
+}
+__name(terminalDispatchError, "terminalDispatchError");
+async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, workflowAgentId, agentIdentity, onTokens, subagentBounds) {
+  const { AgentHeadless, ContextState } = await import("./agent-headless-RI2THRQ7.js");
+  const ctx = new ContextState();
+  ctx.set("task_prompt", prompt);
+  debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
+  if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0 && opts.workingDir === void 0) {
+    const subagent = await AgentHeadless.create(
+      agentIdentity.name,
+      config,
+      {
+        systemPrompt: WORKFLOW_SUBAGENT_SYSTEM_PROMPT
+      },
+      {},
+      // T11 (PR #4732 R1): bound resource ceiling so a single agent() call
+      // cannot loop the model indefinitely. Without this, runConfig was {}
+      // and the loop guards never tripped — combined with the cancellation
+      // bug below, workflows were effectively unkillable.
+      subagentBounds ?? {
+        max_turns: resolveSubagentMaxTurns(),
+        max_time_minutes: resolveSubagentMaxTimeMinutes()
+      },
+      // T11 (PR #4732 R1): disallow SendMessage / ExitPlanMode to align with
+      // upstream Tg8 — closes the back-channel that would let a subagent
+      // deliver its answer via user message instead of the script's read.
+      { tools: ["*"], disallowedTools: WORKFLOW_SUBAGENT_DISALLOWED_TOOLS },
+      // P-stall: the stall-watchdog emitter observes reasoning-loop events
+      // (round/tool/usage) to detect a hang and abort `attemptSignal`.
+      emitter,
+      void 0,
+      void 0,
+      prompt,
+      workflowAgentId
+    );
+    try {
+      await runWithAgentContext(
+        workflowAgentId,
+        () => subagent.execute(ctx, attemptSignal)
+      );
+    } finally {
+      reportTokens(subagent, opts, onTokens);
+    }
+    const mode = subagent.getTerminateMode();
+    if (mode !== "GOAL" /* GOAL */) {
+      throw terminalDispatchError(workflowAgentId, mode);
+    }
+    return toModelVisibleSubagentResult(subagent.getFinalText(), mode);
+  }
+  return runOverridePath(
+    config,
+    ctx,
+    opts,
+    attemptSignal,
+    workflowAgentId,
+    agentIdentity,
+    onTokens,
+    emitter,
+    subagentBounds
+  );
+}
+__name(runSingleDispatch, "runSingleDispatch");
+function reportTokens(subagent, opts, onTokens) {
+  if (!onTokens) return;
+  try {
+    const summary = subagent.getExecutionSummary();
+    onTokens(summary.outputTokens, opts);
+  } catch (e) {
+    debugLogger.warn("onTokens callback threw:", e);
+  }
+}
+__name(reportTokens, "reportTokens");
+async function runOverridePath(config, ctx, opts, signal, workflowAgentId, agentIdentity, onTokens, emitter, subagentBounds) {
+  if (opts.isolation === "remote") {
+    throw new Error(
+      "agent({isolation:'remote'}) is not available in this build."
+    );
+  }
+  const subagentMgr = config.getSubagentManager();
+  let baseConfig;
+  if (opts.agentType !== void 0) {
+    const resolved = agentIdentity.resolvedAgentType;
+    if (!resolved) {
+      const safeAgentType = sanitizeForErrorMessage(opts.agentType);
+      throw new Error(
+        `agent({agentType}): agent type '${safeAgentType}' not found.`
+      );
+    }
+    baseConfig = resolved;
+  } else {
+    baseConfig = {
+      name: agentIdentity.name,
+      description: "Default workflow subagent (per-call overrides).",
+      systemPrompt: WORKFLOW_SUBAGENT_SYSTEM_PROMPT,
+      level: "session",
+      isBuiltin: false
+    };
+  }
+  let schemaSystemPrompt;
+  if (opts.schema !== void 0) {
+    schemaSystemPrompt = opts.agentType !== void 0 && baseConfig.systemPrompt ? `${baseConfig.systemPrompt}
+
+${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA;
+  }
+  let schemaTools;
+  if (opts.schema !== void 0 && baseConfig.tools && baseConfig.tools.length > 0 && !baseConfig.tools.includes("*") && !baseConfig.tools.includes(ToolNames.STRUCTURED_OUTPUT)) {
+    schemaTools = [...baseConfig.tools, ToolNames.STRUCTURED_OUTPUT];
+  }
+  const augmented = {
+    ...baseConfig,
+    ...opts.model !== void 0 ? { model: opts.model } : {},
+    ...schemaSystemPrompt !== void 0 ? { systemPrompt: schemaSystemPrompt } : {},
+    ...schemaTools !== void 0 ? { tools: schemaTools } : {},
+    disallowedTools: Array.from(
+      /* @__PURE__ */ new Set([
+        ...baseConfig.disallowedTools ?? [],
+        ...WORKFLOW_SUBAGENT_DISALLOWED_TOOLS
+      ])
+    )
+  };
+  let worktreeIsolation = null;
+  let effectiveContext = config;
+  let approvalCleanup;
+  if (opts.isolation !== void 0 && opts.workingDir !== void 0) {
+    throw new Error(
+      "agent({workingDir, isolation}): incompatible options. workingDir pins the agent to a worktree you already own; isolation creates a fresh one and removes it afterwards. Pass one."
+    );
+  }
+  if (opts.isolation === "worktree") {
+    worktreeIsolation = await provisionWorkflowWorktree(config);
+    effectiveContext = deriveWorktreeConfig(config, worktreeIsolation.path, {
+      customIgnoreFiles: config.getFileFilteringOptions().customIgnoreFiles
+    });
+    installSessionWorkflowRevisionWriteThrough(effectiveContext, config);
+  } else if (opts.workingDir !== void 0) {
+    if (typeof opts.workingDir !== "string" || opts.workingDir.trim().length === 0) {
+      throw new Error(
+        "agent({workingDir}): must be a non-empty string naming an existing git worktree of this repository."
+      );
+    }
+    const resolved = await resolveExternalWorktreeDir(
+      config,
+      opts.workingDir,
+      "workingDir"
+    );
+    if ("error" in resolved) {
+      throw new Error(
+        `agent({workingDir: ${sanitizeForErrorMessage(JSON.stringify(opts.workingDir))}}): ${sanitizeForErrorMessage(resolved.error)}`
+      );
+    }
+    effectiveContext = deriveWorktreeConfig(config, resolved.path, {
+      customIgnoreFiles: config.getFileFilteringOptions().customIgnoreFiles
+    });
+    installSessionWorkflowRevisionWriteThrough(effectiveContext, config);
+  }
+  if (effectiveContext !== config) {
+    const approvalHandle = deriveApprovalModeConfig(
+      effectiveContext,
+      config.getApprovalMode()
+    );
+    approvalCleanup = approvalHandle.cleanup;
+    effectiveContext = approvalHandle.config;
+  }
+  let onParentAbort;
+  try {
+    let schemaState = null;
+    if (opts.schema !== void 0) {
+      effectiveContext = await createSchemaConfigOverride(
+        effectiveContext,
+        opts.schema
+      );
+      schemaState = createSchemaModeState();
+    }
+    let dispatchSignal = signal;
+    if (schemaState) {
+      const child = new AbortController();
+      if (signal) {
+        if (signal.aborted) {
+          child.abort(signal.reason);
+        } else {
+          onParentAbort = /* @__PURE__ */ __name(() => child.abort(signal.reason), "onParentAbort");
+          signal.addEventListener("abort", onParentAbort);
+        }
+      }
+      schemaState.abortController = child;
+      dispatchSignal = child.signal;
+    }
+    const eventEmitter = emitter ?? (schemaState ? new AgentEventEmitter() : void 0);
+    if (schemaState && eventEmitter) {
+      attachSchemaListeners(eventEmitter, schemaState);
+    }
+    const { subagent, dispose } = await subagentMgr.createAgentHeadless(
+      augmented,
+      effectiveContext,
+      {
+        // Workflow always bounds resource ceiling regardless of agentType's
+        // own runConfig / maxTurns — these are workflow-level safety bounds,
+        // not subagent-level preferences. P5 will refine via budget.
+        runConfigOverrides: subagentBounds ?? {
+          max_turns: resolveSubagentMaxTurns(),
+          max_time_minutes: resolveSubagentMaxTimeMinutes()
+        },
+        eventEmitter,
+        taskName: String(ctx.get("task_prompt")),
+        subagentId: workflowAgentId
+      }
+    );
+    try {
+      try {
+        await runWithAgentContext(
+          workflowAgentId,
+          () => subagent.execute(ctx, dispatchSignal)
+        );
+      } finally {
+        reportTokens(subagent, opts, onTokens);
+      }
+      if (schemaState) {
+        if (schemaState.result !== null) {
+          if (worktreeIsolation) {
+            const isolation = worktreeIsolation;
+            worktreeIsolation = null;
+            const preserved = await cleanupWorkflowWorktree(isolation);
+            if (preserved) {
+              debugLogger.info(
+                `[Workflow] Schema-mode subagent preserved worktree at ${preserved.path ?? "(directory removed)"} on branch ${preserved.branch}. The structured payload is returned verbatim; recover the work from the preserved path / branch.`
+              );
+            }
+          }
+          return schemaState.result;
+        }
+        if (signal?.aborted) {
+          throw new DOMException("Workflow aborted.", "AbortError");
+        }
+        const mode2 = subagent.getTerminateMode();
+        if (mode2 !== "GOAL" /* GOAL */ && mode2 !== "CANCELLED" /* CANCELLED */) {
+          throw terminalDispatchError(workflowAgentId, mode2);
+        }
+        if (schemaState.attempts > 2) {
+          throw new WorkflowAgentFailedError(
+            "subagent completed without calling StructuredOutput (after 2 in-conversation nudges).",
+            "no_structured_output"
+          );
+        }
+        throw new WorkflowAgentFailedError(
+          "subagent completed without calling structured_output (no validation attempt \u2014 model produced plain-text content).",
+          "no_structured_output"
+        );
+      }
+      const mode = subagent.getTerminateMode();
+      if (mode !== "GOAL" /* GOAL */) {
+        throw terminalDispatchError(workflowAgentId, mode);
+      }
+      let finalText = toModelVisibleSubagentResult(
+        subagent.getFinalText(),
+        mode
+      );
+      if (worktreeIsolation) {
+        const isolation = worktreeIsolation;
+        worktreeIsolation = null;
+        const preserved = await cleanupWorkflowWorktree(isolation);
+        if (preserved && typeof finalText === "string") {
+          finalText = appendWorktreePreservedSuffix(finalText, preserved);
+        }
+      }
+      return finalText;
+    } finally {
+      await dispose();
+    }
+  } finally {
+    if (onParentAbort && signal) {
+      signal.removeEventListener("abort", onParentAbort);
+    }
+    approvalCleanup?.();
+    if (worktreeIsolation) {
+      try {
+        await cleanupWorkflowWorktree(worktreeIsolation);
+      } catch (error) {
+        debugLogger.warn(
+          `Workflow worktree cleanup in fallback finally failed for ${worktreeIsolation.path}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+}
+__name(runOverridePath, "runOverridePath");
+async function provisionWorkflowWorktree(config) {
+  const cwd = config.getTargetDir();
+  if (/\.qwen[\\/]worktrees[\\/]/.test(cwd)) {
+    throw new Error(
+      `agent({isolation:'worktree'}): parent is already inside a worktree (${cwd}). Nested isolation worktrees are not supported \u2014 the subagent's inherited paths would still reference the outer worktree.`
+    );
+  }
+  const probe = new GitWorktreeService(cwd);
+  const gitCheck = await probe.checkGitAvailable();
+  if (!gitCheck.available) {
+    throw new Error(
+      `agent({isolation:'worktree'}): ${gitCheck.error ?? "git is not available"}.`
+    );
+  }
+  if (!await probe.isGitRepository()) {
+    throw new Error(
+      `agent({isolation:'worktree'}): ${cwd} is not a git repository.`
+    );
+  }
+  const projectRoot = await probe.getRepoTopLevel() ?? cwd;
+  const wtService = projectRoot === cwd ? probe : new GitWorktreeService(projectRoot);
+  let parentDirty = false;
+  try {
+    parentDirty = await wtService.hasWorktreeChanges(projectRoot);
+  } catch (error) {
+    debugLogger.warn(
+      `[Workflow] hasWorktreeChanges failed at ${projectRoot}: ${error}`
+    );
+    parentDirty = true;
+  }
+  if (parentDirty) {
+    throw new Error(
+      `agent({isolation:'worktree'}): parent working tree at ${projectRoot} has uncommitted changes that would not propagate into the isolated worktree. The subagent would see the prior HEAD instead of the current state. Commit or stash the changes, then re-run.`
+    );
+  }
+  const slug = generateAgentWorktreeSlug();
+  let parentBranch;
+  try {
+    parentBranch = await wtService.getCurrentBranch();
+  } catch (error) {
+    debugLogger.warn(
+      `[Workflow] getCurrentBranch failed at ${projectRoot}: ${error}`
+    );
+  }
+  const created = await wtService.createUserWorktree(slug, parentBranch, {
+    symlinkDirectories: config.getWorktreeSymlinkDirectories()
+  });
+  if (!created.success || !created.worktree) {
+    throw new Error(
+      `agent({isolation:'worktree'}): failed to create worktree: ${created.error ?? "unknown error"}.`
+    );
+  }
+  try {
+    await writeWorktreeSessionMarker(
+      created.worktree.path,
+      config.getSessionId()
+    );
+  } catch (error) {
+    debugLogger.warn(
+      `[Workflow] failed to write session marker at ${created.worktree.path}: ${error}`
+    );
+  }
+  return {
+    slug,
+    path: created.worktree.path,
+    branch: created.worktree.branch,
+    repoRoot: projectRoot
+  };
+}
+__name(provisionWorkflowWorktree, "provisionWorkflowWorktree");
+async function cleanupWorkflowWorktree(isolation) {
+  const wtService = new GitWorktreeService(isolation.repoRoot);
+  const [hasChanges, hasUnmerged] = await Promise.all([
+    wtService.hasWorktreeChanges(isolation.path).catch((error) => {
+      debugLogger.warn(
+        `[Workflow] hasWorktreeChanges failed for ${isolation.path}: ${error}`
+      );
+      return true;
+    }),
+    wtService.hasUnmergedWorktreeCommits(isolation.slug).catch((error) => {
+      debugLogger.warn(
+        `[Workflow] hasUnmergedWorktreeCommits failed for ${isolation.slug}: ${error}`
+      );
+      return true;
+    })
+  ]);
+  if (hasChanges || hasUnmerged) {
+    debugLogger.info(
+      `[Workflow] Preserving isolation worktree ${isolation.path} (branch ${isolation.branch}, hasChanges=${hasChanges}, hasUnmerged=${hasUnmerged})`
+    );
+    return { path: isolation.path, branch: isolation.branch };
+  }
+  try {
+    const result = await wtService.removeUserWorktree(isolation.slug, {
+      deleteBranch: true
+    });
+    if (!result.success) {
+      debugLogger.warn(
+        `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${result.error}`
+      );
+      return { path: isolation.path, branch: isolation.branch };
+    }
+    if (result.branchPreserved) {
+      debugLogger.warn(
+        `[Workflow] Removed worktree directory ${isolation.path} but kept branch ${isolation.branch} (unmerged commits at delete time)`
+      );
+      return { branch: isolation.branch };
+    }
+  } catch (error) {
+    debugLogger.warn(
+      `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${error}`
+    );
+    return { path: isolation.path, branch: isolation.branch };
+  }
+  return null;
+}
+__name(cleanupWorkflowWorktree, "cleanupWorkflowWorktree");
+function appendWorktreePreservedSuffix(finalText, preserved) {
+  const sep2 = finalText.endsWith("\n") ? "\n" : "\n\n";
+  if (preserved.path) {
+    return `${finalText}${sep2}[worktree preserved: ${preserved.path} (branch ${preserved.branch})]`;
+  }
+  return `${finalText}${sep2}[worktree directory removed; branch ${preserved.branch} preserved \u2014 recover with \`git worktree add <path> ${preserved.branch}\`]`;
+}
+__name(appendWorktreePreservedSuffix, "appendWorktreePreservedSuffix");
+function createSchemaModeState() {
+  return {
+    result: null,
+    attempts: 0,
+    pendingArgs: /* @__PURE__ */ new Map(),
+    abortController: new AbortController()
+  };
+}
+__name(createSchemaModeState, "createSchemaModeState");
+function attachSchemaListeners(emitter, state) {
+  const targetTool = ToolNames.STRUCTURED_OUTPUT;
+  emitter.on("tool_call" /* TOOL_CALL */, (evt) => {
+    if (evt.name !== targetTool) return;
+    state.pendingArgs.set(evt.callId, evt.args);
+  });
+  emitter.on("tool_result" /* TOOL_RESULT */, (evt) => {
+    if (evt.name !== targetTool) return;
+    const args = state.pendingArgs.get(evt.callId);
+    state.pendingArgs.delete(evt.callId);
+    if (evt.success) {
+      if (args !== void 0 && state.result === null) {
+        state.result = args;
+        state.abortController.abort();
+      }
+      return;
+    }
+    state.attempts += 1;
+    if (state.attempts > 2 && state.result === null) {
+      state.abortController.abort();
+    }
+  });
+}
+__name(attachSchemaListeners, "attachSchemaListeners");
+async function createSchemaConfigOverride(base, schema) {
+  const override = deriveConfig(base);
+  installSessionWorkflowRevisionWriteThrough(override, base);
+  await rebuildToolRegistryOnOverride(override, base);
+  const registry = override.getToolRegistry();
+  registry.registerTool(new SyntheticOutputTool(schema));
+  return override;
+}
+__name(createSchemaConfigOverride, "createSchemaConfigOverride");
+var WorkflowOrchestrator = class {
+  constructor(dispatch) {
+    this.dispatch = dispatch;
+  }
+  static {
+    __name(this, "WorkflowOrchestrator");
+  }
+  async run(req) {
+    const runId = req.runId ?? generateRunId();
+    const maxAgents = resolveMaxAgentsPerRun();
+    const signal = req.abortOnTimeout?.signal;
+    const scheduler = req.scheduler ?? new WorkflowDispatchScheduler(resolveConcurrencyLimit(), signal);
+    const rejectThroughPauseGate = /* @__PURE__ */ __name((error) => scheduler.waitUntilRunning().then(
+      () => {
+        throw error;
+      },
+      () => {
+        throw error;
+      }
+    ), "rejectThroughPauseGate");
+    let agentCount = 0;
+    let dispatchTraceCount = 0;
+    const emitter = req.emitter;
+    const budget = req.budget;
+    const dependencyContext = new AsyncLocalStorage();
+    const issueDispatchTrace = /* @__PURE__ */ __name((prompt, opts, cached = false) => {
+      const id = `dispatch-${dispatchTraceCount += 1}`;
+      const store = dependencyContext.getStore();
+      const dependsOn = Array.from(new Set(store?.tails ?? []));
+      if (store) store.tails = [id];
+      try {
+        emitter?.dispatchQueued?.({
+          id,
+          ...typeof opts.label === "string" ? { label: opts.label } : {},
+          prompt,
+          dependsOn,
+          queuedAt: Date.now(),
+          ...cached ? { cached: true } : {}
+        });
+      } catch (e) {
+        debugLogger.warn("emitter.dispatchQueued threw:", e);
+      }
+      return id;
+    }, "issueDispatchTrace");
+    const journal = req.journal;
+    const replay = req.resumeReplay;
+    let prefixHash = deriveArgsSeed(req.args);
+    let hadMiss = false;
+    let journalAgentId = 0;
+    const parentSandboxRef = {
+      current: void 0
+    };
+    const countedDispatch = /* @__PURE__ */ __name((prompt, opts) => {
+      if (typeof prompt !== "string" || prompt.length === 0) {
+        return rejectThroughPauseGate(
+          new Error("agent() requires a non-empty string prompt.")
+        );
+      }
+      let journalKey;
+      let journalEntryId;
+      let respawnLine;
+      if (journal) {
+        journalKey = deriveAgentKey(prefixHash, prompt, opts);
+        prefixHash = journalKey;
+        if (!hadMiss && replay) {
+          const cached = replay.results.get(journalKey);
+          if (cached !== void 0) {
+            const respawns = replay.started.get(journalKey);
+            if (respawns && respawns.length > 0) {
+              debugLogger.info(
+                `[Workflow] resume cache hit after ${respawns.length} prior respawn(s) for runId=${runId}.`
+              );
+            }
+            const label2 = typeof opts.label === "string" ? opts.label : void 0;
+            const dispatchId2 = issueDispatchTrace(prompt, opts, true);
+            try {
+              emitter?.agentDispatched?.(label2);
+            } catch (e) {
+              debugLogger.warn("emitter.agentDispatched threw:", e);
+            }
+            try {
+              emitter?.agentCompleted?.(label2);
+            } catch (e) {
+              debugLogger.warn("emitter.agentCompleted threw:", e);
+            }
+            try {
+              emitter?.dispatchSettled?.(dispatchId2, void 0, Date.now());
+            } catch (e) {
+              debugLogger.warn("emitter.dispatchSettled threw:", e);
+            }
+            return scheduler.waitUntilRunning().then(
+              () => cached.result,
+              () => cached.result
+            );
+          }
+        }
+        const priorStarts = replay?.started.get(journalKey);
+        if (priorStarts && priorStarts.length > 0 && !replay?.results.has(journalKey)) {
+          const name = typeof opts.label === "string" ? `"${stripAnsiAndControl(opts.label)}"` : "an agent";
+          respawnLine = replay?.failed.has(journalKey) ? `[resume] re-running ${name}: it failed in the previous run` : `[resume] respawning ${name}: interrupted in a previous run (${priorStarts.length} prior attempt${priorStarts.length === 1 ? "" : "s"})`;
+        }
+        hadMiss = true;
+      }
+      if (budget && budget.total !== null && budget.remaining() <= 0) {
+        debugLogger.warn(
+          `[Workflow] budget gate refused dispatch at entry: runId=${runId} spent=${budget.spent()} total=${budget.total}`
+        );
+        return rejectThroughPauseGate(
+          new WorkflowBudgetExceededError(runId, budget.total, budget.spent())
+        );
+      }
+      if (agentCount >= maxAgents) {
+        return rejectThroughPauseGate(
+          new WorkflowAgentCapExceededError(maxAgents)
+        );
+      }
+      agentCount += 1;
+      if (journal && journalKey !== void 0) {
+        journalEntryId = String(journalAgentId += 1);
+      }
+      const label = typeof opts.label === "string" ? opts.label : void 0;
+      const dispatchId = issueDispatchTrace(prompt, opts);
+      try {
+        emitter?.agentDispatched?.(label);
+      } catch (e) {
+        debugLogger.warn("emitter.agentDispatched threw:", e);
+      }
+      let completionEmitted = false;
+      const emitCompletion = /* @__PURE__ */ __name((error) => {
+        if (completionEmitted) return;
+        completionEmitted = true;
+        const message = error === void 0 ? void 0 : error instanceof Error ? error.message : String(error);
+        try {
+          emitter?.agentCompleted?.(label, message);
+        } catch (e) {
+          debugLogger.warn("emitter.agentCompleted threw:", e);
+        }
+        try {
+          emitter?.dispatchSettled?.(dispatchId, message, Date.now());
+        } catch (e) {
+          debugLogger.warn("emitter.dispatchSettled threw:", e);
+        }
+      }, "emitCompletion");
+      return scheduler.run(async () => {
+        try {
+          try {
+            emitter?.dispatchStarted?.(dispatchId, Date.now());
+          } catch (e) {
+            debugLogger.warn("emitter.dispatchStarted threw:", e);
+          }
+          if (budget && budget.total !== null && budget.remaining() <= 0) {
+            debugLogger.warn(
+              `[Workflow] budget gate refused dispatch at slot-acquire: runId=${runId} spent=${budget.spent()} total=${budget.total}`
+            );
+            throw new WorkflowBudgetExceededError(
+              runId,
+              budget.total,
+              budget.spent()
+            );
+          }
+          if (journal && journalKey !== void 0 && journalEntryId !== void 0) {
+            journal.append({
+              type: "started",
+              key: journalKey,
+              agentId: journalEntryId
+            }).catch(
+              (e) => debugLogger.warn(`journal started-append failed: ${e}`)
+            );
+          }
+          if (respawnLine) {
+            parentSandboxRef.current?.appendLog(respawnLine);
+            try {
+              emitter?.resumeRespawn?.(respawnLine);
+            } catch (e) {
+              debugLogger.warn("emitter.resumeRespawn threw:", e);
+            }
+          }
+          const result = await this.dispatch(prompt, opts, dispatchId);
+          emitCompletion();
+          if (journal && journalKey !== void 0) {
+            journal.append({
+              type: "result",
+              key: journalKey,
+              agentId: journalEntryId ?? "",
+              result
+            }).catch(
+              (e) => debugLogger.warn(`journal result-append failed: ${e}`)
+            );
+          }
+          if (budget) {
+            try {
+              emitter?.budgetUpdated?.(budget.spent(), budget.total);
+            } catch (e) {
+              debugLogger.warn("emitter.budgetUpdated threw:", e);
+            }
+          }
+          return result;
+        } catch (err) {
+          emitCompletion(err);
+          if (budget) {
+            try {
+              emitter?.budgetUpdated?.(budget.spent(), budget.total);
+            } catch (e) {
+              debugLogger.warn("emitter.budgetUpdated threw:", e);
+            }
+          }
+          if (journal && journalKey !== void 0 && !signal?.aborted && !isWorkflowRunLevelError(err)) {
+            journal.append({
+              type: "failed",
+              key: journalKey,
+              agentId: journalEntryId ?? ""
+            }).catch(
+              (e) => debugLogger.warn(`journal failed-append failed: ${e}`)
+            );
+          }
+          if (signal?.aborted || isWorkflowRunLevelError(err)) throw err;
+          if (isWorkflowAgentFailedError(err)) {
+            debugLogger.warn(
+              `[Workflow] agent settled to null (${err.kind}): ${err.message}`
+            );
+          } else {
+            debugLogger.warn(
+              `[Workflow] agent settled to null: ${extractErrorMessage(err)}`
+            );
+          }
+          return null;
+        }
+      }).then(
+        // Resolve even if the gate aborts: a successful dispatch must not
+        // turn into a teardown rejection — for a fire-and-forget call the
+        // script never attached a handler, so the rejection would surface
+        // as a spurious process-level unhandledRejection alarm on a
+        // correctly-cancelled run.
+        (result) => scheduler.waitUntilRunning().then(
+          () => result,
+          () => result
+        ),
+        (error) => {
+          emitCompletion(error);
+          return scheduler.waitUntilRunning().then(
+            () => {
+              throw error;
+            },
+            () => {
+              throw error;
+            }
+          );
+        }
+      );
+    }, "countedDispatch");
+    const parallelImpl = makeParallelImpl(signal, dependencyContext);
+    const pipelineImpl = makePipelineImpl(signal, dependencyContext);
+    const resolveSavedWorkflow = req.resolveSavedWorkflow;
+    const workflowImpl = resolveSavedWorkflow ? async (nameOrRef, nestedArgs) => {
+      const resolved = await resolveSavedWorkflow(nameOrRef);
+      const nestedSandbox = createWorkflowSandbox({
+        args: nestedArgs,
+        runId,
+        dispatch: countedDispatch,
+        parallel: parallelImpl,
+        pipeline: pipelineImpl,
+        abortOnTimeout: req.abortOnTimeout,
+        emitter,
+        budget,
+        scheduler
+        // No `workflow` — single-level nesting limit.
+      });
+      try {
+        return await nestedSandbox.run(resolved.script);
+      } finally {
+        for (const line of nestedSandbox.getLogs()) {
+          parentSandboxRef.current?.appendLog(line);
+        }
+      }
+    } : void 0;
+    const sandbox = createWorkflowSandbox({
+      args: req.args,
+      maxWallClockMs: req.maxWallClockMs,
+      runId,
+      dispatch: countedDispatch,
+      parallel: parallelImpl,
+      pipeline: pipelineImpl,
+      workflow: workflowImpl,
+      abortOnTimeout: req.abortOnTimeout,
+      emitter,
+      budget,
+      scheduler
+    });
+    parentSandboxRef.current = sandbox;
+    try {
+      const result = await dependencyContext.run(
+        { tails: [] },
+        () => sandbox.run(req.script)
+      );
+      return {
+        runId,
+        result,
+        phases: sandbox.getPhases(),
+        logs: sandbox.getLogs(),
+        meta: sandbox.getMeta()
+      };
+    } catch (err) {
+      throw new WorkflowExecutionError(
+        extractErrorMessage(err),
+        sandbox.getPhases(),
+        sandbox.getLogs(),
+        sandbox.getMeta()
+      );
+    }
+  }
+};
+async function settleToNullArray(thunks, signal) {
+  const settled = await Promise.allSettled(
+    thunks.map((t) => Promise.resolve().then(t))
+  );
+  if (signal?.aborted)
+    throw new DOMException("Workflow run aborted.", "AbortError");
+  const visitedReasons = /* @__PURE__ */ new WeakSet();
+  const findRunFailureReason = /* @__PURE__ */ __name((reason) => {
+    if (reason === null || typeof reason !== "object") return void 0;
+    if (visitedReasons.has(reason)) return void 0;
+    visitedReasons.add(reason);
+    try {
+      if (reason.__wfRunFailure === true) {
+        return reason;
+      }
+      const errors = reason?.errors;
+      if (!Array.isArray(errors)) return void 0;
+      for (const error of errors) {
+        const runFailure = findRunFailureReason(error);
+        if (runFailure !== void 0) return runFailure;
+      }
+    } catch {
+      return void 0;
+    }
+    return void 0;
+  }, "findRunFailureReason");
+  for (const result of settled) {
+    if (result.status !== "rejected") continue;
+    const runFailure = findRunFailureReason(result.reason);
+    if (runFailure !== void 0) throw runFailure;
+  }
+  return settled.map((r, i) => {
+    if (r.status === "fulfilled") return r.value;
+    const reason = r.reason;
+    debugLogger.warn(
+      `Workflow thunk at index ${i} rejected: ${String(reason?.message ?? r.reason)}`
+    );
+    return null;
+  });
+}
+__name(settleToNullArray, "settleToNullArray");
+function makeParallelImpl(signal, dependencyContext) {
+  return (thunks) => {
+    if (!Array.isArray(thunks)) {
+      return Promise.reject(
+        new Error(
+          "parallel() expects an array of thunks (functions returning promises)."
+        )
+      );
+    }
+    for (const t of thunks) {
+      if (typeof t !== "function") {
+        return Promise.reject(
+          new Error(
+            "parallel() expects an array of functions, not values \u2014 wrap each call: parallel([() => agent(...), () => agent(...)])."
+          )
+        );
+      }
+    }
+    const parent = dependencyContext.getStore();
+    const inheritedTails = parent?.tails ?? [];
+    const branches = thunks.map((thunk) => {
+      const store = { tails: [...inheritedTails] };
+      return {
+        store,
+        thunk: /* @__PURE__ */ __name(() => dependencyContext.run(store, thunk), "thunk")
+      };
+    });
+    return settleToNullArray(
+      branches.map(({ thunk }) => thunk),
+      signal
+    ).then((result) => {
+      if (parent && branches.length > 0) {
+        parent.tails = mergeFanoutTails(
+          parent.tails,
+          inheritedTails,
+          branches.flatMap(({ store }) => store.tails)
+        );
+      }
+      return result;
+    });
+  };
+}
+__name(makeParallelImpl, "makeParallelImpl");
+function makePipelineImpl(signal, dependencyContext) {
+  return (items, ...stages) => {
+    if (!Array.isArray(items)) {
+      return Promise.reject(
+        new Error(
+          "pipeline() expects an array of items as its first argument."
+        )
+      );
+    }
+    for (const s of stages) {
+      if (typeof s !== "function") {
+        return Promise.reject(
+          new Error(
+            "pipeline() stages must be functions: pipeline(items, item => ..., result => ...)."
+          )
+        );
+      }
+    }
+    const parent = dependencyContext.getStore();
+    const inheritedTails = parent?.tails ?? [];
+    const branches = items.map((item, idx) => {
+      const store = { tails: [...inheritedTails] };
+      return {
+        store,
+        thunk: /* @__PURE__ */ __name(() => dependencyContext.run(
+          store,
+          () => runPipelineChain(item, idx, stages)
+        ), "thunk")
+      };
+    });
+    return settleToNullArray(
+      branches.map(({ thunk }) => thunk),
+      signal
+    ).then((result) => {
+      if (parent && branches.length > 0) {
+        parent.tails = mergeFanoutTails(
+          parent.tails,
+          inheritedTails,
+          branches.flatMap(({ store }) => store.tails)
+        );
+      }
+      return result;
+    });
+  };
+}
+__name(makePipelineImpl, "makePipelineImpl");
+function mergeFanoutTails(currentParentTails, inheritedTails, branchTails) {
+  const inherited = new Set(inheritedTails);
+  const newBranchTails = branchTails.filter((tail) => !inherited.has(tail));
+  const merged = newBranchTails.length > 0 ? [
+    ...newBranchTails,
+    ...currentParentTails.filter((tail) => !inherited.has(tail))
+  ] : currentParentTails;
+  return Array.from(new Set(merged));
+}
+__name(mergeFanoutTails, "mergeFanoutTails");
+async function runPipelineChain(item, idx, stages) {
+  let prev = item;
+  for (const stage of stages) {
+    if (prev === null) break;
+    prev = await stage(prev, item, idx);
+  }
+  return prev;
+}
+__name(runPipelineChain, "runPipelineChain");
+function extractErrorMessage(err) {
+  if (err && typeof err === "object" && "message" in err) {
+    const m = err.message;
+    if (typeof m === "string") return m;
+    return String(m);
+  }
+  return String(err);
+}
+__name(extractErrorMessage, "extractErrorMessage");
+
+// packages/core/src/agents/workflow-snapshot.ts
+init_esbuild_shims();
+import { promises as fs3 } from "node:fs";
+import path3 from "node:path";
+var debugLogger6 = createDebugLogger("WORKFLOW_SNAPSHOT");
 var MAX_RETAINED_SNAPSHOTS = 30;
 function toSnapshot(task) {
   if (!isTerminalWorkflowStatus(task.status)) {
@@ -1913,8 +3648,8 @@ async function writeWorkflowSnapshot(config, task) {
   try {
     const snapshot = toSnapshot(task);
     const dir = storage.getWorkflowRunsDir();
-    await fs2.mkdir(dir, { recursive: true });
-    await fs2.writeFile(
+    await fs3.mkdir(dir, { recursive: true });
+    await fs3.writeFile(
       storage.getWorkflowRunSnapshotPath(task.runId),
       JSON.stringify(snapshot, null, 2),
       "utf8"
@@ -1922,7 +3657,7 @@ async function writeWorkflowSnapshot(config, task) {
     await pruneSnapshots(config, dir);
     return true;
   } catch (e) {
-    debugLogger3.warn(`writeWorkflowSnapshot failed for ${task.runId}: ${e}`);
+    debugLogger6.warn(`writeWorkflowSnapshot failed for ${task.runId}: ${e}`);
     return false;
   }
 }
@@ -1933,22 +3668,22 @@ async function listWorkflowSnapshots(config) {
   const dir = storage.getWorkflowRunsDir();
   let files;
   try {
-    files = (await fs2.readdir(dir)).filter((f) => f.endsWith(".json"));
+    files = (await fs3.readdir(dir)).filter((f) => f.endsWith(".json"));
   } catch {
     return [];
   }
   const snapshots = [];
   for (const file of files) {
     try {
-      const raw = await fs2.readFile(`${dir}/${file}`, "utf8");
+      const raw = await fs3.readFile(`${dir}/${file}`, "utf8");
       const parsed = JSON.parse(raw);
       if (!isWorkflowSnapshot(parsed)) {
-        debugLogger3.warn(`skipping invalid workflow snapshot ${file}`);
+        debugLogger6.warn(`skipping invalid workflow snapshot ${file}`);
         continue;
       }
       snapshots.push(parsed);
     } catch (e) {
-      debugLogger3.warn(`skipping unparseable snapshot ${file}: ${e}`);
+      debugLogger6.warn(`skipping unparseable snapshot ${file}: ${e}`);
     }
   }
   snapshots.sort((a, b) => (b.startTime ?? 0) - (a.startTime ?? 0));
@@ -1959,20 +3694,20 @@ async function deleteWorkflowSnapshot(config, runId) {
   const storage = config.storage;
   if (!storage || !/^wf_[0-9a-f]+$/.test(runId)) return false;
   try {
-    await fs2.rm(path2.dirname(storage.getWorkflowRunJournalPath(runId)), {
+    await fs3.rm(path3.dirname(storage.getWorkflowRunJournalPath(runId)), {
       recursive: true,
       force: true
     });
   } catch (error) {
-    debugLogger3.warn(`delete workflow journal failed for ${runId}: ${error}`);
+    debugLogger6.warn(`delete workflow journal failed for ${runId}: ${error}`);
     return false;
   }
   if (!await deleteInlineWorkflowScript(config, runId)) return false;
   try {
-    await fs2.unlink(storage.getWorkflowRunSnapshotPath(runId));
+    await fs3.unlink(storage.getWorkflowRunSnapshotPath(runId));
   } catch (error) {
     if (error.code !== "ENOENT") {
-      debugLogger3.warn(`deleteWorkflowSnapshot failed for ${runId}: ${error}`);
+      debugLogger6.warn(`deleteWorkflowSnapshot failed for ${runId}: ${error}`);
       return false;
     }
   }
@@ -2070,7 +3805,7 @@ __name(isWorkflowSnapshot, "isWorkflowSnapshot");
 async function pruneSnapshots(config, dir) {
   let files;
   try {
-    files = (await fs2.readdir(dir)).filter((f) => f.endsWith(".json"));
+    files = (await fs3.readdir(dir)).filter((f) => f.endsWith(".json"));
   } catch {
     return;
   }
@@ -2078,7 +3813,7 @@ async function pruneSnapshots(config, dir) {
   const stats = await Promise.all(
     files.map(async (f) => {
       try {
-        const s = await fs2.stat(`${dir}/${f}`);
+        const s = await fs3.stat(`${dir}/${f}`);
         return { f, mtime: s.mtimeMs };
       } catch {
         return { f, mtime: 0 };
@@ -2098,15 +3833,15 @@ async function pruneSnapshots(config, dir) {
       const isRunDir = /^wf_[0-9a-f]+$/.test(runId);
       const deleteArtifacts = isRunDir && !protectedRunIds.has(runId) && !isWorkflowRunPersistenceActive(config, runId);
       return Promise.all([
-        fs2.unlink(`${dir}/${s.f}`).catch(
-          (e) => debugLogger3.warn(`prune unlink failed for ${s.f}: ${e}`)
+        fs3.unlink(`${dir}/${s.f}`).catch(
+          (e) => debugLogger6.warn(`prune unlink failed for ${s.f}: ${e}`)
         ),
         ...deleteArtifacts ? [
-          fs2.rm(
-            path2.dirname(config.storage.getWorkflowRunJournalPath(runId)),
+          fs3.rm(
+            path3.dirname(config.storage.getWorkflowRunJournalPath(runId)),
             { recursive: true, force: true }
           ).catch(
-            (e) => debugLogger3.warn(
+            (e) => debugLogger6.warn(
               `prune journal dir failed for ${runId}: ${e}`
             )
           ),
@@ -2118,12 +3853,79 @@ async function pruneSnapshots(config, dir) {
 }
 __name(pruneSnapshots, "pruneSnapshots");
 
+// packages/core/src/agents/runtime/review-workflow.ts
+init_esbuild_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { promises as fs4 } from "node:fs";
+import path4 from "node:path";
+var debugLogger7 = createDebugLogger("REVIEW_WORKFLOW");
+function resolveReviewWorkflowConcurrency(env = process.env) {
+  const configured = parsePositiveIntegerEnv(env[MAX_WORKFLOW_CONCURRENCY_ENV], 0) || parsePositiveIntegerEnv(env["QWEN_CODE_MAX_TOOL_CONCURRENCY"], 10);
+  return resolveConcurrencyLimit({
+    [MAX_WORKFLOW_CONCURRENCY_ENV]: String(configured)
+  });
+}
+__name(resolveReviewWorkflowConcurrency, "resolveReviewWorkflowConcurrency");
+async function resolveReviewWorkflowLimits(scriptPath, generatedDir, scriptContent, env = process.env, nowMs = Date.now()) {
+  let canonicalScript;
+  try {
+    if ((await fs4.lstat(generatedDir)).isSymbolicLink()) return void 0;
+    const generatedRoot = await fs4.realpath(generatedDir);
+    canonicalScript = await fs4.realpath(scriptPath);
+    if (!canonicalScript.startsWith(path4.join(generatedRoot, "review") + path4.sep)) {
+      return void 0;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      debugLogger7.warn(
+        "Cannot classify review workflow; using generic limits:",
+        error
+      );
+    }
+    return void 0;
+  }
+  const digest = /^qwen-review-[a-f0-9]{10}-([a-f0-9]{64})\.js$/.exec(
+    path4.basename(canonicalScript)
+  )?.[1];
+  if (!digest || createHash2("sha256").update(scriptContent).digest("hex") !== digest) {
+    return void 0;
+  }
+  const seconds = Number(env["QWEN_CODE_MAX_WORKFLOW_SECONDS"]);
+  let maxWallClockMs = (Number.isFinite(seconds) && seconds > 0 ? seconds : 6 * 60 * 60) * 1e3;
+  const deadline = Number(env["QWEN_REVIEW_DEADLINE_EPOCH"]);
+  if (Number.isFinite(deadline) && deadline > 0) {
+    const rawFloor = env["QWEN_REVIEW_DEADLINE_COMPOSE_FLOOR_SECONDS"];
+    const floor = Number(rawFloor);
+    const floorSeconds = rawFloor?.trim() && Number.isFinite(floor) && floor >= 0 ? floor : 1200;
+    const remainingMs = deadline * 1e3 - nowMs - floorSeconds * 1e3;
+    if (remainingMs <= 0) {
+      throw new Error(
+        "Review workflow was not launched: the review deadline has reached the compose reserve floor. Recover completed findings and compose now."
+      );
+    }
+    maxWallClockMs = Math.min(maxWallClockMs, remainingMs);
+  }
+  return {
+    subagent: {
+      max_turns: resolveSubagentMaxTurns(env, 500),
+      max_time_minutes: resolveSubagentMaxTimeMinutes(env, 100)
+    },
+    concurrency: resolveReviewWorkflowConcurrency(env),
+    maxWallClockMs
+  };
+}
+__name(resolveReviewWorkflowLimits, "resolveReviewWorkflowLimits");
+
 export {
   extractAndStripMeta,
   compileWorkflowScript,
   describeWorkflowCompileError,
-  debugLogger,
-  createWorkflowSandbox,
+  MAX_TOKENS_PER_WORKFLOW_ENV,
+  resolveMaxTokensPerWorkflow,
+  WorkflowBudgetImpl,
+  DEFAULT_STALL_MS,
+  MAX_STALL_ATTEMPTS,
+  MAX_WORKFLOW_STALL_MS_ENV,
   validateWorkflowName,
   isSymlinkedRoot,
   listSavedWorkflows,
@@ -2131,11 +3933,26 @@ export {
   saveWorkflowScript,
   persistInlineWorkflowScript,
   deleteInlineWorkflowScript,
+  WorkflowJournal,
+  WorkflowDispatchScheduler,
+  DEFAULT_MAX_AGENTS_PER_RUN,
+  MAX_WORKFLOW_AGENTS_ENV,
+  MAX_WORKFLOW_CONCURRENCY_ENV,
+  resolveConcurrencyLimit,
+  DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS,
+  DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES,
+  WORKFLOW_SUBAGENT_MAX_TURNS_ENV,
+  WORKFLOW_SUBAGENT_MAX_MINUTES_ENV,
+  WorkflowExecutionError,
+  createProductionDispatch,
+  WorkflowOrchestrator,
   MAX_RETAINED_SNAPSHOTS,
   toSnapshot,
   writeWorkflowSnapshot,
   listWorkflowSnapshots,
-  deleteWorkflowSnapshot
+  deleteWorkflowSnapshot,
+  resolveReviewWorkflowConcurrency,
+  resolveReviewWorkflowLimits
 };
 /**
  * @license