@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/{workflow-Y5IPINVH.js → workflow-TOLPAK5G.js}

@@ -4,7 +4,7 @@ import {
   isSymlinkedRoot,
   resolveSavedWorkflowScript,
   writeWorkflowSnapshot
-} from "./chunk-2OUD5T67.js";
+} from "./chunk-I2TMJPCV.js";
 import {
   AgentEventEmitter,
   attachJsonlTranscriptWriter,
@@ -13,109 +13,112 @@ import {
   deriveConfig,
   deriveWorktreeConfig,
   getRuleDisplayName,
+  getWorkflowTaskMutationKey,
+  installSessionWorkflowRevisionWriteThrough,
   isTerminalWorkflowStatus,
   rebuildToolRegistryOnOverride,
   resolveExternalWorktreeDir,
   resolveToolName,
-  toModelVisibleSubagentResult
-} from "./chunk-PZ66FRIC.js";
+  toModelVisibleSubagentResult,
+  tryWithWorkflowTaskMutation
+} from "./chunk-4F7GQGXB.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
+import "./chunk-6HUXPLB5.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
-import "./chunk-EKSCLBBF.js";
-import "./chunk-LUEHOUHM.js";
-import "./chunk-WXEA74YB.js";
-import "./chunk-42IDLQWS.js";
+import "./chunk-NSUKQ4DN.js";
+import "./chunk-DQCKVAF5.js";
+import "./chunk-AI35S34R.js";
+import {
+  GitWorktreeService,
+  generateAgentWorktreeSlug,
+  writeWorktreeSessionMarker
+} from "./chunk-KM3XVTMO.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-JB4JIVTJ.js";
-import "./chunk-DJBQCO2E.js";
+import "./chunk-OKTNXDVO.js";
+import "./chunk-EFTPIZIC.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-D5LUXLUH.js";
+import "./chunk-UJ4DUYIH.js";
+import "./chunk-QJNDUTOL.js";
 import "./chunk-O6GEWCJA.js";
-import "./chunk-T26EAKDL.js";
-import {
-  GitWorktreeService,
-  generateAgentWorktreeSlug,
-  writeWorktreeSessionMarker
-} from "./chunk-2SXSLSQE.js";
-import "./chunk-CPBF7KYF.js";
-import "./chunk-KJO2LBUK.js";
-import "./chunk-TTX2JUE6.js";
-import "./chunk-4K7KNVWH.js";
-import "./chunk-SMPR7SPO.js";
-import "./chunk-JWALNCLT.js";
-import "./chunk-NIFYWDYN.js";
-import "./chunk-C2X7KY45.js";
-import "./chunk-JHYH6PYQ.js";
-import "./chunk-7J6OTNGO.js";
+import "./chunk-OSSTATJF.js";
+import "./chunk-ZHO2CW6D.js";
+import "./chunk-CVX63TFJ.js";
+import "./chunk-373DQUVA.js";
+import "./chunk-H43PSPYS.js";
+import "./chunk-U6D2PPMN.js";
+import "./chunk-VYIUNFEA.js";
+import "./chunk-KGV55H53.js";
+import "./chunk-7TBU7PU2.js";
+import "./chunk-E4JNFXNI.js";
+import "./chunk-CHEIIBT3.js";
 import {
   SUBAGENT_PLAN_LIFECYCLE_TOOLS
-} from "./chunk-V5J4J5TP.js";
+} from "./chunk-TJYRTS4S.js";
+import "./chunk-JX6XHPTX.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-NAVJD2PQ.js";
-import "./chunk-B466ZSHZ.js";
-import "./chunk-4QHPPXK2.js";
-import "./chunk-QHMLYMMS.js";
-import "./chunk-3WK3QDNV.js";
 import "./chunk-PQEISIKS.js";
-import "./chunk-EB6QRGHM.js";
+import "./chunk-FD5SJOWT.js";
 import {
   runWithAgentContext
-} from "./chunk-CMHFCLBU.js";
+} from "./chunk-4LIFGNI4.js";
 import "./chunk-S6LOFUVP.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-KFN2IZYR.js";
+import "./chunk-GB4UKWY5.js";
+import "./chunk-QHMLYMMS.js";
 import "./chunk-CFKIH3D3.js";
 import "./chunk-2LD5U7Q3.js";
 import {
   createAbortController,
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
-import "./chunk-DYXFD5RO.js";
-import "./chunk-V4264FEG.js";
+import "./chunk-S2T7H5MI.js";
+import "./chunk-LKODFJRD.js";
+import "./chunk-LB3WQQJK.js";
 import {
   WorkflowRunEvent,
   logWorkflowRun,
   read,
   writeLine
-} from "./chunk-QYMAKPY5.js";
+} from "./chunk-GH2S4GD5.js";
 import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   isWithinRoot
-} from "./chunk-BKWNKLZB.js";
-import "./chunk-6PJOTWAN.js";
-import "./chunk-BWORX6FA.js";
+} from "./chunk-DYTW3QVG.js";
+import "./chunk-HT5S5TRQ.js";
 import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
-import "./chunk-6DIGWMGT.js";
-import "./chunk-W3JH33JE.js";
-import "./chunk-XZA32HII.js";
-import "./chunk-23RFD54N.js";
-import "./chunk-PPKZ7JOE.js";
+import "./chunk-EIJT2PQ6.js";
+import "./chunk-BFY33IB4.js";
+import "./chunk-KHP66DFN.js";
+import "./chunk-22UH7VTP.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   stripAnsiAndControl
-} from "./chunk-B5PHIJGI.js";
+} from "./chunk-QKDNS6FU.js";
 import "./chunk-74TONY4F.js";
 import {
   SyntheticOutputTool
-} from "./chunk-XF63PKEN.js";
-import "./chunk-CAJTKR6W.js";
-import "./chunk-ZU4UDIWX.js";
+} from "./chunk-ZDFQGHZH.js";
+import "./chunk-G7HBEEX7.js";
+import "./chunk-QQD2GART.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-PDQGMSZK.js";
+import "./chunk-ODZF64DM.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -544,6 +547,12 @@ function compileWorkflowScript(scriptSource) {
   return { script, meta };
 }
 __name(compileWorkflowScript, "compileWorkflowScript");
+function workflowCancelledError() {
+  const error = new Error("Workflow run was aborted (cancelled).");
+  error.name = "AbortError";
+  return error;
+}
+__name(workflowCancelledError, "workflowCancelledError");
 var COMPILE_ERROR_LINE_WIDTH = 80;
 function describeWorkflowCompileError(error, authorLineCount) {
   const err = error instanceof Error ? error : new Error(String(error));
@@ -1630,16 +1639,22 @@ function createWorkflowSandbox(opts) {
       let watchdog;
       let stopWatchingState;
       let rearmWatchdogOnAbort;
+      let settleOnAbort;
+      let wallClockFired = false;
       process.on("unhandledRejection", adoptionEscapeHook);
       try {
         const { script, meta } = compileWorkflowScript(scriptSource);
         extractedMeta = meta;
+        if (opts.abortOnTimeout?.signal.aborted) {
+          throw workflowCancelledError();
+        }
         const runOpts = {
           timeout: 3e4
         };
         const result = script.runInContext(ctx, runOpts);
         const timeoutPromise = new Promise((_, reject) => {
           watchdog = new WallClockWatchdog(maxWallClockMs, () => {
+            wallClockFired = true;
             opts.abortOnTimeout?.abort();
             reject(
               new Error(
@@ -1662,7 +1677,15 @@ function createWorkflowSandbox(opts) {
           rearmWatchdogOnAbort,
           { once: true }
         );
-        return await Promise.race([result, timeoutPromise]);
+        const abortPromise = new Promise((_, reject) => {
+          const signal = opts.abortOnTimeout?.signal;
+          if (!signal) return;
+          settleOnAbort = /* @__PURE__ */ __name(() => {
+            if (!wallClockFired) reject(workflowCancelledError());
+          }, "settleOnAbort");
+          signal.addEventListener("abort", settleOnAbort, { once: true });
+        });
+        return await Promise.race([result, timeoutPromise, abortPromise]);
       } finally {
         if (rearmWatchdogOnAbort) {
           opts.abortOnTimeout?.signal.removeEventListener(
@@ -1670,6 +1693,12 @@ function createWorkflowSandbox(opts) {
             rearmWatchdogOnAbort
           );
         }
+        if (settleOnAbort) {
+          opts.abortOnTimeout?.signal.removeEventListener(
+            "abort",
+            settleOnAbort
+          );
+        }
         stopWatchingState?.();
         watchdog?.stop();
         await flushUnconsumedRejections();
@@ -2163,7 +2192,7 @@ function resolveMaxAgentsPerRun(env = process.env) {
 __name(resolveMaxAgentsPerRun, "resolveMaxAgentsPerRun");
 var MAX_WORKFLOW_CONCURRENCY_ENV = "QWEN_CODE_MAX_WORKFLOW_CONCURRENCY";
 var HARD_MAX_CONCURRENCY_CEILING = 64;
-function resolveConcurrencyLimit(env = process.env) {
+function resolveConcurrencyLimit(env = process.env, availableParallelism2 = os.availableParallelism) {
   const raw = env[MAX_WORKFLOW_CONCURRENCY_ENV];
   if (raw !== void 0 && raw.trim() !== "") {
     const parsed = parsePositiveIntegerEnv(raw, 0);
@@ -2180,7 +2209,7 @@ function resolveConcurrencyLimit(env = process.env) {
       `Invalid ${MAX_WORKFLOW_CONCURRENCY_ENV}=${JSON.stringify(raw)}, using cpu-derived default`
     );
   }
-  return Math.max(1, Math.min(16, os.cpus().length - 2));
+  return Math.max(2, Math.min(16, availableParallelism2() - 2));
 }
 __name(resolveConcurrencyLimit, "resolveConcurrencyLimit");
 var DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS = 50;
@@ -2351,7 +2380,7 @@ function attachDispatchTranscript(config, agentId, prompt, agentName, emitter, a
 }
 __name(attachDispatchTranscript, "attachDispatchTranscript");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, workflowAgentId, agentIdentity, onTokens) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-IZM25LJA.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-OC2IB55D.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
@@ -2482,6 +2511,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
     effectiveContext = deriveWorktreeConfig(config, worktreeIsolation.path, {
       customIgnoreFiles: config.getFileFilteringOptions().customIgnoreFiles
     });
+    installSessionWorkflowRevisionWriteThrough(effectiveContext, config);
   } else if (opts.workingDir !== void 0) {
     if (typeof opts.workingDir !== "string" || opts.workingDir.trim().length === 0) {
       throw new Error(
@@ -2501,6 +2531,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
     effectiveContext = deriveWorktreeConfig(config, resolved.path, {
       customIgnoreFiles: config.getFileFilteringOptions().customIgnoreFiles
     });
+    installSessionWorkflowRevisionWriteThrough(effectiveContext, config);
   }
   if (effectiveContext !== config) {
     const approvalHandle = deriveApprovalModeConfig(
@@ -2794,6 +2825,7 @@ function attachSchemaListeners(emitter, state) {
 __name(attachSchemaListeners, "attachSchemaListeners");
 async function createSchemaConfigOverride(base, schema) {
   const override = deriveConfig(base);
+  installSessionWorkflowRevisionWriteThrough(override, base);
   await rebuildToolRegistryOnOverride(override, base);
   const registry = override.getToolRegistry();
   registry.registerTool(new SyntheticOutputTool(schema));
@@ -3258,74 +3290,111 @@ Workflow scripts must be plain JavaScript \u2014 the usual causes are TypeScript
     __name(this, "WorkflowScriptNotLaunchedError");
   }
 };
+var WorkflowStartCancelledError = class extends Error {
+  static {
+    __name(this, "WorkflowStartCancelledError");
+  }
+  constructor() {
+    super("Workflow start was cancelled.");
+    this.name = "WorkflowStartCancelledError";
+  }
+};
 var WorkflowRunner = class {
   static {
     __name(this, "WorkflowRunner");
   }
   static async start(options) {
+    if (options.resumeFromRunId) {
+      const attempt = await tryWithWorkflowTaskMutation(
+        getWorkflowTaskMutationKey(options.config, options.resumeFromRunId),
+        () => this.startClaimed(options)
+      );
+      if (!attempt.acquired) {
+        throw new Error(
+          `Workflow run ${options.resumeFromRunId} is already being modified.`
+        );
+      }
+      return attempt.value;
+    }
+    return this.startClaimed(options);
+  }
+  static async startClaimed(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;
-    try {
-      compileWorkflowScript(script);
-    } catch (error) {
-      throw new WorkflowScriptNotLaunchedError(
-        describeWorkflowCompileError(
-          error,
-          script.split(/\r\n|[\n\r\u2028\u2029]/).length
-        )
-      );
-    }
     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 registry = config.getWorkflowRunRegistry?.();
     let entry;
     const isCurrentEntry = /* @__PURE__ */ __name(() => registry === void 0 || entry !== void 0 && registry.get(runId) === entry, "isCurrentEntry");
-    const controller = runInBackground ? createAbortController() : createChildAbortController(options.signal);
-    const dispatch = options.dispatch ?? createProductionDispatch(
-      config,
-      controller.signal,
-      (outputTokens) => budget.recordSpent(outputTokens),
-      registry ? (emitter2, dispatchId) => isCurrentEntry() ? registry.bridgeApprovalEvents(
-        runId,
-        emitter2,
-        dispatchId,
-        entry
-      ) : () => void 0 : void 0
-    );
-    const orchestrator = new WorkflowOrchestrator(dispatch);
+    const createController = /* @__PURE__ */ __name(() => runInBackground ? createAbortController() : createChildAbortController(options.signal), "createController");
+    const controller = registry ? registry.reserveStart(runId, createController) : createController();
+    const storage = config.storage;
+    const journal = storage ? new WorkflowJournal(storage.getWorkflowRunJournalPath(runId)) : void 0;
+    let script;
+    let scriptPath;
+    let resumeReplay;
+    let callerWasAbortedBeforeStart;
+    let orchestrator;
     try {
-      entry = registry?.register({
-        runId,
-        toolUseId: options.toolUseId,
-        meta: null,
-        status: "running",
-        startTime: Date.now(),
-        outputFile: "",
-        abortController: controller,
-        tokenBudgetTotal: budget.total,
-        script,
-        scriptPath,
-        args: options.args,
-        ...options.resumeFromRunId ? {
-          sourceRunId: options.resumeFromRunId,
-          startMode: "retry"
-        } : {},
-        isBackgrounded: runInBackground
-      });
+      const loaded = options.scriptPath && options.script === void 0 ? await resolveSavedWorkflowScript(
+        { scriptPath: options.scriptPath },
+        config
+      ) : void 0;
+      script = loaded?.script ?? options.script ?? "";
+      scriptPath = loaded?.scriptPath ?? options.scriptPath;
+      try {
+        compileWorkflowScript(script);
+      } catch (error) {
+        throw new WorkflowScriptNotLaunchedError(
+          describeWorkflowCompileError(
+            error,
+            script.split(/\r\n|[\n\r\u2028\u2029]/).length
+          )
+        );
+      }
+      resumeReplay = options.resumeFromRunId ? await journal?.load() : void 0;
+      if (controller.signal.aborted && !options.signal.aborted) {
+        throw new WorkflowStartCancelledError();
+      }
+      if (runInBackground && options.signal.aborted) {
+        throw new WorkflowStartCancelledError();
+      }
+      callerWasAbortedBeforeStart = options.signal.aborted;
+      const dispatch = options.dispatch ?? createProductionDispatch(
+        config,
+        controller.signal,
+        (outputTokens) => budget.recordSpent(outputTokens),
+        registry ? (emitter2, dispatchId) => isCurrentEntry() ? registry.bridgeApprovalEvents(
+          runId,
+          emitter2,
+          dispatchId,
+          entry
+        ) : () => void 0 : void 0
+      );
+      orchestrator = new WorkflowOrchestrator(dispatch);
+      entry = registry?.register(
+        {
+          runId,
+          toolUseId: options.toolUseId,
+          meta: null,
+          status: "running",
+          startTime: Date.now(),
+          outputFile: "",
+          abortController: controller,
+          tokenBudgetTotal: budget.total,
+          script,
+          scriptPath,
+          args: options.args,
+          ...options.resumeFromRunId ? {
+            sourceRunId: options.resumeFromRunId,
+            startMode: "retry"
+          } : {},
+          isBackgrounded: runInBackground
+        },
+        controller
+      );
     } catch (error) {
+      registry?.releaseStart(runId, controller);
       controller.abort();
       throw error;
     }
@@ -3432,7 +3501,14 @@ var WorkflowRunner = class {
           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") {
+          if (entry && isTerminalWorkflowStatus(entry.status)) {
+            return {
+              ok: false,
+              message: entry.status === "cancelled" ? "Workflow run cancelled." : entry.error ?? message,
+              details
+            };
+          }
+          if (callerWasAbortedBeforeStart || !runInBackground && options.signal.aborted) {
             registry?.cancel(runId, Date.now());
           } else {
             registry?.fail(runId, message, Date.now());
@@ -3449,7 +3525,13 @@ var WorkflowRunner = class {
               tokens_spent: entry.tokensSpent,
               duration_ms: (entry.endTime ?? entry.startTime) - entry.startTime
             });
-            await writeWorkflowSnapshot(config, entry);
+            const snapshotPersisted = await writeWorkflowSnapshot(
+              config,
+              entry
+            );
+            if (snapshotPersisted) {
+              registry?.notifySnapshotPersisted(entry.runId);
+            }
             await journal?.drain();
             try {
               logWorkflowRun(config, telemetryEvent);
@@ -3482,7 +3564,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?, workingDir?, stallMs? }\`. \`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). \`workingDir\` (string): pin the subagent to an EXISTING git worktree of this repository that the caller owns \u2014 nothing is created and nothing is removed. Use it when the directory the agent must work in already exists and its uncommitted state is the point (a review worktree, a checkout a previous step provisioned) \u2014 exactly the case isolation cannot serve. Mutually exclusive with \`isolation\`. The path must be a linked worktree of this repository registered via \`git worktree add\` (it may live anywhere on disk) \u2014 the main checkout is not eligible. \`stallMs\` (number, ms): a no-progress watchdog, not a wall-clock cap. The dispatch is aborted and retried (up to ${MAX_STALL_ATTEMPTS} attempts total) after this many milliseconds with no observable subagent progress \u2014 including before the first response arrives; the timer is suspended while a tool is in flight, so a legitimately slow tool is not a stall. Default ${DEFAULT_STALL_MS} (override via \`${MAX_WORKFLOW_STALL_MS_ENV}\`, whole seconds); \`0\` disables the watchdog. Wall time per attempt is bounded separately. 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.`
+      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?, workingDir?, stallMs? }\`. \`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). \`workingDir\` (string): pin the subagent to an EXISTING git worktree of this repository that the caller owns \u2014 nothing is created and nothing is removed. Use it when the directory the agent must work in already exists and its uncommitted state is the point (a review worktree, a checkout a previous step provisioned) \u2014 exactly the case isolation cannot serve. Mutually exclusive with \`isolation\`. The path must be a linked worktree of this repository registered via \`git worktree add\` (it may live anywhere on disk) \u2014 the main checkout is not eligible. \`stallMs\` (number, ms): a no-progress watchdog, not a wall-clock cap. The dispatch is aborted and retried (up to ${MAX_STALL_ATTEMPTS} attempts total) after this many milliseconds with no observable subagent progress \u2014 including before the first response arrives; the timer is suspended while a tool is in flight, so a legitimately slow tool is not a stall. Default ${DEFAULT_STALL_MS} (override via \`${MAX_WORKFLOW_STALL_MS_ENV}\`, whole seconds); \`0\` disables the watchdog. Wall time per attempt is bounded separately. 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(2, 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",
@@ -3610,7 +3692,7 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
   async execute(signal, updateOutput, _shellExecutionConfig) {
     const runInBackground = this.params.run_in_background === true;
     if (runInBackground && signal.aborted) {
-      return backgroundStartCancelledResult();
+      return startCancelledResult();
     }
     let handle;
     try {
@@ -3627,8 +3709,8 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         onUpdate: !runInBackground && updateOutput ? (entry) => safeEmitUpdate(updateOutput, entry) : void 0
       });
     } catch (error) {
-      if (runInBackground && signal.aborted) {
-        return backgroundStartCancelledResult();
+      if (error instanceof WorkflowStartCancelledError || runInBackground && signal.aborted) {
+        return startCancelledResult();
       }
       if (error instanceof WorkflowScriptNotLaunchedError) {
         return {
@@ -3714,13 +3796,13 @@ ${safeStringifyDisplayPayload({
     }
   }
 };
-function backgroundStartCancelledResult() {
+function startCancelledResult() {
   return {
     llmContent: "Workflow was cancelled before it could start.",
     returnDisplay: "Workflow cancelled."
   };
 }
-__name(backgroundStartCancelledResult, "backgroundStartCancelledResult");
+__name(startCancelledResult, "startCancelledResult");
 function buildLivePhaseTreeDisplay(entry) {
   const payload = {
     runId: entry.runId,
@@ -3923,7 +4005,7 @@ Reach for one to be comprehensive (decompose the work and cover every part in pa
 
 **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 inside either of them or inside the generated-scripts root (\`$QWEN_CODE_PROJECT_DIR/workflows/generated\` \u2014 the per-project runtime dir, not the project tree \u2014 where a tool emitting a one-run script writes it; never a slash command, never resolvable by name); a path outside those roots is refused. 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. Each subagent attempt is separately capped at ${DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS} turns (\`${WORKFLOW_SUBAGENT_MAX_TURNS_ENV}\`) and ${DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES} minutes (\`${WORKFLOW_SUBAGENT_MAX_MINUTES_ENV}\`) \u2014 an attempt that hits either becomes \`null\` in \`parallel()\`/\`pipeline()\`, indistinguishable from a missing agent, so raise them for legitimately long work. 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', workingDir, stallMs })\` covers structured-output contracts, declarative-agent selection, model override, git-worktree-isolated subagents, pinning an agent to a caller-owned worktree, and the no-progress stall watchdog (\`stallMs: 0\` disables it). \`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.
+\`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 inside either of them or inside the generated-scripts root (\`$QWEN_CODE_PROJECT_DIR/workflows/generated\` \u2014 the per-project runtime dir, not the project tree \u2014 where a tool emitting a one-run script writes it; never a slash command, never resolvable by name); a path outside those roots is refused. Default \`max(2, 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. Each subagent attempt is separately capped at ${DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS} turns (\`${WORKFLOW_SUBAGENT_MAX_TURNS_ENV}\`) and ${DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES} minutes (\`${WORKFLOW_SUBAGENT_MAX_MINUTES_ENV}\`) \u2014 an attempt that hits either becomes \`null\` in \`parallel()\`/\`pipeline()\`, indistinguishable from a missing agent, so raise them for legitimately long work. 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', workingDir, stallMs })\` covers structured-output contracts, declarative-agent selection, model override, git-worktree-isolated subagents, pinning an agent to a caller-owned worktree, and the no-progress stall watchdog (\`stallMs: 0\` disables it). \`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**
 
@@ -3969,6 +4051,18 @@ var WorkflowTool = class extends BaseDeclarativeTool {
   static {
     __name(this, "WorkflowTool");
   }
+  buildSessionOwnedBackground(params) {
+    const validationError = this.validateToolParams(params);
+    if (validationError) {
+      throw new Error(validationError);
+    }
+    if (!this.config.getWorkflowRunRegistry().hasCompletionCallback()) {
+      throw new Error(
+        "WorkflowTool: session-owned background runs require an active workflow completion channel."
+      );
+    }
+    return this.createInvocation({ ...params, run_in_background: true });
+  }
   validateToolParamValues(params) {
     const hasScript = typeof params.script === "string" && params.script.length > 0;
     const hasPath = typeof params.scriptPath === "string" && params.scriptPath.length > 0;