@qwen-code/qwen-code 0.21.7-nightly.20260808.4ec0371e6 → 0.21.8

package/chunks/{workflow-RXKBF3LO.js → workflow-FXIPRQQA.js}

@@ -5,13 +5,14 @@ import {
   FileDiscoveryService,
   GitWorktreeService,
   generateAgentWorktreeSlug,
+  isTerminalWorkflowStatus,
   rebuildToolRegistryOnOverride,
   resolveSavedWorkflowScript,
   stripAnsiAndControl,
   toModelVisibleSubagentResult,
   writeWorkflowSnapshot,
   writeWorktreeSessionMarker
-} from "./chunk-BFSQBXHV.js";
+} from "./chunk-GXSNGY5M.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -23,7 +24,7 @@ import "./chunk-7MH4J33A.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-RGTB44BO.js";
+import "./chunk-VXZ5HAOV.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-GNPNYXJB.js";
@@ -36,12 +37,12 @@ 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-REHWPCG2.js";
+import "./chunk-PLFATELK.js";
 import "./chunk-L4N6TIP7.js";
 import "./chunk-SAH4BD2J.js";
 import {
@@ -55,11 +56,12 @@ import "./chunk-AQ37AY7B.js";
 import {
   WorkspaceContext
 } from "./chunk-EQL65XGA.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";
@@ -75,10 +77,11 @@ import {
   logWorkflowRun,
   read,
   writeLine
-} from "./chunk-XCG76UE6.js";
+} from "./chunk-3PY4LPJF.js";
 import "./chunk-WOJZWRAZ.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-FVKHVJZQ.js";
+import "./chunk-COBO5EBO.js";
 import {
   SyntheticOutputTool
 } from "./chunk-6ZRFAKXK.js";
@@ -88,7 +91,8 @@ import {
   ToolDisplayNames,
   ToolNames
 } from "./chunk-PYQADEFD.js";
-import "./chunk-P7HUJDBZ.js";
+import "./chunk-M3STHEMM.js";
+import "./chunk-F6WFNA7U.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
 import "./chunk-KKBPOU75.js";
@@ -404,6 +408,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(
@@ -473,6 +521,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,
@@ -490,6 +549,52 @@ function createWorkflowSandbox(opts) {
         `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,
@@ -557,27 +662,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;
         };
       }
 
@@ -875,41 +1271,118 @@ 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) {
+      debugLogger2.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")
   };
 }
@@ -1146,58 +1619,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;
@@ -1312,7 +1849,7 @@ 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-ZJHZ7I3S.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-2EE5J2KX.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   const workflowAgentId = `workflow-agent-${randomBytes(8).toString("hex")}`;
@@ -1750,7 +2287,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;
@@ -1785,7 +2330,10 @@ var WorkflowOrchestrator = class {
             } catch (e) {
               debugLogger2.warn("emitter.agentCompleted threw:", e);
             }
-            return Promise.resolve(cached.result);
+            return scheduler.waitUntilRunning().then(
+              () => cached.result,
+              () => cached.result
+            );
           }
         }
         hadMiss = true;
@@ -1798,13 +2346,13 @@ var WorkflowOrchestrator = class {
         debugLogger2.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.`
           )
@@ -1816,25 +2364,31 @@ var WorkflowOrchestrator = class {
       } catch (e) {
         debugLogger2.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) {
+          debugLogger2.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) {
+            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()
+            );
           }
+          const result = await this.dispatch(prompt, opts);
+          emitCompletion();
           if (journal && journalKey !== void 0) {
             journal.append({
               type: "result",
@@ -1853,14 +2407,8 @@ var WorkflowOrchestrator = class {
             }
           }
           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);
@@ -1870,35 +2418,70 @@ var WorkflowOrchestrator = class {
           }
           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 {
@@ -2013,11 +2596,12 @@ __name(extractErrorMessage, "extractErrorMessage");
 
 // packages/core/src/agents/runtime/workflow-runner.ts
 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 {
@@ -2027,6 +2611,12 @@ var WorkflowRunHandle = class {
   abort() {
     this.controller.abort();
   }
+  pause() {
+    return this.scheduler.pause();
+  }
+  resume() {
+    return this.scheduler.resume();
+  }
 };
 var WorkflowRunner = class {
   static {
@@ -2105,11 +2695,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({
@@ -2121,7 +2717,8 @@ var WorkflowRunner = class {
             budget,
             resolveSavedWorkflow: /* @__PURE__ */ __name((ref) => resolveSavedWorkflowScript(ref, config), "resolveSavedWorkflow"),
             journal,
-            resumeReplay
+            resumeReplay,
+            scheduler
           });
           if (entry) {
             entry.meta = outcome.meta;
@@ -2130,6 +2727,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) {
@@ -2145,20 +2748,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 {
             }
           }
@@ -2203,7 +2804,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
@@ -2271,7 +2872,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;
@@ -2421,7 +3022,7 @@ var WorkflowTool = class extends BaseDeclarativeTool {
     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.",
+      "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, cooperative pause/resume, 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.",
       "other" /* Other */,
       WORKFLOW_PARAM_SCHEMA,
       /* isOutputMarkdown */