agent-relay 4.0.0 → 4.0.1

package/dist/index.cjs

@@ -4531,15 +4531,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path18 = [graph[toModel].parent, toModel];
+      const path19 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path18.unshift(graph[cur].parent);
+        path19.unshift(graph[cur].parent);
         fn = link2(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path18;
+      fn.conversion = path19;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -5285,17 +5285,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path18) {
-      const ctrl = callVisitor(key, node, visitor, path18);
+    function visit_(key, node, visitor, path19) {
+      const ctrl = callVisitor(key, node, visitor, path19);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path18, ctrl);
-        return visit_(key, ctrl, visitor, path18);
+        replaceNode(key, path19, ctrl);
+        return visit_(key, ctrl, visitor, path19);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path18 = Object.freeze(path18.concat(node));
+          path19 = Object.freeze(path19.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path18);
+            const ci = visit_(i, node.items[i], visitor, path19);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5306,13 +5306,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path18 = Object.freeze(path18.concat(node));
-          const ck = visit_("key", node.key, visitor, path18);
+          path19 = Object.freeze(path19.concat(node));
+          const ck = visit_("key", node.key, visitor, path19);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path18);
+          const cv = visit_("value", node.value, visitor, path19);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5333,17 +5333,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path18) {
-      const ctrl = await callVisitor(key, node, visitor, path18);
+    async function visitAsync_(key, node, visitor, path19) {
+      const ctrl = await callVisitor(key, node, visitor, path19);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path18, ctrl);
-        return visitAsync_(key, ctrl, visitor, path18);
+        replaceNode(key, path19, ctrl);
+        return visitAsync_(key, ctrl, visitor, path19);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path18 = Object.freeze(path18.concat(node));
+          path19 = Object.freeze(path19.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path18);
+            const ci = await visitAsync_(i, node.items[i], visitor, path19);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5354,13 +5354,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path18 = Object.freeze(path18.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path18);
+          path19 = Object.freeze(path19.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path19);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path18);
+          const cv = await visitAsync_("value", node.value, visitor, path19);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5387,23 +5387,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path18) {
+    function callVisitor(key, node, visitor, path19) {
       if (typeof visitor === "function")
-        return visitor(key, node, path18);
+        return visitor(key, node, path19);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path18);
+        return visitor.Map?.(key, node, path19);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path18);
+        return visitor.Seq?.(key, node, path19);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path18);
+        return visitor.Pair?.(key, node, path19);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path18);
+        return visitor.Scalar?.(key, node, path19);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path18);
+        return visitor.Alias?.(key, node, path19);
       return void 0;
     }
-    function replaceNode(key, path18, node) {
-      const parent = path18[path18.length - 1];
+    function replaceNode(key, path19, node) {
+      const parent = path19[path19.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -6011,10 +6011,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path18, value) {
+    function collectionFromPath(schema, path19, value) {
       let v = value;
-      for (let i = path18.length - 1; i >= 0; --i) {
-        const k = path18[i];
+      for (let i = path19.length - 1; i >= 0; --i) {
+        const k = path19[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -6033,7 +6033,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path18) => path18 == null || typeof path18 === "object" && !!path18[Symbol.iterator]().next().done;
+    var isEmptyPath = (path19) => path19 == null || typeof path19 === "object" && !!path19[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -6063,11 +6063,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path18, value) {
-        if (isEmptyPath(path18))
+      addIn(path19, value) {
+        if (isEmptyPath(path19))
           this.add(value);
         else {
-          const [key, ...rest] = path18;
+          const [key, ...rest] = path19;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -6081,8 +6081,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path18) {
-        const [key, ...rest] = path18;
+      deleteIn(path19) {
+        const [key, ...rest] = path19;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -6096,8 +6096,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path18, keepScalar) {
-        const [key, ...rest] = path18;
+      getIn(path19, keepScalar) {
+        const [key, ...rest] = path19;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -6115,8 +6115,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path18) {
-        const [key, ...rest] = path18;
+      hasIn(path19) {
+        const [key, ...rest] = path19;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -6126,8 +6126,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path18, value) {
-        const [key, ...rest] = path18;
+      setIn(path19, value) {
+        const [key, ...rest] = path19;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -8639,9 +8639,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path18, value) {
+      addIn(path19, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path18, value);
+          this.contents.addIn(path19, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -8716,14 +8716,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path18) {
-        if (Collection.isEmptyPath(path18)) {
+      deleteIn(path19) {
+        if (Collection.isEmptyPath(path19)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path18) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path19) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -8738,10 +8738,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path18, keepScalar) {
-        if (Collection.isEmptyPath(path18))
+      getIn(path19, keepScalar) {
+        if (Collection.isEmptyPath(path19))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path18, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path19, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -8752,10 +8752,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path18) {
-        if (Collection.isEmptyPath(path18))
+      hasIn(path19) {
+        if (Collection.isEmptyPath(path19))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path18) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path19) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -8772,13 +8772,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path18, value) {
-        if (Collection.isEmptyPath(path18)) {
+      setIn(path19, value) {
+        if (Collection.isEmptyPath(path19)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path18), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path19), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path18, value);
+          this.contents.setIn(path19, value);
         }
       }
       /**
@@ -10735,9 +10735,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path18) => {
+    visit.itemAtPath = (cst, path19) => {
       let item = cst;
-      for (const [field, index] of path18) {
+      for (const [field, index] of path19) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -10746,23 +10746,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path18) => {
-      const parent = visit.itemAtPath(cst, path18.slice(0, -1));
-      const field = path18[path18.length - 1][0];
+    visit.parentCollection = (cst, path19) => {
+      const parent = visit.itemAtPath(cst, path19.slice(0, -1));
+      const field = path19[path19.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path18, item, visitor) {
-      let ctrl = visitor(item, path18);
+    function _visit(path19, item, visitor) {
+      let ctrl = visitor(item, path19);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path18.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path19.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -10773,10 +10773,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path18);
+            ctrl = ctrl(item, path19);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path18) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path19) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -16162,7 +16162,7 @@ __export(dist_exports, {
   cloneObject: () => cloneObject,
   color: () => color,
   createWritable: () => createWritable,
-  delay: () => delay,
+  delay: () => delay2,
   figures: () => figures,
   getRenderer: () => getRenderer,
   getRendererClass: () => getRendererClass,
@@ -16246,9 +16246,9 @@ function assertFunctionOrSelf(functionOrSelf, ...args) {
 function cloneObject(obj) {
   return clone2(obj);
 }
-function delay(time3) {
-  return new Promise((resolve3) => {
-    setTimeout(resolve3, time3);
+function delay2(time3) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, time3);
   });
 }
 var import_node_util3, import_util6, import_os, import_string_decoder, import_stream2, import_rfdc, import_crypto, ANSI_ESCAPE2, ANSI_ESCAPE_CODES, ListrEnvironmentVariables, ListrErrorTypes, ListrEventType, ListrRendererSelection, ListrTaskEventType, ListrTaskState, EventManager, BaseEventMap, CLEAR_LINE_REGEX, BELL_REGEX, color, FIGURES_MAIN, FIGURES_FALLBACK, figures, ListrLogLevels, LISTR_LOGGER_STYLE, LISTR_LOGGER_STDERR_LEVELS, ListrLogger, ProcessOutputBuffer, ProcessOutputStream, ProcessOutput, ListrPromptAdapter, Spinner, ListrDefaultRendererLogLevels, LISTR_DEFAULT_RENDERER_STYLE, PRESET_TIMER, PRESET_TIMESTAMP, DefaultRenderer, SilentRenderer, SimpleRenderer, TestRendererSerializer, TestRenderer, VerboseRenderer, RENDERERS, clone2, Concurrency, ListrError, ListrRendererError, PromptError, TaskWrapper, ListrTaskEventManager, Task, ListrEventManager, Listr;
@@ -17434,8 +17434,8 @@ var init_dist = __esm({
       }
       add(fn) {
         if (this.count < this.concurrency) return this.run(fn);
-        return new Promise((resolve3) => {
-          const callback = () => resolve3(this.run(fn));
+        return new Promise((resolve4) => {
+          const callback = () => resolve4(this.run(fn));
           this.queue.add(callback);
         });
       }
@@ -17767,7 +17767,7 @@ var init_dist = __esm({
         const state = this.state;
         this.state$ = ListrTaskState.PAUSED;
         this.message$ = { paused: Date.now() + time3 };
-        await delay(time3);
+        await delay2(time3);
         this.state$ = state;
         this.message$ = { paused: null };
       }
@@ -17785,20 +17785,20 @@ var init_dist = __esm({
             this.emit(ListrTaskEventType.SUBTASK, this.subtasks);
             result = result.run(context);
           } else if (result instanceof Promise) result = result.then(handleResult2);
-          else if (isReadable(result)) result = new Promise((resolve3, reject) => {
+          else if (isReadable(result)) result = new Promise((resolve4, reject) => {
             result.on("data", (data) => {
               this.output$ = data.toString();
             });
             result.on("error", (error48) => reject(error48));
-            result.on("end", () => resolve3(null));
+            result.on("end", () => resolve4(null));
           });
-          else if (isObservable(result)) result = new Promise((resolve3, reject) => {
+          else if (isObservable(result)) result = new Promise((resolve4, reject) => {
             result.subscribe({
               next: (data) => {
                 this.output$ = data;
               },
               error: reject,
-              complete: resolve3
+              complete: resolve4
             });
           });
           return result;
@@ -18031,8 +18031,8 @@ function createWorkflowRenderer() {
   const stepHandles = /* @__PURE__ */ new Map();
   let resolveWorkflow;
   let rejectWorkflow;
-  const workflowDone = new Promise((resolve3, reject) => {
-    resolveWorkflow = resolve3;
+  const workflowDone = new Promise((resolve4, reject) => {
+    resolveWorkflow = resolve4;
     rejectWorkflow = reject;
   });
   workflowDone.catch(() => {
@@ -18085,8 +18085,8 @@ function createWorkflowRenderer() {
         let rejectStep;
         let taskRef = null;
         let skipped = false;
-        const done = new Promise((resolve3, reject) => {
-          resolveStep = resolve3;
+        const done = new Promise((resolve4, reject) => {
+          resolveStep = resolve4;
           rejectStep = reject;
         });
         done.catch(() => {
@@ -18803,8 +18803,8 @@ var init_supermemory = __esm({
       /**
        * Make a fetch request to the Supermemory API
        */
-      async fetch(path18, options) {
-        const url2 = `${this.endpoint}${path18}`;
+      async fetch(path19, options) {
+        const url2 = `${this.endpoint}${path19}`;
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
@@ -19697,6 +19697,7 @@ __export(index_exports, {
   COMMON_SEARCH_PATHS: () => COMMON_SEARCH_PATHS,
   CURSOR_MODEL_OPTIONS: () => CURSOR_MODEL_OPTIONS,
   CUSTOM_STEPS_FILE: () => CUSTOM_STEPS_FILE,
+  ChannelMessenger: () => ChannelMessenger,
   ClaudeModels: () => ClaudeModels,
   CodexModels: () => CodexModels,
   ConsensusEngine: () => ConsensusEngine,
@@ -19726,24 +19727,33 @@ __export(index_exports, {
   ShadowManager: () => ShadowManager,
   StateStore: () => StateStore,
   StaticPatterns: () => StaticPatterns,
+  StepExecutor: () => StepExecutor,
   SupermemoryAdapter: () => SupermemoryAdapter,
   SwarmCoordinator: () => SwarmCoordinator,
   SwarmPatterns: () => SwarmPatterns,
   TemplateRegistry: () => TemplateRegistry,
+  TemplateResolver: () => TemplateResolver,
   TracedError: () => TracedError,
   WorkflowBuilder: () => WorkflowBuilder,
+  WorkflowCompletionError: () => WorkflowCompletionError,
   WorkflowRunner: () => WorkflowRunner,
+  WorkflowStepLifecycleExecutor: () => StepExecutor,
   WorkflowTrajectory: () => WorkflowTrajectory,
   benchmarkPatterns: () => benchmarkPatterns,
   brokerLog: () => brokerLog,
   buildBlockReason: () => buildBlockReason,
+  buildCommand: () => buildCommand,
   buildModelSwitchCommand: () => buildModelSwitchCommand,
+  checkExitCode: () => checkExitCode,
+  checkFileExists: () => checkFileExists,
   checkForUpdates: () => checkForUpdates,
   checkForUpdatesInBackground: () => checkForUpdatesInBackground,
+  checkOutputContains: () => checkOutputContains,
   cleanLines: () => cleanLines,
   clearBinaryCache: () => clearBinaryCache,
   clearResolveCache: () => clearResolveCache,
   collectCliSession: () => collectCliSession,
+  collectOutput: () => collectOutput,
   commandExists: () => commandExists,
   connectionLog: () => connectionLog,
   countMessages: () => countMessages,
@@ -19755,12 +19765,14 @@ __export(index_exports, {
   createMemoryAdapter: () => createMemoryAdapter,
   createMemoryHooks: () => createMemoryHooks,
   createMemoryService: () => createMemoryService,
+  createProcessSpawner: () => createProcessSpawner,
   createRequestEnvelope: () => createRequestEnvelope,
   createRequestHandler: () => createRequestHandler,
   createTraceableError: () => createTraceableError,
   createTrajectoryHooks: () => createTrajectoryHooks,
   createWorkflowRenderer: () => createWorkflowRenderer,
   customStepsFileExists: () => customStepsFileExists,
+  detectCompletion: () => detectCompletion,
   estimateContextTokens: () => estimateContextTokens,
   estimateTokens: () => estimateTokens,
   executeApiStep: () => executeApiStep,
@@ -19768,10 +19780,12 @@ __export(index_exports, {
   findRelayPtyBinary: () => findRelayPtyBinary,
   followLogs: () => followLogs,
   formatDryRunReport: () => formatDryRunReport,
+  formatError: () => formatError2,
   formatMessagePreview: () => formatMessagePreview,
   formatProposalMessage: () => formatProposalMessage,
   formatResultMessage: () => formatResultMessage,
   formatRunSummaryTable: () => formatRunSummaryTable,
+  formatStepOutput: () => formatStepOutput,
   generateAgentName: () => generateAgentName,
   generateErrorId: () => generateErrorId,
   generateRequestId: () => generateRequestId,
@@ -19801,6 +19815,7 @@ __export(index_exports, {
   hasRelayPtyBinary: () => hasRelayPtyBinary,
   hasUnreadMessages: () => hasUnreadMessages,
   inboxExists: () => inboxExists,
+  interpolateStepTask: () => interpolateStepTask,
   isAgentStep: () => isAgentStep,
   isConsensusCommand: () => isConsensusCommand,
   isCustomStep: () => isCustomStep,
@@ -19833,15 +19848,28 @@ __export(index_exports, {
   resolveCliSync: () => resolveCliSync,
   resolveCommand: () => resolveCommand,
   resolveCustomStep: () => resolveCustomStep,
+  resolveDotPath: () => resolveDotPath,
   resolveSpawnPolicy: () => resolveSpawnPolicy,
+  resolveStepOutputRef: () => resolveStepOutputRef,
+  resolveTemplate: () => resolveTemplate,
+  resolveTemplateForShell: () => resolveTemplateForShell,
+  resolveVariables: () => resolveVariables,
   routerLog: () => routerLog,
+  runVerification: () => runVerification,
   runWorkflow: () => runWorkflow,
+  scrubForChannel: () => scrubForChannel,
+  scrubSecrets: () => scrubSecrets,
+  sendToChannel: () => sendToChannel,
+  shellEscape: () => shellEscape,
   spawnFromEnv: () => spawnFromEnv,
+  spawnProcess: () => spawnProcess,
   stripAnsi: () => stripAnsi,
   stripAnsiFast: () => stripAnsiFast,
+  stripInjectedTaskEcho: () => stripInjectedTaskEcho,
   toReleaseResult: () => toReleaseResult,
   toSpawnResult: () => toSpawnResult,
   trackPatternPerformance: () => trackPatternPerformance,
+  truncateMessage: () => truncateMessage,
   unescapeFenceMarkersFast: () => unescapeFenceMarkersFast,
   validateCustomStepsUsage: () => validateCustomStepsUsage,
   validateModelForCli: () => validateModelForCli,
@@ -19902,7 +19930,7 @@ var BrokerTransport = class {
     return this.baseUrl.replace(/^http/, "ws") + "/ws";
   }
   // ── HTTP ─────────────────────────────────────────────────────────────
-  async request(path18, init) {
+  async request(path19, init) {
     const headers = new Headers(init?.headers);
     if (!headers.has("Content-Type")) {
       headers.set("Content-Type", "application/json");
@@ -19911,7 +19939,7 @@ var BrokerTransport = class {
       headers.set("X-API-Key", this.apiKey);
     }
     const signal = init?.signal ?? AbortSignal.timeout(this.requestTimeoutMs);
-    const res = await fetch(`${this.baseUrl}${path18}`, { ...init, headers, signal });
+    const res = await fetch(`${this.baseUrl}${path19}`, { ...init, headers, signal });
     if (!res.ok) {
       let body;
       try {
@@ -20040,38 +20068,122 @@ var import_node_child_process = require("node:child_process");
 var import_node_module = require("node:module");
 var import_node_url = require("node:url");
 var BROKER_NAME = "agent-relay-broker";
-function getBrokerBinaryPath() {
-  let binDir = null;
+function addUniquePath(paths, candidate) {
+  if (!candidate || paths.includes(candidate)) {
+    return;
+  }
+  paths.push(candidate);
+}
+function getImportMetaUrl() {
   try {
-    const esmRequire = (0, import_node_module.createRequire)(import_meta_url);
-    const sdkEntry = esmRequire.resolve("@agent-relay/sdk");
-    binDir = (0, import_node_path.join)((0, import_node_path.dirname)(sdkEntry), "..", "bin");
+    return import_meta_url;
   } catch {
+    return null;
+  }
+}
+function getCurrentModuleDir() {
+  if (typeof __dirname === "string" && __dirname) {
+    return __dirname;
+  }
+  if (typeof __filename === "string" && __filename) {
+    return (0, import_node_path.dirname)(__filename);
+  }
+  const importMetaUrl = getImportMetaUrl();
+  if (!importMetaUrl) {
+    return null;
+  }
+  try {
+    return (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  } catch {
+    return null;
+  }
+}
+function getCurrentModuleReference() {
+  if (typeof __filename === "string" && __filename) {
+    return __filename;
+  }
+  if (typeof __dirname === "string" && __dirname) {
+    return (0, import_node_path.join)(__dirname, "broker-path.js");
+  }
+  return getImportMetaUrl();
+}
+function getSdkBinDirs() {
+  const binDirs = [];
+  const currentModuleDir = getCurrentModuleDir();
+  if (currentModuleDir) {
+    addUniquePath(binDirs, (0, import_node_path.resolve)(currentModuleDir, "..", "bin"));
+  }
+  const currentModuleReference = getCurrentModuleReference();
+  if (currentModuleReference) {
     try {
-      binDir = (0, import_node_path.join)((0, import_node_path.dirname)((0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta_url))), "bin");
+      const sdkEntry = (0, import_node_module.createRequire)(currentModuleReference).resolve("@agent-relay/sdk");
+      addUniquePath(binDirs, (0, import_node_path.resolve)((0, import_node_path.dirname)(sdkEntry), "..", "bin"));
     } catch {
     }
   }
-  if (!binDir)
-    return null;
-  const ext = process.platform === "win32" ? ".exe" : "";
-  const exactPath = (0, import_node_path.join)(binDir, `${BROKER_NAME}${ext}`);
-  if ((0, import_node_fs.existsSync)(exactPath)) {
-    return exactPath;
+  const importMetaUrl = getImportMetaUrl();
+  if (importMetaUrl) {
+    try {
+      addUniquePath(binDirs, (0, import_node_path.resolve)((0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl)), "..", "bin"));
+    } catch {
+    }
+  }
+  return binDirs;
+}
+function getDevelopmentBinaryPaths(ext, binDirs) {
+  const binaryPaths = [];
+  const repoRoots = /* @__PURE__ */ new Set();
+  const addRepoRoot = (candidate) => {
+    if (!candidate) {
+      return;
+    }
+    const repoRoot = (0, import_node_path.resolve)(candidate);
+    if (repoRoots.has(repoRoot)) {
+      return;
+    }
+    repoRoots.add(repoRoot);
+    addUniquePath(binaryPaths, (0, import_node_path.join)(repoRoot, "target", "release", `${BROKER_NAME}${ext}`));
+    addUniquePath(binaryPaths, (0, import_node_path.join)(repoRoot, "target", "debug", `${BROKER_NAME}${ext}`));
+  };
+  addRepoRoot(process.cwd());
+  const currentModuleDir = getCurrentModuleDir();
+  if (currentModuleDir) {
+    addRepoRoot((0, import_node_path.resolve)(currentModuleDir, "..", "..", ".."));
+  }
+  for (const binDir of binDirs) {
+    addRepoRoot((0, import_node_path.resolve)(binDir, "..", "..", ".."));
   }
+  return binaryPaths;
+}
+function getBrokerBinaryPath() {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const binDirs = getSdkBinDirs();
   const platformSpecific = `${BROKER_NAME}-${process.platform}-${process.arch}${ext}`;
-  const platformPath = (0, import_node_path.join)(binDir, platformSpecific);
-  if ((0, import_node_fs.existsSync)(platformPath)) {
-    return platformPath;
+  for (const binDir of binDirs) {
+    const exactPath = (0, import_node_path.join)(binDir, `${BROKER_NAME}${ext}`);
+    if ((0, import_node_fs.existsSync)(exactPath)) {
+      return exactPath;
+    }
+  }
+  for (const binDir of binDirs) {
+    const platformPath = (0, import_node_path.join)(binDir, platformSpecific);
+    if ((0, import_node_fs.existsSync)(platformPath)) {
+      return platformPath;
+    }
+  }
+  for (const developmentPath of getDevelopmentBinaryPaths(ext, binDirs)) {
+    if ((0, import_node_fs.existsSync)(developmentPath)) {
+      return developmentPath;
+    }
   }
   try {
     const cmd = process.platform === "win32" ? "where" : "which";
-    const result = (0, import_node_child_process.execSync)(`${cmd} ${BROKER_NAME}`, {
+    const result = (0, import_node_child_process.execFileSync)(cmd, [BROKER_NAME], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (result) {
-      return result.split("\n")[0].trim();
+      return result.split(/\r?\n/u)[0].trim();
     }
   } catch {
   }
@@ -20096,6 +20208,25 @@ function isProcessRunning(pid) {
     return error48.code === "EPERM";
   }
 }
+function buildBrokerInitArgs(args) {
+  if (!args) {
+    return [];
+  }
+  const cliArgs = [];
+  if (args.persist) {
+    cliArgs.push("--persist");
+  }
+  if (args.apiPort !== void 0) {
+    cliArgs.push("--api-port", String(args.apiPort));
+  }
+  if (args.apiBind !== void 0) {
+    cliArgs.push("--api-bind", args.apiBind);
+  }
+  if (args.stateDir !== void 0) {
+    cliArgs.push("--state-dir", args.stateDir);
+  }
+  return cliArgs;
+}
 var AgentRelayClient = class _AgentRelayClient {
   transport;
   /** Set after spawn() — the managed child process. */
@@ -20157,7 +20288,7 @@ var AgentRelayClient = class _AgentRelayClient {
     const brokerName = options?.brokerName ?? (import_node_path2.default.basename(cwd) || "project");
     const channels = options?.channels ?? ["general"];
     const timeoutMs = options?.startupTimeoutMs ?? 15e3;
-    const userArgs = options?.binaryArgs ?? [];
+    const userArgs = buildBrokerInitArgs(options?.binaryArgs);
     const apiKey = `br_${(0, import_node_crypto.randomBytes)(16).toString("hex")}`;
     const env = {
       ...process.env,
@@ -20408,7 +20539,7 @@ var AgentRelayClient = class _AgentRelayClient {
 };
 async function waitForApiUrl(child, timeoutMs) {
   const { createInterface: createInterface2 } = await import("node:readline");
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     if (!child.stdout) {
       reject(new Error("Broker stdout not available"));
       return;
@@ -20446,24 +20577,24 @@ async function waitForApiUrl(child, timeoutMs) {
         resolved = true;
         clearTimeout(timer);
         rl.close();
-        resolve3(match[1]);
+        resolve4(match[1]);
       }
     });
   });
 }
 function waitForExit(child, timeoutMs) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     if (child.exitCode !== null) {
-      resolve3();
+      resolve4();
       return;
     }
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve3();
+      resolve4();
     }, timeoutMs);
     child.on("exit", () => {
       clearTimeout(timer);
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -20984,8 +21115,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path18, errorMaps, issueData } = params;
-  const fullPath = [...path18, ...issueData.path || []];
+  const { data, path: path19, errorMaps, issueData } = params;
+  const fullPath = [...path19, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -21101,11 +21232,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path18, key) {
+  constructor(parent, value, path19, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path18;
+    this._path = path19;
     this._key = key;
   }
   get path() {
@@ -27416,10 +27547,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -27802,11 +27933,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -27989,7 +28120,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path18 = []) => {
+  const processError = (error49, path19 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -27999,7 +28130,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -28031,8 +28162,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -40009,13 +40140,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -41660,11 +41791,11 @@ var WsClient = class {
     this.reconnectAttempt += 1;
     const reconnectingEvent = { type: "reconnecting", attempt: this.reconnectAttempt };
     this.emit("reconnecting", reconnectingEvent);
-    const delay2 = this.computeReconnectDelayMs(this.reconnectAttempt);
+    const delay3 = this.computeReconnectDelayMs(this.reconnectAttempt);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connect();
-    }, delay2);
+    }, delay3);
   }
 };
 
@@ -42074,7 +42205,7 @@ function withInternalOrigin(options, origin) {
   return copy;
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var DEFAULT_RETRY_POLICY = {
   maxRetries: 3,
@@ -42165,8 +42296,8 @@ var HttpClient = class _HttpClient {
       version: this._originVersion
     }));
   }
-  async request(method, path18, body, query, options) {
-    const url2 = new URL(path18, this._baseUrl);
+  async request(method, path19, body, query, options) {
+    const url2 = new URL(path19, this._baseUrl);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
         if (v !== void 0)
@@ -42236,20 +42367,20 @@ var HttpClient = class _HttpClient {
       return camelizeKeys(parsedData);
     }
   }
-  get(path18, query, options) {
-    return this.request("GET", path18, void 0, query, options);
+  get(path19, query, options) {
+    return this.request("GET", path19, void 0, query, options);
   }
-  post(path18, body, options) {
-    return this.request("POST", path18, body, void 0, options);
+  post(path19, body, options) {
+    return this.request("POST", path19, body, void 0, options);
   }
-  patch(path18, body, options) {
-    return this.request("PATCH", path18, body, void 0, options);
+  patch(path19, body, options) {
+    return this.request("PATCH", path19, body, void 0, options);
   }
-  put(path18, body, options) {
-    return this.request("PUT", path18, body, void 0, options);
+  put(path19, body, options) {
+    return this.request("PUT", path19, body, void 0, options);
   }
-  async delete(path18, options) {
-    await this.request("DELETE", path18, void 0, void 0, options);
+  async delete(path19, options) {
+    await this.request("DELETE", path19, void 0, void 0, options);
   }
 };
 
@@ -43162,7 +43293,7 @@ var AgentRelay = class {
     if (!result.targets.length) {
       return { eventId: result.event_id, status: "failed", targets: [] };
     }
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       let resolved = false;
       const ackedTargets = /* @__PURE__ */ new Set();
       let unsubscribe;
@@ -43170,7 +43301,7 @@ var AgentRelay = class {
         if (!resolved) {
           resolved = true;
           unsubscribe?.();
-          resolve3({ eventId: result.event_id, status: "timeout", targets: result.targets });
+          resolve4({ eventId: result.event_id, status: "timeout", targets: result.targets });
         }
       }, timeoutMs);
       unsubscribe = client.onEvent((event) => {
@@ -43182,14 +43313,14 @@ var AgentRelay = class {
             resolved = true;
             clearTimeout(timer);
             unsubscribe?.();
-            resolve3({ eventId: result.event_id, status: "ack", targets: result.targets });
+            resolve4({ eventId: result.event_id, status: "ack", targets: result.targets });
           }
         }
         if (event.kind === "delivery_failed" && event.event_id === result.event_id && result.targets.includes(event.name)) {
           resolved = true;
           clearTimeout(timer);
           unsubscribe?.();
-          resolve3({ eventId: result.event_id, status: "failed", targets: result.targets });
+          resolve4({ eventId: result.event_id, status: "failed", targets: result.targets });
         }
       });
     });
@@ -43308,7 +43439,7 @@ var AgentRelay = class {
     if (existing && this.readyAgents.has(name)) {
       return existing;
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       let settled = false;
       let timeout;
       const cleanup = () => {
@@ -43323,7 +43454,7 @@ var AgentRelay = class {
           return;
         settled = true;
         cleanup();
-        resolve3(agent);
+        resolve4(agent);
       };
       const rejectWith = (error48) => {
         if (settled)
@@ -43356,7 +43487,7 @@ var AgentRelay = class {
     if (existing && this.messageReadyAgents.has(name)) {
       return existing;
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       let settled = false;
       let timeout;
       const cleanup = () => {
@@ -43371,7 +43502,7 @@ var AgentRelay = class {
           return;
         settled = true;
         cleanup();
-        resolve3(agent);
+        resolve4(agent);
       };
       const rejectWith = (error48) => {
         if (settled)
@@ -43786,13 +43917,13 @@ var AgentRelay = class {
         await relay.waitForAgentReady(name, timeoutMs);
       },
       waitForExit(timeoutMs) {
-        return new Promise((resolve3) => {
+        return new Promise((resolve4) => {
           if (!relay.knownAgents.has(name)) {
-            resolve3("exited");
+            resolve4("exited");
             return;
           }
           if (timeoutMs === 0) {
-            resolve3("timeout");
+            resolve4("timeout");
             return;
           }
           let timer;
@@ -43801,7 +43932,7 @@ var AgentRelay = class {
             resolve(reason) {
               if (timer)
                 clearTimeout(timer);
-              resolve3(reason);
+              resolve4(reason);
             },
             token
           });
@@ -43811,19 +43942,19 @@ var AgentRelay = class {
               if (current?.token === token) {
                 relay.exitResolvers.delete(name);
               }
-              resolve3("timeout");
+              resolve4("timeout");
             }, timeoutMs);
           }
         });
       },
       waitForIdle(timeoutMs) {
-        return new Promise((resolve3) => {
+        return new Promise((resolve4) => {
           if (!relay.knownAgents.has(name)) {
-            resolve3("exited");
+            resolve4("exited");
             return;
           }
           if (timeoutMs === 0) {
-            resolve3("timeout");
+            resolve4("timeout");
             return;
           }
           let timer;
@@ -43832,7 +43963,7 @@ var AgentRelay = class {
             resolve(reason) {
               if (timer)
                 clearTimeout(timer);
-              resolve3(reason);
+              resolve4(reason);
             },
             token
           });
@@ -43842,7 +43973,7 @@ var AgentRelay = class {
               if (current?.token === token) {
                 relay.idleResolvers.delete(name);
               }
-              resolve3("timeout");
+              resolve4("timeout");
             }, timeoutMs);
           }
         });
@@ -44826,12 +44957,12 @@ function isAgentStep(step) {
 }
 
 // packages/sdk/dist/workflows/runner.js
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs10 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_promises5 = require("node:fs/promises");
 var import_node_os7 = require("node:os");
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var import_chalk = __toESM(require_source(), 1);
 var import_yaml2 = __toESM(require_dist(), 1);
 
@@ -45089,9 +45220,9 @@ async function resolveCli(cli) {
   for (const binary of def.binaries) {
     try {
       const { stdout } = await execFileAsync("which", [binary]);
-      const path18 = stdout.trim();
-      if (path18) {
-        const result = { binary, path: path18 };
+      const path19 = stdout.trim();
+      if (path19) {
+        const result = { binary, path: path19 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -45124,13 +45255,13 @@ function resolveCliSync(cli) {
   const def = getCliDefinition(cli);
   if (!def)
     return void 0;
-  const { execFileSync } = require("node:child_process");
+  const { execFileSync: execFileSync2 } = require("node:child_process");
   for (const binary of def.binaries) {
     try {
-      const stdout = execFileSync("which", [binary], { stdio: ["pipe", "pipe", "ignore"] });
-      const path18 = stdout.toString().trim();
-      if (path18) {
-        const result = { binary, path: path18 };
+      const stdout = execFileSync2("which", [binary], { stdio: ["pipe", "pipe", "ignore"] });
+      const path19 = stdout.toString().trim();
+      if (path19) {
+        const result = { binary, path: path19 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -46282,6 +46413,224 @@ async function executeApiStep(model, task, options = {}) {
   return response.content;
 }
 
+// packages/sdk/dist/workflows/channel-messenger.js
+async function sendToChannel(relay, channel, message) {
+  await relay.send(channel, message);
+}
+function truncateMessage(message, maxLength) {
+  if (maxLength <= 0)
+    return "";
+  return message.length > maxLength ? message.slice(-maxLength) : message;
+}
+function formatStepOutput(stepName, output, maxLength = 2e3) {
+  const scrubbed = scrubForChannel(output);
+  if (scrubbed.length === 0) {
+    return `**[${stepName}]** Step completed \u2014 output written to disk`;
+  }
+  const preview = truncateMessage(scrubbed, maxLength);
+  return `**[${stepName}] Output:**
+\`\`\`
+${preview}
+\`\`\``;
+}
+function formatError2(stepName, error48) {
+  const raw = error48 instanceof Error ? error48.message : String(error48);
+  const message = raw.replace(/(?:\/[\w.-]+){3,}/g, "[path]");
+  return `**[${stepName}]** Failed: ${message}`;
+}
+var SECRET_PATTERNS = [
+  /(?:api[_-]?key|apikey|secret[_-]?key|access[_-]?token|auth[_-]?token|bearer)\s*[:=]\s*\S+/gi,
+  /(?:sk|pk|rk|ak)[-_][a-zA-Z0-9]{20,}/g,
+  /ghp_[a-zA-Z0-9]{36,}/g,
+  /gho_[a-zA-Z0-9]{36,}/g,
+  /github_pat_[a-zA-Z0-9_]{22,}/g,
+  /xox[bpors]-[a-zA-Z0-9-]+/g,
+  /-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----[\s\S]*?-----END/g
+];
+var SPINNER = "\\u2756\\u2738\\u2739\\u273a\\u273b\\u273c\\u273d\\u2731\\u2732\\u2733\\u2734\\u2735\\u2736\\u2737\\u2743\\u2745\\u2746\\u25d6\\u25d7\\u25d8\\u25d9\\u2022\\u25cf\\u25cb\\u25a0\\u25a1\\u25b6\\u25c0\\u23f5\\u23f6\\u23f7\\u23f8\\u23f9\\u25e2\\u25e3\\u25e4\\u25e5\\u2597\\u2596\\u2598\\u259d\\u2bc8\\u2bc7\\u2bc5\\u2bc6\\u00b7\\u2590\\u258c\\u2588\\u2584\\u2580\\u259a\\u259e\\u2b21\\u2b22";
+var SPINNER_RE = new RegExp(`[${SPINNER}]`, "gu");
+var SPINNER_CLASS_RE = new RegExp(`^[\\s${SPINNER}]*$`, "u");
+var BOX_DRAWING_ONLY_RE = /^[\s\u2500-\u257f\u2580-\u259f\u25a0-\u25ff\-_=~]{3,}$/u;
+var BROKER_LOG_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s+(?:INFO|WARN|ERROR|DEBUG)\s/u;
+var CLAUDE_HEADER_RE = /^(?:[\s\u2580-\u259f✢*·▗▖▘▝]+\s*)?(?:Claude\s+Code(?:\s+v?[\d.]+)?|(?:Sonnet|Haiku|Opus)\s*[\d.]+|claude-(?:sonnet|haiku|opus)-[\w.-]+|Running\s+on\s+claude)/iu;
+var DIR_BREADCRUMB_RE = /^\s*~[\\/]/u;
+var UI_HINT_RE = /\b(?:Press\s+up\s+to\s+edit|tab\s+to\s+queue|bypass\s+permissions|esc\s+to\s+interrupt)\b/iu;
+var THINKING_LINE_RE = new RegExp(`^[\\s${SPINNER}]*\\s*\\w[\\w\\s]*\\u2026\\s*$`, "u");
+var CURSOR_ONLY_RE = /^[\s❯⎿›»◀▶←→↑↓⟨⟩⟪⟫·]+$/u;
+var CURSOR_AGENT_RE = /^(?:Cursor Agent|[\s⬡⬢]*Generating[.\s]|\[Pasted text|Auto-run all|Add a follow-up|ctrl\+c to stop|shift\+tab|Auto$|\/\s*commands|@\s*files|!\s*shell|follow-ups?\s|The user ha)/iu;
+var SLASH_COMMAND_RE = /^\/\w+\s*$/u;
+var MCP_JSON_KV_RE = /^\s*"(?:type|method|params|result|id|jsonrpc|tool|name|arguments|content|role|metadata)"\s*:/u;
+var MEANINGFUL_CONTENT_RE = /[a-zA-Z0-9]/u;
+function scrubSecrets(text) {
+  let result = text;
+  for (const pattern of SECRET_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+function scrubForChannel(text) {
+  let withoutSystemReminders = text;
+  const openTag = "<system-reminder>";
+  const closeTag = "</system-reminder>";
+  let idx;
+  while ((idx = withoutSystemReminders.toLowerCase().indexOf(openTag)) !== -1) {
+    const closeIdx = withoutSystemReminders.toLowerCase().indexOf(closeTag, idx + openTag.length);
+    if (closeIdx !== -1) {
+      withoutSystemReminders = withoutSystemReminders.slice(0, idx) + withoutSystemReminders.slice(closeIdx + closeTag.length);
+    } else {
+      withoutSystemReminders = withoutSystemReminders.slice(0, idx);
+      break;
+    }
+  }
+  const normalized = withoutSystemReminders.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const ansiStripped = stripAnsi(normalized);
+  const secretsRedacted = scrubSecrets(ansiStripped);
+  const countJsonDepth = (line) => {
+    let depth = 0;
+    for (const ch of line) {
+      if (ch === "{" || ch === "[")
+        depth += 1;
+      if (ch === "}" || ch === "]")
+        depth -= 1;
+    }
+    return depth;
+  };
+  const lines = secretsRedacted.split("\n");
+  const meaningful = [];
+  let jsonDepth = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (jsonDepth > 0) {
+      jsonDepth += countJsonDepth(line);
+      if (jsonDepth <= 0)
+        jsonDepth = 0;
+      continue;
+    }
+    if (trimmed.length === 0)
+      continue;
+    if (trimmed.startsWith("{") || /^\[\s*\{/.test(trimmed)) {
+      jsonDepth = Math.max(countJsonDepth(line), 0);
+      continue;
+    }
+    if (MCP_JSON_KV_RE.test(line))
+      continue;
+    if (SPINNER_CLASS_RE.test(trimmed))
+      continue;
+    if (BOX_DRAWING_ONLY_RE.test(trimmed))
+      continue;
+    if (BROKER_LOG_RE.test(trimmed))
+      continue;
+    if (CLAUDE_HEADER_RE.test(trimmed))
+      continue;
+    if (DIR_BREADCRUMB_RE.test(trimmed))
+      continue;
+    if (UI_HINT_RE.test(trimmed))
+      continue;
+    if (THINKING_LINE_RE.test(trimmed))
+      continue;
+    if (CURSOR_ONLY_RE.test(trimmed))
+      continue;
+    if (CURSOR_AGENT_RE.test(trimmed))
+      continue;
+    if (SLASH_COMMAND_RE.test(trimmed))
+      continue;
+    if (!MEANINGFUL_CONTENT_RE.test(trimmed))
+      continue;
+    const alphanum = trimmed.replace(SPINNER_RE, "").replace(/\s+/g, "");
+    if (alphanum.replace(/[^a-zA-Z0-9]/g, "").length <= 3)
+      continue;
+    meaningful.push(line);
+  }
+  return meaningful.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+var ChannelMessenger = class {
+  postFn;
+  constructor(options = {}) {
+    this.postFn = options.postFn;
+  }
+  buildNonInteractiveAwareness(agentMap, stepStates) {
+    const nonInteractive = [...agentMap.values()].filter((agent) => agent.interactive === false);
+    if (nonInteractive.length === 0)
+      return void 0;
+    const agentToSteps = /* @__PURE__ */ new Map();
+    for (const [stepName, state] of stepStates) {
+      const agentName = state.row.agentName;
+      if (!agentName)
+        continue;
+      if (!agentToSteps.has(agentName))
+        agentToSteps.set(agentName, []);
+      agentToSteps.get(agentName).push(stepName);
+    }
+    const lines = nonInteractive.map((agent) => {
+      const stepRefs = (agentToSteps.get(agent.name) ?? []).map((stepName) => `{{steps.${stepName}.output}}`);
+      return `- ${agent.name} (${agent.cli}) \u2014 will return output when complete` + (stepRefs.length > 0 ? `. Access via: ${stepRefs.join(", ")}` : "");
+    });
+    return "\n\n---\nNote: The following agents are non-interactive workers and cannot receive messages:\n" + lines.join("\n") + "\nDo NOT attempt to message these agents. Use the {{steps.<name>.output}} references above to access their results.";
+  }
+  buildRelayRegistrationNote(cli, agentName) {
+    if (cli === "claude")
+      return "";
+    return `---
+RELAY SETUP \u2014 do this FIRST before any other relay tool:
+1. Call: register(name="${agentName}")
+   This authenticates you in the Relaycast workspace.
+   ALL relay tools (mcp__relaycast__message_dm_send, mcp__relaycast__message_inbox_check, mcp__relaycast__message_post, etc.) require
+   registration first \u2014 they will fail with "Not registered" otherwise.
+2. Your agent name is "${agentName}" \u2014 use this exact name when registering.`;
+  }
+  buildDelegationGuidance(cli, timeoutMs) {
+    const timeoutNote = timeoutMs ? `You have approximately ${Math.round(timeoutMs / 6e4)} minutes before this step times out. Plan accordingly \u2014 delegate early if the work is substantial.
+
+` : "";
+    const subAgentOption = cli === "claude" ? "Option 2 \u2014 Use built-in sub-agents (Task tool) for research or scoped work:\n  - Good for exploring code, reading files, or making targeted changes\n  - Can run multiple sub-agents in parallel\n\n" : "";
+    return "---\nAUTONOMOUS DELEGATION \u2014 READ THIS BEFORE STARTING:\n" + timeoutNote + 'Before diving in, assess whether this task is too large or complex for a single agent. If it involves multiple independent subtasks, touches many files, or could take a long time, you should break it down and delegate to helper agents to avoid timeouts.\n\nOption 1 \u2014 Spawn relay agents (for real parallel coding work):\n  - mcp__relaycast__agent_add(name="helper-1", cli="claude", task="Specific subtask description")\n  - Coordinate via mcp__relaycast__message_dm_send(to="helper-1", text="...")\n  - Check on them with mcp__relaycast__message_inbox_check()\n  - Clean up when done: mcp__relaycast__agent_remove(name="helper-1")\n\n' + subAgentOption + `Guidelines:
+- You are the lead \u2014 delegate but stay in control, track progress, integrate results
+- Give each helper a clear, self-contained task with enough context to work independently
+- For simple or quick work, just do it yourself \u2014 don't over-delegate
+- Always release spawned relay agents when their work is complete
+- When spawning non-claude agents (codex, gemini, etc.), prepend to their task:
+  "RELAY SETUP: First call register(name='<exact-agent-name>') before any other relay tool."`;
+  }
+  postCompletionReport(workflowName, outcomes, summary, confidence) {
+    const completed = outcomes.filter((outcome) => outcome.status === "completed");
+    const skipped = outcomes.filter((outcome) => outcome.status === "skipped");
+    const retried = outcomes.filter((outcome) => outcome.attempts > 1);
+    const lines = [
+      `## Workflow **${workflowName}** \u2014 Complete`,
+      "",
+      summary,
+      `Confidence: ${Math.round(confidence * 100)}%`,
+      "",
+      "### Steps",
+      ...completed.map((outcome) => `- **${outcome.name}** (${outcome.agent}) \u2014 passed${outcome.verificationPassed ? " (verified)" : ""}${outcome.attempts > 1 ? ` after ${outcome.attempts} attempts` : ""}`),
+      ...skipped.map((outcome) => `- **${outcome.name}** \u2014 skipped`)
+    ];
+    if (retried.length > 0) {
+      lines.push("", "### Retries");
+      for (const outcome of retried) {
+        lines.push(`- ${outcome.name}: ${outcome.attempts} attempts`);
+      }
+    }
+    this.postFn?.(lines.join("\n"));
+  }
+  postFailureReport(workflowName, outcomes, errorMsg) {
+    const completed = outcomes.filter((outcome) => outcome.status === "completed");
+    const failed = outcomes.filter((outcome) => outcome.status === "failed");
+    const skipped = outcomes.filter((outcome) => outcome.status === "skipped");
+    const lines = [
+      `## Workflow **${workflowName}** \u2014 Failed`,
+      "",
+      `${completed.length}/${outcomes.length} steps passed. Error: ${errorMsg}`,
+      "",
+      "### Steps",
+      ...completed.map((outcome) => `- **${outcome.name}** (${outcome.agent}) \u2014 passed`),
+      ...failed.map((outcome) => `- **${outcome.name}** (${outcome.agent}) \u2014 FAILED: ${outcome.error ?? "unknown"}`),
+      ...skipped.map((outcome) => `- **${outcome.name}** \u2014 skipped`)
+    ];
+    this.postFn?.(lines.join("\n"));
+  }
+};
+
 // packages/sdk/dist/workflows/memory-db.js
 var InMemoryWorkflowDb = class {
   runs = /* @__PURE__ */ new Map();
@@ -46312,6 +46661,265 @@ var InMemoryWorkflowDb = class {
   }
 };
 
+// packages/sdk/dist/workflows/process-spawner.js
+var import_node_child_process5 = require("node:child_process");
+
+// packages/sdk/dist/workflows/verification.js
+var import_node_fs9 = require("node:fs");
+var import_node_path12 = __toESM(require("node:path"), 1);
+var WorkflowCompletionError = class extends Error {
+  completionReason;
+  constructor(message, completionReason) {
+    super(message);
+    this.name = "WorkflowCompletionError";
+    this.completionReason = completionReason;
+  }
+};
+function runVerification(check2, output, stepName, injectedTaskText, options = {}, sideEffects = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const fail = (message) => {
+    const observedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+    sideEffects.recordStepToolSideEffect?.(stepName, {
+      type: "verification_observed",
+      detail: message,
+      observedAt: observedAt2,
+      raw: { passed: false, type: check2.type, value: check2.value }
+    });
+    sideEffects.getOrCreateStepEvidenceRecord?.(stepName).evidence.coordinationSignals.push({
+      kind: "verification_failed",
+      source: "verification",
+      text: message,
+      observedAt: observedAt2,
+      value: check2.value
+    });
+    if (options.allowFailure) {
+      return {
+        passed: false,
+        completionReason: "failed_verification",
+        error: message
+      };
+    }
+    throw new WorkflowCompletionError(message, "failed_verification");
+  };
+  switch (check2.type) {
+    case "output_contains": {
+      const token = check2.value;
+      if (!checkOutputContains(output, token, injectedTaskText)) {
+        return fail(`Verification failed for "${stepName}": output does not contain "${token}"`);
+      }
+      break;
+    }
+    case "exit_code":
+      if (!checkExitCode(check2.value)) {
+        return fail(`Verification failed for "${stepName}": exit code did not match "${check2.value}"`);
+      }
+      break;
+    case "file_exists":
+      if (!checkFileExists(check2.value, cwd)) {
+        return fail(`Verification failed for "${stepName}": file "${check2.value}" does not exist`);
+      }
+      break;
+    case "custom":
+      return { passed: false };
+    default:
+      break;
+  }
+  if (options.completionMarkerFound === false) {
+    sideEffects.log?.(`[${stepName}] Verification passed without legacy STEP_COMPLETE marker; allowing completion`);
+  }
+  const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const successMessage = options.completionMarkerFound === false ? "Verification passed without legacy STEP_COMPLETE marker" : "Verification passed";
+  sideEffects.recordStepToolSideEffect?.(stepName, {
+    type: "verification_observed",
+    detail: successMessage,
+    observedAt,
+    raw: { passed: true, type: check2.type, value: check2.value }
+  });
+  sideEffects.getOrCreateStepEvidenceRecord?.(stepName).evidence.coordinationSignals.push({
+    kind: "verification_passed",
+    source: "verification",
+    text: successMessage,
+    observedAt,
+    value: check2.value
+  });
+  return {
+    passed: true,
+    completionReason: "completed_verified"
+  };
+}
+function stripInjectedTaskEcho(output, injectedTaskText) {
+  if (!injectedTaskText) {
+    return output;
+  }
+  const candidates = [
+    injectedTaskText,
+    injectedTaskText.replace(/\r\n/g, "\n"),
+    injectedTaskText.replace(/\n/g, "\r\n")
+  ].filter((candidate, index, all) => candidate.length > 0 && all.indexOf(candidate) === index);
+  for (const candidate of candidates) {
+    const start = output.indexOf(candidate);
+    if (start !== -1) {
+      return output.slice(0, start) + output.slice(start + candidate.length);
+    }
+  }
+  return output;
+}
+function checkExitCode(_expectedExitCode) {
+  return true;
+}
+function checkOutputContains(output, token, injectedTaskText) {
+  if (!token) {
+    return false;
+  }
+  return stripInjectedTaskEcho(output, injectedTaskText).includes(token);
+}
+function checkFileExists(filePath, cwd = process.cwd()) {
+  const normalizedCwd = import_node_path12.default.resolve(cwd);
+  const resolved = import_node_path12.default.resolve(normalizedCwd, filePath);
+  if (!resolved.startsWith(normalizedCwd + import_node_path12.default.sep) && resolved !== normalizedCwd) {
+    return false;
+  }
+  return (0, import_node_fs9.existsSync)(resolved);
+}
+
+// packages/sdk/dist/workflows/process-spawner.js
+function resolveNonInteractiveCli(cli) {
+  if (cli !== "cursor") {
+    return cli;
+  }
+  const resolved = resolveCliSync("cursor");
+  return resolved?.binary ?? "agent";
+}
+function buildCommand(cli, extraArgs = [], task) {
+  if (cli === "api") {
+    throw new Error('cli "api" uses direct API calls, not a subprocess command');
+  }
+  const resolvedCli = resolveNonInteractiveCli(cli);
+  const definition = getCliDefinition(resolvedCli);
+  if (!definition || definition.binaries.length === 0) {
+    throw new Error(`Unknown or non-executable CLI: ${resolvedCli}`);
+  }
+  return [definition.binaries[0], ...definition.nonInteractiveArgs(task, extraArgs)];
+}
+function spawnProcess(command, options) {
+  const [bin, ...args] = command;
+  return (0, import_node_child_process5.spawn)(bin, args, options);
+}
+function collectOutput(process8) {
+  return new Promise((resolve4, reject) => {
+    let settled = false;
+    const stdout = [];
+    const stderr = [];
+    process8.stdout?.on("data", (chunk) => {
+      stdout.push(chunk.toString());
+    });
+    process8.stderr?.on("data", (chunk) => {
+      stderr.push(chunk.toString());
+    });
+    process8.once("error", (err) => {
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+    process8.once("close", () => {
+      if (!settled) {
+        settled = true;
+        resolve4(`${stdout.join("")}${stderr.join("")}`);
+      }
+    });
+  });
+}
+function detectCompletion(output, verification) {
+  if (/OWNER_DECISION:\s*(?:INCOMPLETE_RETRY|INCOMPLETE_FAIL|NEEDS_CLARIFICATION)\b/i.test(output)) {
+    return false;
+  }
+  if (/OWNER_DECISION:\s*COMPLETE\b/i.test(output)) {
+    return true;
+  }
+  if (/\bSTEP_COMPLETE:([A-Za-z0-9_.:-]+)/.test(output)) {
+    return true;
+  }
+  if (!verification) {
+    return false;
+  }
+  return runVerification(verification, output, "process", void 0, { allowFailure: true }).passed;
+}
+async function runCommand(command, opts) {
+  const child = spawnProcess([command.bin, ...command.args], {
+    cwd: opts.cwd,
+    env: { ...process.env, ...command.env },
+    stdio: "pipe"
+  });
+  const outputPromise = collectOutput(child);
+  const exitPromise = new Promise((resolve4, reject) => {
+    let timedOut = false;
+    let timer;
+    let killTimer;
+    if (opts.timeoutMs) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        killTimer = setTimeout(() => child.kill("SIGKILL"), 5e3);
+      }, opts.timeoutMs);
+    }
+    const clearTimer = () => {
+      if (timer)
+        clearTimeout(timer);
+      if (killTimer)
+        clearTimeout(killTimer);
+    };
+    child.once("error", (error48) => {
+      clearTimer();
+      reject(error48);
+    });
+    child.once("close", (exitCode, exitSignal) => {
+      clearTimer();
+      if (timedOut) {
+        reject(new Error(`Process timed out after ${opts.timeoutMs ?? "unknown"}ms`));
+        return;
+      }
+      resolve4({
+        exitCode: exitCode ?? void 0,
+        exitSignal: exitSignal ?? void 0
+      });
+    });
+  });
+  const [outputResult, exitResult] = await Promise.allSettled([outputPromise, exitPromise]);
+  const output = outputResult.status === "fulfilled" ? outputResult.value : "";
+  if (exitResult.status === "rejected") {
+    const err = exitResult.reason instanceof Error ? exitResult.reason : new Error(String(exitResult.reason));
+    err.partialOutput = output;
+    throw err;
+  }
+  return {
+    output,
+    exitCode: exitResult.value.exitCode,
+    exitSignal: exitResult.value.exitSignal
+  };
+}
+function createProcessSpawner(deps) {
+  const buildAgentCommand = (agent, task) => {
+    const extraArgs = agent.constraints?.model ? ["--model", agent.constraints.model] : [];
+    const [bin, ...args] = buildCommand(agent.cli, extraArgs, task);
+    return { bin, args };
+  };
+  return {
+    async spawnShell(command, opts) {
+      return runCommand({ bin: "sh", args: ["-c", command] }, { ...opts, cwd: opts.cwd ?? deps.cwd });
+    },
+    async spawnAgent(agent, task, opts) {
+      return runCommand(buildAgentCommand(agent, task), { ...opts, cwd: opts.cwd ?? deps.cwd });
+    },
+    async spawnInteractive(agent, task, opts) {
+      return runCommand(buildAgentCommand(agent, task), { ...opts, cwd: opts.cwd ?? deps.cwd });
+    },
+    buildCommand(agent, task) {
+      return buildAgentCommand(agent, task);
+    }
+  };
+}
+
 // packages/sdk/dist/workflows/run-summary-table.js
 function formatCurrency(value) {
   return typeof value === "number" ? `$${value.toFixed(2)}` : "--";
@@ -46403,11 +47011,528 @@ function formatRunSummaryTable(outcomes, reports) {
   return lines.map((line) => `  ${line}`).join("\n");
 }
 
+// packages/sdk/dist/workflows/template-resolver.js
+function shellEscape(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+var TEMPLATE_VARIABLE_PATTERN = /\{\{([\w][\w.\-]*)\}\}/g;
+var STEP_OUTPUT_TEMPLATE_PATTERN = /\{\{(steps\.[\w\-]+\.output)\}\}/g;
+var STEP_OUTPUT_REF_PATTERN = /^steps\.([\w\-]+)\.output$/;
+function resolveVariables(config2, vars) {
+  const resolved = structuredClone(config2);
+  for (const agent of resolved.agents) {
+    if (agent.task) {
+      agent.task = resolveTemplate(agent.task, vars);
+    }
+  }
+  if (resolved.workflows) {
+    for (const workflow2 of resolved.workflows) {
+      for (const step of workflow2.steps) {
+        if (step.task) {
+          step.task = resolveTemplate(step.task, vars);
+        }
+        if (step.command) {
+          step.command = resolveTemplateForShell(step.command, vars);
+        }
+        if (step.params && typeof step.params === "object") {
+          for (const key of Object.keys(step.params)) {
+            const value = step.params[key];
+            if (typeof value === "string") {
+              step.params[key] = resolveTemplate(value, vars);
+            }
+          }
+        }
+      }
+    }
+  }
+  return resolved;
+}
+function resolveTemplate(template, context) {
+  return template.replace(TEMPLATE_VARIABLE_PATTERN, (match, key) => {
+    if (key.startsWith("steps.")) {
+      return match;
+    }
+    const value = resolveDotPath(key, context);
+    if (value === void 0) {
+      throw new Error(`Unresolved variable: {{${key}}}`);
+    }
+    return String(value);
+  });
+}
+function resolveTemplateForShell(template, context) {
+  return template.replace(TEMPLATE_VARIABLE_PATTERN, (match, key) => {
+    if (key.startsWith("steps.")) {
+      return match;
+    }
+    const value = resolveDotPath(key, context);
+    if (value === void 0) {
+      throw new Error(`Unresolved variable: {{${key}}}`);
+    }
+    return shellEscape(String(value));
+  });
+}
+function resolveDotPath(key, context) {
+  if (!key.includes(".")) {
+    return toTemplateScalar(context[key]);
+  }
+  const parts = key.split(".");
+  let current = context;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return toTemplateScalar(current);
+}
+function resolveStepOutputRef(ref, stepOutputs) {
+  const normalizedRef = ref.startsWith("{{") && ref.endsWith("}}") ? ref.slice(2, -2).trim() : ref;
+  const match = STEP_OUTPUT_REF_PATTERN.exec(normalizedRef);
+  if (!match) {
+    throw new Error(`Invalid step output reference: ${ref}`);
+  }
+  const stepOutput = stepOutputs.get(match[1]);
+  if (stepOutput === void 0) {
+    throw new Error(`Unresolved step output reference: ${ref}`);
+  }
+  return stepOutput;
+}
+function interpolateStepTask(template, context) {
+  const stepOutputs = buildStepOutputMap(context);
+  return template.replace(STEP_OUTPUT_TEMPLATE_PATTERN, (match, ref) => {
+    try {
+      return resolveStepOutputRef(ref, stepOutputs);
+    } catch {
+      return match;
+    }
+  });
+}
+function buildStepOutputMap(context) {
+  const stepOutputs = /* @__PURE__ */ new Map();
+  const steps = context.steps;
+  if (!steps || typeof steps !== "object") {
+    return stepOutputs;
+  }
+  for (const [stepName, stepState] of Object.entries(steps)) {
+    if (!stepState || typeof stepState !== "object") {
+      continue;
+    }
+    const output = toTemplateScalar(stepState.output);
+    if (output !== void 0) {
+      stepOutputs.set(stepName, String(output));
+    }
+  }
+  return stepOutputs;
+}
+function toTemplateScalar(value) {
+  if (value === void 0 || value === null)
+    return void 0;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return String(value);
+}
+var TemplateResolver = class {
+  resolveVariables(config2, vars) {
+    return resolveVariables(config2, vars);
+  }
+  interpolate(template, vars) {
+    return resolveTemplate(template, vars);
+  }
+  resolveDotPath(key, vars) {
+    return resolveDotPath(key, vars);
+  }
+  interpolateStepTask(template, context) {
+    return interpolateStepTask(template, context);
+  }
+};
+
+// packages/sdk/dist/workflows/step-executor.js
+var StepExecutor = class {
+  deps;
+  templateResolver;
+  channelMessenger;
+  verificationRunner;
+  constructor(deps) {
+    this.deps = deps;
+    this.templateResolver = deps.templateResolver ?? new TemplateResolver();
+    this.channelMessenger = deps.channelMessenger ?? new ChannelMessenger({ postFn: deps.postToChannel });
+    this.verificationRunner = deps.verificationRunner ?? runVerification;
+  }
+  findReady(steps, statuses) {
+    return steps.filter((step) => {
+      const state = statuses.get(step.name);
+      const status = this.getStatus(state);
+      if (status !== "pending")
+        return false;
+      return (step.dependsOn ?? []).every((dependency) => {
+        const depState = statuses.get(dependency);
+        const depStatus = this.getStatus(depState);
+        return depStatus === "completed" || depStatus === "skipped";
+      });
+    });
+  }
+  /** @deprecated Use {@link findReady} instead. This is an alias kept for backward compatibility. */
+  findReadySteps(steps, statuses) {
+    return this.findReady(steps, statuses);
+  }
+  scheduleStep(step, options = {}) {
+    return {
+      step,
+      readyAt: options.readyAt ?? Date.now(),
+      staggerDelay: options.staggerDelay ?? 0
+    };
+  }
+  async startStep(step, state, startMessage) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    state.row.status = "running";
+    state.row.error = void 0;
+    state.row.completionReason = void 0;
+    state.row.startedAt = startedAt;
+    await this.deps.persistStepRow?.(state.row.id, {
+      status: "running",
+      error: void 0,
+      completionReason: void 0,
+      startedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (startMessage) {
+      this.deps.postToChannel?.(startMessage);
+    }
+    await this.deps.onStepStarted?.(step, state);
+  }
+  async retryStep(step, state, attempt, maxRetries) {
+    state.row.retryCount = attempt;
+    await this.deps.persistStepRow?.(state.row.id, {
+      retryCount: attempt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.deps.onStepRetried?.(step, state, attempt, maxRetries);
+  }
+  async completeStep(step, state, result) {
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const finalResult = {
+      status: result.status ?? "completed",
+      output: result.output ?? "",
+      exitCode: result.exitCode,
+      exitSignal: result.exitSignal,
+      duration: result.duration ?? 0,
+      retries: result.retries ?? state.row.retryCount,
+      completionReason: result.completionReason,
+      error: result.error
+    };
+    state.row.status = finalResult.status;
+    state.row.output = finalResult.output;
+    state.row.error = finalResult.error;
+    state.row.completionReason = finalResult.completionReason;
+    state.row.completedAt = completedAt;
+    await this.deps.persistStepRow?.(state.row.id, {
+      status: finalResult.status,
+      output: finalResult.output,
+      error: finalResult.error,
+      completionReason: finalResult.completionReason,
+      completedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (finalResult.status === "completed" && this.deps.runId && finalResult.output) {
+      await this.deps.persistStepOutput?.(this.deps.runId, step.name, finalResult.output);
+    }
+    if (finalResult.status === "failed") {
+      await this.deps.onStepFailed?.(step, state, finalResult);
+    } else {
+      await this.deps.onStepCompleted?.(step, state, finalResult);
+    }
+    return finalResult;
+  }
+  async monitorStep(step, state, options) {
+    const maxRetries = options.maxRetries ?? 0;
+    const retryDelayMs = options.retryDelayMs ?? 1e3;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+      this.deps.checkAborted?.();
+      await this.deps.waitIfPaused?.();
+      if (attempt > 0) {
+        await this.retryStep(step, state, attempt, maxRetries);
+        await options.onRetry?.(attempt, maxRetries, state);
+        if (retryDelayMs > 0) {
+          await delay(retryDelayMs);
+        }
+      }
+      const attemptStartedAt = Date.now();
+      await this.startStep(step, state, options.startMessage);
+      await options.onStart?.(attempt, state);
+      try {
+        const rawResult = await options.execute(attempt, state);
+        const completion = options.toCompletionResult(rawResult, attempt, state);
+        return await this.completeStep(step, state, {
+          ...completion,
+          duration: completion.duration ?? Date.now() - attemptStartedAt,
+          retries: completion.retries ?? attempt
+        });
+      } catch (error48) {
+        lastError = error48;
+        await options.onAttemptFailed?.(error48, attempt, state);
+      }
+    }
+    const failure = options.getFailureResult?.(lastError, maxRetries, state) ?? {
+      status: "failed",
+      output: "",
+      error: lastError instanceof Error ? lastError.message : String(lastError ?? "Unknown error"),
+      retries: maxRetries
+    };
+    return this.completeStep(step, state, {
+      ...failure,
+      status: "failed"
+    });
+  }
+  async executeAll(steps, agentMap, errorHandling, providedStates) {
+    const states = providedStates ?? this.createEphemeralStates(steps);
+    const strategy = normalizeStrategy(errorHandling?.strategy ?? "fail-fast");
+    const results = /* @__PURE__ */ new Map();
+    while (true) {
+      this.deps.checkAborted?.();
+      await this.deps.waitIfPaused?.();
+      const readySteps = this.findReady(steps, states);
+      if (readySteps.length === 0)
+        break;
+      const schedules = readySteps.map((step, index) => this.scheduleStep(step, {
+        readyAt: Date.now(),
+        staggerDelay: readySteps.length > 3 ? index * 2e3 : 0
+      }));
+      if (schedules.length > 1) {
+        await this.deps.onBeginTrack?.(readySteps);
+      }
+      const settled = await Promise.allSettled(schedules.map(async (schedule) => {
+        if (schedule.staggerDelay > 0) {
+          await delay(schedule.staggerDelay);
+        }
+        return this.executeScheduledStep(schedule.step, states, agentMap, errorHandling);
+      }));
+      const batchOutcomes = [];
+      for (let index = 0; index < settled.length; index += 1) {
+        const settledResult = settled[index];
+        const step = readySteps[index];
+        const state = states.get(step.name);
+        if (settledResult.status === "fulfilled") {
+          const result = settledResult.value;
+          const outcomeStatus = result.status === "completed" || result.status === "skipped" ? result.status : "failed";
+          results.set(step.name, result);
+          batchOutcomes.push({
+            name: step.name,
+            agent: step.agent ?? "deterministic",
+            status: outcomeStatus,
+            attempts: result.retries + 1,
+            output: result.output,
+            error: result.error,
+            verificationPassed: outcomeStatus === "completed" && step.verification !== void 0,
+            completionMode: result.completionReason !== void 0 ? this.deps.buildCompletionMode?.(step.name, result.completionReason) : void 0
+          });
+          if (result.status === "failed") {
+            await this.deps.markDownstreamSkipped?.(step.name);
+            if (strategy === "fail-fast") {
+              throw new Error(`Step "${step.name}" failed: ${result.error ?? "unknown error"}`);
+            }
+          }
+          continue;
+        }
+        const error48 = settledResult.reason instanceof Error ? settledResult.reason.message : String(settledResult.reason);
+        if (state) {
+          const failed = state.row.status === "failed" ? {
+            status: "failed",
+            output: state.row.output ?? "",
+            duration: 0,
+            retries: state.row.retryCount,
+            completionReason: state.row.completionReason,
+            error: state.row.error ?? error48
+          } : await this.completeStep(step, state, {
+            status: "failed",
+            output: "",
+            error: error48,
+            retries: state.row.retryCount
+          });
+          results.set(step.name, failed);
+        }
+        batchOutcomes.push({
+          name: step.name,
+          agent: step.agent ?? "deterministic",
+          status: "failed",
+          attempts: (state?.row.retryCount ?? 0) + 1,
+          error: error48
+        });
+        await this.deps.markDownstreamSkipped?.(step.name);
+        if (strategy === "fail-fast") {
+          throw new Error(`Step "${step.name}" failed: ${error48}`);
+        }
+      }
+      if (readySteps.length > 1 && batchOutcomes.length > 0) {
+        await this.deps.onConverge?.(readySteps, batchOutcomes);
+      }
+    }
+    return results;
+  }
+  async executeOne(step, agentMap, errorHandling, providedState) {
+    const state = providedState ?? this.createEphemeralState(step);
+    if (this.deps.executeStep) {
+      const result = await this.deps.executeStep(step, state, agentMap, errorHandling);
+      if (state.row.status !== "pending" && state.row.status !== "running") {
+        return {
+          status: state.row.status,
+          output: state.row.output ?? "",
+          duration: result?.duration ?? 0,
+          retries: result?.retries ?? state.row.retryCount,
+          exitCode: result?.exitCode,
+          exitSignal: result?.exitSignal,
+          completionReason: state.row.completionReason ?? result?.completionReason,
+          error: state.row.error ?? result?.error
+        };
+      }
+      return this.completeStep(step, state, {
+        status: result?.status ?? "completed",
+        output: result?.output ?? "",
+        exitCode: result?.exitCode,
+        exitSignal: result?.exitSignal,
+        completionReason: result?.completionReason,
+        retries: result?.retries ?? state.row.retryCount,
+        duration: result?.duration ?? 0,
+        error: result?.error
+      });
+    }
+    return this.executeWithProcessSpawner(step, state, agentMap, errorHandling);
+  }
+  async markFailed(stepName, error48) {
+    this.deps.postToChannel?.(`**[${stepName}]** Failed: ${error48}`);
+  }
+  buildStepOutputContext(stepStates) {
+    const steps = {};
+    for (const [name, state] of stepStates) {
+      if (state.row.status === "completed" && state.row.output !== void 0) {
+        steps[name] = { output: state.row.output };
+        continue;
+      }
+      if (state.row.status === "completed" && this.deps.runId) {
+        const persisted = this.deps.loadStepOutput?.(this.deps.runId, name);
+        if (persisted !== void 0) {
+          state.row.output = persisted;
+          steps[name] = { output: persisted };
+        }
+      }
+    }
+    return steps;
+  }
+  resolveStepTemplate(template, context) {
+    if (this.deps.resolveTemplate) {
+      return this.deps.resolveTemplate(template, context);
+    }
+    return this.templateResolver.interpolateStepTask(template, context);
+  }
+  getChannelMessenger() {
+    return this.channelMessenger;
+  }
+  runVerification(check2, output, stepName, injectedTaskText, options) {
+    return this.verificationRunner(check2, output, stepName, injectedTaskText, {
+      ...options,
+      cwd: options?.cwd ?? this.deps.cwd
+    });
+  }
+  async executeScheduledStep(step, states, agentMap, errorHandling) {
+    const state = states.get(step.name) ?? this.createEphemeralState(step);
+    if (!states.has(step.name)) {
+      states.set(step.name, state);
+    }
+    return this.executeOne(step, agentMap, errorHandling, state);
+  }
+  async executeWithProcessSpawner(step, state, agentMap, errorHandling) {
+    const spawner = this.deps.processSpawner;
+    if (!spawner) {
+      throw new Error(`No step execution callback or process spawner configured for step "${step.name}"`);
+    }
+    const maxRetries = step.retries ?? errorHandling?.maxRetries ?? 0;
+    return this.monitorStep(step, state, {
+      maxRetries,
+      retryDelayMs: errorHandling?.retryDelayMs ?? 1e3,
+      startMessage: `**[${step.name}]** Started`,
+      onRetry: (attempt, total) => {
+        this.deps.postToChannel?.(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${total + 1})`);
+      },
+      execute: async () => {
+        if (step.type === "deterministic") {
+          const command = step.command ?? "";
+          return spawner.spawnShell(command, { cwd: this.deps.cwd, timeoutMs: step.timeoutMs });
+        }
+        const agent = step.agent ? agentMap.get(step.agent) : void 0;
+        if (!agent) {
+          throw new Error(`Agent "${step.agent ?? "(missing)"}" not found in config`);
+        }
+        const task = step.task ?? "";
+        if (agent.interactive === false) {
+          return spawner.spawnAgent(agent, task, { cwd: this.deps.cwd, timeoutMs: step.timeoutMs });
+        }
+        return spawner.spawnInteractive(agent, task, { cwd: this.deps.cwd, timeoutMs: step.timeoutMs });
+      },
+      toCompletionResult: (spawnResult, attempt) => {
+        const failOnError = step.failOnError !== false;
+        const failed = failOnError && ((spawnResult.exitCode ?? 0) !== 0 || spawnResult.exitCode === void 0 && spawnResult.exitSignal !== void 0);
+        const output = step.captureOutput === false ? `Command completed (exit code ${spawnResult.exitCode ?? 0})` : spawnResult.output;
+        if (failed) {
+          return {
+            status: "failed",
+            output,
+            exitCode: spawnResult.exitCode,
+            exitSignal: spawnResult.exitSignal,
+            retries: attempt,
+            error: spawnResult.output || `Command failed with exit code ${spawnResult.exitCode ?? "unknown"}`
+          };
+        }
+        return {
+          status: "completed",
+          output,
+          exitCode: spawnResult.exitCode,
+          exitSignal: spawnResult.exitSignal,
+          retries: attempt
+        };
+      }
+    });
+  }
+  createEphemeralStates(steps) {
+    return new Map(steps.map((step) => [step.name, this.createEphemeralState(step)]));
+  }
+  createEphemeralState(step) {
+    return {
+      row: {
+        id: `step-${step.name}`,
+        runId: this.deps.runId ?? "run",
+        stepName: step.name,
+        agentName: step.agent ?? null,
+        stepType: step.type ?? "agent",
+        status: "pending",
+        task: step.task ?? step.command ?? step.branch ?? "",
+        dependsOn: step.dependsOn ?? [],
+        retryCount: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  getStatus(state) {
+    if (typeof state === "string")
+      return state;
+    return state?.row.status;
+  }
+};
+function normalizeStrategy(strategy) {
+  if (strategy === "continue")
+    return "continue";
+  return "fail-fast";
+}
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
 // packages/sdk/dist/workflows/trajectory.js
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs9 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_promises4 = require("node:fs/promises");
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 function classifyFailure(error48) {
   const e = error48.toLowerCase();
   if (e.includes("timed out") || e.includes("timeout"))
@@ -46459,7 +47584,7 @@ var WorkflowTrajectory = class {
     this.reflectOnConverge = cfg.reflectOnConverge !== false;
     this.autoDecisions = cfg.autoDecisions !== false;
     this.runId = runId;
-    this.dataDir = process.env.TRAJECTORIES_DATA_DIR ?? import_node_path12.default.join(cwd, ".trajectories");
+    this.dataDir = process.env.TRAJECTORIES_DATA_DIR ?? import_node_path13.default.join(cwd, ".trajectories");
   }
   // ── Lifecycle ──────────────────────────────────────────────────────────────
   /** Start the trajectory (called at run:started). */
@@ -46868,9 +47993,9 @@ var WorkflowTrajectory = class {
     if (!this.trajectory)
       return;
     try {
-      const activeDir = import_node_path12.default.join(this.dataDir, "active");
+      const activeDir = import_node_path13.default.join(this.dataDir, "active");
       await (0, import_promises4.mkdir)(activeDir, { recursive: true });
-      const filePath = import_node_path12.default.join(activeDir, `${this.trajectory.id}.json`);
+      const filePath = import_node_path13.default.join(activeDir, `${this.trajectory.id}.json`);
       await (0, import_promises4.writeFile)(filePath, JSON.stringify(this.trajectory, null, 2), "utf-8");
     } catch {
     }
@@ -46879,12 +48004,12 @@ var WorkflowTrajectory = class {
     if (!this.trajectory)
       return;
     try {
-      const activeDir = import_node_path12.default.join(this.dataDir, "active");
-      const completedDir = import_node_path12.default.join(this.dataDir, "completed");
+      const activeDir = import_node_path13.default.join(this.dataDir, "active");
+      const completedDir = import_node_path13.default.join(this.dataDir, "completed");
       await (0, import_promises4.mkdir)(completedDir, { recursive: true });
-      const activePath = import_node_path12.default.join(activeDir, `${this.trajectory.id}.json`);
-      const completedPath = import_node_path12.default.join(completedDir, `${this.trajectory.id}.json`);
-      if ((0, import_node_fs9.existsSync)(activePath)) {
+      const activePath = import_node_path13.default.join(activeDir, `${this.trajectory.id}.json`);
+      const completedPath = import_node_path13.default.join(completedDir, `${this.trajectory.id}.json`);
+      if ((0, import_node_fs10.existsSync)(activePath)) {
         await (0, import_promises4.rename)(activePath, completedPath);
       }
     } catch {
@@ -46893,6 +48018,53 @@ var WorkflowTrajectory = class {
 };
 
 // packages/sdk/dist/workflows/runner.js
+var ENV_ALLOWLIST = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "SHELL",
+  "LANG",
+  "TERM",
+  "TMPDIR",
+  "TZ",
+  "NODE_ENV",
+  "NODE_PATH",
+  "NODE_OPTIONS",
+  "NODE_EXTRA_CA_CERTS",
+  "RUST_LOG",
+  "RUST_BACKTRACE",
+  "RELAY_API_KEY",
+  "RELAYCAST_BASE_URL",
+  "AGENT_RELAY_DASHBOARD_PORT",
+  "AGENT_RELAY_RUN_ID_FILE",
+  "EDITOR",
+  "VISUAL",
+  "GIT_AUTHOR_NAME",
+  "GIT_AUTHOR_EMAIL",
+  "GIT_COMMITTER_NAME",
+  "GIT_COMMITTER_EMAIL",
+  "HTTPS_PROXY",
+  "HTTP_PROXY",
+  "NO_PROXY",
+  "https_proxy",
+  "http_proxy",
+  "no_proxy",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_CACHE_HOME"
+]);
+function filteredEnv(extra) {
+  const env = {};
+  for (const key of ENV_ALLOWLIST) {
+    if (process.env[key] !== void 0) {
+      env[key] = process.env[key];
+    }
+  }
+  if (extra) {
+    Object.assign(env, extra);
+  }
+  return env;
+}
 var SpawnExitError = class extends Error {
   exitCode;
   exitSignal;
@@ -46903,14 +48075,6 @@ var SpawnExitError = class extends Error {
     this.exitSignal = exitSignal ?? void 0;
   }
 };
-var WorkflowCompletionError = class extends Error {
-  completionReason;
-  constructor(message, completionReason) {
-    super(message);
-    this.name = "WorkflowCompletionError";
-    this.completionReason = completionReason;
-  }
-};
 function resolveCursorCli() {
   const resolved = resolveCliSync("cursor");
   return resolved?.binary ?? "agent";
@@ -46923,6 +48087,8 @@ var WorkflowRunner = class _WorkflowRunner {
   summaryDir;
   executor;
   envSecrets;
+  templateResolver;
+  channelMessenger;
   /** @internal exposed for CLI signal-handler shutdown only */
   relay;
   relaycast;
@@ -46982,10 +48148,12 @@ var WorkflowRunner = class _WorkflowRunner {
     this.workspaceId = options.workspaceId ?? "local";
     this.relayOptions = options.relay ?? {};
     this.cwd = options.cwd ?? process.cwd();
-    this.summaryDir = options.summaryDir ?? import_node_path13.default.join(this.cwd, ".relay", "summaries");
-    this.workersPath = import_node_path13.default.join(this.cwd, ".agent-relay", "team", "workers.json");
+    this.summaryDir = options.summaryDir ?? import_node_path14.default.join(this.cwd, ".relay", "summaries");
+    this.workersPath = import_node_path14.default.join(this.cwd, ".agent-relay", "team", "workers.json");
     this.executor = options.executor;
     this.envSecrets = options.envSecrets;
+    this.templateResolver = new TemplateResolver();
+    this.channelMessenger = new ChannelMessenger({ postFn: (text) => this.postToChannel(text) });
   }
   // ── Path resolution ─────────────────────────────────────────────────────
   /** Expand environment variables like $HOME or $VAR in a path string. */
@@ -47013,10 +48181,10 @@ var WorkflowRunner = class _WorkflowRunner {
       }
       seenNames.add(pd.name);
       const expanded = _WorkflowRunner.resolveEnvVars(pd.path);
-      const abs = import_node_path13.default.resolve(baseCwd, expanded);
+      const abs = import_node_path14.default.resolve(baseCwd, expanded);
       resolved.set(pd.name, abs);
       const isRequired = pd.required !== false;
-      if (!(0, import_node_fs10.existsSync)(abs)) {
+      if (!(0, import_node_fs11.existsSync)(abs)) {
         if (isRequired) {
           errors.push(`Path "${pd.name}" resolves to "${abs}" which does not exist (required)`);
         } else {
@@ -47039,7 +48207,7 @@ var WorkflowRunner = class _WorkflowRunner {
       return resolved;
     }
     if (agent.cwd) {
-      return import_node_path13.default.resolve(this.cwd, agent.cwd);
+      return import_node_path14.default.resolve(this.cwd, agent.cwd);
     }
     return this.cwd;
   }
@@ -47058,7 +48226,7 @@ var WorkflowRunner = class _WorkflowRunner {
   }
   resolveEffectiveCwd(step, agentDef) {
     if (step.cwd) {
-      return import_node_path13.default.resolve(this.cwd, step.cwd);
+      return import_node_path14.default.resolve(this.cwd, step.cwd);
     }
     return this.resolveStepWorkdir(step) ?? (agentDef ? this.resolveAgentCwd(agentDef) : this.cwd);
   }
@@ -47352,16 +48520,18 @@ ${next}` : next;
     return void 0;
   }
   uniqueEvidenceRoots(roots) {
-    return [...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path13.default.resolve(root)))];
+    return [
+      ...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path14.default.resolve(root)))
+    ];
   }
   captureFileSnapshot(root) {
     const snapshot = /* @__PURE__ */ new Map();
-    if (!(0, import_node_fs10.existsSync)(root))
+    if (!(0, import_node_fs11.existsSync)(root))
       return snapshot;
     const visit = (currentPath) => {
       let entries;
       try {
-        entries = (0, import_node_fs10.readdirSync)(currentPath, { withFileTypes: true });
+        entries = (0, import_node_fs11.readdirSync)(currentPath, { withFileTypes: true });
       } catch {
         return;
       }
@@ -47369,13 +48539,13 @@ ${next}` : next;
         if (entry.isDirectory() && _WorkflowRunner.EVIDENCE_IGNORED_DIRS.has(entry.name)) {
           continue;
         }
-        const fullPath = import_node_path13.default.join(currentPath, entry.name);
+        const fullPath = import_node_path14.default.join(currentPath, entry.name);
         if (entry.isDirectory()) {
           visit(fullPath);
           continue;
         }
         try {
-          const stats = (0, import_node_fs10.statSync)(fullPath);
+          const stats = (0, import_node_fs11.statSync)(fullPath);
           if (!stats.isFile())
             continue;
           snapshot.set(fullPath, { mtimeMs: stats.mtimeMs, size: stats.size });
@@ -47384,7 +48554,7 @@ ${next}` : next;
       }
     };
     try {
-      const stats = (0, import_node_fs10.statSync)(root);
+      const stats = (0, import_node_fs11.statSync)(root);
       if (stats.isFile()) {
         snapshot.set(root, { mtimeMs: stats.mtimeMs, size: stats.size });
         return snapshot;
@@ -47421,9 +48591,9 @@ ${next}` : next;
     return changes.sort((a, b) => a.path.localeCompare(b.path));
   }
   normalizeEvidencePath(filePath) {
-    const relative = import_node_path13.default.relative(this.cwd, filePath);
+    const relative = import_node_path14.default.relative(this.cwd, filePath);
     if (!relative || relative === "")
-      return import_node_path13.default.basename(filePath);
+      return import_node_path14.default.basename(filePath);
     return relative.startsWith("..") ? filePath : relative;
   }
   buildStepCompletionDecision(stepName, completionReason) {
@@ -47540,7 +48710,7 @@ ${next}` : next;
       return this.relayOptions.env;
     }
     return {
-      ...this.relayOptions.env ?? process.env,
+      ...this.relayOptions.env ?? filteredEnv(),
       RELAY_API_KEY: this.relayApiKey
     };
   }
@@ -47631,7 +48801,7 @@ ${next}` : next;
   // ── Parsing & validation ────────────────────────────────────────────────
   /** Parse a relay.yaml file from disk. */
   async parseYamlFile(filePath) {
-    const absPath = import_node_path13.default.resolve(this.cwd, filePath);
+    const absPath = import_node_path14.default.resolve(this.cwd, filePath);
     const raw = await (0, import_promises5.readFile)(absPath, "utf-8");
     return this.parseYamlString(raw, absPath);
   }
@@ -47785,15 +48955,15 @@ ${err.suggestion}`);
     }
     for (const agent of resolved.agents) {
       if (agent.cwd) {
-        const resolvedCwd = import_node_path13.default.resolve(this.cwd, agent.cwd);
-        if (!(0, import_node_fs10.existsSync)(resolvedCwd)) {
+        const resolvedCwd = import_node_path14.default.resolve(this.cwd, agent.cwd);
+        if (!(0, import_node_fs11.existsSync)(resolvedCwd)) {
           warnings.push(`Agent "${agent.name}" cwd "${agent.cwd}" resolves to "${resolvedCwd}" which does not exist`);
         }
       }
       if (agent.additionalPaths) {
         for (const ap of agent.additionalPaths) {
-          const resolvedPath = import_node_path13.default.resolve(this.cwd, ap);
-          if (!(0, import_node_fs10.existsSync)(resolvedPath)) {
+          const resolvedPath = import_node_path14.default.resolve(this.cwd, ap);
+          if (!(0, import_node_fs11.existsSync)(resolvedPath)) {
             warnings.push(`Agent "${agent.name}" additionalPath "${ap}" resolves to "${resolvedPath}" which does not exist`);
           }
         }
@@ -48034,65 +49204,13 @@ ${err.suggestion}`);
   // ── Template variable resolution ────────────────────────────────────────
   /** Resolve {{variable}} placeholders in all task strings. */
   resolveVariables(config2, vars) {
-    const resolved = structuredClone(config2);
-    for (const agent of resolved.agents) {
-      if (agent.task) {
-        agent.task = this.interpolate(agent.task, vars);
-      }
-    }
-    if (resolved.workflows) {
-      for (const wf of resolved.workflows) {
-        for (const step of wf.steps) {
-          if (step.task) {
-            step.task = this.interpolate(step.task, vars);
-          }
-          if (step.command) {
-            step.command = this.interpolate(step.command, vars);
-          }
-          if (step.params && typeof step.params === "object") {
-            for (const key of Object.keys(step.params)) {
-              const val = step.params[key];
-              if (typeof val === "string") {
-                step.params[key] = this.interpolate(val, vars);
-              }
-            }
-          }
-        }
-      }
-    }
-    return resolved;
+    return this.templateResolver.resolveVariables(config2, vars);
   }
   interpolate(template, vars) {
-    return template.replace(/\{\{([\w][\w.\-]*)\}\}/g, (_match, key) => {
-      if (key.startsWith("steps.")) {
-        return _match;
-      }
-      const value = this.resolveDotPath(key, vars);
-      if (value === void 0) {
-        throw new Error(`Unresolved variable: {{${key}}}`);
-      }
-      return String(value);
-    });
+    return resolveTemplate(template, vars);
   }
   resolveDotPath(key, vars) {
-    if (!key.includes(".")) {
-      return vars[key];
-    }
-    const parts = key.split(".");
-    let current = vars;
-    for (const part of parts) {
-      if (current === null || current === void 0 || typeof current !== "object") {
-        return void 0;
-      }
-      current = current[part];
-    }
-    if (current === void 0 || current === null) {
-      return void 0;
-    }
-    if (typeof current === "string" || typeof current === "number" || typeof current === "boolean") {
-      return current;
-    }
-    return String(current);
+    return resolveDotPath(key, vars);
   }
   /** Build a nested context from completed step outputs for {{steps.X.output}} resolution. */
   buildStepOutputContext(stepStates, runId) {
@@ -48112,13 +49230,80 @@ ${err.suggestion}`);
   }
   /** Interpolate step-output variables, silently skipping unresolved ones (they may be user vars). */
   interpolateStepTask(template, context) {
-    return template.replace(/\{\{(steps\.[\w\-]+\.output)\}\}/g, (_match, key) => {
-      const value = this.resolveDotPath(key, context);
-      if (value === void 0) {
-        return _match;
-      }
-      return String(value);
-    });
+    return interpolateStepTask(template, context);
+  }
+  createStepLifecycleExecutor(workflow2, stepStates, agentMap, errorHandling, runId) {
+    let lifecycle;
+    const deps = {
+      cwd: this.cwd,
+      runId,
+      templateResolver: this.templateResolver,
+      channelMessenger: this.channelMessenger,
+      verificationRunner: (check2, output, stepName, injectedTaskText, options) => this.runVerification(check2, output, stepName, injectedTaskText, options),
+      postToChannel: (text) => this.postToChannel(text),
+      persistStepRow: async (stepId, patch) => this.db.updateStep(stepId, patch),
+      persistStepOutput: async (lifecycleRunId, stepName, output) => this.persistStepOutput(lifecycleRunId, stepName, output),
+      loadStepOutput: (lifecycleRunId, stepName) => this.loadStepOutput(lifecycleRunId, stepName),
+      checkAborted: () => this.checkAborted(),
+      waitIfPaused: () => this.waitIfPaused(),
+      log: (message) => this.log(message),
+      onStepStarted: async (step) => {
+        this.emit({ type: "step:started", runId, stepName: step.name });
+      },
+      onStepCompleted: async (step, state, result) => {
+        this.emit({
+          type: "step:completed",
+          runId,
+          stepName: step.name,
+          output: result.output,
+          exitCode: result.exitCode,
+          exitSignal: result.exitSignal
+        });
+        this.finalizeStepEvidence(step.name, result.status, state.row.completedAt, result.completionReason);
+      },
+      onStepFailed: async (step, state, result) => {
+        this.captureStepTerminalEvidence(step.name, {}, {
+          exitCode: result.exitCode,
+          exitSignal: result.exitSignal
+        });
+        this.emit({
+          type: "step:failed",
+          runId,
+          stepName: step.name,
+          error: result.error ?? "Unknown error",
+          exitCode: result.exitCode,
+          exitSignal: result.exitSignal
+        });
+        this.finalizeStepEvidence(step.name, "failed", state.row.completedAt, result.completionReason);
+      },
+      executeStep: async (step, state) => {
+        await this.executeStep(step, state, stepStates, agentMap, errorHandling, runId, lifecycle);
+        return {
+          status: state.row.status,
+          output: state.row.output ?? "",
+          completionReason: state.row.completionReason,
+          retries: state.row.retryCount,
+          error: state.row.error
+        };
+      },
+      onBeginTrack: async (steps) => {
+        if (steps.length > 1 && this.trajectory) {
+          await this.trajectory.beginTrack(steps.map((step) => step.name).join(", "));
+        }
+      },
+      onConverge: async (readySteps, batchOutcomes) => {
+        if (readySteps.length <= 1 || !this.trajectory?.shouldReflectOnConverge()) {
+          return;
+        }
+        const completedNames = new Set(batchOutcomes.filter((outcome) => outcome.status === "completed").map((outcome) => outcome.name));
+        const unblocked = workflow2.steps.filter((step) => step.dependsOn?.some((dependency) => completedNames.has(dependency))).filter((step) => stepStates.get(step.name)?.row.status === "pending").map((step) => step.name);
+        await this.trajectory.synthesizeAndReflect(readySteps.map((step) => step.name).join(" + "), batchOutcomes, unblocked.length > 0 ? unblocked : void 0);
+      },
+      markDownstreamSkipped: async (failedStepName) => this.markDownstreamSkipped(failedStepName, workflow2.steps, stepStates, runId),
+      buildCompletionMode: (stepName, completionReason) => completionReason ? this.buildStepCompletionDecision(stepName, completionReason)?.mode : void 0
+    };
+    lifecycle = new StepExecutor(deps);
+    return lifecycle;
   }
   // ── Execution ───────────────────────────────────────────────────────────
   /** Execute a named workflow from a validated config. */
@@ -48324,7 +49509,7 @@ ${err.suggestion}`);
           }
         }
         this.log("Starting broker...");
-        const brokerBaseName = import_node_path13.default.basename(this.cwd) || "workflow";
+        const brokerBaseName = import_node_path14.default.basename(this.cwd) || "workflow";
         const brokerName = `${brokerBaseName}-${runId.slice(0, 8)}`;
         this.relay = new AgentRelay({
           ...this.relayOptions,
@@ -48346,7 +49531,7 @@ ${err.suggestion}`);
           if (/Read\(/.test(stripped)) {
             const m = stripped.match(/Read\(\s*~?([^\s)"']{8,})/);
             if (m) {
-              const base = import_node_path13.default.basename(m[1]);
+              const base = import_node_path14.default.basename(m[1]);
               activity = base.length >= 3 ? `Reading ${base}` : "Reading file...";
             } else {
               activity = "Reading file...";
@@ -48354,7 +49539,7 @@ ${err.suggestion}`);
           } else if (/Edit\(/.test(stripped)) {
             const m = stripped.match(/Edit\(\s*~?([^\s)"']{8,})/);
             if (m) {
-              const base = import_node_path13.default.basename(m[1]);
+              const base = import_node_path14.default.basename(m[1]);
               activity = base.length >= 3 ? `Editing ${base}` : "Editing file...";
             } else {
               activity = "Editing file...";
@@ -48635,72 +49820,11 @@ ${err.suggestion}`);
   async executeSteps(workflow2, stepStates, agentMap, errorHandling, runId) {
     const rawStrategy = errorHandling?.strategy ?? workflow2.onError ?? "fail-fast";
     const strategy = rawStrategy === "fail" ? "fail-fast" : rawStrategy === "skip" ? "continue" : rawStrategy === "retry" ? "fail-fast" : rawStrategy;
-    while (true) {
-      this.checkAborted();
-      await this.waitIfPaused();
-      const readySteps = this.findReadySteps(workflow2.steps, stepStates);
-      if (readySteps.length === 0) {
-        break;
-      }
-      if (readySteps.length > 1 && this.trajectory) {
-        const trackNames = readySteps.map((s) => s.name).join(", ");
-        await this.trajectory.beginTrack(trackNames);
-      }
-      const STAGGER_THRESHOLD = 3;
-      const STAGGER_DELAY_MS = 2e3;
-      const results = await Promise.allSettled(readySteps.map((step, i) => {
-        const delay2 = readySteps.length > STAGGER_THRESHOLD ? i * STAGGER_DELAY_MS : 0;
-        if (delay2 === 0) {
-          return this.executeStep(step, stepStates, agentMap, errorHandling, runId);
-        }
-        return new Promise((resolve3) => setTimeout(resolve3, delay2)).then(() => this.executeStep(step, stepStates, agentMap, errorHandling, runId));
-      }));
-      const batchOutcomes = [];
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        const step = readySteps[i];
-        const state = stepStates.get(step.name);
-        if (result.status === "rejected") {
-          const error48 = result.reason instanceof Error ? result.reason.message : String(result.reason);
-          if (state && state.row.status !== "failed") {
-            await this.markStepFailed(state, error48, runId);
-          }
-          batchOutcomes.push({
-            name: step.name,
-            agent: step.agent ?? "deterministic",
-            status: "failed",
-            attempts: (state?.row.retryCount ?? 0) + 1,
-            error: error48
-          });
-          if (strategy === "fail-fast") {
-            await this.markDownstreamSkipped(step.name, workflow2.steps, stepStates, runId);
-            throw new Error(`Step "${step.name}" failed: ${error48}`);
-          }
-          if (strategy === "continue") {
-            await this.markDownstreamSkipped(step.name, workflow2.steps, stepStates, runId);
-          }
-        } else {
-          batchOutcomes.push({
-            name: step.name,
-            agent: step.agent ?? "deterministic",
-            status: state?.row.status === "completed" ? "completed" : "failed",
-            attempts: (state?.row.retryCount ?? 0) + 1,
-            output: state?.row.output,
-            verificationPassed: state?.row.status === "completed" && step.verification !== void 0,
-            completionMode: state?.row.completionReason ? this.buildStepCompletionDecision(step.name, state.row.completionReason)?.mode : void 0
-          });
-        }
-      }
-      if (readySteps.length > 1 && this.trajectory?.shouldReflectOnConverge()) {
-        const label = readySteps.map((s) => s.name).join(" + ");
-        const completedNames = new Set(batchOutcomes.filter((o) => o.status === "completed").map((o) => o.name));
-        const unblocked = workflow2.steps.filter((s) => s.dependsOn?.some((dep) => completedNames.has(dep))).filter((s) => {
-          const st = stepStates.get(s.name);
-          return st && st.row.status === "pending";
-        }).map((s) => s.name);
-        await this.trajectory.synthesizeAndReflect(label, batchOutcomes, unblocked.length > 0 ? unblocked : void 0);
-      }
-    }
+    const lifecycle = this.createStepLifecycleExecutor(workflow2, stepStates, agentMap, errorHandling, runId);
+    await lifecycle.executeAll(workflow2.steps, agentMap, {
+      ...errorHandling ?? { strategy: "fail-fast" },
+      strategy
+    }, stepStates);
   }
   findReadySteps(steps, stepStates) {
     return steps.filter((step) => {
@@ -48725,11 +49849,11 @@ ${err.suggestion}`);
       const description = check2.description ?? check2.command.slice(0, 50);
       this.postToChannel(`**[preflight]** ${description}`);
       try {
-        const output = await new Promise((resolve3, reject) => {
-          const child = (0, import_node_child_process5.spawn)("sh", ["-c", check2.command], {
+        const output = await new Promise((resolve4, reject) => {
+          const child = (0, import_node_child_process6.spawn)("sh", ["-c", check2.command], {
             stdio: "pipe",
             cwd: this.cwd,
-            env: { ...process.env }
+            env: filteredEnv()
           });
           const stdoutChunks = [];
           const stderrChunks = [];
@@ -48765,7 +49889,7 @@ ${err.suggestion}`);
               reject(new Error(`Preflight check failed (exit ${code})${stderr ? `: ${stderr.slice(0, 200)}` : ""}`));
               return;
             }
-            resolve3(stdoutChunks.join(""));
+            resolve4(stdoutChunks.join(""));
           });
           child.on("error", (err) => {
             clearTimeout(timer);
@@ -48818,15 +49942,15 @@ ${trimmedOutput.slice(0, 200)}`);
   isIntegrationStep(step) {
     return step.type === "integration";
   }
-  async executeStep(step, stepStates, agentMap, errorHandling, runId) {
+  async executeStep(step, state, stepStates, agentMap, errorHandling, runId, lifecycle) {
     if (this.isDeterministicStep(step)) {
-      return this.executeDeterministicStep(step, stepStates, runId, errorHandling);
+      return this.executeDeterministicStep(step, state, stepStates, runId, errorHandling, lifecycle);
     }
     if (this.isWorktreeStep(step)) {
-      return this.executeWorktreeStep(step, stepStates, runId);
+      return this.executeWorktreeStep(step, state, stepStates, runId, lifecycle);
     }
     if (this.isIntegrationStep(step)) {
-      return this.executeIntegrationStep(step, stepStates, runId);
+      return this.executeIntegrationStep(step, state, stepStates, runId, lifecycle);
     }
     return this.executeAgentStep(step, stepStates, agentMap, errorHandling, runId);
   }
@@ -48834,92 +49958,213 @@ ${trimmedOutput.slice(0, 200)}`);
    * Execute a deterministic step (shell command).
    * Fast, reliable, $0 LLM cost.
    */
-  async executeDeterministicStep(step, stepStates, runId, errorHandling) {
-    const state = stepStates.get(step.name);
-    if (!state)
-      throw new Error(`Step state not found: ${step.name}`);
+  async executeDeterministicStep(step, state, stepStates, runId, errorHandling, lifecycle) {
     const maxRetries = step.retries ?? errorHandling?.maxRetries ?? 0;
     const retryDelay = errorHandling?.retryDelayMs ?? 1e3;
-    let lastError;
+    let lastError = "Unknown error";
     let lastCompletionReason;
     let lastExitCode;
     let lastExitSignal;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-      this.checkAborted();
-      lastExitCode = void 0;
-      lastExitSignal = void 0;
-      if (attempt > 0) {
+    const result = await lifecycle.monitorStep(step, state, {
+      maxRetries,
+      retryDelayMs: retryDelay,
+      startMessage: `**[${step.name}]** Started (deterministic)`,
+      onRetry: async (attempt, total) => {
         this.emit({ type: "step:retrying", runId, stepName: step.name, attempt });
-        this.postToChannel(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${maxRetries + 1})`);
+        this.postToChannel(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${total + 1})`);
         this.recordStepToolSideEffect(step.name, {
           type: "retry",
-          detail: `Retrying attempt ${attempt + 1}/${maxRetries + 1}`,
-          raw: { attempt, maxRetries }
+          detail: `Retrying attempt ${attempt + 1}/${total + 1}`,
+          raw: { attempt, maxRetries: total }
         });
-        state.row.retryCount = attempt;
-        await this.db.updateStep(state.row.id, {
-          retryCount: attempt,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      execute: async () => {
+        const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
+        let resolvedCommand = this.interpolateStepTask(step.command ?? "", stepOutputContext);
+        resolvedCommand = resolvedCommand.replace(/\{\{([\w][\w.\-]*)\}\}/g, (_match, key) => {
+          if (key.startsWith("steps."))
+            return _match;
+          const value = this.resolveDotPath(key, stepOutputContext);
+          return value !== void 0 ? String(value) : _match;
         });
-        await this.delay(retryDelay);
-      }
-      state.row.status = "running";
-      state.row.error = void 0;
-      state.row.completionReason = void 0;
-      state.row.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.db.updateStep(state.row.id, {
-        status: "running",
-        error: void 0,
-        completionReason: void 0,
-        startedAt: state.row.startedAt,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      this.emit({ type: "step:started", runId, stepName: step.name });
-      this.postToChannel(`**[${step.name}]** Started (deterministic)`);
-      const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
-      let resolvedCommand = this.interpolateStepTask(step.command ?? "", stepOutputContext);
-      resolvedCommand = resolvedCommand.replace(/\{\{([\w][\w.\-]*)\}\}/g, (_match, key) => {
-        if (key.startsWith("steps."))
-          return _match;
-        const value = this.resolveDotPath(key, stepOutputContext);
-        return value !== void 0 ? String(value) : _match;
-      });
-      const stepCwd = this.resolveEffectiveCwd(step);
-      this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
-      try {
+        const stepCwd = this.resolveEffectiveCwd(step);
+        this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
         if (this.executor?.executeDeterministicStep) {
-          const result = await this.executor.executeDeterministicStep(step, resolvedCommand, stepCwd);
-          lastExitCode = result.exitCode;
+          const executorResult = await this.executor.executeDeterministicStep(step, resolvedCommand, stepCwd);
+          lastExitCode = executorResult.exitCode;
+          lastExitSignal = void 0;
           const failOnError = step.failOnError !== false;
-          if (failOnError && result.exitCode !== 0) {
-            throw new Error(`Command failed with exit code ${result.exitCode}: ${result.output.slice(0, 500)}`);
+          if (failOnError && executorResult.exitCode !== 0) {
+            throw new Error(`Command failed with exit code ${executorResult.exitCode}: ${executorResult.output.slice(0, 500)}`);
           }
-          const output2 = step.captureOutput !== false ? result.output : `Command completed (exit code ${result.exitCode})`;
-          this.captureStepTerminalEvidence(step.name, { stdout: result.output, combined: result.output }, { exitCode: result.exitCode });
+          const output2 = step.captureOutput !== false ? executorResult.output : `Command completed (exit code ${executorResult.exitCode})`;
+          this.captureStepTerminalEvidence(step.name, { stdout: executorResult.output, combined: executorResult.output }, { exitCode: executorResult.exitCode });
           const verificationResult2 = step.verification ? this.runVerification(step.verification, output2, step.name) : void 0;
-          state.row.status = "completed";
-          state.row.output = output2;
-          state.row.completionReason = verificationResult2?.completionReason;
-          state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-          await this.db.updateStep(state.row.id, {
-            status: "completed",
+          return {
             output: output2,
-            completionReason: verificationResult2?.completionReason,
-            completedAt: state.row.completedAt,
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            completionReason: verificationResult2?.completionReason
+          };
+        }
+        let commandStdout = "";
+        let commandStderr = "";
+        const output = await new Promise((resolve4, reject) => {
+          const child = (0, import_node_child_process6.spawn)("sh", ["-c", resolvedCommand], {
+            stdio: "pipe",
+            cwd: stepCwd,
+            env: filteredEnv()
           });
-          await this.persistStepOutput(runId, step.name, output2);
-          this.emit({ type: "step:completed", runId, stepName: step.name, output: output2 });
-          this.finalizeStepEvidence(step.name, "completed", state.row.completedAt, verificationResult2?.completionReason);
-          return;
+          const stdoutChunks = [];
+          const stderrChunks = [];
+          const abortSignal = this.abortController?.signal;
+          let abortHandler;
+          if (abortSignal && !abortSignal.aborted) {
+            abortHandler = () => {
+              child.kill("SIGTERM");
+              setTimeout(() => child.kill("SIGKILL"), 5e3);
+            };
+            abortSignal.addEventListener("abort", abortHandler, { once: true });
+          }
+          let timedOut = false;
+          let timer;
+          if (step.timeoutMs) {
+            timer = setTimeout(() => {
+              timedOut = true;
+              child.kill("SIGTERM");
+              setTimeout(() => child.kill("SIGKILL"), 5e3);
+            }, step.timeoutMs);
+          }
+          child.stdout?.on("data", (chunk) => {
+            stdoutChunks.push(chunk.toString());
+          });
+          child.stderr?.on("data", (chunk) => {
+            stderrChunks.push(chunk.toString());
+          });
+          child.on("close", (code, signal) => {
+            if (timer)
+              clearTimeout(timer);
+            if (abortHandler && abortSignal) {
+              abortSignal.removeEventListener("abort", abortHandler);
+            }
+            if (abortSignal?.aborted) {
+              reject(new Error(`Step "${step.name}" aborted`));
+              return;
+            }
+            if (timedOut) {
+              reject(new Error(`Step "${step.name}" timed out (no step timeout set, check global swarm.timeoutMs)`));
+              return;
+            }
+            const stdout = stdoutChunks.join("");
+            const stderr = stderrChunks.join("");
+            commandStdout = stdout;
+            commandStderr = stderr;
+            lastExitCode = code ?? void 0;
+            lastExitSignal = signal ?? void 0;
+            const failOnError = step.failOnError !== false;
+            if (failOnError && code !== 0 && code !== null) {
+              reject(new Error(`Command failed with exit code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
+              return;
+            }
+            resolve4(step.captureOutput !== false ? stdout : `Command completed (exit code ${code ?? 0})`);
+          });
+          child.on("error", (err) => {
+            if (timer)
+              clearTimeout(timer);
+            if (abortHandler && abortSignal) {
+              abortSignal.removeEventListener("abort", abortHandler);
+            }
+            reject(new Error(`Failed to execute command: ${err.message}`));
+          });
+        });
+        this.captureStepTerminalEvidence(step.name, {
+          stdout: commandStdout || output,
+          stderr: commandStderr,
+          combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
+        }, { exitCode: lastExitCode, exitSignal: lastExitSignal });
+        const verificationResult = step.verification ? this.runVerification(step.verification, output, step.name) : void 0;
+        return {
+          output,
+          completionReason: verificationResult?.completionReason
+        };
+      },
+      toCompletionResult: ({ output, completionReason }, attempt) => ({
+        status: "completed",
+        output,
+        completionReason,
+        retries: attempt,
+        exitCode: lastExitCode,
+        exitSignal: lastExitSignal
+      }),
+      onAttemptFailed: async (error48) => {
+        lastError = error48 instanceof Error ? error48.message : String(error48);
+        lastCompletionReason = error48 instanceof WorkflowCompletionError ? error48.completionReason : void 0;
+      },
+      getFailureResult: () => ({
+        status: "failed",
+        output: "",
+        error: lastError,
+        retries: state.row.retryCount,
+        exitCode: lastExitCode,
+        exitSignal: lastExitSignal,
+        completionReason: lastCompletionReason
+      })
+    });
+    if (result.status === "failed") {
+      this.postToChannel(`**[${step.name}]** Failed: ${result.error ?? "Unknown error"}`);
+      throw new Error(`Step "${step.name}" failed: ${result.error ?? "Unknown error"}`);
+    }
+  }
+  /**
+   * Execute a worktree step (git worktree setup).
+   * Fast, reliable, $0 LLM cost.
+   * Outputs the worktree path for downstream steps to use.
+   */
+  async executeWorktreeStep(step, state, stepStates, runId, lifecycle) {
+    let lastExitCode;
+    let lastExitSignal;
+    let worktreeBranch = "";
+    let createdBranch = false;
+    const result = await lifecycle.monitorStep(step, state, {
+      startMessage: `**[${step.name}]** Started (worktree setup)`,
+      execute: async () => {
+        const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
+        const branch = this.interpolateStepTask(step.branch ?? "", stepOutputContext);
+        const baseBranch = step.baseBranch ? this.interpolateStepTask(step.baseBranch, stepOutputContext) : "HEAD";
+        const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path14.default.join(".worktrees", step.name);
+        const createBranch = step.createBranch !== false;
+        const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
+        this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
+        if (!branch) {
+          throw new Error('Worktree step missing required "branch" field');
+        }
+        const absoluteWorktreePath = import_node_path14.default.resolve(stepCwd, worktreePath);
+        let branchExists = false;
+        await new Promise((resolve4) => {
+          const checkChild = (0, import_node_child_process6.spawn)("git", ["rev-parse", "--verify", "--quiet", branch], {
+            stdio: "pipe",
+            cwd: stepCwd,
+            env: filteredEnv()
+          });
+          checkChild.on("close", (code) => {
+            branchExists = code === 0;
+            resolve4();
+          });
+          checkChild.on("error", () => resolve4());
+        });
+        let worktreeArgs;
+        if (branchExists) {
+          worktreeArgs = ["worktree", "add", absoluteWorktreePath, branch];
+        } else if (createBranch) {
+          worktreeArgs = ["worktree", "add", "-b", branch, absoluteWorktreePath, baseBranch];
+        } else {
+          throw new Error(`Branch "${branch}" does not exist and createBranch is false`);
         }
         let commandStdout = "";
         let commandStderr = "";
-        const output = await new Promise((resolve3, reject) => {
-          const child = (0, import_node_child_process5.spawn)("sh", ["-c", resolvedCommand], {
+        const output = await new Promise((resolve4, reject) => {
+          const child = (0, import_node_child_process6.spawn)("git", worktreeArgs, {
             stdio: "pipe",
             cwd: stepCwd,
-            env: { ...process.env }
+            env: filteredEnv()
           });
           const stdoutChunks = [];
           const stderrChunks = [];
@@ -48961,18 +50206,15 @@ ${trimmedOutput.slice(0, 200)}`);
               reject(new Error(`Step "${step.name}" timed out (no step timeout set, check global swarm.timeoutMs)`));
               return;
             }
-            const stdout = stdoutChunks.join("");
-            const stderr = stderrChunks.join("");
-            commandStdout = stdout;
-            commandStderr = stderr;
+            commandStdout = stdoutChunks.join("");
+            commandStderr = stderrChunks.join("");
             lastExitCode = code ?? void 0;
             lastExitSignal = signal ?? void 0;
-            const failOnError = step.failOnError !== false;
-            if (failOnError && code !== 0 && code !== null) {
-              reject(new Error(`Command failed with exit code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
+            if (code !== 0 && code !== null) {
+              reject(new Error(`git worktree add failed with exit code ${code}${commandStderr ? `: ${commandStderr.slice(0, 500)}` : ""}`));
               return;
             }
-            resolve3(step.captureOutput !== false ? stdout : `Command completed (exit code ${code ?? 0})`);
+            resolve4(absoluteWorktreePath);
           });
           child.on("error", (err) => {
             if (timer)
@@ -48980,7 +50222,7 @@ ${trimmedOutput.slice(0, 200)}`);
             if (abortHandler && abortSignal) {
               abortSignal.removeEventListener("abort", abortHandler);
             }
-            reject(new Error(`Failed to execute command: ${err.message}`));
+            reject(new Error(`Failed to execute git worktree command: ${err.message}`));
           });
         });
         this.captureStepTerminalEvidence(step.name, {
@@ -48988,253 +50230,78 @@ ${trimmedOutput.slice(0, 200)}`);
           stderr: commandStderr,
           combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
         }, { exitCode: lastExitCode, exitSignal: lastExitSignal });
-        const verificationResult = step.verification ? this.runVerification(step.verification, output, step.name) : void 0;
-        state.row.status = "completed";
-        state.row.output = output;
-        state.row.completionReason = verificationResult?.completionReason;
-        state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await this.db.updateStep(state.row.id, {
-          status: "completed",
-          output,
-          completionReason: verificationResult?.completionReason,
-          completedAt: state.row.completedAt,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        await this.persistStepOutput(runId, step.name, output);
-        this.emit({ type: "step:completed", runId, stepName: step.name, output });
-        this.finalizeStepEvidence(step.name, "completed", state.row.completedAt, verificationResult?.completionReason);
-        return;
-      } catch (err) {
-        lastError = err instanceof Error ? err.message : String(err);
-        lastCompletionReason = err instanceof WorkflowCompletionError ? err.completionReason : void 0;
-      }
-    }
-    const errorMsg = lastError ?? "Unknown error";
-    this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
-    await this.markStepFailed(state, errorMsg, runId, { exitCode: lastExitCode, exitSignal: lastExitSignal }, lastCompletionReason);
-    throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
-  }
-  /**
-   * Execute a worktree step (git worktree setup).
-   * Fast, reliable, $0 LLM cost.
-   * Outputs the worktree path for downstream steps to use.
-   */
-  async executeWorktreeStep(step, stepStates, runId) {
-    const state = stepStates.get(step.name);
-    if (!state)
-      throw new Error(`Step state not found: ${step.name}`);
-    let lastExitCode;
-    let lastExitSignal;
-    this.checkAborted();
-    state.row.status = "running";
-    state.row.error = void 0;
-    state.row.completionReason = void 0;
-    state.row.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.db.updateStep(state.row.id, {
-      status: "running",
-      error: void 0,
-      completionReason: void 0,
-      startedAt: state.row.startedAt,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    this.emit({ type: "step:started", runId, stepName: step.name });
-    this.postToChannel(`**[${step.name}]** Started (worktree setup)`);
-    const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
-    const branch = this.interpolateStepTask(step.branch ?? "", stepOutputContext);
-    const baseBranch = step.baseBranch ? this.interpolateStepTask(step.baseBranch, stepOutputContext) : "HEAD";
-    const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path13.default.join(".worktrees", step.name);
-    const createBranch = step.createBranch !== false;
-    const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
-    this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
-    if (!branch) {
-      const errorMsg = 'Worktree step missing required "branch" field';
-      await this.markStepFailed(state, errorMsg, runId);
-      throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
-    }
-    try {
-      const absoluteWorktreePath = import_node_path13.default.resolve(stepCwd, worktreePath);
-      const checkBranchCmd = `git rev-parse --verify --quiet ${branch} 2>/dev/null`;
-      let branchExists = false;
-      await new Promise((resolve3) => {
-        const checkChild = (0, import_node_child_process5.spawn)("sh", ["-c", checkBranchCmd], {
-          stdio: "pipe",
-          cwd: stepCwd,
-          env: { ...process.env }
-        });
-        checkChild.on("close", (code) => {
-          branchExists = code === 0;
-          resolve3();
-        });
-        checkChild.on("error", () => resolve3());
-      });
-      let worktreeCmd;
-      if (branchExists) {
-        worktreeCmd = `git worktree add "${absoluteWorktreePath}" ${branch}`;
-      } else if (createBranch) {
-        worktreeCmd = `git worktree add -b ${branch} "${absoluteWorktreePath}" ${baseBranch}`;
-      } else {
-        const errorMsg = `Branch "${branch}" does not exist and createBranch is false`;
-        await this.markStepFailed(state, errorMsg, runId);
-        throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
-      }
-      let commandStdout = "";
-      let commandStderr = "";
-      let commandExitCode;
-      let commandExitSignal;
-      const output = await new Promise((resolve3, reject) => {
-        const child = (0, import_node_child_process5.spawn)("sh", ["-c", worktreeCmd], {
-          stdio: "pipe",
-          cwd: stepCwd,
-          env: { ...process.env }
-        });
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        const abortSignal = this.abortController?.signal;
-        let abortHandler;
-        if (abortSignal && !abortSignal.aborted) {
-          abortHandler = () => {
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 5e3);
-          };
-          abortSignal.addEventListener("abort", abortHandler, { once: true });
-        }
-        let timedOut = false;
-        let timer;
-        if (step.timeoutMs) {
-          timer = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 5e3);
-          }, step.timeoutMs);
-        }
-        child.stdout?.on("data", (chunk) => {
-          stdoutChunks.push(chunk.toString());
-        });
-        child.stderr?.on("data", (chunk) => {
-          stderrChunks.push(chunk.toString());
-        });
-        child.on("close", (code, signal) => {
-          if (timer)
-            clearTimeout(timer);
-          if (abortHandler && abortSignal) {
-            abortSignal.removeEventListener("abort", abortHandler);
-          }
-          if (abortSignal?.aborted) {
-            reject(new Error(`Step "${step.name}" aborted`));
-            return;
-          }
-          if (timedOut) {
-            reject(new Error(`Step "${step.name}" timed out (no step timeout set, check global swarm.timeoutMs)`));
-            return;
-          }
-          commandStdout = stdoutChunks.join("");
-          const stderr = stderrChunks.join("");
-          commandStderr = stderr;
-          commandExitCode = code ?? void 0;
-          commandExitSignal = signal ?? void 0;
-          lastExitCode = commandExitCode;
-          lastExitSignal = commandExitSignal;
-          if (code !== 0 && code !== null) {
-            reject(new Error(`git worktree add failed with exit code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
-            return;
-          }
-          resolve3(absoluteWorktreePath);
-        });
-        child.on("error", (err) => {
-          if (timer)
-            clearTimeout(timer);
-          if (abortHandler && abortSignal) {
-            abortSignal.removeEventListener("abort", abortHandler);
-          }
-          reject(new Error(`Failed to execute git worktree command: ${err.message}`));
-        });
-      });
-      this.captureStepTerminalEvidence(step.name, {
-        stdout: commandStdout || output,
-        stderr: commandStderr,
-        combined: [commandStdout || output, commandStderr].filter(Boolean).join("\n")
-      }, { exitCode: commandExitCode, exitSignal: commandExitSignal });
-      state.row.status = "completed";
-      state.row.output = output;
-      state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.db.updateStep(state.row.id, {
+        worktreeBranch = branch;
+        createdBranch = !branchExists && createBranch;
+        return { output };
+      },
+      toCompletionResult: ({ output }, attempt) => ({
         status: "completed",
         output,
-        completedAt: state.row.completedAt,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      await this.persistStepOutput(runId, step.name, output);
-      this.emit({ type: "step:completed", runId, stepName: step.name, output });
-      this.postToChannel(`**[${step.name}]** Worktree created at: ${output}
-  Branch: ${branch}${!branchExists && createBranch ? " (created)" : ""}`);
-      this.recordStepToolSideEffect(step.name, {
-        type: "worktree_created",
-        detail: `Worktree created at ${output}`,
-        raw: { branch, createdBranch: !branchExists && createBranch }
-      });
-      this.finalizeStepEvidence(step.name, "completed", state.row.completedAt);
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
-      await this.markStepFailed(state, errorMsg, runId, {
+        retries: attempt,
         exitCode: lastExitCode,
         exitSignal: lastExitSignal
-      });
-      throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
+      }),
+      getFailureResult: (error48) => ({
+        status: "failed",
+        output: "",
+        error: error48 instanceof Error ? error48.message : String(error48),
+        retries: state.row.retryCount,
+        exitCode: lastExitCode,
+        exitSignal: lastExitSignal
+      })
+    });
+    if (result.status === "failed") {
+      this.postToChannel(`**[${step.name}]** Failed: ${result.error ?? "Unknown error"}`);
+      throw new Error(`Step "${step.name}" failed: ${result.error ?? "Unknown error"}`);
     }
+    this.postToChannel(`**[${step.name}]** Worktree created at: ${result.output}
+  Branch: ${worktreeBranch}${createdBranch ? " (created)" : ""}`);
+    this.recordStepToolSideEffect(step.name, {
+      type: "worktree_created",
+      detail: `Worktree created at ${result.output}`,
+      raw: { branch: worktreeBranch, createdBranch }
+    });
   }
   /**
    * Execute an integration step (external service interaction via executor).
    */
-  async executeIntegrationStep(step, stepStates, runId) {
-    const state = stepStates.get(step.name);
-    if (!state)
-      throw new Error(`Step state not found: ${step.name}`);
-    this.checkAborted();
-    state.row.status = "running";
-    state.row.error = void 0;
-    state.row.completionReason = void 0;
-    state.row.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await this.db.updateStep(state.row.id, {
-      status: "running",
-      error: void 0,
-      completionReason: void 0,
-      startedAt: state.row.startedAt,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    this.emit({ type: "step:started", runId, stepName: step.name });
-    this.postToChannel(`**[${step.name}]** Started (integration: ${step.integration}.${step.action})`);
-    const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
-    const resolvedParams = {};
-    for (const [key, value] of Object.entries(step.params ?? {})) {
-      resolvedParams[key] = this.interpolateStepTask(value, stepOutputContext);
-    }
-    try {
-      if (!this.executor?.executeIntegrationStep) {
-        throw new Error(`Integration steps require a cloud executor. Step "${step.name}" cannot run locally. Use "cloud run" to execute workflows with integration steps.`);
-      }
-      const result = await this.executor.executeIntegrationStep(step, resolvedParams, { workspaceId: this.workspaceId });
-      if (!result.success) {
-        throw new Error(`Integration step "${step.name}" failed: ${result.output}`);
-      }
-      state.row.status = "completed";
-      state.row.output = result.output;
-      state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.db.updateStep(state.row.id, {
+  async executeIntegrationStep(step, state, stepStates, runId, lifecycle) {
+    const result = await lifecycle.monitorStep(step, state, {
+      startMessage: `**[${step.name}]** Started (integration: ${step.integration}.${step.action})`,
+      execute: async () => {
+        const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
+        const resolvedParams = {};
+        for (const [key, value] of Object.entries(step.params ?? {})) {
+          resolvedParams[key] = this.interpolateStepTask(value, stepOutputContext);
+        }
+        if (!this.executor?.executeIntegrationStep) {
+          throw new Error(`Integration steps require a cloud executor. Step "${step.name}" cannot run locally. Use "cloud run" to execute workflows with integration steps.`);
+        }
+        const integrationResult = await this.executor.executeIntegrationStep(step, resolvedParams, {
+          workspaceId: this.workspaceId
+        });
+        if (!integrationResult.success) {
+          throw new Error(`Integration step "${step.name}" failed: ${integrationResult.output}`);
+        }
+        return { output: integrationResult.output };
+      },
+      toCompletionResult: ({ output }, attempt) => ({
         status: "completed",
-        output: result.output,
-        completedAt: state.row.completedAt,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      await this.persistStepOutput(runId, step.name, result.output);
-      this.emit({ type: "step:completed", runId, stepName: step.name, output: result.output });
-      this.postToChannel(`**[${step.name}]** Completed (integration: ${step.integration}.${step.action})`);
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
-      await this.markStepFailed(state, errorMsg, runId);
-      throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
+        output,
+        retries: attempt
+      }),
+      getFailureResult: (error48) => ({
+        status: "failed",
+        output: "",
+        error: error48 instanceof Error ? error48.message : String(error48),
+        retries: state.row.retryCount
+      })
+    });
+    if (result.status === "failed") {
+      this.postToChannel(`**[${step.name}]** Failed: ${result.error ?? "Unknown error"}`);
+      throw new Error(`Step "${step.name}" failed: ${result.error ?? "Unknown error"}`);
     }
+    this.postToChannel(`**[${step.name}]** Completed (integration: ${step.integration}.${step.action})`);
   }
   /**
    * Execute an agent step (LLM-powered).
@@ -49265,7 +50332,11 @@ ${trimmedOutput.slice(0, 200)}`);
       this.emit({ type: "step:started", runId, stepName: step.name });
       this.postToChannel(`**[${step.name}]** Started (api)`);
       try {
-        const output = await executeApiStep(specialistDef.constraints?.model ?? "claude-sonnet-4-20250514", resolvedTask, { envSecrets: this.envSecrets, skills: specialistDef.skills, defaultMaxTokens: specialistDef.constraints?.maxTokens });
+        const output = await executeApiStep(specialistDef.constraints?.model ?? "claude-sonnet-4-20250514", resolvedTask, {
+          envSecrets: this.envSecrets,
+          skills: specialistDef.skills,
+          defaultMaxTokens: specialistDef.constraints?.maxTokens
+        });
         state.row.status = "completed";
         state.row.output = output;
         state.row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -49514,7 +50585,14 @@ ${resolvedTask}`;
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         await this.persistStepOutput(runId, step.name, combinedOutput);
-        this.emit({ type: "step:completed", runId, stepName: step.name, output: combinedOutput, exitCode: lastExitCode, exitSignal: lastExitSignal });
+        this.emit({
+          type: "step:completed",
+          runId,
+          stepName: step.name,
+          output: combinedOutput,
+          exitCode: lastExitCode,
+          exitSignal: lastExitSignal
+        });
         this.finalizeStepEvidence(step.name, "completed", state.row.completedAt, completionReason);
         await this.trajectory?.stepCompleted(step, combinedOutput, attempt + 1);
         return;
@@ -49668,8 +50746,8 @@ WORKER COMPLETION CONTRACT:
     let workerReleased = false;
     let resolveWorkerSpawn;
     let rejectWorkerSpawn;
-    const workerReady = new Promise((resolve3, reject) => {
-      resolveWorkerSpawn = resolve3;
+    const workerReady = new Promise((resolve4, reject) => {
+      resolveWorkerSpawn = resolve4;
       rejectWorkerSpawn = reject;
     });
     const specialistTask = this.buildWorkerHandoffTask(step, resolvedTask, supervised);
@@ -49944,7 +51022,7 @@ WORKER COMPLETION CONTRACT:
   }
   hasOwnerCompletionMarker(step, output, injectedTaskText) {
     const marker = `STEP_COMPLETE:${step.name}`;
-    const strippedOutput = this.stripInjectedTaskEcho(output, injectedTaskText);
+    const strippedOutput = stripInjectedTaskEcho(output, injectedTaskText);
     if (strippedOutput.includes(marker)) {
       return true;
     }
@@ -49994,28 +51072,11 @@ WORKER COMPLETION CONTRACT:
   stripEchoedPromptLines(output, patterns) {
     return output.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => patterns.every((pattern) => !pattern.test(line))).join("\n");
   }
-  stripInjectedTaskEcho(output, injectedTaskText) {
-    if (!injectedTaskText) {
-      return output;
-    }
-    const candidates = [
-      injectedTaskText,
-      injectedTaskText.replace(/\r\n/g, "\n"),
-      injectedTaskText.replace(/\n/g, "\r\n")
-    ].filter((candidate, index, all) => candidate.length > 0 && all.indexOf(candidate) === index);
-    for (const candidate of candidates) {
-      const start = output.indexOf(candidate);
-      if (start !== -1) {
-        return output.slice(0, start) + output.slice(start + candidate.length);
-      }
-    }
-    return output;
-  }
   outputContainsVerificationToken(output, token, injectedTaskText) {
     if (!token) {
       return false;
     }
-    return this.stripInjectedTaskEcho(output, injectedTaskText).includes(token);
+    return stripInjectedTaskEcho(output, injectedTaskText).includes(token);
   }
   prepareInteractiveSpawnTask(agentName, taskText) {
     if (Buffer.byteLength(taskText, "utf8") <= _WorkflowRunner.PTY_TASK_ARG_SIZE_LIMIT) {
@@ -50024,9 +51085,9 @@ WORKER COMPLETION CONTRACT:
         promptTaskText: taskText
       };
     }
-    const taskTmpDir = (0, import_node_fs10.mkdtempSync)(import_node_path13.default.join((0, import_node_os7.tmpdir)(), "relay-pty-task-"));
-    const taskTmpFile = import_node_path13.default.join(taskTmpDir, `${agentName}-${Date.now()}.txt`);
-    (0, import_node_fs10.writeFileSync)(taskTmpFile, taskText, { encoding: "utf8", mode: 384, flag: "wx" });
+    const taskTmpDir = (0, import_node_fs11.mkdtempSync)(import_node_path14.default.join((0, import_node_os7.tmpdir)(), "relay-pty-task-"));
+    const taskTmpFile = import_node_path14.default.join(taskTmpDir, `${agentName}-${Date.now()}.txt`);
+    (0, import_node_fs11.writeFileSync)(taskTmpFile, taskText, { encoding: "utf8", mode: 384, flag: "wx" });
     const promptTaskText = `TASK_FILE:${taskTmpFile}
 Read that file completely before taking any action.
 Treat the file contents as the full workflow task and follow them exactly.
@@ -50362,17 +51423,10 @@ ${review}
    * Delegates to the consolidated CLI registry for per-CLI arg formats.
    */
   static buildNonInteractiveCommand(cli, task, extraArgs = []) {
-    if (cli === "api") {
-      throw new Error('cli "api" uses direct API calls, not a subprocess command');
-    }
-    const resolvedCli = cli === "cursor" ? resolveCursorCli() : cli;
-    const def = getCliDefinition(resolvedCli);
-    if (!def || def.binaries.length === 0) {
-      throw new Error(`Unknown or non-executable CLI: ${resolvedCli}`);
-    }
+    const [cmd, ...args] = buildCommand(cli, extraArgs, task);
     return {
-      cmd: def.binaries[0],
-      args: def.nonInteractiveArgs(task, extraArgs)
+      cmd,
+      args
     };
   }
   /**
@@ -50438,8 +51492,8 @@ DO NOT:
 - Output only status messages without the actual deliverable content`;
     const { cmd, args } = _WorkflowRunner.buildNonInteractiveCommand(agentDef.cli, taskWithDeliverable, modelArgs);
     const logsDir = this.getWorkerLogsDir();
-    const logPath = import_node_path13.default.join(logsDir, `${agentName}.log`);
-    const logStream = (0, import_node_fs10.createWriteStream)(logPath, { flags: "a" });
+    const logPath = import_node_path14.default.join(logsDir, `${agentName}.log`);
+    const logStream = (0, import_node_fs11.createWriteStream)(logPath, { flags: "a" });
     this.registerWorker(agentName, agentDef.cli, step.task ?? "", void 0, false);
     let stopHeartbeat;
     if (this.relayApiKey) {
@@ -50455,11 +51509,11 @@ DO NOT:
     const stdoutChunks = [];
     const stderrChunks = [];
     try {
-      const { stdout: output, exitCode, exitSignal } = await new Promise((resolve3, reject) => {
-        const child = (0, import_node_child_process5.spawn)(cmd, args, {
+      const { stdout: output, exitCode, exitSignal } = await new Promise((resolve4, reject) => {
+        const child = spawnProcess([cmd, ...args], {
           stdio: ["ignore", "pipe", "pipe"],
           cwd: this.resolveEffectiveCwd(step, agentDef),
-          env: this.getRelayEnv() ?? { ...process.env }
+          env: this.getRelayEnv() ?? filteredEnv()
         });
         this.registerWorker(agentName, agentDef.cli, step.task ?? "", child.pid, false);
         const abortSignal = this.abortController?.signal;
@@ -50523,7 +51577,7 @@ DO NOT:
             reject(new SpawnExitError(`Step "${step.name}" exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`, code, signal));
             return;
           }
-          resolve3({
+          resolve4({
             stdout,
             exitCode: code ?? void 0,
             exitSignal: signal ?? void 0
@@ -50577,7 +51631,7 @@ DO NOT:
     const preparedTask = this.prepareInteractiveSpawnTask(agentName, taskWithExit);
     this.ptyOutputBuffers.set(agentName, []);
     const logsDir = this.getWorkerLogsDir();
-    const logStream = (0, import_node_fs10.createWriteStream)(import_node_path13.default.join(logsDir, `${agentName}.log`), { flags: "a" });
+    const logStream = (0, import_node_fs11.createWriteStream)(import_node_path14.default.join(logsDir, `${agentName}.log`), { flags: "a" });
     this.ptyLogStreams.set(agentName, logStream);
     this.ptyListeners.set(agentName, (chunk) => {
       const stripped = _WorkflowRunner.stripAnsi(chunk);
@@ -50612,18 +51666,18 @@ DO NOT:
         const oldName = agentName;
         this.ptyOutputBuffers.set(agent.name, this.ptyOutputBuffers.get(oldName) ?? []);
         this.ptyOutputBuffers.delete(oldName);
-        const oldLogPath = import_node_path13.default.join(logsDir, `${oldName}.log`);
-        const newLogPath = import_node_path13.default.join(logsDir, `${agent.name}.log`);
+        const oldLogPath = import_node_path14.default.join(logsDir, `${oldName}.log`);
+        const newLogPath = import_node_path14.default.join(logsDir, `${agent.name}.log`);
         const oldLogStream = this.ptyLogStreams.get(oldName);
         if (oldLogStream) {
           oldLogStream.end();
           this.ptyLogStreams.delete(oldName);
           try {
-            (0, import_node_fs10.renameSync)(oldLogPath, newLogPath);
+            (0, import_node_fs11.renameSync)(oldLogPath, newLogPath);
           } catch {
           }
         }
-        const newLogStream = (0, import_node_fs10.createWriteStream)(newLogPath, { flags: "a" });
+        const newLogStream = (0, import_node_fs11.createWriteStream)(newLogPath, { flags: "a" });
         this.ptyLogStreams.set(agent.name, newLogStream);
         const oldListener = this.ptyListeners.get(oldName);
         if (oldListener) {
@@ -50682,12 +51736,12 @@ DO NOT:
           if (verificationResult.passed) {
             this.log(`[${step.name}] Agent timed out but verification passed \u2014 treating as complete`);
             this.postToChannel(`**[${step.name}]** Agent idle after completing work \u2014 verification passed, releasing`);
-            await agent.release();
+            await agent.release().catch(() => void 0);
             timeoutRecovered = true;
           }
         }
         if (!timeoutRecovered) {
-          await agent.release();
+          await agent.release().catch(() => void 0);
           throw new Error(`Step "${step.name}" timed out after ${timeoutMs ?? "unknown"}ms`);
         }
       }
@@ -50730,8 +51784,8 @@ DO NOT:
     if (ptyChunks.length > 0) {
       output = ptyChunks.join("");
     } else {
-      const summaryPath = import_node_path13.default.join(this.summaryDir, `${step.name}.md`);
-      output = (0, import_node_fs10.existsSync)(summaryPath) ? await (0, import_promises5.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
+      const summaryPath = import_node_path14.default.join(this.summaryDir, `${step.name}.md`);
+      output = (0, import_node_fs11.existsSync)(summaryPath) ? await (0, import_promises5.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
     }
     if (ptyChunks.length === 0) {
       this.captureStepTerminalEvidence(evidenceStepName, { stdout: output, combined: output }, { exitCode: agent?.exitCode, exitSignal: agent?.exitSignal }, {
@@ -50827,13 +51881,13 @@ DO NOT:
               }
               this.log(`[${step.name}] Agent "${agent.name}" still idle after ${idleGraceSecs}s grace \u2014 releasing`);
               this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` idle \u2014 releasing (verification pending)`);
-              await agent.release();
+              await agent.release().catch(() => void 0);
               return "released";
             }
           }
           this.log(`[${step.name}] Agent "${agent.name}" went idle \u2014 treating as complete`);
           this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` idle \u2014 treating as complete`);
-          await agent.release();
+          await agent.release().catch(() => void 0);
           return "released";
         }
         return result.result;
@@ -50877,7 +51931,7 @@ DO NOT:
       }
       this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` still idle after ${nudgeCount} nudge(s) \u2014 force-releasing`);
       this.emit({ type: "step:force-released", runId: this.currentRunId ?? "", stepName: step.name });
-      await agent.release();
+      await agent.release().catch(() => void 0);
       return "force-released";
     }
   }
@@ -50933,70 +51987,11 @@ DO NOT:
   }
   // ── Verification ────────────────────────────────────────────────────────
   runVerification(check2, output, stepName, injectedTaskText, options) {
-    const fail = (message) => {
-      const observedAt2 = (/* @__PURE__ */ new Date()).toISOString();
-      this.recordStepToolSideEffect(stepName, {
-        type: "verification_observed",
-        detail: message,
-        observedAt: observedAt2,
-        raw: { passed: false, type: check2.type, value: check2.value }
-      });
-      this.getOrCreateStepEvidenceRecord(stepName).evidence.coordinationSignals.push({
-        kind: "verification_failed",
-        source: "verification",
-        text: message,
-        observedAt: observedAt2,
-        value: check2.value
-      });
-      if (options?.allowFailure) {
-        return {
-          passed: false,
-          completionReason: "failed_verification",
-          error: message
-        };
-      }
-      throw new WorkflowCompletionError(message, "failed_verification");
-    };
-    switch (check2.type) {
-      case "output_contains": {
-        const token = check2.value;
-        if (!this.outputContainsVerificationToken(output, token, injectedTaskText)) {
-          return fail(`Verification failed for "${stepName}": output does not contain "${token}"`);
-        }
-        break;
-      }
-      case "exit_code":
-        break;
-      case "file_exists":
-        if (!(0, import_node_fs10.existsSync)(import_node_path13.default.resolve(this.cwd, check2.value))) {
-          return fail(`Verification failed for "${stepName}": file "${check2.value}" does not exist`);
-        }
-        break;
-      case "custom":
-        return { passed: false };
-    }
-    if (options?.completionMarkerFound === false) {
-      this.log(`[${stepName}] Verification passed without legacy STEP_COMPLETE marker; allowing completion`);
-    }
-    const successMessage = options?.completionMarkerFound === false ? `Verification passed without legacy STEP_COMPLETE marker` : `Verification passed`;
-    const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.recordStepToolSideEffect(stepName, {
-      type: "verification_observed",
-      detail: successMessage,
-      observedAt,
-      raw: { passed: true, type: check2.type, value: check2.value }
+    return runVerification(check2, output, stepName, injectedTaskText, { ...options, cwd: this.cwd }, {
+      recordStepToolSideEffect: (name, effect) => this.recordStepToolSideEffect(name, effect),
+      getOrCreateStepEvidenceRecord: (name) => this.getOrCreateStepEvidenceRecord(name),
+      log: (message) => this.log(message)
     });
-    this.getOrCreateStepEvidenceRecord(stepName).evidence.coordinationSignals.push({
-      kind: "verification_passed",
-      source: "verification",
-      text: successMessage,
-      observedAt,
-      value: check2.value
-    });
-    return {
-      passed: true,
-      completionReason: "completed_verified"
-    };
   }
   // ── State helpers ─────────────────────────────────────────────────────
   async updateRunStatus(runId, status, error48) {
@@ -51117,12 +52112,12 @@ DO NOT:
   async waitIfPaused() {
     if (!this.paused)
       return;
-    await new Promise((resolve3) => {
-      this.pauseResolver = resolve3;
+    await new Promise((resolve4) => {
+      this.pauseResolver = resolve4;
     });
   }
   delay(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
+    return new Promise((resolve4) => setTimeout(resolve4, ms));
   }
   // ── Channel messaging ──────────────────────────────────────────────────
   /**
@@ -51130,24 +52125,7 @@ DO NOT:
    * Returns undefined if there are no non-interactive agents.
    */
   buildNonInteractiveAwareness(agentMap, stepStates) {
-    const nonInteractive = [...agentMap.values()].filter((a) => a.interactive === false);
-    if (nonInteractive.length === 0)
-      return void 0;
-    const agentToSteps = /* @__PURE__ */ new Map();
-    for (const [stepName, state] of stepStates) {
-      const agentName = state.row.agentName;
-      if (!agentName)
-        continue;
-      if (!agentToSteps.has(agentName))
-        agentToSteps.set(agentName, []);
-      agentToSteps.get(agentName).push(stepName);
-    }
-    const lines = nonInteractive.map((a) => {
-      const steps = agentToSteps.get(a.name) ?? [];
-      const stepRefs = steps.map((s) => `{{steps.${s}.output}}`).join(", ");
-      return `- ${a.name} (${a.cli}) \u2014 will return output when complete${stepRefs ? `. Access via: ${stepRefs}` : ""}`;
-    });
-    return "\n\n---\nNote: The following agents are non-interactive workers and cannot receive messages:\n" + lines.join("\n") + "\nDo NOT attempt to message these agents. Use the {{steps.<name>.output}} references above to access their results.";
+    return this.channelMessenger.buildNonInteractiveAwareness(agentMap, stepStates);
   }
   /**
    * Build guidance that encourages agents to autonomously delegate subtasks
@@ -51162,28 +52140,10 @@ DO NOT:
    * key, but they won't call `register` unless explicitly told to.
    */
   buildRelayRegistrationNote(cli, agentName) {
-    if (cli === "claude")
-      return "";
-    return `---
-RELAY SETUP \u2014 do this FIRST before any other relay tool:
-1. Call: register(name="${agentName}")
-   This authenticates you in the Relaycast workspace.
-   ALL relay tools (mcp__relaycast__message_dm_send, mcp__relaycast__message_inbox_check, mcp__relaycast__message_post, etc.) require
-   registration first \u2014 they will fail with "Not registered" otherwise.
-2. Your agent name is "${agentName}" \u2014 use this exact name when registering.`;
+    return this.channelMessenger.buildRelayRegistrationNote(cli, agentName);
   }
   buildDelegationGuidance(cli, timeoutMs) {
-    const timeoutNote = timeoutMs ? `You have approximately ${Math.round(timeoutMs / 6e4)} minutes before this step times out. Plan accordingly \u2014 delegate early if the work is substantial.
-
-` : "";
-    const subAgentOption = cli === "claude" ? "Option 2 \u2014 Use built-in sub-agents (Task tool) for research or scoped work:\n  - Good for exploring code, reading files, or making targeted changes\n  - Can run multiple sub-agents in parallel\n\n" : "";
-    return "---\nAUTONOMOUS DELEGATION \u2014 READ THIS BEFORE STARTING:\n" + timeoutNote + 'Before diving in, assess whether this task is too large or complex for a single agent. If it involves multiple independent subtasks, touches many files, or could take a long time, you should break it down and delegate to helper agents to avoid timeouts.\n\nOption 1 \u2014 Spawn relay agents (for real parallel coding work):\n  - mcp__relaycast__agent_add(name="helper-1", cli="claude", task="Specific subtask description")\n  - Coordinate via mcp__relaycast__message_dm_send(to="helper-1", text="...")\n  - Check on them with mcp__relaycast__message_inbox_check()\n  - Clean up when done: mcp__relaycast__agent_remove(name="helper-1")\n\n' + subAgentOption + `Guidelines:
-- You are the lead \u2014 delegate but stay in control, track progress, integrate results
-- Give each helper a clear, self-contained task with enough context to work independently
-- For simple or quick work, just do it yourself \u2014 don't over-delegate
-- Always release spawned relay agents when their work is complete
-- When spawning non-claude agents (codex, gemini, etc.), prepend to their task:
-  "RELAY SETUP: First call register(name='<exact-agent-name>') before any other relay tool."`;
+    return this.channelMessenger.buildDelegationGuidance(cli, timeoutMs);
   }
   /** Post a message to the workflow channel. Fire-and-forget — never throws or blocks. */
   postToChannel(text, options = {}) {
@@ -51208,43 +52168,11 @@ RELAY SETUP \u2014 do this FIRST before any other relay tool:
   }
   /** Post a rich completion report to the channel. */
   postCompletionReport(workflowName, outcomes, summary, confidence) {
-    const completed = outcomes.filter((o) => o.status === "completed");
-    const skipped = outcomes.filter((o) => o.status === "skipped");
-    const retried = outcomes.filter((o) => o.attempts > 1);
-    const lines = [
-      `## Workflow **${workflowName}** \u2014 Complete`,
-      "",
-      summary,
-      `Confidence: ${Math.round(confidence * 100)}%`,
-      "",
-      "### Steps",
-      ...completed.map((o) => `- **${o.name}** (${o.agent}) \u2014 passed${o.verificationPassed ? " (verified)" : ""}${o.attempts > 1 ? ` after ${o.attempts} attempts` : ""}`),
-      ...skipped.map((o) => `- **${o.name}** \u2014 skipped`)
-    ];
-    if (retried.length > 0) {
-      lines.push("", "### Retries");
-      for (const o of retried) {
-        lines.push(`- ${o.name}: ${o.attempts} attempts`);
-      }
-    }
-    this.postToChannel(lines.join("\n"));
+    this.channelMessenger.postCompletionReport(workflowName, outcomes, summary, confidence);
   }
   /** Post a failure report to the channel. */
   postFailureReport(workflowName, outcomes, errorMsg) {
-    const completed = outcomes.filter((o) => o.status === "completed");
-    const failed = outcomes.filter((o) => o.status === "failed");
-    const skipped = outcomes.filter((o) => o.status === "skipped");
-    const lines = [
-      `## Workflow **${workflowName}** \u2014 Failed`,
-      "",
-      `${completed.length}/${outcomes.length} steps passed. Error: ${errorMsg}`,
-      "",
-      "### Steps",
-      ...completed.map((o) => `- **${o.name}** (${o.agent}) \u2014 passed`),
-      ...failed.map((o) => `- **${o.name}** (${o.agent}) \u2014 FAILED: ${o.error ?? "unknown"}`),
-      ...skipped.map((o) => `- **${o.name}** \u2014 skipped`)
-    ];
-    this.postToChannel(lines.join("\n"));
+    this.channelMessenger.postFailureReport(workflowName, outcomes, errorMsg);
   }
   /**
    * Log a human-readable run summary to the console after completion or failure.
@@ -51276,7 +52204,7 @@ RELAY SETUP \u2014 do this FIRST before any other relay tool:
       }
     }
     const outputDir = this.getStepOutputDir(runId);
-    const logsDir = import_node_path13.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
+    const logsDir = import_node_path14.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
     console.log("");
     console.log(`  Run ID:      ${runId}`);
     console.log(`  Step output: ${outputDir}`);
@@ -51362,8 +52290,8 @@ ${excerpt}` : "";
     if (!target)
       return;
     try {
-      (0, import_node_fs10.mkdirSync)(import_node_path13.default.dirname(target), { recursive: true });
-      (0, import_node_fs10.writeFileSync)(target, runId + "\n", "utf8");
+      (0, import_node_fs11.mkdirSync)(import_node_path14.default.dirname(target), { recursive: true });
+      (0, import_node_fs11.writeFileSync)(target, runId + "\n", "utf8");
     } catch {
     }
   }
@@ -51387,15 +52315,15 @@ ${excerpt}` : "";
     const withoutSystemReminders = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/giu, "").replace(/<system-reminder>[\s\S]*/giu, "");
     const normalized = withoutSystemReminders.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     const ansiStripped = stripAnsi(normalized);
-    const SPINNER = "\\u2756\\u2738\\u2739\\u273a\\u273b\\u273c\\u273d\\u2731\\u2732\\u2733\\u2734\\u2735\\u2736\\u2737\\u2743\\u2745\\u2746\\u25d6\\u25d7\\u25d8\\u25d9\\u2022\\u25cf\\u25cb\\u25a0\\u25a1\\u25b6\\u25c0\\u23f5\\u23f6\\u23f7\\u23f8\\u23f9\\u25e2\\u25e3\\u25e4\\u25e5\\u2597\\u2596\\u2598\\u259d\\u2bc8\\u2bc7\\u2bc5\\u2bc6\\u00b7\\u2590\\u258c\\u2588\\u2584\\u2580\\u259a\\u259e\\u2b21\\u2b22";
-    const spinnerRe = new RegExp(`[${SPINNER}]`, "gu");
-    const spinnerClassRe = new RegExp(`^[\\s${SPINNER}]*$`, "u");
+    const SPINNER2 = "\\u2756\\u2738\\u2739\\u273a\\u273b\\u273c\\u273d\\u2731\\u2732\\u2733\\u2734\\u2735\\u2736\\u2737\\u2743\\u2745\\u2746\\u25d6\\u25d7\\u25d8\\u25d9\\u2022\\u25cf\\u25cb\\u25a0\\u25a1\\u25b6\\u25c0\\u23f5\\u23f6\\u23f7\\u23f8\\u23f9\\u25e2\\u25e3\\u25e4\\u25e5\\u2597\\u2596\\u2598\\u259d\\u2bc8\\u2bc7\\u2bc5\\u2bc6\\u00b7\\u2590\\u258c\\u2588\\u2584\\u2580\\u259a\\u259e\\u2b21\\u2b22";
+    const spinnerRe = new RegExp(`[${SPINNER2}]`, "gu");
+    const spinnerClassRe = new RegExp(`^[\\s${SPINNER2}]*$`, "u");
     const boxDrawingOnlyRe = /^[\s\u2500-\u257f\u2580-\u259f\u25a0-\u25ff\-_=~]{3,}$/u;
     const brokerLogRe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s+(?:INFO|WARN|ERROR|DEBUG)\s/u;
     const claudeHeaderRe = /^(?:[\s\u2580-\u259f✢*·▗▖▘▝]+\s*)?(?:Claude\s+Code(?:\s+v?[\d.]+)?|(?:Sonnet|Haiku|Opus)\s*[\d.]+|claude-(?:sonnet|haiku|opus)-[\w.-]+|Running\s+on\s+claude)/iu;
     const dirBreadcrumbRe = /^\s*~[\\/]/u;
     const uiHintRe = /\b(?:Press\s+up\s+to\s+edit|tab\s+to\s+queue|bypass\s+permissions|esc\s+to\s+interrupt)\b/iu;
-    const thinkingLineRe = new RegExp(`^[\\s${SPINNER}]*\\s*\\w[\\w\\s]*\\u2026\\s*$`, "u");
+    const thinkingLineRe = new RegExp(`^[\\s${SPINNER2}]*\\s*\\w[\\w\\s]*\\u2026\\s*$`, "u");
     const cursorOnlyRe = /^[\s❯⎿›»◀▶←→↑↓⟨⟩⟪⟫·]+$/u;
     const cursorAgentRe = /^(?:Cursor Agent|[\s⬡⬢]*Generating[.\s]|\[Pasted text|Auto-run all|Add a follow-up|ctrl\+c to stop|shift\+tab|Auto$|\/\s*commands|@\s*files|!\s*shell|follow-ups?\s|The user ha)/iu;
     const slashCommandRe = /^\/\w+\s*$/u;
@@ -51472,14 +52400,14 @@ ${excerpt}` : "";
   /** Directory for persisted step outputs: .agent-relay/step-outputs/{runId}/ */
   getStepOutputDir(runId) {
     this.validateRunId(runId);
-    return import_node_path13.default.join(this.cwd, ".agent-relay", "step-outputs", runId);
+    return import_node_path14.default.join(this.cwd, ".agent-relay", "step-outputs", runId);
   }
   /** Persist step output to disk and post full output as a channel message. */
   async persistStepOutput(runId, stepName, output) {
-    const outputPath = import_node_path13.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
+    const outputPath = import_node_path14.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
     try {
       const dir = this.getStepOutputDir(runId);
-      (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
+      (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
       const cleaned = _WorkflowRunner.stripAnsi(output);
       await (0, import_promises5.writeFile)(outputPath, cleaned);
     } catch {
@@ -51502,9 +52430,9 @@ ${preview}
 \`\`\``, { stepName });
   }
   async persistAgentReport(runId, stepName, report) {
-    const reportPath = import_node_path13.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
+    const reportPath = import_node_path14.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
     try {
-      (0, import_node_fs10.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
+      (0, import_node_fs11.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
       await (0, import_promises5.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf8");
     } catch {
     }
@@ -51512,18 +52440,18 @@ ${preview}
   /** Scan .agent-relay/step-outputs/ for the most recent run directory containing the needed steps. */
   findMostRecentRunWithSteps(stepNames) {
     try {
-      const baseDir = import_node_path13.default.join(this.cwd, ".agent-relay", "step-outputs");
-      if (!(0, import_node_fs10.existsSync)(baseDir))
+      const baseDir = import_node_path14.default.join(this.cwd, ".agent-relay", "step-outputs");
+      if (!(0, import_node_fs11.existsSync)(baseDir))
         return void 0;
-      const entries = (0, import_node_fs10.readdirSync)(baseDir);
+      const entries = (0, import_node_fs11.readdirSync)(baseDir);
       let best;
       for (const entry of entries) {
-        const dirPath = import_node_path13.default.join(baseDir, entry);
+        const dirPath = import_node_path14.default.join(baseDir, entry);
         try {
-          const stat2 = (0, import_node_fs10.statSync)(dirPath);
+          const stat2 = (0, import_node_fs11.statSync)(dirPath);
           if (!stat2.isDirectory())
             continue;
-          const hasAny = [...stepNames].some((name) => (0, import_node_fs10.existsSync)(import_node_path13.default.join(dirPath, `${name}.md`)));
+          const hasAny = [...stepNames].some((name) => (0, import_node_fs11.existsSync)(import_node_path14.default.join(dirPath, `${name}.md`)));
           if (!hasAny)
             continue;
           if (!best || stat2.mtimeMs > best.mtime) {
@@ -51541,10 +52469,10 @@ ${preview}
   /** Load persisted step output from disk. */
   loadStepOutput(runId, stepName) {
     try {
-      const filePath = import_node_path13.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
-      if (!(0, import_node_fs10.existsSync)(filePath))
+      const filePath = import_node_path14.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
+      if (!(0, import_node_fs11.existsSync)(filePath))
         return void 0;
-      return (0, import_node_fs10.readFileSync)(filePath, "utf-8");
+      return (0, import_node_fs11.readFileSync)(filePath, "utf-8");
     } catch {
       return void 0;
     }
@@ -51566,14 +52494,14 @@ ${preview}
   }
   reconstructRunFromCache(runId, config2) {
     const stepOutputDir = this.getStepOutputDir(runId);
-    if (!(0, import_node_fs10.existsSync)(stepOutputDir))
+    if (!(0, import_node_fs11.existsSync)(stepOutputDir))
       return null;
     let resumeConfig = config2 ?? this.currentConfig;
     if (!resumeConfig) {
-      const yamlPath = import_node_path13.default.join(this.cwd, "relay.yaml");
-      if ((0, import_node_fs10.existsSync)(yamlPath)) {
+      const yamlPath = import_node_path14.default.join(this.cwd, "relay.yaml");
+      if ((0, import_node_fs11.existsSync)(yamlPath)) {
         try {
-          const raw = (0, import_node_fs10.readFileSync)(yamlPath, "utf-8");
+          const raw = (0, import_node_fs11.readFileSync)(yamlPath, "utf-8");
           resumeConfig = this.parseYamlString(raw, yamlPath);
         } catch {
           return null;
@@ -51584,7 +52512,7 @@ ${preview}
     }
     let entries;
     try {
-      entries = (0, import_node_fs10.readdirSync)(stepOutputDir, { withFileTypes: true });
+      entries = (0, import_node_fs11.readdirSync)(stepOutputDir, { withFileTypes: true });
     } catch {
       return null;
     }
@@ -51599,10 +52527,10 @@ ${preview}
     let earliestMtime = Date.now();
     for (const stepName of cachedStepNames) {
       try {
-        const mdPath = import_node_path13.default.join(stepOutputDir, `${stepName}.md`);
-        const reportPath = import_node_path13.default.join(stepOutputDir, `${stepName}.report.json`);
-        const mdStat = (0, import_node_fs10.existsSync)(mdPath) ? (0, import_node_fs10.statSync)(mdPath) : null;
-        const reportStat = (0, import_node_fs10.existsSync)(reportPath) ? (0, import_node_fs10.statSync)(reportPath) : null;
+        const mdPath = import_node_path14.default.join(stepOutputDir, `${stepName}.md`);
+        const reportPath = import_node_path14.default.join(stepOutputDir, `${stepName}.report.json`);
+        const mdStat = (0, import_node_fs11.existsSync)(mdPath) ? (0, import_node_fs11.statSync)(mdPath) : null;
+        const reportStat = (0, import_node_fs11.existsSync)(reportPath) ? (0, import_node_fs11.statSync)(reportPath) : null;
         const mtime = Math.max(mdStat?.mtimeMs ?? 0, reportStat?.mtimeMs ?? 0);
         if (mtime > 0) {
           stepMtimes.set(stepName, new Date(mtime).toISOString());
@@ -51654,8 +52582,8 @@ ${preview}
   }
   /** Get or create the worker logs directory (.agent-relay/team/worker-logs) */
   getWorkerLogsDir() {
-    const logsDir = import_node_path13.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
-    (0, import_node_fs10.mkdirSync)(logsDir, { recursive: true });
+    const logsDir = import_node_path14.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
+    (0, import_node_fs11.mkdirSync)(logsDir, { recursive: true });
     return logsDir;
   }
   /** Register a spawned agent in workers.json so `agents:kill` can find it. */
@@ -51666,12 +52594,12 @@ ${preview}
       spawnedAt: Date.now(),
       pid,
       interactive,
-      logFile: import_node_path13.default.join(this.getWorkerLogsDir(), `${agentName}.log`)
+      logFile: import_node_path14.default.join(this.getWorkerLogsDir(), `${agentName}.log`)
     };
     this.activeWorkers.set(agentName, workerEntry);
     this.workersFileLock = this.workersFileLock.then(() => {
       try {
-        (0, import_node_fs10.mkdirSync)(import_node_path13.default.dirname(this.workersPath), { recursive: true });
+        (0, import_node_fs11.mkdirSync)(import_node_path14.default.dirname(this.workersPath), { recursive: true });
         const existing = this.readWorkers().filter((w) => w.name !== agentName);
         existing.push({ name: agentName, ...workerEntry });
         this.writeWorkers(existing);
@@ -51693,22 +52621,22 @@ ${preview}
   }
   readWorkers() {
     try {
-      if (!(0, import_node_fs10.existsSync)(this.workersPath))
+      if (!(0, import_node_fs11.existsSync)(this.workersPath))
         return [];
-      const raw = JSON.parse((0, import_node_fs10.readFileSync)(this.workersPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs11.readFileSync)(this.workersPath, "utf-8"));
       return Array.isArray(raw?.workers) ? raw.workers : [];
     } catch {
       return [];
     }
   }
   writeWorkers(workers) {
-    (0, import_node_fs10.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
+    (0, import_node_fs11.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
   }
 };
 
 // packages/sdk/dist/workflows/file-db.js
-var import_node_fs11 = require("node:fs");
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_fs12 = require("node:fs");
+var import_node_path15 = __toESM(require("node:path"), 1);
 var JsonFileWorkflowDb = class {
   filePath;
   /** Whether the storage directory is writable. False = silent no-op mode. */
@@ -51718,7 +52646,7 @@ var JsonFileWorkflowDb = class {
     this.filePath = filePath;
     let writable = false;
     try {
-      (0, import_node_fs11.mkdirSync)(import_node_path14.default.dirname(filePath), { recursive: true });
+      (0, import_node_fs12.mkdirSync)(import_node_path15.default.dirname(filePath), { recursive: true });
       writable = true;
     } catch {
     }
@@ -51730,8 +52658,8 @@ var JsonFileWorkflowDb = class {
   }
   hasStepOutputs(runId) {
     try {
-      const dir = import_node_path14.default.join(import_node_path14.default.dirname(this.filePath), "step-outputs", runId);
-      return (0, import_node_fs11.existsSync)(dir) && (0, import_node_fs11.readdirSync)(dir).length > 0;
+      const dir = import_node_path15.default.join(import_node_path15.default.dirname(this.filePath), "step-outputs", runId);
+      return (0, import_node_fs12.existsSync)(dir) && (0, import_node_fs12.readdirSync)(dir).length > 0;
     } catch {
       return false;
     }
@@ -51741,7 +52669,7 @@ var JsonFileWorkflowDb = class {
     if (!this.writable)
       return;
     try {
-      (0, import_node_fs11.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+      (0, import_node_fs12.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
     } catch (err) {
       if (!this.appendFailedOnce) {
         this.appendFailedOnce = true;
@@ -51755,7 +52683,7 @@ var JsonFileWorkflowDb = class {
     const steps = /* @__PURE__ */ new Map();
     let raw = "";
     try {
-      raw = (0, import_node_fs11.readFileSync)(this.filePath, "utf8");
+      raw = (0, import_node_fs12.readFileSync)(this.filePath, "utf8");
     } catch {
       return { runs, steps };
     }
@@ -53197,8 +54125,8 @@ var StateStore = class extends import_node_events4.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/templates.js
-var import_node_fs12 = require("node:fs");
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_fs13 = require("node:fs");
+var import_node_path16 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
 var YAML_EXTENSIONS = [".yaml", ".yml"];
@@ -53223,7 +54151,7 @@ var TemplateRegistry = class {
   fetcher;
   constructor(options = {}) {
     this.builtInTemplatesDir = this.resolveBuiltInTemplatesDir(options.builtInTemplatesDir);
-    this.customTemplatesDir = options.customTemplatesDir ? import_node_path15.default.resolve(options.customTemplatesDir) : import_node_path15.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
+    this.customTemplatesDir = options.customTemplatesDir ? import_node_path16.default.resolve(options.customTemplatesDir) : import_node_path16.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
     this.fetcher = options.fetcher ?? fetch;
   }
   listBuiltInTemplates() {
@@ -53297,13 +54225,13 @@ var TemplateRegistry = class {
     if (!templateName) {
       throw new Error('Template name is required. Provide name explicitly or include a string "name" field.');
     }
-    if (templateName.includes("/") || templateName.includes("\\") || templateName.includes("..") || import_node_path15.default.isAbsolute(templateName)) {
+    if (templateName.includes("/") || templateName.includes("\\") || templateName.includes("..") || import_node_path16.default.isAbsolute(templateName)) {
       throw new Error(`Invalid template name: "${templateName}" contains path separators or traversal sequences`);
     }
     this.validateRelayConfig(parsed, url2);
-    await import_node_fs12.promises.mkdir(this.customTemplatesDir, { recursive: true });
-    const targetPath = import_node_path15.default.join(this.customTemplatesDir, `${templateName}.yaml`);
-    await import_node_fs12.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
+    await import_node_fs13.promises.mkdir(this.customTemplatesDir, { recursive: true });
+    const targetPath = import_node_path16.default.join(this.customTemplatesDir, `${templateName}.yaml`);
+    await import_node_fs13.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
     return targetPath;
   }
   isTemplateShorthand(input) {
@@ -53324,15 +54252,15 @@ var TemplateRegistry = class {
   }
   resolveBuiltInTemplatesDir(explicitDir) {
     if (explicitDir) {
-      return import_node_path15.default.resolve(explicitDir);
+      return import_node_path16.default.resolve(explicitDir);
     }
-    const currentDir = import_node_path15.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
+    const currentDir = import_node_path16.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
     const candidates = [
-      import_node_path15.default.resolve(currentDir, "builtin-templates"),
-      import_node_path15.default.resolve(currentDir, "../workflows/builtin-templates")
+      import_node_path16.default.resolve(currentDir, "builtin-templates"),
+      import_node_path16.default.resolve(currentDir, "../workflows/builtin-templates")
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs12.existsSync)(candidate)) {
+      if ((0, import_node_fs13.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -53352,9 +54280,9 @@ var TemplateRegistry = class {
   }
   async findTemplatePath(directory, templateName) {
     for (const ext of YAML_EXTENSIONS) {
-      const candidate = import_node_path15.default.join(directory, `${templateName}${ext}`);
+      const candidate = import_node_path16.default.join(directory, `${templateName}${ext}`);
       try {
-        const stat2 = await import_node_fs12.promises.stat(candidate);
+        const stat2 = await import_node_fs13.promises.stat(candidate);
         if (stat2.isFile()) {
           return candidate;
         }
@@ -53364,7 +54292,7 @@ var TemplateRegistry = class {
     return void 0;
   }
   async readTemplateFile(templatePath) {
-    const raw = await import_node_fs12.promises.readFile(templatePath, "utf-8");
+    const raw = await import_node_fs13.promises.readFile(templatePath, "utf-8");
     const parsed = (0, import_yaml4.parse)(raw);
     if (!isRecord(parsed)) {
       throw new Error(`Template at ${templatePath} is not a YAML object`);
@@ -53557,7 +54485,7 @@ var TemplateRegistry = class {
   }
   async safeReadDir(directory) {
     try {
-      return await import_node_fs12.promises.readdir(directory);
+      return await import_node_fs13.promises.readdir(directory);
     } catch {
       return [];
     }
@@ -53724,8 +54652,8 @@ function isValidAgentName(name) {
 }
 
 // packages/utils/dist/logger.js
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
 }
@@ -53743,9 +54671,9 @@ var LEVEL_PRIORITY = {
 };
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
-  const logDir = import_node_path16.default.dirname(logFile);
-  if (!createdLogDirs.has(logDir) && !import_node_fs13.default.existsSync(logDir)) {
-    import_node_fs13.default.mkdirSync(logDir, { recursive: true });
+  const logDir = import_node_path17.default.dirname(logFile);
+  if (!createdLogDirs.has(logDir) && !import_node_fs14.default.existsSync(logDir)) {
+    import_node_fs14.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
   }
 }
@@ -53774,7 +54702,7 @@ function log(level, component, msg, extra) {
   const logFile = getLogFile();
   if (logFile) {
     ensureLogDir(logFile);
-    import_node_fs13.default.appendFileSync(logFile, formatted + "\n");
+    import_node_fs14.default.appendFileSync(logFile, formatted + "\n");
     return;
   }
   if (level === "ERROR" || level === "WARN") {
@@ -54044,14 +54972,14 @@ function benchmarkPatterns(iterations = 1e4) {
 }
 
 // packages/utils/dist/command-resolver.js
-var import_node_child_process6 = require("node:child_process");
-var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs15 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
   }
   try {
-    const output = (0, import_node_child_process6.execSync)(`which ${command}`, {
+    const output = (0, import_node_child_process7.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       // Ensure we have a reasonable PATH
@@ -54071,7 +54999,7 @@ function resolveCommand(command) {
 }
 function resolveSymlinks(filePath) {
   try {
-    const resolved = import_node_fs14.default.realpathSync(filePath);
+    const resolved = import_node_fs15.default.realpathSync(filePath);
     if (resolved !== filePath && process.env.DEBUG_SPAWN === "1") {
       console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
     }
@@ -54085,7 +55013,7 @@ function resolveSymlinks(filePath) {
 }
 function commandExists(command) {
   try {
-    (0, import_node_child_process6.execSync)(`which ${command}`, {
+    (0, import_node_child_process7.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -54097,8 +55025,8 @@ function commandExists(command) {
 
 // packages/utils/dist/git-remote.js
 var fs6 = __toESM(require("node:fs"), 1);
-var path14 = __toESM(require("node:path"), 1);
-var import_node_child_process7 = require("node:child_process");
+var path15 = __toESM(require("node:path"), 1);
+var import_node_child_process8 = require("node:child_process");
 function parseGitRemoteUrl(url2) {
   if (!url2)
     return null;
@@ -54114,11 +55042,11 @@ function parseGitRemoteUrl(url2) {
 }
 function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
   try {
-    const gitDir = path14.join(workingDirectory, ".git");
+    const gitDir = path15.join(workingDirectory, ".git");
     if (!fs6.existsSync(gitDir)) {
       return null;
     }
-    const result = (0, import_node_child_process7.execSync)(`git remote get-url ${remoteName}`, {
+    const result = (0, import_node_child_process8.execSync)(`git remote get-url ${remoteName}`, {
       cwd: workingDirectory,
       encoding: "utf-8",
       timeout: 5e3,
@@ -54127,7 +55055,7 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
     return result.trim() || null;
   } catch {
     try {
-      const configPath = path14.join(workingDirectory, ".git", "config");
+      const configPath = path15.join(workingDirectory, ".git", "config");
       if (!fs6.existsSync(configPath)) {
         return null;
       }
@@ -54148,13 +55076,13 @@ function getRepoFullName(workingDirectory) {
   return parseGitRemoteUrl(remoteUrl);
 }
 function findGitRoot(startPath) {
-  let currentPath = path14.resolve(startPath);
-  const root = path14.parse(currentPath).root;
+  let currentPath = path15.resolve(startPath);
+  const root = path15.parse(currentPath).root;
   while (currentPath !== root) {
-    if (fs6.existsSync(path14.join(currentPath, ".git"))) {
+    if (fs6.existsSync(path15.join(currentPath, ".git"))) {
       return currentPath;
     }
-    currentPath = path14.dirname(currentPath);
+    currentPath = path15.dirname(currentPath);
   }
   return null;
 }
@@ -54171,8 +55099,8 @@ function getRepoFullNameFromPath(workingDirectory) {
 }
 
 // packages/utils/dist/update-checker.js
-var import_node_fs15 = __toESM(require("node:fs"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_fs16 = __toESM(require("node:fs"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var import_node_https = __toESM(require("node:https"), 1);
 var import_node_os9 = __toESM(require("node:os"), 1);
 var import_compare_versions = __toESM(require_umd(), 1);
@@ -54180,15 +55108,15 @@ var PACKAGE_NAME = "agent-relay";
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 function getCachePath() {
-  const cacheDir = import_node_path17.default.join(import_node_os9.default.homedir(), ".agent-relay");
-  return import_node_path17.default.join(cacheDir, "update-cache.json");
+  const cacheDir = import_node_path18.default.join(import_node_os9.default.homedir(), ".agent-relay");
+  return import_node_path18.default.join(cacheDir, "update-cache.json");
 }
 function readCache() {
   try {
     const cachePath = getCachePath();
-    if (!import_node_fs15.default.existsSync(cachePath))
+    if (!import_node_fs16.default.existsSync(cachePath))
       return null;
-    const data = import_node_fs15.default.readFileSync(cachePath, "utf-8");
+    const data = import_node_fs16.default.readFileSync(cachePath, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -54197,27 +55125,27 @@ function readCache() {
 function writeCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = import_node_path17.default.dirname(cachePath);
-    if (!import_node_fs15.default.existsSync(cacheDir)) {
-      import_node_fs15.default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = import_node_path18.default.dirname(cachePath);
+    if (!import_node_fs16.default.existsSync(cacheDir)) {
+      import_node_fs16.default.mkdirSync(cacheDir, { recursive: true });
     }
-    import_node_fs15.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+    import_node_fs16.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
   } catch {
   }
 }
 function fetchLatestVersion() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const req = import_node_https.default.get(NPM_REGISTRY_URL, { timeout: 5e3 }, (res) => {
       if (res.statusCode === 301 || res.statusCode === 302) {
         const location = res.headers.location;
         if (location) {
           import_node_https.default.get(location, { timeout: 5e3 }, (redirectRes) => {
-            handleResponse(redirectRes, resolve3, reject);
+            handleResponse(redirectRes, resolve4, reject);
           }).on("error", reject);
           return;
         }
       }
-      handleResponse(res, resolve3, reject);
+      handleResponse(res, resolve4, reject);
     });
     req.on("error", reject);
     req.on("timeout", () => {
@@ -54226,7 +55154,7 @@ function fetchLatestVersion() {
     });
   });
 }
-function handleResponse(res, resolve3, reject) {
+function handleResponse(res, resolve4, reject) {
   if (res.statusCode !== 200) {
     reject(new Error(`HTTP ${res.statusCode}`));
     return;
@@ -54239,7 +55167,7 @@ function handleResponse(res, resolve3, reject) {
     try {
       const json2 = JSON.parse(data);
       if (json2.version) {
-        resolve3(json2.version);
+        resolve4(json2.version);
       } else {
         reject(new Error("No version in response"));
       }
@@ -54480,9 +55408,9 @@ function validateModelForCli(cli, model) {
 }
 
 // packages/utils/dist/relay-pty-path.js
-var import_node_fs16 = __toESM(require("node:fs"), 1);
+var import_node_fs17 = __toESM(require("node:fs"), 1);
 var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
   darwin: {
     arm64: "relay-pty-darwin-arm64",
@@ -54530,23 +55458,23 @@ function findRelayPtyBinary(callerDirname) {
   const scopedMatch = normalizedCaller.match(/^(.+?\/node_modules)\/@agent-relay\//);
   const directMatch = normalizedCaller.match(/^(.+?\/node_modules\/agent-relay)/);
   if (scopedMatch) {
-    packageRoots.push(import_node_path18.default.join(scopedMatch[1], "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(scopedMatch[1], "agent-relay"));
   }
   if (directMatch) {
     packageRoots.push(directMatch[1]);
   }
   if (!normalizedCaller.includes("node_modules")) {
-    packageRoots.push(import_node_path18.default.join(callerDirname, "..", "..", ".."));
+    packageRoots.push(import_node_path19.default.join(callerDirname, "..", "..", ".."));
   }
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
-    const npxCacheBase = import_node_path18.default.join(home, ".npm", "_npx");
-    if (import_node_fs16.default.existsSync(npxCacheBase)) {
+    const npxCacheBase = import_node_path19.default.join(home, ".npm", "_npx");
+    if (import_node_fs17.default.existsSync(npxCacheBase)) {
       try {
-        const entries = import_node_fs16.default.readdirSync(npxCacheBase);
+        const entries = import_node_fs17.default.readdirSync(npxCacheBase);
         for (const entry of entries) {
-          const npxPackage = import_node_path18.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
-          if (import_node_fs16.default.existsSync(npxPackage)) {
+          const npxPackage = import_node_path19.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
+          if (import_node_fs17.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
         }
@@ -54554,42 +55482,42 @@ function findRelayPtyBinary(callerDirname) {
       }
     }
   }
-  packageRoots.push(import_node_path18.default.join(process.cwd(), "node_modules", "agent-relay"));
+  packageRoots.push(import_node_path19.default.join(process.cwd(), "node_modules", "agent-relay"));
   if (home) {
-    packageRoots.push(import_node_path18.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, "n", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path18.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
-  }
-  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path18.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path18.default.join(home, ".agent-relay", "bin") : null;
-  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path18.default.join(home, ".local", "bin") : null);
-  const nodePrefix = import_node_path18.default.resolve(import_node_path18.default.dirname(process.execPath), "..");
-  packageRoots.push(import_node_path18.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, "n", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path19.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
+  }
+  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path19.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path19.default.join(home, ".agent-relay", "bin") : null;
+  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path19.default.join(home, ".local", "bin") : null);
+  const nodePrefix = import_node_path19.default.resolve(import_node_path19.default.dirname(process.execPath), "..");
+  packageRoots.push(import_node_path19.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
   packageRoots.push("/usr/local/lib/node_modules/agent-relay");
   packageRoots.push("/opt/homebrew/lib/node_modules/agent-relay");
   packageRoots.push("/usr/lib/node_modules/agent-relay");
   const candidates = [];
   for (const root of packageRoots) {
     if (platformBinary) {
-      candidates.push(import_node_path18.default.join(root, "bin", platformBinary));
+      candidates.push(import_node_path19.default.join(root, "bin", platformBinary));
     }
-    candidates.push(import_node_path18.default.join(root, "bin", "relay-pty"));
+    candidates.push(import_node_path19.default.join(root, "bin", "relay-pty"));
   }
   if (bashInstallerDir) {
     if (platformBinary) {
-      candidates.push(import_node_path18.default.join(bashInstallerDir, platformBinary));
+      candidates.push(import_node_path19.default.join(bashInstallerDir, platformBinary));
     }
-    candidates.push(import_node_path18.default.join(bashInstallerDir, "relay-pty"));
+    candidates.push(import_node_path19.default.join(bashInstallerDir, "relay-pty"));
   }
   if (bashInstallerBinDir) {
     if (platformBinary) {
-      candidates.push(import_node_path18.default.join(bashInstallerBinDir, platformBinary));
+      candidates.push(import_node_path19.default.join(bashInstallerBinDir, platformBinary));
     }
-    candidates.push(import_node_path18.default.join(bashInstallerBinDir, "relay-pty"));
+    candidates.push(import_node_path19.default.join(bashInstallerBinDir, "relay-pty"));
   }
   candidates.push("/app/bin/relay-pty");
   candidates.push("/usr/local/bin/relay-pty");
@@ -54604,7 +55532,7 @@ function findRelayPtyBinary(callerDirname) {
 }
 function isExecutable(filePath) {
   try {
-    import_node_fs16.default.accessSync(filePath, import_node_fs16.default.constants.X_OK);
+    import_node_fs17.default.accessSync(filePath, import_node_fs17.default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -54613,9 +55541,9 @@ function isExecutable(filePath) {
 function isPlatformCompatibleBinary(filePath) {
   let fd;
   try {
-    fd = import_node_fs16.default.openSync(filePath, "r");
+    fd = import_node_fs17.default.openSync(filePath, "r");
     const header = Buffer.alloc(4);
-    const bytesRead = import_node_fs16.default.readSync(fd, header, 0, 4, 0);
+    const bytesRead = import_node_fs17.default.readSync(fd, header, 0, 4, 0);
     if (bytesRead < 4) {
       return false;
     }
@@ -54633,7 +55561,7 @@ function isPlatformCompatibleBinary(filePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        import_node_fs16.default.closeSync(fd);
+        import_node_fs17.default.closeSync(fd);
       } catch {
       }
     }
@@ -54714,16 +55642,16 @@ function isMatchingResponse(response, requestId, correlationId) {
   const ackPayload = response.type === "ACK" ? response.payload : null;
   return response.id === requestId || responsePayload?.replyTo === requestId || !!correlationId && (responsePayload?.correlationId === correlationId || ackPayload?.correlationId === correlationId);
 }
-function handleResponse2(response, resolve3, reject) {
+function handleResponse2(response, resolve4, reject) {
   const responsePayload = response.payload;
   if (response.type === "ERROR") {
     reject(new Error(responsePayload?.message || responsePayload?.code || "Unknown error"));
   } else if (response.type === "ACK" || response.type === "SPAWN_RESULT" || response.type === "RELEASE_RESULT") {
-    resolve3(response.payload);
+    resolve4(response.payload);
   } else if (responsePayload?.error && !responsePayload?.success) {
     reject(new Error(responsePayload.error));
   } else {
-    resolve3(response.payload);
+    resolve4(response.payload);
   }
 }
 function createRequestEnvelope(type, payload, requestId, options) {
@@ -54757,7 +55685,7 @@ function toReleaseResult(payload) {
   };
 }
 function createRequestHandler(socketPath, envelope, options) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const correlationId = options.payloadMeta?.sync?.correlationId;
     let timedOut = false;
     const parser = new FrameParser();
@@ -54779,7 +55707,7 @@ function createRequestHandler(socketPath, envelope, options) {
         if (isMatchingResponse(response, envelope.id, correlationId)) {
           clearTimeout(timeoutId);
           socket.end();
-          handleResponse2(response, resolve3, reject);
+          handleResponse2(response, resolve4, reject);
           return;
         }
       }
@@ -55249,12 +56177,12 @@ var HookRegistry = class {
 };
 
 // packages/trajectory/dist/integration.js
-var import_node_child_process8 = require("node:child_process");
+var import_node_child_process9 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
 var import_node_crypto13 = __toESM(require("node:crypto"), 1);
-var import_node_path19 = __toESM(require("node:path"), 1);
-var import_node_fs17 = __toESM(require("node:fs"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_fs18 = __toESM(require("node:fs"), 1);
 var import_node_os11 = __toESM(require("node:os"), 1);
 function getGlobalBaseDir2() {
   if (process.env.AGENT_RELAY_DATA_DIR) {
@@ -55262,65 +56190,65 @@ function getGlobalBaseDir2() {
   }
   const xdgDataHome = process.env.XDG_DATA_HOME;
   if (xdgDataHome) {
-    return import_node_path19.default.join(xdgDataHome, "agent-relay");
+    return import_node_path20.default.join(xdgDataHome, "agent-relay");
   }
-  return import_node_path19.default.join(import_node_os11.default.homedir(), ".agent-relay");
+  return import_node_path20.default.join(import_node_os11.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
 var PROJECT_DATA_DIR = ".agent-relay";
 function hashPath(projectPath) {
-  const normalized = import_node_path19.default.resolve(projectPath);
+  const normalized = import_node_path20.default.resolve(projectPath);
   const hash2 = import_node_crypto13.default.createHash("sha256").update(normalized).digest("hex");
   return hash2.substring(0, 12);
 }
 function findProjectRoot(startDir = process.cwd()) {
   if (process.env.AGENT_RELAY_PROJECT) {
-    return import_node_path19.default.resolve(process.env.AGENT_RELAY_PROJECT);
+    return import_node_path20.default.resolve(process.env.AGENT_RELAY_PROJECT);
   }
-  let current = import_node_path19.default.resolve(startDir);
-  const root = import_node_path19.default.parse(current).root;
+  let current = import_node_path20.default.resolve(startDir);
+  const root = import_node_path20.default.parse(current).root;
   const markers = [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".agent-relay"];
   while (current !== root) {
     for (const marker of markers) {
-      if (import_node_fs17.default.existsSync(import_node_path19.default.join(current, marker))) {
+      if (import_node_fs18.default.existsSync(import_node_path20.default.join(current, marker))) {
         return current;
       }
     }
-    current = import_node_path19.default.dirname(current);
+    current = import_node_path20.default.dirname(current);
   }
-  return import_node_path19.default.resolve(startDir);
+  return import_node_path20.default.resolve(startDir);
 }
 function getProjectPaths2(projectRoot) {
   const root = projectRoot ?? findProjectRoot();
   const projectId = hashPath(root);
-  const dataDir = import_node_path19.default.join(root, PROJECT_DATA_DIR);
+  const dataDir = import_node_path20.default.join(root, PROJECT_DATA_DIR);
   return {
     dataDir,
-    teamDir: import_node_path19.default.join(dataDir, "team"),
-    dbPath: import_node_path19.default.join(dataDir, "messages.sqlite"),
-    socketPath: import_node_path19.default.join(dataDir, "relay.sock"),
+    teamDir: import_node_path20.default.join(dataDir, "team"),
+    dbPath: import_node_path20.default.join(dataDir, "messages.sqlite"),
+    socketPath: import_node_path20.default.join(dataDir, "relay.sock"),
     projectRoot: root,
     projectId
   };
 }
 
 // packages/config/dist/trajectory-config.js
-var import_node_fs18 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_path21 = require("node:path");
 var import_node_os12 = require("node:os");
 var import_node_crypto14 = require("node:crypto");
 function getAgentRelayConfigDir() {
-  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path20.join)((0, import_node_os12.homedir)(), ".config", "agent-relay");
+  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path21.join)((0, import_node_os12.homedir)(), ".config", "agent-relay");
 }
 var configCache = null;
 function getRelayConfigPath(_projectRoot) {
-  return (0, import_node_path20.join)(getAgentRelayConfigDir(), "relay.json");
+  return (0, import_node_path21.join)(getAgentRelayConfigDir(), "relay.json");
 }
 function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
   if (configCache && configCache.path === configPath) {
     try {
-      const stat2 = (0, import_node_fs18.statSync)(configPath);
+      const stat2 = (0, import_node_fs19.statSync)(configPath);
       if (stat2.mtimeMs === configCache.mtime) {
         return configCache.config;
       }
@@ -55328,13 +56256,13 @@ function readRelayConfig(projectRoot) {
     }
   }
   try {
-    if (!(0, import_node_fs18.existsSync)(configPath)) {
+    if (!(0, import_node_fs19.existsSync)(configPath)) {
       return {};
     }
-    const content = (0, import_node_fs18.readFileSync)(configPath, "utf-8");
+    const content = (0, import_node_fs19.readFileSync)(configPath, "utf-8");
     const config2 = JSON.parse(content);
     try {
-      const stat2 = (0, import_node_fs18.statSync)(configPath);
+      const stat2 = (0, import_node_fs19.statSync)(configPath);
       configCache = { path: configPath, config: config2, mtime: stat2.mtimeMs };
     } catch {
     }
@@ -55354,12 +56282,12 @@ function getProjectHash(projectRoot) {
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
-  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path20.join)((0, import_node_os12.homedir)(), ".config");
-  return (0, import_node_path20.join)(configDir, "agent-relay", "trajectories", projectHash);
+  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path21.join)((0, import_node_os12.homedir)(), ".config");
+  return (0, import_node_path21.join)(configDir, "agent-relay", "trajectories", projectHash);
 }
 function getRepoTrajectoriesDir(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_path20.join)(root, ".trajectories");
+  return (0, import_node_path21.join)(root, ".trajectories");
 }
 function getPrimaryTrajectoriesDir(projectRoot) {
   if (shouldStoreInRepo(projectRoot)) {
@@ -55376,9 +56304,9 @@ function getTrajectoryEnvVars(projectRoot) {
 
 // packages/trajectory/dist/integration.js
 async function runTrail(args) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const trajectoryEnv = getTrajectoryEnvVars();
-    const proc = (0, import_node_child_process8.spawn)("trail", args, {
+    const proc = (0, import_node_child_process9.spawn)("trail", args, {
       cwd: getProjectPaths2().projectRoot,
       env: { ...process.env, ...trajectoryEnv },
       stdio: ["pipe", "pipe", "pipe"]
@@ -55392,13 +56320,13 @@ async function runTrail(args) {
       stderr += data.toString();
     });
     proc.on("error", (err) => {
-      resolve3({ success: false, output: "", error: `Failed to run trail: ${err.message}` });
+      resolve4({ success: false, output: "", error: `Failed to run trail: ${err.message}` });
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve3({ success: true, output: stdout.trim() });
+        resolve4({ success: true, output: stdout.trim() });
       } else {
-        resolve3({ success: false, output: stdout.trim(), error: stderr.trim() || `Exit code: ${code}` });
+        resolve4({ success: false, output: stdout.trim(), error: stderr.trim() || `Exit code: ${code}` });
       }
     });
   });
@@ -55649,7 +56577,7 @@ var TrajectoryIntegration = class {
    */
   isTrailInstalledSync() {
     try {
-      (0, import_node_child_process8.execSync)("which trail", { stdio: "pipe" });
+      (0, import_node_child_process9.execSync)("which trail", { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -55999,8 +56927,8 @@ var HookEmitter = class {
 };
 
 // packages/hooks/dist/inbox-check/utils.js
-var import_node_fs19 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path22 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
   return process.env.AGENT_RELAY_NAME;
@@ -56010,16 +56938,16 @@ function getInboxPath(config2) {
   if (!agentName) {
     throw new Error("Agent name not configured. Set AGENT_RELAY_NAME env var.");
   }
-  return (0, import_node_path21.join)(config2.inboxDir, agentName, "inbox.md");
+  return (0, import_node_path22.join)(config2.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
-  return (0, import_node_fs19.existsSync)(inboxPath);
+  return (0, import_node_fs20.existsSync)(inboxPath);
 }
 function readInbox(inboxPath) {
   if (!inboxExists(inboxPath)) {
     return "";
   }
-  return (0, import_node_fs19.readFileSync)(inboxPath, "utf-8");
+  return (0, import_node_fs20.readFileSync)(inboxPath, "utf-8");
 }
 function hasUnreadMessages(inboxPath) {
   const content = readInbox(inboxPath);
@@ -56092,6 +57020,7 @@ init_dist2();
   COMMON_SEARCH_PATHS,
   CURSOR_MODEL_OPTIONS,
   CUSTOM_STEPS_FILE,
+  ChannelMessenger,
   ClaudeModels,
   CodexModels,
   ConsensusEngine,
@@ -56121,24 +57050,33 @@ init_dist2();
   ShadowManager,
   StateStore,
   StaticPatterns,
+  StepExecutor,
   SupermemoryAdapter,
   SwarmCoordinator,
   SwarmPatterns,
   TemplateRegistry,
+  TemplateResolver,
   TracedError,
   WorkflowBuilder,
+  WorkflowCompletionError,
   WorkflowRunner,
+  WorkflowStepLifecycleExecutor,
   WorkflowTrajectory,
   benchmarkPatterns,
   brokerLog,
   buildBlockReason,
+  buildCommand,
   buildModelSwitchCommand,
+  checkExitCode,
+  checkFileExists,
   checkForUpdates,
   checkForUpdatesInBackground,
+  checkOutputContains,
   cleanLines,
   clearBinaryCache,
   clearResolveCache,
   collectCliSession,
+  collectOutput,
   commandExists,
   connectionLog,
   countMessages,
@@ -56150,12 +57088,14 @@ init_dist2();
   createMemoryAdapter,
   createMemoryHooks,
   createMemoryService,
+  createProcessSpawner,
   createRequestEnvelope,
   createRequestHandler,
   createTraceableError,
   createTrajectoryHooks,
   createWorkflowRenderer,
   customStepsFileExists,
+  detectCompletion,
   estimateContextTokens,
   estimateTokens,
   executeApiStep,
@@ -56163,10 +57103,12 @@ init_dist2();
   findRelayPtyBinary,
   followLogs,
   formatDryRunReport,
+  formatError,
   formatMessagePreview,
   formatProposalMessage,
   formatResultMessage,
   formatRunSummaryTable,
+  formatStepOutput,
   generateAgentName,
   generateErrorId,
   generateRequestId,
@@ -56196,6 +57138,7 @@ init_dist2();
   hasRelayPtyBinary,
   hasUnreadMessages,
   inboxExists,
+  interpolateStepTask,
   isAgentStep,
   isConsensusCommand,
   isCustomStep,
@@ -56228,15 +57171,28 @@ init_dist2();
   resolveCliSync,
   resolveCommand,
   resolveCustomStep,
+  resolveDotPath,
   resolveSpawnPolicy,
+  resolveStepOutputRef,
+  resolveTemplate,
+  resolveTemplateForShell,
+  resolveVariables,
   routerLog,
+  runVerification,
   runWorkflow,
+  scrubForChannel,
+  scrubSecrets,
+  sendToChannel,
+  shellEscape,
   spawnFromEnv,
+  spawnProcess,
   stripAnsi,
   stripAnsiFast,
+  stripInjectedTaskEcho,
   toReleaseResult,
   toSpawnResult,
   trackPatternPerformance,
+  truncateMessage,
   unescapeFenceMarkersFast,
   validateCustomStepsUsage,
   validateModelForCli,