agent-relay 3.2.10 → 3.2.11

package/dist/index.cjs

@@ -1362,14 +1362,14 @@ var require_templates = __commonJS({
       }
       return results;
     }
-    function buildStyle(chalk3, styles4) {
+    function buildStyle(chalk4, styles4) {
       const enabled = {};
       for (const layer of styles4) {
         for (const style of layer.styles) {
           enabled[style[0]] = layer.inverse ? null : style.slice(1);
         }
       }
-      let current = chalk3;
+      let current = chalk4;
       for (const [styleName, styles5] of Object.entries(enabled)) {
         if (!Array.isArray(styles5)) {
           continue;
@@ -1381,7 +1381,7 @@ var require_templates = __commonJS({
       }
       return current;
     }
-    module2.exports = (chalk3, temporary) => {
+    module2.exports = (chalk4, temporary) => {
       const styles4 = [];
       const chunks = [];
       let chunk = [];
@@ -1391,13 +1391,13 @@ var require_templates = __commonJS({
         } else if (style) {
           const string7 = chunk.join("");
           chunk = [];
-          chunks.push(styles4.length === 0 ? string7 : buildStyle(chalk3, styles4)(string7));
+          chunks.push(styles4.length === 0 ? string7 : buildStyle(chalk4, styles4)(string7));
           styles4.push({ inverse, styles: parseStyle(style) });
         } else if (close) {
           if (styles4.length === 0) {
             throw new Error("Found extraneous } in Chalk template literal");
           }
-          chunks.push(buildStyle(chalk3, styles4)(chunk.join("")));
+          chunks.push(buildStyle(chalk4, styles4)(chunk.join("")));
           chunk = [];
           styles4.pop();
         } else {
@@ -1445,16 +1445,16 @@ var require_source = __commonJS({
       }
     };
     var chalkFactory = (options) => {
-      const chalk4 = {};
-      applyOptions(chalk4, options);
-      chalk4.template = (...arguments_) => chalkTag(chalk4.template, ...arguments_);
-      Object.setPrototypeOf(chalk4, Chalk.prototype);
-      Object.setPrototypeOf(chalk4.template, chalk4);
-      chalk4.template.constructor = () => {
+      const chalk5 = {};
+      applyOptions(chalk5, options);
+      chalk5.template = (...arguments_) => chalkTag(chalk5.template, ...arguments_);
+      Object.setPrototypeOf(chalk5, Chalk.prototype);
+      Object.setPrototypeOf(chalk5.template, chalk5);
+      chalk5.template.constructor = () => {
         throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
       };
-      chalk4.template.Instance = ChalkClass;
-      return chalk4.template;
+      chalk5.template.Instance = ChalkClass;
+      return chalk5.template;
     };
     function Chalk(options) {
       return chalkFactory(options);
@@ -1565,7 +1565,7 @@ var require_source = __commonJS({
       return openAll + string7 + closeAll;
     };
     var template;
-    var chalkTag = (chalk4, ...strings) => {
+    var chalkTag = (chalk5, ...strings) => {
       const [firstString] = strings;
       if (!isArray(firstString) || !isArray(firstString.raw)) {
         return strings.join(" ");
@@ -1581,14 +1581,14 @@ var require_source = __commonJS({
       if (template === void 0) {
         template = require_templates();
       }
-      return template(chalk4, parts.join(""));
+      return template(chalk5, parts.join(""));
     };
     Object.defineProperties(Chalk.prototype, styles4);
-    var chalk3 = Chalk();
-    chalk3.supportsColor = stdoutColor;
-    chalk3.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
-    chalk3.stderr.supportsColor = stderrColor;
-    module2.exports = chalk3;
+    var chalk4 = Chalk();
+    chalk4.supportsColor = stdoutColor;
+    chalk4.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk4.stderr.supportsColor = stderrColor;
+    module2.exports = chalk4;
   }
 });
 
@@ -9305,11 +9305,11 @@ __export(base_exports, {
   setCwd: () => setCwd,
   synchronizedOutput: () => synchronizedOutput
 });
-var import_node_process, import_node_os7, ESC, OSC, BEL, SEP, isTerminalApp, isWindows2, isTmux, cwdFunction, wrapOsc, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, isOldWindows, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beginSynchronizedOutput, endSynchronizedOutput, synchronizedOutput, beep, link, image, iTerm, ConEmu, setCwd;
+var import_node_process, import_node_os8, ESC, OSC, BEL, SEP, isTerminalApp, isWindows2, isTmux, cwdFunction, wrapOsc, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, isOldWindows, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beginSynchronizedOutput, endSynchronizedOutput, synchronizedOutput, beep, link, image, iTerm, ConEmu, setCwd;
 var init_base = __esm({
   "node_modules/ansi-escapes/base.js"() {
     import_node_process = __toESM(require("node:process"), 1);
-    import_node_os7 = __toESM(require("node:os"), 1);
+    import_node_os8 = __toESM(require("node:os"), 1);
     init_environment();
     ESC = "\x1B[";
     OSC = "\x1B]";
@@ -9389,7 +9389,7 @@ var init_base = __esm({
       if (isBrowser || !isWindows2) {
         return false;
       }
-      const parts = import_node_os7.default.release().split(".");
+      const parts = import_node_os8.default.release().split(".");
       const major = Number(parts[0]);
       const build = Number(parts[2] ?? 0);
       if (major < 10) {
@@ -12622,11 +12622,11 @@ function delay(time5) {
     setTimeout(resolve3, time5);
   });
 }
-var import_node_util2, import_util8, import_os, import_string_decoder, import_stream, 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, clone3, Concurrency, ListrError, ListrRendererError, PromptError, TaskWrapper, ListrTaskEventManager, Task, ListrEventManager, Listr;
+var import_node_util3, import_util8, import_os, import_string_decoder, import_stream, 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, clone3, Concurrency, ListrError, ListrRendererError, PromptError, TaskWrapper, ListrTaskEventManager, Task, ListrEventManager, Listr;
 var init_dist = __esm({
   "node_modules/listr2/dist/index.mjs"() {
     init_eventemitter3();
-    import_node_util2 = require("node:util");
+    import_node_util3 = require("node:util");
     import_util8 = require("util");
     import_os = require("os");
     import_string_decoder = require("string_decoder");
@@ -12711,7 +12711,7 @@ var init_dist = __esm({
     };
     CLEAR_LINE_REGEX = "(?:\\u001b|\\u009b)\\[[\\=><~/#&.:=?%@~_-]*[0-9]*[\\a-ln-tqyz=><~/#&.:=?%@~_-]+";
     BELL_REGEX = /\u0007/;
-    color = Object.fromEntries(Object.keys(import_node_util2.inspect.colors).map((color2) => [color2, (text) => (0, import_node_util2.styleText)(color2, String(text))]));
+    color = Object.fromEntries(Object.keys(import_node_util3.inspect.colors).map((color2) => [color2, (text) => (0, import_node_util3.styleText)(color2, String(text))]));
     FIGURES_MAIN = {
       warning: "\u26A0",
       cross: "\u2716",
@@ -14377,6 +14377,220 @@ var init_dist = __esm({
   }
 });
 
+// packages/sdk/dist/workflows/listr-renderer.js
+var listr_renderer_exports = {};
+__export(listr_renderer_exports, {
+  createWorkflowRenderer: () => createWorkflowRenderer
+});
+function installOutputFilter() {
+  const orig = console.log.bind(console);
+  console.log = (...args) => {
+    const str = String(args[0] ?? "");
+    if (str.includes("Observer:") || str.includes("agentrelay.dev") || str.includes("Channel: wf-")) {
+      orig(...args);
+      return;
+    }
+    if (/\[broker\]/.test(str) || /\[workflow\s+\d{2}:\d{2}\]/.test(str))
+      return;
+    orig(...args);
+  };
+  return () => {
+    console.log = orig;
+  };
+}
+function createWorkflowRenderer() {
+  const stepHandles = /* @__PURE__ */ new Map();
+  let resolveWorkflow;
+  let rejectWorkflow;
+  const workflowDone = new Promise((resolve3, reject) => {
+    resolveWorkflow = resolve3;
+    rejectWorkflow = reject;
+  });
+  workflowDone.catch(() => {
+  });
+  let setHeader = () => {
+  };
+  let listr = null;
+  const pendingAdds = [];
+  async function ensureListr() {
+    if (listr)
+      return listr;
+    const { Listr: Listr2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+    listr = new Listr2([
+      {
+        title: import_chalk3.default.dim("Workflow starting..."),
+        task: async (_ctx, task) => {
+          setHeader = (text) => {
+            task.title = text;
+          };
+          await workflowDone;
+        }
+      }
+    ], {
+      concurrent: true,
+      renderer: process.stdout.isTTY ? "default" : "verbose",
+      rendererOptions: {
+        collapseErrors: false,
+        showErrorMessage: true
+      }
+    });
+    for (const task of pendingAdds)
+      listr.add(task);
+    pendingAdds.length = 0;
+    return listr;
+  }
+  const addTask = (task) => {
+    if (listr)
+      listr.add(task);
+    else
+      pendingAdds.push(task);
+  };
+  const onEvent = (event) => {
+    switch (event.type) {
+      case "run:started": {
+        setHeader(import_chalk3.default.dim(`[workflow] run ${event.runId.slice(0, 8)}...`));
+        break;
+      }
+      case "step:started": {
+        let resolveStep;
+        let rejectStep;
+        let taskRef = null;
+        let skipped = false;
+        const done = new Promise((resolve3, reject) => {
+          resolveStep = resolve3;
+          rejectStep = reject;
+        });
+        done.catch(() => {
+        });
+        stepHandles.set(event.stepName, {
+          resolve: resolveStep,
+          reject: rejectStep,
+          setOutput: (text) => {
+            if (taskRef)
+              taskRef.output = text;
+          },
+          markSkipped: () => {
+            skipped = true;
+            if (taskRef)
+              taskRef.title = import_chalk3.default.dim(`${event.stepName} (skipped)`);
+          }
+        });
+        addTask({
+          title: import_chalk3.default.white(event.stepName),
+          task: async (_ctx, task) => {
+            taskRef = task;
+            if (skipped)
+              taskRef.title = import_chalk3.default.dim(`${event.stepName} (skipped)`);
+            await done;
+          },
+          rendererOptions: { persistentOutput: true }
+        });
+        break;
+      }
+      case "step:owner-assigned": {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(import_chalk3.default.dim(`> Owner: ${event.ownerName}`) + (event.specialistName ? import_chalk3.default.dim(` \xB7 specialist: ${event.specialistName}`) : ""));
+        }
+        break;
+      }
+      case "step:retrying": {
+        stepHandles.get(event.stepName)?.setOutput(import_chalk3.default.yellow(`Retrying (attempt ${event.attempt})`));
+        break;
+      }
+      case "step:nudged": {
+        stepHandles.get(event.stepName)?.setOutput(import_chalk3.default.dim(`> Nudge #${event.nudgeCount}`));
+        break;
+      }
+      case "step:force-released": {
+        stepHandles.get(event.stepName)?.setOutput(import_chalk3.default.yellow("> Force-released"));
+        break;
+      }
+      case "step:review-completed": {
+        stepHandles.get(event.stepName)?.setOutput(import_chalk3.default.dim(`> Review: ${event.decision} by ${event.reviewerName}`));
+        break;
+      }
+      case "step:owner-timeout": {
+        stepHandles.get(event.stepName)?.setOutput(import_chalk3.default.red(`> Owner ${event.ownerName} timed out`));
+        break;
+      }
+      case "step:agent-report": {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          const model = event.report.model ? `:${event.report.model}` : "";
+          handle.setOutput(import_chalk3.default.dim(`> Report collected (${event.report.cli}${model})`));
+        }
+        break;
+      }
+      case "step:completed": {
+        stepHandles.get(event.stepName)?.resolve();
+        break;
+      }
+      case "step:skipped": {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.markSkipped();
+          handle.resolve();
+        } else {
+          addTask({
+            title: import_chalk3.default.dim(`${event.stepName} (skipped)`),
+            task: async () => {
+            },
+            rendererOptions: { persistentOutput: true }
+          });
+        }
+        break;
+      }
+      case "step:failed": {
+        stepHandles.get(event.stepName)?.reject(new Error(event.error ?? "Step failed"));
+        break;
+      }
+      case "run:completed": {
+        setHeader(import_chalk3.default.green("Workflow completed"));
+        resolveWorkflow();
+        break;
+      }
+      case "run:failed": {
+        setHeader(import_chalk3.default.red(`Workflow failed: ${event.error ?? "unknown error"}`));
+        rejectWorkflow(new Error(event.error ?? "Workflow failed"));
+        break;
+      }
+      case "run:cancelled": {
+        setHeader(import_chalk3.default.yellow("Workflow cancelled"));
+        resolveWorkflow();
+        break;
+      }
+      case "broker:event":
+        break;
+      default: {
+        const _exhaustive = event;
+        void _exhaustive;
+      }
+    }
+  };
+  let restoreConsole;
+  return {
+    onEvent,
+    start: async () => {
+      restoreConsole = installOutputFilter();
+      const l = await ensureListr();
+      return l.run().catch(() => {
+      });
+    },
+    unmount: () => {
+      restoreConsole?.();
+      restoreConsole = void 0;
+    }
+  };
+}
+var import_chalk3;
+var init_listr_renderer = __esm({
+  "packages/sdk/dist/workflows/listr-renderer.js"() {
+    "use strict";
+    import_chalk3 = __toESM(require_source(), 1);
+  }
+});
+
 // node_modules/compare-versions/lib/umd/index.js
 var require_umd = __commonJS({
   "node_modules/compare-versions/lib/umd/index.js"(exports2, module2) {
@@ -15851,6 +16065,7 @@ __export(index_exports, {
   CLIVersions: () => CLIVersions,
   CLIs: () => CLIs,
   CODEX_MODEL_OPTIONS: () => CODEX_MODEL_OPTIONS,
+  COMMON_SEARCH_PATHS: () => COMMON_SEARCH_PATHS,
   CURSOR_MODEL_OPTIONS: () => CURSOR_MODEL_OPTIONS,
   CUSTOM_STEPS_FILE: () => CUSTOM_STEPS_FILE,
   ClaudeModels: () => ClaudeModels,
@@ -15899,6 +16114,7 @@ __export(index_exports, {
   checkForUpdatesInBackground: () => checkForUpdatesInBackground,
   cleanLines: () => cleanLines,
   clearBinaryCache: () => clearBinaryCache,
+  clearResolveCache: () => clearResolveCache,
   collectCliSession: () => collectCliSession,
   commandExists: () => commandExists,
   connectionLog: () => connectionLog,
@@ -15906,6 +16122,7 @@ __export(index_exports, {
   createCollector: () => createCollector,
   createConsensusEngine: () => createConsensusEngine,
   createContextCompactor: () => createContextCompactor,
+  createDefaultEventLogger: () => createDefaultEventLogger,
   createLogger: () => createLogger,
   createMemoryAdapter: () => createMemoryAdapter,
   createMemoryHooks: () => createMemoryHooks,
@@ -15933,6 +16150,8 @@ __export(index_exports, {
   getAgentName: () => getAgentName,
   getBaseCli: () => getBaseCli,
   getCachedRelayPtyPath: () => getCachedRelayPtyPath,
+  getCliDefinition: () => getCliDefinition,
+  getCliRegistry: () => getCliRegistry,
   getCompiledPatterns: () => getCompiledPatterns,
   getCustomStepsPath: () => getCustomStepsPath,
   getDefaultReasoningEffort: () => getDefaultReasoningEffort,
@@ -15980,6 +16199,8 @@ __export(index_exports, {
   readInbox: () => readInbox,
   resetPatternMetrics: () => resetPatternMetrics,
   resolveAllCustomSteps: () => resolveAllCustomSteps,
+  resolveCli: () => resolveCli,
+  resolveCliSync: () => resolveCliSync,
   resolveCommand: () => resolveCommand,
   resolveCustomStep: () => resolveCustomStep,
   resolveSpawnPolicy: () => resolveSpawnPolicy,
@@ -54688,29 +54909,120 @@ function isAgentStep(step) {
 }
 
 // packages/sdk/dist/workflows/runner.js
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process4 = require("node:child_process");
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs8 = require("node:fs");
-var import_promises4 = require("node:fs/promises");
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs9 = require("node:fs");
+var import_promises5 = require("node:fs/promises");
+var import_node_path12 = __toESM(require("node:path"), 1);
 var import_chalk = __toESM(require_source(), 1);
 var import_yaml2 = __toESM(require_dist(), 1);
 
-// packages/sdk/dist/spawn-from-env.js
-var BYPASS_FLAGS = {
-  claude: { flag: "--dangerously-skip-permissions" },
+// packages/sdk/dist/cli-registry.js
+var COMMON_SEARCH_PATHS = [
+  "~/.local/bin",
+  "~/.opencode/bin",
+  "~/.claude/local",
+  "/usr/local/bin",
+  "/usr/bin",
+  "/bin",
+  "/opt/homebrew/bin"
+];
+var CLI_REGISTRY = {
+  claude: {
+    binaries: ["claude"],
+    nonInteractiveArgs: (task, extra = []) => [
+      "-p",
+      "--dangerously-skip-permissions",
+      task,
+      ...extra
+    ],
+    bypassFlag: "--dangerously-skip-permissions",
+    searchPaths: ["~/.claude/local"]
+  },
   codex: {
-    flag: "--dangerously-bypass-approvals-and-sandbox",
-    aliases: ["--full-auto"]
+    binaries: ["codex"],
+    nonInteractiveArgs: (task, extra = []) => ["exec", task, ...extra],
+    bypassFlag: "--dangerously-bypass-approvals-and-sandbox",
+    bypassAliases: ["--full-auto"],
+    searchPaths: ["~/.local/bin"]
   },
   gemini: {
-    flag: "--yolo",
-    aliases: ["-y"]
+    binaries: ["gemini"],
+    nonInteractiveArgs: (task, extra = []) => ["-p", task, ...extra],
+    bypassFlag: "--yolo",
+    bypassAliases: ["-y"]
+  },
+  opencode: {
+    binaries: ["opencode"],
+    nonInteractiveArgs: (task, extra = []) => ["--prompt", task, ...extra],
+    searchPaths: ["~/.opencode/bin"]
+  },
+  droid: {
+    binaries: ["droid"],
+    nonInteractiveArgs: (task, extra = []) => ["exec", task, ...extra]
+  },
+  aider: {
+    binaries: ["aider"],
+    nonInteractiveArgs: (task, extra = []) => [
+      "--message",
+      task,
+      "--yes-always",
+      "--no-git",
+      ...extra
+    ]
+  },
+  goose: {
+    binaries: ["goose"],
+    nonInteractiveArgs: (task, extra = []) => [
+      "run",
+      "--text",
+      task,
+      "--no-session",
+      ...extra
+    ]
+  },
+  "cursor-agent": {
+    binaries: ["cursor-agent"],
+    nonInteractiveArgs: (task, extra = []) => [
+      "--force",
+      "-p",
+      task,
+      ...extra
+    ]
+  },
+  agent: {
+    binaries: ["agent"],
+    nonInteractiveArgs: (task, extra = []) => [
+      "--force",
+      "-p",
+      task,
+      ...extra
+    ]
+  },
+  cursor: {
+    binaries: ["cursor-agent", "agent"],
+    nonInteractiveArgs: (task, extra = []) => [
+      "--force",
+      "-p",
+      task,
+      ...extra
+    ]
   }
 };
-function getBypassFlagConfig(cli) {
+function getCliDefinition(cli) {
   const baseCli = cli.includes(":") ? cli.split(":")[0] : cli;
-  return BYPASS_FLAGS[baseCli];
+  return CLI_REGISTRY[baseCli];
+}
+function getCliRegistry() {
+  return CLI_REGISTRY;
+}
+
+// packages/sdk/dist/spawn-from-env.js
+function getBypassFlagConfig(cli) {
+  const def = getCliDefinition(cli);
+  if (!def?.bypassFlag)
+    return void 0;
+  return { flag: def.bypassFlag, aliases: def.bypassAliases };
 }
 function parseSpawnEnv(env = process.env) {
   const AGENT_NAME = env.AGENT_NAME;
@@ -54821,19 +55133,115 @@ async function spawnFromEnv(options = {}) {
   }
 }
 
-// packages/sdk/dist/workflows/custom-steps.js
+// packages/sdk/dist/cli-resolver.js
+var import_node_child_process3 = require("node:child_process");
+var import_promises2 = require("node:fs/promises");
 var import_node_fs3 = require("node:fs");
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_path6 = require("node:path");
+var import_node_os4 = require("node:os");
+var import_node_util2 = require("node:util");
+var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
+var resolveCache = /* @__PURE__ */ new Map();
+function clearResolveCache() {
+  resolveCache.clear();
+}
+function expandHome(p) {
+  if (p.startsWith("~/")) {
+    return (0, import_node_path6.join)((0, import_node_os4.homedir)(), p.slice(2));
+  }
+  return p;
+}
+async function resolveCli(cli) {
+  if (resolveCache.has(cli)) {
+    return resolveCache.get(cli) ?? void 0;
+  }
+  const def = getCliDefinition(cli);
+  if (!def)
+    return void 0;
+  for (const binary of def.binaries) {
+    try {
+      const { stdout } = await execFileAsync("which", [binary]);
+      const path18 = stdout.trim();
+      if (path18) {
+        const result = { binary, path: path18 };
+        resolveCache.set(cli, result);
+        return result;
+      }
+    } catch {
+    }
+    const searchDirs = [...def.searchPaths ?? [], ...COMMON_SEARCH_PATHS];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of searchDirs) {
+      const expanded = expandHome(dir);
+      if (seen.has(expanded))
+        continue;
+      seen.add(expanded);
+      const candidate = (0, import_node_path6.join)(expanded, binary);
+      try {
+        await (0, import_promises2.access)(candidate, import_promises2.constants.X_OK);
+        const result = { binary, path: candidate };
+        resolveCache.set(cli, result);
+        return result;
+      } catch {
+      }
+    }
+  }
+  resolveCache.set(cli, null);
+  return void 0;
+}
+function resolveCliSync(cli) {
+  if (resolveCache.has(cli)) {
+    return resolveCache.get(cli) ?? void 0;
+  }
+  const def = getCliDefinition(cli);
+  if (!def)
+    return void 0;
+  const { execFileSync } = 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 };
+        resolveCache.set(cli, result);
+        return result;
+      }
+    } catch {
+    }
+    const searchDirs = [...def.searchPaths ?? [], ...COMMON_SEARCH_PATHS];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of searchDirs) {
+      const expanded = expandHome(dir);
+      if (seen.has(expanded))
+        continue;
+      seen.add(expanded);
+      const candidate = (0, import_node_path6.join)(expanded, binary);
+      try {
+        (0, import_node_fs3.accessSync)(candidate, import_node_fs3.constants.X_OK);
+        const result = { binary, path: candidate };
+        resolveCache.set(cli, result);
+        return result;
+      } catch {
+      }
+    }
+  }
+  resolveCache.set(cli, null);
+  return void 0;
+}
+
+// packages/sdk/dist/workflows/custom-steps.js
+var import_node_fs4 = require("node:fs");
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_yaml = __toESM(require_dist(), 1);
 var CUSTOM_STEPS_FILE = ".relay/steps.yaml";
 function loadCustomSteps(cwd) {
-  const stepsPath = import_node_path6.default.join(cwd, CUSTOM_STEPS_FILE);
+  const stepsPath = import_node_path7.default.join(cwd, CUSTOM_STEPS_FILE);
   const steps = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs3.existsSync)(stepsPath)) {
+  if (!(0, import_node_fs4.existsSync)(stepsPath)) {
     return steps;
   }
   try {
-    const content = (0, import_node_fs3.readFileSync)(stepsPath, "utf-8");
+    const content = (0, import_node_fs4.readFileSync)(stepsPath, "utf-8");
     if (!content.trim()) {
       return steps;
     }
@@ -55083,21 +55491,21 @@ function resolveAllCustomSteps(steps, customSteps) {
   return steps.map((step) => resolveCustomStep(step, customSteps));
 }
 function customStepsFileExists(cwd) {
-  return (0, import_node_fs3.existsSync)(import_node_path6.default.join(cwd, CUSTOM_STEPS_FILE));
+  return (0, import_node_fs4.existsSync)(import_node_path7.default.join(cwd, CUSTOM_STEPS_FILE));
 }
 function getCustomStepsPath(cwd) {
-  return import_node_path6.default.join(cwd, CUSTOM_STEPS_FILE);
+  return import_node_path7.default.join(cwd, CUSTOM_STEPS_FILE);
 }
 
 // packages/sdk/dist/workflows/collectors/claude.js
-var import_node_fs4 = require("node:fs");
-var import_promises2 = require("node:fs/promises");
-var import_node_os4 = require("node:os");
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_fs5 = require("node:fs");
+var import_promises3 = require("node:fs/promises");
+var import_node_os5 = require("node:os");
+var import_node_path8 = __toESM(require("node:path"), 1);
 var import_node_readline2 = require("node:readline");
-var CLAUDE_HOME = import_node_path7.default.join((0, import_node_os4.homedir)(), ".claude");
-var HISTORY_PATH = import_node_path7.default.join(CLAUDE_HOME, "history.jsonl");
-var PROJECTS_PATH = import_node_path7.default.join(CLAUDE_HOME, "projects");
+var CLAUDE_HOME = import_node_path8.default.join((0, import_node_os5.homedir)(), ".claude");
+var HISTORY_PATH = import_node_path8.default.join(CLAUDE_HOME, "history.jsonl");
+var PROJECTS_PATH = import_node_path8.default.join(CLAUDE_HOME, "projects");
 var HISTORY_LOOKBACK_MS = 5e3;
 var ClaudeCodeCollector = class {
   canCollect() {
@@ -55108,7 +55516,7 @@ var ClaudeCodeCollector = class {
     if (!historyEntry) {
       return null;
     }
-    const sessionPath = import_node_path7.default.join(PROJECTS_PATH, encodeProjectPath(historyEntry.project), `${historyEntry.sessionId}.jsonl`);
+    const sessionPath = import_node_path8.default.join(PROJECTS_PATH, encodeProjectPath(historyEntry.project), `${historyEntry.sessionId}.jsonl`);
     if (!await isReadableFileAsync(sessionPath)) {
       return null;
     }
@@ -55117,7 +55525,7 @@ var ClaudeCodeCollector = class {
 };
 async function findMatchingHistoryEntry(query) {
   const history = (0, import_node_readline2.createInterface)({
-    input: (0, import_node_fs4.createReadStream)(HISTORY_PATH, { encoding: "utf8" }),
+    input: (0, import_node_fs5.createReadStream)(HISTORY_PATH, { encoding: "utf8" }),
     crlfDelay: Infinity
   });
   let match = null;
@@ -55146,7 +55554,7 @@ async function findMatchingHistoryEntry(query) {
 }
 async function parseSessionLog(sessionPath, query, sessionId) {
   const session = (0, import_node_readline2.createInterface)({
-    input: (0, import_node_fs4.createReadStream)(sessionPath, { encoding: "utf8" }),
+    input: (0, import_node_fs5.createReadStream)(sessionPath, { encoding: "utf8" }),
     crlfDelay: Infinity
   });
   const rawLines = [];
@@ -55379,21 +55787,21 @@ function getNumber(value) {
 }
 function isReadableFile(filePath) {
   try {
-    return (0, import_node_fs4.existsSync)(filePath) && (0, import_node_fs4.statSync)(filePath).isFile();
+    return (0, import_node_fs5.existsSync)(filePath) && (0, import_node_fs5.statSync)(filePath).isFile();
   } catch {
     return false;
   }
 }
 function isReadableDirectory(dirPath) {
   try {
-    return (0, import_node_fs4.existsSync)(dirPath) && (0, import_node_fs4.statSync)(dirPath).isDirectory();
+    return (0, import_node_fs5.existsSync)(dirPath) && (0, import_node_fs5.statSync)(dirPath).isDirectory();
   } catch {
     return false;
   }
 }
 async function isReadableFileAsync(filePath) {
   try {
-    await (0, import_promises2.access)(filePath);
+    await (0, import_promises3.access)(filePath);
     return true;
   } catch {
     return false;
@@ -55401,14 +55809,14 @@ async function isReadableFileAsync(filePath) {
 }
 
 // packages/sdk/dist/workflows/collectors/codex.js
-var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_os5 = __toESM(require("node:os"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 var import_node_module = require("node:module");
 var require2 = (0, import_node_module.createRequire)(import_meta_url);
-var CODEX_HOME = import_node_path8.default.join(import_node_os5.default.homedir(), ".codex");
-var DEFAULT_HISTORY_PATH = import_node_path8.default.join(CODEX_HOME, "history.jsonl");
-var DEFAULT_STATE_PATH = import_node_path8.default.join(CODEX_HOME, "state_5.sqlite");
+var CODEX_HOME = import_node_path9.default.join(import_node_os6.default.homedir(), ".codex");
+var DEFAULT_HISTORY_PATH = import_node_path9.default.join(CODEX_HOME, "history.jsonl");
+var DEFAULT_STATE_PATH = import_node_path9.default.join(CODEX_HOME, "state_5.sqlite");
 function loadBetterSqlite3() {
   try {
     return require2("better-sqlite3");
@@ -55502,7 +55910,7 @@ var CodexCollector = class {
     this.statePath = options.statePath ?? DEFAULT_STATE_PATH;
   }
   canCollect() {
-    return import_node_fs5.default.existsSync(this.statePath) || import_node_fs5.default.existsSync(this.historyPath);
+    return import_node_fs6.default.existsSync(this.statePath) || import_node_fs6.default.existsSync(this.historyPath);
   }
   async collect(query) {
     const historyEntries = this.readHistoryEntries();
@@ -55555,11 +55963,11 @@ var CodexCollector = class {
     };
   }
   readHistoryEntries() {
-    if (!import_node_fs5.default.existsSync(this.historyPath)) {
+    if (!import_node_fs6.default.existsSync(this.historyPath)) {
       return [];
     }
     try {
-      return import_node_fs5.default.readFileSync(this.historyPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+      return import_node_fs6.default.readFileSync(this.historyPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
         const parsed = parseJsonLine(line);
         return parsed ? [parsed] : [];
       });
@@ -55581,7 +55989,7 @@ var CodexCollector = class {
     return null;
   }
   async findMatchingThread(query) {
-    if (!import_node_fs5.default.existsSync(this.statePath)) {
+    if (!import_node_fs6.default.existsSync(this.statePath)) {
       return null;
     }
     const db = await openDatabase(this.statePath);
@@ -55607,7 +56015,7 @@ var CodexCollector = class {
     }
   }
   async readThreadErrors(threadId) {
-    if (!import_node_fs5.default.existsSync(this.statePath)) {
+    if (!import_node_fs6.default.existsSync(this.statePath)) {
       return [];
     }
     const db = await openDatabase(this.statePath);
@@ -55641,17 +56049,44 @@ var CodexCollector = class {
 };
 
 // packages/sdk/dist/workflows/collectors/opencode.js
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_os6 = __toESM(require("node:os"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_os7 = __toESM(require("node:os"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_module2 = require("node:module");
 var require3 = (0, import_node_module2.createRequire)(import_meta_url);
-var OPENCODE_DB_PATH = import_node_path9.default.join(import_node_os6.default.homedir(), ".local", "share", "opencode", "opencode.db");
+var OPENCODE_DB_PATH = import_node_path10.default.join(import_node_os7.default.homedir(), ".local", "share", "opencode", "opencode.db");
 var MATCH_WINDOW_GRACE_MS = 5e3;
 var ERROR_LINE_PATTERN = /^(Error|error:|Command failed|FAIL)\b/;
 function loadDatabaseConstructor() {
   try {
     return require3("better-sqlite3");
+  } catch {
+  }
+  try {
+    const { DatabaseSync } = require3("node:sqlite");
+    return function NativeSqliteWrapper(filename, options) {
+      const db = new DatabaseSync(filename, { open: true, readOnly: options?.readonly ?? false });
+      return {
+        prepare(sql) {
+          const stmt = db.prepare(sql);
+          return {
+            get(params) {
+              return params != null ? stmt.get(params) : stmt.get();
+            },
+            all(params) {
+              return params != null ? stmt.all(params) : stmt.all();
+            }
+          };
+        },
+        pragma(source) {
+          db.exec(`PRAGMA ${source}`);
+          return void 0;
+        },
+        close() {
+          db.close();
+        }
+      };
+    };
   } catch {
     return null;
   }
@@ -55680,7 +56115,7 @@ function isToolPart(part) {
 }
 var OpenCodeCollector = class {
   canCollect() {
-    if (!import_node_fs6.default.existsSync(OPENCODE_DB_PATH)) {
+    if (!import_node_fs7.default.existsSync(OPENCODE_DB_PATH)) {
       return false;
     }
     const Database = loadDatabaseConstructor();
@@ -55951,9 +56386,9 @@ function formatRunSummaryTable(outcomes, reports) {
 
 // packages/sdk/dist/workflows/trajectory.js
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs7 = require("node:fs");
-var import_promises3 = require("node:fs/promises");
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs8 = require("node:fs");
+var import_promises4 = require("node:fs/promises");
+var import_node_path11 = __toESM(require("node:path"), 1);
 function classifyFailure(error95) {
   const e = error95.toLowerCase();
   if (e.includes("timed out") || e.includes("timeout"))
@@ -56005,7 +56440,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_path10.default.join(cwd, ".trajectories");
+    this.dataDir = process.env.TRAJECTORIES_DATA_DIR ?? import_node_path11.default.join(cwd, ".trajectories");
   }
   // ── Lifecycle ──────────────────────────────────────────────────────────────
   /** Start the trajectory (called at run:started). */
@@ -56414,10 +56849,10 @@ var WorkflowTrajectory = class {
     if (!this.trajectory)
       return;
     try {
-      const activeDir = import_node_path10.default.join(this.dataDir, "active");
-      await (0, import_promises3.mkdir)(activeDir, { recursive: true });
-      const filePath = import_node_path10.default.join(activeDir, `${this.trajectory.id}.json`);
-      await (0, import_promises3.writeFile)(filePath, JSON.stringify(this.trajectory, null, 2), "utf-8");
+      const activeDir = import_node_path11.default.join(this.dataDir, "active");
+      await (0, import_promises4.mkdir)(activeDir, { recursive: true });
+      const filePath = import_node_path11.default.join(activeDir, `${this.trajectory.id}.json`);
+      await (0, import_promises4.writeFile)(filePath, JSON.stringify(this.trajectory, null, 2), "utf-8");
     } catch {
     }
   }
@@ -56425,13 +56860,13 @@ var WorkflowTrajectory = class {
     if (!this.trajectory)
       return;
     try {
-      const activeDir = import_node_path10.default.join(this.dataDir, "active");
-      const completedDir = import_node_path10.default.join(this.dataDir, "completed");
-      await (0, import_promises3.mkdir)(completedDir, { recursive: true });
-      const activePath = import_node_path10.default.join(activeDir, `${this.trajectory.id}.json`);
-      const completedPath = import_node_path10.default.join(completedDir, `${this.trajectory.id}.json`);
-      if ((0, import_node_fs7.existsSync)(activePath)) {
-        await (0, import_promises3.rename)(activePath, completedPath);
+      const activeDir = import_node_path11.default.join(this.dataDir, "active");
+      const completedDir = import_node_path11.default.join(this.dataDir, "completed");
+      await (0, import_promises4.mkdir)(completedDir, { recursive: true });
+      const activePath = import_node_path11.default.join(activeDir, `${this.trajectory.id}.json`);
+      const completedPath = import_node_path11.default.join(completedDir, `${this.trajectory.id}.json`);
+      if ((0, import_node_fs8.existsSync)(activePath)) {
+        await (0, import_promises4.rename)(activePath, completedPath);
       }
     } catch {
     }
@@ -56457,21 +56892,9 @@ var WorkflowCompletionError = class extends Error {
     this.completionReason = completionReason;
   }
 };
-var _resolvedCursorCli;
 function resolveCursorCli() {
-  if (_resolvedCursorCli !== void 0)
-    return _resolvedCursorCli;
-  const candidates = ["cursor-agent", "agent"];
-  for (const candidate of candidates) {
-    try {
-      (0, import_node_child_process3.execFileSync)("which", [candidate], { stdio: "ignore" });
-      _resolvedCursorCli = candidate;
-      return candidate;
-    } catch {
-    }
-  }
-  _resolvedCursorCli = "agent";
-  return _resolvedCursorCli;
+  const resolved = resolveCliSync("cursor");
+  return resolved?.binary ?? "agent";
 }
 var WorkflowRunner = class _WorkflowRunner {
   db;
@@ -56537,8 +56960,8 @@ 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_path11.default.join(this.cwd, ".relay", "summaries");
-    this.workersPath = import_node_path11.default.join(this.cwd, ".agent-relay", "team", "workers.json");
+    this.summaryDir = options.summaryDir ?? import_node_path12.default.join(this.cwd, ".relay", "summaries");
+    this.workersPath = import_node_path12.default.join(this.cwd, ".agent-relay", "team", "workers.json");
     this.executor = options.executor;
   }
   // ── Path resolution ─────────────────────────────────────────────────────
@@ -56567,10 +56990,10 @@ var WorkflowRunner = class _WorkflowRunner {
       }
       seenNames.add(pd.name);
       const expanded = _WorkflowRunner.resolveEnvVars(pd.path);
-      const abs = import_node_path11.default.resolve(baseCwd, expanded);
+      const abs = import_node_path12.default.resolve(baseCwd, expanded);
       resolved.set(pd.name, abs);
       const isRequired = pd.required !== false;
-      if (!(0, import_node_fs8.existsSync)(abs)) {
+      if (!(0, import_node_fs9.existsSync)(abs)) {
         if (isRequired) {
           errors.push(`Path "${pd.name}" resolves to "${abs}" which does not exist (required)`);
         } else {
@@ -56593,7 +57016,7 @@ var WorkflowRunner = class _WorkflowRunner {
       return resolved;
     }
     if (agent.cwd) {
-      return import_node_path11.default.resolve(this.cwd, agent.cwd);
+      return import_node_path12.default.resolve(this.cwd, agent.cwd);
     }
     return this.cwd;
   }
@@ -56612,7 +57035,7 @@ var WorkflowRunner = class _WorkflowRunner {
   }
   resolveEffectiveCwd(step, agentDef) {
     if (step.cwd) {
-      return import_node_path11.default.resolve(this.cwd, step.cwd);
+      return import_node_path12.default.resolve(this.cwd, step.cwd);
     }
     return this.resolveStepWorkdir(step) ?? (agentDef ? this.resolveAgentCwd(agentDef) : this.cwd);
   }
@@ -56906,16 +57329,16 @@ ${next}` : next;
     return void 0;
   }
   uniqueEvidenceRoots(roots) {
-    return [...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path11.default.resolve(root)))];
+    return [...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path12.default.resolve(root)))];
   }
   captureFileSnapshot(root) {
     const snapshot = /* @__PURE__ */ new Map();
-    if (!(0, import_node_fs8.existsSync)(root))
+    if (!(0, import_node_fs9.existsSync)(root))
       return snapshot;
     const visit = (currentPath) => {
       let entries;
       try {
-        entries = (0, import_node_fs8.readdirSync)(currentPath, { withFileTypes: true });
+        entries = (0, import_node_fs9.readdirSync)(currentPath, { withFileTypes: true });
       } catch {
         return;
       }
@@ -56923,13 +57346,13 @@ ${next}` : next;
         if (entry.isDirectory() && _WorkflowRunner.EVIDENCE_IGNORED_DIRS.has(entry.name)) {
           continue;
         }
-        const fullPath = import_node_path11.default.join(currentPath, entry.name);
+        const fullPath = import_node_path12.default.join(currentPath, entry.name);
         if (entry.isDirectory()) {
           visit(fullPath);
           continue;
         }
         try {
-          const stats = (0, import_node_fs8.statSync)(fullPath);
+          const stats = (0, import_node_fs9.statSync)(fullPath);
           if (!stats.isFile())
             continue;
           snapshot.set(fullPath, { mtimeMs: stats.mtimeMs, size: stats.size });
@@ -56938,7 +57361,7 @@ ${next}` : next;
       }
     };
     try {
-      const stats = (0, import_node_fs8.statSync)(root);
+      const stats = (0, import_node_fs9.statSync)(root);
       if (stats.isFile()) {
         snapshot.set(root, { mtimeMs: stats.mtimeMs, size: stats.size });
         return snapshot;
@@ -56975,9 +57398,9 @@ ${next}` : next;
     return changes.sort((a, b) => a.path.localeCompare(b.path));
   }
   normalizeEvidencePath(filePath) {
-    const relative = import_node_path11.default.relative(this.cwd, filePath);
+    const relative = import_node_path12.default.relative(this.cwd, filePath);
     if (!relative || relative === "")
-      return import_node_path11.default.basename(filePath);
+      return import_node_path12.default.basename(filePath);
     return relative.startsWith("..") ? filePath : relative;
   }
   buildStepCompletionDecision(stepName, completionReason) {
@@ -57185,8 +57608,8 @@ ${next}` : next;
   // ── Parsing & validation ────────────────────────────────────────────────
   /** Parse a relay.yaml file from disk. */
   async parseYamlFile(filePath) {
-    const absPath = import_node_path11.default.resolve(this.cwd, filePath);
-    const raw = await (0, import_promises4.readFile)(absPath, "utf-8");
+    const absPath = import_node_path12.default.resolve(this.cwd, filePath);
+    const raw = await (0, import_promises5.readFile)(absPath, "utf-8");
     return this.parseYamlString(raw, absPath);
   }
   /** Parse a relay.yaml string. */
@@ -57339,15 +57762,15 @@ ${err.suggestion}`);
     }
     for (const agent of resolved.agents) {
       if (agent.cwd) {
-        const resolvedCwd = import_node_path11.default.resolve(this.cwd, agent.cwd);
-        if (!(0, import_node_fs8.existsSync)(resolvedCwd)) {
+        const resolvedCwd = import_node_path12.default.resolve(this.cwd, agent.cwd);
+        if (!(0, import_node_fs9.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_path11.default.resolve(this.cwd, ap);
-          if (!(0, import_node_fs8.existsSync)(resolvedPath)) {
+          const resolvedPath = import_node_path12.default.resolve(this.cwd, ap);
+          if (!(0, import_node_fs9.existsSync)(resolvedPath)) {
             warnings.push(`Agent "${agent.name}" additionalPath "${ap}" resolves to "${resolvedPath}" which does not exist`);
           }
         }
@@ -57851,7 +58274,7 @@ ${err.suggestion}`);
           }
         }
         this.log("Starting broker...");
-        const brokerBaseName = import_node_path11.default.basename(this.cwd) || "workflow";
+        const brokerBaseName = import_node_path12.default.basename(this.cwd) || "workflow";
         const brokerName = `${brokerBaseName}-${runId.slice(0, 8)}`;
         this.relay = new AgentRelay({
           ...this.relayOptions,
@@ -57873,7 +58296,7 @@ ${err.suggestion}`);
           if (/Read\(/.test(stripped)) {
             const m = stripped.match(/Read\(\s*~?([^\s)"']{8,})/);
             if (m) {
-              const base = import_node_path11.default.basename(m[1]);
+              const base = import_node_path12.default.basename(m[1]);
               activity = base.length >= 3 ? `Reading ${base}` : "Reading file...";
             } else {
               activity = "Reading file...";
@@ -57881,7 +58304,7 @@ ${err.suggestion}`);
           } else if (/Edit\(/.test(stripped)) {
             const m = stripped.match(/Edit\(\s*~?([^\s)"']{8,})/);
             if (m) {
-              const base = import_node_path11.default.basename(m[1]);
+              const base = import_node_path12.default.basename(m[1]);
               activity = base.length >= 3 ? `Editing ${base}` : "Editing file...";
             } else {
               activity = "Editing file...";
@@ -58248,7 +58671,7 @@ ${err.suggestion}`);
       this.postToChannel(`**[preflight]** ${description}`);
       try {
         const output = await new Promise((resolve3, reject) => {
-          const child = (0, import_node_child_process3.spawn)("sh", ["-c", check3.command], {
+          const child = (0, import_node_child_process4.spawn)("sh", ["-c", check3.command], {
             stdio: "pipe",
             cwd: this.cwd,
             env: { ...process.env }
@@ -58431,7 +58854,7 @@ ${trimmedOutput.slice(0, 200)}`);
         let commandStdout = "";
         let commandStderr = "";
         const output = await new Promise((resolve3, reject) => {
-          const child = (0, import_node_child_process3.spawn)("sh", ["-c", resolvedCommand], {
+          const child = (0, import_node_child_process4.spawn)("sh", ["-c", resolvedCommand], {
             stdio: "pipe",
             cwd: stepCwd,
             env: { ...process.env }
@@ -58557,7 +58980,7 @@ ${trimmedOutput.slice(0, 200)}`);
     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_path11.default.join(".worktrees", step.name);
+    const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path12.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);
@@ -58567,11 +58990,11 @@ ${trimmedOutput.slice(0, 200)}`);
       throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
     }
     try {
-      const absoluteWorktreePath = import_node_path11.default.resolve(stepCwd, worktreePath);
+      const absoluteWorktreePath = import_node_path12.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_process3.spawn)("sh", ["-c", checkBranchCmd], {
+        const checkChild = (0, import_node_child_process4.spawn)("sh", ["-c", checkBranchCmd], {
           stdio: "pipe",
           cwd: stepCwd,
           env: { ...process.env }
@@ -58597,7 +59020,7 @@ ${trimmedOutput.slice(0, 200)}`);
       let commandExitCode;
       let commandExitSignal;
       const output = await new Promise((resolve3, reject) => {
-        const child = (0, import_node_child_process3.spawn)("sh", ["-c", worktreeCmd], {
+        const child = (0, import_node_child_process4.spawn)("sh", ["-c", worktreeCmd], {
           stdio: "pipe",
           cwd: stepCwd,
           env: { ...process.env }
@@ -59729,30 +60152,18 @@ ${review}
   }
   /**
    * Build the CLI command and arguments for a non-interactive agent execution.
-   * Each CLI has a specific flag for one-shot prompt mode.
+   * Delegates to the consolidated CLI registry for per-CLI arg formats.
    */
   static buildNonInteractiveCommand(cli, task, extraArgs = []) {
-    switch (cli) {
-      case "claude":
-        return { cmd: "claude", args: ["-p", "--dangerously-skip-permissions", task, ...extraArgs] };
-      case "codex":
-        return { cmd: "codex", args: ["exec", task, ...extraArgs] };
-      case "gemini":
-        return { cmd: "gemini", args: ["-p", task, ...extraArgs] };
-      case "opencode":
-        return { cmd: "opencode", args: ["--prompt", task, ...extraArgs] };
-      case "droid":
-        return { cmd: "droid", args: ["exec", task, ...extraArgs] };
-      case "aider":
-        return { cmd: "aider", args: ["--message", task, "--yes-always", "--no-git", ...extraArgs] };
-      case "goose":
-        return { cmd: "goose", args: ["run", "--text", task, "--no-session", ...extraArgs] };
-      case "cursor-agent":
-      case "agent":
-        return { cmd: cli, args: ["--force", "-p", task, ...extraArgs] };
-      case "cursor":
-        return { cmd: resolveCursorCli(), args: ["--force", "-p", task, ...extraArgs] };
+    const resolvedCli = cli === "cursor" ? resolveCursorCli() : cli;
+    const def = getCliDefinition(resolvedCli);
+    if (!def) {
+      throw new Error(`Unknown CLI: ${resolvedCli}`);
     }
+    return {
+      cmd: def.binaries[0],
+      args: def.nonInteractiveArgs(task, extraArgs)
+    };
   }
   /**
    * Apply preset defaults to an agent definition.
@@ -59817,8 +60228,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_path11.default.join(logsDir, `${agentName}.log`);
-    const logStream = (0, import_node_fs8.createWriteStream)(logPath, { flags: "a" });
+    const logPath = import_node_path12.default.join(logsDir, `${agentName}.log`);
+    const logStream = (0, import_node_fs9.createWriteStream)(logPath, { flags: "a" });
     this.registerWorker(agentName, agentDef.cli, step.task ?? "", void 0, false);
     let stopHeartbeat;
     if (this.relayApiKey) {
@@ -59835,7 +60246,7 @@ DO NOT:
     const stderrChunks = [];
     try {
       const { stdout: output, exitCode, exitSignal } = await new Promise((resolve3, reject) => {
-        const child = (0, import_node_child_process3.spawn)(cmd, args, {
+        const child = (0, import_node_child_process4.spawn)(cmd, args, {
           stdio: ["ignore", "pipe", "pipe"],
           cwd: this.resolveEffectiveCwd(step, agentDef),
           env: this.getRelayEnv() ?? { ...process.env }
@@ -59954,7 +60365,7 @@ DO NOT:
     const taskWithExit = step.task + (relayRegistrationNote ? "\n\n" + relayRegistrationNote : "") + (delegationGuidance ? "\n\n" + delegationGuidance + "\n" : "") + '\n\n---\nIMPORTANT: When you have fully completed this task, you MUST self-terminate by either: (a) calling remove_agent(name: "<your-agent-name>", reason: "task completed") \u2014 preferred, or (b) outputting the exact text "/exit" on its own line as a fallback. Do not wait for further input \u2014 terminate immediately after finishing. Do NOT spawn sub-agents unless the task explicitly requires it.';
     this.ptyOutputBuffers.set(agentName, []);
     const logsDir = this.getWorkerLogsDir();
-    const logStream = (0, import_node_fs8.createWriteStream)(import_node_path11.default.join(logsDir, `${agentName}.log`), { flags: "a" });
+    const logStream = (0, import_node_fs9.createWriteStream)(import_node_path12.default.join(logsDir, `${agentName}.log`), { flags: "a" });
     this.ptyLogStreams.set(agentName, logStream);
     this.ptyListeners.set(agentName, (chunk) => {
       const stripped = _WorkflowRunner.stripAnsi(chunk);
@@ -59989,18 +60400,18 @@ DO NOT:
         const oldName = agentName;
         this.ptyOutputBuffers.set(agent.name, this.ptyOutputBuffers.get(oldName) ?? []);
         this.ptyOutputBuffers.delete(oldName);
-        const oldLogPath = import_node_path11.default.join(logsDir, `${oldName}.log`);
-        const newLogPath = import_node_path11.default.join(logsDir, `${agent.name}.log`);
+        const oldLogPath = import_node_path12.default.join(logsDir, `${oldName}.log`);
+        const newLogPath = import_node_path12.default.join(logsDir, `${agent.name}.log`);
         const oldLogStream = this.ptyLogStreams.get(oldName);
         if (oldLogStream) {
           oldLogStream.end();
           this.ptyLogStreams.delete(oldName);
           try {
-            (0, import_node_fs8.renameSync)(oldLogPath, newLogPath);
+            (0, import_node_fs9.renameSync)(oldLogPath, newLogPath);
           } catch {
           }
         }
-        const newLogStream = (0, import_node_fs8.createWriteStream)(newLogPath, { flags: "a" });
+        const newLogStream = (0, import_node_fs9.createWriteStream)(newLogPath, { flags: "a" });
         this.ptyLogStreams.set(agent.name, newLogStream);
         const oldListener = this.ptyListeners.get(oldName);
         if (oldListener) {
@@ -60104,8 +60515,8 @@ DO NOT:
     if (ptyChunks.length > 0) {
       output = ptyChunks.join("");
     } else {
-      const summaryPath = import_node_path11.default.join(this.summaryDir, `${step.name}.md`);
-      output = (0, import_node_fs8.existsSync)(summaryPath) ? await (0, import_promises4.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_path12.default.join(this.summaryDir, `${step.name}.md`);
+      output = (0, import_node_fs9.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 }, {
@@ -60356,7 +60767,7 @@ DO NOT:
       case "exit_code":
         break;
       case "file_exists":
-        if (!(0, import_node_fs8.existsSync)(import_node_path11.default.resolve(this.cwd, check3.value))) {
+        if (!(0, import_node_fs9.existsSync)(import_node_path12.default.resolve(this.cwd, check3.value))) {
           return fail(`Verification failed for "${stepName}": file "${check3.value}" does not exist`);
         }
         break;
@@ -60668,7 +61079,7 @@ RELAY SETUP \u2014 do this FIRST before any other relay tool:
       }
     }
     const outputDir = this.getStepOutputDir(runId);
-    const logsDir = import_node_path11.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
+    const logsDir = import_node_path12.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
     console.log("");
     console.log(`  Run ID:      ${runId}`);
     console.log(`  Step output: ${outputDir}`);
@@ -60754,8 +61165,8 @@ ${excerpt}` : "";
     if (!target)
       return;
     try {
-      (0, import_node_fs8.mkdirSync)(import_node_path11.default.dirname(target), { recursive: true });
-      (0, import_node_fs8.writeFileSync)(target, runId + "\n", "utf8");
+      (0, import_node_fs9.mkdirSync)(import_node_path12.default.dirname(target), { recursive: true });
+      (0, import_node_fs9.writeFileSync)(target, runId + "\n", "utf8");
     } catch {
     }
   }
@@ -60857,16 +61268,16 @@ ${excerpt}` : "";
   }
   /** Directory for persisted step outputs: .agent-relay/step-outputs/{runId}/ */
   getStepOutputDir(runId) {
-    return import_node_path11.default.join(this.cwd, ".agent-relay", "step-outputs", runId);
+    return import_node_path12.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_path11.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
+    const outputPath = import_node_path12.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
     try {
       const dir = this.getStepOutputDir(runId);
-      (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
+      (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
       const cleaned = _WorkflowRunner.stripAnsi(output);
-      await (0, import_promises4.writeFile)(outputPath, cleaned);
+      await (0, import_promises5.writeFile)(outputPath, cleaned);
     } catch {
     }
     this.recordStepToolSideEffect(stepName, {
@@ -60887,28 +61298,28 @@ ${preview}
 \`\`\``, { stepName });
   }
   async persistAgentReport(runId, stepName, report) {
-    const reportPath = import_node_path11.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
+    const reportPath = import_node_path12.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
     try {
-      (0, import_node_fs8.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
-      await (0, import_promises4.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf8");
+      (0, import_node_fs9.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
+      await (0, import_promises5.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf8");
     } catch {
     }
   }
   /** Scan .agent-relay/step-outputs/ for the most recent run directory containing the needed steps. */
   findMostRecentRunWithSteps(stepNames) {
     try {
-      const baseDir = import_node_path11.default.join(this.cwd, ".agent-relay", "step-outputs");
-      if (!(0, import_node_fs8.existsSync)(baseDir))
+      const baseDir = import_node_path12.default.join(this.cwd, ".agent-relay", "step-outputs");
+      if (!(0, import_node_fs9.existsSync)(baseDir))
         return void 0;
-      const entries = (0, import_node_fs8.readdirSync)(baseDir);
+      const entries = (0, import_node_fs9.readdirSync)(baseDir);
       let best;
       for (const entry of entries) {
-        const dirPath = import_node_path11.default.join(baseDir, entry);
+        const dirPath = import_node_path12.default.join(baseDir, entry);
         try {
-          const stat2 = (0, import_node_fs8.statSync)(dirPath);
+          const stat2 = (0, import_node_fs9.statSync)(dirPath);
           if (!stat2.isDirectory())
             continue;
-          const hasAny = [...stepNames].some((name) => (0, import_node_fs8.existsSync)(import_node_path11.default.join(dirPath, `${name}.md`)));
+          const hasAny = [...stepNames].some((name) => (0, import_node_fs9.existsSync)(import_node_path12.default.join(dirPath, `${name}.md`)));
           if (!hasAny)
             continue;
           if (!best || stat2.mtimeMs > best.mtime) {
@@ -60926,18 +61337,18 @@ ${preview}
   /** Load persisted step output from disk. */
   loadStepOutput(runId, stepName) {
     try {
-      const filePath = import_node_path11.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
-      if (!(0, import_node_fs8.existsSync)(filePath))
+      const filePath = import_node_path12.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
+      if (!(0, import_node_fs9.existsSync)(filePath))
         return void 0;
-      return (0, import_node_fs8.readFileSync)(filePath, "utf-8");
+      return (0, import_node_fs9.readFileSync)(filePath, "utf-8");
     } catch {
       return void 0;
     }
   }
   /** Get or create the worker logs directory (.agent-relay/team/worker-logs) */
   getWorkerLogsDir() {
-    const logsDir = import_node_path11.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
-    (0, import_node_fs8.mkdirSync)(logsDir, { recursive: true });
+    const logsDir = import_node_path12.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
+    (0, import_node_fs9.mkdirSync)(logsDir, { recursive: true });
     return logsDir;
   }
   /** Register a spawned agent in workers.json so `agents:kill` can find it. */
@@ -60948,12 +61359,12 @@ ${preview}
       spawnedAt: Date.now(),
       pid,
       interactive,
-      logFile: import_node_path11.default.join(this.getWorkerLogsDir(), `${agentName}.log`)
+      logFile: import_node_path12.default.join(this.getWorkerLogsDir(), `${agentName}.log`)
     };
     this.activeWorkers.set(agentName, workerEntry);
     this.workersFileLock = this.workersFileLock.then(() => {
       try {
-        (0, import_node_fs8.mkdirSync)(import_node_path11.default.dirname(this.workersPath), { recursive: true });
+        (0, import_node_fs9.mkdirSync)(import_node_path12.default.dirname(this.workersPath), { recursive: true });
         const existing = this.readWorkers().filter((w) => w.name !== agentName);
         existing.push({ name: agentName, ...workerEntry });
         this.writeWorkers(existing);
@@ -60975,22 +61386,22 @@ ${preview}
   }
   readWorkers() {
     try {
-      if (!(0, import_node_fs8.existsSync)(this.workersPath))
+      if (!(0, import_node_fs9.existsSync)(this.workersPath))
         return [];
-      const raw = JSON.parse((0, import_node_fs8.readFileSync)(this.workersPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs9.readFileSync)(this.workersPath, "utf-8"));
       return Array.isArray(raw?.workers) ? raw.workers : [];
     } catch {
       return [];
     }
   }
   writeWorkers(workers) {
-    (0, import_node_fs8.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
+    (0, import_node_fs9.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
   }
 };
 
 // packages/sdk/dist/workflows/file-db.js
-var import_node_fs9 = require("node:fs");
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_fs10 = require("node:fs");
+var import_node_path13 = __toESM(require("node:path"), 1);
 var JsonFileWorkflowDb = class {
   filePath;
   /** Whether the storage directory is writable. False = silent no-op mode. */
@@ -60999,7 +61410,7 @@ var JsonFileWorkflowDb = class {
     this.filePath = filePath;
     let writable = false;
     try {
-      (0, import_node_fs9.mkdirSync)(import_node_path12.default.dirname(filePath), { recursive: true });
+      (0, import_node_fs10.mkdirSync)(import_node_path13.default.dirname(filePath), { recursive: true });
       writable = true;
     } catch {
     }
@@ -61014,7 +61425,7 @@ var JsonFileWorkflowDb = class {
     if (!this.writable)
       return;
     try {
-      (0, import_node_fs9.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+      (0, import_node_fs10.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
     } catch {
     }
   }
@@ -61024,7 +61435,7 @@ var JsonFileWorkflowDb = class {
     const steps = /* @__PURE__ */ new Map();
     let raw = "";
     try {
-      raw = (0, import_node_fs9.readFileSync)(this.filePath, "utf8");
+      raw = (0, import_node_fs10.readFileSync)(this.filePath, "utf8");
     } catch {
       return { runs, steps };
     }
@@ -61166,6 +61577,109 @@ async function runWorkflow(yamlPath, options = {}) {
 
 // packages/sdk/dist/workflows/builder.js
 var import_yaml3 = __toESM(require_dist(), 1);
+
+// packages/sdk/dist/workflows/default-logger.js
+var import_chalk2 = __toESM(require_source(), 1);
+var noop = () => {
+};
+function createDefaultEventLogger(level = "normal") {
+  if (level === false)
+    return noop;
+  return (event) => {
+    switch (event.type) {
+      // ── Run lifecycle ──
+      case "run:started":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.cyan(`[workflow] run ${event.runId.slice(0, 8)}...`));
+        }
+        break;
+      case "run:completed":
+        console.log(import_chalk2.default.green(`[workflow] completed`));
+        break;
+      case "run:failed":
+        console.log(import_chalk2.default.red(`[workflow] FAILED: ${event.error}`));
+        break;
+      case "run:cancelled":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.yellow(`[workflow] cancelled`));
+        }
+        break;
+      // ── Step lifecycle ──
+      case "step:started":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.blue(`  \u25CF ${event.stepName} \u2014 started`));
+        }
+        break;
+      case "step:completed":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.green(`  \u2713 ${event.stepName} \u2014 completed`));
+        }
+        break;
+      case "step:failed":
+        console.log(import_chalk2.default.red(`  \u2717 ${event.stepName} \u2014 FAILED: ${event.error}`));
+        break;
+      case "step:skipped":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.gray(`  \u25CB ${event.stepName} \u2014 skipped`));
+        }
+        break;
+      case "step:retrying":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.yellow(`  \u21BB ${event.stepName} \u2014 retrying (attempt ${event.attempt})`));
+        }
+        break;
+      case "step:nudged":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.yellow(`  \u26A1 ${event.stepName} \u2014 nudged (${event.nudgeCount})`));
+        }
+        break;
+      case "step:agent-report": {
+        if (level !== "quiet") {
+          const r = event.report;
+          const parts = [];
+          if (r.model)
+            parts.push(r.model);
+          if (r.cost != null)
+            parts.push(`$${r.cost.toFixed(2)}`);
+          if (r.tokens)
+            parts.push(`${r.tokens.input}+${r.tokens.output} tokens`);
+          parts.push(`${r.errors.length} errors`);
+          console.log(import_chalk2.default.dim(`  \u{1F4CA} ${event.stepName} \u2014 ${parts.join(" \xB7 ")}`));
+        }
+        break;
+      }
+      // ── Broker-level events (verbose only) ──
+      case "broker:event":
+        if (level === "verbose") {
+          console.log(import_chalk2.default.dim(`  [broker] ${JSON.stringify(event.event)}`));
+        }
+        break;
+      // ── Other events (verbose only) ──
+      case "step:owner-assigned":
+        if (level === "verbose") {
+          console.log(import_chalk2.default.dim(`  ${event.stepName} \u2014 owner: ${event.ownerName}, specialist: ${event.specialistName}`));
+        }
+        break;
+      case "step:review-completed":
+        if (level === "verbose") {
+          console.log(import_chalk2.default.dim(`  ${event.stepName} \u2014 review: ${event.decision} by ${event.reviewerName}`));
+        }
+        break;
+      case "step:owner-timeout":
+        if (level !== "quiet") {
+          console.log(import_chalk2.default.yellow(`  \u23F1 ${event.stepName} \u2014 owner timeout (${event.ownerName})`));
+        }
+        break;
+      case "step:force-released":
+        if (level === "verbose") {
+          console.log(import_chalk2.default.dim(`  ${event.stepName} \u2014 force-released`));
+        }
+        break;
+    }
+  };
+}
+
+// packages/sdk/dist/workflows/builder.js
 var WorkflowBuilder = class {
   _name;
   _description;
@@ -61376,8 +61890,11 @@ var WorkflowBuilder = class {
       config3.swarm.channel = this._channel;
     if (this._idleNudge !== void 0)
       config3.swarm.idleNudge = this._idleNudge;
-    if (this._errorHandling !== void 0)
-      config3.errorHandling = this._errorHandling;
+    config3.errorHandling = this._errorHandling ?? {
+      strategy: "retry",
+      maxRetries: 2,
+      retryDelayMs: 1e4
+    };
     if (this._coordination !== void 0)
       config3.coordination = this._coordination;
     if (this._state !== void 0)
@@ -61403,16 +61920,32 @@ var WorkflowBuilder = class {
       console.log(formatDryRunReport(report));
       return report;
     }
+    const logLevel = options.renderer === "listr" || options.renderer === false ? false : options.logLevel ?? "normal";
+    if (logLevel !== false) {
+      runner.on(createDefaultEventLogger(logLevel));
+    }
     if (options.onEvent) {
       runner.on(options.onEvent);
     }
     const resumeRunId = process.env.RESUME_RUN_ID;
-    if (resumeRunId) {
-      return runner.resume(resumeRunId, options.vars);
-    }
     const startFrom = this._startFrom ?? options.startFrom ?? process.env.START_FROM;
     const previousRunId = this._previousRunId ?? options.previousRunId ?? process.env.PREVIOUS_RUN_ID;
     const executeOptions = startFrom ? { startFrom, previousRunId } : void 0;
+    if (options.renderer === "listr") {
+      const { createWorkflowRenderer: createWorkflowRenderer2 } = await Promise.resolve().then(() => (init_listr_renderer(), listr_renderer_exports));
+      const renderer = createWorkflowRenderer2();
+      runner.on(renderer.onEvent);
+      const runPromise = resumeRunId ? runner.resume(resumeRunId, options.vars) : runner.execute(config3, options.workflow, options.vars, executeOptions);
+      try {
+        const [result] = await Promise.all([runPromise, renderer.start()]);
+        return result;
+      } finally {
+        renderer.unmount();
+      }
+    }
+    if (resumeRunId) {
+      return runner.resume(resumeRunId, options.vars);
+    }
     return runner.execute(config3, options.workflow, options.vars, executeOptions);
   }
 };
@@ -62273,8 +62806,8 @@ var StateStore = class extends import_node_events5.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/templates.js
-var import_node_fs10 = require("node:fs");
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_fs11 = require("node:fs");
+var import_node_path14 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
 var YAML_EXTENSIONS = [".yaml", ".yml"];
@@ -62299,7 +62832,7 @@ var TemplateRegistry = class {
   fetcher;
   constructor(options = {}) {
     this.builtInTemplatesDir = this.resolveBuiltInTemplatesDir(options.builtInTemplatesDir);
-    this.customTemplatesDir = options.customTemplatesDir ? import_node_path13.default.resolve(options.customTemplatesDir) : import_node_path13.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
+    this.customTemplatesDir = options.customTemplatesDir ? import_node_path14.default.resolve(options.customTemplatesDir) : import_node_path14.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
     this.fetcher = options.fetcher ?? fetch;
   }
   listBuiltInTemplates() {
@@ -62373,13 +62906,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_path13.default.isAbsolute(templateName)) {
+    if (templateName.includes("/") || templateName.includes("\\") || templateName.includes("..") || import_node_path14.default.isAbsolute(templateName)) {
       throw new Error(`Invalid template name: "${templateName}" contains path separators or traversal sequences`);
     }
     this.validateRelayConfig(parsed, url3);
-    await import_node_fs10.promises.mkdir(this.customTemplatesDir, { recursive: true });
-    const targetPath = import_node_path13.default.join(this.customTemplatesDir, `${templateName}.yaml`);
-    await import_node_fs10.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
+    await import_node_fs11.promises.mkdir(this.customTemplatesDir, { recursive: true });
+    const targetPath = import_node_path14.default.join(this.customTemplatesDir, `${templateName}.yaml`);
+    await import_node_fs11.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
     return targetPath;
   }
   isTemplateShorthand(input) {
@@ -62400,15 +62933,15 @@ var TemplateRegistry = class {
   }
   resolveBuiltInTemplatesDir(explicitDir) {
     if (explicitDir) {
-      return import_node_path13.default.resolve(explicitDir);
+      return import_node_path14.default.resolve(explicitDir);
     }
-    const currentDir = import_node_path13.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
+    const currentDir = import_node_path14.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
     const candidates = [
-      import_node_path13.default.resolve(currentDir, "builtin-templates"),
-      import_node_path13.default.resolve(currentDir, "../workflows/builtin-templates")
+      import_node_path14.default.resolve(currentDir, "builtin-templates"),
+      import_node_path14.default.resolve(currentDir, "../workflows/builtin-templates")
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs10.existsSync)(candidate)) {
+      if ((0, import_node_fs11.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -62428,9 +62961,9 @@ var TemplateRegistry = class {
   }
   async findTemplatePath(directory, templateName) {
     for (const ext of YAML_EXTENSIONS) {
-      const candidate = import_node_path13.default.join(directory, `${templateName}${ext}`);
+      const candidate = import_node_path14.default.join(directory, `${templateName}${ext}`);
       try {
-        const stat2 = await import_node_fs10.promises.stat(candidate);
+        const stat2 = await import_node_fs11.promises.stat(candidate);
         if (stat2.isFile()) {
           return candidate;
         }
@@ -62440,7 +62973,7 @@ var TemplateRegistry = class {
     return void 0;
   }
   async readTemplateFile(templatePath) {
-    const raw = await import_node_fs10.promises.readFile(templatePath, "utf-8");
+    const raw = await import_node_fs11.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`);
@@ -62633,7 +63166,7 @@ var TemplateRegistry = class {
   }
   async safeReadDir(directory) {
     try {
-      return await import_node_fs10.promises.readdir(directory);
+      return await import_node_fs11.promises.readdir(directory);
     } catch {
       return [];
     }
@@ -62646,209 +63179,8 @@ var TemplateRegistry = class {
   }
 };
 
-// packages/sdk/dist/workflows/listr-renderer.js
-var import_chalk2 = __toESM(require_source(), 1);
-function installOutputFilter() {
-  const orig = console.log.bind(console);
-  console.log = (...args) => {
-    const str = String(args[0] ?? "");
-    if (str.includes("Observer:") || str.includes("agentrelay.dev") || str.includes("Channel: wf-")) {
-      orig(...args);
-      return;
-    }
-    if (/\[broker\]/.test(str) || /\[workflow\s+\d{2}:\d{2}\]/.test(str))
-      return;
-    orig(...args);
-  };
-  return () => {
-    console.log = orig;
-  };
-}
-function createWorkflowRenderer() {
-  const stepHandles = /* @__PURE__ */ new Map();
-  let resolveWorkflow;
-  let rejectWorkflow;
-  const workflowDone = new Promise((resolve3, reject) => {
-    resolveWorkflow = resolve3;
-    rejectWorkflow = reject;
-  });
-  workflowDone.catch(() => {
-  });
-  let setHeader = () => {
-  };
-  let listr = null;
-  const pendingAdds = [];
-  async function ensureListr() {
-    if (listr)
-      return listr;
-    const { Listr: Listr2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-    listr = new Listr2([
-      {
-        title: import_chalk2.default.dim("Workflow starting..."),
-        task: async (_ctx, task) => {
-          setHeader = (text) => {
-            task.title = text;
-          };
-          await workflowDone;
-        }
-      }
-    ], {
-      concurrent: true,
-      renderer: process.stdout.isTTY ? "default" : "verbose",
-      rendererOptions: {
-        collapseErrors: false,
-        showErrorMessage: true
-      }
-    });
-    for (const task of pendingAdds)
-      listr.add(task);
-    pendingAdds.length = 0;
-    return listr;
-  }
-  const addTask = (task) => {
-    if (listr)
-      listr.add(task);
-    else
-      pendingAdds.push(task);
-  };
-  const onEvent = (event) => {
-    switch (event.type) {
-      case "run:started": {
-        setHeader(import_chalk2.default.dim(`[workflow] run ${event.runId.slice(0, 8)}...`));
-        break;
-      }
-      case "step:started": {
-        let resolveStep;
-        let rejectStep;
-        let taskRef = null;
-        let skipped = false;
-        const done = new Promise((resolve3, reject) => {
-          resolveStep = resolve3;
-          rejectStep = reject;
-        });
-        done.catch(() => {
-        });
-        stepHandles.set(event.stepName, {
-          resolve: resolveStep,
-          reject: rejectStep,
-          setOutput: (text) => {
-            if (taskRef)
-              taskRef.output = text;
-          },
-          markSkipped: () => {
-            skipped = true;
-            if (taskRef)
-              taskRef.title = import_chalk2.default.dim(`${event.stepName} (skipped)`);
-          }
-        });
-        addTask({
-          title: import_chalk2.default.white(event.stepName),
-          task: async (_ctx, task) => {
-            taskRef = task;
-            if (skipped)
-              taskRef.title = import_chalk2.default.dim(`${event.stepName} (skipped)`);
-            await done;
-          },
-          rendererOptions: { persistentOutput: true }
-        });
-        break;
-      }
-      case "step:owner-assigned": {
-        const handle = stepHandles.get(event.stepName);
-        if (handle) {
-          handle.setOutput(import_chalk2.default.dim(`> Owner: ${event.ownerName}`) + (event.specialistName ? import_chalk2.default.dim(` \xB7 specialist: ${event.specialistName}`) : ""));
-        }
-        break;
-      }
-      case "step:retrying": {
-        stepHandles.get(event.stepName)?.setOutput(import_chalk2.default.yellow(`Retrying (attempt ${event.attempt})`));
-        break;
-      }
-      case "step:nudged": {
-        stepHandles.get(event.stepName)?.setOutput(import_chalk2.default.dim(`> Nudge #${event.nudgeCount}`));
-        break;
-      }
-      case "step:force-released": {
-        stepHandles.get(event.stepName)?.setOutput(import_chalk2.default.yellow("> Force-released"));
-        break;
-      }
-      case "step:review-completed": {
-        stepHandles.get(event.stepName)?.setOutput(import_chalk2.default.dim(`> Review: ${event.decision} by ${event.reviewerName}`));
-        break;
-      }
-      case "step:owner-timeout": {
-        stepHandles.get(event.stepName)?.setOutput(import_chalk2.default.red(`> Owner ${event.ownerName} timed out`));
-        break;
-      }
-      case "step:agent-report": {
-        const handle = stepHandles.get(event.stepName);
-        if (handle) {
-          const model = event.report.model ? `:${event.report.model}` : "";
-          handle.setOutput(import_chalk2.default.dim(`> Report collected (${event.report.cli}${model})`));
-        }
-        break;
-      }
-      case "step:completed": {
-        stepHandles.get(event.stepName)?.resolve();
-        break;
-      }
-      case "step:skipped": {
-        const handle = stepHandles.get(event.stepName);
-        if (handle) {
-          handle.markSkipped();
-          handle.resolve();
-        } else {
-          addTask({
-            title: import_chalk2.default.dim(`${event.stepName} (skipped)`),
-            task: async () => {
-            },
-            rendererOptions: { persistentOutput: true }
-          });
-        }
-        break;
-      }
-      case "step:failed": {
-        stepHandles.get(event.stepName)?.reject(new Error(event.error ?? "Step failed"));
-        break;
-      }
-      case "run:completed": {
-        setHeader(import_chalk2.default.green("Workflow completed"));
-        resolveWorkflow();
-        break;
-      }
-      case "run:failed": {
-        setHeader(import_chalk2.default.red(`Workflow failed: ${event.error ?? "unknown error"}`));
-        rejectWorkflow(new Error(event.error ?? "Workflow failed"));
-        break;
-      }
-      case "run:cancelled": {
-        setHeader(import_chalk2.default.yellow("Workflow cancelled"));
-        resolveWorkflow();
-        break;
-      }
-      case "broker:event":
-        break;
-      default: {
-        const _exhaustive = event;
-        void _exhaustive;
-      }
-    }
-  };
-  let restoreConsole;
-  return {
-    onEvent,
-    start: async () => {
-      restoreConsole = installOutputFilter();
-      const l = await ensureListr();
-      return l.run().catch(() => {
-      });
-    },
-    unmount: () => {
-      restoreConsole?.();
-      restoreConsole = void 0;
-    }
-  };
-}
+// packages/sdk/dist/workflows/index.js
+init_listr_renderer();
 
 // packages/utils/dist/name-generator.js
 var ADJECTIVES = [
@@ -63001,8 +63333,8 @@ function isValidAgentName(name) {
 }
 
 // packages/utils/dist/logger.js
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
 }
@@ -63020,9 +63352,9 @@ var LEVEL_PRIORITY = {
 };
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
-  const logDir = import_node_path14.default.dirname(logFile);
-  if (!createdLogDirs.has(logDir) && !import_node_fs11.default.existsSync(logDir)) {
-    import_node_fs11.default.mkdirSync(logDir, { recursive: true });
+  const logDir = import_node_path15.default.dirname(logFile);
+  if (!createdLogDirs.has(logDir) && !import_node_fs12.default.existsSync(logDir)) {
+    import_node_fs12.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
   }
 }
@@ -63051,7 +63383,7 @@ function log(level, component, msg, extra) {
   const logFile = getLogFile();
   if (logFile) {
     ensureLogDir(logFile);
-    import_node_fs11.default.appendFileSync(logFile, formatted + "\n");
+    import_node_fs12.default.appendFileSync(logFile, formatted + "\n");
     return;
   }
   if (level === "ERROR" || level === "WARN") {
@@ -63321,14 +63653,14 @@ function benchmarkPatterns(iterations = 1e4) {
 }
 
 // packages/utils/dist/command-resolver.js
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs13 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
   }
   try {
-    const output = (0, import_node_child_process4.execSync)(`which ${command}`, {
+    const output = (0, import_node_child_process5.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       // Ensure we have a reasonable PATH
@@ -63348,7 +63680,7 @@ function resolveCommand(command) {
 }
 function resolveSymlinks(filePath) {
   try {
-    const resolved = import_node_fs12.default.realpathSync(filePath);
+    const resolved = import_node_fs13.default.realpathSync(filePath);
     if (resolved !== filePath && process.env.DEBUG_SPAWN === "1") {
       console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
     }
@@ -63362,7 +63694,7 @@ function resolveSymlinks(filePath) {
 }
 function commandExists(command) {
   try {
-    (0, import_node_child_process4.execSync)(`which ${command}`, {
+    (0, import_node_child_process5.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -63375,7 +63707,7 @@ function commandExists(command) {
 // packages/utils/dist/git-remote.js
 var fs8 = __toESM(require("node:fs"), 1);
 var path14 = __toESM(require("node:path"), 1);
-var import_node_child_process5 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 function parseGitRemoteUrl(url3) {
   if (!url3)
     return null;
@@ -63395,7 +63727,7 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
     if (!fs8.existsSync(gitDir)) {
       return null;
     }
-    const result = (0, import_node_child_process5.execSync)(`git remote get-url ${remoteName}`, {
+    const result = (0, import_node_child_process6.execSync)(`git remote get-url ${remoteName}`, {
       cwd: workingDirectory,
       encoding: "utf-8",
       timeout: 5e3,
@@ -63448,24 +63780,24 @@ function getRepoFullNameFromPath(workingDirectory) {
 }
 
 // packages/utils/dist/update-checker.js
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 var import_node_https = __toESM(require("node:https"), 1);
-var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_os9 = __toESM(require("node:os"), 1);
 var import_compare_versions = __toESM(require_umd(), 1);
 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_path15.default.join(import_node_os8.default.homedir(), ".agent-relay");
-  return import_node_path15.default.join(cacheDir, "update-cache.json");
+  const cacheDir = import_node_path16.default.join(import_node_os9.default.homedir(), ".agent-relay");
+  return import_node_path16.default.join(cacheDir, "update-cache.json");
 }
 function readCache() {
   try {
     const cachePath = getCachePath();
-    if (!import_node_fs13.default.existsSync(cachePath))
+    if (!import_node_fs14.default.existsSync(cachePath))
       return null;
-    const data = import_node_fs13.default.readFileSync(cachePath, "utf-8");
+    const data = import_node_fs14.default.readFileSync(cachePath, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -63474,11 +63806,11 @@ function readCache() {
 function writeCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = import_node_path15.default.dirname(cachePath);
-    if (!import_node_fs13.default.existsSync(cacheDir)) {
-      import_node_fs13.default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = import_node_path16.default.dirname(cachePath);
+    if (!import_node_fs14.default.existsSync(cacheDir)) {
+      import_node_fs14.default.mkdirSync(cacheDir, { recursive: true });
     }
-    import_node_fs13.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+    import_node_fs14.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
   } catch {
   }
 }
@@ -63757,9 +64089,9 @@ function validateModelForCli(cli, model) {
 }
 
 // packages/utils/dist/relay-pty-path.js
-var import_node_fs14 = __toESM(require("node:fs"), 1);
-var import_node_os9 = __toESM(require("node:os"), 1);
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_fs15 = __toESM(require("node:fs"), 1);
+var import_node_os10 = __toESM(require("node:os"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
   darwin: {
     arm64: "relay-pty-darwin-arm64",
@@ -63771,13 +64103,13 @@ var SUPPORTED_PLATFORMS = {
   }
 };
 function getPlatformBinaryName() {
-  const platform2 = import_node_os9.default.platform();
-  const arch = import_node_os9.default.arch();
+  const platform2 = import_node_os10.default.platform();
+  const arch = import_node_os10.default.arch();
   return SUPPORTED_PLATFORMS[platform2]?.[arch] ?? null;
 }
 function isPlatformSupported() {
-  const platform2 = import_node_os9.default.platform();
-  const arch = import_node_os9.default.arch();
+  const platform2 = import_node_os10.default.platform();
+  const arch = import_node_os10.default.arch();
   return SUPPORTED_PLATFORMS[platform2]?.[arch] !== void 0;
 }
 function getSupportedPlatforms() {
@@ -63807,23 +64139,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_path16.default.join(scopedMatch[1], "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(scopedMatch[1], "agent-relay"));
   }
   if (directMatch) {
     packageRoots.push(directMatch[1]);
   }
   if (!normalizedCaller.includes("node_modules")) {
-    packageRoots.push(import_node_path16.default.join(callerDirname, "..", "..", ".."));
+    packageRoots.push(import_node_path17.default.join(callerDirname, "..", "..", ".."));
   }
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
-    const npxCacheBase = import_node_path16.default.join(home, ".npm", "_npx");
-    if (import_node_fs14.default.existsSync(npxCacheBase)) {
+    const npxCacheBase = import_node_path17.default.join(home, ".npm", "_npx");
+    if (import_node_fs15.default.existsSync(npxCacheBase)) {
       try {
-        const entries = import_node_fs14.default.readdirSync(npxCacheBase);
+        const entries = import_node_fs15.default.readdirSync(npxCacheBase);
         for (const entry of entries) {
-          const npxPackage = import_node_path16.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
-          if (import_node_fs14.default.existsSync(npxPackage)) {
+          const npxPackage = import_node_path17.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
+          if (import_node_fs15.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
         }
@@ -63831,42 +64163,42 @@ function findRelayPtyBinary(callerDirname) {
       }
     }
   }
-  packageRoots.push(import_node_path16.default.join(process.cwd(), "node_modules", "agent-relay"));
+  packageRoots.push(import_node_path17.default.join(process.cwd(), "node_modules", "agent-relay"));
   if (home) {
-    packageRoots.push(import_node_path16.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, "n", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path16.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
-  }
-  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path16.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path16.default.join(home, ".agent-relay", "bin") : null;
-  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path16.default.join(home, ".local", "bin") : null);
-  const nodePrefix = import_node_path16.default.resolve(import_node_path16.default.dirname(process.execPath), "..");
-  packageRoots.push(import_node_path16.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, "n", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path17.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
+  }
+  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path17.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path17.default.join(home, ".agent-relay", "bin") : null;
+  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path17.default.join(home, ".local", "bin") : null);
+  const nodePrefix = import_node_path17.default.resolve(import_node_path17.default.dirname(process.execPath), "..");
+  packageRoots.push(import_node_path17.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_path16.default.join(root, "bin", platformBinary));
+      candidates.push(import_node_path17.default.join(root, "bin", platformBinary));
     }
-    candidates.push(import_node_path16.default.join(root, "bin", "relay-pty"));
+    candidates.push(import_node_path17.default.join(root, "bin", "relay-pty"));
   }
   if (bashInstallerDir) {
     if (platformBinary) {
-      candidates.push(import_node_path16.default.join(bashInstallerDir, platformBinary));
+      candidates.push(import_node_path17.default.join(bashInstallerDir, platformBinary));
     }
-    candidates.push(import_node_path16.default.join(bashInstallerDir, "relay-pty"));
+    candidates.push(import_node_path17.default.join(bashInstallerDir, "relay-pty"));
   }
   if (bashInstallerBinDir) {
     if (platformBinary) {
-      candidates.push(import_node_path16.default.join(bashInstallerBinDir, platformBinary));
+      candidates.push(import_node_path17.default.join(bashInstallerBinDir, platformBinary));
     }
-    candidates.push(import_node_path16.default.join(bashInstallerBinDir, "relay-pty"));
+    candidates.push(import_node_path17.default.join(bashInstallerBinDir, "relay-pty"));
   }
   candidates.push("/app/bin/relay-pty");
   candidates.push("/usr/local/bin/relay-pty");
@@ -63881,7 +64213,7 @@ function findRelayPtyBinary(callerDirname) {
 }
 function isExecutable(filePath) {
   try {
-    import_node_fs14.default.accessSync(filePath, import_node_fs14.default.constants.X_OK);
+    import_node_fs15.default.accessSync(filePath, import_node_fs15.default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -63890,14 +64222,14 @@ function isExecutable(filePath) {
 function isPlatformCompatibleBinary(filePath) {
   let fd;
   try {
-    fd = import_node_fs14.default.openSync(filePath, "r");
+    fd = import_node_fs15.default.openSync(filePath, "r");
     const header = Buffer.alloc(4);
-    const bytesRead = import_node_fs14.default.readSync(fd, header, 0, 4, 0);
+    const bytesRead = import_node_fs15.default.readSync(fd, header, 0, 4, 0);
     if (bytesRead < 4) {
       return false;
     }
     const magic = header.readUInt32BE(0);
-    const platform2 = import_node_os9.default.platform();
+    const platform2 = import_node_os10.default.platform();
     if (platform2 === "darwin") {
       return isMachOBinary(magic);
     }
@@ -63910,7 +64242,7 @@ function isPlatformCompatibleBinary(filePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        import_node_fs14.default.closeSync(fd);
+        import_node_fs15.default.closeSync(fd);
       } catch {
       }
     }
@@ -64526,78 +64858,78 @@ var HookRegistry = class {
 };
 
 // packages/trajectory/dist/integration.js
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process7 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
 var import_node_crypto13 = __toESM(require("node:crypto"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
-var import_node_fs15 = __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_fs16 = __toESM(require("node:fs"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
 function getGlobalBaseDir2() {
   if (process.env.AGENT_RELAY_DATA_DIR) {
     return process.env.AGENT_RELAY_DATA_DIR;
   }
   const xdgDataHome = process.env.XDG_DATA_HOME;
   if (xdgDataHome) {
-    return import_node_path17.default.join(xdgDataHome, "agent-relay");
+    return import_node_path18.default.join(xdgDataHome, "agent-relay");
   }
-  return import_node_path17.default.join(import_node_os10.default.homedir(), ".agent-relay");
+  return import_node_path18.default.join(import_node_os11.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
 var PROJECT_DATA_DIR2 = ".agent-relay";
 function hashPath2(projectPath) {
-  const normalized = import_node_path17.default.resolve(projectPath);
+  const normalized = import_node_path18.default.resolve(projectPath);
   const hash3 = import_node_crypto13.default.createHash("sha256").update(normalized).digest("hex");
   return hash3.substring(0, 12);
 }
 function findProjectRoot2(startDir = process.cwd()) {
   if (process.env.AGENT_RELAY_PROJECT) {
-    return import_node_path17.default.resolve(process.env.AGENT_RELAY_PROJECT);
+    return import_node_path18.default.resolve(process.env.AGENT_RELAY_PROJECT);
   }
-  let current = import_node_path17.default.resolve(startDir);
-  const root = import_node_path17.default.parse(current).root;
+  let current = import_node_path18.default.resolve(startDir);
+  const root = import_node_path18.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_fs15.default.existsSync(import_node_path17.default.join(current, marker))) {
+      if (import_node_fs16.default.existsSync(import_node_path18.default.join(current, marker))) {
         return current;
       }
     }
-    current = import_node_path17.default.dirname(current);
+    current = import_node_path18.default.dirname(current);
   }
-  return import_node_path17.default.resolve(startDir);
+  return import_node_path18.default.resolve(startDir);
 }
 function getProjectPaths2(projectRoot) {
   const root = projectRoot ?? findProjectRoot2();
   const projectId = hashPath2(root);
-  const dataDir = import_node_path17.default.join(root, PROJECT_DATA_DIR2);
+  const dataDir = import_node_path18.default.join(root, PROJECT_DATA_DIR2);
   return {
     dataDir,
-    teamDir: import_node_path17.default.join(dataDir, "team"),
-    dbPath: import_node_path17.default.join(dataDir, "messages.sqlite"),
-    socketPath: import_node_path17.default.join(dataDir, "relay.sock"),
+    teamDir: import_node_path18.default.join(dataDir, "team"),
+    dbPath: import_node_path18.default.join(dataDir, "messages.sqlite"),
+    socketPath: import_node_path18.default.join(dataDir, "relay.sock"),
     projectRoot: root,
     projectId
   };
 }
 
 // packages/config/dist/trajectory-config.js
-var import_node_fs16 = require("node:fs");
-var import_node_path18 = require("node:path");
-var import_node_os11 = require("node:os");
+var import_node_fs17 = require("node:fs");
+var import_node_path19 = 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_path18.join)((0, import_node_os11.homedir)(), ".config", "agent-relay");
+  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path19.join)((0, import_node_os12.homedir)(), ".config", "agent-relay");
 }
 var configCache = null;
 function getRelayConfigPath(_projectRoot) {
-  return (0, import_node_path18.join)(getAgentRelayConfigDir(), "relay.json");
+  return (0, import_node_path19.join)(getAgentRelayConfigDir(), "relay.json");
 }
 function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
   if (configCache && configCache.path === configPath) {
     try {
-      const stat2 = (0, import_node_fs16.statSync)(configPath);
+      const stat2 = (0, import_node_fs17.statSync)(configPath);
       if (stat2.mtimeMs === configCache.mtime) {
         return configCache.config;
       }
@@ -64605,13 +64937,13 @@ function readRelayConfig(projectRoot) {
     }
   }
   try {
-    if (!(0, import_node_fs16.existsSync)(configPath)) {
+    if (!(0, import_node_fs17.existsSync)(configPath)) {
       return {};
     }
-    const content = (0, import_node_fs16.readFileSync)(configPath, "utf-8");
+    const content = (0, import_node_fs17.readFileSync)(configPath, "utf-8");
     const config3 = JSON.parse(content);
     try {
-      const stat2 = (0, import_node_fs16.statSync)(configPath);
+      const stat2 = (0, import_node_fs17.statSync)(configPath);
       configCache = { path: configPath, config: config3, mtime: stat2.mtimeMs };
     } catch {
     }
@@ -64631,12 +64963,12 @@ function getProjectHash(projectRoot) {
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
-  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path18.join)((0, import_node_os11.homedir)(), ".config");
-  return (0, import_node_path18.join)(configDir, "agent-relay", "trajectories", projectHash);
+  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path19.join)((0, import_node_os12.homedir)(), ".config");
+  return (0, import_node_path19.join)(configDir, "agent-relay", "trajectories", projectHash);
 }
 function getRepoTrajectoriesDir(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_path18.join)(root, ".trajectories");
+  return (0, import_node_path19.join)(root, ".trajectories");
 }
 function getPrimaryTrajectoriesDir(projectRoot) {
   if (shouldStoreInRepo(projectRoot)) {
@@ -64655,7 +64987,7 @@ function getTrajectoryEnvVars(projectRoot) {
 async function runTrail(args) {
   return new Promise((resolve3) => {
     const trajectoryEnv = getTrajectoryEnvVars();
-    const proc = (0, import_node_child_process6.spawn)("trail", args, {
+    const proc = (0, import_node_child_process7.spawn)("trail", args, {
       cwd: getProjectPaths2().projectRoot,
       env: { ...process.env, ...trajectoryEnv },
       stdio: ["pipe", "pipe", "pipe"]
@@ -64926,7 +65258,7 @@ var TrajectoryIntegration = class {
    */
   isTrailInstalledSync() {
     try {
-      (0, import_node_child_process6.execSync)("which trail", { stdio: "pipe" });
+      (0, import_node_child_process7.execSync)("which trail", { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -65276,8 +65608,8 @@ var HookEmitter = class {
 };
 
 // packages/hooks/dist/inbox-check/utils.js
-var import_node_fs17 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path20 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
   return process.env.AGENT_RELAY_NAME;
@@ -65287,16 +65619,16 @@ function getInboxPath(config3) {
   if (!agentName) {
     throw new Error("Agent name not configured. Set AGENT_RELAY_NAME env var.");
   }
-  return (0, import_node_path19.join)(config3.inboxDir, agentName, "inbox.md");
+  return (0, import_node_path20.join)(config3.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
-  return (0, import_node_fs17.existsSync)(inboxPath);
+  return (0, import_node_fs18.existsSync)(inboxPath);
 }
 function readInbox(inboxPath) {
   if (!inboxExists(inboxPath)) {
     return "";
   }
-  return (0, import_node_fs17.readFileSync)(inboxPath, "utf-8");
+  return (0, import_node_fs18.readFileSync)(inboxPath, "utf-8");
 }
 function hasUnreadMessages(inboxPath) {
   const content = readInbox(inboxPath);
@@ -65366,6 +65698,7 @@ init_dist2();
   CLIVersions,
   CLIs,
   CODEX_MODEL_OPTIONS,
+  COMMON_SEARCH_PATHS,
   CURSOR_MODEL_OPTIONS,
   CUSTOM_STEPS_FILE,
   ClaudeModels,
@@ -65414,6 +65747,7 @@ init_dist2();
   checkForUpdatesInBackground,
   cleanLines,
   clearBinaryCache,
+  clearResolveCache,
   collectCliSession,
   commandExists,
   connectionLog,
@@ -65421,6 +65755,7 @@ init_dist2();
   createCollector,
   createConsensusEngine,
   createContextCompactor,
+  createDefaultEventLogger,
   createLogger,
   createMemoryAdapter,
   createMemoryHooks,
@@ -65448,6 +65783,8 @@ init_dist2();
   getAgentName,
   getBaseCli,
   getCachedRelayPtyPath,
+  getCliDefinition,
+  getCliRegistry,
   getCompiledPatterns,
   getCustomStepsPath,
   getDefaultReasoningEffort,
@@ -65495,6 +65832,8 @@ init_dist2();
   readInbox,
   resetPatternMetrics,
   resolveAllCustomSteps,
+  resolveCli,
+  resolveCliSync,
   resolveCommand,
   resolveCustomStep,
   resolveSpawnPolicy,