@qwen-code/qwen-code 0.21.8 → 0.21.9

package/chunks/{workflow-FXIPRQQA.js → workflow-5VH2R74I.js}

@@ -12,7 +12,7 @@ import {
   toModelVisibleSubagentResult,
   writeWorkflowSnapshot,
   writeWorktreeSessionMarker
-} from "./chunk-GXSNGY5M.js";
+} from "./chunk-XX7QFP34.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -24,7 +24,7 @@ import "./chunk-7MH4J33A.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-VXZ5HAOV.js";
+import "./chunk-K4ADGWHU.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-GNPNYXJB.js";
@@ -42,8 +42,8 @@ import "./chunk-67N6HB5H.js";
 import {
   SUBAGENT_PLAN_LIFECYCLE_TOOLS
 } from "./chunk-WAUGQKUU.js";
-import "./chunk-PLFATELK.js";
-import "./chunk-L4N6TIP7.js";
+import "./chunk-DZUO626D.js";
+import "./chunk-4TRQPFDP.js";
 import "./chunk-SAH4BD2J.js";
 import {
   runWithAgentContext
@@ -77,7 +77,7 @@ import {
   logWorkflowRun,
   read,
   writeLine
-} from "./chunk-3PY4LPJF.js";
+} from "./chunk-YGT2AUJ7.js";
 import "./chunk-WOJZWRAZ.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-FVKHVJZQ.js";
@@ -91,16 +91,16 @@ import {
   ToolDisplayNames,
   ToolNames
 } from "./chunk-PYQADEFD.js";
-import "./chunk-M3STHEMM.js";
+import "./chunk-PVOGHGSF.js";
 import "./chunk-F6WFNA7U.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
 import "./chunk-KKBPOU75.js";
 import "./chunk-EUNWC2VS.js";
 import "./chunk-FOGU3LJX.js";
-import "./chunk-6M26GBKX.js";
+import "./chunk-L2AFWWJE.js";
 import "./chunk-W4RQUHY3.js";
-import "./chunk-LKRMNRSN.js";
+import "./chunk-PDPFQ2FO.js";
 import {
   createDebugLogger
 } from "./chunk-OIVKILPI.js";
@@ -120,95 +120,6 @@ import {
 // packages/core/src/tools/workflow/workflow.ts
 init_esbuild_shims();
 
-// packages/core/src/agents/runtime/workflow-budget.ts
-init_esbuild_shims();
-var debugLogger = createDebugLogger("WORKFLOW_BUDGET");
-var MAX_TOKENS_PER_WORKFLOW_ENV = "QWEN_CODE_MAX_TOKENS_PER_WORKFLOW";
-var HARD_MAX_TOKENS_CEILING = 1e8;
-function resolveMaxTokensPerWorkflow(env = process.env) {
-  const raw = env[MAX_TOKENS_PER_WORKFLOW_ENV];
-  if (raw === void 0 || raw.trim() === "") {
-    return null;
-  }
-  const parsed = parsePositiveIntegerEnv(raw, 0);
-  if (parsed < 1) {
-    debugLogger.warn(
-      `Invalid ${MAX_TOKENS_PER_WORKFLOW_ENV}=${JSON.stringify(raw)}, treating as unset (no cap)`
-    );
-    return null;
-  }
-  if (parsed > HARD_MAX_TOKENS_CEILING) {
-    debugLogger.warn(
-      `${MAX_TOKENS_PER_WORKFLOW_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_TOKENS_CEILING}); clamping.`
-    );
-    return HARD_MAX_TOKENS_CEILING;
-  }
-  return parsed;
-}
-__name(resolveMaxTokensPerWorkflow, "resolveMaxTokensPerWorkflow");
-var WorkflowBudgetImpl = class _WorkflowBudgetImpl {
-  static {
-    __name(this, "WorkflowBudgetImpl");
-  }
-  total;
-  _spent;
-  constructor(total) {
-    this.total = total;
-    this._spent = 0;
-  }
-  spent() {
-    return this._spent;
-  }
-  remaining() {
-    if (this.total === null) return Infinity;
-    return Math.max(0, this.total - this._spent);
-  }
-  /**
-   * Host-side increment. NOT exposed to the script — the
-   * `WorkflowBudget` interface deliberately omits any setter so a
-   * malicious workflow cannot inflate / deflate the budget. Only the
-   * orchestrator (in `countedDispatch`) calls this after a dispatch
-   * resolves with the agent's output token count.
-   *
-   * Non-positive deltas are silently dropped (some dispatches return
-   * `output_tokens: 0` on early failures); negative deltas would be a
-   * caller bug and are also dropped rather than silently rewinding
-   * the counter.
-   */
-  recordSpent(deltaTokens) {
-    if (!Number.isFinite(deltaTokens) || deltaTokens <= 0) return;
-    this._spent += deltaTokens;
-  }
-  /**
-   * Factory: build a budget from the current environment. Convenience
-   * over `new WorkflowBudgetImpl(resolveMaxTokensPerWorkflow(env))`.
-   */
-  static fromEnv(env = process.env) {
-    return new _WorkflowBudgetImpl(resolveMaxTokensPerWorkflow(env));
-  }
-};
-var WorkflowBudgetExceededError = class extends Error {
-  static {
-    __name(this, "WorkflowBudgetExceededError");
-  }
-  name = "WorkflowBudgetExceededError";
-  runId;
-  budgetTotal;
-  spent;
-  constructor(runId, budgetTotal, spent) {
-    super(
-      `Workflow ${runId} exceeded the token budget (${spent} / ${budgetTotal} output tokens spent).`
-    );
-    this.runId = runId;
-    this.budgetTotal = budgetTotal;
-    this.spent = spent;
-  }
-};
-
-// packages/core/src/agents/runtime/workflow-runner.ts
-init_esbuild_shims();
-import { randomBytes as randomBytes2 } from "node:crypto";
-
 // packages/core/src/agents/runtime/workflow-orchestrator.ts
 init_esbuild_shims();
 import { randomBytes } from "node:crypto";
@@ -394,7 +305,7 @@ function isRegexContext(source, i) {
   return /[{[(,;:=!&|?+\-*/%^~<>]/.test(prev);
 }
 __name(isRegexContext, "isRegexContext");
-var debugLogger2 = createDebugLogger("WORKFLOW");
+var debugLogger = createDebugLogger("WORKFLOW");
 var MAX_LOG_LINES = 1e4;
 var MAX_PHASE_ENTRIES = 1e4;
 var ARGS_MAX_DEPTH = 64;
@@ -497,7 +408,7 @@ function createWorkflowSandbox(opts) {
       try {
         opts.emitter?.logAppended?.(line);
       } catch (e) {
-        debugLogger2.warn("emitter.logAppended threw:", e);
+        debugLogger.warn("emitter.logAppended threw:", e);
       }
     } else if (logs.length === MAX_LOG_LINES) {
       logs.push(`[workflow log truncated at ${MAX_LOG_LINES} lines]`);
@@ -511,7 +422,7 @@ function createWorkflowSandbox(opts) {
       try {
         opts.emitter?.phaseStarted?.(t);
       } catch (e) {
-        debugLogger2.warn("emitter.phaseStarted threw:", e);
+        debugLogger.warn("emitter.phaseStarted threw:", e);
       }
     } else if (phases.length === MAX_PHASE_ENTRIES) {
       phases.push(
@@ -545,7 +456,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) => {
-      debugLogger2.warn(
+      debugLogger.warn(
         `Workflow result revival failed at index ${idx}: ${reason}; slot set to null (non-JSON-serializable thunk return).`
       );
     }, "logRevivalFailure"),
@@ -1314,7 +1225,7 @@ function createWorkflowSandbox(opts) {
       mirroredEscapeKeys.add(key);
       safeLog("dispatch failed (rejection not handled): " + msg);
     } catch (e) {
-      debugLogger2.warn("adoptionEscapeHook failed:", e);
+      debugLogger.warn("adoptionEscapeHook failed:", e);
     }
   }, "adoptionEscapeHook");
   let extractedMeta = null;
@@ -1388,6 +1299,91 @@ ${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;
@@ -1747,13 +1743,13 @@ function resolveMaxAgentsPerRun(env = process.env) {
   }
   const parsed = parsePositiveIntegerEnv(raw, 0);
   if (parsed < 1) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `Invalid ${MAX_WORKFLOW_AGENTS_ENV}=${JSON.stringify(raw)}, using default (${DEFAULT_MAX_AGENTS_PER_RUN})`
     );
     return DEFAULT_MAX_AGENTS_PER_RUN;
   }
   if (parsed > HARD_MAX_AGENTS_PER_RUN_CEILING) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `${MAX_WORKFLOW_AGENTS_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_AGENTS_PER_RUN_CEILING}); clamping.`
     );
     return HARD_MAX_AGENTS_PER_RUN_CEILING;
@@ -1769,14 +1765,14 @@ function resolveConcurrencyLimit(env = process.env) {
     const parsed = parsePositiveIntegerEnv(raw, 0);
     if (parsed >= 1) {
       if (parsed > HARD_MAX_CONCURRENCY_CEILING) {
-        debugLogger2.warn(
+        debugLogger.warn(
           `${MAX_WORKFLOW_CONCURRENCY_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_CONCURRENCY_CEILING}); clamping.`
         );
         return HARD_MAX_CONCURRENCY_CEILING;
       }
       return parsed;
     }
-    debugLogger2.warn(
+    debugLogger.warn(
       `Invalid ${MAX_WORKFLOW_CONCURRENCY_ENV}=${JSON.stringify(raw)}, using cpu-derived default`
     );
   }
@@ -1849,11 +1845,11 @@ function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents
 }
 __name(createProductionDispatch, "createProductionDispatch");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, onTokens) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-2EE5J2KX.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-J5NFOPHP.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   const workflowAgentId = `workflow-agent-${randomBytes(8).toString("hex")}`;
-  debugLogger2.debug(`[workflow] Dispatch ${workflowAgentId}`);
+  debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
   if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0) {
     const subagent = await AgentHeadless.create(
       opts.label ?? "workflow-agent",
@@ -1911,7 +1907,7 @@ function reportTokens(subagent, opts, onTokens) {
     const summary = subagent.getExecutionSummary();
     onTokens(summary.outputTokens, opts);
   } catch (e) {
-    debugLogger2.warn("onTokens callback threw:", e);
+    debugLogger.warn("onTokens callback threw:", e);
   }
 }
 __name(reportTokens, "reportTokens");
@@ -2030,7 +2026,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
             worktreeIsolation = null;
             const preserved = await cleanupWorkflowWorktree(isolation);
             if (preserved) {
-              debugLogger2.info(
+              debugLogger.info(
                 `[Workflow] Schema-mode subagent preserved worktree at ${preserved.path ?? "(directory removed)"} on branch ${preserved.branch}. The structured payload is returned verbatim; recover the work from the preserved path / branch.`
               );
             }
@@ -2085,7 +2081,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
       try {
         await cleanupWorkflowWorktree(worktreeIsolation);
       } catch (error) {
-        debugLogger2.warn(
+        debugLogger.warn(
           `Workflow worktree cleanup in fallback finally failed for ${worktreeIsolation.path}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -2118,7 +2114,7 @@ async function provisionWorkflowWorktree(config) {
   try {
     parentDirty = await wtService.hasWorktreeChanges(projectRoot);
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] hasWorktreeChanges failed at ${projectRoot}: ${error}`
     );
     parentDirty = true;
@@ -2133,7 +2129,7 @@ async function provisionWorkflowWorktree(config) {
   try {
     parentBranch = await wtService.getCurrentBranch();
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] getCurrentBranch failed at ${projectRoot}: ${error}`
     );
   }
@@ -2151,7 +2147,7 @@ async function provisionWorkflowWorktree(config) {
       config.getSessionId()
     );
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] failed to write session marker at ${created.worktree.path}: ${error}`
     );
   }
@@ -2184,20 +2180,20 @@ async function cleanupWorkflowWorktree(isolation) {
   const wtService = new GitWorktreeService(isolation.repoRoot);
   const [hasChanges, hasUnmerged] = await Promise.all([
     wtService.hasWorktreeChanges(isolation.path).catch((error) => {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] hasWorktreeChanges failed for ${isolation.path}: ${error}`
       );
       return true;
     }),
     wtService.hasUnmergedWorktreeCommits(isolation.slug).catch((error) => {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] hasUnmergedWorktreeCommits failed for ${isolation.slug}: ${error}`
       );
       return true;
     })
   ]);
   if (hasChanges || hasUnmerged) {
-    debugLogger2.info(
+    debugLogger.info(
       `[Workflow] Preserving isolation worktree ${isolation.path} (branch ${isolation.branch}, hasChanges=${hasChanges}, hasUnmerged=${hasUnmerged})`
     );
     return { path: isolation.path, branch: isolation.branch };
@@ -2207,19 +2203,19 @@ async function cleanupWorkflowWorktree(isolation) {
       deleteBranch: true
     });
     if (!result.success) {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${result.error}`
       );
       return { path: isolation.path, branch: isolation.branch };
     }
     if (result.branchPreserved) {
-      debugLogger2.warn(
+      debugLogger.warn(
         `[Workflow] Removed worktree directory ${isolation.path} but kept branch ${isolation.branch} (unmerged commits at delete time)`
       );
       return { branch: isolation.branch };
     }
   } catch (error) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${error}`
     );
     return { path: isolation.path, branch: isolation.branch };
@@ -2315,7 +2311,7 @@ var WorkflowOrchestrator = class {
           if (cached !== void 0) {
             const respawns = replay.started.get(journalKey);
             if (respawns && respawns.length > 0) {
-              debugLogger2.info(
+              debugLogger.info(
                 `[Workflow] resume cache hit after ${respawns.length} prior respawn(s) for runId=${runId}.`
               );
             }
@@ -2323,12 +2319,12 @@ var WorkflowOrchestrator = class {
             try {
               emitter?.agentDispatched?.(label2);
             } catch (e) {
-              debugLogger2.warn("emitter.agentDispatched threw:", e);
+              debugLogger.warn("emitter.agentDispatched threw:", e);
             }
             try {
               emitter?.agentCompleted?.(label2);
             } catch (e) {
-              debugLogger2.warn("emitter.agentCompleted threw:", e);
+              debugLogger.warn("emitter.agentCompleted threw:", e);
             }
             return scheduler.waitUntilRunning().then(
               () => cached.result,
@@ -2339,11 +2335,11 @@ var WorkflowOrchestrator = class {
         hadMiss = true;
         journalEntryId = String(journalAgentId += 1);
         journal.append({ type: "started", key: journalKey, agentId: journalEntryId }).catch(
-          (e) => debugLogger2.warn(`journal started-append failed: ${e}`)
+          (e) => debugLogger.warn(`journal started-append failed: ${e}`)
         );
       }
       if (budget && budget.total !== null && budget.remaining() <= 0) {
-        debugLogger2.warn(
+        debugLogger.warn(
           `[Workflow] budget gate refused dispatch at entry: runId=${runId} spent=${budget.spent()} total=${budget.total}`
         );
         return rejectThroughPauseGate(
@@ -2362,7 +2358,7 @@ var WorkflowOrchestrator = class {
       try {
         emitter?.agentDispatched?.(label);
       } catch (e) {
-        debugLogger2.warn("emitter.agentDispatched threw:", e);
+        debugLogger.warn("emitter.agentDispatched threw:", e);
       }
       let completionEmitted = false;
       const emitCompletion = /* @__PURE__ */ __name((error) => {
@@ -2372,13 +2368,13 @@ var WorkflowOrchestrator = class {
         try {
           emitter?.agentCompleted?.(label, message);
         } catch (e) {
-          debugLogger2.warn("emitter.agentCompleted threw:", e);
+          debugLogger.warn("emitter.agentCompleted threw:", e);
         }
       }, "emitCompletion");
       return scheduler.run(async () => {
         try {
           if (budget && budget.total !== null && budget.remaining() <= 0) {
-            debugLogger2.warn(
+            debugLogger.warn(
               `[Workflow] budget gate refused dispatch at slot-acquire: runId=${runId} spent=${budget.spent()} total=${budget.total}`
             );
             throw new WorkflowBudgetExceededError(
@@ -2396,14 +2392,14 @@ var WorkflowOrchestrator = class {
               agentId: journalEntryId ?? "",
               result
             }).catch(
-              (e) => debugLogger2.warn(`journal result-append failed: ${e}`)
+              (e) => debugLogger.warn(`journal result-append failed: ${e}`)
             );
           }
           if (budget) {
             try {
               emitter?.budgetUpdated?.(budget.spent(), budget.total);
             } catch (e) {
-              debugLogger2.warn("emitter.budgetUpdated threw:", e);
+              debugLogger.warn("emitter.budgetUpdated threw:", e);
             }
           }
           return result;
@@ -2413,7 +2409,7 @@ var WorkflowOrchestrator = class {
             try {
               emitter?.budgetUpdated?.(budget.spent(), budget.total);
             } catch (e) {
-              debugLogger2.warn("emitter.budgetUpdated threw:", e);
+              debugLogger.warn("emitter.budgetUpdated threw:", e);
             }
           }
           throw err;
@@ -2514,14 +2510,14 @@ async function settleToNullArray(thunks, signal, kind = "parallel") {
     if (reason?.name === "WorkflowBudgetExceededError") {
       budgetDropped += 1;
     } else {
-      debugLogger2.warn(
+      debugLogger.warn(
         `Workflow thunk at index ${i} rejected: ${String(reason?.message ?? r.reason)}`
       );
     }
     return null;
   });
   if (budgetDropped > 0) {
-    debugLogger2.warn(
+    debugLogger.warn(
       `${kind}: ${budgetDropped} slot${budgetDropped === 1 ? "" : "s"} dropped \u2014 token budget exceeded.`
     );
   }
@@ -2595,6 +2591,8 @@ function extractErrorMessage(err) {
 __name(extractErrorMessage, "extractErrorMessage");
 
 // packages/core/src/agents/runtime/workflow-runner.ts
+init_esbuild_shims();
+import { randomBytes as randomBytes2 } from "node:crypto";
 var WorkflowRunHandle = class {
   constructor(runId, budget, registry, controller, scheduler, start) {
     this.runId = runId;
@@ -2788,7 +2786,7 @@ var WORKFLOW_PARAM_SCHEMA = {
   properties: {
     script: {
       type: "string",
-      description: "JavaScript source of the workflow. Wrapped as an async IIFE. May call the injected globals `phase(title)`, `log(msg)`, `agent(prompt, opts?)`, and read `args`. agent() opts: `{ label?, phase?, schema?, model?, agentType?, isolation? }`. `schema` (JSON Schema object): the subagent must deliver its result by calling `structured_output` with arguments matching the schema; agent() resolves to the validated object. Two failed attempts produce a terminal error \"subagent completed without calling StructuredOutput (after 2 in-conversation nudges)\". `agentType` (string): resolves against the declarative-agents registry (`.qwen/agents/<name>.md`, project then user then built-in). Unresolved names throw \"agent({agentType}): agent type 'X' not found\". `model` (string): per-call model override; routes provider correctly via the subagent runtime view. `isolation`: `'worktree'` provisions a fresh git worktree under `<projectRoot>/.qwen/worktrees/agent-<7hex>`; the worktree is auto-removed if no changes, otherwise the path and branch are returned alongside the result. `'remote'` throws \"agent({isolation:'remote'}) is not available in this build\" (parity with upstream). isolation=worktree refuses to run when the parent working tree has uncommitted changes (the subagent would see a stale HEAD). Workflow subagents always have SendMessage / Monitor / EnterPlanMode / ExitPlanMode in their disallowed-tool floor regardless of agentType. Concurrency: `parallel([() => agent(...), ...])` runs thunks through a shared per-run window (default `max(1, min(16, cpus-2))` agents in flight; override via `QWEN_CODE_MAX_WORKFLOW_CONCURRENCY`) and resolves to a position-aligned array \u2014 a thunk that throws, or resolves to a non-JSON-serializable value, becomes `null` at its index (errors-as-data); parallel() itself rejects only on invalid arguments or abort. `pipeline(items, ...stages)` runs each item through the stages (staggered, no inter-stage barrier); a stage that throws, returns `null`, or returns a non-JSON-serializable value drops that item to `null`. Pass THUNKS to parallel, not eager calls: `parallel([() => agent(...)])`, not `parallel([agent(...)])`. At most 1000 agent() calls per run (override via `QWEN_CODE_MAX_WORKFLOW_AGENTS`). `Date.now()` and `Math.random()` both throw \u2014 workflow scripts must be deterministic for resume. `export const meta = {...}` declarations are stripped before execution."
+      description: `JavaScript source of the workflow. Wrapped as an async IIFE. May call the injected globals \`phase(title)\`, \`log(msg)\`, \`agent(prompt, opts?)\`, and read \`args\`. agent() opts: \`{ label?, phase?, schema?, model?, agentType?, isolation? }\`. \`schema\` (JSON Schema object): the subagent must deliver its result by calling \`structured_output\` with arguments matching the schema; agent() resolves to the validated object. Two failed attempts produce a terminal error "subagent completed without calling StructuredOutput (after 2 in-conversation nudges)". \`agentType\` (string): resolves against the declarative-agents registry (\`.qwen/agents/<name>.md\`, project then user then built-in). Unresolved names throw "agent({agentType}): agent type 'X' not found". \`model\` (string): per-call model override; routes provider correctly via the subagent runtime view. \`isolation\`: \`'worktree'\` provisions a fresh git worktree under \`<projectRoot>/.qwen/worktrees/agent-<7hex>\`; the worktree is auto-removed if no changes, otherwise the path and branch are returned alongside the result. \`'remote'\` throws "agent({isolation:'remote'}) is not available in this build" (parity with upstream). isolation=worktree refuses to run when the parent working tree has uncommitted changes (the subagent would see a stale HEAD). Workflow subagents always have SendMessage / Monitor / EnterPlanMode / ExitPlanMode in their disallowed-tool floor regardless of agentType. Concurrency: \`parallel([() => agent(...), ...])\` runs thunks through a shared per-run window (default \`max(1, min(16, cpus-2))\` agents in flight; override via \`${MAX_WORKFLOW_CONCURRENCY_ENV}\`) and resolves to a position-aligned array \u2014 a thunk that throws, or resolves to a non-JSON-serializable value, becomes \`null\` at its index (errors-as-data); parallel() itself rejects only on invalid arguments or abort. \`pipeline(items, ...stages)\` runs each item through the stages (staggered, no inter-stage barrier); a stage that throws, returns \`null\`, or returns a non-JSON-serializable value drops that item to \`null\`. Pass THUNKS to parallel, not eager calls: \`parallel([() => agent(...)])\`, not \`parallel([agent(...)])\`. At most ${DEFAULT_MAX_AGENTS_PER_RUN} agent() calls per run (override via \`${MAX_WORKFLOW_AGENTS_ENV}\`). \`Date.now()\` and \`Math.random()\` both throw \u2014 workflow scripts must be deterministic for resume. \`export const meta = {...}\` declarations are stripped before execution.`
     },
     scriptPath: {
       type: "string",
@@ -3017,12 +3015,47 @@ function safeStringifyDisplayPayload(payload) {
   }
 }
 __name(safeStringifyDisplayPayload, "safeStringifyDisplayPayload");
+var WORKFLOW_TOOL_DESCRIPTION = `Execute a workflow script that orchestrates subagents deterministically.
+
+**What a workflow is for**
+
+Reach for one to be comprehensive (decompose the work and cover every part in parallel), to be confident (independent perspectives and adversarial checks before an answer is committed to), or to take on scale a single context cannot hold \u2014 migrations, audits, broad sweeps. The script is where that structure is encoded: what fans out, what verifies, what synthesizes. Parallelism on its own is not a reason; work that is already one short sequence of edits belongs in the main loop.
+
+**Runtime** \u2014 see the \`script\` parameter for the detailed authoring contract.
+
+\`phase(title)\`, \`log(msg)\`, \`agent(prompt, opts?)\`, \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`workflow(nameOrRef, args?)\`, plus the \`args\` and \`budget\` globals. \`workflow()\` runs a saved workflow inline under this run's caps and nests one level only \u2014 a workflow reached through \`workflow()\` cannot call \`workflow()\` itself, and doing so throws. Saved workflows are \`<name>.js\` files under \`<projectRoot>/.qwen/workflows\` (project scope, also surfaced as \`/<name>\` slash commands) or \`~/.qwen/workflows\` (user scope, lower precedence when both define the same name); \`workflow('<name>')\` resolves against those two directories, while \`scriptPath\` takes an absolute path to a script anywhere. Default \`max(1, min(16, cpus-2))\` agents in flight per run (\`${MAX_WORKFLOW_CONCURRENCY_ENV}\`), up to ${DEFAULT_MAX_AGENTS_PER_RUN} agents total (\`${MAX_WORKFLOW_AGENTS_ENV}\`), under a 30-minute wall-clock cap per run (\`QWEN_CODE_MAX_WORKFLOW_SECONDS\`) \u2014 a fan-out near the agent cap will not fit inside the default cap. A per-run output-token cap may also be in effect: read \`budget.total\` (\`null\` = uncapped) before committing to a large fan-out, because once the cap is reached every further \`agent()\` call is refused \u2014 a bare sequential \`await agent()\` sees the rejection, while inside \`parallel()\`/\`pipeline()\` the refused slot becomes \`null\` and the script keeps running on partial results. Per-call \`agent({ schema, agentType, model, isolation: 'worktree' })\` covers structured-output contracts, declarative-agent selection, model override, and git-worktree-isolated subagents. \`resumeFromRunId\` resumes a prior run \u2014 agent() calls whose rolling prefix-hash matches the journal are served from cache for the longest unchanged prefix. Runs appear in the background-tasks view and the \`/workflows\` dialog (live phase tree, token usage, cooperative pause/resume, cancel); \`run_in_background: true\` returns a run handle immediately in the interactive TUI and delivers completion through the conversation. Scripts run in a node:vm sandbox with no filesystem or shell access \u2014 all I/O happens through the spawned agents.
+
+**Scout first, then orchestrate**
+
+The strongest pattern is hybrid: discover the work list in the main loop (list the files, scope the diff, read the failing test), then hand that list to a workflow. You do not need to know the shape of the work before the task \u2014 only before the orchestration step. When the work has distinct phases, run several small workflows across turns and read each result before choosing the next, rather than authoring one large script that runs unattended.
+
+Common single-phase shapes: understand (parallel readers over subsystems, merged into one map), design (independent approaches, judged, then synthesized), review (dimensions, find, verify each finding), research (broad sweep, deep read, synthesis), migrate (discover sites, transform each under \`isolation: 'worktree'\`, verify).
+
+**Default to \`pipeline()\`**
+
+\`pipeline()\` runs each item through every stage independently \u2014 item A can be in stage 3 while item B is still in stage 1 \u2014 so wall-clock is the slowest single chain. \`parallel()\` is a barrier: it waits for every thunk before anything moves on, so it costs the slowest item of every stage.
+
+A barrier is right only when a stage genuinely needs cross-item context: deduplicating or merging across the full result set before expensive downstream work, exiting early when the total count is zero, or a prompt that compares one finding against all the others. It is not justified by needing to flatten, map, or filter between stages (do that inside a pipeline stage), by two stages being conceptually separate, or by the code reading more tidily. Smell test: \`parallel()\` \u2192 a pure transform \u2192 \`parallel()\` is a pipeline someone wrote with an unnecessary barrier. When in doubt, \`pipeline()\`.
+
+**Verify before believing**
+
+A subagent's answer is a claim, not a result. For findings that matter, spawn independent verifiers prompted to *refute*, and drop what a majority refutes. When a claim can be wrong in several different ways, give each verifier a distinct lens (correctness, security, performance, does it actually reproduce) \u2014 diversity catches what repetition cannot. For a wide solution space, generate several independent attempts, judge them in parallel, and synthesize from the winner while grafting the best ideas from the rest.
+
+**Converge deliberately**
+
+For discovery of unknown size, keep running finders until some number of consecutive rounds turn up nothing new; a fixed round count stops partway into the tail. Deduplicate each round against everything already seen, never against only what survived judging \u2014 otherwise rejected findings reappear every round and the loop never terminates. A closing pass that asks what is still missing (a search angle never run, a claim never verified, a file never read) usually produces the next round of real work.
+
+**Report honestly**
+
+Scale the fleet to what was actually asked: a quick check gets a few agents and one verification pass; an explicit request to be thorough or exhaustive earns a larger pool and a multi-vote adversarial round. Whenever a run bounds its own coverage \u2014 top-N, sampling, no retry \u2014 \`log()\` what was dropped. Silent truncation reads as full coverage, which is worse than a smaller honest result.
+
+These shapes are a starting point, not a menu; compose the harness the task actually needs.`;
 var WorkflowTool = class extends BaseDeclarativeTool {
   constructor(config, toolOptions = {}) {
     super(
       ToolNames.WORKFLOW,
       ToolDisplayNames.WORKFLOW,
-      "Execute a workflow script that orchestrates subagents. Supports `phase`, `log`, sequential `agent`, concurrent fan-out via `parallel(thunks)` / `pipeline(items, ...stages)` (default `max(1, min(16, cpus-2))` agents in flight per run, up to 1000 agents total; both env-overridable), per-call `agent({ schema, agentType, model, isolation: 'worktree' })` for structured-output contracts, declarative-agent selection, model override, and git-worktree-isolated subagents. Pass `resumeFromRunId` to resume a prior run \u2014 agent() calls whose rolling prefix-hash matches the journal are served from cache for the longest unchanged prefix. Runs are tracked in the background-tasks view and the `/workflows` dialog (live phase tree, token usage, 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.",
+      WORKFLOW_TOOL_DESCRIPTION,
       "other" /* Other */,
       WORKFLOW_PARAM_SCHEMA,
       /* isOutputMarkdown */
@@ -3067,11 +3100,11 @@ export {
 };
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */