@qwen-code/qwen-code 0.21.2 → 0.21.3-nightly.20260803.e1e5b42ce

package/chunks/{workflow-M6QAVKVJ.js → workflow-HU365RFR.js}

@@ -11,88 +11,92 @@ import {
   toModelVisibleSubagentResult,
   writeWorkflowSnapshot,
   writeWorktreeSessionMarker
-} from "./chunk-54YCNSK5.js";
+} from "./chunk-MVMBE5EH.js";
+import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-AOHY3QJ3.js";
-import "./chunk-5NNHICSA.js";
-import "./chunk-SHN4KHDK.js";
-import "./chunk-JXVC2PL3.js";
-import "./chunk-KRXPRVGL.js";
+import "./chunk-VA5NLVPT.js";
+import "./chunk-I7JDGNG6.js";
+import "./chunk-A6SX5TAH.js";
+import "./chunk-33FNCQSY.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-ZMOJ7ISP.js";
+import "./chunk-XXOVLDZQ.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-TEGJSJDF.js";
-import "./chunk-TIRRPCFS.js";
+import "./chunk-MOHAWIAW.js";
+import "./chunk-X6QNZOTC.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
+import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-4KP2F2TE.js";
-import "./chunk-3APUUXRF.js";
-import "./chunk-THVU3RNH.js";
-import "./chunk-LHKCY7DY.js";
-import "./chunk-6FMJLI5M.js";
+import "./chunk-MISUEWB4.js";
+import "./chunk-KRXPRVGL.js";
+import "./chunk-A5YZ3FA2.js";
+import "./chunk-YAVY33G4.js";
+import "./chunk-2UISUFHQ.js";
+import "./chunk-HFVW54NL.js";
 import {
   SUBAGENT_PLAN_LIFECYCLE_TOOLS,
   runWithAgentContext
-} from "./chunk-CBBP4BMC.js";
+} from "./chunk-LLMGP5IC.js";
 import "./chunk-S6LOFUVP.js";
+import "./chunk-7UXI6P72.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import {
   WorkspaceContext
-} from "./chunk-N4ACHWNH.js";
-import "./chunk-ZPJWUGCS.js";
-import "./chunk-D4HTUMGX.js";
+} from "./chunk-432XCUHF.js";
+import "./chunk-YXEVDA66.js";
+import "./chunk-XC656O42.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-LOY7RWQG.js";
-import "./chunk-E6CJ2SMM.js";
+import "./chunk-QYPT3QUD.js";
+import "./chunk-QMBEW7EW.js";
 import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import {
+  createAbortController,
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
-import "./chunk-6CQWRWUC.js";
-import "./chunk-Z3S5EMOW.js";
+import "./chunk-7XLPYF6B.js";
+import "./chunk-RPYYTL7E.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-XQK4XXTN.js";
+import "./chunk-6O5DVH27.js";
 import "./chunk-GLCZKT5V.js";
-import "./chunk-QDK4F2N5.js";
+import "./chunk-2DNKEBXY.js";
 import {
   WorkflowRunEvent,
   logWorkflowRun,
   read,
   writeLine
-} from "./chunk-DUNI4EBW.js";
+} from "./chunk-KZXSAQYV.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-3I6DUGQD.js";
+import "./chunk-E4WHKETF.js";
 import {
   SyntheticOutputTool
-} from "./chunk-7ULQIS27.js";
+} from "./chunk-UEJESCS7.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MM7TH7ZM.js";
-import "./chunk-HIVKI6O6.js";
+} from "./chunk-CFDR3GNL.js";
+import "./chunk-UO7AWUZJ.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
-import "./chunk-Q3T5KA2V.js";
-import "./chunk-R2XWGR75.js";
-import "./chunk-HC45LTEN.js";
-import "./chunk-QARJNL2V.js";
+import "./chunk-BFHXDAR7.js";
+import "./chunk-TYERNYH4.js";
+import "./chunk-UH7Z7Y45.js";
+import "./chunk-O2ZYHG33.js";
 import "./chunk-W4RQUHY3.js";
 import "./chunk-G7XXKQYS.js";
 import {
   createDebugLogger
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import "./chunk-VOQXFAY5.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
@@ -109,6 +113,95 @@ 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";
@@ -294,7 +387,7 @@ function isRegexContext(source, i) {
   return /[{[(,;:=!&|?+\-*/%^~<>]/.test(prev);
 }
 __name(isRegexContext, "isRegexContext");
-var debugLogger = createDebugLogger("WORKFLOW");
+var debugLogger2 = createDebugLogger("WORKFLOW");
 var MAX_LOG_LINES = 1e4;
 var MAX_PHASE_ENTRIES = 1e4;
 var ARGS_MAX_DEPTH = 64;
@@ -353,7 +446,7 @@ function createWorkflowSandbox(opts) {
       try {
         opts.emitter?.logAppended?.(line);
       } catch (e) {
-        debugLogger.warn("emitter.logAppended threw:", e);
+        debugLogger2.warn("emitter.logAppended threw:", e);
       }
     } else if (logs.length === MAX_LOG_LINES) {
       logs.push(`[workflow log truncated at ${MAX_LOG_LINES} lines]`);
@@ -367,7 +460,7 @@ function createWorkflowSandbox(opts) {
       try {
         opts.emitter?.phaseStarted?.(t);
       } catch (e) {
-        debugLogger.warn("emitter.phaseStarted threw:", e);
+        debugLogger2.warn("emitter.phaseStarted threw:", e);
       }
     } else if (phases.length === MAX_PHASE_ENTRIES) {
       phases.push(
@@ -390,7 +483,7 @@ 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) => {
-      debugLogger.warn(
+      debugLogger2.warn(
         `Workflow result revival failed at index ${idx}: ${reason}; slot set to null (non-JSON-serializable thunk return).`
       );
     }, "logRevivalFailure"),
@@ -819,91 +912,6 @@ ${stripped}
 }
 __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;
@@ -1199,13 +1207,13 @@ function resolveMaxAgentsPerRun(env = process.env) {
   }
   const parsed = parsePositiveIntegerEnv(raw, 0);
   if (parsed < 1) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `Invalid ${MAX_WORKFLOW_AGENTS_ENV}=${JSON.stringify(raw)}, using default (${DEFAULT_MAX_AGENTS_PER_RUN})`
     );
     return DEFAULT_MAX_AGENTS_PER_RUN;
   }
   if (parsed > HARD_MAX_AGENTS_PER_RUN_CEILING) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `${MAX_WORKFLOW_AGENTS_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_AGENTS_PER_RUN_CEILING}); clamping.`
     );
     return HARD_MAX_AGENTS_PER_RUN_CEILING;
@@ -1221,14 +1229,14 @@ function resolveConcurrencyLimit(env = process.env) {
     const parsed = parsePositiveIntegerEnv(raw, 0);
     if (parsed >= 1) {
       if (parsed > HARD_MAX_CONCURRENCY_CEILING) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `${MAX_WORKFLOW_CONCURRENCY_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_CONCURRENCY_CEILING}); clamping.`
         );
         return HARD_MAX_CONCURRENCY_CEILING;
       }
       return parsed;
     }
-    debugLogger.warn(
+    debugLogger2.warn(
       `Invalid ${MAX_WORKFLOW_CONCURRENCY_ENV}=${JSON.stringify(raw)}, using cpu-derived default`
     );
   }
@@ -1238,6 +1246,7 @@ __name(resolveConcurrencyLimit, "resolveConcurrencyLimit");
 var WORKFLOW_SUBAGENT_MAX_TURNS = 50;
 var WORKFLOW_SUBAGENT_MAX_TIME_MINUTES = 10;
 var WORKFLOW_SUBAGENT_DISALLOWED_TOOLS = [
+  ToolNames.ASK_USER_QUESTION,
   ToolNames.SEND_MESSAGE,
   ToolNames.MONITOR,
   ...SUBAGENT_PLAN_LIFECYCLE_TOOLS,
@@ -1269,20 +1278,27 @@ function sanitizeForErrorMessage(value) {
   return stripAnsiAndControl(value);
 }
 __name(sanitizeForErrorMessage, "sanitizeForErrorMessage");
-function createProductionDispatch(config, signal, onTokens) {
+function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents) {
   return async (prompt, opts) => {
     const stallMs = resolveStallMs(
       typeof opts.stallMs === "number" ? opts.stallMs : void 0
     );
     return runStallResilient(
-      (attemptSignal, emitter) => runSingleDispatch(
-        config,
-        prompt,
-        opts,
-        attemptSignal,
-        emitter,
-        onTokens
-      ),
+      async (attemptSignal, emitter) => {
+        const cleanupApprovalBridge = bridgeApprovalEvents?.(emitter);
+        try {
+          return await runSingleDispatch(
+            config,
+            prompt,
+            opts,
+            attemptSignal,
+            emitter,
+            onTokens
+          );
+        } finally {
+          cleanupApprovalBridge?.();
+        }
+      },
       {
         stallMs,
         signal,
@@ -1293,11 +1309,11 @@ function createProductionDispatch(config, signal, onTokens) {
 }
 __name(createProductionDispatch, "createProductionDispatch");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, onTokens) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-EO53EFS2.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-I7VMHI22.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   const workflowAgentId = `workflow-agent-${randomBytes(8).toString("hex")}`;
-  debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
+  debugLogger2.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",
@@ -1355,7 +1371,7 @@ function reportTokens(subagent, opts, onTokens) {
     const summary = subagent.getExecutionSummary();
     onTokens(summary.outputTokens, opts);
   } catch (e) {
-    debugLogger.warn("onTokens callback threw:", e);
+    debugLogger2.warn("onTokens callback threw:", e);
   }
 }
 __name(reportTokens, "reportTokens");
@@ -1474,7 +1490,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
             worktreeIsolation = null;
             const preserved = await cleanupWorkflowWorktree(isolation);
             if (preserved) {
-              debugLogger.info(
+              debugLogger2.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.`
               );
             }
@@ -1529,7 +1545,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
       try {
         await cleanupWorkflowWorktree(worktreeIsolation);
       } catch (error) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `Workflow worktree cleanup in fallback finally failed for ${worktreeIsolation.path}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1562,7 +1578,7 @@ async function provisionWorkflowWorktree(config) {
   try {
     parentDirty = await wtService.hasWorktreeChanges(projectRoot);
   } catch (error) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `[Workflow] hasWorktreeChanges failed at ${projectRoot}: ${error}`
     );
     parentDirty = true;
@@ -1577,7 +1593,7 @@ async function provisionWorkflowWorktree(config) {
   try {
     parentBranch = await wtService.getCurrentBranch();
   } catch (error) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `[Workflow] getCurrentBranch failed at ${projectRoot}: ${error}`
     );
   }
@@ -1595,7 +1611,7 @@ async function provisionWorkflowWorktree(config) {
       config.getSessionId()
     );
   } catch (error) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `[Workflow] failed to write session marker at ${created.worktree.path}: ${error}`
     );
   }
@@ -1628,20 +1644,20 @@ async function cleanupWorkflowWorktree(isolation) {
   const wtService = new GitWorktreeService(isolation.repoRoot);
   const [hasChanges, hasUnmerged] = await Promise.all([
     wtService.hasWorktreeChanges(isolation.path).catch((error) => {
-      debugLogger.warn(
+      debugLogger2.warn(
         `[Workflow] hasWorktreeChanges failed for ${isolation.path}: ${error}`
       );
       return true;
     }),
     wtService.hasUnmergedWorktreeCommits(isolation.slug).catch((error) => {
-      debugLogger.warn(
+      debugLogger2.warn(
         `[Workflow] hasUnmergedWorktreeCommits failed for ${isolation.slug}: ${error}`
       );
       return true;
     })
   ]);
   if (hasChanges || hasUnmerged) {
-    debugLogger.info(
+    debugLogger2.info(
       `[Workflow] Preserving isolation worktree ${isolation.path} (branch ${isolation.branch}, hasChanges=${hasChanges}, hasUnmerged=${hasUnmerged})`
     );
     return { path: isolation.path, branch: isolation.branch };
@@ -1651,19 +1667,19 @@ async function cleanupWorkflowWorktree(isolation) {
       deleteBranch: true
     });
     if (!result.success) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${result.error}`
       );
       return { path: isolation.path, branch: isolation.branch };
     }
     if (result.branchPreserved) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `[Workflow] Removed worktree directory ${isolation.path} but kept branch ${isolation.branch} (unmerged commits at delete time)`
       );
       return { branch: isolation.branch };
     }
   } catch (error) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${error}`
     );
     return { path: isolation.path, branch: isolation.branch };
@@ -1751,7 +1767,7 @@ var WorkflowOrchestrator = class {
           if (cached !== void 0) {
             const respawns = replay.started.get(journalKey);
             if (respawns && respawns.length > 0) {
-              debugLogger.info(
+              debugLogger2.info(
                 `[Workflow] resume cache hit after ${respawns.length} prior respawn(s) for runId=${runId}.`
               );
             }
@@ -1759,12 +1775,12 @@ var WorkflowOrchestrator = class {
             try {
               emitter?.agentDispatched?.(label2);
             } catch (e) {
-              debugLogger.warn("emitter.agentDispatched threw:", e);
+              debugLogger2.warn("emitter.agentDispatched threw:", e);
             }
             try {
               emitter?.agentCompleted?.(label2);
             } catch (e) {
-              debugLogger.warn("emitter.agentCompleted threw:", e);
+              debugLogger2.warn("emitter.agentCompleted threw:", e);
             }
             return Promise.resolve(cached.result);
           }
@@ -1772,11 +1788,11 @@ var WorkflowOrchestrator = class {
         hadMiss = true;
         journalEntryId = String(journalAgentId += 1);
         journal.append({ type: "started", key: journalKey, agentId: journalEntryId }).catch(
-          (e) => debugLogger.warn(`journal started-append failed: ${e}`)
+          (e) => debugLogger2.warn(`journal started-append failed: ${e}`)
         );
       }
       if (budget && budget.total !== null && budget.remaining() <= 0) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `[Workflow] budget gate refused dispatch at entry: runId=${runId} spent=${budget.spent()} total=${budget.total}`
         );
         return Promise.reject(
@@ -1795,11 +1811,11 @@ var WorkflowOrchestrator = class {
       try {
         emitter?.agentDispatched?.(label);
       } catch (e) {
-        debugLogger.warn("emitter.agentDispatched threw:", e);
+        debugLogger2.warn("emitter.agentDispatched threw:", e);
       }
       return limiter.run(() => {
         if (budget && budget.total !== null && budget.remaining() <= 0) {
-          debugLogger.warn(
+          debugLogger2.warn(
             `[Workflow] budget gate refused dispatch at slot-acquire: runId=${runId} spent=${budget.spent()} total=${budget.total}`
           );
           throw new WorkflowBudgetExceededError(
@@ -1814,7 +1830,7 @@ var WorkflowOrchestrator = class {
           try {
             emitter?.agentCompleted?.(label);
           } catch (e) {
-            debugLogger.warn("emitter.agentCompleted threw:", e);
+            debugLogger2.warn("emitter.agentCompleted threw:", e);
           }
           if (journal && journalKey !== void 0) {
             journal.append({
@@ -1823,14 +1839,14 @@ var WorkflowOrchestrator = class {
               agentId: journalEntryId ?? "",
               result
             }).catch(
-              (e) => debugLogger.warn(`journal result-append failed: ${e}`)
+              (e) => debugLogger2.warn(`journal result-append failed: ${e}`)
             );
           }
           if (budget) {
             try {
               emitter?.budgetUpdated?.(budget.spent(), budget.total);
             } catch (e) {
-              debugLogger.warn("emitter.budgetUpdated threw:", e);
+              debugLogger2.warn("emitter.budgetUpdated threw:", e);
             }
           }
           return result;
@@ -1840,13 +1856,13 @@ var WorkflowOrchestrator = class {
           try {
             emitter?.agentCompleted?.(label, msg);
           } catch (e) {
-            debugLogger.warn("emitter.agentCompleted threw:", e);
+            debugLogger2.warn("emitter.agentCompleted threw:", e);
           }
           if (budget) {
             try {
               emitter?.budgetUpdated?.(budget.spent(), budget.total);
             } catch (e) {
-              debugLogger.warn("emitter.budgetUpdated threw:", e);
+              debugLogger2.warn("emitter.budgetUpdated threw:", e);
             }
           }
           throw err;
@@ -1912,14 +1928,14 @@ async function settleToNullArray(thunks, signal, kind = "parallel") {
     if (reason?.name === "WorkflowBudgetExceededError") {
       budgetDropped += 1;
     } else {
-      debugLogger.warn(
+      debugLogger2.warn(
         `Workflow thunk at index ${i} rejected: ${String(reason?.message ?? r.reason)}`
       );
     }
     return null;
   });
   if (budgetDropped > 0) {
-    debugLogger.warn(
+    debugLogger2.warn(
       `${kind}: ${budgetDropped} slot${budgetDropped === 1 ? "" : "s"} dropped \u2014 token budget exceeded.`
     );
   }
@@ -1992,8 +2008,176 @@ function extractErrorMessage(err) {
 }
 __name(extractErrorMessage, "extractErrorMessage");
 
+// packages/core/src/agents/runtime/workflow-runner.ts
+var WorkflowRunHandle = class {
+  constructor(runId, budget, registry, controller, start) {
+    this.runId = runId;
+    this.budget = budget;
+    this.registry = registry;
+    this.controller = controller;
+    this.completion = Promise.resolve().then(start);
+  }
+  static {
+    __name(this, "WorkflowRunHandle");
+  }
+  completion;
+  abort() {
+    this.controller.abort();
+  }
+};
+var WorkflowRunner = class {
+  static {
+    __name(this, "WorkflowRunner");
+  }
+  static async start(options) {
+    const config = options.config;
+    const runInBackground = options.runInBackground === true;
+    const budget = WorkflowBudgetImpl.fromEnv();
+    const loaded = options.scriptPath && options.script === void 0 ? await resolveSavedWorkflowScript(
+      { scriptPath: options.scriptPath },
+      config
+    ) : void 0;
+    const script = loaded?.script ?? options.script ?? "";
+    const scriptPath = loaded?.scriptPath ?? options.scriptPath;
+    const runId = options.resumeFromRunId ?? `wf_${randomBytes2(8).toString("hex")}`;
+    const storage = config.storage;
+    const journal = storage ? new WorkflowJournal(storage.getWorkflowRunJournalPath(runId)) : void 0;
+    const resumeReplay = options.resumeFromRunId ? await journal?.load() : void 0;
+    if (runInBackground && options.signal.aborted) {
+      throw new Error("Background workflow start was cancelled.");
+    }
+    const callerWasAbortedBeforeStart = options.signal.aborted;
+    const controller = runInBackground ? createAbortController() : createChildAbortController(options.signal);
+    const registry = config.getWorkflowRunRegistry?.();
+    const dispatch = options.dispatch ?? createProductionDispatch(
+      config,
+      controller.signal,
+      (outputTokens) => budget.recordSpent(outputTokens),
+      registry ? (emitter2) => registry.bridgeApprovalEvents(runId, emitter2) : void 0
+    );
+    const orchestrator = new WorkflowOrchestrator(dispatch);
+    let entry;
+    try {
+      entry = registry?.register({
+        runId,
+        meta: null,
+        status: "running",
+        startTime: Date.now(),
+        outputFile: "",
+        abortController: controller,
+        tokenBudgetTotal: budget.total,
+        script,
+        scriptPath,
+        isBackgrounded: runInBackground
+      });
+    } catch (error) {
+      controller.abort();
+      throw error;
+    }
+    const emitUpdate = /* @__PURE__ */ __name(() => {
+      if (!entry || !options.onUpdate) return;
+      try {
+        options.onUpdate(entry);
+      } catch {
+      }
+    }, "emitUpdate");
+    const emitter = {
+      phaseStarted: /* @__PURE__ */ __name((title) => {
+        registry?.onPhaseStarted(runId, title);
+        emitUpdate();
+      }, "phaseStarted"),
+      agentDispatched: /* @__PURE__ */ __name(() => {
+        registry?.onAgentDispatched(runId);
+        emitUpdate();
+      }, "agentDispatched"),
+      agentCompleted: /* @__PURE__ */ __name(() => {
+        registry?.onAgentCompleted(runId);
+      }, "agentCompleted"),
+      // Deliberate no-op: logs are snapshotted at terminal via
+      // setRecentLogs; per-line emit would cause up to 10k TUI redraws.
+      logAppended: /* @__PURE__ */ __name(() => {
+      }, "logAppended"),
+      budgetUpdated: /* @__PURE__ */ __name((spent, total) => {
+        registry?.onBudgetUpdated(runId, spent, total);
+        emitUpdate();
+      }, "budgetUpdated")
+    };
+    const handle = new WorkflowRunHandle(
+      runId,
+      budget,
+      registry,
+      controller,
+      async () => {
+        try {
+          const outcome = await orchestrator.run({
+            script,
+            args: options.args,
+            abortOnTimeout: controller,
+            runId,
+            emitter,
+            budget,
+            resolveSavedWorkflow: /* @__PURE__ */ __name((ref) => resolveSavedWorkflowScript(ref, config), "resolveSavedWorkflow"),
+            journal,
+            resumeReplay
+          });
+          if (entry) {
+            entry.meta = outcome.meta;
+            if (outcome.meta?.name && entry.description === runId) {
+              entry.description = outcome.meta.name;
+            }
+          }
+          registry?.setRecentLogs(runId, outcome.logs);
+          registry?.complete(runId, outcome.result, Date.now());
+          return { ok: true, outcome };
+        } catch (error) {
+          const details = error instanceof WorkflowExecutionError ? error : void 0;
+          const message = extractErrorMessage2(error);
+          if (entry && details?.meta && !entry.meta) entry.meta = details.meta;
+          if (details?.logs) registry?.setRecentLogs(runId, details.logs);
+          if (callerWasAbortedBeforeStart || !runInBackground && options.signal.aborted || entry?.status === "cancelled") {
+            registry?.cancel(runId, Date.now());
+          } else {
+            registry?.fail(runId, message, Date.now());
+          }
+          return { ok: false, message, details };
+        } finally {
+          controller.abort();
+          if (entry && entry.status !== "running") {
+            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
+                })
+              );
+            } catch {
+            }
+          }
+          registry?.releaseHandle(runId, handle);
+        }
+      }
+    );
+    registry?.attachHandle(handle);
+    return handle;
+  }
+};
+function extractErrorMessage2(error) {
+  if (error && typeof error === "object" && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+    return String(message);
+  }
+  return String(error);
+}
+__name(extractErrorMessage2, "extractErrorMessage");
+
 // packages/core/src/tools/workflow/workflow.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
 import * as path from "node:path";
 var WORKFLOW_PARAM_SCHEMA = {
   type: "object",
@@ -2012,6 +2196,11 @@ var WORKFLOW_PARAM_SCHEMA = {
     resumeFromRunId: {
       type: "string",
       description: "Optional. Resume a prior workflow run by id (e.g. wf_abc123\u2026). Re-runs the SAME script; agent() calls whose rolling prefix-hash (prompt + opts, chained in call order) matches a journaled result are served from cache for the longest unchanged prefix, and the first changed/missing call onward runs live. Pass the same script and args as the original run for the cache to apply."
+    },
+    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."
     }
   }
   // `script` is required UNLESS `scriptPath` is supplied; this XOR can't be
@@ -2041,104 +2230,54 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
     return Promise.resolve("ask");
   }
   async execute(signal, updateOutput, _shellExecutionConfig) {
-    const dispatchController = createChildAbortController(signal);
-    const budget = WorkflowBudgetImpl.fromEnv();
-    const dispatch = this.toolOptions.dispatch ?? createProductionDispatch(
-      this.config,
-      dispatchController.signal,
-      // P5 T3: production-dispatch onTokens callback. Test-injected
-      // dispatches (`toolOptions.dispatch`) handle their own
-      // recording — they don't surface stats the same way.
-      (outputTokens) => budget.recordSpent(outputTokens)
-    );
-    const orchestrator = new WorkflowOrchestrator(dispatch);
-    let resolvedScript = this.params.script ?? "";
-    let resolvedScriptPath = this.params.scriptPath;
-    if (this.params.scriptPath && this.params.script === void 0) {
-      const loaded = await resolveSavedWorkflowScript(
-        { scriptPath: this.params.scriptPath },
-        this.config
-      );
-      resolvedScript = loaded.script;
-      resolvedScriptPath = loaded.scriptPath;
-    }
-    const runId = this.params.resumeFromRunId ?? `wf_${randomBytes2(8).toString("hex")}`;
-    let journal;
-    let resumeReplay;
-    const storage = this.config.storage;
-    if (storage) {
-      journal = new WorkflowJournal(storage.getWorkflowRunJournalPath(runId));
-      if (this.params.resumeFromRunId) {
-        resumeReplay = await journal.load();
-      }
+    const runInBackground = this.params.run_in_background === true;
+    if (runInBackground && signal.aborted) {
+      return backgroundStartCancelledResult();
     }
-    const registry = this.config.getWorkflowRunRegistry?.();
-    const registryEntry = registry?.register({
-      runId,
-      meta: null,
-      // populated after meta parses; safe default until then
-      status: "running",
-      startTime: Date.now(),
-      outputFile: "",
-      // P4b reserves the field but doesn't materialize
-      abortController: dispatchController,
-      // P5: seed the cap so the dialog can render the `M / N` form
-      // immediately, before the first `budgetUpdated` fires. Stays
-      // `null` when no env override.
-      tokenBudgetTotal: budget.total,
-      // P7b: carry the script source so a completed run can be snapshotted
-      // to disk and saved to `.qwen/workflows/<name>.js` from the dialog.
-      // `scriptPath` is set when the run was launched from a saved file (run
-      // provenance for the snapshot).
-      script: resolvedScript,
-      scriptPath: resolvedScriptPath
-    });
-    const emitter = {
-      phaseStarted: /* @__PURE__ */ __name((title) => {
-        registry?.onPhaseStarted(runId, title);
-        safeEmitUpdate(updateOutput, registryEntry);
-      }, "phaseStarted"),
-      agentDispatched: /* @__PURE__ */ __name(() => {
-        registry?.onAgentDispatched(runId);
-        safeEmitUpdate(updateOutput, registryEntry);
-      }, "agentDispatched"),
-      agentCompleted: /* @__PURE__ */ __name(() => {
-        registry?.onAgentCompleted(runId);
-      }, "agentCompleted"),
-      logAppended: /* @__PURE__ */ __name(() => {
-      }, "logAppended"),
-      budgetUpdated: /* @__PURE__ */ __name((spent, total) => {
-        registry?.onBudgetUpdated(runId, spent, total);
-        safeEmitUpdate(updateOutput, registryEntry);
-      }, "budgetUpdated")
-    };
+    let handle;
     try {
-      const outcome = await orchestrator.run({
-        script: resolvedScript,
+      handle = await WorkflowRunner.start({
+        config: this.config,
+        signal,
+        script: this.params.script,
+        scriptPath: this.params.scriptPath,
         args: this.params.args,
-        abortOnTimeout: dispatchController,
-        runId,
-        emitter,
-        budget,
-        // P-nested: resolve `workflow('<name>')` / `workflow({scriptPath})`
-        // against the saved-workflow scripts in `.qwen/workflows/`.
-        resolveSavedWorkflow: /* @__PURE__ */ __name((ref) => resolveSavedWorkflowScript(ref, this.config), "resolveSavedWorkflow"),
-        // P6: resume journal (always wired) + replay maps (resume only).
-        journal,
-        resumeReplay
+        resumeFromRunId: this.params.resumeFromRunId,
+        dispatch: this.toolOptions.dispatch,
+        runInBackground,
+        onUpdate: !runInBackground && updateOutput ? (entry) => safeEmitUpdate(updateOutput, entry) : void 0
       });
-      if (registryEntry) {
-        registryEntry.meta = outcome.meta;
-        if (outcome.meta?.name && registryEntry.description === runId) {
-          registryEntry.description = outcome.meta.name;
-        }
+    } catch (error) {
+      if (runInBackground && signal.aborted) {
+        return backgroundStartCancelledResult();
       }
-      registry?.setRecentLogs(runId, outcome.logs);
-      registry?.complete(runId, outcome.result, Date.now());
+      throw error;
+    }
+    if (runInBackground) {
+      const status = handle.registry?.get(handle.runId)?.status ?? "running";
+      const usageBanner = resolveUsageBanner(
+        this.config,
+        handle.registry,
+        handle.budget.total
+      );
+      return {
+        llmContent: [
+          {
+            text: `Workflow started in background.
+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.`
+      };
+    }
+    const settlement = await handle.completion;
+    if (settlement.ok) {
+      const { outcome } = settlement;
       const usageBanner = resolveUsageBanner(
         this.config,
-        registry,
-        budget.total
+        handle.registry,
+        handle.budget.total
       );
       const llmText = safeStringifyResult(outcome.result);
       const displayJson = safeStringifyDisplayPayload({
@@ -2153,10 +2292,10 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         // tokens whenever ANY usage is reported OR a cap is set, not
         // only when spend > 0. A capped-but-zero-spend run still wants
         // the cap visible so the user sees the gate engaged.
-        ...budget.spent() > 0 || budget.total !== null ? {
+        ...handle.budget.spent() > 0 || handle.budget.total !== null ? {
           tokens: {
-            spent: budget.spent(),
-            total: budget.total
+            spent: handle.budget.spent(),
+            total: handle.budget.total
           }
         } : {}
       });
@@ -2164,20 +2303,9 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         llmContent: [{ text: llmText }],
         returnDisplay: usageBanner + "```json\n" + displayJson + "\n```"
       };
-    } catch (err) {
-      const message = extractErrorMessage2(err);
-      const phases = err instanceof WorkflowExecutionError ? err.phases : void 0;
-      const logs = err instanceof WorkflowExecutionError ? err.logs : void 0;
-      const meta = err instanceof WorkflowExecutionError ? err.meta : void 0;
-      if (registryEntry) {
-        if (meta && !registryEntry.meta) registryEntry.meta = meta;
-      }
-      if (logs) registry?.setRecentLogs(runId, logs);
-      if (signal.aborted) {
-        registry?.cancel(runId, Date.now());
-      } else {
-        registry?.fail(runId, message, Date.now());
-      }
+    } else {
+      const { message, details } = settlement;
+      const { phases, logs, meta } = details ?? {};
       const display = phases || logs || meta ? `Workflow failed: ${message}
 
 ${safeStringifyDisplayPayload({
@@ -2193,28 +2321,16 @@ ${safeStringifyDisplayPayload({
         // the same way as other execution-time tool errors.
         error: { message, type: "execution_failed" /* EXECUTION_FAILED */ }
       };
-    } finally {
-      dispatchController.abort();
-      if (registryEntry && registryEntry.status !== "running") {
-        await writeWorkflowSnapshot(this.config, registryEntry);
-        try {
-          logWorkflowRun(
-            this.config,
-            new WorkflowRunEvent({
-              status: registryEntry.status,
-              agents_dispatched: registryEntry.agentsDispatched,
-              agents_completed: registryEntry.agentsCompleted,
-              phase_count: registryEntry.phases.length,
-              tokens_spent: registryEntry.tokensSpent,
-              duration_ms: (registryEntry.endTime ?? registryEntry.startTime) - registryEntry.startTime
-            })
-          );
-        } catch {
-        }
-      }
     }
   }
 };
+function backgroundStartCancelledResult() {
+  return {
+    llmContent: "Workflow was cancelled before it could start.",
+    returnDisplay: "Workflow cancelled."
+  };
+}
+__name(backgroundStartCancelledResult, "backgroundStartCancelledResult");
 function buildLivePhaseTreeDisplay(entry) {
   const payload = {
     runId: entry.runId,
@@ -2297,21 +2413,12 @@ function safeStringifyDisplayPayload(payload) {
   }
 }
 __name(safeStringifyDisplayPayload, "safeStringifyDisplayPayload");
-function extractErrorMessage2(err) {
-  if (err && typeof err === "object" && "message" in err) {
-    const m = err.message;
-    if (typeof m === "string") return m;
-    return String(m);
-  }
-  return String(err);
-}
-__name(extractErrorMessage2, "extractErrorMessage");
 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). 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, 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 */
@@ -2337,6 +2444,14 @@ var WorkflowTool = class extends BaseDeclarativeTool {
     if (params.resumeFromRunId !== void 0 && !/^wf_[0-9a-f]+$/.test(params.resumeFromRunId)) {
       return "WorkflowTool: `resumeFromRunId` must match the generated id format `wf_<hex>`.";
     }
+    if (params.run_in_background === true) {
+      if (!this.config.isInteractive() || this.config.getExperimentalZedIntegration?.() === true) {
+        return "WorkflowTool: `run_in_background` is available only in the interactive TUI.";
+      }
+      if (!this.config.getWorkflowRunRegistry().hasCompletionCallback()) {
+        return "WorkflowTool: `run_in_background` requires an active workflow completion channel.";
+      }
+    }
     return null;
   }
   createInvocation(params) {
@@ -2348,11 +2463,11 @@ export {
 };
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */