@qwen-code/qwen-code 0.21.7 → 0.21.8-nightly.20260810.55e20db328

package/chunks/{workflow-ERH3SJG2.js → workflow-6MKLKQ6R.js}

@@ -5,29 +5,30 @@ import {
   FileDiscoveryService,
   GitWorktreeService,
   generateAgentWorktreeSlug,
+  isTerminalWorkflowStatus,
   rebuildToolRegistryOnOverride,
   resolveSavedWorkflowScript,
   stripAnsiAndControl,
   toModelVisibleSubagentResult,
   writeWorkflowSnapshot,
   writeWorktreeSessionMarker
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-47ZUMGGY.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-CNIID3TV.js";
+import "./chunk-2UUMVNYT.js";
 import "./chunk-MVUQRLOH.js";
 import "./chunk-XCWO3SMQ.js";
 import "./chunk-7MH4J33A.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-RMH5OWLD.js";
+import "./chunk-F3II4BTZ.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-GNPNYXJB.js";
-import "./chunk-Y4NGLFGJ.js";
+import "./chunk-HUWENAHO.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
 import "./chunk-ZPJWUGCS.js";
@@ -36,65 +37,70 @@ import "./chunk-J6SZID63.js";
 import "./chunk-KRXPRVGL.js";
 import "./chunk-GM463R2B.js";
 import "./chunk-SEZ556DZ.js";
-import "./chunk-CJXIIILK.js";
-import "./chunk-3K7FH2KQ.js";
+import "./chunk-2FRY5CRX.js";
+import "./chunk-67N6HB5H.js";
+import {
+  SUBAGENT_PLAN_LIFECYCLE_TOOLS
+} from "./chunk-WAUGQKUU.js";
+import "./chunk-DZUO626D.js";
+import "./chunk-4TRQPFDP.js";
+import "./chunk-SAH4BD2J.js";
 import {
-  SUBAGENT_PLAN_LIFECYCLE_TOOLS,
   runWithAgentContext
-} from "./chunk-BVWVWGLE.js";
+} from "./chunk-CPG6P4GG.js";
 import "./chunk-S6LOFUVP.js";
-import "./chunk-LZC3B5N2.js";
+import "./chunk-2J3OJGTL.js";
+import "./chunk-IA7TGCN2.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import {
   WorkspaceContext
 } from "./chunk-EQL65XGA.js";
-import "./chunk-IIJEYBNH.js";
-import "./chunk-22NBYCPD.js";
+import "./chunk-3P2LV43B.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-3ULCB3NE.js";
-import "./chunk-BGG4MBYD.js";
+import "./chunk-HV76SFIA.js";
+import "./chunk-4PYCZH2V.js";
+import "./chunk-P3QQPMQA.js";
+import "./chunk-SR7RZ4MS.js";
+import "./chunk-M6HMMKVG.js";
 import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-AXMWHKXA.js";
+import "./chunk-GLCZKT5V.js";
 import {
   createAbortController,
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
-import "./chunk-33ACCIIY.js";
-import "./chunk-L4N6TIP7.js";
-import "./chunk-2J3OJGTL.js";
-import "./chunk-P3QQPMQA.js";
-import "./chunk-M6HMMKVG.js";
-import "./chunk-GLCZKT5V.js";
 import "./chunk-EI3HZX6C.js";
 import {
   WorkflowRunEvent,
   logWorkflowRun,
   read,
   writeLine
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-YGT2AUJ7.js";
 import "./chunk-WOJZWRAZ.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-FVKHVJZQ.js";
+import "./chunk-COBO5EBO.js";
 import {
   SyntheticOutputTool
-} from "./chunk-NG2R4N5O.js";
+} from "./chunk-6ZRFAKXK.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-IC4Z6LX6.js";
-import "./chunk-6EOI4HOK.js";
+} from "./chunk-PYQADEFD.js";
+import "./chunk-E2T7FLDU.js";
+import "./chunk-F6WFNA7U.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
 import "./chunk-KKBPOU75.js";
 import "./chunk-EUNWC2VS.js";
 import "./chunk-FOGU3LJX.js";
-import "./chunk-6M26GBKX.js";
+import "./chunk-L2AFWWJE.js";
 import "./chunk-W4RQUHY3.js";
-import "./chunk-LKRMNRSN.js";
+import "./chunk-PDPFQ2FO.js";
 import {
   createDebugLogger
 } from "./chunk-OIVKILPI.js";
@@ -114,95 +120,6 @@ import {
 // packages/core/src/tools/workflow/workflow.ts
 init_esbuild_shims();
 
-// packages/core/src/agents/runtime/workflow-budget.ts
-init_esbuild_shims();
-var debugLogger = 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) {
-    debugLogger.warn(
-      `Invalid ${MAX_TOKENS_PER_WORKFLOW_ENV}=${JSON.stringify(raw)}, treating as unset (no cap)`
-    );
-    return null;
-  }
-  if (parsed > HARD_MAX_TOKENS_CEILING) {
-    debugLogger.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-runner.ts
-init_esbuild_shims();
-import { randomBytes as randomBytes2 } from "node:crypto";
-
 // packages/core/src/agents/runtime/workflow-orchestrator.ts
 init_esbuild_shims();
 import { randomBytes } from "node:crypto";
@@ -388,7 +305,7 @@ function isRegexContext(source, i) {
   return /[{[(,;:=!&|?+\-*/%^~<>]/.test(prev);
 }
 __name(isRegexContext, "isRegexContext");
-var debugLogger2 = createDebugLogger("WORKFLOW");
+var debugLogger = createDebugLogger("WORKFLOW");
 var MAX_LOG_LINES = 1e4;
 var MAX_PHASE_ENTRIES = 1e4;
 var ARGS_MAX_DEPTH = 64;
@@ -402,6 +319,50 @@ function resolveMaxWallClockMs(opts) {
   return DEFAULT_MAX_WALL_CLOCK_MS;
 }
 __name(resolveMaxWallClockMs, "resolveMaxWallClockMs");
+var WallClockWatchdog = class {
+  constructor(budgetMs, onFire) {
+    this.onFire = onFire;
+    this.remainingMs = budgetMs;
+    this.arm();
+  }
+  static {
+    __name(this, "WallClockWatchdog");
+  }
+  timer;
+  remainingMs;
+  armedAt = 0;
+  paused = false;
+  stopped = false;
+  pause() {
+    if (this.stopped || this.paused || this.timer === void 0) return;
+    this.paused = true;
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    this.remainingMs = Math.max(
+      0,
+      this.remainingMs - (performance.now() - this.armedAt)
+    );
+  }
+  resume() {
+    if (this.stopped || !this.paused) return;
+    this.paused = false;
+    this.arm();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  arm() {
+    this.armedAt = performance.now();
+    this.timer = setTimeout(() => {
+      this.stopped = true;
+      this.timer = void 0;
+      this.onFire();
+    }, this.remainingMs);
+    this.timer.unref?.();
+  }
+};
 function validateArgs(val, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
   if (depth > ARGS_MAX_DEPTH) {
     throw new Error(
@@ -447,7 +408,7 @@ function createWorkflowSandbox(opts) {
       try {
         opts.emitter?.logAppended?.(line);
       } catch (e) {
-        debugLogger2.warn("emitter.logAppended threw:", e);
+        debugLogger.warn("emitter.logAppended threw:", e);
       }
     } else if (logs.length === MAX_LOG_LINES) {
       logs.push(`[workflow log truncated at ${MAX_LOG_LINES} lines]`);
@@ -461,7 +422,7 @@ function createWorkflowSandbox(opts) {
       try {
         opts.emitter?.phaseStarted?.(t);
       } catch (e) {
-        debugLogger2.warn("emitter.phaseStarted threw:", e);
+        debugLogger.warn("emitter.phaseStarted threw:", e);
       }
     } else if (phases.length === MAX_PHASE_ENTRIES) {
       phases.push(
@@ -471,6 +432,17 @@ function createWorkflowSandbox(opts) {
   }, "safePhase");
   if (opts.args !== void 0) validateArgs(opts.args);
   const argsJson = opts.args === void 0 ? null : JSON.stringify(opts.args);
+  const unconsumedRoots = /* @__PURE__ */ new Map();
+  const unconsumedRejections = /* @__PURE__ */ new Map();
+  let nextUnconsumedId = 1;
+  let unconsumedSettled = false;
+  let mirroredEscapeKeys = /* @__PURE__ */ new Set();
+  const unconsumedRejectionLine = /* @__PURE__ */ __name((rec) => {
+    if (rec.dispatchFailed) {
+      return rec.isRoot ? "dispatch failed (result not consumed): " + rec.msg : "dispatch failed (rejection not handled): " + rec.msg;
+    }
+    return "script handler failed (rejection not handled): " + rec.msg;
+  }, "unconsumedRejectionLine");
   const bridge = {
     argsJson,
     pushPhase: safePhase,
@@ -484,10 +456,56 @@ function createWorkflowSandbox(opts) {
     // value" (this warn). Receives only primitive strings/numbers — the bridge
     // contract forbids host objects crossing back to the script.
     logRevivalFailure: /* @__PURE__ */ __name((idx, reason) => {
-      debugLogger2.warn(
+      debugLogger.warn(
         `Workflow result revival failed at index ${idx}: ${reason}; slot set to null (non-JSON-serializable thunk return).`
       );
     }, "logRevivalFailure"),
+    // --- Unconsumed-rejection mirror bookkeeping ---
+    wfRegisterRoot: /* @__PURE__ */ __name(() => {
+      const id = nextUnconsumedId++;
+      unconsumedRoots.set(id, { rejectionHandled: false, adoptedOut: false });
+      return id;
+    }, "wfRegisterRoot"),
+    wfMarkRejectionHandled: /* @__PURE__ */ __name((rootId) => {
+      const root = unconsumedRoots.get(rootId);
+      if (root) root.rejectionHandled = true;
+    }, "wfMarkRejectionHandled"),
+    wfIsRootHandled: /* @__PURE__ */ __name((rootId) => unconsumedRoots.get(rootId)?.rejectionHandled === true, "wfIsRootHandled"),
+    wfMarkAdopted: /* @__PURE__ */ __name((rootId) => {
+      const root = unconsumedRoots.get(rootId);
+      if (root) root.adoptedOut = true;
+    }, "wfMarkAdopted"),
+    runId: opts.runId ?? "",
+    wfReportUnconsumed: /* @__PURE__ */ __name((rootId, isRoot, dispatchFailed, msg) => {
+      if (unconsumedSettled) {
+        const rec = {
+          rootId,
+          isRoot,
+          dispatchFailed,
+          msg
+        };
+        const rootState = unconsumedRoots.get(rootId);
+        if (!rootState?.rejectionHandled && !(dispatchFailed && rootState?.adoptedOut)) {
+          safeLog(unconsumedRejectionLine(rec));
+        }
+        return 0;
+      }
+      const id = nextUnconsumedId++;
+      unconsumedRejections.set(id, { rootId, isRoot, dispatchFailed, msg });
+      return id;
+    }, "wfReportUnconsumed"),
+    wfClearUnconsumed: /* @__PURE__ */ __name((id) => {
+      unconsumedRejections.delete(id);
+    }, "wfClearUnconsumed"),
+    // R10-1: teardown discrimination cannot key on the error name alone.
+    // The dominant in-flight cancellation path (controller.abort() →
+    // subagent returns terminateMode=CANCELLED → runSingleDispatch throws
+    // a PLAIN Error) never produces an 'AbortError', so the mirror would
+    // log a spurious dispatch failure for a correctly-cancelled run. Once
+    // the run's abort signal has fired, the run is already settling as
+    // cancelled / timed-out — every rejection still crossing the boundary
+    // is teardown noise regardless of its shape.
+    isRunAborted: /* @__PURE__ */ __name(() => opts.abortOnTimeout?.signal.aborted === true, "isRunAborted"),
     // The truthy flags distinguish "injected" from "default stub" inside the
     // init script without leaking the host function itself when not used.
     hasParallel: !!opts.parallel,
@@ -555,27 +573,318 @@ function createWorkflowSandbox(opts) {
       // those wrappers will produce vm-realm results); reject with a
       // freshly-constructed vm-realm Error so e.constructor.constructor
       // stays in the vm realm.
+      // Dispatch promises are ObservedPromise instances (a vm-realm
+      // Promise subclass). Its then override marks the result consumed
+      // and re-attaches the teardown observer to the derived promise, so
+      // script-derived chains (agent(...).then(...), await, and the
+      // ELEMENTS of static-combinator aggregates \u2014 everything that
+      // funnels through then) stay observed at every depth. The
+      // AGGREGATES of Promise.all/race/any are built by the native
+      // statics and never pass through the observed then, so those
+      // statics are wrapped explicitly below (observeAggregate).
+      // Without this, a correctly-cancelled run holding a pending derived
+      // chain fired a process-level unhandledRejection even though the
+      // bare dispatch promise was observed.
+      //
+      // Unconsumed rejections of an observed node are recorded through
+      // the bridge and mirrored into the run log at run settlement (a
+      // later consumption clears the record first) \u2014 a dispatch refused
+      // at the entry gate (budget / agent cap) or failing mid-run reaches
+      // no other surface, so without the mirror the failure leaves no
+      // log, alarm, or telemetry.
+      function mapDispatchError(hostErr) {
+        var msg;
+        try {
+          msg = (hostErr && hostErr.message != null)
+            ? String(hostErr.message)
+            : String(hostErr);
+        } catch (e) {
+          msg = '[unserializable rejection value]';
+        }
+        const vmErr = new Error(msg);
+        // Teardown discrimination at the host boundary \u2014 before the error
+        // is flattened into a vm-realm Error. Two shapes count as
+        // teardown: an error NAMED 'AbortError' (the scheduler's
+        // abortError() DOMException), and ANY rejection that crosses
+        // after the run's abort signal has fired \u2014 the dominant
+        // cancellation path rejects with a plain Error ('did not complete
+        // (terminate mode: CANCELLED).'), which a name-only match would
+        // mirror as a spurious dispatch failure on a correctly-cancelled
+        // run. Matching the name here (rather than the message text)
+        // still suppresses teardown noise without swallowing genuine
+        // failures whose message merely contains 'aborted' (e.g. a
+        // network-layer 'connection aborted by peer').
+        var isAbort = false;
+        try {
+          isAbort = !!(hostErr && hostErr.name === 'AbortError');
+        } catch (e) {
+          isAbort = false;
+        }
+        if (isAbort || __b.isRunAborted()) vmErr.__wfAbort = true;
+        vmErr.__wfDispatchFailed = true;
+        return vmErr;
+      }
+      function readFlag(value, name) {
+        try {
+          return !!(value && value[name]);
+        } catch (e) {
+          return false;
+        }
+      }
+      function observeDispatch(promise) {
+        // Direct native-then call: routing through ObservedPromise.then
+        // would mark the promise consumed and recurse the observer. The
+        // observer body must be exception-safe on ANY rejection value:
+        // a script handler can throw an exotic value (a message getter
+        // that throws, a Proxy with throwing traps), and an observer
+        // killed mid-body would turn the very rejection it watches into
+        // a process-level unhandledRejection \u2014 the exact failure class
+        // the observer exists to remove.
+        Promise.prototype.then.call(promise, undefined, function (err) {
+          if (promise.__wfConsumed) return;
+          // R11-30: also suppress on the run-level abort state, not just
+          // the rejection's own marker \u2014 a wrapped Promise.any aggregate
+          // rejects with a natively built AggregateError that carries
+          // neither marker, so teardown rejections of a correctly-
+          // cancelled run would still be mirrored when it is unconsumed.
+          if (readFlag(err, '__wfAbort') || __b.isRunAborted()) return;
+          var dispatchFailed = readFlag(err, '__wfDispatchFailed');
+          var errors = null;
+          try {
+            if (err && Array.isArray(err.errors)) errors = err.errors;
+          } catch (e) {
+            errors = null;
+          }
+          if (!dispatchFailed && errors) {
+            // R11-4: Promise.any rejects with a fresh vm-realm
+            // AggregateError carrying no flags; the element errors are
+            // reachable on .errors with their markers preserved. Derive
+            // the attribution from the causes instead of blaming the
+            // script for a dispatch failure.
+            for (var i = 0; i < errors.length; i++) {
+              if (readFlag(errors[i], '__wfDispatchFailed')) {
+                dispatchFailed = true;
+                break;
+              }
+            }
+          }
+          // R11-15: cross-root suppression \u2014 aggregate roots track
+          // rejectionHandled independently of their elements' roots, so
+          // a forwarded dispatch failure whose originating element root
+          // the script already handled must not mirror from the
+          // aggregate. The element rootId is stamped in vmAsync;
+          // Promise.all/race forward the element's own reason,
+          // Promise.any surfaces them on .errors.
+          try {
+            var sourceIds = [];
+            if (err && err.__wfRootId) {
+              sourceIds.push(err.__wfRootId);
+            } else if (errors) {
+              for (var j = 0; j < errors.length; j++) {
+                if (errors[j] && errors[j].__wfRootId) {
+                  sourceIds.push(errors[j].__wfRootId);
+                }
+              }
+            }
+            for (var k = 0; k < sourceIds.length; k++) {
+              if (
+                sourceIds[k] !== promise.__wfRootId &&
+                __b.wfIsRootHandled(sourceIds[k])
+              ) {
+                return;
+              }
+            }
+          } catch (e) {
+            // A throwing exotic value must not kill the observer; fall
+            // through and mirror conservatively.
+          }
+          var msg;
+          try {
+            msg = String(err && err.message != null ? err.message : err);
+          } catch (e) {
+            msg = '[unserializable rejection value]';
+          }
+          promise.__wfUnconsumedId = __b.wfReportUnconsumed(
+            promise.__wfRootId,
+            promise.__wfIsRoot === true,
+            dispatchFailed,
+            msg,
+          );
+        });
+      }
+      // R11-3: await / Promise.resolve / returning a thenable from a
+      // handler adopts an ObservedPromise through this then with the
+      // adopting promise's capability (resolve, reject) pair \u2014 native
+      // functions, indistinguishable from real handlers by arity. They
+      // are detected by the native toString signature. Adoption
+      // CONSUMES the result (a delayed adoption clears a recorded
+      // verdict exactly like a delayed await) but is NOT a rejection
+      // handler: the rejection transfers into the adopting promise \u2014
+      // typically an async wrapper's implicit promise, which is a plain
+      // vm-realm Promise the mirror cannot observe. Marking adoption as
+      // handling would silently disarm the mirror for the forgotten-
+      // await failure class; the run-level escape hook in the host
+      // surfaces those escapes instead. Bound script functions also
+      // stringify as native code; misreading one as adoption only
+      // forgoes the rejectionHandled marking, never native semantics.
+      function isAdoptionAttach(handler) {
+        try {
+          return (
+            typeof handler === 'function' &&
+            Function.prototype.toString
+              .call(handler)
+              .indexOf('[native code]') !== -1
+          );
+        } catch (e) {
+          return false;
+        }
+      }
+      class ObservedPromise extends Promise {
+        then(onFulfilled, onRejected) {
+          // R11-26: introspect the handler BEFORE any state mutation.
+          // The read is guarded because a script-supplied handler can
+          // be exotic (a revoked Proxy wrapping a function, a throwing
+          // accessor) \u2014 an unguarded read made .then() throw
+          // synchronously, something native then never does, leaving
+          // the promise marked consumed with no handler attached.
+          var rethrows = false;
+          try {
+            rethrows = !!(onRejected && onRejected.__wfRethrows);
+          } catch (e) {
+            rethrows = false;
+          }
+          this.__wfConsumed = true;
+          // An attached rejection handler means the script can surface the
+          // root rejection itself; the mirror stays silent for it. The
+          // finally override below routes through this then with marked
+          // rethrow combinators \u2014 those re-raise the rejection instead of
+          // handling it, so they must NOT set the flag (marking them
+          // handled would silently drop a fire-and-forget
+          // agent(...).finally(...) failure). Adoption attaches count
+          // as consumption only, never handling (see isAdoptionAttach):
+          // they mark adoptedOut so forwarded sibling entries defer to
+          // the adopting chain / escape hook instead of mirroring.
+          if (isAdoptionAttach(onRejected)) {
+            __b.wfMarkAdopted(this.__wfRootId);
+          } else if (typeof onRejected === 'function' && !rethrows) {
+            __b.wfMarkRejectionHandled(this.__wfRootId);
+          }
+          // A delayed consumption clears a verdict recorded at
+          // rejection-settlement time, so a late-but-real await is not
+          // misreported as unconsumed.
+          if (this.__wfUnconsumedId !== undefined) {
+            __b.wfClearUnconsumed(this.__wfUnconsumedId);
+            this.__wfUnconsumedId = undefined;
+          }
+          const derived = super.then(onFulfilled, onRejected);
+          derived.__wfRootId = this.__wfRootId;
+          observeDispatch(derived);
+          return derived;
+        }
+        finally(onFinally) {
+          // Native Promise.prototype.finally calls the observed then with
+          // two function combinators, indistinguishable there from a real
+          // then(f, g) \u2014 which would mark the root rejection handled even
+          // though finally rethrows it. Implement finally through the
+          // observed then with an explicitly-marked rethrow combinator so
+          // the mirror stays armed for finally-only chains.
+          if (typeof onFinally !== 'function') {
+            return this.then(undefined, undefined);
+          }
+          const onRethrow = function (err) {
+            return Promise.resolve(onFinally()).then(function () {
+              throw err;
+            });
+          };
+          onRethrow.__wfRethrows = true;
+          return this.then(
+            function (value) {
+              return Promise.resolve(onFinally()).then(function () {
+                return value;
+              });
+            },
+            onRethrow,
+          );
+        }
+      }
+      // --- Static combinators: observe the aggregate promise ---
+      // Promise.all/race/any build their aggregate via the native static;
+      // it never passes through the observed then, so a fire-and-forget
+      // aggregate holding a failed dispatch would escape the run-log
+      // mirror. While the run is live the host's adoption-escape hook
+      // (R11-3) still catches and mirrors the process-level
+      // unhandledRejection \u2014 a round-14 A/B confirmed that hook, not
+      // this wrap, is the live-run backstop \u2014 but only with the coarse
+      // '(rejection not handled)' wording, and once the run's hook is
+      // detached nothing in the sandbox catches the escape. R14-A:
+      // wrapping the statics gives each aggregate its own observer, so
+      // consumption tracking works through the aggregate's own observed
+      // then (await / .catch / .then marks it handled) and the mirror
+      // itself classifies the rejection; the elements still funnel
+      // through the then override via the native static's internal
+      // attach, so they stay marked consumed.
+      function observeAggregate(nativeAggregate) {
+        const rootId = __b.wfRegisterRoot();
+        const observed = new ObservedPromise(function (resolve, reject) {
+          Promise.prototype.then.call(nativeAggregate, resolve, reject);
+        });
+        observed.__wfRootId = rootId;
+        observed.__wfIsRoot = true;
+        observeDispatch(observed);
+        return observed;
+      }
+      const nativePromiseAll = Promise.all;
+      const nativePromiseRace = Promise.race;
+      const nativePromiseAny = Promise.any;
+      // R11-16: a static called on a script-defined Promise subclass
+      // must honor the species contract and return a subclass instance,
+      // so non-default receivers bypass observation (their elements
+      // still funnel through the observed then, and a fire-and-forget
+      // dispatch failure escaping such an aggregate is still caught by
+      // the host's adoption-escape hook via its stamped markers).
+      Promise.all = function (items) {
+        if (this !== Promise) return nativePromiseAll.call(this, items);
+        return observeAggregate(nativePromiseAll.call(this, items));
+      };
+      Promise.race = function (items) {
+        if (this !== Promise) return nativePromiseRace.call(this, items);
+        return observeAggregate(nativePromiseRace.call(this, items));
+      };
+      Promise.any = function (items) {
+        if (this !== Promise) return nativePromiseAny.call(this, items);
+        return observeAggregate(nativePromiseAny.call(this, items));
+      };
       function vmAsync(hostFn) {
         return function (...vmArgs) {
-          return new Promise(function (resolve, reject) {
+          const rootId = __b.wfRegisterRoot();
+          const p = new ObservedPromise(function (resolve, reject) {
+            function rejectMapped(hostErr) {
+              const vmErr = mapDispatchError(hostErr);
+              // Stamp the originating root and run BEFORE the error can
+              // be forwarded into aggregate promises: the observer's
+              // cross-root suppression (R11-15) reads __wfRootId and
+              // the host's adoption-escape hook (R11-3) attributes by
+              // __wfRunId.
+              try {
+                vmErr.__wfRootId = rootId;
+                vmErr.__wfRunId = __b.runId;
+              } catch (e) {}
+              reject(vmErr);
+            }
             try {
               const hostPromise = hostFn.apply(null, vmArgs);
               hostPromise.then(
                 function (value) { resolve(value); },
-                function (hostErr) {
-                  const msg = (hostErr && hostErr.message != null)
-                    ? String(hostErr.message)
-                    : String(hostErr);
-                  reject(new Error(msg));
-                }
+                rejectMapped
               );
             } catch (hostErr) {
-              const msg = (hostErr && hostErr.message != null)
-                ? String(hostErr.message)
-                : String(hostErr);
-              reject(new Error(msg));
+              rejectMapped(hostErr);
             }
           });
+          p.__wfRootId = rootId;
+          p.__wfIsRoot = true;
+          observeDispatch(p);
+          return p;
         };
       }
 
@@ -873,46 +1182,208 @@ function createWorkflowSandbox(opts) {
     { filename: "workflow-sandbox-init.js" }
   );
   const maxWallClockMs = resolveMaxWallClockMs(opts);
+  const flushUnconsumedRejections = /* @__PURE__ */ __name(async () => {
+    unconsumedSettled = true;
+    if (nextUnconsumedId === 1) return;
+    await new Promise((resolve) => {
+      setImmediate(resolve);
+    });
+    for (const rec of unconsumedRejections.values()) {
+      const rootState = unconsumedRoots.get(rec.rootId);
+      if (rootState?.rejectionHandled) {
+        continue;
+      }
+      if (rec.dispatchFailed && rootState?.adoptedOut) {
+        continue;
+      }
+      const key = rec.rootId + "\0" + rec.msg;
+      if (mirroredEscapeKeys.has(key)) continue;
+      mirroredEscapeKeys.add(key);
+      safeLog(unconsumedRejectionLine(rec));
+    }
+    unconsumedRejections.clear();
+  }, "flushUnconsumedRejections");
+  const hookRunId = opts.runId ?? "";
+  const adoptionEscapeHook = /* @__PURE__ */ __name((reason, _promise) => {
+    try {
+      if (!reason || typeof reason !== "object") return;
+      const marked = reason;
+      if (marked.__wfDispatchFailed !== true) return;
+      if (String(marked.__wfRunId ?? "") !== hookRunId) return;
+      const rootId = typeof marked.__wfRootId === "number" ? marked.__wfRootId : void 0;
+      if (rootId !== void 0 && unconsumedRoots.get(rootId)?.rejectionHandled) {
+        return;
+      }
+      let msg;
+      try {
+        msg = marked.message != null ? String(marked.message) : String(reason);
+      } catch {
+        msg = "[unserializable rejection value]";
+      }
+      const key = String(rootId ?? "") + "\0" + msg;
+      if (mirroredEscapeKeys.has(key)) return;
+      mirroredEscapeKeys.add(key);
+      safeLog("dispatch failed (rejection not handled): " + msg);
+    } catch (e) {
+      debugLogger.warn("adoptionEscapeHook failed:", e);
+    }
+  }, "adoptionEscapeHook");
   let extractedMeta = null;
   return {
     async run(scriptSource) {
-      const { stripped, meta } = extractAndStripMeta(scriptSource);
-      extractedMeta = meta;
-      const wrapped = `(async () => {
+      unconsumedSettled = false;
+      unconsumedRoots.clear();
+      unconsumedRejections.clear();
+      nextUnconsumedId = 1;
+      mirroredEscapeKeys = /* @__PURE__ */ new Set();
+      let watchdog;
+      let stopWatchingState;
+      let rearmWatchdogOnAbort;
+      process.on("unhandledRejection", adoptionEscapeHook);
+      try {
+        const { stripped, meta } = extractAndStripMeta(scriptSource);
+        extractedMeta = meta;
+        const wrapped = `(async () => {
 ${stripped}
 })()`;
-      const script = new vm.Script(wrapped, {
-        filename: "workflow.js"
-      });
-      const runOpts = {
-        timeout: 3e4
-      };
-      const result = script.runInContext(ctx, runOpts);
-      let timer;
-      const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          opts.abortOnTimeout?.abort();
-          reject(
-            new Error(
-              `Workflow execution timed out after ${maxWallClockMs} ms wall clock. Override via SandboxOptions.maxWallClockMs or QWEN_CODE_MAX_WORKFLOW_SECONDS env var.`
-            )
-          );
-        }, maxWallClockMs);
-        timer.unref?.();
-      });
-      try {
+        const script = new vm.Script(wrapped, {
+          filename: "workflow.js"
+        });
+        const runOpts = {
+          timeout: 3e4
+        };
+        const result = script.runInContext(ctx, runOpts);
+        const timeoutPromise = new Promise((_, reject) => {
+          watchdog = new WallClockWatchdog(maxWallClockMs, () => {
+            opts.abortOnTimeout?.abort();
+            reject(
+              new Error(
+                `Workflow execution exceeded ${maxWallClockMs} ms of active time (paused time is not counted). Override via SandboxOptions.maxWallClockMs or QWEN_CODE_MAX_WORKFLOW_SECONDS env var.`
+              )
+            );
+          });
+        });
+        const aborted = /* @__PURE__ */ __name(() => opts.abortOnTimeout?.signal.aborted === true, "aborted");
+        stopWatchingState = opts.scheduler?.onStateChange(({ state }) => {
+          if (state === "paused" && !aborted()) watchdog?.pause();
+          else watchdog?.resume();
+        });
+        if (opts.scheduler?.snapshot().state === "paused" && !aborted()) {
+          watchdog?.pause();
+        }
+        rearmWatchdogOnAbort = /* @__PURE__ */ __name(() => watchdog?.resume(), "rearmWatchdogOnAbort");
+        opts.abortOnTimeout?.signal.addEventListener(
+          "abort",
+          rearmWatchdogOnAbort,
+          { once: true }
+        );
         return await Promise.race([result, timeoutPromise]);
       } finally {
-        if (timer !== void 0) clearTimeout(timer);
+        if (rearmWatchdogOnAbort) {
+          opts.abortOnTimeout?.signal.removeEventListener(
+            "abort",
+            rearmWatchdogOnAbort
+          );
+        }
+        stopWatchingState?.();
+        watchdog?.stop();
+        await flushUnconsumedRejections();
+        process.off("unhandledRejection", adoptionEscapeHook);
       }
     },
     getPhases: /* @__PURE__ */ __name(() => [...phases], "getPhases"),
     getLogs: /* @__PURE__ */ __name(() => [...logs], "getLogs"),
+    appendLog: /* @__PURE__ */ __name((line) => safeLog(line), "appendLog"),
     getMeta: /* @__PURE__ */ __name(() => extractedMeta, "getMeta")
   };
 }
 __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();
 var DEFAULT_STALL_MS = 6e4;
@@ -1144,58 +1615,122 @@ 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/utils/concurrencyLimiter.ts
+// packages/core/src/agents/runtime/workflow-dispatch-scheduler.ts
 init_esbuild_shims();
 function abortError() {
-  return new DOMException("Concurrency limiter aborted.", "AbortError");
+  return new DOMException("Workflow dispatch scheduler aborted.", "AbortError");
 }
 __name(abortError, "abortError");
-function createConcurrencyLimiter(limit, signal) {
-  if (!Number.isInteger(limit) || limit < 1) {
-    throw new Error(
-      `Concurrency limit must be a positive integer, got ${String(limit)}.`
-    );
+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((resolve, reject) => {
+      if (this.signal?.aborted) {
+        reject(abortError());
+        return;
+      }
+      this.queue.push({
+        thunk,
+        resolve,
+        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((resolve, reject) => {
+      this.gateWaiters.push({ resolve, reject });
+    });
+  }
+  snapshot() {
+    return {
+      state: this.state,
+      queued: this.queue.length,
+      inFlight: this.inFlight
+    };
   }
-  let active = 0;
-  const queue = [];
-  const pump = /* @__PURE__ */ __name(() => {
-    while (active < limit && queue.length > 0) {
-      const job = queue.shift();
-      if (signal?.aborted) {
+  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;
       }
-      active++;
+      this.inFlight++;
       Promise.resolve().then(job.thunk).then(job.resolve, job.reject).finally(() => {
-        active--;
-        pump();
+        this.inFlight--;
+        if (this.state === "pausing" && this.inFlight === 0) {
+          this.setState("paused");
+        }
+        this.pump();
       });
     }
-  }, "pump");
-  const run = /* @__PURE__ */ __name((thunk) => new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(abortError());
-      return;
+  }
+  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);
     }
-    queue.push({
-      thunk,
-      resolve,
-      reject
-    });
-    pump();
-  }), "run");
-  if (signal && !signal.aborted) {
-    signal.addEventListener(
-      "abort",
-      () => {
-        while (queue.length > 0) queue.shift().reject(abortError());
-      },
-      { once: true }
-    );
   }
-  return { run };
-}
-__name(createConcurrencyLimiter, "createConcurrencyLimiter");
+};
 
 // packages/core/src/agents/runtime/workflow-orchestrator.ts
 var DEFAULT_MAX_AGENTS_PER_RUN = 1e3;
@@ -1208,13 +1743,13 @@ function resolveMaxAgentsPerRun(env = process.env) {
   }
   const parsed = parsePositiveIntegerEnv(raw, 0);
   if (parsed < 1) {
-    debugLogger2.warn(
+    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) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `${MAX_WORKFLOW_AGENTS_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_AGENTS_PER_RUN_CEILING}); clamping.`
     );
     return HARD_MAX_AGENTS_PER_RUN_CEILING;
@@ -1230,14 +1765,14 @@ function resolveConcurrencyLimit(env = process.env) {
     const parsed = parsePositiveIntegerEnv(raw, 0);
     if (parsed >= 1) {
       if (parsed > HARD_MAX_CONCURRENCY_CEILING) {
-        debugLogger2.warn(
+        debugLogger.warn(
           `${MAX_WORKFLOW_CONCURRENCY_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_CONCURRENCY_CEILING}); clamping.`
         );
         return HARD_MAX_CONCURRENCY_CEILING;
       }
       return parsed;
     }
-    debugLogger2.warn(
+    debugLogger.warn(
       `Invalid ${MAX_WORKFLOW_CONCURRENCY_ENV}=${JSON.stringify(raw)}, using cpu-derived default`
     );
   }
@@ -1310,11 +1845,11 @@ function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents
 }
 __name(createProductionDispatch, "createProductionDispatch");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, onTokens) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-PR7YCB7S.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-XXGY2SQO.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   const workflowAgentId = `workflow-agent-${randomBytes(8).toString("hex")}`;
-  debugLogger2.debug(`[workflow] Dispatch ${workflowAgentId}`);
+  debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
   if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0) {
     const subagent = await AgentHeadless.create(
       opts.label ?? "workflow-agent",
@@ -1372,7 +1907,7 @@ function reportTokens(subagent, opts, onTokens) {
     const summary = subagent.getExecutionSummary();
     onTokens(summary.outputTokens, opts);
   } catch (e) {
-    debugLogger2.warn("onTokens callback threw:", e);
+    debugLogger.warn("onTokens callback threw:", e);
   }
 }
 __name(reportTokens, "reportTokens");
@@ -1491,7 +2026,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
             worktreeIsolation = null;
             const preserved = await cleanupWorkflowWorktree(isolation);
             if (preserved) {
-              debugLogger2.info(
+              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.`
               );
             }
@@ -1546,7 +2081,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
       try {
         await cleanupWorkflowWorktree(worktreeIsolation);
       } catch (error) {
-        debugLogger2.warn(
+        debugLogger.warn(
           `Workflow worktree cleanup in fallback finally failed for ${worktreeIsolation.path}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1579,7 +2114,7 @@ async function provisionWorkflowWorktree(config) {
   try {
     parentDirty = await wtService.hasWorktreeChanges(projectRoot);
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] hasWorktreeChanges failed at ${projectRoot}: ${error}`
     );
     parentDirty = true;
@@ -1594,7 +2129,7 @@ async function provisionWorkflowWorktree(config) {
   try {
     parentBranch = await wtService.getCurrentBranch();
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] getCurrentBranch failed at ${projectRoot}: ${error}`
     );
   }
@@ -1612,7 +2147,7 @@ async function provisionWorkflowWorktree(config) {
       config.getSessionId()
     );
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] failed to write session marker at ${created.worktree.path}: ${error}`
     );
   }
@@ -1645,20 +2180,20 @@ async function cleanupWorkflowWorktree(isolation) {
   const wtService = new GitWorktreeService(isolation.repoRoot);
   const [hasChanges, hasUnmerged] = await Promise.all([
     wtService.hasWorktreeChanges(isolation.path).catch((error) => {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] hasWorktreeChanges failed for ${isolation.path}: ${error}`
       );
       return true;
     }),
     wtService.hasUnmergedWorktreeCommits(isolation.slug).catch((error) => {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] hasUnmergedWorktreeCommits failed for ${isolation.slug}: ${error}`
       );
       return true;
     })
   ]);
   if (hasChanges || hasUnmerged) {
-    debugLogger2.info(
+    debugLogger.info(
       `[Workflow] Preserving isolation worktree ${isolation.path} (branch ${isolation.branch}, hasChanges=${hasChanges}, hasUnmerged=${hasUnmerged})`
     );
     return { path: isolation.path, branch: isolation.branch };
@@ -1668,19 +2203,19 @@ async function cleanupWorkflowWorktree(isolation) {
       deleteBranch: true
     });
     if (!result.success) {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${result.error}`
       );
       return { path: isolation.path, branch: isolation.branch };
     }
     if (result.branchPreserved) {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] Removed worktree directory ${isolation.path} but kept branch ${isolation.branch} (unmerged commits at delete time)`
       );
       return { branch: isolation.branch };
     }
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${error}`
     );
     return { path: isolation.path, branch: isolation.branch };
@@ -1748,7 +2283,15 @@ var WorkflowOrchestrator = class {
     const runId = req.runId ?? generateRunId();
     const maxAgents = resolveMaxAgentsPerRun();
     const signal = req.abortOnTimeout?.signal;
-    const limiter = createConcurrencyLimiter(resolveConcurrencyLimit(), 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;
     const emitter = req.emitter;
     const budget = req.budget;
@@ -1768,7 +2311,7 @@ var WorkflowOrchestrator = class {
           if (cached !== void 0) {
             const respawns = replay.started.get(journalKey);
             if (respawns && respawns.length > 0) {
-              debugLogger2.info(
+              debugLogger.info(
                 `[Workflow] resume cache hit after ${respawns.length} prior respawn(s) for runId=${runId}.`
               );
             }
@@ -1776,33 +2319,36 @@ var WorkflowOrchestrator = class {
             try {
               emitter?.agentDispatched?.(label2);
             } catch (e) {
-              debugLogger2.warn("emitter.agentDispatched threw:", e);
+              debugLogger.warn("emitter.agentDispatched threw:", e);
             }
             try {
               emitter?.agentCompleted?.(label2);
             } catch (e) {
-              debugLogger2.warn("emitter.agentCompleted threw:", e);
+              debugLogger.warn("emitter.agentCompleted threw:", e);
             }
-            return Promise.resolve(cached.result);
+            return scheduler.waitUntilRunning().then(
+              () => cached.result,
+              () => cached.result
+            );
           }
         }
         hadMiss = true;
         journalEntryId = String(journalAgentId += 1);
         journal.append({ type: "started", key: journalKey, agentId: journalEntryId }).catch(
-          (e) => debugLogger2.warn(`journal started-append failed: ${e}`)
+          (e) => debugLogger.warn(`journal started-append failed: ${e}`)
         );
       }
       if (budget && budget.total !== null && budget.remaining() <= 0) {
-        debugLogger2.warn(
+        debugLogger.warn(
           `[Workflow] budget gate refused dispatch at entry: runId=${runId} spent=${budget.spent()} total=${budget.total}`
         );
-        return Promise.reject(
+        return rejectThroughPauseGate(
           new WorkflowBudgetExceededError(runId, budget.total, budget.spent())
         );
       }
       agentCount += 1;
       if (agentCount > maxAgents) {
-        return Promise.reject(
+        return rejectThroughPauseGate(
           new Error(
             `Workflow exceeded the maximum of ${maxAgents} agent() calls per run.`
           )
@@ -1812,27 +2358,33 @@ var WorkflowOrchestrator = class {
       try {
         emitter?.agentDispatched?.(label);
       } catch (e) {
-        debugLogger2.warn("emitter.agentDispatched threw:", e);
+        debugLogger.warn("emitter.agentDispatched threw:", e);
       }
-      return limiter.run(() => {
-        if (budget && budget.total !== null && budget.remaining() <= 0) {
-          debugLogger2.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()
-          );
+      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);
         }
-        return this.dispatch(prompt, opts);
-      }).then(
-        (result) => {
-          try {
-            emitter?.agentCompleted?.(label);
-          } catch (e) {
-            debugLogger2.warn("emitter.agentCompleted threw:", e);
+      }, "emitCompletion");
+      return scheduler.run(async () => {
+        try {
+          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()
+            );
           }
+          const result = await this.dispatch(prompt, opts);
+          emitCompletion();
           if (journal && journalKey !== void 0) {
             journal.append({
               type: "result",
@@ -1840,63 +2392,92 @@ var WorkflowOrchestrator = class {
               agentId: journalEntryId ?? "",
               result
             }).catch(
-              (e) => debugLogger2.warn(`journal result-append failed: ${e}`)
+              (e) => debugLogger.warn(`journal result-append failed: ${e}`)
             );
           }
           if (budget) {
             try {
               emitter?.budgetUpdated?.(budget.spent(), budget.total);
             } catch (e) {
-              debugLogger2.warn("emitter.budgetUpdated threw:", e);
+              debugLogger.warn("emitter.budgetUpdated threw:", e);
             }
           }
           return result;
-        },
-        (err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          try {
-            emitter?.agentCompleted?.(label, msg);
-          } catch (e) {
-            debugLogger2.warn("emitter.agentCompleted threw:", e);
-          }
+        } catch (err) {
+          emitCompletion(err);
           if (budget) {
             try {
               emitter?.budgetUpdated?.(budget.spent(), budget.total);
             } catch (e) {
-              debugLogger2.warn("emitter.budgetUpdated threw:", e);
+              debugLogger.warn("emitter.budgetUpdated threw:", e);
             }
           }
           throw err;
         }
+      }).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);
     const pipelineImpl = makePipelineImpl(signal);
     const resolveSavedWorkflow = req.resolveSavedWorkflow;
+    const parentSandboxRef = {
+      current: void 0
+    };
     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
+        budget,
+        scheduler
         // No `workflow` — single-level nesting limit.
       });
-      return nestedSandbox.run(resolved.script);
+      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,
+      runId,
       dispatch: countedDispatch,
       parallel: parallelImpl,
       pipeline: pipelineImpl,
       workflow: workflowImpl,
       abortOnTimeout: req.abortOnTimeout,
       emitter,
-      budget
+      budget,
+      scheduler
     });
+    parentSandboxRef.current = sandbox;
     try {
       const result = await sandbox.run(req.script);
       return {
@@ -1929,14 +2510,14 @@ async function settleToNullArray(thunks, signal, kind = "parallel") {
     if (reason?.name === "WorkflowBudgetExceededError") {
       budgetDropped += 1;
     } else {
-      debugLogger2.warn(
+      debugLogger.warn(
         `Workflow thunk at index ${i} rejected: ${String(reason?.message ?? r.reason)}`
       );
     }
     return null;
   });
   if (budgetDropped > 0) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `${kind}: ${budgetDropped} slot${budgetDropped === 1 ? "" : "s"} dropped \u2014 token budget exceeded.`
     );
   }
@@ -2010,12 +2591,15 @@ function extractErrorMessage(err) {
 __name(extractErrorMessage, "extractErrorMessage");
 
 // packages/core/src/agents/runtime/workflow-runner.ts
+init_esbuild_shims();
+import { randomBytes as randomBytes2 } from "node:crypto";
 var WorkflowRunHandle = class {
-  constructor(runId, budget, registry, controller, start) {
+  constructor(runId, budget, registry, controller, scheduler, start) {
     this.runId = runId;
     this.budget = budget;
     this.registry = registry;
     this.controller = controller;
+    this.scheduler = scheduler;
     this.completion = Promise.resolve().then(start);
   }
   static {
@@ -2025,6 +2609,12 @@ var WorkflowRunHandle = class {
   abort() {
     this.controller.abort();
   }
+  pause() {
+    return this.scheduler.pause();
+  }
+  resume() {
+    return this.scheduler.resume();
+  }
 };
 var WorkflowRunner = class {
   static {
@@ -2103,11 +2693,17 @@ var WorkflowRunner = class {
         emitUpdate();
       }, "budgetUpdated")
     };
+    const scheduler = new WorkflowDispatchScheduler(
+      resolveConcurrencyLimit(),
+      controller.signal,
+      ({ state }) => registry?.onDispatchStateChange(runId, state)
+    );
     const handle = new WorkflowRunHandle(
       runId,
       budget,
       registry,
       controller,
+      scheduler,
       async () => {
         try {
           const outcome = await orchestrator.run({
@@ -2119,7 +2715,8 @@ var WorkflowRunner = class {
             budget,
             resolveSavedWorkflow: /* @__PURE__ */ __name((ref) => resolveSavedWorkflowScript(ref, config), "resolveSavedWorkflow"),
             journal,
-            resumeReplay
+            resumeReplay,
+            scheduler
           });
           if (entry) {
             entry.meta = outcome.meta;
@@ -2128,6 +2725,12 @@ var WorkflowRunner = class {
             }
           }
           registry?.setRecentLogs(runId, outcome.logs);
+          if (entry && isTerminalWorkflowStatus(entry.status)) {
+            return {
+              ok: false,
+              message: entry.status === "cancelled" ? "Workflow run cancelled." : entry.error ?? "Workflow run failed."
+            };
+          }
           registry?.complete(runId, outcome.result, Date.now());
           return { ok: true, outcome };
         } catch (error) {
@@ -2143,20 +2746,18 @@ var WorkflowRunner = class {
           return { ok: false, message, details };
         } finally {
           controller.abort();
-          if (entry && entry.status !== "running") {
+          if (entry && isTerminalWorkflowStatus(entry.status)) {
+            const telemetryEvent = new WorkflowRunEvent({
+              status: entry.status,
+              agents_dispatched: entry.agentsDispatched,
+              agents_completed: entry.agentsCompleted,
+              phase_count: entry.phases.length,
+              tokens_spent: entry.tokensSpent,
+              duration_ms: (entry.endTime ?? entry.startTime) - entry.startTime
+            });
             await writeWorkflowSnapshot(config, entry);
             try {
-              logWorkflowRun(
-                config,
-                new WorkflowRunEvent({
-                  status: entry.status,
-                  agents_dispatched: entry.agentsDispatched,
-                  agents_completed: entry.agentsCompleted,
-                  phase_count: entry.phases.length,
-                  tokens_spent: entry.tokensSpent,
-                  duration_ms: (entry.endTime ?? entry.startTime) - entry.startTime
-                })
-              );
+              logWorkflowRun(config, telemetryEvent);
             } catch {
             }
           }
@@ -2185,7 +2786,7 @@ var WORKFLOW_PARAM_SCHEMA = {
   properties: {
     script: {
       type: "string",
-      description: "JavaScript source of the workflow. Wrapped as an async IIFE. May call the injected globals `phase(title)`, `log(msg)`, `agent(prompt, opts?)`, and read `args`. agent() opts: `{ label?, phase?, schema?, model?, agentType?, isolation? }`. `schema` (JSON Schema object): the subagent must deliver its result by calling `structured_output` with arguments matching the schema; agent() resolves to the validated object. Two failed attempts produce a terminal error \"subagent completed without calling StructuredOutput (after 2 in-conversation nudges)\". `agentType` (string): resolves against the declarative-agents registry (`.qwen/agents/<name>.md`, project then user then built-in). Unresolved names throw \"agent({agentType}): agent type 'X' not found\". `model` (string): per-call model override; routes provider correctly via the subagent runtime view. `isolation`: `'worktree'` provisions a fresh git worktree under `<projectRoot>/.qwen/worktrees/agent-<7hex>`; the worktree is auto-removed if no changes, otherwise the path and branch are returned alongside the result. `'remote'` throws \"agent({isolation:'remote'}) is not available in this build\" (parity with upstream). isolation=worktree refuses to run when the parent working tree has uncommitted changes (the subagent would see a stale HEAD). Workflow subagents always have SendMessage / Monitor / EnterPlanMode / ExitPlanMode in their disallowed-tool floor regardless of agentType. Concurrency: `parallel([() => agent(...), ...])` runs thunks through a shared per-run window (default `max(1, min(16, cpus-2))` agents in flight; override via `QWEN_CODE_MAX_WORKFLOW_CONCURRENCY`) and resolves to a position-aligned array \u2014 a thunk that throws, or resolves to a non-JSON-serializable value, becomes `null` at its index (errors-as-data); parallel() itself rejects only on invalid arguments or abort. `pipeline(items, ...stages)` runs each item through the stages (staggered, no inter-stage barrier); a stage that throws, returns `null`, or returns a non-JSON-serializable value drops that item to `null`. Pass THUNKS to parallel, not eager calls: `parallel([() => agent(...)])`, not `parallel([agent(...)])`. At most 1000 agent() calls per run (override via `QWEN_CODE_MAX_WORKFLOW_AGENTS`). `Date.now()` and `Math.random()` both throw \u2014 workflow scripts must be deterministic for resume. `export const meta = {...}` declarations are stripped before execution."
+      description: `JavaScript source of the workflow. Wrapped as an async IIFE. May call the injected globals \`phase(title)\`, \`log(msg)\`, \`agent(prompt, opts?)\`, and read \`args\`. agent() opts: \`{ label?, phase?, schema?, model?, agentType?, isolation? }\`. \`schema\` (JSON Schema object): the subagent must deliver its result by calling \`structured_output\` with arguments matching the schema; agent() resolves to the validated object. Two failed attempts produce a terminal error "subagent completed without calling StructuredOutput (after 2 in-conversation nudges)". \`agentType\` (string): resolves against the declarative-agents registry (\`.qwen/agents/<name>.md\`, project then user then built-in). Unresolved names throw "agent({agentType}): agent type 'X' not found". \`model\` (string): per-call model override; routes provider correctly via the subagent runtime view. \`isolation\`: \`'worktree'\` provisions a fresh git worktree under \`<projectRoot>/.qwen/worktrees/agent-<7hex>\`; the worktree is auto-removed if no changes, otherwise the path and branch are returned alongside the result. \`'remote'\` throws "agent({isolation:'remote'}) is not available in this build" (parity with upstream). isolation=worktree refuses to run when the parent working tree has uncommitted changes (the subagent would see a stale HEAD). Workflow subagents always have SendMessage / Monitor / EnterPlanMode / ExitPlanMode in their disallowed-tool floor regardless of agentType. Concurrency: \`parallel([() => agent(...), ...])\` runs thunks through a shared per-run window (default \`max(1, min(16, cpus-2))\` agents in flight; override via \`${MAX_WORKFLOW_CONCURRENCY_ENV}\`) and resolves to a position-aligned array \u2014 a thunk that throws, or resolves to a non-JSON-serializable value, becomes \`null\` at its index (errors-as-data); parallel() itself rejects only on invalid arguments or abort. \`pipeline(items, ...stages)\` runs each item through the stages (staggered, no inter-stage barrier); a stage that throws, returns \`null\`, or returns a non-JSON-serializable value drops that item to \`null\`. Pass THUNKS to parallel, not eager calls: \`parallel([() => agent(...)])\`, not \`parallel([agent(...)])\`. At most ${DEFAULT_MAX_AGENTS_PER_RUN} agent() calls per run (override via \`${MAX_WORKFLOW_AGENTS_ENV}\`). \`Date.now()\` and \`Math.random()\` both throw \u2014 workflow scripts must be deterministic for resume. \`export const meta = {...}\` declarations are stripped before execution.`
     },
     scriptPath: {
       type: "string",
@@ -2201,7 +2802,7 @@ var WORKFLOW_PARAM_SCHEMA = {
     run_in_background: {
       type: "boolean",
       default: false,
-      description: "Optional. When true, start the workflow under the interactive session and return a run handle immediately. The Background Tasks view can observe or stop it, and completion is delivered to the conversation when the run settles. Interactive TUI only. Defaults to false."
+      description: "Optional. When true, start the workflow under the interactive session and return a run handle immediately. The Background Tasks view can observe, cooperatively pause/resume, or stop it, and completion is delivered to the conversation when the run settles. Interactive TUI only. Defaults to false."
     }
   }
   // `script` is required UNLESS `scriptPath` is supplied; this XOR can't be
@@ -2269,7 +2870,7 @@ Run ID: ${handle.runId}
 Status: ${status}`
           }
         ],
-        returnDisplay: usageBanner + `Workflow ${handle.runId} started in the background (status: ${status}). Use Background Tasks to observe or stop it.`
+        returnDisplay: usageBanner + `Workflow ${handle.runId} started in the background (status: ${status}). Use Background Tasks to observe, cooperatively pause/resume, or stop it.`
       };
     }
     const settlement = await handle.completion;
@@ -2414,12 +3015,47 @@ function safeStringifyDisplayPayload(payload) {
   }
 }
 __name(safeStringifyDisplayPayload, "safeStringifyDisplayPayload");
+var WORKFLOW_TOOL_DESCRIPTION = `Execute a workflow script that orchestrates subagents deterministically.
+
+**What a workflow is for**
+
+Reach for one to be comprehensive (decompose the work and cover every part in parallel), to be confident (independent perspectives and adversarial checks before an answer is committed to), or to take on scale a single context cannot hold \u2014 migrations, audits, broad sweeps. The script is where that structure is encoded: what fans out, what verifies, what synthesizes. Parallelism on its own is not a reason; work that is already one short sequence of edits belongs in the main loop.
+
+**Runtime** \u2014 see the \`script\` parameter for the detailed authoring contract.
+
+\`phase(title)\`, \`log(msg)\`, \`agent(prompt, opts?)\`, \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`workflow(nameOrRef, args?)\`, plus the \`args\` and \`budget\` globals. \`workflow()\` runs a saved workflow inline under this run's caps and nests one level only \u2014 a workflow reached through \`workflow()\` cannot call \`workflow()\` itself, and doing so throws. Saved workflows are \`<name>.js\` files under \`<projectRoot>/.qwen/workflows\` (project scope, also surfaced as \`/<name>\` slash commands) or \`~/.qwen/workflows\` (user scope, lower precedence when both define the same name); \`workflow('<name>')\` resolves against those two directories, while \`scriptPath\` takes an absolute path to a script anywhere. Default \`max(1, min(16, cpus-2))\` agents in flight per run (\`${MAX_WORKFLOW_CONCURRENCY_ENV}\`), up to ${DEFAULT_MAX_AGENTS_PER_RUN} agents total (\`${MAX_WORKFLOW_AGENTS_ENV}\`), under a 30-minute wall-clock cap per run (\`QWEN_CODE_MAX_WORKFLOW_SECONDS\`) \u2014 a fan-out near the agent cap will not fit inside the default cap. A per-run output-token cap may also be in effect: read \`budget.total\` (\`null\` = uncapped) before committing to a large fan-out, because once the cap is reached every further \`agent()\` call is refused \u2014 a bare sequential \`await agent()\` sees the rejection, while inside \`parallel()\`/\`pipeline()\` the refused slot becomes \`null\` and the script keeps running on partial results. Per-call \`agent({ schema, agentType, model, isolation: 'worktree' })\` covers structured-output contracts, declarative-agent selection, model override, and git-worktree-isolated subagents. \`resumeFromRunId\` resumes a prior run \u2014 agent() calls whose rolling prefix-hash matches the journal are served from cache for the longest unchanged prefix. Runs appear in the background-tasks view and the \`/workflows\` dialog (live phase tree, token usage, cooperative pause/resume, cancel); \`run_in_background: true\` returns a run handle immediately in the interactive TUI and delivers completion through the conversation. Scripts run in a node:vm sandbox with no filesystem or shell access \u2014 all I/O happens through the spawned agents.
+
+**Scout first, then orchestrate**
+
+The strongest pattern is hybrid: discover the work list in the main loop (list the files, scope the diff, read the failing test), then hand that list to a workflow. You do not need to know the shape of the work before the task \u2014 only before the orchestration step. When the work has distinct phases, run several small workflows across turns and read each result before choosing the next, rather than authoring one large script that runs unattended.
+
+Common single-phase shapes: understand (parallel readers over subsystems, merged into one map), design (independent approaches, judged, then synthesized), review (dimensions, find, verify each finding), research (broad sweep, deep read, synthesis), migrate (discover sites, transform each under \`isolation: 'worktree'\`, verify).
+
+**Default to \`pipeline()\`**
+
+\`pipeline()\` runs each item through every stage independently \u2014 item A can be in stage 3 while item B is still in stage 1 \u2014 so wall-clock is the slowest single chain. \`parallel()\` is a barrier: it waits for every thunk before anything moves on, so it costs the slowest item of every stage.
+
+A barrier is right only when a stage genuinely needs cross-item context: deduplicating or merging across the full result set before expensive downstream work, exiting early when the total count is zero, or a prompt that compares one finding against all the others. It is not justified by needing to flatten, map, or filter between stages (do that inside a pipeline stage), by two stages being conceptually separate, or by the code reading more tidily. Smell test: \`parallel()\` \u2192 a pure transform \u2192 \`parallel()\` is a pipeline someone wrote with an unnecessary barrier. When in doubt, \`pipeline()\`.
+
+**Verify before believing**
+
+A subagent's answer is a claim, not a result. For findings that matter, spawn independent verifiers prompted to *refute*, and drop what a majority refutes. When a claim can be wrong in several different ways, give each verifier a distinct lens (correctness, security, performance, does it actually reproduce) \u2014 diversity catches what repetition cannot. For a wide solution space, generate several independent attempts, judge them in parallel, and synthesize from the winner while grafting the best ideas from the rest.
+
+**Converge deliberately**
+
+For discovery of unknown size, keep running finders until some number of consecutive rounds turn up nothing new; a fixed round count stops partway into the tail. Deduplicate each round against everything already seen, never against only what survived judging \u2014 otherwise rejected findings reappear every round and the loop never terminates. A closing pass that asks what is still missing (a search angle never run, a claim never verified, a file never read) usually produces the next round of real work.
+
+**Report honestly**
+
+Scale the fleet to what was actually asked: a quick check gets a few agents and one verification pass; an explicit request to be thorough or exhaustive earns a larger pool and a multi-vote adversarial round. Whenever a run bounds its own coverage \u2014 top-N, sampling, no retry \u2014 \`log()\` what was dropped. Silent truncation reads as full coverage, which is worse than a smaller honest result.
+
+These shapes are a starting point, not a menu; compose the harness the task actually needs.`;
 var WorkflowTool = class extends BaseDeclarativeTool {
   constructor(config, toolOptions = {}) {
     super(
       ToolNames.WORKFLOW,
       ToolDisplayNames.WORKFLOW,
-      "Execute a workflow script that orchestrates subagents. Supports `phase`, `log`, sequential `agent`, concurrent fan-out via `parallel(thunks)` / `pipeline(items, ...stages)` (default `max(1, min(16, cpus-2))` agents in flight per run, up to 1000 agents total; both env-overridable), per-call `agent({ schema, agentType, model, isolation: 'worktree' })` for structured-output contracts, declarative-agent selection, model override, and git-worktree-isolated subagents. Pass `resumeFromRunId` to resume a prior run \u2014 agent() calls whose rolling prefix-hash matches the journal are served from cache for the longest unchanged prefix. Runs are tracked in the background-tasks view and the `/workflows` dialog (live phase tree, token usage, cancel). Set `run_in_background: true` to return a run handle immediately in the interactive TUI and receive completion through the conversation. Scripts run in a node:vm sandbox without access to the filesystem or shell; all I/O happens through the spawned agents.",
+      WORKFLOW_TOOL_DESCRIPTION,
       "other" /* Other */,
       WORKFLOW_PARAM_SCHEMA,
       /* isOutputMarkdown */
@@ -2464,11 +3100,11 @@ export {
 };
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */