@qwen-code/qwen-code 0.18.5-nightly.20260622.6bc3f853e → 0.19.0

package/chunks/{workflow-4RGAYFSJ.js → workflow-WUDNBCGX.js}

@@ -4,57 +4,67 @@ import {
   AgentEventEmitter,
   FileDiscoveryService,
   GitWorktreeService,
-  WorkspaceContext,
   generateAgentWorktreeSlug,
   rebuildToolRegistryOnOverride,
+  resolveSavedWorkflowScript,
   stripAnsiAndControl,
+  writeWorkflowSnapshot,
   writeWorktreeSessionMarker
-} from "./chunk-CXZV4Q4J.js";
+} from "./chunk-YF3ORUIU.js";
 import "./chunk-K5PGHDBN.js";
-import "./chunk-XU7BKR3B.js";
-import "./chunk-2O3NAOJG.js";
-import "./chunk-XGU3ETVO.js";
+import "./chunk-TXVGVZYR.js";
+import "./chunk-XU5P23GN.js";
+import "./chunk-2BIF2NVV.js";
+import "./chunk-57XRIZVC.js";
+import "./chunk-255L5QYW.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-C6MI2ASN.js";
-import "./chunk-LF6BKGZT.js";
-import "./chunk-26ZYKTYZ.js";
+import "./chunk-GZCJS5WH.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LD2XBG6Z.js";
-import "./chunk-ID533GA3.js";
-import "./chunk-KGV3F6UF.js";
-import "./chunk-77WXWU44.js";
-import "./chunk-AE6RQU6F.js";
-import "./chunk-GM3LTU6K.js";
+import "./chunk-OTBK43JR.js";
+import "./chunk-HGNSRCRB.js";
+import {
+  WorkspaceContext
+} from "./chunk-EEEZIVFJ.js";
+import "./chunk-PRYMDRBV.js";
+import {
+  WorkflowRunEvent,
+  logWorkflowRun,
+  read,
+  writeLine
+} from "./chunk-CICUTYTF.js";
 import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
-import "./chunk-FH4P6RQA.js";
-import "./chunk-CTHZVIMD.js";
+import "./chunk-BNXANYLH.js";
+import "./chunk-T2VDEFUU.js";
 import {
   SyntheticOutputTool
-} from "./chunk-VKILGMZQ.js";
+} from "./chunk-PO5LVPK3.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-GOMVJKBL.js";
-import "./chunk-MSJ2MXJ6.js";
-import "./chunk-ATLUHLZE.js";
+} from "./chunk-PLY4F7QW.js";
+import "./chunk-BGUDAULQ.js";
+import "./chunk-EW6C27XX.js";
+import "./chunk-22IFUCVR.js";
 import {
   createChildAbortController
 } from "./chunk-64WXLC72.js";
-import "./chunk-LTN3VYMZ.js";
-import "./chunk-42HGOMED.js";
-import "./chunk-G4BUMVEY.js";
+import "./chunk-3UALQ56H.js";
+import "./chunk-JDV3VBPY.js";
+import "./chunk-CGEGHF2C.js";
+import "./chunk-EJYJYJZ2.js";
 import "./chunk-55ZMG67I.js";
 import "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
 import {
   createDebugLogger
-} from "./chunk-WE6TNQJU.js";
+} from "./chunk-C4K3FEQ2.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -358,9 +368,11 @@ function createWorkflowSandbox(opts) {
     // init script without leaking the host function itself when not used.
     hasParallel: !!opts.parallel,
     hasPipeline: !!opts.pipeline,
+    hasWorkflow: !!opts.workflow,
     hasBudget: !!opts.budget,
     hostParallel: opts.parallel,
     hostPipeline: opts.pipeline,
+    hostWorkflow: opts.workflow,
     budgetTotal: opts.budget ? opts.budget.total : null,
     hostBudgetSpent: opts.budget ? opts.budget.spent.bind(opts.budget) : null,
     hostBudgetRemaining: opts.budget ? opts.budget.remaining.bind(opts.budget) : null
@@ -466,7 +478,7 @@ function createWorkflowSandbox(opts) {
       // FIX-Round1-T13: throw on any opts key not in the allowlist \u2014 catches
       // typos like { scema: ... } that previously slipped through the
       // [key:string]: unknown index signature.
-      const KNOWN_AGENT_OPTS = ['label', 'phase', 'schema', 'model', 'isolation', 'agentType'];
+      const KNOWN_AGENT_OPTS = ['label', 'phase', 'schema', 'model', 'isolation', 'agentType', 'stallMs'];
       globalThis.agent = vmAsync(function (prompt, agentOpts) {
         agentOpts = agentOpts || {};
         const keys = Object.keys(agentOpts);
@@ -639,15 +651,64 @@ function createWorkflowSandbox(opts) {
           });
         };
       }
-      // workflow() always throws in P1.
-      globalThis.workflow = function workflow() {
-        return new Promise(function (_, reject) {
-          reject(new Error(
-            'workflow() (nested workflow invocation) is not supported in P1. ' +
-            'Scheduled for a later phase.'
-          ));
+      // --- workflow (nested, single-level) ---
+      // Mirrors agent(): args cross vm\u2192host verbatim (safe direction), the
+      // single result is revived back into the vm realm via JSON round-trip
+      // (same T1/T8/T14 escape defense as agent / parallel / pipeline). The
+      // host impl resolves a saved workflow and runs it sharing this run's
+      // agent-count cap + token budget. When __b.hasWorkflow is false, the
+      // sandbox is either bare (no resolver wired) OR is itself a nested
+      // workflow \u2014 in both cases workflow() must throw, which is how the
+      // single-level nesting limit is enforced (a nested sandbox is created
+      // without a workflow impl, so its workflow() lands in the else branch).
+      if (__b.hasWorkflow) {
+        const callWorkflow = vmAsync(function (nameOrRef, wfArgs) {
+          // Sanitize args through a JSON round-trip BEFORE crossing so the
+          // host only ever sees vm-realm plain objects (same defense as
+          // agent()'s safeOpts). nameOrRef may be a string or {scriptPath}.
+          var safeRef;
+          var safeArgs;
+          try {
+            safeRef = nameOrRef === undefined
+              ? undefined
+              : JSON.parse(JSON.stringify(nameOrRef));
+            safeArgs = wfArgs === undefined
+              ? undefined
+              : JSON.parse(JSON.stringify(wfArgs));
+          } catch (e) {
+            throw new Error(
+              'workflow() received a non-JSON-serializable argument: ' +
+              String(e && e.message != null ? e.message : e)
+            );
+          }
+          return __b.hostWorkflow(safeRef, safeArgs).then(function (value) {
+            if (value === null || typeof value !== 'object') {
+              return value;
+            }
+            try {
+              return JSON.parse(JSON.stringify(value));
+            } catch (e) {
+              __b.logRevivalFailure(0, String(e && e.message != null ? e.message : e));
+              return null;
+            }
+          });
         });
-      };
+        globalThis.workflow = function workflow(nameOrRef, wfArgs) {
+          return callWorkflow(nameOrRef, wfArgs);
+        };
+      } else {
+        globalThis.workflow = function workflow() {
+          return new Promise(function (_, reject) {
+            reject(new Error(
+              "workflow() is unavailable here. Either this sandbox was created " +
+              "without a saved-workflow resolver, or this script is already " +
+              "running as a nested workflow \u2014 workflow() nesting is limited to " +
+              "a single level (a workflow cannot call another workflow that " +
+              "itself calls workflow())."
+            ));
+          });
+        };
+      }
 
       // --- budget ---
       const safeBudget = Object.create(null);
@@ -813,6 +874,231 @@ var WorkflowBudgetExceededError = class extends Error {
   }
 };
 
+// packages/core/src/agents/runtime/workflow-stall.ts
+init_esbuild_shims();
+var DEFAULT_STALL_MS = 6e4;
+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];
+  if (raw !== void 0 && raw.trim() !== "") {
+    const sec = Number(raw);
+    if (Number.isFinite(sec) && sec > 0) return sec * 1e3;
+    if (sec === 0) return 0;
+  }
+  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("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 Error(
+          `agent "${label ?? "workflow-agent"}" stalled on all ${MAX_STALL_ATTEMPTS} attempts (no progress for ${stallMs}ms each).`
+        );
+      }
+      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";
+var debugLogger4 = createDebugLogger("WORKFLOW_JOURNAL");
+var JOURNAL_KEY_VERSION = "v2";
+function canonicalizeAgentOpts(opts) {
+  const projected = {};
+  for (const k of ["schema", "model", "isolation", "agentType"]) {
+    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();
+  for (const e of entries) {
+    if (e.type === "result") {
+      results.set(e.key, e);
+    } else if (e.type === "started") {
+      const list = started.get(e.key);
+      if (list) list.push(e);
+      else started.set(e.key, [e]);
+    }
+  }
+  return { results, started };
+}
+__name(buildReplay, "buildReplay");
+var WorkflowJournal = class {
+  constructor(path2) {
+    this.path = path2;
+  }
+  static {
+    __name(this, "WorkflowJournal");
+  }
+  /** 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() };
+    }
+  }
+  /** Append one entry. Rejects only on I/O error (callers `.catch`). */
+  append(entry) {
+    return writeLine(this.path, entry);
+  }
+};
+
 // 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.';
@@ -946,48 +1232,65 @@ function sanitizeForErrorMessage(value) {
 __name(sanitizeForErrorMessage, "sanitizeForErrorMessage");
 function createProductionDispatch(config, signal, onTokens) {
   return async (prompt, opts) => {
-    const { AgentHeadless, ContextState } = await import("./agent-headless-Q27MG73I.js");
-    const ctx = new ContextState();
-    ctx.set("task_prompt", prompt);
-    if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0) {
-      const subagent = await AgentHeadless.create(
-        opts.label ?? "workflow-agent",
-        config,
-        {
-          systemPrompt: WORKFLOW_SUBAGENT_SYSTEM_PROMPT,
-          initialMessages: []
-        },
-        {},
-        // 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: WORKFLOW_SUBAGENT_MAX_TURNS,
-          max_time_minutes: WORKFLOW_SUBAGENT_MAX_TIME_MINUTES
-        },
-        // 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 }
-      );
-      try {
-        await subagent.execute(ctx, signal);
-      } finally {
-        reportTokens(subagent, opts, onTokens);
-      }
-      const mode = subagent.getTerminateMode();
-      if (mode !== "GOAL" /* GOAL */) {
-        throw new Error(
-          `Workflow subagent did not complete (terminate mode: ${mode}).`
-        );
+    const stallMs = resolveStallMs(
+      typeof opts.stallMs === "number" ? opts.stallMs : void 0
+    );
+    return runStallResilient(
+      (attemptSignal, emitter) => runSingleDispatch(config, prompt, opts, attemptSignal, emitter, onTokens),
+      {
+        stallMs,
+        signal,
+        label: typeof opts.label === "string" ? opts.label : void 0
       }
-      return subagent.getFinalText();
-    }
-    return runOverridePath(config, ctx, opts, signal, onTokens);
+    );
   };
 }
 __name(createProductionDispatch, "createProductionDispatch");
+async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, onTokens) {
+  const { AgentHeadless, ContextState } = await import("./agent-headless-ZMTUWMZJ.js");
+  const ctx = new ContextState();
+  ctx.set("task_prompt", prompt);
+  if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0) {
+    const subagent = await AgentHeadless.create(
+      opts.label ?? "workflow-agent",
+      config,
+      {
+        systemPrompt: WORKFLOW_SUBAGENT_SYSTEM_PROMPT,
+        initialMessages: []
+      },
+      {},
+      // 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: WORKFLOW_SUBAGENT_MAX_TURNS,
+        max_time_minutes: WORKFLOW_SUBAGENT_MAX_TIME_MINUTES
+      },
+      // 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
+    );
+    try {
+      await subagent.execute(ctx, attemptSignal);
+    } finally {
+      reportTokens(subagent, opts, onTokens);
+    }
+    const mode = subagent.getTerminateMode();
+    if (mode !== "GOAL" /* GOAL */) {
+      throw new Error(
+        `Workflow subagent did not complete (terminate mode: ${mode}).`
+      );
+    }
+    return subagent.getFinalText();
+  }
+  return runOverridePath(config, ctx, opts, attemptSignal, onTokens, emitter);
+}
+__name(runSingleDispatch, "runSingleDispatch");
 function reportTokens(subagent, opts, onTokens) {
   if (!onTokens) return;
   try {
@@ -998,7 +1301,7 @@ function reportTokens(subagent, opts, onTokens) {
   }
 }
 __name(reportTokens, "reportTokens");
-async function runOverridePath(config, ctx, opts, signal, onTokens) {
+async function runOverridePath(config, ctx, opts, signal, onTokens, emitter) {
   if (opts.isolation === "remote") {
     throw new Error(
       "agent({isolation:'remote'}) is not available in this build."
@@ -1079,7 +1382,10 @@ ${WORKFLOW_SUBAGENT_SYSTEM_PROMPT_WITH_SCHEMA}` : WORKFLOW_SUBAGENT_SYSTEM_PROMP
       schemaState.abortController = child;
       dispatchSignal = child.signal;
     }
-    const eventEmitter = schemaState ? createSchemaEventEmitter(schemaState) : void 0;
+    const eventEmitter = emitter ?? (schemaState ? new AgentEventEmitter() : void 0);
+    if (schemaState && eventEmitter) {
+      attachSchemaListeners(eventEmitter, schemaState);
+    }
     const { subagent, dispose } = await subagentMgr.createAgentHeadless(
       augmented,
       effectiveContext,
@@ -1318,8 +1624,7 @@ function createSchemaModeState() {
   };
 }
 __name(createSchemaModeState, "createSchemaModeState");
-function createSchemaEventEmitter(state) {
-  const emitter = new AgentEventEmitter();
+function attachSchemaListeners(emitter, state) {
   const targetTool = ToolNames.STRUCTURED_OUTPUT;
   emitter.on("tool_call" /* TOOL_CALL */, (evt) => {
     if (evt.name !== targetTool) return;
@@ -1341,9 +1646,8 @@ function createSchemaEventEmitter(state) {
       state.abortController.abort();
     }
   });
-  return emitter;
 }
-__name(createSchemaEventEmitter, "createSchemaEventEmitter");
+__name(attachSchemaListeners, "attachSchemaListeners");
 async function createSchemaConfigOverride(base, schema) {
   const override = Object.create(base);
   await rebuildToolRegistryOnOverride(override, base);
@@ -1367,7 +1671,46 @@ var WorkflowOrchestrator = class {
     let agentCount = 0;
     const emitter = req.emitter;
     const budget = req.budget;
+    const journal = req.journal;
+    const replay = req.resumeReplay;
+    let prefixHash = deriveArgsSeed(req.args);
+    let hadMiss = false;
+    let journalAgentId = 0;
     const countedDispatch = /* @__PURE__ */ __name((prompt, opts) => {
+      let journalKey;
+      let journalEntryId;
+      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;
+            try {
+              emitter?.agentDispatched?.(label2);
+            } catch (e) {
+              debugLogger.warn("emitter.agentDispatched threw:", e);
+            }
+            try {
+              emitter?.agentCompleted?.(label2);
+            } catch (e) {
+              debugLogger.warn("emitter.agentCompleted threw:", e);
+            }
+            return Promise.resolve(cached.result);
+          }
+        }
+        hadMiss = true;
+        journalEntryId = String(journalAgentId += 1);
+        journal.append({ type: "started", key: journalKey, agentId: journalEntryId }).catch(
+          (e) => debugLogger.warn(`journal started-append failed: ${e}`)
+        );
+      }
       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}`
@@ -1409,6 +1752,16 @@ var WorkflowOrchestrator = class {
           } catch (e) {
             debugLogger.warn("emitter.agentCompleted threw:", e);
           }
+          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);
@@ -1438,11 +1791,27 @@ var WorkflowOrchestrator = class {
     }, "countedDispatch");
     const parallelImpl = makeParallelImpl(signal);
     const pipelineImpl = makePipelineImpl(signal);
+    const resolveSavedWorkflow = req.resolveSavedWorkflow;
+    const workflowImpl = resolveSavedWorkflow ? async (nameOrRef, nestedArgs) => {
+      const resolved = await resolveSavedWorkflow(nameOrRef);
+      const nestedSandbox = createWorkflowSandbox({
+        args: nestedArgs,
+        dispatch: countedDispatch,
+        parallel: parallelImpl,
+        pipeline: pipelineImpl,
+        abortOnTimeout: req.abortOnTimeout,
+        emitter,
+        budget
+        // No `workflow` — single-level nesting limit.
+      });
+      return nestedSandbox.run(resolved.script);
+    } : void 0;
     const sandbox = createWorkflowSandbox({
       args: req.args,
       dispatch: countedDispatch,
       parallel: parallelImpl,
       pipeline: pipelineImpl,
+      workflow: workflowImpl,
       abortOnTimeout: req.abortOnTimeout,
       emitter,
       budget
@@ -1466,19 +1835,31 @@ var WorkflowOrchestrator = class {
     }
   }
 };
-async function settleToNullArray(thunks, signal) {
+async function settleToNullArray(thunks, signal, kind = "parallel") {
   const settled = await Promise.allSettled(
     thunks.map((t) => Promise.resolve().then(t))
   );
   if (signal?.aborted)
     throw new DOMException("Workflow run aborted.", "AbortError");
-  return settled.map((r, i) => {
+  let budgetDropped = 0;
+  const result = settled.map((r, i) => {
     if (r.status === "fulfilled") return r.value;
-    debugLogger.warn(
-      `Workflow thunk at index ${i} rejected: ${String(r.reason?.message ?? r.reason)}`
-    );
+    const reason = r.reason;
+    if (reason?.name === "WorkflowBudgetExceededError") {
+      budgetDropped += 1;
+    } else {
+      debugLogger.warn(
+        `Workflow thunk at index ${i} rejected: ${String(reason?.message ?? r.reason)}`
+      );
+    }
     return null;
   });
+  if (budgetDropped > 0) {
+    debugLogger.warn(
+      `${kind}: ${budgetDropped} slot${budgetDropped === 1 ? "" : "s"} dropped \u2014 token budget exceeded.`
+    );
+  }
+  return result;
 }
 __name(settleToNullArray, "settleToNullArray");
 function makeParallelImpl(signal) {
@@ -1524,7 +1905,7 @@ function makePipelineImpl(signal) {
     const chains = items.map(
       (item, idx) => () => runPipelineChain(item, idx, stages)
     );
-    return settleToNullArray(chains, signal);
+    return settleToNullArray(chains, signal, "pipeline");
   };
 }
 __name(makePipelineImpl, "makePipelineImpl");
@@ -1549,6 +1930,7 @@ __name(extractErrorMessage, "extractErrorMessage");
 
 // packages/core/src/tools/workflow/workflow.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
+import * as path from "node:path";
 var WORKFLOW_PARAM_SCHEMA = {
   type: "object",
   properties: {
@@ -1556,11 +1938,22 @@ var WORKFLOW_PARAM_SCHEMA = {
       type: "string",
       description: "JavaScript source of the workflow. Wrapped as an async IIFE. May call the injected globals `phase(title)`, `log(msg)`, `agent(prompt, opts?)`, and read `args`. agent() opts: `{ label?, phase?, schema?, model?, agentType?, isolation? }`. `schema` (JSON Schema object): the subagent must deliver its result by calling `structured_output` with arguments matching the schema; agent() resolves to the validated object. Two failed attempts produce a terminal error \"subagent completed without calling StructuredOutput (after 2 in-conversation nudges)\". `agentType` (string): resolves against the declarative-agents registry (`.qwen/agents/<name>.md`, project then user then built-in). Unresolved names throw \"agent({agentType}): agent type 'X' not found\". `model` (string): per-call model override; routes provider correctly via the subagent runtime view. `isolation`: `'worktree'` provisions a fresh git worktree under `<projectRoot>/.qwen/worktrees/agent-<7hex>`; the worktree is auto-removed if no changes, otherwise the path and branch are returned alongside the result. `'remote'` throws \"agent({isolation:'remote'}) is not available in this build\" (parity with upstream). isolation=worktree refuses to run when the parent working tree has uncommitted changes (the subagent would see a stale HEAD). Workflow subagents always have SendMessage / ExitPlanMode in their disallowed-tool floor regardless of agentType. Concurrency: `parallel([() => agent(...), ...])` runs thunks through a shared per-run window (default `max(1, min(16, cpus-2))` agents in flight; override via `QWEN_CODE_MAX_WORKFLOW_CONCURRENCY`) and resolves to a position-aligned array \u2014 a thunk that throws, or resolves to a non-JSON-serializable value, becomes `null` at its index (errors-as-data); parallel() itself rejects only on invalid arguments or abort. `pipeline(items, ...stages)` runs each item through the stages (staggered, no inter-stage barrier); a stage that throws, returns `null`, or returns a non-JSON-serializable value drops that item to `null`. Pass THUNKS to parallel, not eager calls: `parallel([() => agent(...)])`, not `parallel([agent(...)])`. At most 1000 agent() calls per run (override via `QWEN_CODE_MAX_WORKFLOW_AGENTS`). `Date.now()` and `Math.random()` both throw \u2014 workflow scripts must be deterministic for resume. `export const meta = {...}` declarations are stripped before execution."
     },
+    scriptPath: {
+      type: "string",
+      description: "Optional. Absolute path to a saved workflow `.js` file to load and run instead of inline `script`. Primarily set by the `/<name>` saved-workflow slash command. 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."
+    },
     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 SAME script; 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 same script and args as the original run for the cache to apply."
     }
-  },
-  required: ["script"]
+  }
+  // `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) {
@@ -1572,7 +1965,10 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
     __name(this, "WorkflowToolInvocation");
   }
   getDescription() {
-    return `Run a workflow script (${this.params.script.length} chars)`;
+    if (this.params.scriptPath && this.params.script === void 0) {
+      return `Run saved workflow (${path.basename(this.params.scriptPath)})`;
+    }
+    return `Run a workflow script (${this.params.script?.length ?? 0} chars)`;
   }
   toolLocations() {
     return [];
@@ -1592,7 +1988,26 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
       (outputTokens) => budget.recordSpent(outputTokens)
     );
     const orchestrator = new WorkflowOrchestrator(dispatch);
-    const runId = `wf_${randomBytes2(8).toString("hex")}`;
+    let resolvedScript = this.params.script ?? "";
+    let resolvedScriptPath = this.params.scriptPath;
+    if (this.params.scriptPath && this.params.script === void 0) {
+      const loaded = await resolveSavedWorkflowScript(
+        { scriptPath: this.params.scriptPath },
+        this.config
+      );
+      resolvedScript = loaded.script;
+      resolvedScriptPath = loaded.scriptPath;
+    }
+    const runId = this.params.resumeFromRunId ?? `wf_${randomBytes2(8).toString("hex")}`;
+    let journal;
+    let resumeReplay;
+    const storage = this.config.storage;
+    if (storage) {
+      journal = new WorkflowJournal(storage.getWorkflowRunJournalPath(runId));
+      if (this.params.resumeFromRunId) {
+        resumeReplay = await journal.load();
+      }
+    }
     const registry = this.config.getWorkflowRunRegistry?.();
     const registryEntry = registry?.register({
       runId,
@@ -1606,7 +2021,13 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
       // P5: seed the cap so the dialog can render the `M / N` form
       // immediately, before the first `budgetUpdated` fires. Stays
       // `null` when no env override.
-      tokenBudgetTotal: budget.total
+      tokenBudgetTotal: budget.total,
+      // P7b: carry the script source so a completed run can be snapshotted
+      // to disk and saved to `.qwen/workflows/<name>.js` from the dialog.
+      // `scriptPath` is set when the run was launched from a saved file (run
+      // provenance for the snapshot).
+      script: resolvedScript,
+      scriptPath: resolvedScriptPath
     });
     const emitter = {
       phaseStarted: /* @__PURE__ */ __name((title) => {
@@ -1629,12 +2050,18 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
     };
     try {
       const outcome = await orchestrator.run({
-        script: this.params.script,
+        script: resolvedScript,
         args: this.params.args,
         abortOnTimeout: dispatchController,
         runId,
         emitter,
-        budget
+        budget,
+        // P-nested: resolve `workflow('<name>')` / `workflow({scriptPath})`
+        // against the saved-workflow scripts in `.qwen/workflows/`.
+        resolveSavedWorkflow: /* @__PURE__ */ __name((ref) => resolveSavedWorkflowScript(ref, this.config), "resolveSavedWorkflow"),
+        // P6: resume journal (always wired) + replay maps (resume only).
+        journal,
+        resumeReplay
       });
       if (registryEntry) {
         registryEntry.meta = outcome.meta;
@@ -1704,6 +2131,23 @@ ${safeStringifyDisplayPayload({
       };
     } finally {
       dispatchController.abort();
+      if (registryEntry && registryEntry.status !== "running") {
+        await writeWorkflowSnapshot(this.config, registryEntry);
+        try {
+          logWorkflowRun(
+            this.config,
+            new WorkflowRunEvent({
+              status: registryEntry.status,
+              agents_dispatched: registryEntry.agentsDispatched,
+              agents_completed: registryEntry.agentsCompleted,
+              phase_count: registryEntry.phases.length,
+              tokens_spent: registryEntry.tokensSpent,
+              duration_ms: (registryEntry.endTime ?? registryEntry.startTime) - registryEntry.startTime
+            })
+          );
+        } catch {
+        }
+      }
     }
   }
 };
@@ -1803,7 +2247,7 @@ var WorkflowTool = class extends BaseDeclarativeTool {
     super(
       ToolNames.WORKFLOW,
       ToolDisplayNames.WORKFLOW,
-      "Execute a workflow script that orchestrates subagents. Supports `phase`, `log`, sequential `agent`, concurrent fan-out via `parallel(thunks)` / `pipeline(items, ...stages)` (default `max(1, min(16, cpus-2))` agents in flight per run, up to 1000 agents total; both env-overridable), per-call `agent({ schema, agentType, model, isolation: 'worktree' })` for structured-output contracts, declarative-agent selection, model override, and git-worktree-isolated subagents. No resume and no background execution yet (scheduled for later phases). Scripts run in a node:vm sandbox without access to the filesystem or shell; all I/O happens through the spawned agents.",
+      "Execute a workflow script that orchestrates subagents. Supports `phase`, `log`, sequential `agent`, concurrent fan-out via `parallel(thunks)` / `pipeline(items, ...stages)` (default `max(1, min(16, cpus-2))` agents in flight per run, up to 1000 agents total; both env-overridable), per-call `agent({ schema, agentType, model, isolation: 'worktree' })` for structured-output contracts, declarative-agent selection, model override, and git-worktree-isolated subagents. Pass `resumeFromRunId` to resume a prior run \u2014 agent() calls whose rolling prefix-hash matches the journal are served from cache for the longest unchanged prefix. Runs are tracked in the background-tasks view and the `/workflows` dialog (live phase tree, token usage, cancel). Scripts run in a node:vm sandbox without access to the filesystem or shell; all I/O happens through the spawned agents.",
       "other" /* Other */,
       WORKFLOW_PARAM_SCHEMA,
       /* isOutputMarkdown */
@@ -1818,8 +2262,16 @@ var WorkflowTool = class extends BaseDeclarativeTool {
     __name(this, "WorkflowTool");
   }
   validateToolParamValues(params) {
-    if (typeof params.script !== "string" || params.script.length === 0) {
-      return "WorkflowTool: `script` parameter is required and must be a non-empty string.";
+    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 saved workflow 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>`.";
     }
     return null;
   }