agent-relay 3.2.1 → 3.2.3

package/dist/index.cjs

@@ -35,13 +35,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/config/src/bridge-utils.ts
-var import_node_child_process2, import_node_util, execAsync;
+var import_node_child_process, import_node_util, execAsync;
 var init_bridge_utils = __esm({
   "packages/config/src/bridge-utils.ts"() {
     "use strict";
-    import_node_child_process2 = require("node:child_process");
+    import_node_child_process = require("node:child_process");
     import_node_util = require("node:util");
-    execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
+    execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
   }
 });
 
@@ -6885,14 +6885,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs9 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map2.items.push({ start, key: fs9, sep: [] });
+                map2.items.push({ start, key: fs10, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs9);
+                this.stack.push(fs10);
               } else {
-                Object.assign(it, { key: fs9, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7020,13 +7020,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs9 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs9, sep: [] });
+                fc.items.push({ start: [], key: fs10, sep: [] });
               else if (it.sep)
-                this.stack.push(fs9);
+                this.stack.push(fs10);
               else
-                Object.assign(it, { key: fs9, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7467,11 +7467,11 @@ var init_types = __esm({
 });
 
 // packages/memory/dist/adapters/inmemory.js
-var import_node_crypto10, InMemoryAdapter;
+var import_node_crypto11, InMemoryAdapter;
 var init_inmemory = __esm({
   "packages/memory/dist/adapters/inmemory.js"() {
     "use strict";
-    import_node_crypto10 = require("node:crypto");
+    import_node_crypto11 = require("node:crypto");
     InMemoryAdapter = class {
       type = "inmemory";
       memories = /* @__PURE__ */ new Map();
@@ -7486,7 +7486,7 @@ var init_inmemory = __esm({
       async init() {
       }
       async add(content, options) {
-        const id = (0, import_node_crypto10.randomUUID)();
+        const id = (0, import_node_crypto11.randomUUID)();
         const now = Date.now();
         const entry = {
           id,
@@ -8825,6 +8825,7 @@ __export(index_exports, {
   HOOK_ABI_VERSION: () => HOOK_ABI_VERSION,
   HookEmitter: () => HookEmitter,
   HookRegistry: () => HookRegistry,
+  HttpAgentRelayClient: () => HttpAgentRelayClient,
   InMemoryAdapter: () => InMemoryAdapter,
   InMemoryWorkflowDb: () => InMemoryWorkflowDb,
   JsonFileWorkflowDb: () => JsonFileWorkflowDb,
@@ -8951,623 +8952,12 @@ var PROTOCOL_VERSION = 1;
 
 // packages/sdk/dist/client.js
 var import_node_events = require("node:events");
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var import_node_readline = require("node:readline");
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
-var AgentRelayProtocolError = class extends Error {
-  code;
-  retryable;
-  data;
-  constructor(payload) {
-    super(payload.message);
-    this.name = "AgentRelayProtocolError";
-    this.code = payload.code;
-    this.retryable = payload.retryable;
-    this.data = payload.data;
-  }
-};
-var AgentRelayProcessError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AgentRelayProcessError";
-  }
-};
-function isHeadlessProvider(value) {
-  return value === "claude" || value === "opencode";
-}
-var AgentRelayClient = class _AgentRelayClient {
-  options;
-  child;
-  stdoutRl;
-  stderrRl;
-  lastStderrLine;
-  requestSeq = 0;
-  pending = /* @__PURE__ */ new Map();
-  startingPromise;
-  eventListeners = /* @__PURE__ */ new Set();
-  stderrListeners = /* @__PURE__ */ new Set();
-  eventBuffer = [];
-  maxBufferSize = 1e3;
-  exitPromise;
-  /** The workspace key returned by the broker in its hello_ack response. */
-  workspaceKey;
-  constructor(options = {}) {
-    this.options = {
-      binaryPath: options.binaryPath ?? resolveDefaultBinaryPath(),
-      binaryArgs: options.binaryArgs ?? [],
-      brokerName: options.brokerName ?? (import_node_path.default.basename(options.cwd ?? process.cwd()) || "project"),
-      channels: options.channels ?? ["general"],
-      cwd: options.cwd ?? process.cwd(),
-      env: options.env ?? process.env,
-      requestTimeoutMs: options.requestTimeoutMs ?? 1e4,
-      shutdownTimeoutMs: options.shutdownTimeoutMs ?? 3e3,
-      clientName: options.clientName ?? "@agent-relay/sdk",
-      clientVersion: options.clientVersion ?? "0.1.0"
-    };
-  }
-  static async start(options = {}) {
-    const client = new _AgentRelayClient(options);
-    await client.start();
-    return client;
-  }
-  onEvent(listener) {
-    this.eventListeners.add(listener);
-    return () => {
-      this.eventListeners.delete(listener);
-    };
-  }
-  queryEvents(filter) {
-    let events = [...this.eventBuffer];
-    if (filter?.kind) {
-      events = events.filter((event) => event.kind === filter.kind);
-    }
-    if (filter?.name) {
-      events = events.filter((event) => "name" in event && event.name === filter.name);
-    }
-    const since = filter?.since;
-    if (since !== void 0) {
-      events = events.filter((event) => "timestamp" in event && typeof event.timestamp === "number" && event.timestamp >= since);
-    }
-    const limit = filter?.limit;
-    if (limit !== void 0) {
-      events = events.slice(-limit);
-    }
-    return events;
-  }
-  getLastEvent(kind, name) {
-    for (let i = this.eventBuffer.length - 1; i >= 0; i -= 1) {
-      const event = this.eventBuffer[i];
-      if (event.kind === kind && (!name || "name" in event && event.name === name)) {
-        return event;
-      }
-    }
-    return void 0;
-  }
-  onBrokerStderr(listener) {
-    this.stderrListeners.add(listener);
-    return () => {
-      this.stderrListeners.delete(listener);
-    };
-  }
-  get brokerPid() {
-    return this.child?.pid;
-  }
-  async start() {
-    if (this.child) {
-      return;
-    }
-    if (this.startingPromise) {
-      return this.startingPromise;
-    }
-    this.startingPromise = this.startInternal();
-    try {
-      await this.startingPromise;
-    } finally {
-      this.startingPromise = void 0;
-    }
-  }
-  /**
-   * Pre-register a batch of agents with Relaycast before their steps execute.
-   * The broker warms its token cache in parallel; subsequent spawn_agent calls
-   * hit the cache rather than waiting on individual HTTP registrations.
-   * Fire-and-forget from the caller's perspective — broker responds immediately
-   * and registers in the background.
-   */
-  async preflightAgents(agents) {
-    if (agents.length === 0)
-      return;
-    await this.start();
-    await this.requestOk("preflight_agents", { agents });
-  }
-  async spawnPty(input) {
-    await this.start();
-    const args = buildPtyArgsWithModel(input.cli, input.args ?? [], input.model);
-    const agent = {
-      name: input.name,
-      runtime: "pty",
-      cli: input.cli,
-      args,
-      channels: input.channels ?? [],
-      model: input.model,
-      cwd: input.cwd ?? this.options.cwd,
-      team: input.team,
-      shadow_of: input.shadowOf,
-      shadow_mode: input.shadowMode,
-      restart_policy: input.restartPolicy
-    };
-    const result = await this.requestOk("spawn_agent", {
-      agent,
-      ...input.task != null ? { initial_task: input.task } : {},
-      ...input.idleThresholdSecs != null ? { idle_threshold_secs: input.idleThresholdSecs } : {},
-      ...input.continueFrom != null ? { continue_from: input.continueFrom } : {},
-      ...input.skipRelayPrompt != null ? { skip_relay_prompt: input.skipRelayPrompt } : {}
-    });
-    return result;
-  }
-  async spawnHeadless(input) {
-    await this.start();
-    const agent = {
-      name: input.name,
-      runtime: "headless",
-      provider: input.provider,
-      args: input.args ?? [],
-      channels: input.channels ?? []
-    };
-    const result = await this.requestOk("spawn_agent", {
-      agent,
-      ...input.task != null ? { initial_task: input.task } : {},
-      ...input.skipRelayPrompt != null ? { skip_relay_prompt: input.skipRelayPrompt } : {}
-    });
-    return result;
-  }
-  async spawnProvider(input) {
-    const transport = input.transport ?? (input.provider === "opencode" ? "headless" : "pty");
-    if (transport === "headless") {
-      if (!isHeadlessProvider(input.provider)) {
-        throw new AgentRelayProcessError(`provider '${input.provider}' does not support headless transport (supported: claude, opencode)`);
-      }
-      return this.spawnHeadless({
-        name: input.name,
-        provider: input.provider,
-        args: input.args,
-        channels: input.channels,
-        task: input.task,
-        skipRelayPrompt: input.skipRelayPrompt
-      });
-    }
-    return this.spawnPty({
-      name: input.name,
-      cli: input.provider,
-      args: input.args,
-      channels: input.channels,
-      task: input.task,
-      model: input.model,
-      cwd: input.cwd,
-      team: input.team,
-      shadowOf: input.shadowOf,
-      shadowMode: input.shadowMode,
-      idleThresholdSecs: input.idleThresholdSecs,
-      restartPolicy: input.restartPolicy,
-      continueFrom: input.continueFrom,
-      skipRelayPrompt: input.skipRelayPrompt
-    });
-  }
-  async spawnClaude(input) {
-    return this.spawnProvider({ ...input, provider: "claude" });
-  }
-  async spawnOpencode(input) {
-    return this.spawnProvider({ ...input, provider: "opencode" });
-  }
-  async release(name, reason) {
-    await this.start();
-    return this.requestOk("release_agent", { name, reason });
-  }
-  async sendInput(name, data) {
-    await this.start();
-    return this.requestOk("send_input", { name, data });
-  }
-  async setModel(name, model, opts) {
-    await this.start();
-    return this.requestOk("set_model", {
-      name,
-      model,
-      timeout_ms: opts?.timeoutMs
-    });
-  }
-  async getMetrics(agent) {
-    await this.start();
-    return this.requestOk("get_metrics", { agent });
-  }
-  async getCrashInsights() {
-    await this.start();
-    return this.requestOk("get_crash_insights", {});
-  }
-  async sendMessage(input) {
-    await this.start();
-    try {
-      return await this.requestOk("send_message", {
-        to: input.to,
-        text: input.text,
-        from: input.from,
-        thread_id: input.threadId,
-        workspace_id: input.workspaceId,
-        workspace_alias: input.workspaceAlias,
-        priority: input.priority,
-        data: input.data
-      });
-    } catch (error48) {
-      if (error48 instanceof AgentRelayProtocolError && error48.code === "unsupported_operation") {
-        return { event_id: "unsupported_operation", targets: [] };
-      }
-      throw error48;
-    }
-  }
-  async listAgents() {
-    await this.start();
-    const result = await this.requestOk("list_agents", {});
-    return result.agents;
-  }
-  async getStatus() {
-    await this.start();
-    return this.requestOk("get_status", {});
-  }
-  async shutdown() {
-    if (!this.child) {
-      return;
-    }
-    void this.requestOk("shutdown", {}).catch(() => {
-    });
-    const child = this.child;
-    const wait = this.exitPromise ?? Promise.resolve();
-    const waitForExit = async (timeoutMs) => {
-      let timer;
-      const result = await Promise.race([
-        wait.then(() => true),
-        new Promise((resolve3) => {
-          timer = setTimeout(() => resolve3(false), timeoutMs);
-        })
-      ]);
-      if (timer !== void 0)
-        clearTimeout(timer);
-      return result;
-    };
-    if (await waitForExit(this.options.shutdownTimeoutMs)) {
-      return;
-    }
-    if (child.exitCode === null && child.signalCode === null) {
-      child.kill("SIGTERM");
-    }
-    if (await waitForExit(1e3)) {
-      return;
-    }
-    if (child.exitCode === null && child.signalCode === null) {
-      child.kill("SIGKILL");
-    }
-    await waitForExit(1e3);
-  }
-  async waitForExit() {
-    if (!this.child) {
-      return;
-    }
-    await this.exitPromise;
-  }
-  async startInternal() {
-    const resolvedBinary = expandTilde(this.options.binaryPath);
-    if (isExplicitPath(this.options.binaryPath) && !import_node_fs.default.existsSync(resolvedBinary)) {
-      throw new AgentRelayProcessError(`broker binary not found: ${this.options.binaryPath}`);
-    }
-    this.lastStderrLine = void 0;
-    const args = [
-      "init",
-      "--name",
-      this.options.brokerName,
-      ...this.options.channels.length > 0 ? ["--channels", this.options.channels.join(",")] : [],
-      ...this.options.binaryArgs
-    ];
-    const env = { ...this.options.env };
-    if (isExplicitPath(this.options.binaryPath)) {
-      const binDir = import_node_path.default.dirname(import_node_path.default.resolve(resolvedBinary));
-      const currentPath = env.PATH ?? env.Path ?? "";
-      if (!currentPath.split(import_node_path.default.delimiter).includes(binDir)) {
-        env.PATH = `${binDir}${import_node_path.default.delimiter}${currentPath}`;
-      }
-    }
-    console.error(`[broker] Starting: ${resolvedBinary} ${args.join(" ")}`);
-    const child = (0, import_node_child_process.spawn)(resolvedBinary, args, {
-      cwd: this.options.cwd,
-      env,
-      stdio: "pipe"
-    });
-    this.child = child;
-    this.stdoutRl = (0, import_node_readline.createInterface)({ input: child.stdout, crlfDelay: Infinity });
-    this.stderrRl = (0, import_node_readline.createInterface)({ input: child.stderr, crlfDelay: Infinity });
-    this.stdoutRl.on("line", (line) => {
-      this.handleStdoutLine(line);
-    });
-    this.stderrRl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (trimmed) {
-        this.lastStderrLine = trimmed;
-      }
-      for (const listener of this.stderrListeners) {
-        listener(line);
-      }
-    });
-    this.exitPromise = new Promise((resolve3) => {
-      child.once("close", (code, signal) => {
-        const detail = this.lastStderrLine ? `: ${this.lastStderrLine}` : "";
-        const error48 = new AgentRelayProcessError(`broker exited (code=${code ?? "null"}, signal=${signal ?? "null"})${detail}`);
-        this.failAllPending(error48);
-        this.disposeProcessHandles();
-        resolve3();
-      });
-      child.once("error", (error48) => {
-        this.failAllPending(error48);
-        this.disposeProcessHandles();
-        resolve3();
-      });
-    });
-    const helloAck = await this.requestHello();
-    console.error("[broker] Broker ready (hello handshake complete)");
-    if (helloAck.workspace_key) {
-      this.workspaceKey = helloAck.workspace_key;
-    }
-  }
-  disposeProcessHandles() {
-    this.stdoutRl?.close();
-    this.stderrRl?.close();
-    this.stdoutRl = void 0;
-    this.stderrRl = void 0;
-    this.lastStderrLine = void 0;
-    this.child = void 0;
-    this.exitPromise = void 0;
-  }
-  failAllPending(error48) {
-    for (const pending of this.pending.values()) {
-      clearTimeout(pending.timeout);
-      pending.reject(error48);
-    }
-    this.pending.clear();
-  }
-  handleStdoutLine(line) {
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      return;
-    }
-    if (!parsed || typeof parsed !== "object") {
-      return;
-    }
-    if (parsed.v !== PROTOCOL_VERSION || typeof parsed.type !== "string") {
-      return;
-    }
-    const envelope = {
-      v: parsed.v,
-      type: parsed.type,
-      request_id: parsed.request_id,
-      payload: parsed.payload
-    };
-    if (envelope.type === "event") {
-      const payload = envelope.payload;
-      this.eventBuffer.push(payload);
-      if (this.eventBuffer.length > this.maxBufferSize) {
-        this.eventBuffer.shift();
-      }
-      for (const listener of this.eventListeners) {
-        listener(payload);
-      }
-      return;
-    }
-    if (!envelope.request_id) {
-      return;
-    }
-    const pending = this.pending.get(envelope.request_id);
-    if (!pending) {
-      return;
-    }
-    if (envelope.type === "error") {
-      clearTimeout(pending.timeout);
-      this.pending.delete(envelope.request_id);
-      pending.reject(new AgentRelayProtocolError(envelope.payload));
-      return;
-    }
-    if (envelope.type !== pending.expectedType) {
-      clearTimeout(pending.timeout);
-      this.pending.delete(envelope.request_id);
-      pending.reject(new AgentRelayProcessError(`unexpected response type '${envelope.type}' for request '${envelope.request_id}' (expected '${pending.expectedType}')`));
-      return;
-    }
-    clearTimeout(pending.timeout);
-    this.pending.delete(envelope.request_id);
-    pending.resolve(envelope);
-  }
-  async requestHello() {
-    const payload = {
-      client_name: this.options.clientName,
-      client_version: this.options.clientVersion
-    };
-    const frame = await this.sendRequest("hello", payload, "hello_ack");
-    return frame.payload;
-  }
-  async requestOk(type, payload) {
-    const frame = await this.sendRequest(type, payload, "ok");
-    const result = frame.payload;
-    return result.result;
-  }
-  async sendRequest(type, payload, expectedType) {
-    if (!this.child) {
-      throw new AgentRelayProcessError("broker is not running");
-    }
-    const requestId = `req_${++this.requestSeq}`;
-    const message = {
-      v: PROTOCOL_VERSION,
-      type,
-      request_id: requestId,
-      payload
-    };
-    const responsePromise = new Promise((resolve3, reject) => {
-      const timeout = setTimeout(() => {
-        this.pending.delete(requestId);
-        reject(new AgentRelayProcessError(`request timed out after ${this.options.requestTimeoutMs}ms (type='${type}', request_id='${requestId}')`));
-      }, this.options.requestTimeoutMs);
-      this.pending.set(requestId, {
-        expectedType,
-        resolve: resolve3,
-        reject,
-        timeout
-      });
-    });
-    const line = `${JSON.stringify(message)}
-`;
-    if (!this.child.stdin.write(line)) {
-      await (0, import_node_events.once)(this.child.stdin, "drain");
-    }
-    return responsePromise;
-  }
-};
-var CLI_MODEL_FLAG_CLIS = /* @__PURE__ */ new Set(["claude", "codex", "gemini", "goose", "aider"]);
-var CLI_DEFAULT_ARGS = {
-  codex: ["-c", "check_for_update_on_startup=false"]
-};
-function buildPtyArgsWithModel(cli, args, model) {
-  const cliName = cli.split(":")[0].trim().toLowerCase();
-  const defaultArgs = CLI_DEFAULT_ARGS[cliName] ?? [];
-  const baseArgs = [...defaultArgs, ...args];
-  if (!model) {
-    return baseArgs;
-  }
-  if (!CLI_MODEL_FLAG_CLIS.has(cliName)) {
-    return baseArgs;
-  }
-  if (hasModelArg(baseArgs)) {
-    return baseArgs;
-  }
-  return ["--model", model, ...baseArgs];
-}
-function hasModelArg(args) {
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--model") {
-      return true;
-    }
-    if (arg.startsWith("--model=")) {
-      return true;
-    }
-  }
-  return false;
-}
-function expandTilde(p) {
-  if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-    const home = import_node_os.default.homedir();
-    return import_node_path.default.join(home, p.slice(2));
-  }
-  return p;
-}
-function isExplicitPath(binaryPath) {
-  return binaryPath.includes("/") || binaryPath.includes("\\") || binaryPath.startsWith(".") || binaryPath.startsWith("~");
-}
-function detectPlatformSuffix() {
-  const platformMap = {
-    darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
-    linux: { arm64: "linux-arm64", x64: "linux-x64" },
-    win32: { x64: "win32-x64" }
-  };
-  return platformMap[process.platform]?.[process.arch] ?? null;
-}
-function getLatestVersionSync() {
-  try {
-    const result = (0, import_node_child_process.execSync)("curl -fsSL https://api.github.com/repos/AgentWorkforce/relay/releases/latest", {
-      timeout: 15e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).toString();
-    const match = result.match(/"tag_name"\s*:\s*"([^"]+)"/);
-    if (!match?.[1])
-      return null;
-    return match[1].replace(/^openclaw-/, "").replace(/^v/, "");
-  } catch {
-    return null;
-  }
-}
-function installBrokerBinary() {
-  const suffix = detectPlatformSuffix();
-  if (!suffix) {
-    throw new AgentRelayProcessError(`Unsupported platform: ${process.platform}-${process.arch}`);
-  }
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const installDir = import_node_path.default.join(homeDir, ".agent-relay", "bin");
-  const brokerExe = process.platform === "win32" ? "agent-relay-broker.exe" : "agent-relay-broker";
-  const targetPath = import_node_path.default.join(installDir, brokerExe);
-  console.log(`[agent-relay] Broker binary not found, installing for ${suffix}...`);
-  const version2 = getLatestVersionSync();
-  if (!version2) {
-    throw new AgentRelayProcessError("Failed to fetch latest agent-relay version from GitHub.\nInstall manually: curl -fsSL https://raw.githubusercontent.com/AgentWorkforce/relay/main/install.sh | bash");
-  }
-  const binaryName = `agent-relay-broker-${suffix}`;
-  const downloadUrl = `https://github.com/AgentWorkforce/relay/releases/download/v${version2}/${binaryName}`;
-  console.log(`[agent-relay] Downloading v${version2} from ${downloadUrl}`);
-  try {
-    import_node_fs.default.mkdirSync(installDir, { recursive: true });
-    (0, import_node_child_process.execSync)(`curl -fsSL "${downloadUrl}" -o "${targetPath}"`, {
-      timeout: 6e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    import_node_fs.default.chmodSync(targetPath, 493);
-    if (process.platform === "darwin") {
-      try {
-        (0, import_node_child_process.execSync)(`xattr -d com.apple.quarantine "${targetPath}" 2>/dev/null || true`, {
-          timeout: 1e4,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      } catch {
-      }
-      try {
-        (0, import_node_child_process.execSync)(`codesign --force --sign - "${targetPath}"`, {
-          timeout: 1e4,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      } catch {
-      }
-    }
-    (0, import_node_child_process.execSync)(`"${targetPath}" --help`, { timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
-  } catch (err) {
-    try {
-      import_node_fs.default.unlinkSync(targetPath);
-    } catch {
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    throw new AgentRelayProcessError(`Failed to install broker binary: ${message}
-Install manually: curl -fsSL https://raw.githubusercontent.com/AgentWorkforce/relay/main/install.sh | bash`);
-  }
-  console.log(`[agent-relay] Broker installed to ${targetPath}`);
-  return targetPath;
-}
-function resolveDefaultBinaryPath() {
-  const brokerExe = process.platform === "win32" ? "agent-relay-broker.exe" : "agent-relay-broker";
-  const moduleDir = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta_url));
-  const workspaceRelease = import_node_path.default.resolve(moduleDir, "..", "..", "..", "target", "release", brokerExe);
-  if (import_node_fs.default.existsSync(workspaceRelease)) {
-    return workspaceRelease;
-  }
-  const binDir = import_node_path.default.resolve(moduleDir, "..", "bin");
-  const suffix = detectPlatformSuffix();
-  if (suffix) {
-    const ext = process.platform === "win32" ? ".exe" : "";
-    const platformBinary = import_node_path.default.join(binDir, `agent-relay-broker-${suffix}${ext}`);
-    if (import_node_fs.default.existsSync(platformBinary)) {
-      return platformBinary;
-    }
-  }
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const standaloneBroker = import_node_path.default.join(homeDir, ".agent-relay", "bin", brokerExe);
-  if (import_node_fs.default.existsSync(standaloneBroker)) {
-    return standaloneBroker;
-  }
-  return installBrokerBinary();
-}
 
 // packages/config/src/relay-config.ts
 var DEFAULT_CONNECTION_CONFIG = {
@@ -9580,28 +8970,66 @@ var DEFAULT_CONNECTION_CONFIG = {
 };
 
 // packages/config/src/bridge-config.ts
-var import_node_path3 = __toESM(require("node:path"), 1);
-var import_node_os3 = __toESM(require("node:os"), 1);
-
-// packages/config/src/project-namespace.ts
 var import_node_path2 = __toESM(require("node:path"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
+
+// packages/config/src/project-namespace.ts
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
 function getGlobalBaseDir() {
   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_path2.default.join(xdgDataHome, "agent-relay");
+    return import_node_path.default.join(xdgDataHome, "agent-relay");
   }
-  return import_node_path2.default.join(import_node_os2.default.homedir(), ".agent-relay");
+  return import_node_path.default.join(import_node_os.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR = getGlobalBaseDir();
+var PROJECT_DATA_DIR = ".agent-relay";
+function hashPath(projectPath) {
+  const normalized = import_node_path.default.resolve(projectPath);
+  const hash2 = import_node_crypto.default.createHash("sha256").update(normalized).digest("hex");
+  return hash2.substring(0, 12);
+}
+function findProjectRoot(startDir = process.cwd()) {
+  if (process.env.AGENT_RELAY_PROJECT) {
+    return import_node_path.default.resolve(process.env.AGENT_RELAY_PROJECT);
+  }
+  let current = import_node_path.default.resolve(startDir);
+  const root = import_node_path.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_fs.default.existsSync(import_node_path.default.join(current, marker))) {
+        return current;
+      }
+    }
+    current = import_node_path.default.dirname(current);
+  }
+  return import_node_path.default.resolve(startDir);
+}
+function getProjectPaths(projectRoot) {
+  const root = projectRoot ?? findProjectRoot();
+  const projectId = hashPath(root);
+  const dataDir = import_node_path.default.join(root, PROJECT_DATA_DIR);
+  return {
+    dataDir,
+    teamDir: import_node_path.default.join(dataDir, "team"),
+    dbPath: import_node_path.default.join(dataDir, "messages.sqlite"),
+    socketPath: import_node_path.default.join(dataDir, "relay.sock"),
+    projectRoot: root,
+    projectId
+  };
+}
 
 // packages/config/src/bridge-config.ts
 var CONFIG_PATHS = [
-  import_node_path3.default.join(import_node_os3.default.homedir(), ".agent-relay", "bridge.json"),
-  import_node_path3.default.join(import_node_os3.default.homedir(), ".config", "agent-relay", "bridge.json")
+  import_node_path2.default.join(import_node_os2.default.homedir(), ".agent-relay", "bridge.json"),
+  import_node_path2.default.join(import_node_os2.default.homedir(), ".config", "agent-relay", "bridge.json")
 ];
 
 // packages/config/src/index.ts
@@ -15501,93 +14929,924 @@ var ModelOptions = {
   Droid: DROID_MODEL_OPTIONS,
   Opencode: OPENCODE_MODEL_OPTIONS
 };
-var SwarmPatterns = {
-  /** Central coordinator distributes tasks to workers */
-  HUB_SPOKE: "hub-spoke",
-  /** Directed acyclic graph with dependencies */
-  DAG: "dag",
-  /** Parallel execution across multiple agents */
-  FAN_OUT: "fan-out",
-  /** Sequential processing through stages */
-  PIPELINE: "pipeline",
-  /** Agents reach agreement before proceeding */
-  CONSENSUS: "consensus",
-  /** Fully connected peer-to-peer communication */
-  MESH: "mesh",
-  /** Sequential handoff between agents */
-  HANDOFF: "handoff",
-  /** Cascading delegation */
-  CASCADE: "cascade",
-  /** Agents debate to reach conclusion */
-  DEBATE: "debate",
-  /** Tree-structured coordination */
-  HIERARCHICAL: "hierarchical"
+var SwarmPatterns = {
+  /** Central coordinator distributes tasks to workers */
+  HUB_SPOKE: "hub-spoke",
+  /** Directed acyclic graph with dependencies */
+  DAG: "dag",
+  /** Parallel execution across multiple agents */
+  FAN_OUT: "fan-out",
+  /** Sequential processing through stages */
+  PIPELINE: "pipeline",
+  /** Agents reach agreement before proceeding */
+  CONSENSUS: "consensus",
+  /** Fully connected peer-to-peer communication */
+  MESH: "mesh",
+  /** Sequential handoff between agents */
+  HANDOFF: "handoff",
+  /** Cascading delegation */
+  CASCADE: "cascade",
+  /** Agents debate to reach conclusion */
+  DEBATE: "debate",
+  /** Tree-structured coordination */
+  HIERARCHICAL: "hierarchical"
+};
+var CLIRegistry = {
+  claude: {
+    name: "Claude Code",
+    package: "@anthropic-ai/claude-code",
+    version: "2.1.72",
+    install: "npm install -g @anthropic-ai/claude-code",
+    npmLink: "https://www.npmjs.com/package/@anthropic-ai"
+  },
+  codex: {
+    name: "Codex CLI",
+    package: "@openai/codex",
+    version: "0.114.0",
+    install: "npm install -g @openai/codex",
+    npmLink: "https://www.npmjs.com/package/@openai/codex"
+  },
+  gemini: {
+    name: "Gemini CLI",
+    package: "@google/gemini-cli",
+    version: "0.33.0",
+    install: "npm install -g @google/gemini-cli",
+    npmLink: "https://www.npmjs.com/package/@google/gemini-cli"
+  },
+  cursor: {
+    name: "Cursor",
+    package: "cursor",
+    version: "2026.02.27-e7d2ef6",
+    install: "Download from cursor.com",
+    npmLink: void 0
+  },
+  droid: {
+    name: "Droid",
+    package: "droid",
+    version: "0.1.0",
+    install: "Download from droid.dev",
+    npmLink: void 0
+  },
+  opencode: {
+    name: "OpenCode",
+    package: "opencode-ai",
+    version: "1.2.24",
+    install: "npm install -g opencode-ai",
+    npmLink: "https://www.npmjs.com/package/opencode-ai"
+  },
+  aider: {
+    name: "Aider",
+    package: "aider-chat",
+    version: "0.72.1",
+    install: "pip install aider-chat",
+    npmLink: void 0
+  },
+  goose: {
+    name: "Goose",
+    package: "goose-ai",
+    version: "1.0.16",
+    install: "pip install goose-ai",
+    npmLink: void 0
+  }
+};
+var DefaultModels = {
+  claude: "sonnet",
+  codex: "gpt-5.4",
+  gemini: "gemini-3.1-pro-preview",
+  cursor: "opus-4.6-thinking",
+  droid: "opus-4.6-fast",
+  opencode: "openai/gpt-5.2"
+};
+
+// packages/sdk/dist/client.js
+var AgentRelayProtocolError = class extends Error {
+  code;
+  retryable;
+  data;
+  constructor(payload) {
+    super(payload.message);
+    this.name = "AgentRelayProtocolError";
+    this.code = payload.code;
+    this.retryable = payload.retryable;
+    this.data = payload.data;
+  }
+};
+var AgentRelayProcessError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentRelayProcessError";
+  }
+};
+function isHeadlessProvider(value) {
+  return value === "claude" || value === "opencode";
+}
+var AgentRelayClient = class _AgentRelayClient {
+  options;
+  child;
+  stdoutRl;
+  stderrRl;
+  lastStderrLine;
+  requestSeq = 0;
+  pending = /* @__PURE__ */ new Map();
+  startingPromise;
+  eventListeners = /* @__PURE__ */ new Set();
+  stderrListeners = /* @__PURE__ */ new Set();
+  eventBuffer = [];
+  maxBufferSize = 1e3;
+  exitPromise;
+  /** The workspace key returned by the broker in its hello_ack response. */
+  workspaceKey;
+  constructor(options = {}) {
+    this.options = {
+      binaryPath: options.binaryPath ?? resolveDefaultBinaryPath(),
+      binaryArgs: options.binaryArgs ?? [],
+      brokerName: options.brokerName ?? (import_node_path3.default.basename(options.cwd ?? process.cwd()) || "project"),
+      channels: options.channels ?? ["general"],
+      cwd: options.cwd ?? process.cwd(),
+      env: options.env ?? process.env,
+      requestTimeoutMs: options.requestTimeoutMs ?? 1e4,
+      shutdownTimeoutMs: options.shutdownTimeoutMs ?? 3e3,
+      clientName: options.clientName ?? "@agent-relay/sdk",
+      clientVersion: options.clientVersion ?? "0.1.0"
+    };
+  }
+  static async start(options = {}) {
+    const client = new _AgentRelayClient(options);
+    await client.start();
+    return client;
+  }
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => {
+      this.eventListeners.delete(listener);
+    };
+  }
+  queryEvents(filter) {
+    let events = [...this.eventBuffer];
+    if (filter?.kind) {
+      events = events.filter((event) => event.kind === filter.kind);
+    }
+    if (filter?.name) {
+      events = events.filter((event) => "name" in event && event.name === filter.name);
+    }
+    const since = filter?.since;
+    if (since !== void 0) {
+      events = events.filter((event) => "timestamp" in event && typeof event.timestamp === "number" && event.timestamp >= since);
+    }
+    const limit = filter?.limit;
+    if (limit !== void 0) {
+      events = events.slice(-limit);
+    }
+    return events;
+  }
+  getLastEvent(kind, name) {
+    for (let i = this.eventBuffer.length - 1; i >= 0; i -= 1) {
+      const event = this.eventBuffer[i];
+      if (event.kind === kind && (!name || "name" in event && event.name === name)) {
+        return event;
+      }
+    }
+    return void 0;
+  }
+  onBrokerStderr(listener) {
+    this.stderrListeners.add(listener);
+    return () => {
+      this.stderrListeners.delete(listener);
+    };
+  }
+  get brokerPid() {
+    return this.child?.pid;
+  }
+  async start() {
+    if (this.child) {
+      return;
+    }
+    if (this.startingPromise) {
+      return this.startingPromise;
+    }
+    this.startingPromise = this.startInternal();
+    try {
+      await this.startingPromise;
+    } finally {
+      this.startingPromise = void 0;
+    }
+  }
+  /**
+   * Pre-register a batch of agents with Relaycast before their steps execute.
+   * The broker warms its token cache in parallel; subsequent spawn_agent calls
+   * hit the cache rather than waiting on individual HTTP registrations.
+   * Fire-and-forget from the caller's perspective — broker responds immediately
+   * and registers in the background.
+   */
+  async preflightAgents(agents) {
+    if (agents.length === 0)
+      return;
+    await this.start();
+    await this.requestOk("preflight_agents", { agents });
+  }
+  async spawnPty(input) {
+    await this.start();
+    const args = buildPtyArgsWithModel(input.cli, input.args ?? [], input.model);
+    const agent = {
+      name: input.name,
+      runtime: "pty",
+      cli: input.cli,
+      args,
+      channels: input.channels ?? [],
+      model: input.model,
+      cwd: input.cwd ?? this.options.cwd,
+      team: input.team,
+      shadow_of: input.shadowOf,
+      shadow_mode: input.shadowMode,
+      restart_policy: input.restartPolicy
+    };
+    const result = await this.requestOk("spawn_agent", {
+      agent,
+      ...input.task != null ? { initial_task: input.task } : {},
+      ...input.idleThresholdSecs != null ? { idle_threshold_secs: input.idleThresholdSecs } : {},
+      ...input.continueFrom != null ? { continue_from: input.continueFrom } : {},
+      ...input.skipRelayPrompt != null ? { skip_relay_prompt: input.skipRelayPrompt } : {}
+    });
+    return result;
+  }
+  async spawnHeadless(input) {
+    await this.start();
+    const agent = {
+      name: input.name,
+      runtime: "headless",
+      provider: input.provider,
+      args: input.args ?? [],
+      channels: input.channels ?? []
+    };
+    const result = await this.requestOk("spawn_agent", {
+      agent,
+      ...input.task != null ? { initial_task: input.task } : {},
+      ...input.skipRelayPrompt != null ? { skip_relay_prompt: input.skipRelayPrompt } : {}
+    });
+    return result;
+  }
+  async spawnProvider(input) {
+    const transport = input.transport ?? (input.provider === "opencode" ? "headless" : "pty");
+    if (transport === "headless") {
+      if (!isHeadlessProvider(input.provider)) {
+        throw new AgentRelayProcessError(`provider '${input.provider}' does not support headless transport (supported: claude, opencode)`);
+      }
+      return this.spawnHeadless({
+        name: input.name,
+        provider: input.provider,
+        args: input.args,
+        channels: input.channels,
+        task: input.task,
+        skipRelayPrompt: input.skipRelayPrompt
+      });
+    }
+    return this.spawnPty({
+      name: input.name,
+      cli: input.provider,
+      args: input.args,
+      channels: input.channels,
+      task: input.task,
+      model: input.model,
+      cwd: input.cwd,
+      team: input.team,
+      shadowOf: input.shadowOf,
+      shadowMode: input.shadowMode,
+      idleThresholdSecs: input.idleThresholdSecs,
+      restartPolicy: input.restartPolicy,
+      continueFrom: input.continueFrom,
+      skipRelayPrompt: input.skipRelayPrompt
+    });
+  }
+  async spawnClaude(input) {
+    return this.spawnProvider({ ...input, provider: "claude" });
+  }
+  async spawnOpencode(input) {
+    return this.spawnProvider({ ...input, provider: "opencode" });
+  }
+  async release(name, reason) {
+    await this.start();
+    return this.requestOk("release_agent", { name, reason });
+  }
+  async sendInput(name, data) {
+    await this.start();
+    return this.requestOk("send_input", { name, data });
+  }
+  async setModel(name, model, opts) {
+    await this.start();
+    return this.requestOk("set_model", {
+      name,
+      model,
+      timeout_ms: opts?.timeoutMs
+    });
+  }
+  async getMetrics(agent) {
+    await this.start();
+    return this.requestOk("get_metrics", { agent });
+  }
+  async getCrashInsights() {
+    await this.start();
+    return this.requestOk("get_crash_insights", {});
+  }
+  async sendMessage(input) {
+    await this.start();
+    try {
+      return await this.requestOk("send_message", {
+        to: input.to,
+        text: input.text,
+        from: input.from,
+        thread_id: input.threadId,
+        workspace_id: input.workspaceId,
+        workspace_alias: input.workspaceAlias,
+        priority: input.priority,
+        data: input.data
+      });
+    } catch (error48) {
+      if (error48 instanceof AgentRelayProtocolError && error48.code === "unsupported_operation") {
+        return { event_id: "unsupported_operation", targets: [] };
+      }
+      throw error48;
+    }
+  }
+  async listAgents() {
+    await this.start();
+    const result = await this.requestOk("list_agents", {});
+    return result.agents;
+  }
+  async getStatus() {
+    await this.start();
+    return this.requestOk("get_status", {});
+  }
+  async shutdown() {
+    if (!this.child) {
+      return;
+    }
+    void this.requestOk("shutdown", {}).catch(() => {
+    });
+    const child = this.child;
+    const wait = this.exitPromise ?? Promise.resolve();
+    const waitForExit = async (timeoutMs) => {
+      let timer;
+      const result = await Promise.race([
+        wait.then(() => true),
+        new Promise((resolve3) => {
+          timer = setTimeout(() => resolve3(false), timeoutMs);
+        })
+      ]);
+      if (timer !== void 0)
+        clearTimeout(timer);
+      return result;
+    };
+    if (await waitForExit(this.options.shutdownTimeoutMs)) {
+      return;
+    }
+    if (child.exitCode === null && child.signalCode === null) {
+      child.kill("SIGTERM");
+    }
+    if (await waitForExit(1e3)) {
+      return;
+    }
+    if (child.exitCode === null && child.signalCode === null) {
+      child.kill("SIGKILL");
+    }
+    await waitForExit(1e3);
+  }
+  async waitForExit() {
+    if (!this.child) {
+      return;
+    }
+    await this.exitPromise;
+  }
+  async startInternal() {
+    const resolvedBinary = expandTilde(this.options.binaryPath);
+    if (isExplicitPath(this.options.binaryPath) && !import_node_fs2.default.existsSync(resolvedBinary)) {
+      throw new AgentRelayProcessError(`broker binary not found: ${this.options.binaryPath}`);
+    }
+    this.lastStderrLine = void 0;
+    const args = [
+      "init",
+      "--name",
+      this.options.brokerName,
+      ...this.options.channels.length > 0 ? ["--channels", this.options.channels.join(",")] : [],
+      ...this.options.binaryArgs
+    ];
+    const env = { ...this.options.env };
+    if (isExplicitPath(this.options.binaryPath)) {
+      const binDir = import_node_path3.default.dirname(import_node_path3.default.resolve(resolvedBinary));
+      const currentPath = env.PATH ?? env.Path ?? "";
+      if (!currentPath.split(import_node_path3.default.delimiter).includes(binDir)) {
+        env.PATH = `${binDir}${import_node_path3.default.delimiter}${currentPath}`;
+      }
+    }
+    console.error(`[broker] Starting: ${resolvedBinary} ${args.join(" ")}`);
+    const child = (0, import_node_child_process2.spawn)(resolvedBinary, args, {
+      cwd: this.options.cwd,
+      env,
+      stdio: "pipe"
+    });
+    this.child = child;
+    this.stdoutRl = (0, import_node_readline.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+    this.stderrRl = (0, import_node_readline.createInterface)({ input: child.stderr, crlfDelay: Infinity });
+    this.stdoutRl.on("line", (line) => {
+      this.handleStdoutLine(line);
+    });
+    this.stderrRl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (trimmed) {
+        this.lastStderrLine = trimmed;
+      }
+      for (const listener of this.stderrListeners) {
+        listener(line);
+      }
+    });
+    this.exitPromise = new Promise((resolve3) => {
+      child.once("close", (code, signal) => {
+        const detail = this.lastStderrLine ? `: ${this.lastStderrLine}` : "";
+        const error48 = new AgentRelayProcessError(`broker exited (code=${code ?? "null"}, signal=${signal ?? "null"})${detail}`);
+        this.failAllPending(error48);
+        this.disposeProcessHandles();
+        resolve3();
+      });
+      child.once("error", (error48) => {
+        this.failAllPending(error48);
+        this.disposeProcessHandles();
+        resolve3();
+      });
+    });
+    const helloAck = await this.requestHello();
+    console.error("[broker] Broker ready (hello handshake complete)");
+    if (helloAck.workspace_key) {
+      this.workspaceKey = helloAck.workspace_key;
+    }
+  }
+  disposeProcessHandles() {
+    this.stdoutRl?.close();
+    this.stderrRl?.close();
+    this.stdoutRl = void 0;
+    this.stderrRl = void 0;
+    this.lastStderrLine = void 0;
+    this.child = void 0;
+    this.exitPromise = void 0;
+  }
+  failAllPending(error48) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(error48);
+    }
+    this.pending.clear();
+  }
+  handleStdoutLine(line) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!parsed || typeof parsed !== "object") {
+      return;
+    }
+    if (parsed.v !== PROTOCOL_VERSION || typeof parsed.type !== "string") {
+      return;
+    }
+    const envelope = {
+      v: parsed.v,
+      type: parsed.type,
+      request_id: parsed.request_id,
+      payload: parsed.payload
+    };
+    if (envelope.type === "event") {
+      const payload = envelope.payload;
+      this.eventBuffer.push(payload);
+      if (this.eventBuffer.length > this.maxBufferSize) {
+        this.eventBuffer.shift();
+      }
+      for (const listener of this.eventListeners) {
+        listener(payload);
+      }
+      return;
+    }
+    if (!envelope.request_id) {
+      return;
+    }
+    const pending = this.pending.get(envelope.request_id);
+    if (!pending) {
+      return;
+    }
+    if (envelope.type === "error") {
+      clearTimeout(pending.timeout);
+      this.pending.delete(envelope.request_id);
+      pending.reject(new AgentRelayProtocolError(envelope.payload));
+      return;
+    }
+    if (envelope.type !== pending.expectedType) {
+      clearTimeout(pending.timeout);
+      this.pending.delete(envelope.request_id);
+      pending.reject(new AgentRelayProcessError(`unexpected response type '${envelope.type}' for request '${envelope.request_id}' (expected '${pending.expectedType}')`));
+      return;
+    }
+    clearTimeout(pending.timeout);
+    this.pending.delete(envelope.request_id);
+    pending.resolve(envelope);
+  }
+  async requestHello() {
+    const payload = {
+      client_name: this.options.clientName,
+      client_version: this.options.clientVersion
+    };
+    const frame = await this.sendRequest("hello", payload, "hello_ack");
+    return frame.payload;
+  }
+  async requestOk(type, payload) {
+    const frame = await this.sendRequest(type, payload, "ok");
+    const result = frame.payload;
+    return result.result;
+  }
+  async sendRequest(type, payload, expectedType) {
+    if (!this.child) {
+      throw new AgentRelayProcessError("broker is not running");
+    }
+    const requestId = `req_${++this.requestSeq}`;
+    const message = {
+      v: PROTOCOL_VERSION,
+      type,
+      request_id: requestId,
+      payload
+    };
+    const responsePromise = new Promise((resolve3, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new AgentRelayProcessError(`request timed out after ${this.options.requestTimeoutMs}ms (type='${type}', request_id='${requestId}')`));
+      }, this.options.requestTimeoutMs);
+      this.pending.set(requestId, {
+        expectedType,
+        resolve: resolve3,
+        reject,
+        timeout
+      });
+    });
+    const line = `${JSON.stringify(message)}
+`;
+    if (!this.child.stdin.write(line)) {
+      await (0, import_node_events.once)(this.child.stdin, "drain");
+    }
+    return responsePromise;
+  }
+};
+var CLI_MODEL_FLAG_CLIS = /* @__PURE__ */ new Set(["claude", "codex", "gemini", "goose", "aider"]);
+var CLI_DEFAULT_ARGS = {
+  codex: ["-c", "check_for_update_on_startup=false"]
 };
-var CLIRegistry = {
-  claude: {
-    name: "Claude Code",
-    package: "@anthropic-ai/claude-code",
-    version: "2.1.72",
-    install: "npm install -g @anthropic-ai/claude-code",
-    npmLink: "https://www.npmjs.com/package/@anthropic-ai"
-  },
-  codex: {
-    name: "Codex CLI",
-    package: "@openai/codex",
-    version: "0.114.0",
-    install: "npm install -g @openai/codex",
-    npmLink: "https://www.npmjs.com/package/@openai/codex"
-  },
-  gemini: {
-    name: "Gemini CLI",
-    package: "@google/gemini-cli",
-    version: "0.33.0",
-    install: "npm install -g @google/gemini-cli",
-    npmLink: "https://www.npmjs.com/package/@google/gemini-cli"
-  },
-  cursor: {
-    name: "Cursor",
-    package: "cursor",
-    version: "2026.02.27-e7d2ef6",
-    install: "Download from cursor.com",
-    npmLink: void 0
-  },
-  droid: {
-    name: "Droid",
-    package: "droid",
-    version: "0.1.0",
-    install: "Download from droid.dev",
-    npmLink: void 0
-  },
-  opencode: {
-    name: "OpenCode",
-    package: "opencode-ai",
-    version: "1.2.24",
-    install: "npm install -g opencode-ai",
-    npmLink: "https://www.npmjs.com/package/opencode-ai"
-  },
-  aider: {
-    name: "Aider",
-    package: "aider-chat",
-    version: "0.72.1",
-    install: "pip install aider-chat",
-    npmLink: void 0
-  },
-  goose: {
-    name: "Goose",
-    package: "goose-ai",
-    version: "1.0.16",
-    install: "pip install goose-ai",
-    npmLink: void 0
+function buildPtyArgsWithModel(cli, args, model) {
+  const cliName = cli.split(":")[0].trim().toLowerCase();
+  const defaultArgs = CLI_DEFAULT_ARGS[cliName] ?? [];
+  const baseArgs = [...defaultArgs, ...args];
+  if (!model) {
+    return baseArgs;
+  }
+  if (!CLI_MODEL_FLAG_CLIS.has(cliName)) {
+    return baseArgs;
+  }
+  if (hasModelArg(baseArgs)) {
+    return baseArgs;
+  }
+  return ["--model", model, ...baseArgs];
+}
+function hasModelArg(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--model") {
+      return true;
+    }
+    if (arg.startsWith("--model=")) {
+      return true;
+    }
+  }
+  return false;
+}
+function expandTilde(p) {
+  if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
+    const home = import_node_os3.default.homedir();
+    return import_node_path3.default.join(home, p.slice(2));
+  }
+  return p;
+}
+function isExplicitPath(binaryPath) {
+  return binaryPath.includes("/") || binaryPath.includes("\\") || binaryPath.startsWith(".") || binaryPath.startsWith("~");
+}
+function detectPlatformSuffix() {
+  const platformMap = {
+    darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
+    linux: { arm64: "linux-arm64", x64: "linux-x64" },
+    win32: { x64: "win32-x64" }
+  };
+  return platformMap[process.platform]?.[process.arch] ?? null;
+}
+function getLatestVersionSync() {
+  try {
+    const result = (0, import_node_child_process2.execSync)("curl -fsSL https://api.github.com/repos/AgentWorkforce/relay/releases/latest", {
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString();
+    const match = result.match(/"tag_name"\s*:\s*"([^"]+)"/);
+    if (!match?.[1])
+      return null;
+    return match[1].replace(/^openclaw-/, "").replace(/^v/, "");
+  } catch {
+    return null;
+  }
+}
+function installBrokerBinary() {
+  const suffix = detectPlatformSuffix();
+  if (!suffix) {
+    throw new AgentRelayProcessError(`Unsupported platform: ${process.platform}-${process.arch}`);
+  }
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const installDir = import_node_path3.default.join(homeDir, ".agent-relay", "bin");
+  const brokerExe = process.platform === "win32" ? "agent-relay-broker.exe" : "agent-relay-broker";
+  const targetPath = import_node_path3.default.join(installDir, brokerExe);
+  console.log(`[agent-relay] Broker binary not found, installing for ${suffix}...`);
+  const version2 = getLatestVersionSync();
+  if (!version2) {
+    throw new AgentRelayProcessError("Failed to fetch latest agent-relay version from GitHub.\nInstall manually: curl -fsSL https://raw.githubusercontent.com/AgentWorkforce/relay/main/install.sh | bash");
+  }
+  const binaryName = `agent-relay-broker-${suffix}`;
+  const downloadUrl = `https://github.com/AgentWorkforce/relay/releases/download/v${version2}/${binaryName}`;
+  console.log(`[agent-relay] Downloading v${version2} from ${downloadUrl}`);
+  try {
+    import_node_fs2.default.mkdirSync(installDir, { recursive: true });
+    (0, import_node_child_process2.execSync)(`curl -fsSL "${downloadUrl}" -o "${targetPath}"`, {
+      timeout: 6e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    import_node_fs2.default.chmodSync(targetPath, 493);
+    if (process.platform === "darwin") {
+      try {
+        (0, import_node_child_process2.execSync)(`xattr -d com.apple.quarantine "${targetPath}" 2>/dev/null || true`, {
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+      }
+      try {
+        (0, import_node_child_process2.execSync)(`codesign --force --sign - "${targetPath}"`, {
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+      }
+    }
+    (0, import_node_child_process2.execSync)(`"${targetPath}" --help`, { timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
+  } catch (err) {
+    try {
+      import_node_fs2.default.unlinkSync(targetPath);
+    } catch {
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    throw new AgentRelayProcessError(`Failed to install broker binary: ${message}
+Install manually: curl -fsSL https://raw.githubusercontent.com/AgentWorkforce/relay/main/install.sh | bash`);
+  }
+  console.log(`[agent-relay] Broker installed to ${targetPath}`);
+  return targetPath;
+}
+function resolveDefaultBinaryPath() {
+  const brokerExe = process.platform === "win32" ? "agent-relay-broker.exe" : "agent-relay-broker";
+  const moduleDir = import_node_path3.default.dirname((0, import_node_url.fileURLToPath)(import_meta_url));
+  const workspaceRelease = import_node_path3.default.resolve(moduleDir, "..", "..", "..", "target", "release", brokerExe);
+  if (import_node_fs2.default.existsSync(workspaceRelease)) {
+    return workspaceRelease;
+  }
+  const binDir = import_node_path3.default.resolve(moduleDir, "..", "bin");
+  const suffix = detectPlatformSuffix();
+  if (suffix) {
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const platformBinary = import_node_path3.default.join(binDir, `agent-relay-broker-${suffix}${ext}`);
+    if (import_node_fs2.default.existsSync(platformBinary)) {
+      return platformBinary;
+    }
+  }
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const standaloneBroker = import_node_path3.default.join(homeDir, ".agent-relay", "bin", brokerExe);
+  if (import_node_fs2.default.existsSync(standaloneBroker)) {
+    return standaloneBroker;
+  }
+  return installBrokerBinary();
+}
+var DEFAULT_DASHBOARD_PORT = (() => {
+  const envPort = typeof process !== "undefined" ? process.env.AGENT_RELAY_DASHBOARD_PORT : void 0;
+  if (envPort) {
+    const parsed = Number.parseInt(envPort, 10);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+  }
+  return 3888;
+})();
+var HTTP_MAX_PORT_SCAN = 25;
+var HTTP_AUTOSTART_TIMEOUT_MS = 1e4;
+var HTTP_AUTOSTART_POLL_MS = 250;
+function sanitizeBrokerName(name) {
+  return name.replace(/[^\p{L}\p{N}-]/gu, "-");
+}
+function brokerPidFilename(projectRoot) {
+  const brokerName = import_node_path3.default.basename(projectRoot) || "project";
+  return `broker-${sanitizeBrokerName(brokerName)}.pid`;
+}
+var HttpAgentRelayClient = class _HttpAgentRelayClient {
+  port;
+  apiKey;
+  constructor(options) {
+    this.port = options.port;
+    this.apiKey = options.apiKey;
+  }
+  /**
+   * Connect to an already-running broker on the given port.
+   */
+  static async connectHttp(port, options) {
+    const client = new _HttpAgentRelayClient({ port, apiKey: options?.apiKey });
+    await client.healthCheck();
+    return client;
+  }
+  /**
+   * Discover a running broker for the current project and connect to it.
+   * Reads the broker PID file, verifies the process is alive, scans ports
+   * for the HTTP API, and returns a connected client.
+   */
+  static async discoverAndConnect(options) {
+    const cwd = options?.cwd ?? process.cwd();
+    const apiKey = options?.apiKey ?? process.env.RELAY_BROKER_API_KEY?.trim();
+    const autoStart = options?.autoStart ?? false;
+    const paths = getProjectPaths(cwd);
+    const preferredApiPort = DEFAULT_DASHBOARD_PORT + 1;
+    const pidFilePath = import_node_path3.default.join(paths.dataDir, brokerPidFilename(paths.projectRoot));
+    const legacyPidPath = import_node_path3.default.join(paths.dataDir, "broker.pid");
+    let brokerRunning = false;
+    for (const pidPath of [pidFilePath, legacyPidPath]) {
+      if (import_node_fs2.default.existsSync(pidPath)) {
+        const pidStr = import_node_fs2.default.readFileSync(pidPath, "utf-8").trim();
+        const pid = Number.parseInt(pidStr, 10);
+        if (Number.isFinite(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            brokerRunning = true;
+            break;
+          } catch {
+          }
+        }
+      }
+    }
+    if (brokerRunning) {
+      const port = await _HttpAgentRelayClient.scanForBrokerPort(preferredApiPort);
+      if (port !== null) {
+        return new _HttpAgentRelayClient({ port, apiKey });
+      }
+      throw new AgentRelayProcessError("broker is running for this project, but its local API is unavailable");
+    }
+    if (!autoStart) {
+      throw new AgentRelayProcessError("broker is not running for this project");
+    }
+    const brokerBinary = options?.brokerBinaryPath ?? resolveDefaultBinaryPath();
+    const child = (0, import_node_child_process2.spawn)(brokerBinary, ["init", "--persist", "--api-port", String(preferredApiPort)], {
+      cwd: paths.projectRoot,
+      env: process.env,
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < HTTP_AUTOSTART_TIMEOUT_MS) {
+      const port = await _HttpAgentRelayClient.scanForBrokerPort(preferredApiPort);
+      if (port !== null) {
+        return new _HttpAgentRelayClient({ port, apiKey });
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, HTTP_AUTOSTART_POLL_MS));
+    }
+    throw new AgentRelayProcessError(`broker did not become ready within ${HTTP_AUTOSTART_TIMEOUT_MS}ms`);
+  }
+  static async scanForBrokerPort(startPort) {
+    for (let i = 0; i < HTTP_MAX_PORT_SCAN; i++) {
+      const port = startPort + i;
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`);
+        if (!res.ok)
+          continue;
+        const payload = await res.json().catch(() => null);
+        if (payload?.service === "agent-relay-listen") {
+          return port;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  async request(pathname, init) {
+    const headers = new Headers(init?.headers);
+    if (this.apiKey && !headers.has("x-api-key") && !headers.has("authorization")) {
+      headers.set("x-api-key", this.apiKey);
+    }
+    const response = await fetch(`http://127.0.0.1:${this.port}${pathname}`, {
+      ...init,
+      headers
+    });
+    const text = await response.text();
+    let payload;
+    try {
+      payload = text ? JSON.parse(text) : void 0;
+    } catch {
+      payload = text;
+    }
+    if (!response.ok) {
+      const msg = _HttpAgentRelayClient.extractErrorMessage(response, payload);
+      throw new AgentRelayProcessError(msg);
+    }
+    return payload;
+  }
+  static extractErrorMessage(response, payload) {
+    if (typeof payload === "string" && payload.trim())
+      return payload.trim();
+    const p = payload;
+    if (typeof p?.error === "string")
+      return p.error;
+    if (typeof p?.error?.message === "string")
+      return p.error.message;
+    if (typeof p?.message === "string" && p.message.trim())
+      return p.message.trim();
+    return `${response.status} ${response.statusText}`.trim();
+  }
+  async healthCheck() {
+    return this.request("/health");
+  }
+  /** No-op — broker is already running. */
+  async start() {
+  }
+  /** No-op — don't kill an externally-managed broker. */
+  async shutdown() {
+  }
+  async spawnPty(input) {
+    const payload = await this.request("/api/spawn", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        name: input.name,
+        cli: input.cli,
+        model: input.model,
+        args: input.args ?? [],
+        task: input.task,
+        channels: input.channels ?? [],
+        cwd: input.cwd,
+        team: input.team,
+        shadowOf: input.shadowOf,
+        shadowMode: input.shadowMode,
+        continueFrom: input.continueFrom,
+        idleThresholdSecs: input.idleThresholdSecs,
+        restartPolicy: input.restartPolicy,
+        skipRelayPrompt: input.skipRelayPrompt
+      })
+    });
+    return {
+      name: typeof payload?.name === "string" ? payload.name : input.name,
+      runtime: "pty"
+    };
+  }
+  async sendMessage(input) {
+    return this.request("/api/send", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        to: input.to,
+        text: input.text,
+        from: input.from,
+        threadId: input.threadId,
+        workspaceId: input.workspaceId,
+        workspaceAlias: input.workspaceAlias,
+        priority: input.priority,
+        data: input.data
+      })
+    });
+  }
+  async listAgents() {
+    const payload = await this.request("/api/spawned", { method: "GET" });
+    return Array.isArray(payload?.agents) ? payload.agents : [];
+  }
+  async release(name, reason) {
+    const payload = await this.request(`/api/spawned/${encodeURIComponent(name)}`, {
+      method: "DELETE",
+      ...reason ? { headers: { "content-type": "application/json" }, body: JSON.stringify({ reason }) } : {}
+    });
+    return { name: typeof payload?.name === "string" ? payload.name : name };
+  }
+  async setModel(name, model, opts) {
+    const payload = await this.request(`/api/spawned/${encodeURIComponent(name)}/model`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, timeoutMs: opts?.timeoutMs })
+    });
+    return {
+      name,
+      model: typeof payload?.model === "string" ? payload.model : model,
+      success: payload?.success !== false
+    };
+  }
+  async getConfig() {
+    return this.request("/api/config");
   }
-};
-var DefaultModels = {
-  claude: "sonnet",
-  codex: "gpt-5.4",
-  gemini: "gemini-3.1-pro-preview",
-  cursor: "opus-4.6-thinking",
-  droid: "opus-4.6-fast",
-  opencode: "openai/gpt-5.2"
 };
 
 // node_modules/@relaycast/sdk/dist/version.js
@@ -31425,7 +31684,7 @@ function cleanLines(raw) {
 }
 
 // packages/sdk/dist/relay.js
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var import_node_path5 = __toESM(require("node:path"), 1);
 
 // packages/sdk/dist/logs.js
@@ -31843,7 +32102,7 @@ var AgentRelay = class {
         if (result?.event_id === "unsupported_operation") {
           return buildUnsupportedOperationMessage(opts.name, input);
         }
-        const eventId = result?.event_id ?? (0, import_node_crypto.randomBytes)(8).toString("hex");
+        const eventId = result?.event_id ?? (0, import_node_crypto2.randomBytes)(8).toString("hex");
         const msg = {
           eventId,
           from: opts.name,
@@ -32505,7 +32764,7 @@ var AgentRelay = class {
         if (result?.event_id === "unsupported_operation") {
           return buildUnsupportedOperationMessage(name, input);
         }
-        const eventId = result?.event_id ?? (0, import_node_crypto.randomBytes)(8).toString("hex");
+        const eventId = result?.event_id ?? (0, import_node_crypto2.randomBytes)(8).toString("hex");
         const msg = {
           eventId,
           from: name,
@@ -32622,7 +32881,7 @@ var AgentRelay = class {
 };
 
 // packages/sdk/dist/consensus.js
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 var import_node_events2 = require("node:events");
 
 // packages/sdk/dist/consensus-helpers.js
@@ -32759,7 +33018,7 @@ var ConsensusEngine = class extends import_node_events2.EventEmitter {
   }
   // ── Proposal management ──────────────────────────────────────────────────
   createProposal(options) {
-    const id = `prop_${Date.now()}_${(0, import_node_crypto2.randomBytes)(4).toString("hex")}`;
+    const id = `prop_${Date.now()}_${(0, import_node_crypto3.randomBytes)(4).toString("hex")}`;
     const now = Date.now();
     const timeoutMs = options.timeoutMs ?? this.config.defaultTimeoutMs;
     const proposal = {
@@ -33227,15 +33486,15 @@ var ShadowManager = class {
 var WORKFLOW_BOOTSTRAP_TASK = "You are connected to Agent Relay. Do not reply to this message and wait for relay messages and respond using Relaycast MCP tools.";
 var WORKFLOW_CONVENTIONS = [
   "Messaging requirements:",
-  '- When you receive `Relay message from <sender> ...`, reply using `mcp__relaycast__dm_send(to: "<sender>", text: "...")`.',
+  '- When you receive `Relay message from <sender> ...`, reply using `mcp__relaycast__message_dm_send(to: "<sender>", text: "...")`.',
   "- Send `ACK: ...` when you receive a task.",
   "- Send `DONE: ...` when the task is complete.",
-  "- Do not reply only in terminal text; send the response via mcp__relaycast__dm_send.",
-  "- Use mcp__relaycast__inbox_check() and mcp__relaycast__agent_list() when context is missing."
+  "- Do not reply only in terminal text; send the response via mcp__relaycast__message_dm_send.",
+  "- Use mcp__relaycast__message_inbox_check() and mcp__relaycast__agent_list() when context is missing."
 ].join("\n");
 function hasWorkflowConventions(task) {
   const lower = task.toLowerCase();
-  return lower.includes("mcp__relaycast__dm_send(") || lower.includes("relay_send(") || lower.includes("ack:") && lower.includes("done:");
+  return lower.includes("mcp__relaycast__message_dm_send(") || lower.includes("relay_send(") || lower.includes("ack:") && lower.includes("done:");
 }
 function buildSpawnTask(task, includeWorkflowConventions) {
   const normalized = typeof task === "string" ? task.trim() : "";
@@ -33427,8 +33686,8 @@ function isAgentStep(step) {
 
 // packages/sdk/dist/workflows/runner.js
 var import_node_child_process3 = require("node:child_process");
-var import_node_crypto4 = require("node:crypto");
-var import_node_fs4 = require("node:fs");
+var import_node_crypto5 = require("node:crypto");
+var import_node_fs5 = require("node:fs");
 var import_promises3 = require("node:fs/promises");
 var import_node_path8 = __toESM(require("node:path"), 1);
 var import_yaml2 = __toESM(require_dist(), 1);
@@ -33559,18 +33818,18 @@ async function spawnFromEnv(options = {}) {
 }
 
 // packages/sdk/dist/workflows/custom-steps.js
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_path6 = __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 steps = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs2.existsSync)(stepsPath)) {
+  if (!(0, import_node_fs3.existsSync)(stepsPath)) {
     return steps;
   }
   try {
-    const content = (0, import_node_fs2.readFileSync)(stepsPath, "utf-8");
+    const content = (0, import_node_fs3.readFileSync)(stepsPath, "utf-8");
     if (!content.trim()) {
       return steps;
     }
@@ -33820,7 +34079,7 @@ function resolveAllCustomSteps(steps, customSteps) {
   return steps.map((step) => resolveCustomStep(step, customSteps));
 }
 function customStepsFileExists(cwd) {
-  return (0, import_node_fs2.existsSync)(import_node_path6.default.join(cwd, CUSTOM_STEPS_FILE));
+  return (0, import_node_fs3.existsSync)(import_node_path6.default.join(cwd, CUSTOM_STEPS_FILE));
 }
 function getCustomStepsPath(cwd) {
   return import_node_path6.default.join(cwd, CUSTOM_STEPS_FILE);
@@ -33857,8 +34116,8 @@ var InMemoryWorkflowDb = class {
 };
 
 // packages/sdk/dist/workflows/trajectory.js
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs3 = require("node:fs");
+var import_node_crypto4 = require("node:crypto");
+var import_node_fs4 = require("node:fs");
 var import_promises2 = require("node:fs/promises");
 var import_node_path7 = __toESM(require("node:path"), 1);
 function classifyFailure(error48) {
@@ -33921,7 +34180,7 @@ var WorkflowTrajectory = class {
       return;
     this.startTime = Date.now();
     this.swarmPattern = pattern ?? "dag";
-    const id = `traj_${Date.now()}_${(0, import_node_crypto3.randomBytes)(4).toString("hex")}`;
+    const id = `traj_${Date.now()}_${(0, import_node_crypto4.randomBytes)(4).toString("hex")}`;
     this.trajectory = {
       id,
       version: 1,
@@ -34264,7 +34523,7 @@ var WorkflowTrajectory = class {
     if (!this.trajectory)
       return;
     const chapter = {
-      id: `ch_${(0, import_node_crypto3.randomBytes)(4).toString("hex")}`,
+      id: `ch_${(0, import_node_crypto4.randomBytes)(4).toString("hex")}`,
       title,
       agentName,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -34337,7 +34596,7 @@ var WorkflowTrajectory = class {
       await (0, import_promises2.mkdir)(completedDir, { recursive: true });
       const activePath = import_node_path7.default.join(activeDir, `${this.trajectory.id}.json`);
       const completedPath = import_node_path7.default.join(completedDir, `${this.trajectory.id}.json`);
-      if ((0, import_node_fs3.existsSync)(activePath)) {
+      if ((0, import_node_fs4.existsSync)(activePath)) {
         await (0, import_promises2.rename)(activePath, completedPath);
       }
     } catch {
@@ -34435,6 +34694,8 @@ var WorkflowRunner = class _WorkflowRunner {
   stepSignalParticipants = /* @__PURE__ */ new Map();
   /** Resolved named paths from the top-level `paths` config, keyed by name → absolute directory. */
   resolvedPaths = /* @__PURE__ */ new Map();
+  /** Tracks agent names currently assigned as reviewers (ref-counted to handle concurrent usage). */
+  activeReviewers = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.db = options.db ?? new InMemoryWorkflowDb();
     this.workspaceId = options.workspaceId ?? "local";
@@ -34473,7 +34734,7 @@ var WorkflowRunner = class _WorkflowRunner {
       const abs = import_node_path8.default.resolve(baseCwd, expanded);
       resolved.set(pd.name, abs);
       const isRequired = pd.required !== false;
-      if (!(0, import_node_fs4.existsSync)(abs)) {
+      if (!(0, import_node_fs5.existsSync)(abs)) {
         if (isRequired) {
           errors.push(`Path "${pd.name}" resolves to "${abs}" which does not exist (required)`);
         } else {
@@ -34807,12 +35068,12 @@ ${next}` : next;
   }
   captureFileSnapshot(root) {
     const snapshot = /* @__PURE__ */ new Map();
-    if (!(0, import_node_fs4.existsSync)(root))
+    if (!(0, import_node_fs5.existsSync)(root))
       return snapshot;
     const visit = (currentPath) => {
       let entries;
       try {
-        entries = (0, import_node_fs4.readdirSync)(currentPath, { withFileTypes: true });
+        entries = (0, import_node_fs5.readdirSync)(currentPath, { withFileTypes: true });
       } catch {
         return;
       }
@@ -34826,7 +35087,7 @@ ${next}` : next;
           continue;
         }
         try {
-          const stats = (0, import_node_fs4.statSync)(fullPath);
+          const stats = (0, import_node_fs5.statSync)(fullPath);
           if (!stats.isFile())
             continue;
           snapshot.set(fullPath, { mtimeMs: stats.mtimeMs, size: stats.size });
@@ -34835,7 +35096,7 @@ ${next}` : next;
       }
     };
     try {
-      const stats = (0, import_node_fs4.statSync)(root);
+      const stats = (0, import_node_fs5.statSync)(root);
       if (stats.isFile()) {
         snapshot.set(root, { mtimeMs: stats.mtimeMs, size: stats.size });
         return snapshot;
@@ -34956,7 +35217,7 @@ ${next}` : next;
       this.relayApiKey = envKey;
       return;
     }
-    const workspaceName = `relay-${channel}-${(0, import_node_crypto4.randomBytes)(4).toString("hex")}`;
+    const workspaceName = `relay-${channel}-${(0, import_node_crypto5.randomBytes)(4).toString("hex")}`;
     const baseUrl = this.relayOptions.env?.RELAYCAST_BASE_URL ?? process.env.RELAYCAST_BASE_URL ?? "https://api.relaycast.dev";
     const res = await fetch(`${baseUrl}/v1/workspaces`, {
       method: "POST",
@@ -35020,7 +35281,7 @@ ${next}` : next;
     } catch (err) {
       if (err instanceof RelayError && err.code === "name_conflict") {
         registration = await rc.agents.register({
-          name: `WorkflowRunner-${(0, import_node_crypto4.randomBytes)(4).toString("hex")}`,
+          name: `WorkflowRunner-${(0, import_node_crypto5.randomBytes)(4).toString("hex")}`,
           type: "agent"
         });
       } else {
@@ -35237,14 +35498,14 @@ ${err.suggestion}`);
     for (const agent of resolved.agents) {
       if (agent.cwd) {
         const resolvedCwd = import_node_path8.default.resolve(this.cwd, agent.cwd);
-        if (!(0, import_node_fs4.existsSync)(resolvedCwd)) {
+        if (!(0, import_node_fs5.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_path8.default.resolve(this.cwd, ap);
-          if (!(0, import_node_fs4.existsSync)(resolvedPath)) {
+          if (!(0, import_node_fs5.existsSync)(resolvedPath)) {
             warnings.push(`Agent "${agent.name}" additionalPath "${ap}" resolves to "${resolvedPath}" which does not exist`);
           }
         }
@@ -35983,6 +36244,7 @@ ${err.suggestion}`);
       this.lastActivity.clear();
       this.supervisedRuntimeAgents.clear();
       this.runtimeStepAgents.clear();
+      this.activeReviewers.clear();
       this.log("Shutting down broker...");
       await this.relay?.shutdown();
       this.relay = void 0;
@@ -36577,9 +36839,11 @@ ${trimmedOutput.slice(0, 200)}`);
     }
     const specialistDef = _WorkflowRunner.resolveAgentDef(rawAgentDef);
     const usesOwnerFlow = specialistDef.interactive !== false;
-    const usesAutoHardening = usesOwnerFlow && !this.isExplicitInteractiveWorker(specialistDef);
+    const currentPattern = this.currentConfig?.swarm?.pattern ?? "";
+    const isHubPattern = _WorkflowRunner.HUB_PATTERNS.has(currentPattern);
+    const usesAutoHardening = usesOwnerFlow && isHubPattern && !this.isExplicitInteractiveWorker(specialistDef);
     const ownerDef = usesAutoHardening ? this.resolveAutoStepOwner(specialistDef, agentMap) : specialistDef;
-    const reviewDef = usesAutoHardening ? this.resolveAutoReviewAgent(ownerDef, agentMap) : void 0;
+    let reviewDef;
     const supervised = {
       specialist: specialistDef,
       owner: ownerDef,
@@ -36700,6 +36964,7 @@ ${resolvedTask}`;
           const spawnResult = this.executor ? await this.executor.executeAgentStep(resolvedStep, effectiveOwner, ownerTask, timeoutMs) : await this.spawnAndWait(effectiveOwner, resolvedStep, timeoutMs, {
             evidenceStepName: step.name,
             evidenceRole: usesOwnerFlow ? "owner" : "specialist",
+            preserveOnIdle: !isHubPattern || !this.isLeadLikeAgent(effectiveOwner) ? false : void 0,
             logicalName: effectiveOwner.name,
             onSpawned: explicitInteractiveWorker ? ({ agent }) => {
               explicitWorkerHandle = agent;
@@ -36750,11 +37015,24 @@ ${resolvedTask}`;
         if (completionReason === "retry_requested_by_owner") {
           throw new WorkflowCompletionError(`Step "${step.name}" owner requested another attempt`, "retry_requested_by_owner");
         }
+        if (usesAutoHardening && usesDedicatedOwner && !reviewDef) {
+          reviewDef = this.resolveAutoReviewAgent(ownerDef, agentMap);
+          supervised.reviewer = reviewDef;
+        }
         let combinedOutput = specialistOutput;
         if (usesOwnerFlow && reviewDef) {
-          const remainingMs = timeoutMs ? Math.max(0, timeoutMs - ownerElapsed) : void 0;
-          const reviewOutput = await this.runStepReviewGate(step, resolvedTask, specialistOutput, ownerOutput, ownerDef, reviewDef, remainingMs);
-          combinedOutput = this.combineStepAndReviewOutput(specialistOutput, reviewOutput);
+          this.activeReviewers.set(reviewDef.name, (this.activeReviewers.get(reviewDef.name) ?? 0) + 1);
+          try {
+            const remainingMs = timeoutMs ? Math.max(0, timeoutMs - ownerElapsed) : void 0;
+            const reviewOutput = await this.runStepReviewGate(step, resolvedTask, specialistOutput, ownerOutput, ownerDef, reviewDef, remainingMs);
+            combinedOutput = this.combineStepAndReviewOutput(specialistOutput, reviewOutput);
+          } finally {
+            const count = (this.activeReviewers.get(reviewDef.name) ?? 1) - 1;
+            if (count <= 0)
+              this.activeReviewers.delete(reviewDef.name);
+            else
+              this.activeReviewers.set(reviewDef.name, count);
+          }
         }
         state.row.status = "completed";
         state.row.output = combinedOutput;
@@ -37113,10 +37391,13 @@ WORKER COMPLETION CONTRACT:
         return 2;
       return isReviewer(def) ? 1 : 0;
     };
-    const dedicated = allDefs.filter((d) => eligible(d) && isReviewer(d)).sort((a, b) => reviewerPriority(b) - reviewerPriority(a) || a.name.localeCompare(b.name))[0];
+    const notBusy = (def) => !this.activeReviewers.has(def.name);
+    const dedicatedCandidates = allDefs.filter((d) => eligible(d) && isReviewer(d)).sort((a, b) => reviewerPriority(b) - reviewerPriority(a) || a.name.localeCompare(b.name));
+    const dedicated = dedicatedCandidates.find(notBusy) ?? dedicatedCandidates[0];
     if (dedicated)
       return dedicated;
-    const alternate = allDefs.find((d) => eligible(d) && d.interactive !== false);
+    const alternateCandidates = allDefs.filter((d) => eligible(d) && d.interactive !== false);
+    const alternate = alternateCandidates.find(notBusy) ?? alternateCandidates[0];
     if (alternate)
       return alternate;
     return ownerDef;
@@ -37610,7 +37891,7 @@ ${review}
   buildPresetInjection(preset) {
     switch (preset) {
       case "worker":
-        return "You are a non-interactive worker agent. Produce clean, structured output to stdout.\nDo NOT use mcp__relaycast__agent_add, add_agent, or any MCP tool to spawn sub-agents.\nDo NOT use mcp__relaycast__dm_send or any Relaycast messaging tools \u2014 you have no relay connection.\n\n";
+        return "You are a non-interactive worker agent. Produce clean, structured output to stdout.\nDo NOT use mcp__relaycast__agent_add, add_agent, or any MCP tool to spawn sub-agents.\nDo NOT use mcp__relaycast__message_dm_send or any Relaycast messaging tools \u2014 you have no relay connection.\n\n";
       case "reviewer":
         return "You are a non-interactive reviewer agent. Read the specified files/artifacts and produce a clear verdict.\nDo NOT spawn sub-agents or use any Relaycast messaging tools.\n\n";
       case "analyst":
@@ -37650,7 +37931,7 @@ DO NOT:
     const { cmd, args } = _WorkflowRunner.buildNonInteractiveCommand(agentDef.cli, taskWithDeliverable, modelArgs);
     const logsDir = this.getWorkerLogsDir();
     const logPath = import_node_path8.default.join(logsDir, `${agentName}.log`);
-    const logStream = (0, import_node_fs4.createWriteStream)(logPath, { flags: "a" });
+    const logStream = (0, import_node_fs5.createWriteStream)(logPath, { flags: "a" });
     this.registerWorker(agentName, agentDef.cli, step.task ?? "", void 0, false);
     let stopHeartbeat;
     if (this.relayApiKey) {
@@ -37786,7 +38067,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_fs4.createWriteStream)(import_node_path8.default.join(logsDir, `${agentName}.log`), { flags: "a" });
+    const logStream = (0, import_node_fs5.createWriteStream)(import_node_path8.default.join(logsDir, `${agentName}.log`), { flags: "a" });
     this.ptyLogStreams.set(agentName, logStream);
     this.ptyListeners.set(agentName, (chunk) => {
       const stripped = _WorkflowRunner.stripAnsi(chunk);
@@ -37828,11 +38109,11 @@ DO NOT:
           oldLogStream.end();
           this.ptyLogStreams.delete(oldName);
           try {
-            (0, import_node_fs4.renameSync)(oldLogPath, newLogPath);
+            (0, import_node_fs5.renameSync)(oldLogPath, newLogPath);
           } catch {
           }
         }
-        const newLogStream = (0, import_node_fs4.createWriteStream)(newLogPath, { flags: "a" });
+        const newLogStream = (0, import_node_fs5.createWriteStream)(newLogPath, { flags: "a" });
         this.ptyLogStreams.set(agent.name, newLogStream);
         const oldListener = this.ptyListeners.get(oldName);
         if (oldListener) {
@@ -37937,7 +38218,7 @@ DO NOT:
       output = ptyChunks.join("");
     } else {
       const summaryPath = import_node_path8.default.join(this.summaryDir, `${step.name}.md`);
-      output = (0, import_node_fs4.existsSync)(summaryPath) ? await (0, import_promises3.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
+      output = (0, import_node_fs5.existsSync)(summaryPath) ? await (0, import_promises3.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 }, {
@@ -38001,17 +38282,56 @@ DO NOT:
         this.log(`[${step.name}] Supervising agent "${agent.name}" may idle while waiting \u2014 using exit-only completion`);
         return agent.waitForExit(timeoutMs);
       }
-      const result = await Promise.race([
-        agent.waitForExit(timeoutMs).then((r) => ({ kind: "exit", result: r })),
-        agent.waitForIdle(timeoutMs).then((r) => ({ kind: "idle", result: r }))
-      ]);
-      if (result.kind === "idle" && result.result === "idle") {
-        this.log(`[${step.name}] Agent "${agent.name}" went idle \u2014 treating as complete`);
-        this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` idle \u2014 treating as complete`);
-        await agent.release();
-        return "released";
+      const idleLoopStart = Date.now();
+      while (true) {
+        const elapsed = Date.now() - idleLoopStart;
+        const remaining = timeoutMs != null ? Math.max(0, timeoutMs - elapsed) : void 0;
+        if (remaining != null && remaining <= 0) {
+          return "timeout";
+        }
+        const result = await Promise.race([
+          agent.waitForExit(remaining).then((r) => ({ kind: "exit", result: r })),
+          agent.waitForIdle(remaining).then((r) => ({ kind: "idle", result: r }))
+        ]);
+        if (result.kind === "idle" && result.result === "idle") {
+          if (step.verification && step.verification.type === "output_contains") {
+            const token = step.verification.value;
+            const ptyOutput = (this.ptyOutputBuffers.get(agent.name) ?? []).join("");
+            const taskText = step.task ?? "";
+            const taskHasToken = taskText.includes(token);
+            let verificationPassed = true;
+            if (taskHasToken) {
+              const first = ptyOutput.indexOf(token);
+              verificationPassed = first !== -1 && ptyOutput.includes(token, first + token.length);
+            } else {
+              verificationPassed = ptyOutput.includes(token);
+            }
+            if (!verificationPassed) {
+              this.log(`[${step.name}] Agent "${agent.name}" went idle but verification not yet passed \u2014 waiting for more output`);
+              const idleGraceSecs = 15;
+              const graceResult = await Promise.race([
+                agent.waitForExit(idleGraceSecs * 1e3).then((r) => ({ kind: "exit", result: r })),
+                agent.waitForIdle(idleGraceSecs * 1e3).then((r) => ({ kind: "idle", result: r }))
+              ]);
+              if (graceResult.kind === "idle" && graceResult.result === "idle") {
+                continue;
+              }
+              if (graceResult.kind === "exit") {
+                return graceResult.result;
+              }
+              this.log(`[${step.name}] Agent "${agent.name}" still idle after ${idleGraceSecs}s grace \u2014 releasing`);
+              this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` idle \u2014 releasing (verification pending)`);
+              await agent.release();
+              return "released";
+            }
+          }
+          this.log(`[${step.name}] Agent "${agent.name}" went idle \u2014 treating as complete`);
+          this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` idle \u2014 treating as complete`);
+          await agent.release();
+          return "released";
+        }
+        return result.result;
       }
-      return result.result;
     }
     const nudgeAfterMs = nudgeConfig.nudgeAfterMs ?? 12e4;
     const escalateAfterMs = nudgeConfig.escalateAfterMs ?? 12e4;
@@ -38149,7 +38469,7 @@ DO NOT:
       case "exit_code":
         break;
       case "file_exists":
-        if (!(0, import_node_fs4.existsSync)(import_node_path8.default.resolve(this.cwd, check2.value))) {
+        if (!(0, import_node_fs5.existsSync)(import_node_path8.default.resolve(this.cwd, check2.value))) {
           return fail(`Verification failed for "${stepName}": file "${check2.value}" does not exist`);
         }
         break;
@@ -38303,7 +38623,7 @@ DO NOT:
 RELAY SETUP \u2014 do this FIRST before any other relay tool:
 1. Call: register(name="${agentName}")
    This authenticates you in the Relaycast workspace.
-   ALL relay tools (mcp__relaycast__dm_send, mcp__relaycast__inbox_check, mcp__relaycast__message_post, etc.) require
+   ALL relay tools (mcp__relaycast__message_dm_send, mcp__relaycast__message_inbox_check, mcp__relaycast__message_post, etc.) require
    registration first \u2014 they will fail with "Not registered" otherwise.
 2. Your agent name is "${agentName}" \u2014 use this exact name when registering.`;
   }
@@ -38312,7 +38632,7 @@ RELAY SETUP \u2014 do this FIRST before any other relay tool:
 
 ` : "";
     const subAgentOption = cli === "claude" ? "Option 2 \u2014 Use built-in sub-agents (Task tool) for research or scoped work:\n  - Good for exploring code, reading files, or making targeted changes\n  - Can run multiple sub-agents in parallel\n\n" : "";
-    return "---\nAUTONOMOUS DELEGATION \u2014 READ THIS BEFORE STARTING:\n" + timeoutNote + 'Before diving in, assess whether this task is too large or complex for a single agent. If it involves multiple independent subtasks, touches many files, or could take a long time, you should break it down and delegate to helper agents to avoid timeouts.\n\nOption 1 \u2014 Spawn relay agents (for real parallel coding work):\n  - mcp__relaycast__agent_add(name="helper-1", cli="claude", task="Specific subtask description")\n  - Coordinate via mcp__relaycast__dm_send(to="helper-1", text="...")\n  - Check on them with mcp__relaycast__inbox_check()\n  - Clean up when done: mcp__relaycast__agent_remove(name="helper-1")\n\n' + subAgentOption + `Guidelines:
+    return "---\nAUTONOMOUS DELEGATION \u2014 READ THIS BEFORE STARTING:\n" + timeoutNote + 'Before diving in, assess whether this task is too large or complex for a single agent. If it involves multiple independent subtasks, touches many files, or could take a long time, you should break it down and delegate to helper agents to avoid timeouts.\n\nOption 1 \u2014 Spawn relay agents (for real parallel coding work):\n  - mcp__relaycast__agent_add(name="helper-1", cli="claude", task="Specific subtask description")\n  - Coordinate via mcp__relaycast__message_dm_send(to="helper-1", text="...")\n  - Check on them with mcp__relaycast__message_inbox_check()\n  - Clean up when done: mcp__relaycast__agent_remove(name="helper-1")\n\n' + subAgentOption + `Guidelines:
 - You are the lead \u2014 delegate but stay in control, track progress, integrate results
 - Give each helper a clear, self-contained task with enough context to work independently
 - For simple or quick work, just do it yourself \u2014 don't over-delegate
@@ -38488,10 +38808,10 @@ ${excerpt}` : "";
   }
   // ── ID generation ─────────────────────────────────────────────────────
   generateId() {
-    return (0, import_node_crypto4.randomBytes)(12).toString("hex");
+    return (0, import_node_crypto5.randomBytes)(12).toString("hex");
   }
   generateShortId() {
-    return (0, import_node_crypto4.randomBytes)(4).toString("hex");
+    return (0, import_node_crypto5.randomBytes)(4).toString("hex");
   }
   /** Strip ANSI escape codes from terminal output — delegates to pty.ts canonical regex. */
   static stripAnsi(text) {
@@ -38592,7 +38912,7 @@ ${excerpt}` : "";
     const outputPath = import_node_path8.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
     try {
       const dir = this.getStepOutputDir(runId);
-      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+      (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
       const cleaned = _WorkflowRunner.stripAnsi(output);
       await (0, import_promises3.writeFile)(outputPath, cleaned);
     } catch {
@@ -38618,9 +38938,9 @@ ${preview}
   loadStepOutput(runId, stepName) {
     try {
       const filePath = import_node_path8.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
-      if (!(0, import_node_fs4.existsSync)(filePath))
+      if (!(0, import_node_fs5.existsSync)(filePath))
         return void 0;
-      return (0, import_node_fs4.readFileSync)(filePath, "utf-8");
+      return (0, import_node_fs5.readFileSync)(filePath, "utf-8");
     } catch {
       return void 0;
     }
@@ -38628,7 +38948,7 @@ ${preview}
   /** Get or create the worker logs directory (.agent-relay/team/worker-logs) */
   getWorkerLogsDir() {
     const logsDir = import_node_path8.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
-    (0, import_node_fs4.mkdirSync)(logsDir, { recursive: true });
+    (0, import_node_fs5.mkdirSync)(logsDir, { recursive: true });
     return logsDir;
   }
   /** Register a spawned agent in workers.json so `agents:kill` can find it. */
@@ -38644,7 +38964,7 @@ ${preview}
     this.activeWorkers.set(agentName, workerEntry);
     this.workersFileLock = this.workersFileLock.then(() => {
       try {
-        (0, import_node_fs4.mkdirSync)(import_node_path8.default.dirname(this.workersPath), { recursive: true });
+        (0, import_node_fs5.mkdirSync)(import_node_path8.default.dirname(this.workersPath), { recursive: true });
         const existing = this.readWorkers().filter((w) => w.name !== agentName);
         existing.push({ name: agentName, ...workerEntry });
         this.writeWorkers(existing);
@@ -38666,21 +38986,21 @@ ${preview}
   }
   readWorkers() {
     try {
-      if (!(0, import_node_fs4.existsSync)(this.workersPath))
+      if (!(0, import_node_fs5.existsSync)(this.workersPath))
         return [];
-      const raw = JSON.parse((0, import_node_fs4.readFileSync)(this.workersPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs5.readFileSync)(this.workersPath, "utf-8"));
       return Array.isArray(raw?.workers) ? raw.workers : [];
     } catch {
       return [];
     }
   }
   writeWorkers(workers) {
-    (0, import_node_fs4.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
+    (0, import_node_fs5.writeFileSync)(this.workersPath, JSON.stringify({ workers }, null, 2));
   }
 };
 
 // packages/sdk/dist/workflows/file-db.js
-var import_node_fs5 = require("node:fs");
+var import_node_fs6 = require("node:fs");
 var import_node_path9 = __toESM(require("node:path"), 1);
 var JsonFileWorkflowDb = class {
   filePath;
@@ -38690,7 +39010,7 @@ var JsonFileWorkflowDb = class {
     this.filePath = filePath;
     let writable = false;
     try {
-      (0, import_node_fs5.mkdirSync)(import_node_path9.default.dirname(filePath), { recursive: true });
+      (0, import_node_fs6.mkdirSync)(import_node_path9.default.dirname(filePath), { recursive: true });
       writable = true;
     } catch {
     }
@@ -38705,7 +39025,7 @@ var JsonFileWorkflowDb = class {
     if (!this.writable)
       return;
     try {
-      (0, import_node_fs5.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+      (0, import_node_fs6.appendFileSync)(this.filePath, JSON.stringify(entry) + "\n", "utf8");
     } catch {
     }
   }
@@ -38715,7 +39035,7 @@ var JsonFileWorkflowDb = class {
     const steps = /* @__PURE__ */ new Map();
     let raw = "";
     try {
-      raw = (0, import_node_fs5.readFileSync)(this.filePath, "utf8");
+      raw = (0, import_node_fs6.readFileSync)(this.filePath, "utf8");
     } catch {
       return { runs, steps };
     }
@@ -38906,6 +39226,8 @@ var WorkflowBuilder = class {
       def.task = options.task;
     if (options.channels !== void 0)
       def.channels = options.channels;
+    if (options.preset !== void 0)
+      def.preset = options.preset;
     if (options.interactive !== void 0)
       def.interactive = options.interactive;
     if (options.model !== void 0 || options.maxTokens !== void 0 || options.timeoutMs !== void 0 || options.retries !== void 0 || options.idleThresholdSecs !== void 0) {
@@ -38924,21 +39246,29 @@ var WorkflowBuilder = class {
     this._agents.push(def);
     return this;
   }
-  /** Add a workflow step. */
+  /** Add a workflow step (agent or deterministic). */
   step(name, options) {
-    const step = {
-      name,
-      agent: options.agent,
-      task: options.task
-    };
+    const step = { name };
+    if ("type" in options && options.type === "deterministic") {
+      step.type = "deterministic";
+      step.command = options.command;
+      if (options.failOnError !== void 0)
+        step.failOnError = options.failOnError;
+      if (options.captureOutput !== void 0)
+        step.captureOutput = options.captureOutput;
+    } else {
+      const agentOpts = options;
+      step.agent = agentOpts.agent;
+      step.task = agentOpts.task;
+      if (agentOpts.verification !== void 0)
+        step.verification = agentOpts.verification;
+      if (agentOpts.retries !== void 0)
+        step.retries = agentOpts.retries;
+    }
     if (options.dependsOn !== void 0)
       step.dependsOn = options.dependsOn;
-    if (options.verification !== void 0)
-      step.verification = options.verification;
     if (options.timeoutMs !== void 0)
       step.timeoutMs = options.timeoutMs;
-    if (options.retries !== void 0)
-      step.retries = options.retries;
     this._steps.push(step);
     return this;
   }
@@ -38955,8 +39285,9 @@ var WorkflowBuilder = class {
   }
   /** Build and return the RelayYamlConfig object. */
   toConfig() {
-    if (this._agents.length === 0) {
-      throw new Error("Workflow must have at least one agent");
+    const hasAgentSteps = this._steps.some((s) => s.type !== "deterministic" && s.type !== "worktree");
+    if (hasAgentSteps && this._agents.length === 0) {
+      throw new Error("Workflow must have at least one agent when using agent steps");
     }
     if (this._steps.length === 0) {
       throw new Error("Workflow must have at least one step");
@@ -39016,7 +39347,7 @@ function workflow(name) {
 }
 
 // packages/sdk/dist/workflows/coordinator.js
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 var import_node_events3 = require("node:events");
 var PATTERN_HEURISTICS = [
   // ── Dependency-based patterns (highest priority) ──────────────────────
@@ -39371,7 +39702,7 @@ var SwarmCoordinator = class extends import_node_events3.EventEmitter {
   }
   // ── Lifecycle: create run ───────────────────────────────────────────────
   async createRun(workspaceId, config2) {
-    const id = `run_${Date.now()}_${(0, import_node_crypto5.randomBytes)(4).toString("hex")}`;
+    const id = `run_${Date.now()}_${(0, import_node_crypto6.randomBytes)(4).toString("hex")}`;
     const pattern = this.selectPattern(config2);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const { rows } = await this.db.query(`INSERT INTO workflow_runs (id, workspace_id, workflow_name, pattern, status, config, started_at, created_at, updated_at)
@@ -39410,7 +39741,7 @@ var SwarmCoordinator = class extends import_node_events3.EventEmitter {
     const created = [];
     for (const wf of workflows) {
       for (const step of wf.steps) {
-        const id = `step_${Date.now()}_${(0, import_node_crypto5.randomBytes)(4).toString("hex")}`;
+        const id = `step_${Date.now()}_${(0, import_node_crypto6.randomBytes)(4).toString("hex")}`;
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const { rows } = await this.db.query(`INSERT INTO workflow_steps (id, run_id, step_name, agent_name, status, task, depends_on, created_at, updated_at)
            VALUES ($1, $2, $3, $4, 'pending', $5, $6, $7, $7)
@@ -39587,7 +39918,7 @@ var SwarmCoordinator = class extends import_node_events3.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/barrier.js
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_node_events4 = require("node:events");
 var BarrierManager = class extends import_node_events4.EventEmitter {
   db;
@@ -39603,7 +39934,7 @@ var BarrierManager = class extends import_node_events4.EventEmitter {
    * Create a barrier for a workflow run.
    */
   async createBarrier(runId, definition) {
-    const id = `bar_${Date.now()}_${(0, import_node_crypto6.randomBytes)(4).toString("hex")}`;
+    const id = `bar_${Date.now()}_${(0, import_node_crypto7.randomBytes)(4).toString("hex")}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const mode = definition.mode ?? "all";
     const { rows } = await this.db.query(`INSERT INTO workflow_barriers (id, run_id, barrier_name, wait_for, resolved, is_satisfied, timeout_ms, created_at, updated_at)
@@ -39737,7 +40068,7 @@ var BarrierManager = class extends import_node_events4.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/state.js
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var import_node_events5 = require("node:events");
 var StateStore = class extends import_node_events5.EventEmitter {
   db;
@@ -39780,7 +40111,7 @@ var StateStore = class extends import_node_events5.EventEmitter {
     const namespace = options.namespace ?? this.defaultNamespace;
     const ttlMs = options.ttlMs ?? this.defaultTtlMs;
     const expiresAt = ttlMs ? new Date(Date.now() + ttlMs).toISOString() : null;
-    const id = `st_${Date.now()}_${(0, import_node_crypto7.randomBytes)(4).toString("hex")}`;
+    const id = `st_${Date.now()}_${(0, import_node_crypto8.randomBytes)(4).toString("hex")}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const { rows } = await this.db.query(`INSERT INTO swarm_state (id, run_id, namespace, key, value, expires_at, created_at, updated_at)
        VALUES ($1, $2, $3, $4, $5, $6, $7, $7)
@@ -39868,7 +40199,7 @@ var StateStore = class extends import_node_events5.EventEmitter {
 };
 
 // packages/sdk/dist/workflows/templates.js
-var import_node_fs6 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
@@ -39972,9 +40303,9 @@ var TemplateRegistry = class {
       throw new Error(`Invalid template name: "${templateName}" contains path separators or traversal sequences`);
     }
     this.validateRelayConfig(parsed, url2);
-    await import_node_fs6.promises.mkdir(this.customTemplatesDir, { recursive: true });
+    await import_node_fs7.promises.mkdir(this.customTemplatesDir, { recursive: true });
     const targetPath = import_node_path10.default.join(this.customTemplatesDir, `${templateName}.yaml`);
-    await import_node_fs6.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
+    await import_node_fs7.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
     return targetPath;
   }
   isTemplateShorthand(input) {
@@ -40003,7 +40334,7 @@ var TemplateRegistry = class {
       import_node_path10.default.resolve(currentDir, "../workflows/builtin-templates")
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs6.existsSync)(candidate)) {
+      if ((0, import_node_fs7.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -40025,7 +40356,7 @@ var TemplateRegistry = class {
     for (const ext of YAML_EXTENSIONS) {
       const candidate = import_node_path10.default.join(directory, `${templateName}${ext}`);
       try {
-        const stat2 = await import_node_fs6.promises.stat(candidate);
+        const stat2 = await import_node_fs7.promises.stat(candidate);
         if (stat2.isFile()) {
           return candidate;
         }
@@ -40035,7 +40366,7 @@ var TemplateRegistry = class {
     return void 0;
   }
   async readTemplateFile(templatePath) {
-    const raw = await import_node_fs6.promises.readFile(templatePath, "utf-8");
+    const raw = await import_node_fs7.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`);
@@ -40228,7 +40559,7 @@ var TemplateRegistry = class {
   }
   async safeReadDir(directory) {
     try {
-      return await import_node_fs6.promises.readdir(directory);
+      return await import_node_fs7.promises.readdir(directory);
     } catch {
       return [];
     }
@@ -40392,7 +40723,7 @@ function isValidAgentName(name) {
 }
 
 // packages/utils/dist/logger.js
-var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_path11 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
@@ -40412,8 +40743,8 @@ var LEVEL_PRIORITY = {
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
   const logDir = import_node_path11.default.dirname(logFile);
-  if (!createdLogDirs.has(logDir) && !import_node_fs7.default.existsSync(logDir)) {
-    import_node_fs7.default.mkdirSync(logDir, { recursive: true });
+  if (!createdLogDirs.has(logDir) && !import_node_fs8.default.existsSync(logDir)) {
+    import_node_fs8.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
   }
 }
@@ -40442,7 +40773,7 @@ function log(level, component, msg, extra) {
   const logFile = getLogFile();
   if (logFile) {
     ensureLogDir(logFile);
-    import_node_fs7.default.appendFileSync(logFile, formatted + "\n");
+    import_node_fs8.default.appendFileSync(logFile, formatted + "\n");
     return;
   }
   if (level === "ERROR" || level === "WARN") {
@@ -40713,7 +41044,7 @@ function benchmarkPatterns(iterations = 1e4) {
 
 // packages/utils/dist/command-resolver.js
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
@@ -40739,7 +41070,7 @@ function resolveCommand(command) {
 }
 function resolveSymlinks(filePath) {
   try {
-    const resolved = import_node_fs8.default.realpathSync(filePath);
+    const resolved = import_node_fs9.default.realpathSync(filePath);
     if (resolved !== filePath && process.env.DEBUG_SPAWN === "1") {
       console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
     }
@@ -40764,7 +41095,7 @@ function commandExists(command) {
 }
 
 // packages/utils/dist/git-remote.js
-var fs5 = __toESM(require("node:fs"), 1);
+var fs6 = __toESM(require("node:fs"), 1);
 var path11 = __toESM(require("node:path"), 1);
 var import_node_child_process5 = require("node:child_process");
 function parseGitRemoteUrl(url2) {
@@ -40783,7 +41114,7 @@ function parseGitRemoteUrl(url2) {
 function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
   try {
     const gitDir = path11.join(workingDirectory, ".git");
-    if (!fs5.existsSync(gitDir)) {
+    if (!fs6.existsSync(gitDir)) {
       return null;
     }
     const result = (0, import_node_child_process5.execSync)(`git remote get-url ${remoteName}`, {
@@ -40796,10 +41127,10 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
   } catch {
     try {
       const configPath = path11.join(workingDirectory, ".git", "config");
-      if (!fs5.existsSync(configPath)) {
+      if (!fs6.existsSync(configPath)) {
         return null;
       }
-      const config2 = fs5.readFileSync(configPath, "utf-8");
+      const config2 = fs6.readFileSync(configPath, "utf-8");
       const remoteSection = new RegExp(`\\[remote\\s+"${remoteName}"\\][^\\[]*url\\s*=\\s*([^\\n]+)`, "i");
       const match = config2.match(remoteSection);
       return match?.[1]?.trim() || null;
@@ -40819,7 +41150,7 @@ function findGitRoot(startPath) {
   let currentPath = path11.resolve(startPath);
   const root = path11.parse(currentPath).root;
   while (currentPath !== root) {
-    if (fs5.existsSync(path11.join(currentPath, ".git"))) {
+    if (fs6.existsSync(path11.join(currentPath, ".git"))) {
       return currentPath;
     }
     currentPath = path11.dirname(currentPath);
@@ -40839,7 +41170,7 @@ function getRepoFullNameFromPath(workingDirectory) {
 }
 
 // packages/utils/dist/update-checker.js
-var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_path12 = __toESM(require("node:path"), 1);
 var import_node_https = __toESM(require("node:https"), 1);
 var import_node_os4 = __toESM(require("node:os"), 1);
@@ -40854,9 +41185,9 @@ function getCachePath() {
 function readCache() {
   try {
     const cachePath = getCachePath();
-    if (!import_node_fs9.default.existsSync(cachePath))
+    if (!import_node_fs10.default.existsSync(cachePath))
       return null;
-    const data = import_node_fs9.default.readFileSync(cachePath, "utf-8");
+    const data = import_node_fs10.default.readFileSync(cachePath, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -40866,10 +41197,10 @@ function writeCache(cache) {
   try {
     const cachePath = getCachePath();
     const cacheDir = import_node_path12.default.dirname(cachePath);
-    if (!import_node_fs9.default.existsSync(cacheDir)) {
-      import_node_fs9.default.mkdirSync(cacheDir, { recursive: true });
+    if (!import_node_fs10.default.existsSync(cacheDir)) {
+      import_node_fs10.default.mkdirSync(cacheDir, { recursive: true });
     }
-    import_node_fs9.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+    import_node_fs10.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
   } catch {
   }
 }
@@ -40987,10 +41318,10 @@ function checkForUpdatesInBackground(currentVersion) {
 }
 
 // packages/utils/dist/error-tracking.js
-var import_node_crypto8 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 function generateErrorId() {
   const timestamp = Math.floor(Date.now() / 1e3);
-  const random = (0, import_node_crypto8.randomBytes)(2).toString("hex");
+  const random = (0, import_node_crypto9.randomBytes)(2).toString("hex");
   return `ERR-${timestamp}-${random}`;
 }
 function createTraceableError(message, context = {}, originalError) {
@@ -41148,7 +41479,7 @@ function validateModelForCli(cli, model) {
 }
 
 // packages/utils/dist/relay-pty-path.js
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
 var import_node_os5 = __toESM(require("node:os"), 1);
 var import_node_path13 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
@@ -41209,12 +41540,12 @@ function findRelayPtyBinary(callerDirname) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
     const npxCacheBase = import_node_path13.default.join(home, ".npm", "_npx");
-    if (import_node_fs10.default.existsSync(npxCacheBase)) {
+    if (import_node_fs11.default.existsSync(npxCacheBase)) {
       try {
-        const entries = import_node_fs10.default.readdirSync(npxCacheBase);
+        const entries = import_node_fs11.default.readdirSync(npxCacheBase);
         for (const entry of entries) {
           const npxPackage = import_node_path13.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
-          if (import_node_fs10.default.existsSync(npxPackage)) {
+          if (import_node_fs11.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
         }
@@ -41272,7 +41603,7 @@ function findRelayPtyBinary(callerDirname) {
 }
 function isExecutable(filePath) {
   try {
-    import_node_fs10.default.accessSync(filePath, import_node_fs10.default.constants.X_OK);
+    import_node_fs11.default.accessSync(filePath, import_node_fs11.default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -41281,9 +41612,9 @@ function isExecutable(filePath) {
 function isPlatformCompatibleBinary(filePath) {
   let fd;
   try {
-    fd = import_node_fs10.default.openSync(filePath, "r");
+    fd = import_node_fs11.default.openSync(filePath, "r");
     const header = Buffer.alloc(4);
-    const bytesRead = import_node_fs10.default.readSync(fd, header, 0, 4, 0);
+    const bytesRead = import_node_fs11.default.readSync(fd, header, 0, 4, 0);
     if (bytesRead < 4) {
       return false;
     }
@@ -41301,7 +41632,7 @@ function isPlatformCompatibleBinary(filePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        import_node_fs10.default.closeSync(fd);
+        import_node_fs11.default.closeSync(fd);
       } catch {
       }
     }
@@ -41332,7 +41663,7 @@ function clearBinaryCache() {
 
 // packages/utils/dist/client-helpers.js
 var import_node_net = require("node:net");
-var import_node_crypto9 = require("node:crypto");
+var import_node_crypto10 = require("node:crypto");
 
 // packages/utils/dist/legacy-protocol.js
 var PROTOCOL_VERSION2 = 1;
@@ -41459,14 +41790,14 @@ function createRequestHandler(socketPath, envelope, options) {
   });
 }
 function generateRequestId(prefix = "") {
-  return `${prefix}${Date.now().toString(36)}-${(0, import_node_crypto9.randomUUID)().slice(0, 8)}`;
+  return `${prefix}${Date.now().toString(36)}-${(0, import_node_crypto10.randomUUID)().slice(0, 8)}`;
 }
 
 // packages/hooks/dist/types.js
 var HOOK_ABI_VERSION = PROTOCOL_VERSION;
 
 // packages/hooks/dist/registry.js
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 var InMemoryHookMemory = class {
   store = /* @__PURE__ */ new Map();
   get(key) {
@@ -41515,8 +41846,8 @@ var HookRegistry = class {
   injectFn;
   sendFn;
   constructor(options = {}) {
-    this.sessionId = (0, import_node_crypto11.randomUUID)();
-    this.agentId = options.agentId ?? (0, import_node_crypto11.randomUUID)();
+    this.sessionId = (0, import_node_crypto12.randomUUID)();
+    this.agentId = options.agentId ?? (0, import_node_crypto12.randomUUID)();
     this.agentName = options.agentName ?? "agent";
     this.workingDir = options.workingDir ?? process.cwd();
     this.projectId = options.projectId ?? "default";
@@ -41920,9 +42251,9 @@ var HookRegistry = class {
 var import_node_child_process6 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
-var import_node_crypto12 = __toESM(require("node:crypto"), 1);
+var import_node_crypto13 = __toESM(require("node:crypto"), 1);
 var import_node_path14 = __toESM(require("node:path"), 1);
-var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
 var import_node_os6 = __toESM(require("node:os"), 1);
 function getGlobalBaseDir2() {
   if (process.env.AGENT_RELAY_DATA_DIR) {
@@ -41935,13 +42266,13 @@ function getGlobalBaseDir2() {
   return import_node_path14.default.join(import_node_os6.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
-var PROJECT_DATA_DIR = ".agent-relay";
-function hashPath(projectPath) {
+var PROJECT_DATA_DIR2 = ".agent-relay";
+function hashPath2(projectPath) {
   const normalized = import_node_path14.default.resolve(projectPath);
-  const hash2 = import_node_crypto12.default.createHash("sha256").update(normalized).digest("hex");
+  const hash2 = import_node_crypto13.default.createHash("sha256").update(normalized).digest("hex");
   return hash2.substring(0, 12);
 }
-function findProjectRoot(startDir = process.cwd()) {
+function findProjectRoot2(startDir = process.cwd()) {
   if (process.env.AGENT_RELAY_PROJECT) {
     return import_node_path14.default.resolve(process.env.AGENT_RELAY_PROJECT);
   }
@@ -41950,7 +42281,7 @@ function findProjectRoot(startDir = process.cwd()) {
   const markers = [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".agent-relay"];
   while (current !== root) {
     for (const marker of markers) {
-      if (import_node_fs11.default.existsSync(import_node_path14.default.join(current, marker))) {
+      if (import_node_fs12.default.existsSync(import_node_path14.default.join(current, marker))) {
         return current;
       }
     }
@@ -41959,9 +42290,9 @@ function findProjectRoot(startDir = process.cwd()) {
   return import_node_path14.default.resolve(startDir);
 }
 function getProjectPaths2(projectRoot) {
-  const root = projectRoot ?? findProjectRoot();
-  const projectId = hashPath(root);
-  const dataDir = import_node_path14.default.join(root, PROJECT_DATA_DIR);
+  const root = projectRoot ?? findProjectRoot2();
+  const projectId = hashPath2(root);
+  const dataDir = import_node_path14.default.join(root, PROJECT_DATA_DIR2);
   return {
     dataDir,
     teamDir: import_node_path14.default.join(dataDir, "team"),
@@ -41973,10 +42304,10 @@ function getProjectPaths2(projectRoot) {
 }
 
 // packages/config/dist/trajectory-config.js
-var import_node_fs12 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_node_path15 = require("node:path");
 var import_node_os7 = require("node:os");
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 function getAgentRelayConfigDir() {
   return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path15.join)((0, import_node_os7.homedir)(), ".config", "agent-relay");
 }
@@ -41988,7 +42319,7 @@ function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
   if (configCache && configCache.path === configPath) {
     try {
-      const stat2 = (0, import_node_fs12.statSync)(configPath);
+      const stat2 = (0, import_node_fs13.statSync)(configPath);
       if (stat2.mtimeMs === configCache.mtime) {
         return configCache.config;
       }
@@ -41996,13 +42327,13 @@ function readRelayConfig(projectRoot) {
     }
   }
   try {
-    if (!(0, import_node_fs12.existsSync)(configPath)) {
+    if (!(0, import_node_fs13.existsSync)(configPath)) {
       return {};
     }
-    const content = (0, import_node_fs12.readFileSync)(configPath, "utf-8");
+    const content = (0, import_node_fs13.readFileSync)(configPath, "utf-8");
     const config2 = JSON.parse(content);
     try {
-      const stat2 = (0, import_node_fs12.statSync)(configPath);
+      const stat2 = (0, import_node_fs13.statSync)(configPath);
       configCache = { path: configPath, config: config2, mtime: stat2.mtimeMs };
     } catch {
     }
@@ -42018,7 +42349,7 @@ function shouldStoreInRepo(projectRoot) {
 }
 function getProjectHash(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_crypto13.createHash)("sha256").update(root).digest("hex").slice(0, 16);
+  return (0, import_node_crypto14.createHash)("sha256").update(root).digest("hex").slice(0, 16);
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
@@ -42667,7 +42998,7 @@ var HookEmitter = class {
 };
 
 // packages/hooks/dist/inbox-check/utils.js
-var import_node_fs13 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_path16 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
@@ -42681,13 +43012,13 @@ function getInboxPath(config2) {
   return (0, import_node_path16.join)(config2.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
-  return (0, import_node_fs13.existsSync)(inboxPath);
+  return (0, import_node_fs14.existsSync)(inboxPath);
 }
 function readInbox(inboxPath) {
   if (!inboxExists(inboxPath)) {
     return "";
   }
-  return (0, import_node_fs13.readFileSync)(inboxPath, "utf-8");
+  return (0, import_node_fs14.readFileSync)(inboxPath, "utf-8");
 }
 function hasUnreadMessages(inboxPath) {
   const content = readInbox(inboxPath);
@@ -42774,6 +43105,7 @@ init_dist();
   HOOK_ABI_VERSION,
   HookEmitter,
   HookRegistry,
+  HttpAgentRelayClient,
   InMemoryAdapter,
   InMemoryWorkflowDb,
   JsonFileWorkflowDb,