agent-relay 3.2.2 → 3.2.4

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,99 +14929,930 @@ 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
+// packages/sdk/node_modules/@relaycast/sdk/dist/version.js
 var SDK_VERSION = "0.4.2";
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/external.js
+// packages/sdk/node_modules/zod/v4/classic/external.js
 var external_exports2 = {};
 __export(external_exports2, {
   $brand: () => $brand,
@@ -15834,7 +16093,7 @@ __export(external_exports2, {
   xor: () => xor
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/index.js
+// packages/sdk/node_modules/zod/v4/core/index.js
 var core_exports2 = {};
 __export(core_exports2, {
   $ZodAny: () => $ZodAny,
@@ -16112,7 +16371,7 @@ __export(core_exports2, {
   version: () => version
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/core.js
+// packages/sdk/node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
   status: "aborted"
 });
@@ -16187,7 +16446,7 @@ function config(newConfig) {
   return globalConfig;
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/util.js
+// packages/sdk/node_modules/zod/v4/core/util.js
 var util_exports = {};
 __export(util_exports, {
   BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
@@ -16866,7 +17125,7 @@ var Class = class {
   }
 };
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/errors.js
+// packages/sdk/node_modules/zod/v4/core/errors.js
 var initializer = (inst, def) => {
   inst.name = "$ZodError";
   Object.defineProperty(inst, "_zod", {
@@ -17002,7 +17261,7 @@ function prettifyError(error48) {
   return lines.join("\n");
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/parse.js
+// packages/sdk/node_modules/zod/v4/core/parse.js
 var _parse = (_Err) => (schema, value, _ctx, _params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx);
@@ -17090,7 +17349,7 @@ var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 };
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/regexes.js
+// packages/sdk/node_modules/zod/v4/core/regexes.js
 var regexes_exports = {};
 __export(regexes_exports, {
   base64: () => base64,
@@ -17247,7 +17506,7 @@ var sha512_hex = /^[0-9a-fA-F]{128}$/;
 var sha512_base64 = /* @__PURE__ */ fixedBase64(86, "==");
 var sha512_base64url = /* @__PURE__ */ fixedBase64url(86);
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/checks.js
+// packages/sdk/node_modules/zod/v4/core/checks.js
 var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
   var _a2;
   inst._zod ?? (inst._zod = {});
@@ -17795,7 +18054,7 @@ var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (ins
   };
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/doc.js
+// packages/sdk/node_modules/zod/v4/core/doc.js
 var Doc = class {
   constructor(args = []) {
     this.content = [];
@@ -17831,14 +18090,14 @@ var Doc = class {
   }
 };
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/versions.js
+// packages/sdk/node_modules/zod/v4/core/versions.js
 var version = {
   major: 4,
   minor: 3,
   patch: 6
 };
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/schemas.js
+// packages/sdk/node_modules/zod/v4/core/schemas.js
 var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   var _a2;
   inst ?? (inst = {});
@@ -19809,7 +20068,7 @@ function handleRefineResult(result, payload, input, inst) {
   }
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/index.js
+// packages/sdk/node_modules/zod/v4/locales/index.js
 var locales_exports = {};
 __export(locales_exports, {
   ar: () => ar_default,
@@ -19863,7 +20122,7 @@ __export(locales_exports, {
   zhTW: () => zh_TW_default
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ar.js
+// packages/sdk/node_modules/zod/v4/locales/ar.js
 var error = () => {
   const Sizable = {
     string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
@@ -19970,7 +20229,7 @@ function ar_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/az.js
+// packages/sdk/node_modules/zod/v4/locales/az.js
 var error2 = () => {
   const Sizable = {
     string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
@@ -20076,7 +20335,7 @@ function az_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/be.js
+// packages/sdk/node_modules/zod/v4/locales/be.js
 function getBelarusianPlural(count, one, few, many) {
   const absCount = Math.abs(count);
   const lastDigit = absCount % 10;
@@ -20233,7 +20492,7 @@ function be_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/bg.js
+// packages/sdk/node_modules/zod/v4/locales/bg.js
 var error4 = () => {
   const Sizable = {
     string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
@@ -20354,7 +20613,7 @@ function bg_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ca.js
+// packages/sdk/node_modules/zod/v4/locales/ca.js
 var error5 = () => {
   const Sizable = {
     string: { unit: "car\xE0cters", verb: "contenir" },
@@ -20463,7 +20722,7 @@ function ca_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/cs.js
+// packages/sdk/node_modules/zod/v4/locales/cs.js
 var error6 = () => {
   const Sizable = {
     string: { unit: "znak\u016F", verb: "m\xEDt" },
@@ -20575,7 +20834,7 @@ function cs_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/da.js
+// packages/sdk/node_modules/zod/v4/locales/da.js
 var error7 = () => {
   const Sizable = {
     string: { unit: "tegn", verb: "havde" },
@@ -20691,7 +20950,7 @@ function da_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/de.js
+// packages/sdk/node_modules/zod/v4/locales/de.js
 var error8 = () => {
   const Sizable = {
     string: { unit: "Zeichen", verb: "zu haben" },
@@ -20800,7 +21059,7 @@ function de_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/en.js
+// packages/sdk/node_modules/zod/v4/locales/en.js
 var error9 = () => {
   const Sizable = {
     string: { unit: "characters", verb: "to have" },
@@ -20909,7 +21168,7 @@ function en_default2() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/eo.js
+// packages/sdk/node_modules/zod/v4/locales/eo.js
 var error10 = () => {
   const Sizable = {
     string: { unit: "karaktrojn", verb: "havi" },
@@ -21019,7 +21278,7 @@ function eo_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/es.js
+// packages/sdk/node_modules/zod/v4/locales/es.js
 var error11 = () => {
   const Sizable = {
     string: { unit: "caracteres", verb: "tener" },
@@ -21152,7 +21411,7 @@ function es_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/fa.js
+// packages/sdk/node_modules/zod/v4/locales/fa.js
 var error12 = () => {
   const Sizable = {
     string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
@@ -21267,7 +21526,7 @@ function fa_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/fi.js
+// packages/sdk/node_modules/zod/v4/locales/fi.js
 var error13 = () => {
   const Sizable = {
     string: { unit: "merkki\xE4", subject: "merkkijonon" },
@@ -21380,7 +21639,7 @@ function fi_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/fr.js
+// packages/sdk/node_modules/zod/v4/locales/fr.js
 var error14 = () => {
   const Sizable = {
     string: { unit: "caract\xE8res", verb: "avoir" },
@@ -21489,7 +21748,7 @@ function fr_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/fr-CA.js
+// packages/sdk/node_modules/zod/v4/locales/fr-CA.js
 var error15 = () => {
   const Sizable = {
     string: { unit: "caract\xE8res", verb: "avoir" },
@@ -21597,7 +21856,7 @@ function fr_CA_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/he.js
+// packages/sdk/node_modules/zod/v4/locales/he.js
 var error16 = () => {
   const TypeNames = {
     string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
@@ -21792,7 +22051,7 @@ function he_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/hu.js
+// packages/sdk/node_modules/zod/v4/locales/hu.js
 var error17 = () => {
   const Sizable = {
     string: { unit: "karakter", verb: "legyen" },
@@ -21901,7 +22160,7 @@ function hu_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/hy.js
+// packages/sdk/node_modules/zod/v4/locales/hy.js
 function getArmenianPlural(count, one, many) {
   return Math.abs(count) === 1 ? one : many;
 }
@@ -22049,7 +22308,7 @@ function hy_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/id.js
+// packages/sdk/node_modules/zod/v4/locales/id.js
 var error19 = () => {
   const Sizable = {
     string: { unit: "karakter", verb: "memiliki" },
@@ -22156,7 +22415,7 @@ function id_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/is.js
+// packages/sdk/node_modules/zod/v4/locales/is.js
 var error20 = () => {
   const Sizable = {
     string: { unit: "stafi", verb: "a\xF0 hafa" },
@@ -22266,7 +22525,7 @@ function is_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/it.js
+// packages/sdk/node_modules/zod/v4/locales/it.js
 var error21 = () => {
   const Sizable = {
     string: { unit: "caratteri", verb: "avere" },
@@ -22375,7 +22634,7 @@ function it_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ja.js
+// packages/sdk/node_modules/zod/v4/locales/ja.js
 var error22 = () => {
   const Sizable = {
     string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
@@ -22483,7 +22742,7 @@ function ja_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ka.js
+// packages/sdk/node_modules/zod/v4/locales/ka.js
 var error23 = () => {
   const Sizable = {
     string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
@@ -22596,7 +22855,7 @@ function ka_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/km.js
+// packages/sdk/node_modules/zod/v4/locales/km.js
 var error24 = () => {
   const Sizable = {
     string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
@@ -22707,12 +22966,12 @@ function km_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/kh.js
+// packages/sdk/node_modules/zod/v4/locales/kh.js
 function kh_default() {
   return km_default();
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ko.js
+// packages/sdk/node_modules/zod/v4/locales/ko.js
 var error25 = () => {
   const Sizable = {
     string: { unit: "\uBB38\uC790", verb: "to have" },
@@ -22824,7 +23083,7 @@ function ko_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/lt.js
+// packages/sdk/node_modules/zod/v4/locales/lt.js
 var capitalizeFirstCharacter = (text) => {
   return text.charAt(0).toUpperCase() + text.slice(1);
 };
@@ -23028,7 +23287,7 @@ function lt_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/mk.js
+// packages/sdk/node_modules/zod/v4/locales/mk.js
 var error27 = () => {
   const Sizable = {
     string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
@@ -23138,7 +23397,7 @@ function mk_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ms.js
+// packages/sdk/node_modules/zod/v4/locales/ms.js
 var error28 = () => {
   const Sizable = {
     string: { unit: "aksara", verb: "mempunyai" },
@@ -23246,7 +23505,7 @@ function ms_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/nl.js
+// packages/sdk/node_modules/zod/v4/locales/nl.js
 var error29 = () => {
   const Sizable = {
     string: { unit: "tekens", verb: "heeft" },
@@ -23357,7 +23616,7 @@ function nl_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/no.js
+// packages/sdk/node_modules/zod/v4/locales/no.js
 var error30 = () => {
   const Sizable = {
     string: { unit: "tegn", verb: "\xE5 ha" },
@@ -23466,7 +23725,7 @@ function no_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ota.js
+// packages/sdk/node_modules/zod/v4/locales/ota.js
 var error31 = () => {
   const Sizable = {
     string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
@@ -23576,7 +23835,7 @@ function ota_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ps.js
+// packages/sdk/node_modules/zod/v4/locales/ps.js
 var error32 = () => {
   const Sizable = {
     string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
@@ -23691,7 +23950,7 @@ function ps_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/pl.js
+// packages/sdk/node_modules/zod/v4/locales/pl.js
 var error33 = () => {
   const Sizable = {
     string: { unit: "znak\xF3w", verb: "mie\u0107" },
@@ -23801,7 +24060,7 @@ function pl_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/pt.js
+// packages/sdk/node_modules/zod/v4/locales/pt.js
 var error34 = () => {
   const Sizable = {
     string: { unit: "caracteres", verb: "ter" },
@@ -23910,7 +24169,7 @@ function pt_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ru.js
+// packages/sdk/node_modules/zod/v4/locales/ru.js
 function getRussianPlural(count, one, few, many) {
   const absCount = Math.abs(count);
   const lastDigit = absCount % 10;
@@ -24067,7 +24326,7 @@ function ru_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/sl.js
+// packages/sdk/node_modules/zod/v4/locales/sl.js
 var error36 = () => {
   const Sizable = {
     string: { unit: "znakov", verb: "imeti" },
@@ -24177,7 +24436,7 @@ function sl_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/sv.js
+// packages/sdk/node_modules/zod/v4/locales/sv.js
 var error37 = () => {
   const Sizable = {
     string: { unit: "tecken", verb: "att ha" },
@@ -24288,7 +24547,7 @@ function sv_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ta.js
+// packages/sdk/node_modules/zod/v4/locales/ta.js
 var error38 = () => {
   const Sizable = {
     string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
@@ -24399,7 +24658,7 @@ function ta_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/th.js
+// packages/sdk/node_modules/zod/v4/locales/th.js
 var error39 = () => {
   const Sizable = {
     string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -24510,7 +24769,7 @@ function th_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/tr.js
+// packages/sdk/node_modules/zod/v4/locales/tr.js
 var error40 = () => {
   const Sizable = {
     string: { unit: "karakter", verb: "olmal\u0131" },
@@ -24616,7 +24875,7 @@ function tr_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/uk.js
+// packages/sdk/node_modules/zod/v4/locales/uk.js
 var error41 = () => {
   const Sizable = {
     string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -24725,12 +24984,12 @@ function uk_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ua.js
+// packages/sdk/node_modules/zod/v4/locales/ua.js
 function ua_default() {
   return uk_default();
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/ur.js
+// packages/sdk/node_modules/zod/v4/locales/ur.js
 var error42 = () => {
   const Sizable = {
     string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
@@ -24841,7 +25100,7 @@ function ur_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/uz.js
+// packages/sdk/node_modules/zod/v4/locales/uz.js
 var error43 = () => {
   const Sizable = {
     string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
@@ -24951,7 +25210,7 @@ function uz_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/vi.js
+// packages/sdk/node_modules/zod/v4/locales/vi.js
 var error44 = () => {
   const Sizable = {
     string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
@@ -25060,7 +25319,7 @@ function vi_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/zh-CN.js
+// packages/sdk/node_modules/zod/v4/locales/zh-CN.js
 var error45 = () => {
   const Sizable = {
     string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
@@ -25170,7 +25429,7 @@ function zh_CN_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/zh-TW.js
+// packages/sdk/node_modules/zod/v4/locales/zh-TW.js
 var error46 = () => {
   const Sizable = {
     string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
@@ -25278,7 +25537,7 @@ function zh_TW_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/locales/yo.js
+// packages/sdk/node_modules/zod/v4/locales/yo.js
 var error47 = () => {
   const Sizable = {
     string: { unit: "\xE0mi", verb: "n\xED" },
@@ -25386,7 +25645,7 @@ function yo_default() {
   };
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/registries.js
+// packages/sdk/node_modules/zod/v4/core/registries.js
 var _a;
 var $output = /* @__PURE__ */ Symbol("ZodOutput");
 var $input = /* @__PURE__ */ Symbol("ZodInput");
@@ -25436,7 +25695,7 @@ function registry() {
 (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
 var globalRegistry = globalThis.__zod_globalRegistry;
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/api.js
+// packages/sdk/node_modules/zod/v4/core/api.js
 // @__NO_SIDE_EFFECTS__
 function _string(Class2, params) {
   return new Class2({
@@ -26475,7 +26734,7 @@ function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
   return inst;
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/to-json-schema.js
+// packages/sdk/node_modules/zod/v4/core/to-json-schema.js
 function initializeContext(params) {
   let target = params?.target ?? "draft-2020-12";
   if (target === "draft-4")
@@ -26827,7 +27086,7 @@ var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) =
   return finalize(ctx, schema);
 };
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/json-schema-processors.js
+// packages/sdk/node_modules/zod/v4/core/json-schema-processors.js
 var formatMap = {
   guid: "uuid",
   url: "uri",
@@ -27378,7 +27637,7 @@ function toJSONSchema(input, params) {
   return finalize(ctx, input);
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/json-schema-generator.js
+// packages/sdk/node_modules/zod/v4/core/json-schema-generator.js
 var JSONSchemaGenerator = class {
   /** @deprecated Access via ctx instead */
   get metadataRegistry() {
@@ -27453,10 +27712,10 @@ var JSONSchemaGenerator = class {
   }
 };
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/core/json-schema.js
+// packages/sdk/node_modules/zod/v4/core/json-schema.js
 var json_schema_exports = {};
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/schemas.js
+// packages/sdk/node_modules/zod/v4/classic/schemas.js
 var schemas_exports2 = {};
 __export(schemas_exports2, {
   ZodAny: () => ZodAny2,
@@ -27625,7 +27884,7 @@ __export(schemas_exports2, {
   xor: () => xor
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/checks.js
+// packages/sdk/node_modules/zod/v4/classic/checks.js
 var checks_exports2 = {};
 __export(checks_exports2, {
   endsWith: () => _endsWith,
@@ -27659,7 +27918,7 @@ __export(checks_exports2, {
   uppercase: () => _uppercase
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/iso.js
+// packages/sdk/node_modules/zod/v4/classic/iso.js
 var iso_exports = {};
 __export(iso_exports, {
   ZodISODate: () => ZodISODate,
@@ -27700,7 +27959,7 @@ function duration2(params) {
   return _isoDuration(ZodISODuration, params);
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/errors.js
+// packages/sdk/node_modules/zod/v4/classic/errors.js
 var initializer2 = (inst, issues) => {
   $ZodError.init(inst, issues);
   inst.name = "ZodError";
@@ -27740,7 +27999,7 @@ var ZodRealError = $constructor("ZodError", initializer2, {
   Parent: Error
 });
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/parse.js
+// packages/sdk/node_modules/zod/v4/classic/parse.js
 var parse2 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -27754,7 +28013,7 @@ var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError);
 var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/schemas.js
+// packages/sdk/node_modules/zod/v4/classic/schemas.js
 var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   $ZodType.init(inst, def);
   Object.assign(inst["~standard"], {
@@ -28833,7 +29092,7 @@ function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/compat.js
+// packages/sdk/node_modules/zod/v4/classic/compat.js
 var ZodIssueCode2 = {
   invalid_type: "invalid_type",
   too_big: "too_big",
@@ -28859,7 +29118,7 @@ var ZodFirstPartyTypeKind2;
 /* @__PURE__ */ (function(ZodFirstPartyTypeKind3) {
 })(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/from-json-schema.js
+// packages/sdk/node_modules/zod/v4/classic/from-json-schema.js
 var z = {
   ...schemas_exports2,
   ...checks_exports2,
@@ -29333,7 +29592,7 @@ function fromJSONSchema(schema, params) {
   return convertSchema(schema, ctx);
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/coerce.js
+// packages/sdk/node_modules/zod/v4/classic/coerce.js
 var coerce_exports = {};
 __export(coerce_exports, {
   bigint: () => bigint3,
@@ -29358,10 +29617,10 @@ function date4(params) {
   return _coercedDate(ZodDate2, params);
 }
 
-// node_modules/@relaycast/sdk/node_modules/zod/v4/classic/external.js
+// packages/sdk/node_modules/zod/v4/classic/external.js
 config(en_default2());
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/workspace.js
+// packages/sdk/node_modules/@relaycast/types/dist/workspace.js
 var WorkspaceSchema = external_exports2.object({
   id: external_exports2.string(),
   name: external_exports2.string(),
@@ -29416,7 +29675,7 @@ var TokenRotateResponseSchema = external_exports2.object({
   token: external_exports2.string()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/agent.js
+// packages/sdk/node_modules/@relaycast/types/dist/agent.js
 var AgentTypeSchema = external_exports2.enum(["agent", "human", "system"]);
 var AgentStatusSchema = external_exports2.enum(["online", "offline", "away"]);
 var AgentSchema = external_exports2.object({
@@ -29493,7 +29752,7 @@ var ReleaseAgentResponseSchema = external_exports2.object({
   reason: external_exports2.string().nullable()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/channel.js
+// packages/sdk/node_modules/@relaycast/types/dist/channel.js
 var ChannelMemberInfoSchema = external_exports2.object({
   agent_id: external_exports2.string(),
   agent_name: external_exports2.string(),
@@ -29540,7 +29799,7 @@ var InviteChannelResponseSchema = external_exports2.object({
   agent: external_exports2.string()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/file.js
+// packages/sdk/node_modules/@relaycast/types/dist/file.js
 var FileStatusSchema = external_exports2.enum(["pending", "complete", "deleted"]);
 var FileRecordSchema = external_exports2.object({
   id: external_exports2.string(),
@@ -29587,7 +29846,7 @@ var CompleteUploadResponseSchema = external_exports2.object({
   download_url: external_exports2.string()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/reaction.js
+// packages/sdk/node_modules/@relaycast/types/dist/reaction.js
 var ReactionSchema = external_exports2.object({
   id: external_exports2.string(),
   message_id: external_exports2.string(),
@@ -29611,7 +29870,7 @@ var ReactionGroupSchema = external_exports2.object({
   agents: external_exports2.array(external_exports2.string())
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/message.js
+// packages/sdk/node_modules/@relaycast/types/dist/message.js
 var HeaderBlockSchema = external_exports2.object({
   type: external_exports2.literal("header"),
   text: external_exports2.string()
@@ -29701,7 +29960,7 @@ var SearchMessageResultSchema = external_exports2.object({
   relevance_score: external_exports2.number()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/receipt.js
+// packages/sdk/node_modules/@relaycast/types/dist/receipt.js
 var ReadReceiptSchema = external_exports2.object({
   message_id: external_exports2.string(),
   agent_id: external_exports2.string(),
@@ -29718,7 +29977,7 @@ var ChannelReadStatusSchema = external_exports2.object({
   last_read_at: external_exports2.string().nullable()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/dm.js
+// packages/sdk/node_modules/@relaycast/types/dist/dm.js
 var DmTypeSchema = external_exports2.enum(["1:1", "group"]);
 var DmConversationSchema = external_exports2.object({
   id: external_exports2.string(),
@@ -29790,7 +30049,7 @@ var GroupDmParticipantResponseSchema = external_exports2.object({
   already_member: external_exports2.boolean()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/events.js
+// packages/sdk/node_modules/@relaycast/types/dist/events.js
 var SubscribeEventSchema = external_exports2.object({
   type: external_exports2.literal("subscribe"),
   channels: external_exports2.array(external_exports2.string())
@@ -30001,7 +30260,7 @@ var WsClientEventSchema = external_exports2.discriminatedUnion("type", [
   WsCloseEventSchema
 ]);
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/api.js
+// packages/sdk/node_modules/@relaycast/types/dist/api.js
 var ApiErrorSchema = external_exports2.object({
   ok: external_exports2.literal(false),
   error: external_exports2.object({
@@ -30027,7 +30286,7 @@ var InboxResponseSchema = external_exports2.object({
   }))
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/webhook.js
+// packages/sdk/node_modules/@relaycast/types/dist/webhook.js
 var WebhookSchema = external_exports2.object({
   id: external_exports2.string(),
   name: external_exports2.string(),
@@ -30061,7 +30320,7 @@ var WebhookTriggerResponseSchema = external_exports2.object({
   created_at: external_exports2.string()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/subscription.js
+// packages/sdk/node_modules/@relaycast/types/dist/subscription.js
 var SubscribableEventTypeSchema = external_exports2.enum([
   "message.created",
   "message.updated",
@@ -30109,7 +30368,7 @@ var CreateSubscriptionResponseSchema = external_exports2.object({
   created_at: external_exports2.string()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/command.js
+// packages/sdk/node_modules/@relaycast/types/dist/command.js
 var CommandParameterSchema = external_exports2.object({
   name: external_exports2.string(),
   description: external_exports2.string().optional(),
@@ -30156,7 +30415,7 @@ var CommandInvocationSchema = external_exports2.object({
   created_at: external_exports2.string()
 });
 
-// node_modules/@relaycast/sdk/node_modules/@relaycast/types/dist/telemetry.js
+// packages/sdk/node_modules/@relaycast/types/dist/telemetry.js
 var TELEMETRY_MAX_PROPERTIES = 64;
 var TELEMETRY_VALUE_MAX_LENGTH = 512;
 var telemetryString = (max) => external_exports2.string().trim().min(1).max(max);
@@ -30259,14 +30518,14 @@ var internalTelemetryEventSchema = telemetryEnvelopeBaseSchema.extend({
   event: telemetryEventSchema
 }).merge(telemetryOriginSchema);
 
-// node_modules/@relaycast/sdk/dist/origin.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/origin.js
 var SDK_ORIGIN = Object.freeze({
   surface: "sdk",
   client: "@relaycast/sdk",
   version: SDK_VERSION
 });
 
-// node_modules/@relaycast/sdk/dist/casing.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/casing.js
 function isPlainObject2(value) {
   if (Object.prototype.toString.call(value) !== "[object Object]")
     return false;
@@ -30309,7 +30568,7 @@ function decamelizeKey(key) {
   return toSnakeKey(key);
 }
 
-// node_modules/@relaycast/sdk/dist/ws.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/ws.js
 var INTERNAL_WS_ORIGIN = /* @__PURE__ */ Symbol("relaycast.internal.ws-origin");
 function readInternalWsOrigin(options) {
   return options[INTERNAL_WS_ORIGIN];
@@ -30573,7 +30832,7 @@ var WsClient = class {
   }
 };
 
-// node_modules/@relaycast/sdk/dist/agent.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/agent.js
 function stripHash(channel) {
   return channel.startsWith("#") ? channel.slice(1) : channel;
 }
@@ -30882,7 +31141,7 @@ var AgentClient = class {
   };
 };
 
-// node_modules/@relaycast/sdk/dist/errors.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/errors.js
 var RAW_CODE_MAP = {
   name_conflict: "name_conflict",
   agent_already_exists: "name_conflict",
@@ -30941,7 +31200,7 @@ function relayErrorFromApi(rawCode, message, statusCode) {
   return new RelayError(code, message, { statusCode, rawCode });
 }
 
-// node_modules/@relaycast/sdk/dist/client.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/client.js
 var INTERNAL_ORIGIN = /* @__PURE__ */ Symbol("relaycast.internal.origin");
 function readInternalOrigin(options) {
   return options[INTERNAL_ORIGIN];
@@ -31136,7 +31395,7 @@ var HttpClient = class _HttpClient {
   }
 };
 
-// node_modules/@relaycast/sdk/dist/identity.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/identity.js
 var COMPAT_EVENT_NAME = "relaycast.compatibility";
 var emittedCompatibilityEvents = /* @__PURE__ */ new Set();
 function emitCompatibilityTelemetry(event, metadata = {}) {
@@ -31159,7 +31418,7 @@ function isNameConflictError(err) {
   return err instanceof RelayError && err.code === "name_conflict";
 }
 
-// node_modules/@relaycast/sdk/dist/relay.js
+// packages/sdk/node_modules/@relaycast/sdk/dist/relay.js
 var RelayCast = class {
   client;
   identityHint = null;
@@ -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 = {
@@ -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 {
@@ -34475,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 {
@@ -34809,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;
       }
@@ -34828,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 });
@@ -34837,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;
@@ -34958,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",
@@ -35022,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 {
@@ -35239,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`);
           }
         }
@@ -35560,7 +35819,7 @@ ${err.suggestion}`);
   }
   // ── Execution ───────────────────────────────────────────────────────────
   /** Execute a named workflow from a validated config. */
-  async execute(config2, workflowName, vars) {
+  async execute(config2, workflowName, vars, executeOptions) {
     this.abortController = new AbortController();
     this.paused = false;
     const resolved = vars ? this.resolveVariables(config2, vars) : config2;
@@ -35617,6 +35876,37 @@ ${err.suggestion}`);
       await this.db.insertStep(stepRow);
       stepStates.set(step.name, { row: stepRow });
     }
+    if (executeOptions?.startFrom) {
+      const startFromName = executeOptions.startFrom;
+      const stepNames = new Set(resolvedWorkflow.steps.map((s) => s.name));
+      if (!stepNames.has(startFromName)) {
+        throw new Error(`startFrom step "${startFromName}" not found in workflow. Available steps: ${[...stepNames].join(", ")}`);
+      }
+      const transitiveDeps = this.collectTransitiveDeps(startFromName, resolvedWorkflow.steps);
+      const skippedCount = transitiveDeps.size;
+      const cacheRunId = executeOptions.previousRunId ?? this.findMostRecentRunWithSteps(transitiveDeps);
+      for (const depName of transitiveDeps) {
+        const state = stepStates.get(depName);
+        if (!state)
+          continue;
+        const cachedOutput = cacheRunId ? this.loadStepOutput(cacheRunId, depName) : void 0;
+        if (!cachedOutput) {
+          this.log(`[startFrom] No cached output for skipped step "${depName}" \u2014 using empty string`);
+        }
+        state.row.status = "completed";
+        state.row.output = cachedOutput ?? "";
+        state.row.completedAt = now;
+        await this.db.updateStep(state.row.id, {
+          status: "completed",
+          output: state.row.output,
+          completedAt: now,
+          updatedAt: now
+        });
+      }
+      if (skippedCount > 0) {
+        this.log(`[startFrom] Skipping ${skippedCount} steps, starting from "${startFromName}"`);
+      }
+    }
     return this.runWorkflowCore({
       run,
       workflow: resolvedWorkflow,
@@ -37672,7 +37962,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) {
@@ -37808,7 +38098,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);
@@ -37850,11 +38140,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) {
@@ -37959,7 +38249,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 }, {
@@ -38210,7 +38500,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;
@@ -38304,6 +38594,33 @@ DO NOT:
       }
     }
   }
+  // ── startFrom dependency resolution ─────────────────────────────────
+  /**
+   * Walk the dependsOn graph backwards from a target step to collect ALL
+   * transitive dependencies (i.e. every step that must complete before
+   * the target step can run). The target step itself is NOT included.
+   */
+  collectTransitiveDeps(targetStep, steps) {
+    const stepMap = /* @__PURE__ */ new Map();
+    for (const s of steps)
+      stepMap.set(s.name, s);
+    const deps = /* @__PURE__ */ new Set();
+    const queue = [...stepMap.get(targetStep)?.dependsOn ?? []];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (deps.has(current))
+        continue;
+      deps.add(current);
+      const step = stepMap.get(current);
+      if (step?.dependsOn) {
+        for (const dep of step.dependsOn) {
+          if (!deps.has(dep))
+            queue.push(dep);
+        }
+      }
+    }
+    return deps;
+  }
   // ── Control flow helpers ──────────────────────────────────────────────
   checkAborted() {
     if (this.abortController?.signal.aborted) {
@@ -38549,10 +38866,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) {
@@ -38653,7 +38970,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 {
@@ -38675,13 +38992,42 @@ ${excerpt}` : "";
 ${preview}
 \`\`\``, { stepName });
   }
+  /** Scan .agent-relay/step-outputs/ for the most recent run directory containing the needed steps. */
+  findMostRecentRunWithSteps(stepNames) {
+    try {
+      const baseDir = import_node_path8.default.join(this.cwd, ".agent-relay", "step-outputs");
+      if (!(0, import_node_fs5.existsSync)(baseDir))
+        return void 0;
+      const entries = (0, import_node_fs5.readdirSync)(baseDir);
+      let best;
+      for (const entry of entries) {
+        const dirPath = import_node_path8.default.join(baseDir, entry);
+        try {
+          const stat2 = (0, import_node_fs5.statSync)(dirPath);
+          if (!stat2.isDirectory())
+            continue;
+          const hasAny = [...stepNames].some((name) => (0, import_node_fs5.existsSync)(import_node_path8.default.join(dirPath, `${name}.md`)));
+          if (!hasAny)
+            continue;
+          if (!best || stat2.mtimeMs > best.mtime) {
+            best = { name: entry, mtime: stat2.mtimeMs };
+          }
+        } catch {
+          continue;
+        }
+      }
+      return best?.name;
+    } catch {
+      return void 0;
+    }
+  }
   /** Load persisted step output from disk. */
   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;
     }
@@ -38689,7 +39035,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. */
@@ -38705,7 +39051,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);
@@ -38727,21 +39073,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;
@@ -38751,7 +39097,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 {
     }
@@ -38766,7 +39112,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 {
     }
   }
@@ -38776,7 +39122,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 };
     }
@@ -38922,6 +39268,11 @@ var WorkflowBuilder = class {
   _agents = [];
   _steps = [];
   _errorHandling;
+  _coordination;
+  _state;
+  _trajectories;
+  _startFrom;
+  _previousRunId;
   constructor(name) {
     this._name = name;
   }
@@ -38955,6 +39306,31 @@ var WorkflowBuilder = class {
     this._idleNudge = config2;
     return this;
   }
+  /** Set workflow coordination settings (barriers, voting threshold, consensus strategy). */
+  coordination(config2) {
+    this._coordination = config2;
+    return this;
+  }
+  /** Configure shared workflow state backend settings. */
+  state(config2) {
+    this._state = config2;
+    return this;
+  }
+  /** Configure trajectory recording, or pass `false` to disable it. */
+  trajectories(config2) {
+    this._trajectories = config2;
+    return this;
+  }
+  /** Start execution from a specific step, skipping all predecessor steps. */
+  startFrom(stepName) {
+    this._startFrom = stepName;
+    return this;
+  }
+  /** Set the previous run ID whose cached step outputs should be used with startFrom. */
+  previousRunId(id) {
+    this._previousRunId = id;
+    return this;
+  }
   /** Add an agent definition. */
   agent(name, options) {
     const def = {
@@ -38991,25 +39367,56 @@ var WorkflowBuilder = class {
   step(name, options) {
     const step = { name };
     if ("type" in options && options.type === "deterministic") {
+      if (!options.command) {
+        throw new Error("deterministic steps must have a command");
+      }
+      if ("agent" in options || "task" in options) {
+        throw new Error("deterministic steps must not have agent or task");
+      }
       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;
+      if (options.failOnError !== void 0)
+        step.failOnError = options.failOnError;
+      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;
+    } else if ("type" in options && options.type === "worktree") {
+      if ("agent" in options || "task" in options) {
+        throw new Error("worktree steps must not have agent or task");
+      }
+      step.type = "worktree";
+      step.branch = options.branch;
+      if (options.baseBranch !== void 0)
+        step.baseBranch = options.baseBranch;
+      if (options.path !== void 0)
+        step.path = options.path;
+      if (options.createBranch !== void 0)
+        step.createBranch = options.createBranch;
+      if (options.dependsOn !== void 0)
+        step.dependsOn = options.dependsOn;
+      if (options.timeoutMs !== void 0)
+        step.timeoutMs = options.timeoutMs;
     } else {
       const agentOpts = options;
+      if (!agentOpts.agent || !agentOpts.task) {
+        throw new Error("Agent steps must have both agent and task");
+      }
       step.agent = agentOpts.agent;
       step.task = agentOpts.task;
+      if (agentOpts.dependsOn !== void 0)
+        step.dependsOn = agentOpts.dependsOn;
       if (agentOpts.verification !== void 0)
         step.verification = agentOpts.verification;
+      if (agentOpts.timeoutMs !== void 0)
+        step.timeoutMs = agentOpts.timeoutMs;
       if (agentOpts.retries !== void 0)
         step.retries = agentOpts.retries;
     }
-    if (options.dependsOn !== void 0)
-      step.dependsOn = options.dependsOn;
-    if (options.timeoutMs !== void 0)
-      step.timeoutMs = options.timeoutMs;
     this._steps.push(step);
     return this;
   }
@@ -39058,6 +39465,12 @@ var WorkflowBuilder = class {
       config2.swarm.idleNudge = this._idleNudge;
     if (this._errorHandling !== void 0)
       config2.errorHandling = this._errorHandling;
+    if (this._coordination !== void 0)
+      config2.coordination = this._coordination;
+    if (this._state !== void 0)
+      config2.state = this._state;
+    if (this._trajectories !== void 0)
+      config2.trajectories = this._trajectories;
     return config2;
   }
   /** Serialize the config to a YAML string. */
@@ -39080,7 +39493,10 @@ var WorkflowBuilder = class {
     if (options.onEvent) {
       runner.on(options.onEvent);
     }
-    return runner.execute(config2, options.workflow, options.vars);
+    const startFrom = this._startFrom ?? options.startFrom;
+    const previousRunId = this._previousRunId ?? options.previousRunId;
+    const executeOptions = startFrom ? { startFrom, previousRunId } : void 0;
+    return runner.execute(config2, options.workflow, options.vars, executeOptions);
   }
 };
 function workflow(name) {
@@ -39088,7 +39504,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) ──────────────────────
@@ -39443,7 +39859,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)
@@ -39482,7 +39898,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)
@@ -39659,7 +40075,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;
@@ -39675,7 +40091,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)
@@ -39809,7 +40225,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;
@@ -39852,7 +40268,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)
@@ -39940,7 +40356,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);
@@ -40044,9 +40460,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) {
@@ -40075,7 +40491,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;
       }
     }
@@ -40097,7 +40513,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;
         }
@@ -40107,7 +40523,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`);
@@ -40300,7 +40716,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 [];
     }
@@ -40464,7 +40880,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;
@@ -40484,8 +40900,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);
   }
 }
@@ -40514,7 +40930,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") {
@@ -40785,7 +41201,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);
@@ -40811,7 +41227,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}`);
     }
@@ -40836,7 +41252,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) {
@@ -40855,7 +41271,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}`, {
@@ -40868,10 +41284,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;
@@ -40891,7 +41307,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);
@@ -40911,7 +41327,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);
@@ -40926,9 +41342,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;
@@ -40938,10 +41354,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 {
   }
 }
@@ -41059,10 +41475,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) {
@@ -41220,7 +41636,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 = {
@@ -41281,12 +41697,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);
           }
         }
@@ -41344,7 +41760,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;
@@ -41353,9 +41769,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;
     }
@@ -41373,7 +41789,7 @@ function isPlatformCompatibleBinary(filePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        import_node_fs10.default.closeSync(fd);
+        import_node_fs11.default.closeSync(fd);
       } catch {
       }
     }
@@ -41404,7 +41820,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;
@@ -41531,14 +41947,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) {
@@ -41587,8 +42003,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";
@@ -41992,9 +42408,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) {
@@ -42007,13 +42423,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);
   }
@@ -42022,7 +42438,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;
       }
     }
@@ -42031,9 +42447,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"),
@@ -42045,10 +42461,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");
 }
@@ -42060,7 +42476,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;
       }
@@ -42068,13 +42484,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 {
     }
@@ -42090,7 +42506,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);
@@ -42739,7 +43155,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() {
@@ -42753,13 +43169,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);
@@ -42846,6 +43262,7 @@ init_dist();
   HOOK_ABI_VERSION,
   HookEmitter,
   HookRegistry,
+  HttpAgentRelayClient,
   InMemoryAdapter,
   InMemoryWorkflowDb,
   JsonFileWorkflowDb,