@qwen-code/qwen-code 0.23.2 → 0.23.3

package/chunks/workflow-HD5NYMW5.js

@@ -1,2907 +0,0 @@
-// Force strict mode and setup for ESM
-"use strict";
-import {
-  compileWorkflowScript,
-  createWorkflowSandbox,
-  debugLogger,
-  deleteInlineWorkflowScript,
-  describeWorkflowCompileError,
-  extractAndStripMeta,
-  isSymlinkedRoot,
-  persistInlineWorkflowScript,
-  resolveSavedWorkflowScript,
-  writeWorkflowSnapshot
-} from "./chunk-OXR34GCD.js";
-import {
-  AgentEventEmitter,
-  RESUME_ARGS_TOO_LARGE_NOTE,
-  attachJsonlTranscriptWriter,
-  buildAgentTranscriptAttach,
-  buildFailureLines,
-  buildResumeCall,
-  deriveApprovalModeConfig,
-  deriveConfig,
-  deriveWorktreeConfig,
-  getRuleDisplayName,
-  getWorkflowTaskMutationKey,
-  hasUninlinableResumeArgs,
-  installSessionWorkflowRevisionWriteThrough,
-  isTerminalWorkflowStatus,
-  markWorkflowRunPersistenceActive,
-  rebuildToolRegistryOnOverride,
-  resolveExternalWorktreeDir,
-  resolveToolName,
-  toModelVisibleSubagentResult,
-  tryWithWorkflowTaskMutation
-} from "./chunk-HJ5UJQQL.js";
-import "./chunk-GOFAQQZA.js";
-import "./chunk-65I7S4Z3.js";
-import "./chunk-6HUXPLB5.js";
-import "./chunk-TWPJO254.js";
-import "./chunk-CQ35AJ4Z.js";
-import "./chunk-XKBFYTCD.js";
-import "./chunk-LYT2OU7D.js";
-import "./chunk-7CLLH5TI.js";
-import {
-  GitWorktreeService,
-  generateAgentWorktreeSlug,
-  writeWorktreeSessionMarker
-} from "./chunk-HIXUUCGY.js";
-import {
-  parsePositiveIntegerEnv
-} from "./chunk-6PVPNMXU.js";
-import "./chunk-565U2ANU.js";
-import "./chunk-GSFV5RQW.js";
-import "./chunk-IRH27ZC2.js";
-import "./chunk-QHWCP53L.js";
-import "./chunk-F53KKZUD.js";
-import "./chunk-TRWQQBVH.js";
-import "./chunk-QJNDUTOL.js";
-import "./chunk-N6S3NUYJ.js";
-import "./chunk-O6GEWCJA.js";
-import "./chunk-CHEIIBT3.js";
-import {
-  SUBAGENT_PLAN_LIFECYCLE_TOOLS
-} from "./chunk-QAZ2MGYT.js";
-import "./chunk-QQK4L3UU.js";
-import "./chunk-CH2YDT6X.js";
-import "./chunk-JX6XHPTX.js";
-import "./chunk-CLKE4IY3.js";
-import "./chunk-ZSTCM3MX.js";
-import "./chunk-SOA4HKRJ.js";
-import "./chunk-MLXTMF7H.js";
-import "./chunk-3LPJ776W.js";
-import "./chunk-3CZ2BQV6.js";
-import "./chunk-PQEISIKS.js";
-import "./chunk-S5QR6CB5.js";
-import {
-  runWithAgentContext
-} from "./chunk-H3Q3RSKZ.js";
-import "./chunk-S6LOFUVP.js";
-import "./chunk-NAVJD2PQ.js";
-import "./chunk-OFVAS4AR.js";
-import "./chunk-HNLMYDQE.js";
-import "./chunk-QHMLYMMS.js";
-import "./chunk-CFKIH3D3.js";
-import "./chunk-VBLAI2HA.js";
-import {
-  createAbortController,
-  createChildAbortController
-} from "./chunk-DJ2GSRLV.js";
-import "./chunk-4ALNJDHL.js";
-import "./chunk-NOO4QFXM.js";
-import "./chunk-KFFCDLKV.js";
-import "./chunk-7OCIQNKX.js";
-import {
-  WorkflowRunEvent,
-  logWorkflowRun,
-  read,
-  writeLine
-} from "./chunk-F2NYVASI.js";
-import "./chunk-5ETULJLP.js";
-import "./chunk-XBVNNDPK.js";
-import "./chunk-VGC4I5JJ.js";
-import {
-  isWithinRoot
-} from "./chunk-J6MB5ZHZ.js";
-import "./chunk-EDIDYZBT.js";
-import "./chunk-HD7O6WLV.js";
-import "./chunk-WZAD4ZNJ.js";
-import "./chunk-FPGTNKCP.js";
-import "./chunk-TIGXX4PA.js";
-import "./chunk-JO77FGNZ.js";
-import "./chunk-XFFRI3WM.js";
-import "./chunk-4HOEU2OR.js";
-import "./chunk-HHJLM3WQ.js";
-import {
-  stripAnsiAndControl
-} from "./chunk-7VEYUF3N.js";
-import "./chunk-74TONY4F.js";
-import {
-  SyntheticOutputTool
-} from "./chunk-E6TI726I.js";
-import "./chunk-4VY3ITHR.js";
-import "./chunk-O2FEO2CB.js";
-import "./chunk-G6UUOCUT.js";
-import "./chunk-IZ2U57NY.js";
-import {
-  BaseDeclarativeTool,
-  BaseToolInvocation,
-  ToolDisplayNames,
-  ToolNames
-} from "./chunk-MWIO7MF6.js";
-import {
-  createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
-import "./chunk-75DOP5OR.js";
-import "./chunk-DMTGGOSA.js";
-import "./chunk-YQ3U5MUC.js";
-import "./chunk-MATEIJZF.js";
-import "./chunk-TBWQLLFO.js";
-import {
-  init_esbuild_shims
-} from "./chunk-5O2XNYP6.js";
-import {
-  __name
-} from "./chunk-J2S4EL5Y.js";
-
-// packages/core/src/tools/workflow/workflow.ts
-init_esbuild_shims();
-
-// packages/core/src/agents/runtime/workflow-orchestrator.ts
-init_esbuild_shims();
-import { randomBytes } from "node:crypto";
-import { AsyncLocalStorage } from "node:async_hooks";
-import * as os from "node:os";
-
-// packages/core/src/agents/runtime/workflow-budget.ts
-init_esbuild_shims();
-var debugLogger2 = createDebugLogger("WORKFLOW_BUDGET");
-var MAX_TOKENS_PER_WORKFLOW_ENV = "QWEN_CODE_MAX_TOKENS_PER_WORKFLOW";
-var HARD_MAX_TOKENS_CEILING = 1e8;
-function resolveMaxTokensPerWorkflow(env = process.env) {
-  const raw = env[MAX_TOKENS_PER_WORKFLOW_ENV];
-  if (raw === void 0 || raw.trim() === "") {
-    return null;
-  }
-  const parsed = parsePositiveIntegerEnv(raw, 0);
-  if (parsed < 1) {
-    debugLogger2.warn(
-      `Invalid ${MAX_TOKENS_PER_WORKFLOW_ENV}=${JSON.stringify(raw)}, treating as unset (no cap)`
-    );
-    return null;
-  }
-  if (parsed > HARD_MAX_TOKENS_CEILING) {
-    debugLogger2.warn(
-      `${MAX_TOKENS_PER_WORKFLOW_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_TOKENS_CEILING}); clamping.`
-    );
-    return HARD_MAX_TOKENS_CEILING;
-  }
-  return parsed;
-}
-__name(resolveMaxTokensPerWorkflow, "resolveMaxTokensPerWorkflow");
-var WorkflowBudgetImpl = class _WorkflowBudgetImpl {
-  static {
-    __name(this, "WorkflowBudgetImpl");
-  }
-  total;
-  _spent;
-  constructor(total) {
-    this.total = total;
-    this._spent = 0;
-  }
-  spent() {
-    return this._spent;
-  }
-  remaining() {
-    if (this.total === null) return Infinity;
-    return Math.max(0, this.total - this._spent);
-  }
-  /**
-   * Host-side increment. NOT exposed to the script — the
-   * `WorkflowBudget` interface deliberately omits any setter so a
-   * malicious workflow cannot inflate / deflate the budget. Only the
-   * orchestrator (in `countedDispatch`) calls this after a dispatch
-   * resolves with the agent's output token count.
-   *
-   * Non-positive deltas are silently dropped (some dispatches return
-   * `output_tokens: 0` on early failures); negative deltas would be a
-   * caller bug and are also dropped rather than silently rewinding
-   * the counter.
-   */
-  recordSpent(deltaTokens) {
-    if (!Number.isFinite(deltaTokens) || deltaTokens <= 0) return;
-    this._spent += deltaTokens;
-  }
-  /**
-   * Factory: build a budget from the current environment. Convenience
-   * over `new WorkflowBudgetImpl(resolveMaxTokensPerWorkflow(env))`.
-   */
-  static fromEnv(env = process.env) {
-    return new _WorkflowBudgetImpl(resolveMaxTokensPerWorkflow(env));
-  }
-};
-var WorkflowBudgetExceededError = class extends Error {
-  static {
-    __name(this, "WorkflowBudgetExceededError");
-  }
-  name = "WorkflowBudgetExceededError";
-  runId;
-  budgetTotal;
-  spent;
-  constructor(runId, budgetTotal, spent) {
-    super(
-      `Workflow ${runId} exceeded the token budget (${spent} / ${budgetTotal} output tokens spent).`
-    );
-    this.runId = runId;
-    this.budgetTotal = budgetTotal;
-    this.spent = spent;
-  }
-};
-
-// packages/core/src/agents/runtime/workflow-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 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-journal.ts
-init_esbuild_shims();
-import { createHash } from "node:crypto";
-import { constants, promises as fs } from "node:fs";
-import path from "node:path";
-var debugLogger4 = createDebugLogger("WORKFLOW_JOURNAL");
-var JOURNAL_KEY_VERSION = "v2";
-function canonicalizeAgentOpts(opts) {
-  const projected = {};
-  for (const k of [
-    "schema",
-    "model",
-    "isolation",
-    "agentType",
-    "workingDir"
-  ]) {
-    const v = opts[k];
-    if (v === void 0 || typeof v === "function") continue;
-    projected[k] = v;
-  }
-  const sortDeep = /* @__PURE__ */ __name((val) => {
-    if (typeof val === "function") return void 0;
-    if (Array.isArray(val)) return val.map(sortDeep);
-    if (val && typeof val === "object") {
-      const out = {};
-      for (const key of Object.keys(val).sort()) {
-        if (key === "__proto__") continue;
-        out[key] = sortDeep(val[key]);
-      }
-      return out;
-    }
-    return val;
-  }, "sortDeep");
-  try {
-    return JSON.stringify(sortDeep(projected));
-  } catch {
-    return "{}";
-  }
-}
-__name(canonicalizeAgentOpts, "canonicalizeAgentOpts");
-function deriveAgentKey(prefixHash, prompt, opts) {
-  const hash = createHash("sha256");
-  hash.update(prefixHash);
-  hash.update("\0");
-  hash.update(prompt);
-  hash.update("\0");
-  hash.update(canonicalizeAgentOpts(opts));
-  return `${JOURNAL_KEY_VERSION}:${hash.digest("hex")}`;
-}
-__name(deriveAgentKey, "deriveAgentKey");
-function deriveArgsSeed(args) {
-  const hash = createHash("sha256");
-  let serialized;
-  try {
-    serialized = JSON.stringify(args ?? null) ?? "null";
-  } catch {
-    serialized = "non-serializable-args";
-  }
-  hash.update(serialized);
-  return `${JOURNAL_KEY_VERSION}:${hash.digest("hex")}`;
-}
-__name(deriveArgsSeed, "deriveArgsSeed");
-function buildReplay(entries) {
-  const results = /* @__PURE__ */ new Map();
-  const started = /* @__PURE__ */ new Map();
-  const failed = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    if (e.type === "result") {
-      results.set(e.key, e);
-    } else if (e.type === "started") {
-      failed.delete(e.key);
-      const list = started.get(e.key);
-      if (list) list.push(e);
-      else started.set(e.key, [e]);
-    } else if (e.type === "failed") {
-      failed.add(e.key);
-    }
-  }
-  return { results, started, failed };
-}
-__name(buildReplay, "buildReplay");
-var WorkflowJournal = class {
-  constructor(journalPath, root = path.dirname(path.dirname(journalPath))) {
-    this.root = root;
-    this.path = journalPath;
-  }
-  static {
-    __name(this, "WorkflowJournal");
-  }
-  pending = Promise.resolve();
-  path;
-  async hasSymlinkedPath() {
-    if (await isSymlinkedRoot(this.root) || await isSymlinkedRoot(path.dirname(this.path))) {
-      return true;
-    }
-    return fs.lstat(this.path).then((stat) => stat.isSymbolicLink()).catch(() => false);
-  }
-  /** Ensure the advertised journal path exists without affecting the run. */
-  async ensureExists() {
-    try {
-      if (await this.hasSymlinkedPath()) return false;
-      await fs.mkdir(path.dirname(this.path), { recursive: true });
-      if (await this.hasSymlinkedPath()) return false;
-      const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
-      const file = await fs.open(
-        this.path,
-        constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | noFollow,
-        384
-      );
-      try {
-        await file.chmod(384);
-      } finally {
-        await file.close();
-      }
-      return true;
-    } catch (error) {
-      debugLogger4.warn(
-        `WorkflowJournal.ensureExists failed for ${this.path}: ${error}`
-      );
-      return false;
-    }
-  }
-  /** Remove a never-registered run's journal file, best-effort. */
-  async remove() {
-    try {
-      if (await this.hasSymlinkedPath()) return;
-      await fs.rm(this.path, { force: true });
-      await fs.rmdir(path.dirname(this.path)).catch((error) => {
-        const code = error.code;
-        if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
-      });
-    } catch (error) {
-      debugLogger4.warn(
-        `WorkflowJournal.remove failed for ${this.path}: ${error}`
-      );
-    }
-  }
-  /** Load + parse all entries into replay maps. Empty maps if no file. */
-  async load() {
-    try {
-      const entries = await read(this.path);
-      return buildReplay(entries);
-    } catch (e) {
-      debugLogger4.warn(`WorkflowJournal.load failed for ${this.path}: ${e}`);
-      return { results: /* @__PURE__ */ new Map(), started: /* @__PURE__ */ new Map(), failed: /* @__PURE__ */ new Set() };
-    }
-  }
-  /** Append one entry. Rejects only on I/O error (callers `.catch`). */
-  append(entry) {
-    const operation = this.pending.then(() => writeLine(this.path, entry));
-    this.pending = operation.catch(() => void 0);
-    return operation;
-  }
-  /** Wait until every append issued so far has settled. */
-  drain() {
-    return this.pending;
-  }
-};
-
-// packages/core/src/agents/runtime/workflow-prompts.ts
-init_esbuild_shims();
-var WORKFLOW_SUBAGENT_SYSTEM_PROMPT = 'You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.\nCRITICAL: Your final text response is returned **verbatim** as a string to the calling script \u2014 it is your return value, not a message to a human.\n- Output the literal result (data, JSON, text). Do NOT output confirmations like "Done." or "Sent."\n- If asked for JSON, return ONLY the raw JSON \u2014 no code fences, no prose, no markdown.\n- Do NOT use SendUserMessage to deliver your answer. Put your answer in your final text response.\n- Be concise. The script will parse your output.';
-var WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA = "You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.\nCRITICAL: You MUST deliver your final answer by calling the `structured_output` tool with arguments that conform to its parameter schema. Plain-text final answers are DISCARDED \u2014 only a valid `structured_output` call returns a result to the calling script.\n- Use other tools (Read, Grep, etc.) to gather information first.\n- When ready, call `structured_output` ONCE with the conforming JSON object.\n- If validation fails, the error tells you what to fix. Try again with corrected fields.\n- After two failed attempts, the run terminates \u2014 get the arguments right.\n- Do NOT use SendUserMessage to deliver your answer.\n- Be concise; the script reads only the structured payload, not your prose.";
-
-// packages/core/src/agents/runtime/workflow-dispatch-scheduler.ts
-init_esbuild_shims();
-function abortError() {
-  return new DOMException("Workflow dispatch scheduler aborted.", "AbortError");
-}
-__name(abortError, "abortError");
-var WorkflowDispatchScheduler = class {
-  constructor(limit, signal, onStateChange) {
-    this.limit = limit;
-    this.signal = signal;
-    if (!Number.isInteger(limit) || limit < 1) {
-      throw new Error(
-        `Workflow dispatch limit must be a positive integer, got ${String(limit)}.`
-      );
-    }
-    if (onStateChange) this.stateListeners.add(onStateChange);
-    if (signal && !signal.aborted) {
-      signal.addEventListener("abort", () => this.abortPending(), {
-        once: true
-      });
-    }
-  }
-  static {
-    __name(this, "WorkflowDispatchScheduler");
-  }
-  state = "running";
-  inFlight = 0;
-  queue = [];
-  gateWaiters = [];
-  stateListeners = /* @__PURE__ */ new Set();
-  /**
-   * Subscribe to state transitions. Returns an unsubscribe function.
-   * The constructor callback (when given) is registered as the first
-   * listener; this method lets additional observers — e.g. the sandbox's
-   * pause-aware wall-clock watchdog — hook the same transitions.
-   */
-  onStateChange(listener) {
-    this.stateListeners.add(listener);
-    return () => {
-      this.stateListeners.delete(listener);
-    };
-  }
-  run(thunk) {
-    return new Promise((resolve2, reject) => {
-      if (this.signal?.aborted) {
-        reject(abortError());
-        return;
-      }
-      this.queue.push({
-        thunk,
-        resolve: resolve2,
-        reject
-      });
-      this.pump();
-    });
-  }
-  pause() {
-    if (this.state !== "running" || this.signal?.aborted) return false;
-    this.setState("pausing");
-    if (this.inFlight === 0) this.setState("paused");
-    return true;
-  }
-  resume() {
-    if (this.state !== "paused" || this.signal?.aborted) return false;
-    this.setState("running");
-    while (this.gateWaiters.length > 0) {
-      this.gateWaiters.shift().resolve();
-    }
-    this.pump();
-    return true;
-  }
-  waitUntilRunning() {
-    if (this.signal?.aborted) return Promise.reject(abortError());
-    if (this.state === "running") return Promise.resolve();
-    return new Promise((resolve2, reject) => {
-      this.gateWaiters.push({ resolve: resolve2, reject });
-    });
-  }
-  snapshot() {
-    return {
-      state: this.state,
-      queued: this.queue.length,
-      inFlight: this.inFlight
-    };
-  }
-  pump() {
-    while (this.state === "running" && this.inFlight < this.limit && this.queue.length > 0) {
-      const job = this.queue.shift();
-      if (this.signal?.aborted) {
-        job.reject(abortError());
-        continue;
-      }
-      this.inFlight++;
-      Promise.resolve().then(job.thunk).then(job.resolve, job.reject).finally(() => {
-        this.inFlight--;
-        if (this.state === "pausing" && this.inFlight === 0) {
-          this.setState("paused");
-        }
-        this.pump();
-      });
-    }
-  }
-  setState(state) {
-    if (this.state === state) return;
-    this.state = state;
-    const snapshot = this.snapshot();
-    for (const listener of [...this.stateListeners]) listener(snapshot);
-  }
-  abortPending() {
-    const error = abortError();
-    while (this.queue.length > 0) this.queue.shift().reject(error);
-    while (this.gateWaiters.length > 0) {
-      this.gateWaiters.shift().reject(error);
-    }
-  }
-};
-
-// packages/core/src/agents/runtime/workflow-orchestrator.ts
-var DEFAULT_MAX_AGENTS_PER_RUN = 1e3;
-var MAX_WORKFLOW_AGENTS_ENV = "QWEN_CODE_MAX_WORKFLOW_AGENTS";
-var HARD_MAX_AGENTS_PER_RUN_CEILING = 1e4;
-function resolveMaxAgentsPerRun(env = process.env) {
-  const raw = env[MAX_WORKFLOW_AGENTS_ENV];
-  if (raw === void 0 || raw.trim() === "") {
-    return DEFAULT_MAX_AGENTS_PER_RUN;
-  }
-  const parsed = parsePositiveIntegerEnv(raw, 0);
-  if (parsed < 1) {
-    debugLogger.warn(
-      `Invalid ${MAX_WORKFLOW_AGENTS_ENV}=${JSON.stringify(raw)}, using default (${DEFAULT_MAX_AGENTS_PER_RUN})`
-    );
-    return DEFAULT_MAX_AGENTS_PER_RUN;
-  }
-  if (parsed > HARD_MAX_AGENTS_PER_RUN_CEILING) {
-    debugLogger.warn(
-      `${MAX_WORKFLOW_AGENTS_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_AGENTS_PER_RUN_CEILING}); clamping.`
-    );
-    return HARD_MAX_AGENTS_PER_RUN_CEILING;
-  }
-  return parsed;
-}
-__name(resolveMaxAgentsPerRun, "resolveMaxAgentsPerRun");
-var MAX_WORKFLOW_CONCURRENCY_ENV = "QWEN_CODE_MAX_WORKFLOW_CONCURRENCY";
-var HARD_MAX_CONCURRENCY_CEILING = 64;
-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);
-    if (parsed >= 1) {
-      if (parsed > HARD_MAX_CONCURRENCY_CEILING) {
-        debugLogger.warn(
-          `${MAX_WORKFLOW_CONCURRENCY_ENV}=${parsed} exceeds hard ceiling (${HARD_MAX_CONCURRENCY_CEILING}); clamping.`
-        );
-        return HARD_MAX_CONCURRENCY_CEILING;
-      }
-      return parsed;
-    }
-    debugLogger.warn(
-      `Invalid ${MAX_WORKFLOW_CONCURRENCY_ENV}=${JSON.stringify(raw)}, using cpu-derived default`
-    );
-  }
-  return Math.max(2, Math.min(16, availableParallelism2() - 2));
-}
-__name(resolveConcurrencyLimit, "resolveConcurrencyLimit");
-var DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS = 50;
-var DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES = 10;
-var WORKFLOW_SUBAGENT_MAX_TURNS_ENV = "QWEN_CODE_WORKFLOW_AGENT_MAX_TURNS";
-var WORKFLOW_SUBAGENT_MAX_MINUTES_ENV = "QWEN_CODE_WORKFLOW_AGENT_MAX_MINUTES";
-var HARD_WORKFLOW_SUBAGENT_MAX_TURNS_CEILING = 500;
-var HARD_WORKFLOW_SUBAGENT_MAX_MINUTES_CEILING = 100;
-function resolveSubagentBound(envName, defaultValue, ceiling, env) {
-  const raw = env[envName];
-  if (raw === void 0 || raw.trim() === "") return defaultValue;
-  const parsed = parsePositiveIntegerEnv(raw, 0);
-  if (parsed < 1) {
-    debugLogger.warn(
-      `Invalid ${envName}=${JSON.stringify(raw)}, using default (${defaultValue})`
-    );
-    return defaultValue;
-  }
-  if (parsed > ceiling) {
-    debugLogger.warn(
-      `${envName}=${parsed} exceeds hard ceiling (${ceiling}); clamping.`
-    );
-    return ceiling;
-  }
-  return parsed;
-}
-__name(resolveSubagentBound, "resolveSubagentBound");
-function resolveSubagentMaxTurns(env = process.env) {
-  return resolveSubagentBound(
-    WORKFLOW_SUBAGENT_MAX_TURNS_ENV,
-    DEFAULT_WORKFLOW_SUBAGENT_MAX_TURNS,
-    HARD_WORKFLOW_SUBAGENT_MAX_TURNS_CEILING,
-    env
-  );
-}
-__name(resolveSubagentMaxTurns, "resolveSubagentMaxTurns");
-function resolveSubagentMaxTimeMinutes(env = process.env) {
-  return resolveSubagentBound(
-    WORKFLOW_SUBAGENT_MAX_MINUTES_ENV,
-    DEFAULT_WORKFLOW_SUBAGENT_MAX_TIME_MINUTES,
-    HARD_WORKFLOW_SUBAGENT_MAX_MINUTES_CEILING,
-    env
-  );
-}
-__name(resolveSubagentMaxTimeMinutes, "resolveSubagentMaxTimeMinutes");
-var WORKFLOW_SUBAGENT_DISALLOWED_TOOLS = [
-  ToolNames.ASK_USER_QUESTION,
-  ToolNames.SEND_MESSAGE,
-  ToolNames.MONITOR,
-  ...SUBAGENT_PLAN_LIFECYCLE_TOOLS,
-  // AgentTool: workflow subagents must not spawn sub-agents even where
-  // maxSubagentDepth would permit nesting — a leaf-spawned agent would run
-  // outside the orchestrator's concurrency cap, agent counter, and token
-  // budget, and its result would bypass the script's return-value contract.
-  // The WorkflowTool itself is already excluded from every subagent; this
-  // closes the same loop for plain `agent` calls (review #6189).
-  ToolNames.AGENT
-];
-var WorkflowExecutionError = class extends Error {
-  constructor(message, phases, logs, meta = null) {
-    super(message);
-    this.phases = phases;
-    this.logs = logs;
-    this.meta = meta;
-  }
-  static {
-    __name(this, "WorkflowExecutionError");
-  }
-  name = "WorkflowExecutionError";
-};
-function generateRunId() {
-  return `wf_${randomBytes(8).toString("hex")}`;
-}
-__name(generateRunId, "generateRunId");
-function sanitizeForErrorMessage(value) {
-  return stripAnsiAndControl(value);
-}
-__name(sanitizeForErrorMessage, "sanitizeForErrorMessage");
-function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents) {
-  return async (prompt, opts, dispatchId) => {
-    if (typeof prompt !== "string" || prompt.length === 0) {
-      throw new Error("agent() requires a non-empty string prompt.");
-    }
-    const stallMs = resolveStallMs(
-      typeof opts.stallMs === "number" ? opts.stallMs : void 0
-    );
-    const workflowAgentId = `workflow-agent-${randomBytes(8).toString("hex")}`;
-    const agentIdentity = await resolveWorkflowAgentIdentity(config, opts);
-    let attempt = 0;
-    return runStallResilient(
-      async (attemptSignal, emitter) => {
-        attempt += 1;
-        const cleanupApprovalBridge = bridgeApprovalEvents?.(
-          emitter,
-          dispatchId
-        );
-        const cleanupTranscript = attachDispatchTranscript(
-          config,
-          workflowAgentId,
-          prompt,
-          agentIdentity.name,
-          emitter,
-          attempt
-        );
-        try {
-          return await runSingleDispatch(
-            config,
-            prompt,
-            opts,
-            attemptSignal,
-            emitter,
-            workflowAgentId,
-            agentIdentity,
-            onTokens
-          );
-        } finally {
-          cleanupTranscript();
-          cleanupApprovalBridge?.();
-        }
-      },
-      {
-        stallMs,
-        signal,
-        // The name can carry a model-authored agentType spelling — keep
-        // the stall log / abandoned error single-line the same way the
-        // "not found" throw site sanitizes it.
-        label: sanitizeForErrorMessage(agentIdentity.name)
-      }
-    );
-  };
-}
-__name(createProductionDispatch, "createProductionDispatch");
-async function resolveWorkflowAgentIdentity(config, opts) {
-  if (opts.agentType) {
-    const resolved = await config.getSubagentManager().findSubagentByName(opts.agentType);
-    if (resolved) {
-      return { name: resolved.name, resolvedAgentType: resolved };
-    }
-  }
-  if (typeof opts.label === "string" && opts.label) {
-    return { name: opts.label };
-  }
-  return { name: opts.agentType || "workflow-agent" };
-}
-__name(resolveWorkflowAgentIdentity, "resolveWorkflowAgentIdentity");
-function attachDispatchTranscript(config, agentId, prompt, agentName, emitter, attempt) {
-  const append = attempt > 1;
-  try {
-    const { jsonlPath, options } = buildAgentTranscriptAttach(config, agentId, {
-      agentName,
-      // The prompt the SCRIPT dispatched, seeded as the transcript's first
-      // user record — the same shape AgentTool writes, so a reader that
-      // recovers a launch prompt from a transcript needs no workflow-
-      // specific branch. A retry re-uses the first attempt's record rather
-      // than seeding a second one.
-      initialUserPrompt: append ? void 0 : prompt,
-      appendToExisting: append,
-      retryAttempt: append ? attempt : void 0
-    });
-    return attachJsonlTranscriptWriter(emitter, jsonlPath, options).cleanup;
-  } catch (error) {
-    debugLogger.warn(
-      `[Workflow] failed to attach transcript for ${agentId}: ${error}`
-    );
-    return () => {
-    };
-  }
-}
-__name(attachDispatchTranscript, "attachDispatchTranscript");
-function terminalDispatchError(workflowAgentId, mode) {
-  const message = `Workflow subagent ${workflowAgentId} did not complete (terminate mode: ${mode}).`;
-  switch (mode) {
-    case "MAX_TURNS" /* MAX_TURNS */:
-      return new WorkflowAgentFailedError(message, "max_turns", mode);
-    case "TIMEOUT" /* TIMEOUT */:
-      return new WorkflowAgentFailedError(message, "timeout", mode);
-    case "ERROR" /* ERROR */:
-      return new WorkflowAgentFailedError(message, "error", mode);
-    default:
-      return new Error(message);
-  }
-}
-__name(terminalDispatchError, "terminalDispatchError");
-async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, workflowAgentId, agentIdentity, onTokens) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-VZKSRH36.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) {
-    const subagent = await AgentHeadless.create(
-      agentIdentity.name,
-      config,
-      {
-        systemPrompt: WORKFLOW_SUBAGENT_SYSTEM_PROMPT
-      },
-      {},
-      // T11 (PR #4732 R1): bound resource ceiling so a single agent() call
-      // cannot loop the model indefinitely. Without this, runConfig was {}
-      // and the loop guards never tripped — combined with the cancellation
-      // bug below, workflows were effectively unkillable.
-      {
-        max_turns: resolveSubagentMaxTurns(),
-        max_time_minutes: resolveSubagentMaxTimeMinutes()
-      },
-      // T11 (PR #4732 R1): disallow SendMessage / ExitPlanMode to align with
-      // upstream Tg8 — closes the back-channel that would let a subagent
-      // deliver its answer via user message instead of the script's read.
-      { tools: ["*"], disallowedTools: WORKFLOW_SUBAGENT_DISALLOWED_TOOLS },
-      // P-stall: the stall-watchdog emitter observes reasoning-loop events
-      // (round/tool/usage) to detect a hang and abort `attemptSignal`.
-      emitter,
-      void 0,
-      void 0,
-      prompt,
-      workflowAgentId
-    );
-    try {
-      await runWithAgentContext(
-        workflowAgentId,
-        () => subagent.execute(ctx, attemptSignal)
-      );
-    } finally {
-      reportTokens(subagent, opts, onTokens);
-    }
-    const mode = subagent.getTerminateMode();
-    if (mode !== "GOAL" /* GOAL */) {
-      throw terminalDispatchError(workflowAgentId, mode);
-    }
-    return toModelVisibleSubagentResult(subagent.getFinalText(), mode);
-  }
-  return runOverridePath(
-    config,
-    ctx,
-    opts,
-    attemptSignal,
-    workflowAgentId,
-    agentIdentity,
-    onTokens,
-    emitter
-  );
-}
-__name(runSingleDispatch, "runSingleDispatch");
-function reportTokens(subagent, opts, onTokens) {
-  if (!onTokens) return;
-  try {
-    const summary = subagent.getExecutionSummary();
-    onTokens(summary.outputTokens, opts);
-  } catch (e) {
-    debugLogger.warn("onTokens callback threw:", e);
-  }
-}
-__name(reportTokens, "reportTokens");
-async function runOverridePath(config, ctx, opts, signal, workflowAgentId, agentIdentity, onTokens, emitter) {
-  if (opts.isolation === "remote") {
-    throw new Error(
-      "agent({isolation:'remote'}) is not available in this build."
-    );
-  }
-  const subagentMgr = config.getSubagentManager();
-  let baseConfig;
-  if (opts.agentType !== void 0) {
-    const resolved = agentIdentity.resolvedAgentType;
-    if (!resolved) {
-      const safeAgentType = sanitizeForErrorMessage(opts.agentType);
-      throw new Error(
-        `agent({agentType}): agent type '${safeAgentType}' not found.`
-      );
-    }
-    baseConfig = resolved;
-  } else {
-    baseConfig = {
-      name: agentIdentity.name,
-      description: "Default workflow subagent (per-call overrides).",
-      systemPrompt: WORKFLOW_SUBAGENT_SYSTEM_PROMPT,
-      level: "session",
-      isBuiltin: false
-    };
-  }
-  let schemaSystemPrompt;
-  if (opts.schema !== void 0) {
-    schemaSystemPrompt = opts.agentType !== void 0 && baseConfig.systemPrompt ? `${baseConfig.systemPrompt}
-
-${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA;
-  }
-  let schemaTools;
-  if (opts.schema !== void 0 && baseConfig.tools && baseConfig.tools.length > 0 && !baseConfig.tools.includes("*") && !baseConfig.tools.includes(ToolNames.STRUCTURED_OUTPUT)) {
-    schemaTools = [...baseConfig.tools, ToolNames.STRUCTURED_OUTPUT];
-  }
-  const augmented = {
-    ...baseConfig,
-    ...opts.model !== void 0 ? { model: opts.model } : {},
-    ...schemaSystemPrompt !== void 0 ? { systemPrompt: schemaSystemPrompt } : {},
-    ...schemaTools !== void 0 ? { tools: schemaTools } : {},
-    disallowedTools: Array.from(
-      /* @__PURE__ */ new Set([
-        ...baseConfig.disallowedTools ?? [],
-        ...WORKFLOW_SUBAGENT_DISALLOWED_TOOLS
-      ])
-    )
-  };
-  let worktreeIsolation = null;
-  let effectiveContext = config;
-  let approvalCleanup;
-  if (opts.isolation !== void 0 && opts.workingDir !== void 0) {
-    throw new Error(
-      "agent({workingDir, isolation}): incompatible options. workingDir pins the agent to a worktree you already own; isolation creates a fresh one and removes it afterwards. Pass one."
-    );
-  }
-  if (opts.isolation === "worktree") {
-    worktreeIsolation = await provisionWorkflowWorktree(config);
-    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(
-        "agent({workingDir}): must be a non-empty string naming an existing git worktree of this repository."
-      );
-    }
-    const resolved = await resolveExternalWorktreeDir(
-      config,
-      opts.workingDir,
-      "workingDir"
-    );
-    if ("error" in resolved) {
-      throw new Error(
-        `agent({workingDir: ${sanitizeForErrorMessage(JSON.stringify(opts.workingDir))}}): ${sanitizeForErrorMessage(resolved.error)}`
-      );
-    }
-    effectiveContext = deriveWorktreeConfig(config, resolved.path, {
-      customIgnoreFiles: config.getFileFilteringOptions().customIgnoreFiles
-    });
-    installSessionWorkflowRevisionWriteThrough(effectiveContext, config);
-  }
-  if (effectiveContext !== config) {
-    const approvalHandle = deriveApprovalModeConfig(
-      effectiveContext,
-      config.getApprovalMode()
-    );
-    approvalCleanup = approvalHandle.cleanup;
-    effectiveContext = approvalHandle.config;
-  }
-  let onParentAbort;
-  try {
-    let schemaState = null;
-    if (opts.schema !== void 0) {
-      effectiveContext = await createSchemaConfigOverride(
-        effectiveContext,
-        opts.schema
-      );
-      schemaState = createSchemaModeState();
-    }
-    let dispatchSignal = signal;
-    if (schemaState) {
-      const child = new AbortController();
-      if (signal) {
-        if (signal.aborted) {
-          child.abort(signal.reason);
-        } else {
-          onParentAbort = /* @__PURE__ */ __name(() => child.abort(signal.reason), "onParentAbort");
-          signal.addEventListener("abort", onParentAbort);
-        }
-      }
-      schemaState.abortController = child;
-      dispatchSignal = child.signal;
-    }
-    const eventEmitter = emitter ?? (schemaState ? new AgentEventEmitter() : void 0);
-    if (schemaState && eventEmitter) {
-      attachSchemaListeners(eventEmitter, schemaState);
-    }
-    const { subagent, dispose } = await subagentMgr.createAgentHeadless(
-      augmented,
-      effectiveContext,
-      {
-        // Workflow always bounds resource ceiling regardless of agentType's
-        // own runConfig / maxTurns — these are workflow-level safety bounds,
-        // not subagent-level preferences. P5 will refine via budget.
-        runConfigOverrides: {
-          max_turns: resolveSubagentMaxTurns(),
-          max_time_minutes: resolveSubagentMaxTimeMinutes()
-        },
-        eventEmitter,
-        taskName: String(ctx.get("task_prompt")),
-        subagentId: workflowAgentId
-      }
-    );
-    try {
-      try {
-        await runWithAgentContext(
-          workflowAgentId,
-          () => subagent.execute(ctx, dispatchSignal)
-        );
-      } finally {
-        reportTokens(subagent, opts, onTokens);
-      }
-      if (schemaState) {
-        if (schemaState.result !== null) {
-          if (worktreeIsolation) {
-            const isolation = worktreeIsolation;
-            worktreeIsolation = null;
-            const preserved = await cleanupWorkflowWorktree(isolation);
-            if (preserved) {
-              debugLogger.info(
-                `[Workflow] Schema-mode subagent preserved worktree at ${preserved.path ?? "(directory removed)"} on branch ${preserved.branch}. The structured payload is returned verbatim; recover the work from the preserved path / branch.`
-              );
-            }
-          }
-          return schemaState.result;
-        }
-        if (signal?.aborted) {
-          throw new DOMException("Workflow aborted.", "AbortError");
-        }
-        const mode2 = subagent.getTerminateMode();
-        if (mode2 !== "GOAL" /* GOAL */ && mode2 !== "CANCELLED" /* CANCELLED */) {
-          throw terminalDispatchError(workflowAgentId, mode2);
-        }
-        if (schemaState.attempts > 2) {
-          throw new WorkflowAgentFailedError(
-            "subagent completed without calling StructuredOutput (after 2 in-conversation nudges).",
-            "no_structured_output"
-          );
-        }
-        throw new WorkflowAgentFailedError(
-          "subagent completed without calling structured_output (no validation attempt \u2014 model produced plain-text content).",
-          "no_structured_output"
-        );
-      }
-      const mode = subagent.getTerminateMode();
-      if (mode !== "GOAL" /* GOAL */) {
-        throw terminalDispatchError(workflowAgentId, mode);
-      }
-      let finalText = toModelVisibleSubagentResult(
-        subagent.getFinalText(),
-        mode
-      );
-      if (worktreeIsolation) {
-        const isolation = worktreeIsolation;
-        worktreeIsolation = null;
-        const preserved = await cleanupWorkflowWorktree(isolation);
-        if (preserved && typeof finalText === "string") {
-          finalText = appendWorktreePreservedSuffix(finalText, preserved);
-        }
-      }
-      return finalText;
-    } finally {
-      await dispose();
-    }
-  } finally {
-    if (onParentAbort && signal) {
-      signal.removeEventListener("abort", onParentAbort);
-    }
-    approvalCleanup?.();
-    if (worktreeIsolation) {
-      try {
-        await cleanupWorkflowWorktree(worktreeIsolation);
-      } catch (error) {
-        debugLogger.warn(
-          `Workflow worktree cleanup in fallback finally failed for ${worktreeIsolation.path}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-}
-__name(runOverridePath, "runOverridePath");
-async function provisionWorkflowWorktree(config) {
-  const cwd = config.getTargetDir();
-  if (/\.qwen[\\/]worktrees[\\/]/.test(cwd)) {
-    throw new Error(
-      `agent({isolation:'worktree'}): parent is already inside a worktree (${cwd}). Nested isolation worktrees are not supported \u2014 the subagent's inherited paths would still reference the outer worktree.`
-    );
-  }
-  const probe = new GitWorktreeService(cwd);
-  const gitCheck = await probe.checkGitAvailable();
-  if (!gitCheck.available) {
-    throw new Error(
-      `agent({isolation:'worktree'}): ${gitCheck.error ?? "git is not available"}.`
-    );
-  }
-  if (!await probe.isGitRepository()) {
-    throw new Error(
-      `agent({isolation:'worktree'}): ${cwd} is not a git repository.`
-    );
-  }
-  const projectRoot = await probe.getRepoTopLevel() ?? cwd;
-  const wtService = projectRoot === cwd ? probe : new GitWorktreeService(projectRoot);
-  let parentDirty = false;
-  try {
-    parentDirty = await wtService.hasWorktreeChanges(projectRoot);
-  } catch (error) {
-    debugLogger.warn(
-      `[Workflow] hasWorktreeChanges failed at ${projectRoot}: ${error}`
-    );
-    parentDirty = true;
-  }
-  if (parentDirty) {
-    throw new Error(
-      `agent({isolation:'worktree'}): parent working tree at ${projectRoot} has uncommitted changes that would not propagate into the isolated worktree. The subagent would see the prior HEAD instead of the current state. Commit or stash the changes, then re-run.`
-    );
-  }
-  const slug = generateAgentWorktreeSlug();
-  let parentBranch;
-  try {
-    parentBranch = await wtService.getCurrentBranch();
-  } catch (error) {
-    debugLogger.warn(
-      `[Workflow] getCurrentBranch failed at ${projectRoot}: ${error}`
-    );
-  }
-  const created = await wtService.createUserWorktree(slug, parentBranch, {
-    symlinkDirectories: config.getWorktreeSymlinkDirectories()
-  });
-  if (!created.success || !created.worktree) {
-    throw new Error(
-      `agent({isolation:'worktree'}): failed to create worktree: ${created.error ?? "unknown error"}.`
-    );
-  }
-  try {
-    await writeWorktreeSessionMarker(
-      created.worktree.path,
-      config.getSessionId()
-    );
-  } catch (error) {
-    debugLogger.warn(
-      `[Workflow] failed to write session marker at ${created.worktree.path}: ${error}`
-    );
-  }
-  return {
-    slug,
-    path: created.worktree.path,
-    branch: created.worktree.branch,
-    repoRoot: projectRoot
-  };
-}
-__name(provisionWorkflowWorktree, "provisionWorkflowWorktree");
-async function cleanupWorkflowWorktree(isolation) {
-  const wtService = new GitWorktreeService(isolation.repoRoot);
-  const [hasChanges, hasUnmerged] = await Promise.all([
-    wtService.hasWorktreeChanges(isolation.path).catch((error) => {
-      debugLogger.warn(
-        `[Workflow] hasWorktreeChanges failed for ${isolation.path}: ${error}`
-      );
-      return true;
-    }),
-    wtService.hasUnmergedWorktreeCommits(isolation.slug).catch((error) => {
-      debugLogger.warn(
-        `[Workflow] hasUnmergedWorktreeCommits failed for ${isolation.slug}: ${error}`
-      );
-      return true;
-    })
-  ]);
-  if (hasChanges || hasUnmerged) {
-    debugLogger.info(
-      `[Workflow] Preserving isolation worktree ${isolation.path} (branch ${isolation.branch}, hasChanges=${hasChanges}, hasUnmerged=${hasUnmerged})`
-    );
-    return { path: isolation.path, branch: isolation.branch };
-  }
-  try {
-    const result = await wtService.removeUserWorktree(isolation.slug, {
-      deleteBranch: true
-    });
-    if (!result.success) {
-      debugLogger.warn(
-        `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${result.error}`
-      );
-      return { path: isolation.path, branch: isolation.branch };
-    }
-    if (result.branchPreserved) {
-      debugLogger.warn(
-        `[Workflow] Removed worktree directory ${isolation.path} but kept branch ${isolation.branch} (unmerged commits at delete time)`
-      );
-      return { branch: isolation.branch };
-    }
-  } catch (error) {
-    debugLogger.warn(
-      `[Workflow] Failed to remove ephemeral worktree ${isolation.path}: ${error}`
-    );
-    return { path: isolation.path, branch: isolation.branch };
-  }
-  return null;
-}
-__name(cleanupWorkflowWorktree, "cleanupWorkflowWorktree");
-function appendWorktreePreservedSuffix(finalText, preserved) {
-  const sep = finalText.endsWith("\n") ? "\n" : "\n\n";
-  if (preserved.path) {
-    return `${finalText}${sep}[worktree preserved: ${preserved.path} (branch ${preserved.branch})]`;
-  }
-  return `${finalText}${sep}[worktree directory removed; branch ${preserved.branch} preserved \u2014 recover with \`git worktree add <path> ${preserved.branch}\`]`;
-}
-__name(appendWorktreePreservedSuffix, "appendWorktreePreservedSuffix");
-function createSchemaModeState() {
-  return {
-    result: null,
-    attempts: 0,
-    pendingArgs: /* @__PURE__ */ new Map(),
-    abortController: new AbortController()
-  };
-}
-__name(createSchemaModeState, "createSchemaModeState");
-function attachSchemaListeners(emitter, state) {
-  const targetTool = ToolNames.STRUCTURED_OUTPUT;
-  emitter.on("tool_call" /* TOOL_CALL */, (evt) => {
-    if (evt.name !== targetTool) return;
-    state.pendingArgs.set(evt.callId, evt.args);
-  });
-  emitter.on("tool_result" /* TOOL_RESULT */, (evt) => {
-    if (evt.name !== targetTool) return;
-    const args = state.pendingArgs.get(evt.callId);
-    state.pendingArgs.delete(evt.callId);
-    if (evt.success) {
-      if (args !== void 0 && state.result === null) {
-        state.result = args;
-        state.abortController.abort();
-      }
-      return;
-    }
-    state.attempts += 1;
-    if (state.attempts > 2 && state.result === null) {
-      state.abortController.abort();
-    }
-  });
-}
-__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));
-  return override;
-}
-__name(createSchemaConfigOverride, "createSchemaConfigOverride");
-var WorkflowOrchestrator = class {
-  constructor(dispatch) {
-    this.dispatch = dispatch;
-  }
-  static {
-    __name(this, "WorkflowOrchestrator");
-  }
-  async run(req) {
-    const runId = req.runId ?? generateRunId();
-    const maxAgents = resolveMaxAgentsPerRun();
-    const signal = req.abortOnTimeout?.signal;
-    const scheduler = req.scheduler ?? new WorkflowDispatchScheduler(resolveConcurrencyLimit(), signal);
-    const rejectThroughPauseGate = /* @__PURE__ */ __name((error) => scheduler.waitUntilRunning().then(
-      () => {
-        throw error;
-      },
-      () => {
-        throw error;
-      }
-    ), "rejectThroughPauseGate");
-    let agentCount = 0;
-    let dispatchTraceCount = 0;
-    const emitter = req.emitter;
-    const budget = req.budget;
-    const dependencyContext = new AsyncLocalStorage();
-    const issueDispatchTrace = /* @__PURE__ */ __name((prompt, opts, cached = false) => {
-      const id = `dispatch-${dispatchTraceCount += 1}`;
-      const store = dependencyContext.getStore();
-      const dependsOn = Array.from(new Set(store?.tails ?? []));
-      if (store) store.tails = [id];
-      try {
-        emitter?.dispatchQueued?.({
-          id,
-          ...typeof opts.label === "string" ? { label: opts.label } : {},
-          prompt,
-          dependsOn,
-          queuedAt: Date.now(),
-          ...cached ? { cached: true } : {}
-        });
-      } catch (e) {
-        debugLogger.warn("emitter.dispatchQueued threw:", e);
-      }
-      return id;
-    }, "issueDispatchTrace");
-    const journal = req.journal;
-    const replay = req.resumeReplay;
-    let prefixHash = deriveArgsSeed(req.args);
-    let hadMiss = false;
-    let journalAgentId = 0;
-    const parentSandboxRef = {
-      current: void 0
-    };
-    const countedDispatch = /* @__PURE__ */ __name((prompt, opts) => {
-      if (typeof prompt !== "string" || prompt.length === 0) {
-        return rejectThroughPauseGate(
-          new Error("agent() requires a non-empty string prompt.")
-        );
-      }
-      let journalKey;
-      let journalEntryId;
-      let respawnLine;
-      if (journal) {
-        journalKey = deriveAgentKey(prefixHash, prompt, opts);
-        prefixHash = journalKey;
-        if (!hadMiss && replay) {
-          const cached = replay.results.get(journalKey);
-          if (cached !== void 0) {
-            const respawns = replay.started.get(journalKey);
-            if (respawns && respawns.length > 0) {
-              debugLogger.info(
-                `[Workflow] resume cache hit after ${respawns.length} prior respawn(s) for runId=${runId}.`
-              );
-            }
-            const label2 = typeof opts.label === "string" ? opts.label : void 0;
-            const dispatchId2 = issueDispatchTrace(prompt, opts, true);
-            try {
-              emitter?.agentDispatched?.(label2);
-            } catch (e) {
-              debugLogger.warn("emitter.agentDispatched threw:", e);
-            }
-            try {
-              emitter?.agentCompleted?.(label2);
-            } catch (e) {
-              debugLogger.warn("emitter.agentCompleted threw:", e);
-            }
-            try {
-              emitter?.dispatchSettled?.(dispatchId2, void 0, Date.now());
-            } catch (e) {
-              debugLogger.warn("emitter.dispatchSettled threw:", e);
-            }
-            return scheduler.waitUntilRunning().then(
-              () => cached.result,
-              () => cached.result
-            );
-          }
-        }
-        const priorStarts = replay?.started.get(journalKey);
-        if (priorStarts && priorStarts.length > 0 && !replay?.results.has(journalKey)) {
-          const name = typeof opts.label === "string" ? `"${stripAnsiAndControl(opts.label)}"` : "an agent";
-          respawnLine = replay?.failed.has(journalKey) ? `[resume] re-running ${name}: it failed in the previous run` : `[resume] respawning ${name}: interrupted in a previous run (${priorStarts.length} prior attempt${priorStarts.length === 1 ? "" : "s"})`;
-        }
-        hadMiss = true;
-      }
-      if (budget && budget.total !== null && budget.remaining() <= 0) {
-        debugLogger.warn(
-          `[Workflow] budget gate refused dispatch at entry: runId=${runId} spent=${budget.spent()} total=${budget.total}`
-        );
-        return rejectThroughPauseGate(
-          new WorkflowBudgetExceededError(runId, budget.total, budget.spent())
-        );
-      }
-      if (agentCount >= maxAgents) {
-        return rejectThroughPauseGate(
-          new WorkflowAgentCapExceededError(maxAgents)
-        );
-      }
-      agentCount += 1;
-      if (journal && journalKey !== void 0) {
-        journalEntryId = String(journalAgentId += 1);
-      }
-      const label = typeof opts.label === "string" ? opts.label : void 0;
-      const dispatchId = issueDispatchTrace(prompt, opts);
-      try {
-        emitter?.agentDispatched?.(label);
-      } catch (e) {
-        debugLogger.warn("emitter.agentDispatched threw:", e);
-      }
-      let completionEmitted = false;
-      const emitCompletion = /* @__PURE__ */ __name((error) => {
-        if (completionEmitted) return;
-        completionEmitted = true;
-        const message = error === void 0 ? void 0 : error instanceof Error ? error.message : String(error);
-        try {
-          emitter?.agentCompleted?.(label, message);
-        } catch (e) {
-          debugLogger.warn("emitter.agentCompleted threw:", e);
-        }
-        try {
-          emitter?.dispatchSettled?.(dispatchId, message, Date.now());
-        } catch (e) {
-          debugLogger.warn("emitter.dispatchSettled threw:", e);
-        }
-      }, "emitCompletion");
-      return scheduler.run(async () => {
-        try {
-          try {
-            emitter?.dispatchStarted?.(dispatchId, Date.now());
-          } catch (e) {
-            debugLogger.warn("emitter.dispatchStarted threw:", e);
-          }
-          if (budget && budget.total !== null && budget.remaining() <= 0) {
-            debugLogger.warn(
-              `[Workflow] budget gate refused dispatch at slot-acquire: runId=${runId} spent=${budget.spent()} total=${budget.total}`
-            );
-            throw new WorkflowBudgetExceededError(
-              runId,
-              budget.total,
-              budget.spent()
-            );
-          }
-          if (journal && journalKey !== void 0 && journalEntryId !== void 0) {
-            journal.append({
-              type: "started",
-              key: journalKey,
-              agentId: journalEntryId
-            }).catch(
-              (e) => debugLogger.warn(`journal started-append failed: ${e}`)
-            );
-          }
-          if (respawnLine) {
-            parentSandboxRef.current?.appendLog(respawnLine);
-            try {
-              emitter?.resumeRespawn?.(respawnLine);
-            } catch (e) {
-              debugLogger.warn("emitter.resumeRespawn threw:", e);
-            }
-          }
-          const result = await this.dispatch(prompt, opts, dispatchId);
-          emitCompletion();
-          if (journal && journalKey !== void 0) {
-            journal.append({
-              type: "result",
-              key: journalKey,
-              agentId: journalEntryId ?? "",
-              result
-            }).catch(
-              (e) => debugLogger.warn(`journal result-append failed: ${e}`)
-            );
-          }
-          if (budget) {
-            try {
-              emitter?.budgetUpdated?.(budget.spent(), budget.total);
-            } catch (e) {
-              debugLogger.warn("emitter.budgetUpdated threw:", e);
-            }
-          }
-          return result;
-        } catch (err) {
-          emitCompletion(err);
-          if (budget) {
-            try {
-              emitter?.budgetUpdated?.(budget.spent(), budget.total);
-            } catch (e) {
-              debugLogger.warn("emitter.budgetUpdated threw:", e);
-            }
-          }
-          if (journal && journalKey !== void 0 && !signal?.aborted && !isWorkflowRunLevelError(err)) {
-            journal.append({
-              type: "failed",
-              key: journalKey,
-              agentId: journalEntryId ?? ""
-            }).catch(
-              (e) => debugLogger.warn(`journal failed-append failed: ${e}`)
-            );
-          }
-          if (signal?.aborted || isWorkflowRunLevelError(err)) throw err;
-          if (isWorkflowAgentFailedError(err)) {
-            debugLogger.warn(
-              `[Workflow] agent settled to null (${err.kind}): ${err.message}`
-            );
-          } else {
-            debugLogger.warn(
-              `[Workflow] agent settled to null: ${extractErrorMessage(err)}`
-            );
-          }
-          return null;
-        }
-      }).then(
-        // Resolve even if the gate aborts: a successful dispatch must not
-        // turn into a teardown rejection — for a fire-and-forget call the
-        // script never attached a handler, so the rejection would surface
-        // as a spurious process-level unhandledRejection alarm on a
-        // correctly-cancelled run.
-        (result) => scheduler.waitUntilRunning().then(
-          () => result,
-          () => result
-        ),
-        (error) => {
-          emitCompletion(error);
-          return scheduler.waitUntilRunning().then(
-            () => {
-              throw error;
-            },
-            () => {
-              throw error;
-            }
-          );
-        }
-      );
-    }, "countedDispatch");
-    const parallelImpl = makeParallelImpl(signal, dependencyContext);
-    const pipelineImpl = makePipelineImpl(signal, dependencyContext);
-    const resolveSavedWorkflow = req.resolveSavedWorkflow;
-    const workflowImpl = resolveSavedWorkflow ? async (nameOrRef, nestedArgs) => {
-      const resolved = await resolveSavedWorkflow(nameOrRef);
-      const nestedSandbox = createWorkflowSandbox({
-        args: nestedArgs,
-        runId,
-        dispatch: countedDispatch,
-        parallel: parallelImpl,
-        pipeline: pipelineImpl,
-        abortOnTimeout: req.abortOnTimeout,
-        emitter,
-        budget,
-        scheduler
-        // No `workflow` — single-level nesting limit.
-      });
-      try {
-        return await nestedSandbox.run(resolved.script);
-      } finally {
-        for (const line of nestedSandbox.getLogs()) {
-          parentSandboxRef.current?.appendLog(line);
-        }
-      }
-    } : void 0;
-    const sandbox = createWorkflowSandbox({
-      args: req.args,
-      runId,
-      dispatch: countedDispatch,
-      parallel: parallelImpl,
-      pipeline: pipelineImpl,
-      workflow: workflowImpl,
-      abortOnTimeout: req.abortOnTimeout,
-      emitter,
-      budget,
-      scheduler
-    });
-    parentSandboxRef.current = sandbox;
-    try {
-      const result = await dependencyContext.run(
-        { tails: [] },
-        () => sandbox.run(req.script)
-      );
-      return {
-        runId,
-        result,
-        phases: sandbox.getPhases(),
-        logs: sandbox.getLogs(),
-        meta: sandbox.getMeta()
-      };
-    } catch (err) {
-      throw new WorkflowExecutionError(
-        extractErrorMessage(err),
-        sandbox.getPhases(),
-        sandbox.getLogs(),
-        sandbox.getMeta()
-      );
-    }
-  }
-};
-async function settleToNullArray(thunks, signal) {
-  const settled = await Promise.allSettled(
-    thunks.map((t) => Promise.resolve().then(t))
-  );
-  if (signal?.aborted)
-    throw new DOMException("Workflow run aborted.", "AbortError");
-  const visitedReasons = /* @__PURE__ */ new WeakSet();
-  const findRunFailureReason = /* @__PURE__ */ __name((reason) => {
-    if (reason === null || typeof reason !== "object") return void 0;
-    if (visitedReasons.has(reason)) return void 0;
-    visitedReasons.add(reason);
-    try {
-      if (reason.__wfRunFailure === true) {
-        return reason;
-      }
-      const errors = reason?.errors;
-      if (!Array.isArray(errors)) return void 0;
-      for (const error of errors) {
-        const runFailure = findRunFailureReason(error);
-        if (runFailure !== void 0) return runFailure;
-      }
-    } catch {
-      return void 0;
-    }
-    return void 0;
-  }, "findRunFailureReason");
-  for (const result of settled) {
-    if (result.status !== "rejected") continue;
-    const runFailure = findRunFailureReason(result.reason);
-    if (runFailure !== void 0) throw runFailure;
-  }
-  return settled.map((r, i) => {
-    if (r.status === "fulfilled") return r.value;
-    const reason = r.reason;
-    debugLogger.warn(
-      `Workflow thunk at index ${i} rejected: ${String(reason?.message ?? r.reason)}`
-    );
-    return null;
-  });
-}
-__name(settleToNullArray, "settleToNullArray");
-function makeParallelImpl(signal, dependencyContext) {
-  return (thunks) => {
-    if (!Array.isArray(thunks)) {
-      return Promise.reject(
-        new Error(
-          "parallel() expects an array of thunks (functions returning promises)."
-        )
-      );
-    }
-    for (const t of thunks) {
-      if (typeof t !== "function") {
-        return Promise.reject(
-          new Error(
-            "parallel() expects an array of functions, not values \u2014 wrap each call: parallel([() => agent(...), () => agent(...)])."
-          )
-        );
-      }
-    }
-    const parent = dependencyContext.getStore();
-    const inheritedTails = parent?.tails ?? [];
-    const branches = thunks.map((thunk) => {
-      const store = { tails: [...inheritedTails] };
-      return {
-        store,
-        thunk: /* @__PURE__ */ __name(() => dependencyContext.run(store, thunk), "thunk")
-      };
-    });
-    return settleToNullArray(
-      branches.map(({ thunk }) => thunk),
-      signal
-    ).then((result) => {
-      if (parent && branches.length > 0) {
-        parent.tails = mergeFanoutTails(
-          parent.tails,
-          inheritedTails,
-          branches.flatMap(({ store }) => store.tails)
-        );
-      }
-      return result;
-    });
-  };
-}
-__name(makeParallelImpl, "makeParallelImpl");
-function makePipelineImpl(signal, dependencyContext) {
-  return (items, ...stages) => {
-    if (!Array.isArray(items)) {
-      return Promise.reject(
-        new Error(
-          "pipeline() expects an array of items as its first argument."
-        )
-      );
-    }
-    for (const s of stages) {
-      if (typeof s !== "function") {
-        return Promise.reject(
-          new Error(
-            "pipeline() stages must be functions: pipeline(items, item => ..., result => ...)."
-          )
-        );
-      }
-    }
-    const parent = dependencyContext.getStore();
-    const inheritedTails = parent?.tails ?? [];
-    const branches = items.map((item, idx) => {
-      const store = { tails: [...inheritedTails] };
-      return {
-        store,
-        thunk: /* @__PURE__ */ __name(() => dependencyContext.run(
-          store,
-          () => runPipelineChain(item, idx, stages)
-        ), "thunk")
-      };
-    });
-    return settleToNullArray(
-      branches.map(({ thunk }) => thunk),
-      signal
-    ).then((result) => {
-      if (parent && branches.length > 0) {
-        parent.tails = mergeFanoutTails(
-          parent.tails,
-          inheritedTails,
-          branches.flatMap(({ store }) => store.tails)
-        );
-      }
-      return result;
-    });
-  };
-}
-__name(makePipelineImpl, "makePipelineImpl");
-function mergeFanoutTails(currentParentTails, inheritedTails, branchTails) {
-  const inherited = new Set(inheritedTails);
-  const newBranchTails = branchTails.filter((tail) => !inherited.has(tail));
-  const merged = newBranchTails.length > 0 ? [
-    ...newBranchTails,
-    ...currentParentTails.filter((tail) => !inherited.has(tail))
-  ] : currentParentTails;
-  return Array.from(new Set(merged));
-}
-__name(mergeFanoutTails, "mergeFanoutTails");
-async function runPipelineChain(item, idx, stages) {
-  let prev = item;
-  for (const stage of stages) {
-    if (prev === null) break;
-    prev = await stage(prev, item, idx);
-  }
-  return prev;
-}
-__name(runPipelineChain, "runPipelineChain");
-function extractErrorMessage(err) {
-  if (err && typeof err === "object" && "message" in err) {
-    const m = err.message;
-    if (typeof m === "string") return m;
-    return String(m);
-  }
-  return String(err);
-}
-__name(extractErrorMessage, "extractErrorMessage");
-
-// packages/core/src/agents/runtime/workflow-runner.ts
-init_esbuild_shims();
-import { randomBytes as randomBytes2 } from "node:crypto";
-var WorkflowRunHandle = class {
-  constructor(runId, budget, registry, controller, scheduler, start, locations = {}) {
-    this.runId = runId;
-    this.budget = budget;
-    this.registry = registry;
-    this.controller = controller;
-    this.scheduler = scheduler;
-    this.scriptPath = locations.scriptPath;
-    this.journalPath = locations.journalPath;
-    this.completion = Promise.resolve().then(start);
-  }
-  static {
-    __name(this, "WorkflowRunHandle");
-  }
-  completion;
-  /**
-   * Where this run's script lives on disk: the file a `{scriptPath}` launch
-   * loaded, or the persisted copy of an inline `{script}`. `undefined` when
-   * an inline script could not be persisted (no `storage`, symlinked root,
-   * write failure) — callers report the run without it rather than naming a
-   * path that does not exist.
-   */
-  scriptPath;
-  /** This run's resume journal, when the config has a `storage` to hold one. */
-  journalPath;
-  abort() {
-    this.controller.abort();
-  }
-  pause() {
-    return this.scheduler.pause();
-  }
-  resume() {
-    return this.scheduler.resume();
-  }
-};
-var WorkflowScriptNotLaunchedError = class extends Error {
-  constructor(detail) {
-    super(
-      `Workflow script is invalid and was not launched:
-${detail}
-
-Workflow scripts must be plain JavaScript \u2014 the usual causes are TypeScript syntax (type annotations, interfaces, generics) and broken string quoting or escaping. Metadata must use literal values.`
-    );
-    this.detail = detail;
-    this.name = "WorkflowScriptNotLaunchedError";
-  }
-  static {
-    __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 runId = options.resumeFromRunId ?? `wf_${randomBytes2(8).toString("hex")}`;
-    const registry = config.getWorkflowRunRegistry?.();
-    let entry;
-    const isCurrentEntry = /* @__PURE__ */ __name(() => registry === void 0 || entry !== void 0 && registry.get(runId) === entry, "isCurrentEntry");
-    const createController = /* @__PURE__ */ __name(() => runInBackground ? createAbortController() : createChildAbortController(options.signal), "createController");
-    const controller = registry ? registry.reserveStart(runId, createController) : createController();
-    const releasePersistenceActivity = markWorkflowRunPersistenceActive(
-      config,
-      runId
-    );
-    const assertStartNotCancelled = /* @__PURE__ */ __name(() => {
-      if (controller.signal.aborted && !options.signal.aborted) {
-        throw new WorkflowStartCancelledError();
-      }
-      if (runInBackground && options.signal.aborted) {
-        throw new WorkflowStartCancelledError();
-      }
-    }, "assertStartNotCancelled");
-    const storage = config.storage;
-    const previousEntry = registry?.get(runId);
-    let journalPath = storage ? storage.getWorkflowRunJournalPath(runId) : void 0;
-    const journal = journalPath ? new WorkflowJournal(journalPath, storage.getWorkflowRunsDir()) : void 0;
-    let script;
-    let scriptPath;
-    let resumeReplay;
-    let persistedInlineScript = false;
-    let callerWasAbortedBeforeStart;
-    let orchestrator;
-    try {
-      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;
-      const workflowName = options.workflowName ?? loaded?.savedWorkflowName ?? registry?.get(runId)?.workflowName;
-      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;
-      assertStartNotCancelled();
-      callerWasAbortedBeforeStart = options.signal.aborted;
-      if (options.script !== void 0 && scriptPath === void 0) {
-        const persisted = await persistInlineWorkflowScript(
-          config,
-          runId,
-          script
-        );
-        scriptPath = persisted ?? void 0;
-        persistedInlineScript = persisted !== null;
-      }
-      if (journal && !await journal.ensureExists()) {
-        journalPath = void 0;
-      }
-      assertStartNotCancelled();
-      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,
-          ...workflowName ? { workflowName } : {},
-          meta: null,
-          status: "running",
-          startTime: Date.now(),
-          outputFile: "",
-          abortController: controller,
-          tokenBudgetTotal: budget.total,
-          script,
-          scriptPath,
-          ...journalPath ? { journalPath } : {},
-          args: options.args,
-          ...options.resumeFromRunId ? {
-            sourceRunId: options.resumeFromRunId,
-            startMode: "retry"
-          } : {},
-          isBackgrounded: runInBackground,
-          resumeInBackground: runInBackground && config.isInteractive?.() === true && config.getExperimentalZedIntegration?.() !== true
-        },
-        controller
-      );
-    } catch (error) {
-      registry?.releaseStart(runId, controller);
-      controller.abort();
-      if (persistedInlineScript && options.resumeFromRunId === void 0) {
-        await deleteInlineWorkflowScript(config, runId);
-      }
-      if (persistedInlineScript && options.resumeFromRunId && previousEntry) {
-        await persistInlineWorkflowScript(config, runId, previousEntry.script);
-      }
-      if (options.resumeFromRunId === void 0) {
-        await journal?.remove();
-      }
-      releasePersistenceActivity();
-      throw error;
-    }
-    const emitUpdate = /* @__PURE__ */ __name(() => {
-      if (!entry || !options.onUpdate || !isCurrentEntry()) return;
-      try {
-        options.onUpdate(entry);
-      } catch {
-      }
-    }, "emitUpdate");
-    const emitter = {
-      phaseStarted: /* @__PURE__ */ __name((title) => {
-        if (!isCurrentEntry()) return;
-        registry?.onPhaseStarted(runId, title);
-        emitUpdate();
-      }, "phaseStarted"),
-      agentDispatched: /* @__PURE__ */ __name(() => {
-        if (!isCurrentEntry()) return;
-        registry?.onAgentDispatched(runId);
-        emitUpdate();
-      }, "agentDispatched"),
-      agentCompleted: /* @__PURE__ */ __name(() => {
-        if (!isCurrentEntry()) return;
-        registry?.onAgentCompleted(runId);
-      }, "agentCompleted"),
-      dispatchQueued: /* @__PURE__ */ __name((event) => {
-        if (!isCurrentEntry()) return;
-        registry?.onDispatchQueued(runId, event);
-        emitUpdate();
-      }, "dispatchQueued"),
-      dispatchStarted: /* @__PURE__ */ __name((dispatchId, startedAt) => {
-        if (!isCurrentEntry()) return;
-        registry?.onDispatchStarted(runId, dispatchId, startedAt);
-        emitUpdate();
-      }, "dispatchStarted"),
-      dispatchSettled: /* @__PURE__ */ __name((dispatchId, error, endedAt) => {
-        if (!isCurrentEntry()) return;
-        registry?.onDispatchSettled(
-          runId,
-          dispatchId,
-          error,
-          endedAt,
-          !runInBackground && options.signal.aborted
-        );
-        emitUpdate();
-      }, "dispatchSettled"),
-      // The registry records this without firing a status update, avoiding a
-      // TUI redraw per line while retaining the real replay timestamp.
-      logAppended: /* @__PURE__ */ __name((line) => {
-        if (!isCurrentEntry()) return;
-        registry?.onLogAppended(runId, line);
-      }, "logAppended"),
-      budgetUpdated: /* @__PURE__ */ __name((spent, total) => {
-        if (!isCurrentEntry()) return;
-        registry?.onBudgetUpdated(runId, spent, total);
-        emitUpdate();
-      }, "budgetUpdated"),
-      resumeRespawn: /* @__PURE__ */ __name((line) => {
-        if (!isCurrentEntry()) return;
-        registry?.onResumeRespawn(runId, line);
-        emitUpdate();
-      }, "resumeRespawn")
-    };
-    const scheduler = new WorkflowDispatchScheduler(
-      resolveConcurrencyLimit(),
-      controller.signal,
-      ({ state }) => {
-        if (!isCurrentEntry()) return;
-        registry?.onDispatchStateChange(runId, state);
-      }
-    );
-    const handle = new WorkflowRunHandle(
-      runId,
-      budget,
-      registry,
-      controller,
-      scheduler,
-      async () => {
-        try {
-          const outcome = await orchestrator.run({
-            script,
-            args: options.args,
-            abortOnTimeout: controller,
-            runId,
-            emitter,
-            budget,
-            resolveSavedWorkflow: /* @__PURE__ */ __name((ref) => resolveSavedWorkflowScript(ref, config), "resolveSavedWorkflow"),
-            journal,
-            resumeReplay,
-            scheduler
-          });
-          if (entry) {
-            entry.meta = outcome.meta;
-            if (outcome.meta?.name && entry.description === runId) {
-              entry.description = outcome.meta.name;
-            }
-          }
-          registry?.setRecentLogs(runId, outcome.logs);
-          if (entry && isTerminalWorkflowStatus(entry.status)) {
-            return {
-              ok: false,
-              message: entry.status === "cancelled" ? "Workflow run cancelled." : entry.error ?? "Workflow run failed."
-            };
-          }
-          registry?.complete(runId, outcome.result, Date.now());
-          return { ok: true, outcome };
-        } catch (error) {
-          const details = error instanceof WorkflowExecutionError ? error : void 0;
-          const message = extractErrorMessage2(error);
-          if (entry && details?.meta && !entry.meta) entry.meta = details.meta;
-          if (details?.logs) registry?.setRecentLogs(runId, details.logs);
-          if (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());
-          }
-          return { ok: false, message, details };
-        } finally {
-          controller.abort();
-          if (entry && isTerminalWorkflowStatus(entry.status)) {
-            const telemetryEvent = new WorkflowRunEvent({
-              status: entry.status,
-              agents_dispatched: entry.agentsDispatched,
-              agents_completed: entry.agentsCompleted,
-              // Read off the dispatch traces rather than the counters: a
-              // dispatch that failed or replayed from cache still counts as
-              // completed, so without these three a run that lost half its
-              // fan-out and one that lost none report identically.
-              agents_failed: entry.dispatches.reduce(
-                (n, dispatch) => dispatch.status === "failed" ? n + 1 : n,
-                0
-              ),
-              agents_cached: entry.dispatches.reduce(
-                (n, dispatch) => dispatch.status === "cached" ? n + 1 : n,
-                0
-              ),
-              agents_respawned: entry.agentsRespawned ?? 0,
-              phase_count: entry.phases.length,
-              tokens_spent: entry.tokensSpent,
-              duration_ms: (entry.endTime ?? entry.startTime) - entry.startTime
-            });
-            const snapshotPersisted = await writeWorkflowSnapshot(
-              config,
-              entry
-            );
-            if (snapshotPersisted) {
-              registry?.notifySnapshotPersisted(entry.runId);
-            }
-            await journal?.drain();
-            try {
-              logWorkflowRun(config, telemetryEvent);
-            } catch {
-            }
-          }
-          releasePersistenceActivity();
-          registry?.releaseHandle(runId, handle);
-        }
-      },
-      {
-        ...scriptPath ? { scriptPath } : {},
-        ...journalPath ? { journalPath } : {}
-      }
-    );
-    registry?.attachHandle(handle);
-    return handle;
-  }
-};
-function extractErrorMessage2(error) {
-  if (error && typeof error === "object" && "message" in error) {
-    const message = error.message;
-    if (typeof message === "string") return message;
-    return String(message);
-  }
-  return String(error);
-}
-__name(extractErrorMessage2, "extractErrorMessage");
-
-// packages/core/src/tools/workflow/workflow.ts
-import { promises as fs2 } from "node:fs";
-import * as path2 from "node:path";
-var WORKFLOW_PARAM_SCHEMA = {
-  type: "object",
-  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.`
-    },
-    scriptPath: {
-      type: "string",
-      description: "Optional. Absolute path to a workflow `.js` file to load and run instead of inline `script`. Primarily set by the `/<name>` saved-workflow slash command; a tool that generated a script for this run hands you its path the same way. The file must resolve inside a saved-workflow directory (`.qwen/workflows`, `~/.qwen/workflows`) or the generated-scripts root (`$QWEN_CODE_PROJECT_DIR/workflows/generated` \u2014 the per-project runtime dir, not the project tree) \u2014 any other path is refused. Provide exactly ONE of `script` or `scriptPath`. The file is read at execution time, so edits to a saved workflow take effect on the next run. An inline `script` is persisted to `<generated root>/inline/<runId>.js` and that path comes back in the result, so a resume passes the path instead of the source."
-    },
-    args: {
-      description: "Optional structured value bound to the `args` global. Pass actual JSON, not a stringified value."
-    },
-    resumeFromRunId: {
-      type: "string",
-      description: "Optional. Resume a prior workflow run by id (e.g. wf_abc123\u2026). Re-runs the supplied script or returned script path; agent() calls whose rolling prefix-hash (prompt + opts, chained in call order) matches a journaled result are served from cache for the longest unchanged prefix, and the first changed/missing call onward runs live. Pass the `scriptPath` the original run returned and the same `args`. Editing a saved workflow changes future runs too, so copy it for run-specific edits. Replay requires a journal; without one, every agent() call runs live. The journal keys hash each agent() call's prompt and opts, not the script text, so post-processing can change without losing the cache."
-    },
-    run_in_background: {
-      type: "boolean",
-      default: false,
-      description: "Optional. When true, start the workflow under the interactive session and return a run handle immediately. The Background Tasks view can observe, cooperatively pause/resume, or stop it, and completion is delivered to the conversation when the run settles. Interactive TUI only. Defaults to false."
-    }
-  }
-  // `script` is required UNLESS `scriptPath` is supplied; this XOR can't be
-  // expressed as a plain `required` list, so it's enforced in
-  // `validateToolParamValues`. Inline authoring (the LLM path) should always
-  // pass `script`; the `scriptPath` property description states the XOR.
-};
-var WorkflowToolInvocation = class extends BaseToolInvocation {
-  constructor(config, toolOptions, params, workflowName) {
-    super(params);
-    this.config = config;
-    this.toolOptions = toolOptions;
-    this.workflowName = workflowName;
-  }
-  static {
-    __name(this, "WorkflowToolInvocation");
-  }
-  callId;
-  setCallId(callId) {
-    this.callId = callId;
-  }
-  /**
-   * Cache so the transcript header and the approval dialog cannot disagree,
-   * and so an oversized script is scanned once per invocation rather than
-   * once per surface that asks.
-   */
-  metaCache;
-  resolveMeta() {
-    if (this.metaCache === void 0) {
-      this.metaCache = this.params.script ? readMetaForConfirmation(this.params.script) : null;
-    }
-    return this.metaCache;
-  }
-  getDescription() {
-    const meta = this.resolveMeta();
-    if (meta) {
-      return `Run workflow: ${sanitizeLine(meta.name)}`;
-    }
-    if (this.params.scriptPath && this.params.script === void 0) {
-      const kind = isGeneratedWorkflowScriptPath(
-        this.config,
-        this.params.scriptPath
-      ) ? "generated workflow script" : "saved workflow";
-      return `Run ${kind} (${path2.basename(this.params.scriptPath)})`;
-    }
-    return `Run a workflow script (${this.params.script?.length ?? 0} chars)`;
-  }
-  toolLocations() {
-    return [];
-  }
-  getDefaultPermission() {
-    return Promise.resolve("ask");
-  }
-  /**
-   * Show what is about to run, and scope the grant that approves it.
-   *
-   * Without this override the base class renders `Confirm WorkflowTool` over
-   * `Run a workflow script (4127 chars)` — a character count standing in for
-   * arbitrary model-authored JavaScript that may fan out to
-   * `DEFAULT_MAX_AGENTS_PER_RUN` subagents, provision git worktrees and spend
-   * an uncapped token budget. The asymmetry is visible within one run: the
-   * subagent approvals this workflow bubbles up each get a full dialog.
-   *
-   * Two properties of the grant matter as much as the disclosure:
-   *
-   *   - An inline `script` can never be pre-approved. It is fresh
-   *     model-authored source every time, so a blanket "always allow" would
-   *     transfer consent from the script the user read to every script the
-   *     model writes afterwards. `hideAlwaysAllow` removes the option and the
-   *     empty `permissionRules` stops `injectPermissionRulesIfMissing` from
-   *     supplying the bare-tool-name rule, which `buildPermissionRules`
-   *     documents as matching *all* invocations.
-   *   - A `scriptPath` names a file on disk that the user chose, so it can be
-   *     pre-approved — but scoped to that path. The rule is built with the
-   *     same helpers the matcher uses so a tool rename moves both sides.
-   */
-  async getConfirmationDetails(_abortSignal) {
-    const meta = this.resolveMeta();
-    const isGeneratedScriptPath = this.params.scriptPath !== void 0 && await isGeneratedWorkflowScriptPathCanonical(
-      this.config,
-      this.params.scriptPath
-    );
-    const isGeneratedInlineScriptPath = this.params.scriptPath !== void 0 && await isWorkflowScriptPathWithinCanonicalRoot(
-      this.params.scriptPath,
-      path2.dirname(this.config.storage.getInlineWorkflowScriptPath("wf_0"))
-    );
-    const body = buildConfirmationPrompt(
-      this.params,
-      meta,
-      isGeneratedScriptPath
-    );
-    const banner = resolveUsageBanner(
-      this.config,
-      this.config.getWorkflowRunRegistry?.(),
-      resolveMaxTokensPerWorkflow()
-    );
-    const isInlineScript = this.params.script !== void 0 || isGeneratedInlineScriptPath;
-    const details = {
-      type: "info",
-      title: "Run a dynamic workflow?",
-      prompt: banner ? `${banner}${body}` : body,
-      // The body is a script excerpt and a phase list: rendering it as
-      // Markdown would swallow the very characters the reader needs to see.
-      renderPromptAsPlainText: true,
-      hideAlwaysAllow: isInlineScript,
-      permissionRules: isInlineScript ? [] : [
-        `${getRuleDisplayName(resolveToolName(ToolNames.WORKFLOW))}(scriptPath:${this.params.scriptPath})`
-      ],
-      onConfirm: /* @__PURE__ */ __name(async (_outcome, _payload) => {
-      }, "onConfirm")
-    };
-    return details;
-  }
-  async execute(signal, updateOutput, _shellExecutionConfig) {
-    const runInBackground = this.params.run_in_background === true;
-    if (runInBackground && signal.aborted) {
-      return startCancelledResult();
-    }
-    let handle;
-    try {
-      handle = await WorkflowRunner.start({
-        config: this.config,
-        signal,
-        toolUseId: this.callId,
-        ...this.workflowName ? { workflowName: this.workflowName } : {},
-        script: this.params.script,
-        scriptPath: this.params.scriptPath,
-        args: this.params.args,
-        resumeFromRunId: this.params.resumeFromRunId,
-        dispatch: this.toolOptions.dispatch,
-        runInBackground,
-        onUpdate: !runInBackground && updateOutput ? (entry) => safeEmitUpdate(updateOutput, entry) : void 0
-      });
-    } catch (error) {
-      if (error instanceof WorkflowStartCancelledError || runInBackground && signal.aborted) {
-        return startCancelledResult();
-      }
-      if (error instanceof WorkflowScriptNotLaunchedError) {
-        return {
-          llmContent: [{ text: error.message }],
-          returnDisplay: error.message,
-          error: {
-            message: error.message,
-            type: "invalid_tool_params" /* INVALID_TOOL_PARAMS */
-          }
-        };
-      }
-      throw error;
-    }
-    if (runInBackground) {
-      const status = handle.registry?.get(handle.runId)?.status ?? "running";
-      const usageBanner = resolveUsageBanner(
-        this.config,
-        handle.registry,
-        handle.budget.total
-      );
-      return {
-        workflowRunId: handle.runId,
-        ...handle.scriptPath ? { scriptPath: handle.scriptPath } : {},
-        ...handle.journalPath ? { journalPath: handle.journalPath } : {},
-        llmContent: [
-          {
-            text: buildBackgroundStartText(handle, status)
-          }
-        ],
-        returnDisplay: usageBanner + `Workflow ${handle.runId} started in the background (status: ${status}). Use Background Tasks to observe, cooperatively pause/resume, or stop it.`
-      };
-    }
-    const settlement = await handle.completion;
-    if (settlement.ok) {
-      const { outcome } = settlement;
-      const usageBanner = resolveUsageBanner(
-        this.config,
-        handle.registry,
-        handle.budget.total
-      );
-      const llmText = safeStringifyResult(outcome.result);
-      const displayJson = safeStringifyDisplayPayload({
-        runId: outcome.runId,
-        ...outcome.meta ? { meta: outcome.meta } : {},
-        phases: outcome.phases,
-        logs: outcome.logs,
-        result: outcome.result,
-        // P5: surface the per-run token total in the terminal display so
-        // the user sees actual usage even without opening the dialog.
-        // P5 R1 (#11): align with `buildLivePhaseTreeDisplay` — include
-        // tokens whenever ANY usage is reported OR a cap is set, not
-        // only when spend > 0. A capped-but-zero-spend run still wants
-        // the cap visible so the user sees the gate engaged.
-        ...handle.budget.spent() > 0 || handle.budget.total !== null ? {
-          tokens: {
-            spent: handle.budget.spent(),
-            total: handle.budget.total
-          }
-        } : {}
-      });
-      return {
-        ...handle.scriptPath ? { scriptPath: handle.scriptPath } : {},
-        ...handle.journalPath ? { journalPath: handle.journalPath } : {},
-        // Two parts: the script's return value is left exactly as it was,
-        // and the run handle follows as a separate part. Note what this does
-        // NOT mean — `convertToFunctionResponse` joins the text parts with a
-        // newline, so the model reads `<return value>\n--- workflow run ---…`
-        // as one string. Keeping them apart is still what makes the return
-        // value untouched at the tool boundary, keeps `returnDisplay` clean,
-        // and gives the per-tool head/tail truncator a distinct trailer part.
-        // The scheduler-wide persistence gate may still fold both parts into
-        // one head-only preview when their combined text crosses its limit.
-        llmContent: [
-          { text: llmText },
-          { text: buildRunTrailer(this.config, handle, this.params.args) }
-        ],
-        returnDisplay: usageBanner + "```json\n" + displayJson + "\n```"
-      };
-    } else {
-      const { message, details } = settlement;
-      const { phases, logs, meta } = details ?? {};
-      const cancelled = handle.registry?.get(handle.runId)?.status === "cancelled";
-      const failureText = cancelled ? "Workflow cancelled." : `Workflow failed: ${clampForDisplay(
-        sanitizeBlock(message),
-        TRAILER_ERROR_CHARS
-      )}`;
-      const trailer = buildRunTrailer(
-        this.config,
-        handle,
-        this.params.args,
-        logs,
-        !cancelled
-      );
-      const display = `${cancelled ? "Workflow cancelled." : `Workflow failed: ${message}`}
-
-${safeStringifyDisplayPayload(
-        {
-          runId: handle.runId,
-          ...meta ? { meta } : {},
-          phases: phases ?? [],
-          logs: logs ?? []
-        }
-      )}`;
-      return {
-        ...handle.scriptPath ? { scriptPath: handle.scriptPath } : {},
-        ...handle.journalPath ? { journalPath: handle.journalPath } : {},
-        // The failure message alone names what threw but not where to look:
-        // the logs the runtime already mirrored (`dispatch failed (result not
-        // consumed)` and friends) only reached `returnDisplay`, which the
-        // scheduler overwrites with `error.message` — so the model never saw
-        // them. Mirror the two content parts into the error message because
-        // that is the only text the non-timeout scheduler branch delivers.
-        llmContent: [{ text: failureText }, { text: trailer }],
-        returnDisplay: display,
-        // FIX-10 (REUSE-I1): use the standard ToolErrorType.EXECUTION_FAILED
-        // code so error routing / dashboards can classify workflow failures
-        // the same way as other execution-time tool errors.
-        error: {
-          message: `${failureText}
-${trailer}`,
-          type: "execution_failed" /* EXECUTION_FAILED */
-        }
-      };
-    }
-  }
-};
-var TRAILER_LOG_LINES = 20;
-var TRAILER_LOG_LINE_CHARS = 400;
-var TRAILER_ERROR_CHARS = 4e3;
-function buildRunTrailer(config, handle, args, logs, includeResume = true) {
-  const lines = [
-    "--- workflow run ---",
-    `runId: ${sanitizeLine(handle.runId)}`
-  ];
-  if (handle.scriptPath) {
-    lines.push(`script: ${sanitizeLine(handle.scriptPath)}`);
-  }
-  if (handle.journalPath) {
-    lines.push(`journal: ${sanitizeLine(handle.journalPath)}`);
-  }
-  const entry = handle.registry?.get(handle.runId);
-  let failedCount = 0;
-  if (entry) {
-    const countByStatus = /* @__PURE__ */ __name((status) => entry.dispatches.reduce(
-      (n, dispatch) => dispatch.status === status ? n + 1 : n,
-      0
-    ), "countByStatus");
-    const respawned = entry.agentsRespawned ?? 0;
-    failedCount = countByStatus("failed");
-    lines.push(
-      `agents: ${entry.dispatches.length} dispatched` + (respawned > 0 ? ` (${respawned} re-ran from a prior run)` : "") + ` \xB7 ${countByStatus("completed")} completed \xB7 ${countByStatus("cached")} cached \xB7 ${failedCount} failed \xB7 ${countByStatus("cancelled")} cancelled`
-    );
-  }
-  const spent = handle.budget.spent();
-  lines.push(
-    handle.budget.total === null ? `tokens: ${spent} spent (no cap)` : `tokens: ${spent} / ${handle.budget.total} spent`
-  );
-  const failures = entry ? buildFailureLines(entry) : [];
-  if (failures.length > 0 && entry) {
-    lines.push(
-      `failures (${failedCount}):`,
-      ...failures.map(
-        (line) => clampForDisplay(sanitizeLine(line), TRAILER_LOG_LINE_CHARS)
-      )
-    );
-  }
-  const resume = buildResumeCall({
-    runId: handle.runId,
-    scriptPath: handle.scriptPath,
-    args
-  });
-  if (resume && includeResume) {
-    const pathAdvice = entry?.workflowName || !isGeneratedWorkflowScriptPath(config, handle.scriptPath) ? "this reads the saved workflow; copy it before making a run-specific change" : "edit that generated copy first if the script needs to change";
-    const journalAdvice = handle.journalPath ? "the journal replays the longest unchanged prefix of agent() calls, and the first changed call onward runs live" : "no journal was written for this run, so every agent() call runs live";
-    lines.push(`resume: ${resume} \u2014 ${pathAdvice}; ${journalAdvice}.`);
-    if (hasUninlinableResumeArgs({ runId: handle.runId, args })) {
-      lines.push(RESUME_ARGS_TOO_LARGE_NOTE);
-    }
-  }
-  const tail = (logs ?? []).slice(-TRAILER_LOG_LINES);
-  if (tail.length > 0) {
-    lines.push(
-      `logs (last ${tail.length}):`,
-      ...tail.map(
-        (line) => clampForDisplay(sanitizeLine(line), TRAILER_LOG_LINE_CHARS)
-      )
-    );
-  }
-  return lines.join("\n");
-}
-__name(buildRunTrailer, "buildRunTrailer");
-function buildBackgroundStartText(handle, status) {
-  const lines = [
-    "Workflow started in background.",
-    `Run ID: ${sanitizeLine(handle.runId)}`,
-    `Status: ${sanitizeLine(status)}`
-  ];
-  if (handle.scriptPath) {
-    lines.push(`Script file: ${sanitizeLine(handle.scriptPath)}`);
-  }
-  if (handle.journalPath) {
-    lines.push(`Journal: ${sanitizeLine(handle.journalPath)}`);
-  }
-  lines.push(
-    `You will be notified when it settles. Use /workflows ${sanitizeLine(handle.runId)} for the live phase tree.`
-  );
-  return lines.join("\n");
-}
-__name(buildBackgroundStartText, "buildBackgroundStartText");
-function startCancelledResult() {
-  return {
-    llmContent: "Workflow was cancelled before it could start.",
-    returnDisplay: "Workflow cancelled."
-  };
-}
-__name(startCancelledResult, "startCancelledResult");
-function buildLivePhaseTreeDisplay(entry) {
-  const payload = {
-    runId: entry.runId,
-    ...entry.meta ? { meta: entry.meta } : {},
-    status: entry.status,
-    currentPhase: entry.currentPhase,
-    phases: entry.phases,
-    agentsDispatched: entry.agentsDispatched,
-    agentsCompleted: entry.agentsCompleted
-  };
-  if (entry.tokensSpent > 0 || entry.tokenBudgetTotal !== null) {
-    payload["tokens"] = {
-      spent: entry.tokensSpent,
-      total: entry.tokenBudgetTotal
-    };
-  }
-  try {
-    return "```json\n" + JSON.stringify(payload, null, 2) + "\n```";
-  } catch {
-    return `Workflow ${entry.runId} \u2014 ${entry.status} \u2014 ${entry.phases.length} phase(s)`;
-  }
-}
-__name(buildLivePhaseTreeDisplay, "buildLivePhaseTreeDisplay");
-function resolveUsageBanner(config, registry, budgetTotal) {
-  if (!registry) return "";
-  if (config.getSkipWorkflowUsageWarning?.()) return "";
-  if (!registry.shouldShowUsageWarning()) return "";
-  return buildUsageBanner(budgetTotal);
-}
-__name(resolveUsageBanner, "resolveUsageBanner");
-var CONFIRM_SCRIPT_EXCERPT_CHARS = 1200;
-var CONFIRM_ARGS_CHARS = 300;
-var CONFIRM_MAX_PHASES = 12;
-function sanitizeLine(text) {
-  return stripAnsiAndControl(text);
-}
-__name(sanitizeLine, "sanitizeLine");
-function sanitizeBlock(text) {
-  return text.replace(/\t/g, "  ").split("\n").map((line) => stripAnsiAndControl(line)).join("\n");
-}
-__name(sanitizeBlock, "sanitizeBlock");
-function clampForDisplay(text, max) {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max)}
-\u2026 (${text.length - max} more characters)`;
-}
-__name(clampForDisplay, "clampForDisplay");
-function readMetaForConfirmation(script) {
-  try {
-    return extractAndStripMeta(script).meta;
-  } catch {
-    return null;
-  }
-}
-__name(readMetaForConfirmation, "readMetaForConfirmation");
-function isGeneratedWorkflowScriptPath(config, scriptPath) {
-  return isWithinRoot(scriptPath, config.storage.getGeneratedWorkflowsDir());
-}
-__name(isGeneratedWorkflowScriptPath, "isGeneratedWorkflowScriptPath");
-async function isGeneratedWorkflowScriptPathCanonical(config, scriptPath) {
-  return isWorkflowScriptPathWithinCanonicalRoot(
-    scriptPath,
-    config.storage.getGeneratedWorkflowsDir()
-  );
-}
-__name(isGeneratedWorkflowScriptPathCanonical, "isGeneratedWorkflowScriptPathCanonical");
-async function isWorkflowScriptPathWithinCanonicalRoot(scriptPath, root) {
-  if (await isSymlinkedRoot(root)) return false;
-  let realScriptPath;
-  try {
-    realScriptPath = await fs2.realpath(scriptPath);
-  } catch {
-    return isWithinRoot(scriptPath, root);
-  }
-  let realRoot;
-  try {
-    realRoot = await fs2.realpath(root);
-  } catch {
-    realRoot = path2.resolve(root);
-  }
-  return isWithinRoot(realScriptPath, realRoot);
-}
-__name(isWorkflowScriptPathWithinCanonicalRoot, "isWorkflowScriptPathWithinCanonicalRoot");
-function buildConfirmationPrompt(params, meta, isGeneratedScriptPath) {
-  const lines = [];
-  if (meta) {
-    lines.push(`Workflow: ${sanitizeLine(meta.name)}`);
-    lines.push(sanitizeLine(meta.description));
-  } else if (params.scriptPath) {
-    const label = isGeneratedScriptPath ? "Generated workflow script" : "Saved workflow";
-    lines.push(`${label}: ${sanitizeLine(params.scriptPath)}`);
-  } else {
-    lines.push("Workflow: (the script declares no meta block)");
-  }
-  if (meta?.phases?.length) {
-    const shown = meta.phases.slice(0, CONFIRM_MAX_PHASES);
-    lines.push("", `Phases (${meta.phases.length}):`);
-    shown.forEach((phase, i) => {
-      const detail = phase.detail ? ` \u2014 ${sanitizeLine(phase.detail)}` : "";
-      lines.push(`  ${i + 1}. ${sanitizeLine(phase.title)}${detail}`);
-    });
-    if (meta.phases.length > shown.length) {
-      lines.push(`  \u2026 and ${meta.phases.length - shown.length} more`);
-    }
-  }
-  if (params.scriptPath && meta) {
-    lines.push("", `Loaded from: ${sanitizeLine(params.scriptPath)}`);
-  }
-  if (params.resumeFromRunId) {
-    lines.push("", `Resuming run: ${sanitizeLine(params.resumeFromRunId)}`);
-  }
-  if (params.args !== void 0) {
-    let rendered;
-    try {
-      rendered = JSON.stringify(params.args) ?? String(params.args);
-    } catch {
-      rendered = "(args are not JSON-serializable)";
-    }
-    lines.push(
-      "",
-      `Args: ${clampForDisplay(sanitizeLine(rendered), CONFIRM_ARGS_CHARS)}`
-    );
-  }
-  if (params.script) {
-    lines.push(
-      "",
-      "Script:",
-      clampForDisplay(
-        sanitizeBlock(params.script),
-        CONFIRM_SCRIPT_EXCERPT_CHARS
-      )
-    );
-  }
-  return lines.join("\n");
-}
-__name(buildConfirmationPrompt, "buildConfirmationPrompt");
-function buildUsageBanner(total) {
-  if (total === null) {
-    return `> Workflows have no per-run token cap. Set \`${MAX_TOKENS_PER_WORKFLOW_ENV}=<n>\` (env) for a soft cap. Suppress this notice with \`skipWorkflowUsageWarning: true\` in settings.
-
-`;
-  }
-  return `> Workflow token cap is ${total} (per \`${MAX_TOKENS_PER_WORKFLOW_ENV}\`). Suppress this notice with \`skipWorkflowUsageWarning: true\` in settings.
-
-`;
-}
-__name(buildUsageBanner, "buildUsageBanner");
-function safeEmitUpdate(updateOutput, entry) {
-  if (!updateOutput || !entry) return;
-  try {
-    updateOutput(buildLivePhaseTreeDisplay(entry));
-  } catch {
-  }
-}
-__name(safeEmitUpdate, "safeEmitUpdate");
-function safeStringifyResult(result) {
-  if (result === void 0) return "(workflow returned no value)";
-  if (typeof result === "string") return result;
-  try {
-    return JSON.stringify(result, null, 2);
-  } catch {
-    return `(workflow returned a non-JSON-serializable value of type ${typeof result})`;
-  }
-}
-__name(safeStringifyResult, "safeStringifyResult");
-function safeStringifyDisplayPayload(payload) {
-  try {
-    return JSON.stringify(payload, null, 2);
-  } catch {
-    if (payload && typeof payload === "object") {
-      const sanitized = {};
-      for (const [key, value] of Object.entries(payload)) {
-        try {
-          JSON.stringify(value);
-          sanitized[key] = value;
-        } catch {
-          sanitized[key] = `(non-JSON-serializable value of type ${typeof value})`;
-        }
-      }
-      try {
-        return JSON.stringify(sanitized, null, 2);
-      } catch {
-      }
-    }
-    return "(display payload not JSON-serializable)";
-  }
-}
-__name(safeStringifyDisplayPayload, "safeStringifyDisplayPayload");
-var WORKFLOW_TOOL_DESCRIPTION = `Execute a workflow script that orchestrates subagents deterministically.
-
-**Only on an explicit request**
-
-Do not call this tool unless the user has asked for multi-agent orchestration. A run can dispatch up to ${DEFAULT_MAX_AGENTS_PER_RUN} subagents and spend tokens accordingly, so that scale has to be requested rather than inferred. It counts as requested when any of these holds:
-
-- The user's message contains the word \`workflow\`; a system reminder confirms it when it does.
-- The user asked for orchestration in their own words \u2014 run a workflow, fan out agents, orchestrate this with subagents.
-- A skill or slash command the user invoked instructs you to use this tool.
-- The user named a saved workflow to run, reached through \`workflow('<name>')\` or \`scriptPath\`.
-- The user asked to resume or continue an earlier run, which is \`resumeFromRunId\`.
-
-Otherwise do not call it, however well the task would parallelize. Do the work in the main loop, or spawn a single subagent for one self-contained piece. When a workflow would genuinely be the better tool, say in one sentence what it would fan out over and roughly how many agents that is, then let the user decide \u2014 and mention that including the word \`workflow\` next time skips the ask.
-
-**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**
-
-The strongest pattern is hybrid: discover the work list in the main loop (list the files, scope the diff, read the failing test), then hand that list to a workflow. You do not need to know the shape of the work before the task \u2014 only before the orchestration step. When the work has distinct phases, run several small workflows across turns and read each result before choosing the next, rather than authoring one large script that runs unattended.
-
-Common single-phase shapes: understand (parallel readers over subsystems, merged into one map), design (independent approaches, judged, then synthesized), review (dimensions, find, verify each finding), research (broad sweep, deep read, synthesis), migrate (discover sites, transform each under \`isolation: 'worktree'\`, verify).
-
-**Default to \`pipeline()\`**
-
-\`pipeline()\` runs each item through every stage independently \u2014 item A can be in stage 3 while item B is still in stage 1 \u2014 so wall-clock is the slowest single chain. \`parallel()\` is a barrier: it waits for every thunk before anything moves on, so it costs the slowest item of every stage.
-
-A barrier is right only when a stage genuinely needs cross-item context: deduplicating or merging across the full result set before expensive downstream work, exiting early when the total count is zero, or a prompt that compares one finding against all the others. It is not justified by needing to flatten, map, or filter between stages (do that inside a pipeline stage), by two stages being conceptually separate, or by the code reading more tidily. Smell test: \`parallel()\` \u2192 a pure transform \u2192 \`parallel()\` is a pipeline someone wrote with an unnecessary barrier. When in doubt, \`pipeline()\`.
-
-**Verify before believing**
-
-A subagent's answer is a claim, not a result. For findings that matter, spawn independent verifiers prompted to *refute*, and drop what a majority refutes. When a claim can be wrong in several different ways, give each verifier a distinct lens (correctness, security, performance, does it actually reproduce) \u2014 diversity catches what repetition cannot. For a wide solution space, generate several independent attempts, judge them in parallel, and synthesize from the winner while grafting the best ideas from the rest.
-
-**Converge deliberately**
-
-For discovery of unknown size, keep running finders until some number of consecutive rounds turn up nothing new; a fixed round count stops partway into the tail. Deduplicate each round against everything already seen, never against only what survived judging \u2014 otherwise rejected findings reappear every round and the loop never terminates. A closing pass that asks what is still missing (a search angle never run, a claim never verified, a file never read) usually produces the next round of real work.
-
-**Report honestly**
-
-Scale the fleet to what was actually asked: a quick check gets a few agents and one verification pass; an explicit request to be thorough or exhaustive earns a larger pool and a multi-vote adversarial round. Whenever a run bounds its own coverage \u2014 top-N, sampling, no retry \u2014 \`log()\` what was dropped. Silent truncation reads as full coverage, which is worse than a smaller honest result.
-
-These shapes are a starting point, not a menu; compose the harness the task actually needs.`;
-var WorkflowTool = class extends BaseDeclarativeTool {
-  constructor(config, toolOptions = {}) {
-    super(
-      ToolNames.WORKFLOW,
-      ToolDisplayNames.WORKFLOW,
-      WORKFLOW_TOOL_DESCRIPTION,
-      "other" /* Other */,
-      WORKFLOW_PARAM_SCHEMA,
-      /* isOutputMarkdown */
-      true,
-      /* canUpdateOutput */
-      true
-    );
-    this.config = config;
-    this.toolOptions = toolOptions;
-  }
-  static {
-    __name(this, "WorkflowTool");
-  }
-  buildSessionOwnedBackground(params, workflowName) {
-    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 new WorkflowToolInvocation(
-      this.config,
-      this.toolOptions,
-      { ...params, run_in_background: true },
-      workflowName
-    );
-  }
-  validateToolParamValues(params) {
-    const hasScript = typeof params.script === "string" && params.script.length > 0;
-    const hasPath = typeof params.scriptPath === "string" && params.scriptPath.length > 0;
-    if (!hasScript && !hasPath) {
-      return "WorkflowTool: provide `script` (inline source) or `scriptPath` (a workflow script file).";
-    }
-    if (hasScript && hasPath) {
-      return "WorkflowTool: provide exactly one of `script` or `scriptPath`, not both.";
-    }
-    if (params.resumeFromRunId !== void 0 && !/^wf_[0-9a-f]+$/.test(params.resumeFromRunId)) {
-      return "WorkflowTool: `resumeFromRunId` must match the generated id format `wf_<hex>`.";
-    }
-    if (params.run_in_background === true) {
-      if (!this.config.isInteractive() || this.config.getExperimentalZedIntegration?.() === true) {
-        return "WorkflowTool: `run_in_background` is available only in the interactive TUI.";
-      }
-      if (!this.config.getWorkflowRunRegistry().hasCompletionCallback()) {
-        return "WorkflowTool: `run_in_background` requires an active workflow completion channel.";
-      }
-    }
-    return null;
-  }
-  createInvocation(params) {
-    return new WorkflowToolInvocation(this.config, this.toolOptions, params);
-  }
-};
-export {
-  WorkflowTool
-};
-/**
- * @license
- * Copyright 2026 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */