@qwen-code/qwen-code 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784

package/chunks/{chunk-UKZ45TJL.js → chunk-FFBP5POK.js}

@@ -11,40 +11,49 @@ import {
   isActiveWorkflowStatus,
   isTerminalWorkflowStatus,
   isWorkflowRunPersistenceActive,
+  parseSkillContent,
   rebuildToolRegistryOnOverride,
   resolveExternalWorktreeDir,
   toModelVisibleSubagentResult
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-CFSBWJBB.js";
+import {
+  parsePositiveIntegerEnv
+} from "./chunk-6PVPNMXU.js";
 import {
   GitWorktreeService,
   generateAgentWorktreeSlug,
   writeWorktreeSessionMarker
-} from "./chunk-36HCNKDS.js";
+} from "./chunk-WKVZES7O.js";
 import {
-  parsePositiveIntegerEnv
-} from "./chunk-6PVPNMXU.js";
+  resolveBundleDir
+} from "./chunk-ACHCT36C.js";
 import {
   SUBAGENT_PLAN_LIFECYCLE_TOOLS
-} from "./chunk-PLLIWEM3.js";
+} from "./chunk-AEWCOE64.js";
 import {
   runWithAgentContext
-} from "./chunk-U7O65WKL.js";
+} from "./chunk-BW2SMO6L.js";
 import {
   read,
   writeLine
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-NRUKL236.js";
+import {
+  REASONING_EFFORT_TIERS,
+  normalizeReasoningEffort
+} from "./chunk-ARDHE6MM.js";
 import {
   atomicWriteFile
 } from "./chunk-XFFRI3WM.js";
 import {
   stripAnsiAndControl
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import {
   SyntheticOutputTool
-} from "./chunk-HUXPEUFL.js";
+} from "./chunk-SYROIHU7.js";
 import {
-  ToolNames
-} from "./chunk-TP6FYVQT.js";
+  ToolNames,
+  resolveBuiltinToolName
+} from "./chunk-RSWBT7AZ.js";
 import {
   Storage,
   createDebugLogger
@@ -599,6 +608,7 @@ var MAX_LOG_LINES = 1e4;
 var MAX_PHASE_ENTRIES = 1e4;
 var ARGS_MAX_DEPTH = 64;
 var DEFAULT_MAX_WALL_CLOCK_MS = 30 * 60 * 1e3;
+var WORKFLOW_SYNC_EVALUATION_TIMEOUT_MS = 3e4;
 function resolveMaxWallClockMs(opts) {
   if (typeof opts.maxWallClockMs === "number" && opts.maxWallClockMs > 0) {
     return opts.maxWallClockMs;
@@ -743,6 +753,18 @@ function createWorkflowSandbox(opts) {
     pushLog: safeLog,
     lastPhase: /* @__PURE__ */ __name(() => phases[phases.length - 1], "lastPhase"),
     hostAgent: opts.dispatch,
+    // Effort tiers are resolved host-side so the sandbox accepts exactly the
+    // aliases `/effort` does without a second copy of the alias table. Takes
+    // and returns primitives only.
+    normalizeEffort: /* @__PURE__ */ __name((raw) => typeof raw === "string" ? normalizeReasoningEffort(raw) ?? null : null, "normalizeEffort"),
+    effortTiers: REASONING_EFFORT_TIERS.join(", "),
+    // A built-in tool named by its display name or a legacy alias becomes its
+    // tool name, so both spellings share one resume key; any other entry comes
+    // back as given for the host to judge. Primitives only.
+    canonicalDenyName: /* @__PURE__ */ __name((raw) => typeof raw === "string" ? resolveBuiltinToolName(raw) ?? raw : null, "canonicalDenyName"),
+    // JSON.stringify escapes only C0: strip DEL / C1 (incl. NEL) from a
+    // script-controlled echo so it cannot fragment a rejection message.
+    sanitizeForMessage: /* @__PURE__ */ __name((raw) => typeof raw === "string" ? stripAnsiAndControl(raw) : "", "sanitizeForMessage"),
     // PR #4947 R2 T7 (qwen-code-ci-bot): host-side log hook for reviveInRealm's
     // catch path. Mirrors the rejection-logging in settleToNullArray so an
     // operator running with debug logging can distinguish "thunk rejected"
@@ -1216,7 +1238,7 @@ function createWorkflowSandbox(opts) {
       // FIX-Round1-T13: throw on any opts key not in the allowlist \u2014 catches
       // typos like { scema: ... } that previously slipped through the
       // [key:string]: unknown index signature.
-      const KNOWN_AGENT_OPTS = ['label', 'phase', 'schema', 'model', 'isolation', 'agentType', 'stallMs', 'workingDir'];
+      const KNOWN_AGENT_OPTS = ['label', 'phase', 'schema', 'model', 'effort', 'isolation', 'agentType', 'stallMs', 'workingDir', 'disallowedTools'];
       globalThis.agent = vmAsync(function (prompt, agentOpts) {
         agentOpts = agentOpts || {};
         const keys = Object.keys(agentOpts);
@@ -1274,11 +1296,6 @@ function createWorkflowSandbox(opts) {
             );
           }
         }
-        if (typeof agentOpts.phase === 'string' && agentOpts.phase.length > 0) {
-          if (__b.lastPhase() !== agentOpts.phase) {
-            __b.pushPhase(agentOpts.phase);
-          }
-        }
         // SECURITY (P3 R2 self-review): user-script-controlled agentOpts
         // cross the vm/host boundary verbatim via vmAsync's hostFn.apply.
         // A Proxy / inherited-getter / non-plain object in agentOpts.schema
@@ -1297,6 +1314,55 @@ function createWorkflowSandbox(opts) {
             String(e && e.message != null ? e.message : e)
           );
         }
+        // effort and disallowedTools are validated on the REVIVED copy: that
+        // is the object the host dispatch and the resume key see, so a getter
+        // cannot show one value here and hand another to the dispatch. Both
+        // are normalized in place (an effort alias becomes its tier; a deny
+        // list has built-in display names mapped to tool names and is sorted
+        // and de-duplicated) so equivalent spellings share one resume key.
+        if (safeOpts.effort !== undefined) {
+          var tier = __b.normalizeEffort(safeOpts.effort);
+          if (tier === null) {
+            throw new Error(
+              "agent({effort}): unknown effort tier " + __b.sanitizeForMessage(JSON.stringify(safeOpts.effort)) + ". " +
+              "Known tiers are: " + __b.effortTiers + "."
+            );
+          }
+          safeOpts.effort = tier;
+        }
+        if (safeOpts.disallowedTools !== undefined) {
+          var denied = safeOpts.disallowedTools;
+          if (
+            !Array.isArray(denied) ||
+            denied.some(function (name) {
+              return typeof name !== 'string' || name.length === 0 || name !== name.trim();
+            })
+          ) {
+            throw new Error(
+              "agent({disallowedTools}): must be an array of non-empty tool-name strings " +
+              "without surrounding whitespace, e.g. ['run_shell_command', 'write_file']."
+            );
+          }
+          var uniqueDenied = [];
+          for (var d = 0; d < denied.length; d++) {
+            var deniedName = __b.canonicalDenyName(denied[d]);
+            if (uniqueDenied.indexOf(deniedName) === -1) uniqueDenied.push(deniedName);
+          }
+          uniqueDenied.sort();
+          if (uniqueDenied.length === 0) {
+            delete safeOpts.disallowedTools;
+          } else {
+            safeOpts.disallowedTools = uniqueDenied;
+          }
+        }
+        // The phase is recorded only once every option gate above has passed,
+        // so a call its options rejected leaves no phase that dispatched
+        // nothing.
+        if (typeof agentOpts.phase === 'string' && agentOpts.phase.length > 0) {
+          if (__b.lastPhase() !== agentOpts.phase) {
+            __b.pushPhase(agentOpts.phase);
+          }
+        }
         // SECURITY (PR #4947 R1 wenshao, extended for P3): vmAsync's resolve
         // path is verbatim (no re-wrap of resolved values). Host-realm
         // strings cross the boundary harmlessly because primitives have no
@@ -1582,7 +1648,7 @@ function createWorkflowSandbox(opts) {
           throw workflowCancelledError();
         }
         const runOpts = {
-          timeout: 3e4
+          timeout: WORKFLOW_SYNC_EVALUATION_TIMEOUT_MS
         };
         const result = script.runInContext(ctx, runOpts);
         const timeoutPromise = new Promise((_, reject) => {
@@ -1731,186 +1797,11 @@ var WorkflowBudgetExceededError = class extends Error {
   }
 };
 
-// packages/core/src/agents/runtime/workflow-stall.ts
-init_esbuild_shims();
-
-// packages/core/src/agents/runtime/workflow-agent-failure.ts
-init_esbuild_shims();
-var WorkflowAgentFailedError = class extends Error {
-  static {
-    __name(this, "WorkflowAgentFailedError");
-  }
-  name = "WorkflowAgentFailedError";
-  kind;
-  terminateMode;
-  constructor(message, kind, terminateMode) {
-    super(message);
-    this.kind = kind;
-    this.terminateMode = terminateMode;
-  }
-};
-function isWorkflowAgentFailedError(error) {
-  return typeof error === "object" && error !== null && error.name === "WorkflowAgentFailedError";
-}
-__name(isWorkflowAgentFailedError, "isWorkflowAgentFailedError");
-var WorkflowAgentCapExceededError = class extends Error {
-  static {
-    __name(this, "WorkflowAgentCapExceededError");
-  }
-  name = "WorkflowAgentCapExceededError";
-  constructor(maxAgents) {
-    super(
-      `Workflow exceeded the maximum of ${maxAgents} agent() calls per run.`
-    );
-  }
-};
-function isWorkflowRunLevelError(error) {
-  if (typeof error !== "object" || error === null) return false;
-  const name = error.name;
-  return name === "WorkflowBudgetExceededError" || name === "WorkflowAgentCapExceededError";
-}
-__name(isWorkflowRunLevelError, "isWorkflowRunLevelError");
-var WORKFLOW_ABORT_REASON_STALLED = "stalled";
-
-// packages/core/src/agents/runtime/workflow-stall.ts
-var DEFAULT_STALL_MS = 18e4;
-var MAX_STALL_ATTEMPTS = 3;
-var MAX_WORKFLOW_STALL_MS_ENV = "QWEN_CODE_WORKFLOW_STALL_SECONDS";
-function resolveStallMs(perCall, env = process.env) {
-  if (typeof perCall === "number" && Number.isFinite(perCall)) {
-    if (perCall === 0) return 0;
-    if (perCall > 0) return perCall;
-  }
-  const raw = env[MAX_WORKFLOW_STALL_MS_ENV];
-  const trimmed = raw?.trim();
-  if (trimmed) {
-    if (trimmed === "0") return 0;
-    const sec = parsePositiveIntegerEnv(trimmed, 0);
-    if (sec > 0) return sec * 1e3;
-  }
-  return DEFAULT_STALL_MS;
-}
-__name(resolveStallMs, "resolveStallMs");
-var debugLogger3 = createDebugLogger("WORKFLOW_STALL");
-function attachStallWatchdog(emitter, controller, stallMs) {
-  if (stallMs <= 0) {
-    return { stalled: /* @__PURE__ */ __name(() => false, "stalled"), dispose: /* @__PURE__ */ __name(() => {
-    }, "dispose") };
-  }
-  let inFlightTools = 0;
-  let fired = false;
-  let timer;
-  let disposed = false;
-  const clear = /* @__PURE__ */ __name(() => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-  }, "clear");
-  const arm = /* @__PURE__ */ __name(() => {
-    clear();
-    if (disposed || fired) return;
-    if (inFlightTools > 0) return;
-    timer = setTimeout(() => {
-      if (disposed || fired) return;
-      fired = true;
-      debugLogger3.warn(
-        `[Workflow] agent dispatch stalled \u2014 no progress for ${stallMs}ms; aborting.`
-      );
-      try {
-        controller.abort(WORKFLOW_ABORT_REASON_STALLED);
-      } catch (e) {
-        debugLogger3.warn("stall watchdog abort threw:", e);
-      }
-    }, stallMs);
-    if (typeof timer.unref === "function") {
-      timer.unref();
-    }
-  }, "arm");
-  const onActivity = /* @__PURE__ */ __name(() => arm(), "onActivity");
-  const onToolCall = /* @__PURE__ */ __name(() => {
-    inFlightTools += 1;
-    clear();
-  }, "onToolCall");
-  const onToolResult = /* @__PURE__ */ __name(() => {
-    inFlightTools = Math.max(0, inFlightTools - 1);
-    arm();
-  }, "onToolResult");
-  emitter.on("round_start" /* ROUND_START */, onActivity);
-  emitter.on("round_end" /* ROUND_END */, onActivity);
-  emitter.on("stream_text" /* STREAM_TEXT */, onActivity);
-  emitter.on("usage_metadata" /* USAGE_METADATA */, onActivity);
-  emitter.on("tool_call" /* TOOL_CALL */, onToolCall);
-  emitter.on("tool_result" /* TOOL_RESULT */, onToolResult);
-  return {
-    stalled: /* @__PURE__ */ __name(() => fired, "stalled"),
-    dispose: /* @__PURE__ */ __name(() => {
-      if (disposed) return;
-      disposed = true;
-      clear();
-      emitter.off("round_start" /* ROUND_START */, onActivity);
-      emitter.off("round_end" /* ROUND_END */, onActivity);
-      emitter.off("stream_text" /* STREAM_TEXT */, onActivity);
-      emitter.off("usage_metadata" /* USAGE_METADATA */, onActivity);
-      emitter.off("tool_call" /* TOOL_CALL */, onToolCall);
-      emitter.off("tool_result" /* TOOL_RESULT */, onToolResult);
-    }, "dispose")
-  };
-}
-__name(attachStallWatchdog, "attachStallWatchdog");
-async function runStallResilient(attemptFn, opts) {
-  const { stallMs, signal, label } = opts;
-  if (stallMs <= 0) {
-    const emitter = new AgentEventEmitter();
-    return attemptFn(signal ?? new AbortController().signal, emitter);
-  }
-  let attempt = 0;
-  for (; ; ) {
-    attempt += 1;
-    const controller = new AbortController();
-    let onParentAbort;
-    if (signal) {
-      if (signal.aborted) {
-        controller.abort(signal.reason);
-      } else {
-        onParentAbort = /* @__PURE__ */ __name(() => controller.abort(signal.reason), "onParentAbort");
-        signal.addEventListener("abort", onParentAbort);
-      }
-    }
-    const emitter = new AgentEventEmitter();
-    const watchdog = attachStallWatchdog(emitter, controller, stallMs);
-    try {
-      return await attemptFn(controller.signal, emitter);
-    } catch (err) {
-      if (signal?.aborted) throw err;
-      if (watchdog.stalled() && attempt < MAX_STALL_ATTEMPTS) {
-        debugLogger3.warn(
-          `[Workflow] agent "${label ?? "workflow-agent"}" stalled (attempt ${attempt}/${MAX_STALL_ATTEMPTS}) \u2014 retrying.`
-        );
-        continue;
-      }
-      if (watchdog.stalled()) {
-        throw new WorkflowAgentFailedError(
-          `agent "${label ?? "workflow-agent"}" stalled on all ${MAX_STALL_ATTEMPTS} attempts (no progress for ${stallMs}ms each).`,
-          "stalled"
-        );
-      }
-      throw err;
-    } finally {
-      watchdog.dispose();
-      if (onParentAbort && signal) {
-        signal.removeEventListener("abort", onParentAbort);
-      }
-    }
-  }
-}
-__name(runStallResilient, "runStallResilient");
-
 // packages/core/src/agents/runtime/workflow-saved.ts
 init_esbuild_shims();
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
-var debugLogger4 = createDebugLogger("WORKFLOW_SAVED");
+var debugLogger3 = createDebugLogger("WORKFLOW_SAVED");
 var WORKFLOW_NAME_PATTERN = /^[a-z][a-z0-9-]{0,40}$/;
 function validateWorkflowName(name) {
   if (!name) return "Workflow name is required.";
@@ -1940,7 +1831,7 @@ async function isSymlinkedRoot(dir) {
 __name(isSymlinkedRoot, "isSymlinkedRoot");
 async function listJsFiles(dir) {
   if (await isSymlinkedRoot(dir)) {
-    debugLogger4.warn(`refusing symlinked saved-workflow dir: ${dir}`);
+    debugLogger3.warn(`refusing symlinked saved-workflow dir: ${dir}`);
     return [];
   }
   try {
@@ -1956,7 +1847,7 @@ async function listJsFiles(dir) {
   } catch (e) {
     const code = e?.code;
     if (code !== "ENOENT") {
-      debugLogger4.warn(`listJsFiles failed for ${dir}: ${e}`);
+      debugLogger3.warn(`listJsFiles failed for ${dir}: ${e}`);
     }
     return [];
   }
@@ -2103,7 +1994,7 @@ __name(saveWorkflowScript, "saveWorkflowScript");
 var INLINE_RUN_ID_PATTERN = /^wf_[0-9a-f]+$/;
 async function persistInlineWorkflowScript(config, runId, script) {
   if (!INLINE_RUN_ID_PATTERN.test(runId)) {
-    debugLogger4.warn(`refusing to persist a script for run id: ${runId}`);
+    debugLogger3.warn(`refusing to persist a script for run id: ${runId}`);
     return null;
   }
   const storage = config.storage;
@@ -2112,7 +2003,7 @@ async function persistInlineWorkflowScript(config, runId, script) {
     const filePath = storage.getInlineWorkflowScriptPath(runId);
     const dir = path.dirname(filePath);
     if (await isSymlinkedRoot(storage.getGeneratedWorkflowsDir()) || await isSymlinkedRoot(dir)) {
-      debugLogger4.warn(
+      debugLogger3.warn(
         `refusing to persist an inline workflow script into a symlinked root: '${dir}'.`
       );
       return null;
@@ -2126,7 +2017,7 @@ async function persistInlineWorkflowScript(config, runId, script) {
     });
     return filePath;
   } catch (error) {
-    debugLogger4.warn(
+    debugLogger3.warn(
       `failed to persist inline workflow script for ${runId}: ${error}`
     );
     return null;
@@ -2141,7 +2032,7 @@ async function deleteInlineWorkflowScript(config, runId) {
     await fs.rm(storage.getInlineWorkflowScriptPath(runId), { force: true });
     return true;
   } catch (error) {
-    debugLogger4.warn(
+    debugLogger3.warn(
       `failed to delete inline workflow script for ${runId}: ${error}`
     );
     return false;
@@ -2155,6 +2046,179 @@ import { randomBytes } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as os from "node:os";
 
+// packages/core/src/agents/runtime/workflow-agent-failure.ts
+init_esbuild_shims();
+var WorkflowAgentFailedError = class extends Error {
+  static {
+    __name(this, "WorkflowAgentFailedError");
+  }
+  name = "WorkflowAgentFailedError";
+  kind;
+  terminateMode;
+  constructor(message, kind, terminateMode) {
+    super(message);
+    this.kind = kind;
+    this.terminateMode = terminateMode;
+  }
+};
+function isWorkflowAgentFailedError(error) {
+  return typeof error === "object" && error !== null && error.name === "WorkflowAgentFailedError";
+}
+__name(isWorkflowAgentFailedError, "isWorkflowAgentFailedError");
+var WorkflowAgentCapExceededError = class extends Error {
+  static {
+    __name(this, "WorkflowAgentCapExceededError");
+  }
+  name = "WorkflowAgentCapExceededError";
+  constructor(maxAgents) {
+    super(
+      `Workflow exceeded the maximum of ${maxAgents} agent() calls per run.`
+    );
+  }
+};
+function isWorkflowRunLevelError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const name = error.name;
+  return name === "WorkflowBudgetExceededError" || name === "WorkflowAgentCapExceededError";
+}
+__name(isWorkflowRunLevelError, "isWorkflowRunLevelError");
+var WORKFLOW_ABORT_REASON_STALLED = "stalled";
+
+// packages/core/src/agents/runtime/workflow-stall.ts
+init_esbuild_shims();
+var DEFAULT_STALL_MS = 18e4;
+var MAX_STALL_ATTEMPTS = 3;
+var MAX_WORKFLOW_STALL_MS_ENV = "QWEN_CODE_WORKFLOW_STALL_SECONDS";
+function resolveStallMs(perCall, env = process.env) {
+  if (typeof perCall === "number" && Number.isFinite(perCall)) {
+    if (perCall === 0) return 0;
+    if (perCall > 0) return perCall;
+  }
+  const raw = env[MAX_WORKFLOW_STALL_MS_ENV];
+  const trimmed = raw?.trim();
+  if (trimmed) {
+    if (trimmed === "0") return 0;
+    const sec = parsePositiveIntegerEnv(trimmed, 0);
+    if (sec > 0) return sec * 1e3;
+  }
+  return DEFAULT_STALL_MS;
+}
+__name(resolveStallMs, "resolveStallMs");
+var debugLogger4 = createDebugLogger("WORKFLOW_STALL");
+function attachStallWatchdog(emitter, controller, stallMs) {
+  if (stallMs <= 0) {
+    return { stalled: /* @__PURE__ */ __name(() => false, "stalled"), dispose: /* @__PURE__ */ __name(() => {
+    }, "dispose") };
+  }
+  let inFlightTools = 0;
+  let fired = false;
+  let timer;
+  let disposed = false;
+  const clear = /* @__PURE__ */ __name(() => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }, "clear");
+  const arm = /* @__PURE__ */ __name(() => {
+    clear();
+    if (disposed || fired) return;
+    if (inFlightTools > 0) return;
+    timer = setTimeout(() => {
+      if (disposed || fired) return;
+      fired = true;
+      debugLogger4.warn(
+        `[Workflow] agent dispatch stalled \u2014 no progress for ${stallMs}ms; aborting.`
+      );
+      try {
+        controller.abort(WORKFLOW_ABORT_REASON_STALLED);
+      } catch (e) {
+        debugLogger4.warn("stall watchdog abort threw:", e);
+      }
+    }, stallMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  }, "arm");
+  const onActivity = /* @__PURE__ */ __name(() => arm(), "onActivity");
+  const onToolCall = /* @__PURE__ */ __name(() => {
+    inFlightTools += 1;
+    clear();
+  }, "onToolCall");
+  const onToolResult = /* @__PURE__ */ __name(() => {
+    inFlightTools = Math.max(0, inFlightTools - 1);
+    arm();
+  }, "onToolResult");
+  emitter.on("round_start" /* ROUND_START */, onActivity);
+  emitter.on("round_end" /* ROUND_END */, onActivity);
+  emitter.on("stream_text" /* STREAM_TEXT */, onActivity);
+  emitter.on("usage_metadata" /* USAGE_METADATA */, onActivity);
+  emitter.on("tool_call" /* TOOL_CALL */, onToolCall);
+  emitter.on("tool_result" /* TOOL_RESULT */, onToolResult);
+  return {
+    stalled: /* @__PURE__ */ __name(() => fired, "stalled"),
+    dispose: /* @__PURE__ */ __name(() => {
+      if (disposed) return;
+      disposed = true;
+      clear();
+      emitter.off("round_start" /* ROUND_START */, onActivity);
+      emitter.off("round_end" /* ROUND_END */, onActivity);
+      emitter.off("stream_text" /* STREAM_TEXT */, onActivity);
+      emitter.off("usage_metadata" /* USAGE_METADATA */, onActivity);
+      emitter.off("tool_call" /* TOOL_CALL */, onToolCall);
+      emitter.off("tool_result" /* TOOL_RESULT */, onToolResult);
+    }, "dispose")
+  };
+}
+__name(attachStallWatchdog, "attachStallWatchdog");
+async function runStallResilient(attemptFn, opts) {
+  const { stallMs, signal, label } = opts;
+  if (stallMs <= 0) {
+    const emitter = new AgentEventEmitter();
+    return attemptFn(signal ?? new AbortController().signal, emitter);
+  }
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    const controller = new AbortController();
+    let onParentAbort;
+    if (signal) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+      } else {
+        onParentAbort = /* @__PURE__ */ __name(() => controller.abort(signal.reason), "onParentAbort");
+        signal.addEventListener("abort", onParentAbort);
+      }
+    }
+    const emitter = new AgentEventEmitter();
+    const watchdog = attachStallWatchdog(emitter, controller, stallMs);
+    try {
+      return await attemptFn(controller.signal, emitter);
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      if (watchdog.stalled() && attempt < MAX_STALL_ATTEMPTS) {
+        debugLogger4.warn(
+          `[Workflow] agent "${label ?? "workflow-agent"}" stalled (attempt ${attempt}/${MAX_STALL_ATTEMPTS}) \u2014 retrying.`
+        );
+        continue;
+      }
+      if (watchdog.stalled()) {
+        throw new WorkflowAgentFailedError(
+          `agent "${label ?? "workflow-agent"}" stalled on all ${MAX_STALL_ATTEMPTS} attempts (no progress for ${stallMs}ms each).`,
+          "stalled"
+        );
+      }
+      throw err;
+    } finally {
+      watchdog.dispose();
+      if (onParentAbort && signal) {
+        signal.removeEventListener("abort", onParentAbort);
+      }
+    }
+  }
+}
+__name(runStallResilient, "runStallResilient");
+
 // packages/core/src/agents/runtime/workflow-journal.ts
 init_esbuild_shims();
 import { createHash } from "node:crypto";
@@ -2162,15 +2226,18 @@ import { constants, promises as fs2 } from "node:fs";
 import path2 from "node:path";
 var debugLogger5 = createDebugLogger("WORKFLOW_JOURNAL");
 var JOURNAL_KEY_VERSION = "v2";
+var DISPATCH_AFFECTING_AGENT_OPTS = [
+  "schema",
+  "model",
+  "effort",
+  "isolation",
+  "agentType",
+  "workingDir",
+  "disallowedTools"
+];
 function canonicalizeAgentOpts(opts) {
   const projected = {};
-  for (const k of [
-    "schema",
-    "model",
-    "isolation",
-    "agentType",
-    "workingDir"
-  ]) {
+  for (const k of DISPATCH_AFFECTING_AGENT_OPTS) {
     const v = opts[k];
     if (v === void 0 || typeof v === "function") continue;
     projected[k] = v;
@@ -2671,11 +2738,11 @@ function terminalDispatchError(workflowAgentId, mode) {
 }
 __name(terminalDispatchError, "terminalDispatchError");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, workflowAgentId, agentIdentity, onTokens, subagentBounds) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-RI2THRQ7.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-TU5N3GFF.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
-  if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0 && opts.workingDir === void 0) {
+  if (DISPATCH_AFFECTING_AGENT_OPTS.every((key) => opts[key] === void 0)) {
     const subagent = await AgentHeadless.create(
       agentIdentity.name,
       config,
@@ -2740,12 +2807,39 @@ function reportTokens(subagent, opts, onTokens) {
   }
 }
 __name(reportTokens, "reportTokens");
+function resolveDispatchEffort(raw) {
+  if (raw === void 0) return void 0;
+  const tier = typeof raw === "string" ? normalizeReasoningEffort(raw) : void 0;
+  if (tier === void 0) {
+    throw new Error(
+      `agent({effort}): unknown effort tier ${sanitizeForErrorMessage(
+        JSON.stringify(raw) ?? String(raw)
+      )}. Known tiers are: ${REASONING_EFFORT_TIERS.join(", ")}.`
+    );
+  }
+  return tier;
+}
+__name(resolveDispatchEffort, "resolveDispatchEffort");
+function resolveDispatchDenies(raw) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw) || raw.some(
+    (name) => typeof name !== "string" || name.length === 0 || name !== name.trim()
+  )) {
+    throw new Error(
+      "agent({disallowedTools}): must be an array of non-empty tool-name strings without surrounding whitespace, e.g. ['run_shell_command', 'write_file']."
+    );
+  }
+  return raw.map((name) => resolveBuiltinToolName(name) ?? name);
+}
+__name(resolveDispatchDenies, "resolveDispatchDenies");
 async function runOverridePath(config, ctx, opts, signal, workflowAgentId, agentIdentity, onTokens, emitter, subagentBounds) {
   if (opts.isolation === "remote") {
     throw new Error(
       "agent({isolation:'remote'}) is not available in this build."
     );
   }
+  const effort = resolveDispatchEffort(opts.effort);
+  const requestedDenies = resolveDispatchDenies(opts.disallowedTools);
   const subagentMgr = config.getSubagentManager();
   let baseConfig;
   if (opts.agentType !== void 0) {
@@ -2784,10 +2878,28 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
     disallowedTools: Array.from(
       /* @__PURE__ */ new Set([
         ...baseConfig.disallowedTools ?? [],
-        ...WORKFLOW_SUBAGENT_DISALLOWED_TOOLS
+        ...WORKFLOW_SUBAGENT_DISALLOWED_TOOLS,
+        ...requestedDenies
       ])
     )
   };
+  if (requestedDenies.length > 0) {
+    const unmatched = await subagentMgr.findUnmatchedToolNames(requestedDenies);
+    if (unmatched.length > 0) {
+      throw new Error(
+        `agent({disallowedTools}): ${sanitizeForErrorMessage(
+          unmatched.map((name) => JSON.stringify(name)).join(", ")
+        )} ${unmatched.length === 1 ? "matches" : "match"} no tool. Use a tool name (run_shell_command, write_file, edit), a display name (Shell, WriteFile, Edit), or an MCP pattern (mcp__<server>, mcp__<server>__*, mcp__<server>__<tool>).`
+      );
+    }
+  }
+  if (opts.schema !== void 0 && [...baseConfig.disallowedTools ?? [], ...requestedDenies].some(
+    (name) => (resolveBuiltinToolName(name) ?? name) === ToolNames.STRUCTURED_OUTPUT
+  )) {
+    throw new Error(
+      "agent({schema, disallowedTools}): schema mode needs the structured_output tool, but disallowedTools deny it (from this call or from the agent type)."
+    );
+  }
   let worktreeIsolation = null;
   let effectiveContext = config;
   let approvalCleanup;
@@ -2870,6 +2982,7 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
           max_turns: resolveSubagentMaxTurns(),
           max_time_minutes: resolveSubagentMaxTimeMinutes()
         },
+        ...effort !== void 0 ? { modelConfigOverrides: { reasoningEffort: effort } } : {},
         eventEmitter,
         taskName: String(ctx.get("task_prompt")),
         subagentId: workflowAgentId
@@ -3853,12 +3966,98 @@ async function pruneSnapshots(config, dir) {
 }
 __name(pruneSnapshots, "pruneSnapshots");
 
+// packages/core/src/skills/workflow-authoring-skill.ts
+init_esbuild_shims();
+import { readFileSync } from "node:fs";
+import * as path4 from "node:path";
+var debugLogger7 = createDebugLogger("WORKFLOW_AUTHORING_SKILL");
+var WORKFLOW_AUTHORING_SKILL_NAME = "workflow-authoring";
+var cachedReference;
+function referencePath() {
+  return path4.join(
+    resolveBundleDir(import.meta.url),
+    "bundled",
+    WORKFLOW_AUTHORING_SKILL_NAME,
+    "SKILL.md"
+  );
+}
+__name(referencePath, "referencePath");
+function readWorkflowAuthoringReference() {
+  if (cachedReference !== void 0) return cachedReference;
+  try {
+    const filePath = referencePath();
+    const parsed = parseSkillContent(readFileSync(filePath, "utf8"), filePath);
+    cachedReference = { body: parsed.body, baseDir: path4.dirname(filePath) };
+  } catch (error) {
+    debugLogger7.warn(`cannot read the workflow-authoring reference: ${error}`);
+    cachedReference = null;
+  }
+  return cachedReference;
+}
+__name(readWorkflowAuthoringReference, "readWorkflowAuthoringReference");
+function resolveWorkflowAuthoringRoute(config) {
+  try {
+    if (config.getDisabledSkillLevels?.()?.has("bundled")) return "withheld";
+    if (config.isSkillEnabled?.({
+      name: WORKFLOW_AUTHORING_SKILL_NAME,
+      level: "bundled"
+    }) === false) {
+      return "withheld";
+    }
+    if (!config.getSkillManager?.()) return "inline";
+    const registry = config.getToolRegistry?.();
+    const toolNames = registry?.getAllToolNames?.();
+    if (!Array.isArray(toolNames)) return "skill";
+    if (!toolNames.includes(ToolNames.SKILL)) return "inline";
+    if (isToolDeferredBehindToolSearch(config, ToolNames.SKILL)) {
+      return toolNames.includes(ToolNames.TOOL_SEARCH) ? "skill-via-tool-search" : "inline";
+    }
+    return "skill";
+  } catch (error) {
+    debugLogger7.warn(`cannot resolve the workflow-authoring route: ${error}`);
+    return "skill";
+  }
+}
+__name(resolveWorkflowAuthoringRoute, "resolveWorkflowAuthoringRoute");
+function resolveWorkflowAuthoringSurface(config) {
+  const route = resolveWorkflowAuthoringRoute(config);
+  switch (route) {
+    case "skill":
+      return "pointer";
+    case "skill-via-tool-search":
+      return "pointer-via-tool-search";
+    case "withheld":
+      return "withheld";
+    case "inline":
+      return readWorkflowAuthoringReference() ? "inline" : "pointer";
+    default: {
+      const unhandled = route;
+      return unhandled;
+    }
+  }
+}
+__name(resolveWorkflowAuthoringSurface, "resolveWorkflowAuthoringSurface");
+function isToolDeferredBehindToolSearch(config, name) {
+  if (!config.getToolRegistry?.()?.isPermissionDeferred?.(name)) return false;
+  return !config.getVisibleTools?.()?.has(name);
+}
+__name(isToolDeferredBehindToolSearch, "isToolDeferredBehindToolSearch");
+function isToolHiddenBehindToolSearch(config, name) {
+  if (!isToolDeferredBehindToolSearch(config, name)) return false;
+  return !config.getToolRegistry?.()?.isDeferredToolRevealed?.(name);
+}
+__name(isToolHiddenBehindToolSearch, "isToolHiddenBehindToolSearch");
+function toolSearchRevealSentence(toolDisplayName) {
+  return `If the ${toolDisplayName} tool is not in your tool list, reveal it with ToolSearch first.`;
+}
+__name(toolSearchRevealSentence, "toolSearchRevealSentence");
+
 // packages/core/src/agents/runtime/review-workflow.ts
 init_esbuild_shims();
 import { createHash as createHash2 } from "node:crypto";
 import { promises as fs4 } from "node:fs";
-import path4 from "node:path";
-var debugLogger7 = createDebugLogger("REVIEW_WORKFLOW");
+import path5 from "node:path";
+var debugLogger8 = createDebugLogger("REVIEW_WORKFLOW");
 function resolveReviewWorkflowConcurrency(env = process.env) {
   const configured = parsePositiveIntegerEnv(env[MAX_WORKFLOW_CONCURRENCY_ENV], 0) || parsePositiveIntegerEnv(env["QWEN_CODE_MAX_TOOL_CONCURRENCY"], 10);
   return resolveConcurrencyLimit({
@@ -3872,12 +4071,12 @@ async function resolveReviewWorkflowLimits(scriptPath, generatedDir, scriptConte
     if ((await fs4.lstat(generatedDir)).isSymbolicLink()) return void 0;
     const generatedRoot = await fs4.realpath(generatedDir);
     canonicalScript = await fs4.realpath(scriptPath);
-    if (!canonicalScript.startsWith(path4.join(generatedRoot, "review") + path4.sep)) {
+    if (!canonicalScript.startsWith(path5.join(generatedRoot, "review") + path5.sep)) {
       return void 0;
     }
   } catch (error) {
     if (error.code !== "ENOENT") {
-      debugLogger7.warn(
+      debugLogger8.warn(
         "Cannot classify review workflow; using generic limits:",
         error
       );
@@ -3885,7 +4084,7 @@ async function resolveReviewWorkflowLimits(scriptPath, generatedDir, scriptConte
     return void 0;
   }
   const digest = /^qwen-review-[a-f0-9]{10}-([a-f0-9]{64})\.js$/.exec(
-    path4.basename(canonicalScript)
+    path5.basename(canonicalScript)
   )?.[1];
   if (!digest || createHash2("sha256").update(scriptContent).digest("hex") !== digest) {
     return void 0;
@@ -3923,9 +4122,6 @@ export {
   MAX_TOKENS_PER_WORKFLOW_ENV,
   resolveMaxTokensPerWorkflow,
   WorkflowBudgetImpl,
-  DEFAULT_STALL_MS,
-  MAX_STALL_ATTEMPTS,
-  MAX_WORKFLOW_STALL_MS_ENV,
   validateWorkflowName,
   isSymlinkedRoot,
   listSavedWorkflows,
@@ -3952,7 +4148,12 @@ export {
   listWorkflowSnapshots,
   deleteWorkflowSnapshot,
   resolveReviewWorkflowConcurrency,
-  resolveReviewWorkflowLimits
+  resolveReviewWorkflowLimits,
+  WORKFLOW_AUTHORING_SKILL_NAME,
+  readWorkflowAuthoringReference,
+  resolveWorkflowAuthoringSurface,
+  isToolHiddenBehindToolSearch,
+  toolSearchRevealSentence
 };
 /**
  * @license