@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-subagents/src/workflows/scripted-workflow.js

@@ -45,6 +45,7 @@ let topLevelWorkflowPromise;
 let suppressNativePromiseConsumption = 0;
 const activeNativePromises = [];
 const pending = new Map();
+const workflowErrorKinds = new WeakMap();
 const runKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 function validGitRef(ref) {
   if (typeof ref !== "string" || !ref || ref === "@" || new TextEncoder().encode(ref).length > 1024 || ref.startsWith("/") || ref.endsWith("/") || ref.includes("//") || ref.includes("..") || ref.includes("@{")) return false;
@@ -848,12 +849,32 @@ function isSyntaxError(error) {
   return error instanceof SyntaxError || error?.name === "SyntaxError";
 }
 
+function postWorkflowError(error) {
+  // Pre-run syntax and portability errors are tagged "validation" where the script is compiled;
+  // anything reaching here was thrown while the script ran, including a runtime SyntaxError.
+  const taggedKind = error && (typeof error === "object" || typeof error === "function") ? workflowErrorKinds.get(error) : undefined;
+  parentPort.postMessage({ type: "error", error: isSyntaxError(error) ? formatWorkflowScriptSyntaxError(error) : formatWorkflowScriptError(error), errorKind: taggedKind ?? "script" });
+}
+
+process.on("unhandledRejection", postWorkflowError);
+
 const NESTED_ASYNC_WORKFLOW_ERROR = "workflowScript validation failed before child launch; no children launched. workflowScript does not support nested async functions. Use top-level await, plain helper functions that return runs.run(...), or explicit Promise chains so workflows stay portable across Node and Bun. Parallel plus sequential rewrite: const a = runs.run(\"a\", { agent: \"worker\", task: \"A\" }); const writer = await runs.run(\"writer\", { agent: \"worker\", task: \"Write\" }); const review = await runs.run(\"review\", { agent: \"reviewer\", task: writer.output }); const [aResult] = await Promise.all([a]); return { a: aResult.output, issue: { writerRunId: writer.runId, reviewRunId: review.runId } };";
 const AST_SCALAR_KEYS = new Set(["type", "start", "end"]);
 
 function assertPortableWorkflowScript(source) {
   const wrapped = "(async () => {\n" + source + "\n})()";
-  const ast = parse(wrapped, { ecmaVersion: "latest", sourceType: "script" });
+  let ast;
+  try {
+    ast = parse(wrapped, { ecmaVersion: "latest", sourceType: "script" });
+  } catch (error) {
+    // The wrapper adds one line before the script; report the script's own line.
+    if (isSyntaxError(error) && typeof error.message === "string") {
+      const message = error.message.replace(/\((\d+):(\d+)\)$/, (_match, line, column) => "(" + Math.max(1, Number(line) - 1) + ":" + column + ")");
+      if (typeof error.stack === "string") error.stack = error.stack.replace(error.message, message);
+      error.message = message;
+    }
+    throw error;
+  }
   const wrapper = workflowWrapperFunction(ast);
   walkWorkflowAst(wrapper.body, wrapper);
 }
@@ -964,14 +985,14 @@ parentPort.on("message", async (message) => {
     if (message.ok) entry.resolve(message.value);
     else {
       const error = new Error(message.error);
-      if (message.errorKind === "detached-child") error.workflowErrorKind = "detached-child";
+      if (message.errorKind === "child" || message.errorKind === "detached-child") workflowErrorKinds.set(error, message.errorKind);
       entry.reject(error);
     }
     return;
   }
   if (message.type !== "start") return;
   try {
-    const sandbox = { runs, Promise: workflowPromise, emit(value) { const emittedValue = unwrapRunsAllResults(value); assertJsonValue(emittedValue); parentPort.postMessage({ type: "emit", value: emittedValue }); }, console: capturedConsole };
+    const sandbox = { runs, Promise: workflowPromise, emit(value) { const unwrapped = unwrapRunsAllResults(value); const emittedValue = unwrapped === undefined ? null : omitUndefinedWorkflowValues(unwrapped); assertJsonValue(emittedValue); parentPort.postMessage({ type: "emit", value: emittedValue }); }, console: capturedConsole };
     if (message.stateEnabled) sandbox.state = state;
     const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
     contextObjectPrototype = vm.runInContext("Object.prototype", context);
@@ -981,9 +1002,9 @@ parentPort.on("message", async (message) => {
     let compiled;
     try {
       assertPortableWorkflowScript(message.script);
-      compiled = new vm.Script("(async () => {\n" + message.script + "\n})()", { filename: "workflow-script.js" });
+      compiled = new vm.Script("(async () => {\n" + message.script + "\n})()", { filename: "workflow-script.js", lineOffset: -1 });
     } catch (error) {
-      parentPort.postMessage({ type: "error", error: isSyntaxError(error) ? formatWorkflowScriptSyntaxError(error) : formatWorkflowScriptError(error) });
+      parentPort.postMessage({ type: "error", errorKind: "validation", error: isSyntaxError(error) ? formatWorkflowScriptSyntaxError(error) : formatWorkflowScriptError(error) });
       return;
     }
     const nativePromisePrototype = vm.runInContext("(async () => {})().constructor.prototype", context);
@@ -993,7 +1014,9 @@ parentPort.on("message", async (message) => {
     let stopWorkflowPromiseHook;
     let value;
     try {
-      Object.defineProperty(nativePromisePrototype, "then", {
+      // Some hosts freeze built-ins in every realm, which makes then read-only. The promise hooks
+      // below still track observation, so skip the wrapper rather than fail every workflow.
+      if (nativeThenDescriptor.configurable) Object.defineProperty(nativePromisePrototype, "then", {
         ...nativeThenDescriptor,
         value: function workflowPromiseThen(...args) {
           if (isDirectWorkflowScriptPromiseHandlerCall() || suppressNativePromiseConsumption > 0) {
@@ -1033,7 +1056,7 @@ parentPort.on("message", async (message) => {
         stopWorkflowPromiseHook?.();
       } finally {
         try {
-          Object.defineProperty(nativePromisePrototype, "then", nativeThenDescriptor);
+          if (nativeThenDescriptor.configurable) Object.defineProperty(nativePromisePrototype, "then", nativeThenDescriptor);
         } finally {
           topLevelWorkflowPromise = undefined;
           activeNativePromises.length = 0;
@@ -1047,21 +1070,27 @@ parentPort.on("message", async (message) => {
     try {
       assertJsonValue(persistedValue, "return");
     } catch (error) {
-      parentPort.postMessage({ type: "error", errorPhase: "return-serialization", error: formatWorkflowScriptError(error) });
+      parentPort.postMessage({ type: "error", errorKind: "return-serialization", errorPhase: "return-serialization", error: formatWorkflowScriptError(error) });
       return;
     }
     parentPort.postMessage({ type: "complete", value: persistedValue });
   } catch (error) {
-    parentPort.postMessage({ type: "error", error: isSyntaxError(error) ? formatWorkflowScriptSyntaxError(error) : formatWorkflowScriptError(error), ...(error && error.workflowErrorKind === "detached-child" ? { errorKind: "detached-child" } : {}) });
+    postWorkflowError(error);
   }
 });
 `;
+function isWorkflowScriptFailureKind(value) {
+  return value === "validation" || value === "script" || value === "child" || value === "return-serialization" || value === "timeout" || value === "detached-child" || value === "runtime";
+}
+function taggedWorkflowError(message, kind) {
+  return Object.assign(new Error(message), { workflowErrorKind: kind });
+}
 
 export class WorkflowScriptError extends Error {
   partial;
   errorKind;
-  constructor(message, partial, errorKind) {
-    super(message);
+  constructor(message, partial, errorKind, options) {
+    super(message, options);
     this.name = "WorkflowScriptError";
     this.partial = partial;
     this.errorKind = errorKind;
@@ -1211,7 +1240,9 @@ export function formatWorkflowJsonPreview(value, maxLength) {
   try {
     assertWorkflowJsonValue(value);
     const serialized = JSON.stringify(value);
-    return typeof serialized === "string" ? serialized.slice(0, maxLength) : undefined;
+    if (typeof serialized !== "string")
+      return;
+    return serialized.length > maxLength ? `${serialized.slice(0, maxLength)}…` : serialized;
   } catch {
     return;
   }
@@ -1262,6 +1293,9 @@ function canonicalRunParams(params) {
   const { acceptance: _acceptance, ...withoutAcceptance } = params;
   return withoutAcceptance;
 }
+export function workflowRunParamsFingerprint(params) {
+  return stableJson(canonicalRunParams(params));
+}
 function validateKey(value, owner = "runs.run") {
   if (typeof value !== "string" || !KEY_PATTERN.test(value)) {
     throw new Error(`${owner} key must be 1-128 characters using letters, numbers, '.', '_' or '-', and start with a letter or number.`);
@@ -1501,6 +1535,36 @@ function validateStaticBaseRef(params, owner) {
   }
   return [];
 }
+function staticChildAgentNode(params) {
+  if (!astNode(params) || params.type !== "ObjectExpression" || !Array.isArray(params.properties))
+    return;
+  let agent;
+  for (const property of params.properties) {
+    if (!astNode(property) || property.type !== "Property")
+      return;
+    const key = staticPropertyKey(property);
+    if (key === undefined || key === "cwd" || key === "agentScope" || key === "resume")
+      return;
+    if (key === "agent")
+      agent = property.kind === "init" && astNode(property.value) ? property.value : undefined;
+  }
+  return literalString(agent) === undefined ? undefined : agent;
+}
+function validateStaticChildAgents(call, agentNameError) {
+  const args = Array.isArray(call.arguments) ? call.arguments : [];
+  const elements = (node) => astNode(node) && node.type === "ArrayExpression" && Array.isArray(node.elements) ? node.elements : [];
+  const staticLane = (lane) => astNode(lane) && lane.type === "ObjectExpression" && Array.isArray(lane.properties) && lane.properties.every((property) => astNode(property) && property.type === "Property" && staticPropertyKey(property) !== undefined);
+  const children = directRunsCall(call, "run") ? [{ owner: "runs.run", params: args[1] }] : directRunsCall(call, "all") ? elements(args[0]).map((params) => ({ owner: "runs.all item", params })) : directRunsCall(call, "lanes") ? elements(args[0]).flatMap((lane) => staticLane(lane) ? elements(directObjectPropertyValue(lane, "stages")).map((params) => ({ owner: "runs.lanes stage", params })) : []) : [];
+  const errors = [];
+  for (const child of children) {
+    const agentNode = staticChildAgentNode(child.params);
+    const agentName = literalString(agentNode);
+    const error = agentName === undefined ? undefined : agentNameError(agentName);
+    if (agentNode && error)
+      errors.push({ kind: "agent", message: `${child.owner}: ${error}`, ...nodeLocation(agentNode) });
+  }
+  return errors;
+}
 function directRunsAllKeys(call) {
   const args = Array.isArray(call.arguments) ? call.arguments : [];
   const items = astNode(args[0]) && args[0].type === "ArrayExpression" && Array.isArray(args[0].elements) ? args[0].elements : [];
@@ -1656,6 +1720,7 @@ ${script}
   }
   const wrapper = astNode(root.body) ? undefined : Array.isArray(root.body) && astNode(root.body[0]) && astNode(root.body[0].expression) && astNode(root.body[0].expression.callee) ? root.body[0].expression.callee : undefined;
   const workflowBody = wrapper && astNode(wrapper.body) ? wrapper.body : root;
+  const agentNameError = options.agentNameError && !invalidatesRunsBinding(workflowBody) ? options.agentNameError : undefined;
   walkAst(workflowBody, (node) => {
     if (node !== wrapper && node.async === true && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")) {
       errors.push({ message: "workflowScript does not support nested async functions. Use top-level await, plain helper functions that return runs.run(...), or explicit Promise chains.", ...nodeLocation(node) });
@@ -1690,9 +1755,11 @@ ${script}
     }
     if (directRunsCall(node, "host"))
       errors.push(...validateStaticHostCall(node));
+    if (agentNameError)
+      errors.push(...validateStaticChildAgents(node, agentNameError));
     const boundaryValue = node.type === "CallExpression" && astNode(node.callee) && node.callee.type === "Identifier" && node.callee.name === "emit" && Array.isArray(node.arguments) && astNode(node.arguments[0]) ? node.arguments[0] : node.type === "CallExpression" && astNode(node.callee) && node.callee.type === "MemberExpression" && astNode(node.callee.object) && node.callee.object.type === "Identifier" && node.callee.object.name === "state" && astNode(node.callee.property) && node.callee.property.type === "Identifier" && node.callee.property.name === "set" && Array.isArray(node.arguments) && astNode(node.arguments[1]) ? node.arguments[1] : undefined;
     if (boundaryValue) {
-      const message = definitelyNonJson(boundaryValue);
+      const message = definitelyNonJson(boundaryValue, Array.isArray(node.arguments) && boundaryValue === node.arguments[0]);
       if (message)
         errors.push({ message: `workflowScript boundary value is invalid: ${message}.`, ...nodeLocation(boundaryValue) });
     }
@@ -1811,12 +1878,13 @@ function setupAbortResumeParams(params, result, signal) {
   return resumeParams;
 }
 export async function runWorkflowScript(options) {
+  const emptyPartial = () => ({ emits: [], console: [], trace: [], children: [] });
   if (!options.script.trim())
-    throw new Error("workflowScript must not be empty.");
+    throw new WorkflowScriptError("workflowScript must not be empty.", emptyPartial(), "validation");
   if (options.timeoutMs !== undefined && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1))
-    throw new Error("workflow script timeout must be a positive integer.");
+    throw new WorkflowScriptError("workflow script timeout must be a positive integer.", emptyPartial(), "runtime");
   if (options.globalConcurrencyLimit !== undefined && (!Number.isSafeInteger(options.globalConcurrencyLimit) || options.globalConcurrencyLimit < 1)) {
-    throw new Error("workflow script global concurrency limit must be a positive integer.");
+    throw new WorkflowScriptError("workflow script global concurrency limit must be a positive integer.", emptyPartial(), "runtime");
   }
   const launchSemaphore = new Semaphore(options.globalConcurrencyLimit ?? DEFAULT_GLOBAL_CONCURRENCY_LIMIT);
   if (options.processCwd !== undefined) {
@@ -1826,7 +1894,7 @@ export async function runWorkflowScript(options) {
     } catch (error) {
       const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
       if (code !== "ENOENT")
-        throw new Error("Workflow current cwd could not be validated.", { cause: error });
+        throw new WorkflowScriptError("Workflow current cwd could not be validated.", emptyPartial(), "runtime", { cause: error });
       staleCwd = true;
     }
     try {
@@ -1843,16 +1911,21 @@ export async function runWorkflowScript(options) {
       }
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
-      throw new Error(`Workflow process cwd is unavailable: ${options.processCwd}: ${detail}`, { cause: error });
+      throw new WorkflowScriptError(`Workflow process cwd is unavailable: ${options.processCwd}: ${detail}`, emptyPartial(), "runtime", { cause: error });
     }
   }
   let acornPath;
   try {
     acornPath = resolveWorkflowParserEntry();
   } catch (error) {
-    throw new Error("Workflow parser dependency 'acorn' is unavailable from dm-subagents. Reinstall dm-subagents dependencies before launching workflowScript.", { cause: error });
+    throw new WorkflowScriptError("Workflow parser dependency 'acorn' is unavailable from dm-subagents. Reinstall dm-subagents dependencies before launching workflowScript.", emptyPartial(), "runtime", { cause: error });
+  }
+  let worker;
+  try {
+    worker = new Worker(WORKER_SOURCE, { eval: true, workerData: { acornPath } });
+  } catch (error) {
+    throw new WorkflowScriptError(`Workflow worker could not start: ${error instanceof Error ? error.message : String(error)}`, emptyPartial(), "runtime", { cause: error });
   }
-  const worker = new Worker(WORKER_SOURCE, { eval: true, workerData: { acornPath } });
   const emits = [];
   const consoleEntries = [];
   const trace = [];
@@ -1913,7 +1986,7 @@ export async function runWorkflowScript(options) {
     if (isAcceptanceMetadataRecovery(result))
       acceptanceRecoveryBarrier = { key };
   };
-  const stopChild = (key, message = `Workflow child '${key}' stopped by user.`) => {
+  const stopChild = (key, message = `Workflow child '${key}' stopped.`) => {
     if (!launches.has(key) || children.has(key))
       return false;
     stoppedLaunches.add(key);
@@ -1946,7 +2019,8 @@ export async function runWorkflowScript(options) {
         outcome,
         ...outputReference ? { outputReference } : {},
         ...!result.ok && result.error ? { error: result.error } : {},
-        workflowRunning: !settled && !finishing
+        workflowRunning: !settled && !finishing,
+        result
       });
     } catch (error) {
       console.error("Workflow onChildSettled callback failed:", error);
@@ -1981,9 +2055,9 @@ export async function runWorkflowScript(options) {
           return unobservedHosts.length > 0 ? new Error(`workflowScript completed with unawaited runs.host call(s): ${unobservedHosts.map((key) => `'${key}'`).join(", ")}. Await or return each call.`) : undefined;
         })() : undefined;
         if ("error" in outcome)
-          reject(new WorkflowScriptError(outcome.error.message, partial(), outcome.error.workflowErrorKind === "detached-child" || outcome.error.workflowErrorKind === "timeout" ? outcome.error.workflowErrorKind : undefined));
+          reject(new WorkflowScriptError(outcome.error.message, partial(), isWorkflowScriptFailureKind(outcome.error.workflowErrorKind) ? outcome.error.workflowErrorKind : undefined));
         else if (completionError)
-          reject(new WorkflowScriptError(completionError.message, partial()));
+          reject(new WorkflowScriptError(completionError.message, partial(), "validation"));
         else
           resolve({ value: outcome.value, ...partial() });
       });
@@ -2000,7 +2074,7 @@ export async function runWorkflowScript(options) {
         mayFlushAssembly = options.continueAfterAbortWhenChildrenSettled?.(error) === true;
       } catch (callbackError) {
         const callbackMessage = callbackError instanceof Error ? callbackError.message : String(callbackError);
-        return finish({ error: new Error(`Workflow assembly flush eligibility failed: ${callbackMessage}`) });
+        return finish({ error: taggedWorkflowError(`Workflow assembly flush eligibility failed: ${callbackMessage}`, "runtime") });
       }
       if (mayFlushAssembly && allChildrenSettled) {
         assemblyAbortRequested = true;
@@ -2028,17 +2102,15 @@ export async function runWorkflowScript(options) {
       finish({ error });
     };
     const timer = options.timeoutMs === undefined ? undefined : setTimeout(() => {
-      const error = new Error(`Workflow script timed out after ${options.timeoutMs}ms.`);
-      error.workflowErrorKind = "timeout";
-      finish({ error });
+      finish({ error: taggedWorkflowError(`Workflow script timed out after ${options.timeoutMs}ms.`, "timeout") });
     }, options.timeoutMs);
     options.signal?.addEventListener("abort", onAbort, { once: true });
     if (options.signal?.aborted)
       return onAbort();
-    worker.on("error", (error) => finish({ error: new Error(`Workflow worker failed: ${error instanceof Error ? error.message : String(error)}`) }));
+    worker.on("error", (error) => finish({ error: taggedWorkflowError(`Workflow worker failed: ${error instanceof Error ? error.message : String(error)}`, "runtime") }));
     worker.on("exit", (code) => {
       if (!settled && code !== 0)
-        finish({ error: new Error(`Workflow worker exited with code ${code}.`) });
+        finish({ error: taggedWorkflowError(`Workflow worker exited with code ${code}.`, "runtime") });
     });
     worker.on("message", (message) => {
       if (settled)
@@ -2051,7 +2123,7 @@ export async function runWorkflowScript(options) {
         try {
           assertWorkflowJsonValue(message.value, "emit");
         } catch (error) {
-          finish({ error: new Error(`Workflow emit could not be persisted: ${error instanceof Error ? error.message : String(error)}`) });
+          finish({ error: taggedWorkflowError(`Workflow emit could not be persisted: ${error instanceof Error ? error.message : String(error)}`, "runtime") });
           return;
         }
         emits.push(message.value);
@@ -2059,7 +2131,7 @@ export async function runWorkflowScript(options) {
           options.onEmit?.([...emits]);
         } catch (error) {
           emits.pop();
-          finish({ error: new Error(`Workflow emit could not be persisted: ${error instanceof Error ? error.message : String(error)}`) });
+          finish({ error: taggedWorkflowError(`Workflow emit could not be persisted: ${error instanceof Error ? error.message : String(error)}`, "runtime") });
         }
         return;
       }
@@ -2073,17 +2145,14 @@ export async function runWorkflowScript(options) {
         try {
           assertWorkflowJsonValue(message.value, "return");
         } catch (error) {
-          return finish({ error: new Error(`Workflow return could not be persisted: ${error instanceof Error ? error.message : String(error)}`) });
+          return finish({ error: taggedWorkflowError(`Workflow return could not be persisted: ${error instanceof Error ? error.message : String(error)}`, "return-serialization") });
         }
         return finish({ value: message.value });
       }
       if (message.type === "error") {
         const rawError = typeof message.error === "string" ? message.error : "Workflow script failed.";
         const text = message.errorPhase === "return-serialization" ? `${rawError}${workflowReturnRecoveryHint(partial().children)}` : rawError;
-        const workflowError = new Error(text);
-        if (message.errorKind === "detached-child")
-          workflowError.workflowErrorKind = "detached-child";
-        return finish({ error: workflowError });
+        return finish({ error: isWorkflowScriptFailureKind(message.errorKind) ? taggedWorkflowError(text, message.errorKind) : new Error(text) });
       }
       if (message.type === "callObserved" && typeof message.callId === "number") {
         const key = typeof message.key === "string" ? message.key : undefined;
@@ -2129,8 +2198,10 @@ export async function runWorkflowScript(options) {
             worker.postMessage({ type: "response", callId: message.callId, ok: false, error: `${responsePath} must contain only JSON data before it can be returned from workflowScript. Return a plain projection such as { runId, ok, output }. ${error instanceof Error ? error.message : String(error)}` });
           }
         }, (error) => {
-          if (!settled)
-            worker.postMessage({ type: "response", callId: message.callId, ok: false, error: error instanceof Error ? error.message : String(error), ...error instanceof Error && error.workflowErrorKind === "detached-child" ? { errorKind: "detached-child" } : {} });
+          if (!settled) {
+            const errorKind = error instanceof Error ? error.workflowErrorKind : undefined;
+            worker.postMessage({ type: "response", callId: message.callId, ok: false, error: error instanceof Error ? error.message : String(error), ...isWorkflowScriptFailureKind(errorKind) ? { errorKind } : {} });
+          }
         });
       };
       if (message.method === "state.get" || message.method === "state.set") {
@@ -2279,14 +2350,11 @@ export async function runWorkflowScript(options) {
       const deliver = (promise) => collectFailure ? promise : promise.then((result) => {
         const recoverableAcceptanceMetadata = result.recovery?.status === "available-for-review" && result.recovery.reason === "acceptance-metadata-rejected";
         if (!result.ok && result.state !== "running" && !result.stopped && !recoverableAcceptanceMetadata) {
-          const childError = new Error(result.detached ? `Run '${key}' detached: ${result.error ?? result.output}` : `Run '${key}' failed: ${result.error ?? result.output}`);
-          if (result.detached)
-            childError.workflowErrorKind = "detached-child";
-          throw childError;
+          throw taggedWorkflowError(`Run '${key}' ${result.detached ? "detached" : "failed"}: ${result.error ?? result.output}`, result.detached ? "detached-child" : "child");
         }
         return result;
       });
-      const fingerprint = stableJson(canonicalRunParams(params));
+      const fingerprint = workflowRunParamsFingerprint(params);
       const existing = launches.get(key);
       if (existing) {
         if (existing.fingerprint !== fingerprint)
@@ -2430,7 +2498,10 @@ export async function runWorkflowScript(options) {
         children.set(key, normalized);
         recordAcceptanceRecoveryBarrier(key, normalized);
         const state = normalized.state === "running" ? "started" : normalized.ok ? "completed" : normalized.stopped ? "stopped" : normalized.detached ? "detached" : "failed";
-        trace.push({ operation: "run", key, state, durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), ...generatedLaneKey ? { generatedLaneKey } : {}, ...normalized.agent ? { agent: normalized.agent } : {}, ...normalized.runId ? { runId: normalized.runId } : {}, ...!normalized.ok && normalized.state !== "running" ? { error: normalized.error ?? normalized.output } : {} });
+        const settledEntry = { operation: "run", key, state, durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), ...generatedLaneKey ? { generatedLaneKey } : {}, ...normalized.agent ? { agent: normalized.agent } : {}, ...normalized.runId ? { runId: normalized.runId } : {}, ...!normalized.ok && normalized.state !== "running" ? { error: normalized.error ?? normalized.output } : {} };
+        if (normalized.reused)
+          settledEntry.reused = true;
+        trace.push(settledEntry);
         traceChanged();
         notifyChildSettled(key, normalized);
         return normalized;

package/extensions/dm-subagents/src/workflows/structured-workflow-scripts.js

@@ -0,0 +1,154 @@
+const OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const PLACEHOLDER_PATTERN = /\{(?:task|previous|outputs\.([A-Za-z_][A-Za-z0-9_]*))\}/g;
+export function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function nonEmptyString(value, path) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${path} must be a non-empty string.`);
+  return value;
+}
+function exactFields(value, path, allowed, hint) {
+  if (!isPlainRecord(value))
+    throw new Error(`${path} must be an object.`);
+  const unsupported = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (unsupported.length > 0)
+    throw new Error(`${path} contains unsupported fields: ${unsupported.join(", ")}. ${hint}`);
+  return value;
+}
+function compileTemplate(template, scope) {
+  const parts = [];
+  let cursor = 0;
+  for (const match of template.matchAll(PLACEHOLDER_PATTERN)) {
+    const literal = template.slice(cursor, match.index);
+    cursor = match.index + match[0].length;
+    let variable;
+    if (match[0] === "{task}") {
+      if (!scope.hasOriginalTask)
+        throw new Error(`${scope.path} references {task}, but no top-level task was provided.`);
+      variable = "originalTask";
+    } else if (match[0] === "{previous}") {
+      if ("unavailable" in scope.previous)
+        throw new Error(`${scope.path} cannot use {previous}; ${scope.previous.unavailable}`);
+      variable = scope.previous.variable;
+    } else {
+      const name = match[1];
+      if (!scope.outputs)
+        throw new Error(`${scope.path} cannot use {outputs.${name}}; ${scope.outputsUnavailable}`);
+      const named = scope.outputs.get(name);
+      if (!named)
+        throw new Error(`${scope.path} references {outputs.${name}}, but no earlier sequential step sets as: "${name}".`);
+      variable = named;
+    }
+    if (literal)
+      parts.push(JSON.stringify(literal));
+    parts.push(variable);
+  }
+  const literal = template.slice(cursor);
+  if (literal || parts.length === 0)
+    parts.push(JSON.stringify(literal));
+  return parts.join(" + ");
+}
+function prelude(originalTask) {
+  return originalTask === undefined ? [SETTLE_HELPER] : [SETTLE_HELPER, `const originalTask = ${JSON.stringify(originalTask)};`];
+}
+function runsAllCall(children) {
+  return `await runs.all([${children.map((child) => `{ key: ${JSON.stringify(child.key)}, agent: ${JSON.stringify(child.agent)}, task: ${child.taskExpression} }`).join(", ")}])`;
+}
+const SETTLE_HELPER = [
+  "function settle(results, agents) {",
+  "  return results.map(function (result, index) {",
+  '    const child = { key: result.key, agent: agents[index], ok: result.ok === true, output: typeof result.output === "string" ? result.output : "" };',
+  '    if (!child.ok && typeof result.error === "string") child.error = result.error;',
+  "    return child;",
+  "  });",
+  "}",
+  "function failure(label, children) {",
+  '  return new Error(label + ": " + children.filter(function (child) { return !child.ok; }).map(function (child) { return child.key + " (" + child.agent + ") failed" + (child.error ? ": " + child.error : ""); }).join("; "));',
+  "}"
+].join(`
+`);
+function buildTasksScript(steps, originalTask) {
+  if (!Array.isArray(steps) || steps.length === 0)
+    throw new Error("tasks must be a non-empty array of { agent, task } items.");
+  const children = steps.map((item, index) => {
+    const path = `tasks[${index}]`;
+    const record = exactFields(item, path, ["agent", "task"], "Each tasks item accepts only agent and task.");
+    const agent = nonEmptyString(record.agent, `${path}.agent`);
+    const task = nonEmptyString(record.task, `${path}.task`);
+    const taskExpression = compileTemplate(task, {
+      path: `${path}.task`,
+      hasOriginalTask: originalTask !== undefined,
+      previous: { unavailable: "tasks items may only use {task}." },
+      outputsUnavailable: "tasks items may only use {task}."
+    });
+    return { key: `task-${index + 1}`, agent, taskExpression };
+  });
+  return [
+    ...prelude(originalTask),
+    `const run1 = ${runsAllCall(children)};`,
+    `const children = settle(run1, ${JSON.stringify(children.map((child) => child.agent))});`,
+    'if (!children.every(function (child) { return child.ok; })) throw failure("tasks failed", children);',
+    "return { ok: true, children };"
+  ].join(`
+`);
+}
+function buildChainScript(steps, originalTask) {
+  if (!Array.isArray(steps) || steps.length === 0)
+    throw new Error("chain must be a non-empty array of steps.");
+  const lines = [...prelude(originalTask), "const children = [];"];
+  const hasOriginalTask = originalTask !== undefined;
+  const outputs = new Map;
+  for (const [index, step] of steps.entries()) {
+    const number = index + 1;
+    const path = `chain[${index}]`;
+    const previous = index === 0 ? { unavailable: "the first chain step has no previous output." } : { variable: `output${index}` };
+    let stepChildren;
+    let outputName;
+    if (isPlainRecord(step) && Object.hasOwn(step, "parallel")) {
+      const record = exactFields(step, path, ["parallel"], "A parallel step accepts only parallel; as is supported on sequential steps only.");
+      const items = record.parallel;
+      if (!Array.isArray(items) || items.length === 0)
+        throw new Error(`${path}.parallel must be a non-empty array of { agent, task } items.`);
+      stepChildren = items.map((item, itemIndex) => {
+        const itemPath = `${path}.parallel[${itemIndex}]`;
+        const itemRecord = exactFields(item, itemPath, ["agent", "task"], "Each parallel item accepts only agent and task.");
+        const agent = nonEmptyString(itemRecord.agent, `${itemPath}.agent`);
+        const task = nonEmptyString(itemRecord.task, `${itemPath}.task`);
+        return { key: `step-${number}-${itemIndex + 1}`, agent, taskExpression: compileTemplate(task, { path: `${itemPath}.task`, hasOriginalTask, previous, outputs }) };
+      });
+    } else {
+      const record = exactFields(step, path, ["agent", "task", "as"], "A sequential step accepts only agent, task and as; a parallel step accepts only parallel.");
+      const agent = nonEmptyString(record.agent, `${path}.agent`);
+      let task;
+      if (record.task === undefined) {
+        if (index === 0)
+          throw new Error(`${path}.task is required; the first chain step has no previous output.`);
+        task = "{previous}";
+      } else
+        task = nonEmptyString(record.task, `${path}.task`);
+      if (record.as !== undefined) {
+        if (typeof record.as !== "string" || !OUTPUT_NAME_PATTERN.test(record.as))
+          throw new Error(`${path}.as must be an identifier matching ${OUTPUT_NAME_PATTERN}.`);
+        if (outputs.has(record.as))
+          throw new Error(`${path}.as '${record.as}' is already used by an earlier step.`);
+        outputName = record.as;
+      }
+      stepChildren = [{ key: `step-${number}`, agent, taskExpression: compileTemplate(task, { path: `${path}.task`, hasOriginalTask, previous, outputs }) }];
+    }
+    lines.push(`const run${number} = ${runsAllCall(stepChildren)};`, `const step${number} = settle(run${number}, ${JSON.stringify(stepChildren.map((child) => child.agent))});`, `children.push(...step${number});`, `if (!step${number}.every(function (child) { return child.ok; })) throw failure(${JSON.stringify(`chain stopped at step ${number}`)}, step${number});`);
+    if (index < steps.length - 1)
+      lines.push(`const output${number} = step${number}.map(function (child) { return child.output; }).join("\\n\\n");`);
+    if (outputName !== undefined)
+      outputs.set(outputName, `output${number}`);
+  }
+  lines.push("return { ok: true, children };");
+  return lines.join(`
+`);
+}
+export function buildStructuredWorkflowScript(kind, steps, originalTask) {
+  return kind === "tasks" ? buildTasksScript(steps, originalTask) : buildChainScript(steps, originalTask);
+}

package/extensions/dm-subagents/src/workflows/workflow-checklist.js

@@ -1,3 +1,4 @@
+import { childThinkingLevel } from "../shared/model-info.js";
 import { sanitizeDisplayText } from "../shared/display-text.js";
 import { workflowPreflightLaneForRuntimeKey as laneFor } from "./workflow-preflight.js";
 const MAX_TEXT = 160;
@@ -75,12 +76,14 @@ function stepKey(step) {
 }
 function stepItem(step, index, phase, key = stepKey(step) ?? `step-${index + 1}`, label = step.label ?? step.description ?? stepKey(step) ?? step.agent ?? key, preflight) {
   const state = checklistState(step);
+  const thinking = childThinkingLevel(step);
   return {
     key: keyText(key, `step-${index + 1}`),
     label: keyText(label, key),
     phase,
     state,
     ...text(step.agent) ? { agent: text(step.agent) } : {},
+    ...thinking ? { thinking } : {},
     ...step.context ? { context: step.context } : {},
     ...finite(step.startedAt) !== undefined ? { startedAt: finite(step.startedAt) } : {},
     ...duration(step, undefined, state) !== undefined ? { durationMs: duration(step, undefined, state) } : {},

package/extensions/dm-subagents/src/workflows/workflow-receipt.js

@@ -4,6 +4,7 @@ import { writePrivateAtomicJson } from "../shared/atomic-json.js";
 import { parseWorkflowChildSummary } from "./workflow-child-summary.js";
 import { HOST_STEP_MAX_COUNT, assertUniqueHostStepIds, parseHostStepNode } from "../runs/shared/host-step-status.js";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../runs/shared/lane-metadata.js";
+import { projectWorkflowKeyRevival } from "./workflow-revival.js";
 export const WORKFLOW_RECEIPT_VERSION = 1;
 export const WORKFLOW_RECEIPT_FILE = "workflow-receipt.json";
 const MAX_WORKFLOW_RECEIPT_BYTES = 2 * 1024 * 1024;
@@ -368,9 +369,9 @@ export function readWorkflowReceipt(asyncDirRoot, workflowRunId) {
     if (error.code === "ENOENT") {
       const workflowDir = path.dirname(receiptPath);
       if (fs.existsSync(path.join(workflowDir, "status.json")) || fs.existsSync(path.join(workflowDir, "events.jsonl"))) {
-        throw new Error(`Workflow receipt '${workflowRunId}' is not available because the workflow may still be active or terminal receipt writing failed. Use direct child run IDs from status/events for direct resume after the normal retained-child checks.`);
+        throw new Error(`Workflow receipt '${workflowRunId}' is not available because the workflow may still be active or terminal receipt writing failed. Use direct child run IDs from status/events for direct resume after the normal retained-child checks.`, { cause: error });
       }
-      throw new Error(`Workflow receipt '${workflowRunId}' was not found.`);
+      throw new Error(`Workflow receipt '${workflowRunId}' was not found.`, { cause: error });
     }
     throw new Error(`Workflow receipt '${workflowRunId}' could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : undefined });
   }
@@ -416,9 +417,11 @@ export function resolveWorkflowReceiptResumeEntry(input) {
     throw new Error("Keyed workflow receipt resume requires latest: true.");
   const key = assertKey(input.reference.key, "keyed resume key");
   const receipt = readWorkflowReceipt(input.asyncDirRoot, input.reference.workflowRunId.trim());
-  const entry = receipt.entries[key];
-  if (!entry)
+  const recorded = receipt.entries[key];
+  if (!recorded)
     throw new Error(`Workflow receipt '${receipt.workflowRunId}' has no child key '${key}'.`);
+  const revival = recorded.latestRunId ? projectWorkflowKeyRevival(input.asyncDirRoot, receipt.workflowRunId, key, recorded.latestRunId) : undefined;
+  const entry = revival ? { ...recorded, latestRunId: revival.latestRunId, continuation: { runIds: [...recorded.continuation.runIds, ...revival.revivedRunIds] } } : recorded;
   assertResumableEntry(entry, receipt.workflowRunId, key);
   input.assertResumable?.(entry.latestRunId);
   return entry;