agent-relay 3.0.1 → 3.1.0

package/dist/index.cjs

@@ -8975,6 +8975,9 @@ var AgentRelayProcessError = class extends Error {
     this.name = "AgentRelayProcessError";
   }
 };
+function isHeadlessProvider(value) {
+  return value === "claude" || value === "opencode";
+}
 var AgentRelayClient = class _AgentRelayClient {
   options;
   child;
@@ -8989,6 +8992,8 @@ var AgentRelayClient = class _AgentRelayClient {
   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(),
@@ -9098,11 +9103,12 @@ var AgentRelayClient = class _AgentRelayClient {
     });
     return result;
   }
-  async spawnHeadlessClaude(input) {
+  async spawnHeadless(input) {
     await this.start();
     const agent = {
       name: input.name,
-      runtime: "headless_claude",
+      runtime: "headless",
+      provider: input.provider,
       args: input.args ?? [],
       channels: input.channels ?? []
     };
@@ -9112,6 +9118,42 @@ var AgentRelayClient = class _AgentRelayClient {
     });
     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
+      });
+    }
+    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
+    });
+  }
+  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 });
@@ -9250,8 +9292,11 @@ var AgentRelayClient = class _AgentRelayClient {
         resolve3();
       });
     });
-    await this.requestHello();
+    const helloAck = await this.requestHello();
     console.log("[broker] Broker ready (hello handshake complete)");
+    if (helloAck.workspace_key) {
+      this.workspaceKey = helloAck.workspace_key;
+    }
   }
   disposeProcessHandles() {
     this.stdoutRl?.close();
@@ -9367,12 +9412,16 @@ var AgentRelayClient = class _AgentRelayClient {
   }
 };
 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 baseArgs = [...args];
+  const cliName = cli.split(":")[0].trim().toLowerCase();
+  const defaultArgs = CLI_DEFAULT_ARGS[cliName] ?? [];
+  const baseArgs = [...defaultArgs, ...args];
   if (!model) {
     return baseArgs;
   }
-  const cliName = cli.split(":")[0].trim().toLowerCase();
   if (!CLI_MODEL_FLAG_CLIS.has(cliName)) {
     return baseArgs;
   }
@@ -9403,6 +9452,71 @@ function expandTilde(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" }
+  };
+  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*"v?([^"]+)"/);
+    return match?.[1] ?? null;
+  } 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 version3 = getLatestVersionSync();
+  if (!version3) {
+    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${version3}/${binaryName}`;
+  console.log(`[agent-relay] Downloading v${version3} 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)(`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));
@@ -9410,7 +9524,15 @@ function resolveDefaultBinaryPath() {
   if (import_node_fs.default.existsSync(workspaceRelease)) {
     return workspaceRelease;
   }
-  const bundled = import_node_path.default.resolve(moduleDir, "..", "bin", brokerExe);
+  const binDir = import_node_path.default.resolve(moduleDir, "..", "bin");
+  const suffix = detectPlatformSuffix();
+  if (suffix) {
+    const platformBinary = import_node_path.default.join(binDir, `agent-relay-broker-${suffix}`);
+    if (import_node_fs.default.existsSync(platformBinary)) {
+      return platformBinary;
+    }
+  }
+  const bundled = import_node_path.default.join(binDir, brokerExe);
   if (import_node_fs.default.existsSync(bundled)) {
     return bundled;
   }
@@ -9419,7 +9541,7 @@ function resolveDefaultBinaryPath() {
   if (import_node_fs.default.existsSync(standaloneBroker)) {
     return standaloneBroker;
   }
-  return "agent-relay";
+  return installBrokerBinary();
 }
 
 // packages/config/src/relay-config.ts
@@ -15176,7 +15298,7 @@ var DefaultModels = {
 };
 
 // node_modules/@relaycast/sdk/dist/version.js
-var SDK_VERSION = "0.4.0";
+var SDK_VERSION = "0.4.2";
 
 // node_modules/@relaycast/types/node_modules/zod/v4/classic/external.js
 var external_exports2 = {};
@@ -45021,12 +45143,26 @@ var AgentRelay = class {
   onDeliveryUpdate = null;
   onAgentExitRequested = null;
   onAgentIdle = null;
+  // ── Public accessors ────────────────────────────────────────────────────
+  /** The resolved Relaycast workspace API key (available after first spawn). */
+  get workspaceKey() {
+    return this.relayApiKey;
+  }
+  /** Observer URL for the auto-created workspace (available after first spawn). */
+  get observerUrl() {
+    if (!this.relayApiKey)
+      return void 0;
+    return `https://observer.relaycast.dev/?key=${this.relayApiKey}`;
+  }
   // Shorthand spawners
   codex;
   claude;
   gemini;
   clientOptions;
   defaultChannels;
+  workspaceName;
+  relaycastBaseUrl;
+  relayApiKey;
   client;
   startPromise;
   unsubEvent;
@@ -45043,6 +45179,8 @@ var AgentRelay = class {
   idleResolverSeq = 0;
   constructor(options = {}) {
     this.defaultChannels = options.channels ?? ["general"];
+    this.workspaceName = options.workspaceName;
+    this.relaycastBaseUrl = options.relaycastBaseUrl;
     this.clientOptions = {
       binaryPath: options.binaryPath,
       binaryArgs: options.binaryArgs,
@@ -45084,26 +45222,44 @@ var AgentRelay = class {
       console.warn(`[AgentRelay] spawnPty("${input.name}"): no channels specified, defaulting to "general". Set explicit channels for workflow isolation.`);
     }
     const channels = input.channels ?? ["general"];
-    const result = await client.spawnPty({
+    const lifecycleContext = {
       name: input.name,
       cli: input.cli,
-      args: input.args,
       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
-    });
-    this.readyAgents.delete(result.name);
-    this.messageReadyAgents.delete(result.name);
-    this.exitedAgents.delete(result.name);
-    this.idleAgents.delete(result.name);
+      task: input.task
+    };
+    await this.invokeLifecycleHook(input.onStart, lifecycleContext, `spawnPty("${input.name}") onStart`);
+    let result;
+    try {
+      result = await client.spawnPty({
+        name: input.name,
+        cli: input.cli,
+        args: input.args,
+        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
+      });
+    } catch (error95) {
+      await this.invokeLifecycleHook(input.onError, {
+        ...lifecycleContext,
+        error: error95
+      }, `spawnPty("${input.name}") onError`);
+      throw error95;
+    }
+    this.resetAgentLifecycleState(result.name);
     const agent = this.makeAgent(result.name, result.runtime, channels);
     this.knownAgents.set(agent.name, agent);
+    await this.invokeLifecycleHook(input.onSuccess, {
+      ...lifecycleContext,
+      name: result.name,
+      runtime: result.runtime
+    }, `spawnPty("${input.name}") onSuccess`);
     return agent;
   }
   async spawn(name, cli, task, options) {
@@ -45119,7 +45275,10 @@ var AgentRelay = class {
       shadowOf: options?.shadowOf,
       shadowMode: options?.shadowMode,
       idleThresholdSecs: options?.idleThresholdSecs,
-      restartPolicy: options?.restartPolicy
+      restartPolicy: options?.restartPolicy,
+      onStart: options?.onStart,
+      onSuccess: options?.onSuccess,
+      onError: options?.onError
     });
   }
   async spawnAndWait(name, cli, task, options) {
@@ -45128,7 +45287,7 @@ var AgentRelay = class {
     if (waitForMessage) {
       return this.waitForAgentMessage(name, timeoutMs ?? 6e4);
     }
-    return this.waitForAgentReady(name, timeoutMs ?? 3e4);
+    return this.waitForAgentReady(name, timeoutMs ?? 6e4);
   }
   // ── Human source ────────────────────────────────────────────────────────
   human(opts) {
@@ -45318,7 +45477,7 @@ var AgentRelay = class {
    * The agent's CLI may not yet be ready to receive messages.
    * Use `waitForAgentMessage()` for full readiness.
    */
-  async waitForAgentReady(name, timeoutMs = 3e4) {
+  async waitForAgentReady(name, timeoutMs = 6e4) {
     const client = await this.ensureStarted();
     const existing = this.knownAgents.get(name);
     if (existing && this.readyAgents.has(name)) {
@@ -45492,14 +45651,42 @@ var AgentRelay = class {
       }
     }
   }
+  /**
+   * Ensure a Relaycast workspace API key is available.
+   * Resolution order:
+   *   1. Already resolved (cached from a previous call)
+   *   2. RELAY_API_KEY in options.env
+   *   3. RELAY_API_KEY in process.env
+   *   4. Auto-create a fresh workspace via the Relaycast REST API
+   */
+  async ensureRelaycastApiKey() {
+    if (this.relayApiKey)
+      return;
+    const envKey = this.clientOptions.env?.RELAY_API_KEY ?? process.env.RELAY_API_KEY;
+    if (envKey) {
+      this.relayApiKey = envKey;
+      if (!this.clientOptions.env) {
+        this.clientOptions.env = { ...process.env, RELAY_API_KEY: envKey };
+      } else if (!this.clientOptions.env.RELAY_API_KEY) {
+        this.clientOptions.env.RELAY_API_KEY = envKey;
+      }
+      return;
+    }
+    if (!this.clientOptions.env) {
+      this.clientOptions.env = { ...process.env };
+    }
+  }
   async ensureStarted() {
     if (this.client)
       return this.client;
     if (this.startPromise)
       return this.startPromise;
-    this.startPromise = AgentRelayClient.start(this.clientOptions).then((c) => {
+    this.startPromise = this.ensureRelaycastApiKey().then(() => AgentRelayClient.start(this.clientOptions)).then((c) => {
       this.client = c;
       this.startPromise = void 0;
+      if (c.workspaceKey) {
+        this.relayApiKey = c.workspaceKey;
+      }
       this.wireEvents(c);
       return c;
     }).catch((err) => {
@@ -45644,11 +45831,26 @@ var AgentRelay = class {
       },
       exitCode: void 0,
       exitSignal: void 0,
-      async release(reason) {
+      async release(reasonOrOptions) {
+        const releaseOptions = relay.normalizeReleaseOptions(reasonOrOptions);
+        const releaseContext = {
+          name,
+          reason: releaseOptions.reason
+        };
         const client = await relay.ensureStarted();
-        await client.release(name, reason);
+        await relay.invokeLifecycleHook(releaseOptions.onStart, releaseContext, `release("${name}") onStart`);
+        try {
+          await client.release(name, releaseOptions.reason);
+          await relay.invokeLifecycleHook(releaseOptions.onSuccess, releaseContext, `release("${name}") onSuccess`);
+        } catch (error95) {
+          await relay.invokeLifecycleHook(releaseOptions.onError, {
+            ...releaseContext,
+            error: error95
+          }, `release("${name}") onError`);
+          throw error95;
+        }
       },
-      async waitForReady(timeoutMs = 3e4) {
+      async waitForReady(timeoutMs = 6e4) {
         await relay.waitForAgentReady(name, timeoutMs);
       },
       waitForExit(timeoutMs) {
@@ -45769,31 +45971,83 @@ var AgentRelay = class {
   createSpawner(cli, defaultName, runtime) {
     return {
       spawn: async (options) => {
-        const client = await this.ensureStarted();
         const name = options?.name ?? defaultName;
         const channels = options?.channels ?? ["general"];
         const args = options?.args ?? [];
         const task = options?.task;
-        let result;
-        if (runtime === "headless_claude") {
-          result = await client.spawnHeadlessClaude({ name, args, channels, task });
-        } else {
-          result = await client.spawnPty({
+        if (runtime === "pty") {
+          return this.spawnPty({
             name,
             cli,
             args,
             channels,
             task,
             model: options?.model,
-            cwd: options?.cwd
+            cwd: options?.cwd,
+            onStart: options?.onStart,
+            onSuccess: options?.onSuccess,
+            onError: options?.onError
           });
         }
+        const client = await this.ensureStarted();
+        const lifecycleContext = {
+          name,
+          cli,
+          channels,
+          task
+        };
+        await this.invokeLifecycleHook(options?.onStart, lifecycleContext, `spawn("${name}") onStart`);
+        let result;
+        try {
+          result = await client.spawnProvider({
+            name,
+            provider: cli,
+            transport: "headless",
+            args,
+            channels,
+            task
+          });
+        } catch (error95) {
+          await this.invokeLifecycleHook(options?.onError, {
+            ...lifecycleContext,
+            error: error95
+          }, `spawn("${name}") onError`);
+          throw error95;
+        }
+        this.resetAgentLifecycleState(result.name);
         const agent = this.makeAgent(result.name, result.runtime, channels);
         this.knownAgents.set(agent.name, agent);
+        await this.invokeLifecycleHook(options?.onSuccess, {
+          ...lifecycleContext,
+          name: result.name,
+          runtime: result.runtime
+        }, `spawn("${name}") onSuccess`);
         return agent;
       }
     };
   }
+  async invokeLifecycleHook(hook, context, label) {
+    if (!hook) {
+      return;
+    }
+    try {
+      await hook(context);
+    } catch (error95) {
+      console.warn(`[AgentRelay] ${label} hook threw`, error95);
+    }
+  }
+  resetAgentLifecycleState(name) {
+    this.readyAgents.delete(name);
+    this.messageReadyAgents.delete(name);
+    this.exitedAgents.delete(name);
+    this.idleAgents.delete(name);
+  }
+  normalizeReleaseOptions(reasonOrOptions) {
+    if (typeof reasonOrOptions === "string" || reasonOrOptions === void 0) {
+      return { reason: reasonOrOptions };
+    }
+    return reasonOrOptions;
+  }
 };
 
 // packages/sdk/dist/consensus.js
@@ -47299,6 +47553,22 @@ var WorkflowTrajectory = class {
 };
 
 // packages/sdk/dist/workflows/runner.js
+var _resolvedCursorCli;
+function resolveCursorCli() {
+  if (_resolvedCursorCli !== void 0)
+    return _resolvedCursorCli;
+  const candidates = ["cursor-agent", "agent"];
+  for (const candidate of candidates) {
+    try {
+      (0, import_node_child_process3.execFileSync)("which", [candidate], { stdio: "ignore" });
+      _resolvedCursorCli = candidate;
+      return candidate;
+    } catch {
+    }
+  }
+  _resolvedCursorCli = "agent";
+  return _resolvedCursorCli;
+}
 var WorkflowRunner = class _WorkflowRunner {
   db;
   workspaceId;
@@ -47393,6 +47663,17 @@ var WorkflowRunner = class _WorkflowRunner {
     }
     this.relayApiKey = apiKey;
     this.relayApiKeyAutoCreated = true;
+    const dashboardPort = process.env.AGENT_RELAY_DASHBOARD_PORT || "3888";
+    fetch(`http://127.0.0.1:${dashboardPort}/api/relay-config`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ apiKey })
+    }).then((res2) => {
+      if (!res2.ok) {
+        console.warn(`[WorkflowRunner] dashboard key push failed: HTTP ${res2.status}`);
+      }
+    }).catch(() => {
+    });
   }
   getRelayEnv() {
     if (!this.relayApiKey) {
@@ -48075,8 +48356,7 @@ ${err.suggestion}`);
       this.log("API key resolved");
       if (this.relayApiKeyAutoCreated && this.relayApiKey) {
         this.log(`Workspace created \u2014 follow this run in Relaycast:`);
-        this.log(`  RELAY_API_KEY=${this.relayApiKey}`);
-        this.log(`  Observer: https://observer.relaycast.dev (paste key above)`);
+        this.log(`  Observer: https://observer.relaycast.dev/?key=${this.relayApiKey}`);
         this.log(`  Channel: ${channel}`);
       }
       this.log("Starting broker...");
@@ -48182,19 +48462,6 @@ ${err.suggestion}`);
       if (!isResume && workflow2.preflight?.length) {
         await this.runPreflightChecks(workflow2.preflight, runId);
       }
-      if (this.relay && !isResume) {
-        const agentPreflight = workflow2.steps.filter((s) => s.type !== "deterministic" && s.type !== "worktree" && s.agent).map((s) => {
-          const agentDef = agentMap.get(s.agent);
-          return agentDef && agentDef.interactive !== false ? { name: `${s.name}-${runId.slice(0, 8)}`, cli: agentDef.cli } : null;
-        }).filter((e) => e !== null);
-        if (agentPreflight.length > 0) {
-          this.log(`Pre-registering ${agentPreflight.length} agents with Relaycast...`);
-          await this.relay.preflightAgents(agentPreflight).catch((err) => {
-            this.log(`[preflight-agents] warning: ${err.message} \u2014 continuing without pre-registration`);
-          });
-          this.log("Agent pre-registration complete");
-        }
-      }
       this.log(`Executing ${workflow2.steps.length} steps (pattern: ${config3.swarm.pattern})`);
       await this.executeSteps(workflow2, stepStates, agentMap, config3.errorHandling, runId);
       const allCompleted = [...stepStates.values()].every((s) => s.row.status === "completed" || s.row.status === "skipped");
@@ -48576,8 +48843,6 @@ ${trimmedOutput.slice(0, 200)}`);
       });
       await this.persistStepOutput(runId, step.name, output);
       this.emit({ type: "step:completed", runId, stepName: step.name, output });
-      this.postToChannel(`**[${step.name}]** Completed (deterministic)
-${output.slice(0, 500)}${output.length > 500 ? "\n...(truncated)" : ""}`);
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
@@ -48792,8 +49057,6 @@ ${output.slice(0, 500)}${output.length > 500 ? "\n...(truncated)" : ""}`);
         });
         await this.persistStepOutput(runId, step.name, output);
         this.emit({ type: "step:completed", runId, stepName: step.name, output });
-        this.postToChannel(`**[${step.name}]** Completed
-${output.slice(0, 500)}${output.length > 500 ? "\n...(truncated)" : ""}`);
         await this.trajectory?.stepCompleted(step, output, attempt + 1);
         return;
       } catch (err) {
@@ -48831,6 +49094,11 @@ ${output.slice(0, 500)}${output.length > 500 ? "\n...(truncated)" : ""}`);
         return { cmd: "aider", args: ["--message", task, "--yes-always", "--no-git", ...extraArgs] };
       case "goose":
         return { cmd: "goose", args: ["run", "--text", task, "--no-session", ...extraArgs] };
+      case "cursor-agent":
+      case "agent":
+        return { cmd: cli, args: ["--force", "-p", task, ...extraArgs] };
+      case "cursor":
+        return { cmd: resolveCursorCli(), args: ["--force", "-p", task, ...extraArgs] };
     }
   }
   /**
@@ -48838,11 +49106,12 @@ ${output.slice(0, 500)}${output.length > 500 ? "\n...(truncated)" : ""}`);
    * Explicit fields on the definition always win over preset-inferred defaults.
    */
   static resolveAgentDef(def) {
+    const resolvedCli = def.cli === "cursor" ? resolveCursorCli() : def.cli;
     if (!def.preset)
-      return def;
+      return resolvedCli !== def.cli ? { ...def, cli: resolvedCli } : def;
     const nonInteractivePresets = ["worker", "reviewer", "analyst"];
     const defaults = nonInteractivePresets.includes(def.preset) ? { interactive: false } : {};
-    return { ...defaults, ...def };
+    return { ...defaults, ...def, cli: resolvedCli };
   }
   /**
    * Returns a preset-specific prefix that is prepended to the non-interactive
@@ -49157,7 +49426,17 @@ DO NOT:
   async waitForExitWithIdleNudging(agent, agentDef, step, timeoutMs) {
     const nudgeConfig = this.currentConfig?.swarm.idleNudge;
     if (!nudgeConfig) {
-      return agent.waitForExit(timeoutMs);
+      const result = await Promise.race([
+        agent.waitForExit(timeoutMs).then((r) => ({ kind: "exit", result: r })),
+        agent.waitForIdle(timeoutMs).then((r) => ({ kind: "idle", result: r }))
+      ]);
+      if (result.kind === "idle" && result.result === "idle") {
+        this.log(`[${step.name}] Agent "${agent.name}" went idle \u2014 treating as complete`);
+        this.postToChannel(`**[${step.name}]** Agent \`${agent.name}\` idle \u2014 treating as complete`);
+        await agent.release();
+        return "released";
+      }
+      return result.result;
     }
     const nudgeAfterMs = nudgeConfig.nudgeAfterMs ?? 12e4;
     const escalateAfterMs = nudgeConfig.escalateAfterMs ?? 12e4;
@@ -49572,7 +49851,7 @@ ${excerpt}` : "";
     const withoutSystemReminders = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/giu, "").replace(/<system-reminder>[\s\S]*/giu, "");
     const normalized = withoutSystemReminders.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
     const ansiStripped = stripAnsi(normalized);
-    const SPINNER = "\\u2756\\u2738\\u2739\\u273a\\u273b\\u273c\\u273d\\u2731\\u2732\\u2733\\u2734\\u2735\\u2736\\u2737\\u2743\\u2745\\u2746\\u25d6\\u25d7\\u25d8\\u25d9\\u2022\\u25cf\\u25cb\\u25a0\\u25a1\\u25b6\\u25c0\\u23f5\\u23f6\\u23f7\\u23f8\\u23f9\\u25e2\\u25e3\\u25e4\\u25e5\\u2597\\u2596\\u2598\\u259d\\u2bc8\\u2bc7\\u2bc5\\u2bc6\\u00b7\\u2590\\u258c\\u2588\\u2584\\u2580\\u259a\\u259e";
+    const SPINNER = "\\u2756\\u2738\\u2739\\u273a\\u273b\\u273c\\u273d\\u2731\\u2732\\u2733\\u2734\\u2735\\u2736\\u2737\\u2743\\u2745\\u2746\\u25d6\\u25d7\\u25d8\\u25d9\\u2022\\u25cf\\u25cb\\u25a0\\u25a1\\u25b6\\u25c0\\u23f5\\u23f6\\u23f7\\u23f8\\u23f9\\u25e2\\u25e3\\u25e4\\u25e5\\u2597\\u2596\\u2598\\u259d\\u2bc8\\u2bc7\\u2bc5\\u2bc6\\u00b7\\u2590\\u258c\\u2588\\u2584\\u2580\\u259a\\u259e\\u2b21\\u2b22";
     const spinnerRe = new RegExp(`[${SPINNER}]`, "gu");
     const spinnerClassRe = new RegExp(`^[\\s${SPINNER}]*$`, "u");
     const boxDrawingOnlyRe = /^[\s\u2500-\u257f\u2580-\u259f\u25a0-\u25ff\-_=~]{3,}$/u;
@@ -49582,6 +49861,7 @@ ${excerpt}` : "";
     const uiHintRe = /\b(?:Press\s+up\s+to\s+edit|tab\s+to\s+queue|bypass\s+permissions|esc\s+to\s+interrupt)\b/iu;
     const thinkingLineRe = new RegExp(`^[\\s${SPINNER}]*\\s*\\w[\\w\\s]*\\u2026\\s*$`, "u");
     const cursorOnlyRe = /^[\s❯⎿›»◀▶←→↑↓⟨⟩⟪⟫·]+$/u;
+    const cursorAgentRe = /^(?:Cursor Agent|[\s⬡⬢]*Generating[.\s]|\[Pasted text|Auto-run all|Add a follow-up|ctrl\+c to stop|shift\+tab|Auto$|\/\s*commands|@\s*files|!\s*shell|follow-ups?\s|The user ha)/iu;
     const slashCommandRe = /^\/\w+\s*$/u;
     const mcpJsonKvRe = /^\s*"(?:type|method|params|result|id|jsonrpc|tool|name|arguments|content|role|metadata)"\s*:/u;
     const meaningfulContentRe = /[a-zA-Z0-9]/u;
@@ -49630,6 +49910,8 @@ ${excerpt}` : "";
         continue;
       if (cursorOnlyRe.test(trimmed))
         continue;
+      if (cursorAgentRe.test(trimmed))
+        continue;
       if (slashCommandRe.test(trimmed))
         continue;
       if (!meaningfulContentRe.test(trimmed))

package/dist/src/cli/commands/core.d.ts

@@ -45,6 +45,8 @@ export interface CoreRelay {
     }>;
     shutdown: () => Promise<unknown>;
     onBrokerStderr?: (listener: (line: string) => void) => () => void;
+    /** Relaycast workspace API key, available after the hello handshake. */
+    workspaceKey?: string;
 }
 export interface CoreFileSystem {
     existsSync: (path: string) => boolean;