@qwen-code/qwen-code 0.23.3 → 0.23.4

package/chunks/{version-EAAZN4T2.js → version-5IC46F2Z.js}

@@ -3,7 +3,7 @@
 import {
   formatVersionLabel,
   getCliVersion
-} from "./chunk-R4Q2PEFV.js";
+} from "./chunk-E7HXORS7.js";
 import "./chunk-W3N5XAZ6.js";
 import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";

package/chunks/{web-fetch-VRU3A2NI.js → web-fetch-WSW4QZBA.js}

@@ -7,19 +7,18 @@ import {
   fetchWithPolicy,
   isConnectionLevelError,
   isPrivateHost
-} from "./chunk-YBUMTY7B.js";
-import "./chunk-HNLMYDQE.js";
-import "./chunk-4ALNJDHL.js";
+} from "./chunk-66N6C4EH.js";
+import "./chunk-FMLBBXHB.js";
+import "./chunk-ZKIAGIGH.js";
+import "./chunk-VGY2RGXL.js";
 import {
   MAX_SESSION_BYTES,
   import_lru_cache,
   runSideQuery
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-TRKIKBUW.js";
 import "./chunk-5ETULJLP.js";
-import "./chunk-ZHKTKHMO.js";
+import "./chunk-7MIBD3LG.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-EDIDYZBT.js";
-import "./chunk-HD7O6WLV.js";
 import {
   extractPDFText,
   formatByteSize,
@@ -27,25 +26,28 @@ import {
   looksLikeText,
   persistBinaryContent,
   sniffFileKind
-} from "./chunk-J6MB5ZHZ.js";
+} from "./chunk-QZW6WRB7.js";
+import "./chunk-EDIDYZBT.js";
+import "./chunk-HD7O6WLV.js";
+import "./chunk-CFMZLE3L.js";
 import "./chunk-WZAD4ZNJ.js";
-import "./chunk-3FPYT6QC.js";
+import "./chunk-ARDHE6MM.js";
 import "./chunk-FPGTNKCP.js";
 import "./chunk-TIGXX4PA.js";
-import "./chunk-3UXUOFO6.js";
+import "./chunk-7W2Y3PZD.js";
 import "./chunk-XFFRI3WM.js";
 import "./chunk-ERU3SDXT.js";
 import "./chunk-EWJTAP3Y.js";
 import "./chunk-HHJLM3WQ.js";
-import "./chunk-W5ZQMAEM.js";
+import "./chunk-4Y2I3CI3.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-HUXPEUFL.js";
+import "./chunk-SYROIHU7.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   createDebugLogger,
   getErrorMessage

package/chunks/web-search-5QFKXWUV.js

@@ -0,0 +1,39 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  CITATION_RULES,
+  DEFAULT_WEB_SEARCH_MODEL,
+  DEFAULT_WEB_SEARCH_TIMEOUT_MS,
+  MAX_WEB_SEARCH_TIMEOUT_MS,
+  WebSearchTool,
+  evaluateWebSearchGate,
+  resolveWebSearchTimeoutMs
+} from "./chunk-7JGH6IMU.js";
+import "./chunk-5JG3DAKS.js";
+import "./chunk-GSS4SZNG.js";
+import "./chunk-FMLBBXHB.js";
+import "./chunk-JL6APGBX.js";
+import "./chunk-ZKIAGIGH.js";
+import "./chunk-VGY2RGXL.js";
+import "./chunk-C75BXMPM.js";
+import "./chunk-7MIBD3LG.js";
+import "./chunk-ARDHE6MM.js";
+import "./chunk-FPGTNKCP.js";
+import "./chunk-7W2Y3PZD.js";
+import "./chunk-ERU3SDXT.js";
+import "./chunk-EWJTAP3Y.js";
+import "./chunk-RSWBT7AZ.js";
+import "./chunk-ZAFYHRVY.js";
+import "./chunk-TBWQLLFO.js";
+import "./chunk-UKMWZ5NS.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  CITATION_RULES,
+  DEFAULT_WEB_SEARCH_MODEL,
+  DEFAULT_WEB_SEARCH_TIMEOUT_MS,
+  MAX_WEB_SEARCH_TIMEOUT_MS,
+  WebSearchTool,
+  evaluateWebSearchGate,
+  resolveWebSearchTimeoutMs
+};

package/chunks/{web-shell-static-CCN4JZEE.js → web-shell-static-T7UGLVE4.js}

@@ -4,11 +4,9 @@ import {
   WEB_SHELL_CSP,
   buildWebShellCsp,
   buildWebShellPermissionsPolicy,
-  loopbackSandboxOrigins,
   mountWebShellAssets,
-  mountWebShellSpaFallback,
-  portFromHostHeader
-} from "./chunk-3I7W2POO.js";
+  mountWebShellSpaFallback
+} from "./chunk-FGROOEKM.js";
 import {
   isDocumentNavigation,
   isPreAuthWebShellRequest
@@ -16,7 +14,6 @@ import {
 import {
   resolveWebShellDir
 } from "./chunk-FBX2SDQ4.js";
-import "./chunk-DMEUXLSS.js";
 import "./chunk-ZL4HFSL6.js";
 import "./chunk-K6KS3LTN.js";
 import "./chunk-OSHQMOBS.js";
@@ -33,9 +30,7 @@ export {
   buildWebShellPermissionsPolicy,
   isDocumentNavigation,
   isPreAuthWebShellRequest,
-  loopbackSandboxOrigins,
   mountWebShellAssets,
   mountWebShellSpaFallback,
-  portFromHostHeader,
   resolveWebShellDir
 };

package/chunks/{workflow-UHPFALVZ.js → workflow-ZF4DLK4V.js}

@@ -2,14 +2,12 @@
 "use strict";
 import {
   DEFAULT_MAX_AGENTS_PER_RUN,
-  DEFAULT_STALL_MS,
   DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES,
   DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS,
-  MAX_STALL_ATTEMPTS,
   MAX_TOKENS_PER_WORKFLOW_ENV,
   MAX_WORKFLOW_AGENTS_ENV,
   MAX_WORKFLOW_CONCURRENCY_ENV,
-  MAX_WORKFLOW_STALL_MS_ENV,
+  WORKFLOW_AUTHORING_SKILL_NAME,
   WORKFLOW_SUBAGENT_MAX_MINUTES_ENV,
   WORKFLOW_SUBAGENT_MAX_TURNS_ENV,
   WorkflowBudgetImpl,
@@ -24,12 +22,15 @@ import {
   extractAndStripMeta,
   isSymlinkedRoot,
   persistInlineWorkflowScript,
+  readWorkflowAuthoringReference,
   resolveConcurrencyLimit,
   resolveMaxTokensPerWorkflow,
   resolveReviewWorkflowLimits,
   resolveSavedWorkflowScript,
+  resolveWorkflowAuthoringSurface,
+  toolSearchRevealSentence,
   writeWorkflowSnapshot
-} from "./chunk-UKZ45TJL.js";
+} from "./chunk-LMDMYMSS.js";
 import {
   RESUME_ARGS_TOO_LARGE_NOTE,
   buildFailureLines,
@@ -41,94 +42,98 @@ import {
   markWorkflowRunPersistenceActive,
   resolveToolName,
   tryWithWorkflowTaskMutation
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
 import "./chunk-GOFAQQZA.js";
+import "./chunk-HEOH7JZY.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-65I7S4Z3.js";
-import "./chunk-6HUXPLB5.js";
 import "./chunk-7CLLH5TI.js";
-import "./chunk-XKBFYTCD.js";
-import "./chunk-ZTTC7T4X.js";
-import "./chunk-E4UEO3XM.js";
-import "./chunk-IAEXTMED.js";
-import "./chunk-IRH27ZC2.js";
+import "./chunk-WK6DEH3Q.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-5JG3DAKS.js";
+import "./chunk-ME4JBHSB.js";
+import "./chunk-GNV2SFO7.js";
+import "./chunk-5EZRLTLQ.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-F53KKZUD.js";
+import "./chunk-3LMDSCLU.js";
 import "./chunk-O6GEWCJA.js";
-import "./chunk-36HCNKDS.js";
-import "./chunk-6PVPNMXU.js";
-import "./chunk-2SZH22YO.js";
-import "./chunk-DTNV6UZY.js";
+import "./chunk-WKVZES7O.js";
+import "./chunk-NJ2OFVUX.js";
+import "./chunk-HFJSQ4GL.js";
 import "./chunk-QJNDUTOL.js";
-import "./chunk-JXNIF2O5.js";
-import "./chunk-NFYEQRLG.js";
+import "./chunk-V545KI73.js";
+import "./chunk-MQRLLBMQ.js";
 import "./chunk-ELRMZTPF.js";
+import "./chunk-U6H3XTFA.js";
+import "./chunk-ACHCT36C.js";
 import "./chunk-CHEIIBT3.js";
-import "./chunk-PLLIWEM3.js";
-import "./chunk-5GLDOLNQ.js";
+import "./chunk-AEWCOE64.js";
+import "./chunk-OWUAZXXN.js";
 import "./chunk-CH2YDT6X.js";
 import "./chunk-JX6XHPTX.js";
 import "./chunk-ZSTCM3MX.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-LILGKQ4B.js";
-import "./chunk-3CZ2BQV6.js";
-import "./chunk-SAH4BD2J.js";
-import "./chunk-CXTPVBFA.js";
-import "./chunk-U7O65WKL.js";
+import "./chunk-AXZMWAJV.js";
+import "./chunk-NXUZFW3G.js";
+import "./chunk-WFNEY5G7.js";
+import "./chunk-GSS4SZNG.js";
+import "./chunk-BW2SMO6L.js";
 import "./chunk-S6LOFUVP.js";
-import "./chunk-FN3JNDRU.js";
-import "./chunk-EUURTIV6.js";
+import "./chunk-VVI7MK3V.js";
+import "./chunk-WBSJ6VPZ.js";
 import "./chunk-G6UUOCUT.js";
 import "./chunk-IZ2U57NY.js";
+import "./chunk-Z72PLR74.js";
 import "./chunk-NUQ4GK5I.js";
-import "./chunk-K2OJUPOE.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-YBUMTY7B.js";
-import "./chunk-HNLMYDQE.js";
-import "./chunk-QHMLYMMS.js";
-import "./chunk-CFKIH3D3.js";
+import "./chunk-66N6C4EH.js";
+import "./chunk-FMLBBXHB.js";
+import "./chunk-S7UQ3V2H.js";
 import "./chunk-JL6APGBX.js";
 import {
   createAbortController,
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
-import "./chunk-4ALNJDHL.js";
-import "./chunk-NOO4QFXM.js";
+import "./chunk-ZKIAGIGH.js";
+import "./chunk-VGY2RGXL.js";
+import "./chunk-C75BXMPM.js";
 import "./chunk-KFFCDLKV.js";
-import "./chunk-ZW2EUO2A.js";
+import "./chunk-KP2FHIFR.js";
+import "./chunk-L6DIANLD.js";
 import {
   WorkflowRunEvent,
   logWorkflowRun
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-TRKIKBUW.js";
 import "./chunk-5ETULJLP.js";
-import "./chunk-ZHKTKHMO.js";
+import "./chunk-7MIBD3LG.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-EDIDYZBT.js";
-import "./chunk-HD7O6WLV.js";
 import {
   isWithinRoot
-} from "./chunk-J6MB5ZHZ.js";
+} from "./chunk-QZW6WRB7.js";
+import "./chunk-EDIDYZBT.js";
+import "./chunk-HD7O6WLV.js";
+import "./chunk-CFMZLE3L.js";
 import "./chunk-WZAD4ZNJ.js";
-import "./chunk-3FPYT6QC.js";
+import "./chunk-ARDHE6MM.js";
 import "./chunk-FPGTNKCP.js";
 import "./chunk-TIGXX4PA.js";
-import "./chunk-3UXUOFO6.js";
+import "./chunk-7W2Y3PZD.js";
 import "./chunk-XFFRI3WM.js";
 import "./chunk-ERU3SDXT.js";
 import "./chunk-EWJTAP3Y.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   stripAnsiAndControl
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-HUXPEUFL.js";
+import "./chunk-SYROIHU7.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import "./chunk-ZAFYHRVY.js";
 import "./chunk-TBWQLLFO.js";
 import "./chunk-UKMWZ5NS.js";
@@ -328,6 +333,11 @@ var WorkflowRunner = class {
           script,
           scriptPath,
           ...journalPath ? { journalPath } : {},
+          // A saved workflow is the user's file, and the recovery advice says to
+          // copy it first. The name is resolved here — from the resumed run
+          // too, which a caller re-running a saved workflow's inline source
+          // does not pass — so the hint follows the same decision.
+          ...options.authoringHint && !workflowName ? { authoringHint: options.authoringHint } : {},
           args: options.args,
           ...options.resumeFromRunId ? {
             sourceRunId: options.resumeFromRunId,
@@ -543,7 +553,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. After two in-conversation nudges without a valid result, it resolves to null and the failure is recorded as "subagent completed without calling StructuredOutput (after 2 in-conversation nudges)"; check for null. \`agentType\` (string): resolves against the declarative-agents registry (\`.qwen/agents/<name>.md\`, project then user then built-in). Unresolved names make the admitted agent() resolve to null and record "agent({agentType}): agent type 'X' not found"; check for null. \`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'\` makes the admitted agent() resolve to null and records "agent({isolation:'remote'}) is not available in this build" (parity with upstream). isolation=worktree also resolves to null and records a refusal 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 on invalid arguments, abort, or a run-level token/agent-cap refusal. \`pipeline(items, ...stages)\` runs each item through the stages (staggered, no inter-stage barrier); an ordinary stage error, \`null\`, or non-JSON-serializable value drops that item to \`null\`, while a run-level refusal rejects the batch. A bare sequential \`await agent()\` follows the same rule: an agent that fails on its own terms resolves to \`null\` there too, so the fan-out and the sequential form never disagree about what a broken agent means. 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: top-level `await` and `return` are both legal, and a trailing expression is NOT a return value. Uses the injected globals `phase()`, `log()`, `agent()`, `parallel()`, `pipeline()`, `workflow()`, `args` and `budget`, and cannot import anything. May start with a literal `export const meta = {...}` (stripped before execution). `Math.random()` and all of `Date` (`new Date()`, `Date.now()` included) throw \u2014 a script must be deterministic for resume, so pass timestamps in via `args` or stamp the result after the run returns. Pass THUNKS to parallel(), not eager calls: `parallel([() => agent(...)])`, not `parallel([agent(...)])`."
     },
     scriptPath: {
       type: "string",
@@ -568,16 +578,32 @@ var WORKFLOW_PARAM_SCHEMA = {
   // pass `script`; the `scriptPath` property description states the XOR.
 };
 var WorkflowToolInvocation = class extends BaseToolInvocation {
-  constructor(config, toolOptions, params, workflowName) {
+  constructor(config, toolOptions, params, authoringHint, workflowName) {
     super(params);
     this.config = config;
     this.toolOptions = toolOptions;
+    this.authoringHint = authoringHint;
     this.workflowName = workflowName;
   }
   static {
     __name(this, "WorkflowToolInvocation");
   }
   callId;
+  /**
+   * The failure hint, when the failing script is one this call authored.
+   *
+   * A saved workflow is the user's file, and the resume advice already tells
+   * the model to copy it before making a run-specific change — "fix the script,
+   * and retry" would contradict that in the same message.
+   */
+  authoredScriptHint() {
+    if (!this.authoringHint) return null;
+    return isScriptAuthoredByThisCall(
+      this.config,
+      this.workflowName,
+      this.params.scriptPath
+    ) ? this.authoringHint : null;
+  }
   setCallId(callId) {
     this.callId = callId;
   }
@@ -685,6 +711,7 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         signal,
         toolUseId: this.callId,
         ...this.workflowName ? { workflowName: this.workflowName } : {},
+        ...authoringHintOption(this.authoredScriptHint()),
         script: this.params.script,
         scriptPath: this.params.scriptPath,
         args: this.params.args,
@@ -698,11 +725,14 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         return startCancelledResult();
       }
       if (error instanceof WorkflowScriptNotLaunchedError) {
+        const hint = this.authoredScriptHint();
+        const text = hint ? `${error.message}
+${hint}` : error.message;
         return {
-          llmContent: [{ text: error.message }],
+          llmContent: [{ text }],
           returnDisplay: error.message,
           error: {
-            message: error.message,
+            message: text,
             type: "invalid_tool_params" /* INVALID_TOOL_PARAMS */
           }
         };
@@ -787,7 +817,8 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         handle,
         this.params.args,
         logs,
-        !cancelled
+        !cancelled,
+        cancelled ? null : this.authoredScriptHint()
       );
       const display = `${cancelled ? "Workflow cancelled." : `Workflow failed: ${message}`}
 
@@ -825,7 +856,7 @@ ${trailer}`,
 var TRAILER_LOG_LINES = 20;
 var TRAILER_LOG_LINE_CHARS = 400;
 var TRAILER_ERROR_CHARS = 4e3;
-function buildRunTrailer(config, handle, args, logs, includeResume = true) {
+function buildRunTrailer(config, handle, args, logs, includeResume = true, authoringHint = null) {
   const lines = [
     "--- workflow run ---",
     `runId: ${sanitizeLine(handle.runId)}`
@@ -875,6 +906,7 @@ function buildRunTrailer(config, handle, args, logs, includeResume = true) {
       lines.push(RESUME_ARGS_TOO_LARGE_NOTE);
     }
   }
+  if (authoringHint && !entry?.workflowName) lines.push(authoringHint);
   const tail = (logs ?? []).slice(-TRAILER_LOG_LINES);
   if (tail.length > 0) {
     lines.push(
@@ -1100,7 +1132,7 @@ function safeStringifyDisplayPayload(payload) {
   }
 }
 __name(safeStringifyDisplayPayload, "safeStringifyDisplayPayload");
-var WORKFLOW_TOOL_DESCRIPTION = `Execute a workflow script that orchestrates subagents deterministically.
+var WORKFLOW_TOOL_DECISION = `Execute a workflow script that orchestrates subagents deterministically.
 
 **Only on an explicit request**
 
@@ -1116,45 +1148,98 @@ Otherwise do not call it, however well the task would parallelize. Do the work i
 
 **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 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 raise them for legitimately long work. \`agent()\` resolves to \`null\` when that admitted agent fails on its own \u2014 including turn/time caps, model or setup errors, missing structured output, and exhausted stall retries \u2014 and it does so for a bare \`await agent()\` exactly as it does inside \`parallel()\`/\`pipeline()\`, so check for \`null\` wherever you read a result. Call-shape validation failures \u2014 such as an empty prompt, an unsupported option combination, or an invalid option value \u2014 reject a bare call; inside \`parallel()\`/\`pipeline()\`, the surrounding ordinary thunk or stage rejection becomes a position-aligned \`null\`. Run-level rejections no later call could survive \u2014 the token budget, the ${DEFAULT_MAX_AGENTS_PER_RUN}-agent cap, and cancellation \u2014 throw and end a \`parallel()\`/\`pipeline()\` batch. An admitted agent that fails and settles to \`null\` still counts as dispatched and is named, with its error, in the run's failures list; a \`null\` returned by an ordinary thunk or stage is not an agent dispatch. 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. 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. Every run hands back its runId, the script's path on disk (an inline script is persisted, so a resume edits that file rather than re-sending the source) and its journal path; the journal holds one result line per completed agent, so read it before diagnosing an empty or surprising result. 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**
+Reach for one to be comprehensive (cover every part of the work 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. Parallelism on its own is not a reason; work that is already one short sequence of edits belongs in the main loop.`;
+var WORKFLOW_TOOL_RUNTIME = `**Runtime**
 
-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.
+\`phase(title)\`, \`log(msg)\`, \`agent(prompt, opts?)\`, \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`workflow(nameOrRef, args?)\`, plus the \`args\` and \`budget\` globals. Saved workflows are \`<name>.js\` files under \`<projectRoot>/.qwen/workflows\` (project scope, also surfaced as \`/<name>\` slash commands) or \`~/.qwen/workflows\` (user scope); \`scriptPath\` additionally accepts a path inside the generated-scripts root (\`$QWEN_CODE_PROJECT_DIR/workflows/generated\` \u2014 the per-project runtime dir, not the project tree), and a path outside those roots is refused. Default \`max(2, min(16, availableParallelism()-2))\` agents in flight per run, which follows CPU affinity and container CPU limits (\`${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}\`). \`agent()\` resolves to \`null\` when that admitted agent fails on its own \u2014 turn/time caps, model or setup errors, missing structured output, exhausted stall retries \u2014 for a bare \`await agent()\` exactly as inside \`parallel()\`/\`pipeline()\`, so check for \`null\` wherever you read a result; run-level rejections no later call could survive (the token budget, the ${DEFAULT_MAX_AGENTS_PER_RUN}-agent cap, cancellation) throw instead. Every run hands back its runId, the script's path on disk (an inline script is persisted, so a resume edits that file rather than re-sending the source) and its journal path; read it before diagnosing an empty or surprising result. 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.`;
+var WORKFLOW_AUTHORING_POINTER = `**Writing the script**
 
-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).
+Before writing a script, load the \`${WORKFLOW_AUTHORING_SKILL_NAME}\` skill \u2014 the authoring reference: the sandbox contract, agent() options, \`pipeline()\` vs \`parallel()\`, verification and convergence patterns, resume, and a worked example.`;
+var WORKFLOW_AUTHORING_TOOL_SEARCH_NOTE = ` ${toolSearchRevealSentence(ToolDisplayNames.SKILL)}`;
+var WORKFLOW_AUTHORING_INLINE_NOTE = "Skills cannot be loaded in this session, even one named in a skill listing, so the authoring reference follows in full. Where it points at another skill, that skill is not available here either.";
+function buildWorkflowToolDescription(surface, reference = readWorkflowAuthoringReference()) {
+  const pointer = `${WORKFLOW_TOOL_DECISION}
 
-**Default to \`pipeline()\`**
+${WORKFLOW_TOOL_RUNTIME}
 
-\`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.
+${WORKFLOW_AUTHORING_POINTER}`;
+  switch (surface) {
+    case "pointer":
+      return pointer;
+    case "pointer-via-tool-search":
+      return `${pointer}${WORKFLOW_AUTHORING_TOOL_SEARCH_NOTE}`;
+    case "withheld":
+      return `${WORKFLOW_TOOL_DECISION}
 
-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()\`.
+${WORKFLOW_TOOL_RUNTIME}`;
+    case "inline":
+      return reference ? `${WORKFLOW_TOOL_DECISION}
 
-**Verify before believing**
+${WORKFLOW_AUTHORING_INLINE_NOTE}
 
-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.`;
+${reference.body.trim()}` : pointer;
+    default: {
+      const unhandled = surface;
+      return unhandled;
+    }
+  }
+}
+__name(buildWorkflowToolDescription, "buildWorkflowToolDescription");
+function buildWorkflowParamSchema(surface) {
+  const base = WORKFLOW_PARAM_SCHEMA.properties.script.description;
+  const where = surface === "pointer" || surface === "pointer-via-tool-search" ? ` agent() options and orchestration patterns are in the \`${WORKFLOW_AUTHORING_SKILL_NAME}\` skill.` : surface === "inline" ? " agent() options and orchestration patterns are in the authoring reference in this tool's description." : "";
+  return {
+    ...WORKFLOW_PARAM_SCHEMA,
+    properties: {
+      ...WORKFLOW_PARAM_SCHEMA.properties,
+      script: { type: "string", description: `${base}${where}` }
+    }
+  };
+}
+__name(buildWorkflowParamSchema, "buildWorkflowParamSchema");
+function buildWorkflowAuthoringHint(surface) {
+  const loadSkill = `hint: Load the \`${WORKFLOW_AUTHORING_SKILL_NAME}\` skill for the script reference if you have not, fix the script, and retry.`;
+  switch (surface) {
+    case "pointer":
+      return loadSkill;
+    case "pointer-via-tool-search":
+      return `${loadSkill} ${toolSearchRevealSentence(ToolDisplayNames.SKILL)}`;
+    case "inline":
+      return "hint: See the authoring reference in this tool's description, fix the script, and retry.";
+    case "withheld":
+      return null;
+    default: {
+      const unhandled = surface;
+      return unhandled;
+    }
+  }
+}
+__name(buildWorkflowAuthoringHint, "buildWorkflowAuthoringHint");
+function isScriptAuthoredByThisCall(config, workflowName, scriptPath) {
+  if (workflowName) return false;
+  if (!scriptPath) return true;
+  try {
+    return isGeneratedWorkflowScriptPath(config, scriptPath);
+  } catch {
+    return false;
+  }
+}
+__name(isScriptAuthoredByThisCall, "isScriptAuthoredByThisCall");
+function authoringHintOption(hint) {
+  return hint ? { authoringHint: hint } : {};
+}
+__name(authoringHintOption, "authoringHintOption");
 var WorkflowTool = class extends BaseDeclarativeTool {
   constructor(config, toolOptions = {}) {
+    const surface = resolveWorkflowAuthoringSurface(config);
     super(
       ToolNames.WORKFLOW,
       ToolDisplayNames.WORKFLOW,
-      WORKFLOW_TOOL_DESCRIPTION,
+      buildWorkflowToolDescription(surface),
       "other" /* Other */,
-      WORKFLOW_PARAM_SCHEMA,
+      buildWorkflowParamSchema(surface),
       /* isOutputMarkdown */
       true,
       /* canUpdateOutput */
@@ -1162,10 +1247,18 @@ var WorkflowTool = class extends BaseDeclarativeTool {
     );
     this.config = config;
     this.toolOptions = toolOptions;
+    this.authoringSurface = surface;
   }
   static {
     __name(this, "WorkflowTool");
   }
+  /**
+   * What this tool's description says about the authoring reference, decided
+   * once here. The failure hint and the keyword reminder read it instead of
+   * asking again, so a mid-session `/skills` toggle cannot make them disagree
+   * with the description the model is holding.
+   */
+  authoringSurface;
   buildSessionOwnedBackground(params, workflowName) {
     const validationError = this.validateToolParams(params);
     if (validationError) {
@@ -1180,6 +1273,7 @@ var WorkflowTool = class extends BaseDeclarativeTool {
       this.config,
       this.toolOptions,
       { ...params, run_in_background: true },
+      buildWorkflowAuthoringHint(this.authoringSurface),
       workflowName
     );
   }
@@ -1206,11 +1300,17 @@ var WorkflowTool = class extends BaseDeclarativeTool {
     return null;
   }
   createInvocation(params) {
-    return new WorkflowToolInvocation(this.config, this.toolOptions, params);
+    return new WorkflowToolInvocation(
+      this.config,
+      this.toolOptions,
+      params,
+      buildWorkflowAuthoringHint(this.authoringSurface)
+    );
   }
 };
 export {
-  WorkflowTool
+  WorkflowTool,
+  buildWorkflowToolDescription
 };
 /**
  * @license