@slock-ai/daemon 0.56.1-play.20260605140553 → 0.57.0

package/dist/{chunk-YOVM6OOZ.js → chunk-DQN3TW2I.js}

@@ -1,14 +1,5 @@
-import {
-  DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
-  buildWebSocketOptions,
-  daemonFetch,
-  executeJsonRequest,
-  executeResponseRequest,
-  logger
-} from "./chunk-M2KQBJR3.js";
-
 // src/core.ts
-import path17 from "path";
+import path15 from "path";
 import os7 from "os";
 import { createRequire as createRequire2 } from "module";
 import { accessSync } from "fs";
@@ -1274,10 +1265,10 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync4 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
-import path13 from "path";
+import path11 from "path";
 import os5 from "os";
 
 // src/drivers/claude.ts
@@ -1989,19 +1980,6 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
-// src/authEnv.ts
-var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
-var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
-function scrubDaemonAuthEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  return env;
-}
-function scrubDaemonChildEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  delete env[SLOCK_AGENT_TOKEN_ENV];
-  return env;
-}
-
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -2331,6 +2309,160 @@ function stripUndefined(value) {
   return value;
 }
 
+// src/proxy.ts
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { ProxyAgent } from "undici";
+var fetchDispatcherCache = /* @__PURE__ */ new Map();
+function getFetchPreResponseTimeoutMs(env) {
+  const parsed = Number.parseInt(env.SLOCK_DAEMON_FETCH_PRE_RESPONSE_TIMEOUT_MS || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
+}
+function getDefaultPort(protocol) {
+  switch (protocol) {
+    case "https:":
+    case "wss:":
+      return "443";
+    case "http:":
+    case "ws:":
+      return "80";
+    default:
+      return "";
+  }
+}
+function hostMatchesNoProxyEntry(hostname, ruleHost) {
+  if (!ruleHost) return false;
+  const normalizedRule = ruleHost.replace(/^\*\./, ".").replace(/^\./, "").toLowerCase();
+  const normalizedHost = hostname.toLowerCase();
+  return normalizedHost === normalizedRule || normalizedHost.endsWith(`.${normalizedRule}`);
+}
+function getProxyUrlForTarget(targetUrl, env) {
+  const protocol = new URL(targetUrl).protocol;
+  switch (protocol) {
+    case "wss:":
+      return env.WSS_PROXY || env.wss_proxy || env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "ws:":
+      return env.WS_PROXY || env.ws_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    case "https:":
+      return env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "http:":
+      return env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    default:
+      return env.ALL_PROXY || env.all_proxy;
+  }
+}
+function shouldBypassProxy(targetUrl, env) {
+  const rawNoProxy = env.NO_PROXY || env.no_proxy;
+  if (!rawNoProxy) return false;
+  const url = new URL(targetUrl);
+  const hostname = url.hostname.toLowerCase();
+  const port = url.port || getDefaultPort(url.protocol);
+  return rawNoProxy.split(",").map((entry) => entry.trim()).filter(Boolean).some((entry) => {
+    if (entry === "*") return true;
+    const [ruleHost, rulePort] = entry.split(":", 2);
+    if (rulePort && rulePort !== port) return false;
+    return hostMatchesNoProxyEntry(hostname, ruleHost);
+  });
+}
+function buildWebSocketOptions(wsUrl, env) {
+  const proxyUrl = getProxyUrlForTarget(wsUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(wsUrl, env)) return void 0;
+  return {
+    agent: new HttpsProxyAgent(proxyUrl)
+  };
+}
+function resolveProxyUrl(targetUrl, env) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(targetUrl, env)) return void 0;
+  return proxyUrl;
+}
+function buildFetchDispatcher(targetUrl, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  if (!proxyUrl) return void 0;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (cached) return cached;
+  const timeoutMs = getFetchPreResponseTimeoutMs(env);
+  const dispatcher = new ProxyAgent({
+    uri: proxyUrl,
+    // All three are pre-response and body-agnostic (see getFetchPreResponseTimeoutMs):
+    // headersTimeout = headers-hang leg; requestTls.timeout = CONNECT-tunnel
+    // establish leg; connect.timeout = socket to the proxy itself (defensive).
+    connect: { timeout: timeoutMs },
+    requestTls: { timeout: timeoutMs },
+    headersTimeout: timeoutMs
+  });
+  fetchDispatcherCache.set(proxyUrl, dispatcher);
+  return dispatcher;
+}
+function evictFetchDispatcher(targetUrl, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  if (!proxyUrl) return false;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (!cached) return false;
+  fetchDispatcherCache.delete(proxyUrl);
+  void Promise.resolve().then(() => cached.close()).catch(() => cached.destroy?.(new Error("evicted"))).catch(() => {
+  });
+  return true;
+}
+
+// src/daemonFetch.ts
+function withDaemonFetchProxy(input, init = {}, env = process.env) {
+  const dispatcher = buildFetchDispatcher(input.toString(), env);
+  return dispatcher ? { ...init, dispatcher } : init;
+}
+async function daemonFetch(input, init, env = process.env) {
+  try {
+    return await fetch(input, withDaemonFetchProxy(input, init, env));
+  } catch (err) {
+    evictFetchDispatcher(input.toString(), env);
+    throw err;
+  }
+}
+
+// src/logger.ts
+var listeners = /* @__PURE__ */ new Set();
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function format(level, msg) {
+  return `${timestamp()} [${level}] ${msg}`;
+}
+function emit(event) {
+  for (const listener of listeners) {
+    listener(event);
+  }
+}
+function subscribeDaemonLogs(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+var logger = {
+  info(msg) {
+    const line = format("INFO", msg);
+    console.log(line);
+    emit({ level: "INFO", line, message: msg });
+  },
+  warn(msg) {
+    const line = format("WARN", msg);
+    console.warn(line);
+    emit({ level: "WARN", line, message: msg });
+  },
+  error(msg, err) {
+    const line = format("ERROR", msg);
+    if (err) {
+      console.error(line, err);
+    } else {
+      console.error(line);
+    }
+    emit({ level: "ERROR", line, message: msg, error: err });
+  }
+};
+
 // src/agentCredentialProxy.ts
 var registrations = /* @__PURE__ */ new Map();
 var proxyServerState = null;
@@ -3157,9 +3289,7 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 var cachedOpencliBinPath;
 function resolveOpencliBinPath() {
@@ -3374,7 +3504,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -3803,7 +3933,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn, existsSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync2;
   if (platform === "win32") {
@@ -3829,7 +3959,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -4526,7 +4656,7 @@ var CodexDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -4543,50 +4673,6 @@ var CodexDriver = class {
   probe() {
     return probeCodex();
   }
-  buildRuntimeActionsConfigArgs(ctx) {
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = isTsSource ? [
-      "tsx",
-      ctx.chatBridgePath,
-      "--agent-id",
-      ctx.agentId,
-      "--server-url",
-      ctx.config.serverUrl,
-      "--auth-token",
-      ctx.config.authToken || ctx.daemonApiKey,
-      "--runtime",
-      this.id,
-      ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-      "--runtime-actions-only"
-    ] : [
-      ctx.chatBridgePath,
-      "--agent-id",
-      ctx.agentId,
-      "--server-url",
-      ctx.config.serverUrl,
-      "--auth-token",
-      ctx.config.authToken || ctx.daemonApiKey,
-      "--runtime",
-      this.id,
-      ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-      "--runtime-actions-only"
-    ];
-    return [
-      "-c",
-      `mcp_servers.chat.command=${JSON.stringify(command)}`,
-      "-c",
-      `mcp_servers.chat.args=${JSON.stringify(bridgeArgs)}`,
-      "-c",
-      "mcp_servers.chat.startup_timeout_sec=30",
-      "-c",
-      "mcp_servers.chat.tool_timeout_sec=120",
-      "-c",
-      "mcp_servers.chat.enabled=true",
-      "-c",
-      "mcp_servers.chat.required=true"
-    ];
-  }
   buildThreadRequest(ctx) {
     const threadParams = {
       cwd: ctx.workingDirectory,
@@ -4640,7 +4726,6 @@ var CodexDriver = class {
     this.initialTurnStarted = false;
     this.normalizer.reset({ threadId: ctx.config.sessionId || null });
     const args = ["app-server", "--listen", "stdio://"];
-    args.push(...this.buildRuntimeActionsConfigArgs(ctx));
     const { command, args: spawnArgs } = resolveCodexSpawn(args);
     const proc = spawn2(command, spawnArgs, {
       cwd: ctx.workingDirectory,
@@ -4927,8 +5012,6 @@ var AntigravityDriver = class {
 
 // src/drivers/copilot.ts
 import { spawn as spawn4 } from "child_process";
-import path6 from "path";
-import { writeFileSync as writeFileSync3 } from "fs";
 async function buildCopilotSpawnEnv(ctx) {
   return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
 }
@@ -4942,7 +5025,7 @@ var CopilotDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -4957,43 +5040,14 @@ var CopilotDriver = class {
   usesSlockCliForCommunication = true;
   sessionId = null;
   sessionAnnounced = false;
-  buildRuntimeActionsMcpConfig(ctx) {
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
-    return JSON.stringify({
-      mcpServers: {
-        chat: {
-          command,
-          args: [
-            ...bridgeArgs,
-            "--agent-id",
-            ctx.agentId,
-            "--server-url",
-            ctx.config.serverUrl,
-            "--auth-token",
-            ctx.config.authToken || ctx.daemonApiKey,
-            "--runtime",
-            this.id,
-            ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-            "--runtime-actions-only"
-          ]
-        }
-      }
-    });
-  }
   async spawn(ctx) {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
-    const mcpConfigPath = path6.join(ctx.workingDirectory, ".slock-copilot-mcp.json");
-    writeFileSync3(mcpConfigPath, this.buildRuntimeActionsMcpConfig(ctx), "utf8");
     const args = [
       "--output-format",
       "json",
       "--allow-all-tools",
       "--allow-all-paths",
-      "--additional-mcp-config",
-      `@${mcpConfigPath}`,
       "-p",
       ctx.prompt
     ];
@@ -5102,8 +5156,6 @@ var CopilotDriver = class {
 
 // src/drivers/cursor.ts
 import { spawn as spawn5, spawnSync } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
-import path7 from "path";
 async function buildCursorSpawnEnv(ctx, deps = {}) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
   return withWindowsUserEnvironment(spawnEnv, deps);
@@ -5118,7 +5170,7 @@ var CursorDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -5131,38 +5183,7 @@ var CursorDriver = class {
   mcpToolPrefix = "mcp__chat__";
   busyDeliveryMode = "none";
   usesSlockCliForCommunication = true;
-  buildRuntimeActionsMcpConfig(ctx) {
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
-    return JSON.stringify({
-      mcpServers: {
-        chat: {
-          command,
-          args: [
-            ...bridgeArgs,
-            "--agent-id",
-            ctx.agentId,
-            "--server-url",
-            ctx.config.serverUrl,
-            "--auth-token",
-            ctx.config.authToken || ctx.daemonApiKey,
-            "--runtime",
-            this.id,
-            ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-            "--runtime-actions-only"
-          ]
-        }
-      }
-    });
-  }
   async spawn(ctx) {
-    const cursorDir = path7.join(ctx.workingDirectory, ".cursor");
-    if (!existsSync4(cursorDir)) {
-      mkdirSync2(cursorDir, { recursive: true });
-    }
-    const mcpConfigPath = path7.join(cursorDir, "mcp.json");
-    writeFileSync4(mcpConfigPath, this.buildRuntimeActionsMcpConfig(ctx), "utf8");
     const args = [
       "--print",
       "--output-format",
@@ -5292,11 +5313,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -5308,8 +5329,8 @@ function runCursorModelsCommand() {
 
 // src/drivers/gemini.ts
 import { execFileSync as execFileSync3, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
-import path8 from "path";
+import { existsSync as existsSync4 } from "fs";
+import path6 from "path";
 async function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
   const launchEnvVars = runtimeConfigToLaunchFields(ctx.config).envVars;
@@ -5351,9 +5372,9 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
     return { command: resolveCommandOnPath("gemini", deps) ?? "gemini", args: commandArgs };
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
-  const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
-  const winPath = path8.win32;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync4;
+  const env = deps.env ?? process.env;
+  const winPath = path6.win32;
   let geminiEntry = null;
   try {
     const globalRoot = normalizeExecOutput2(execFileSyncFn("npm", ["root", "-g"], {
@@ -5397,7 +5418,7 @@ var GeminiDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -5415,7 +5436,6 @@ var GeminiDriver = class {
   async spawn(ctx) {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
-    this.writeGeminiSettings(ctx);
     const { command, args } = resolveGeminiSpawn(buildGeminiArgs(ctx.config));
     const spawnEnv = await buildGeminiSpawnEnv(ctx);
     const proc = spawn6(command, args, {
@@ -5488,52 +5508,17 @@ var GeminiDriver = class {
       messageNotificationStyle: "poll"
     });
   }
-  writeGeminiSettings(ctx) {
-    const geminiDir = path8.join(ctx.workingDirectory, ".gemini");
-    mkdirSync3(geminiDir, { recursive: true });
-    const settingsPath = path8.join(geminiDir, "settings.json");
-    writeFileSync5(settingsPath, JSON.stringify(this.buildRuntimeActionsMcpSettings(ctx)), "utf8");
-  }
-  buildRuntimeActionsMcpSettings(ctx) {
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
-    return {
-      mcpServers: {
-        chat: {
-          command,
-          args: [
-            ...bridgeArgs,
-            "--agent-id",
-            ctx.agentId,
-            "--server-url",
-            ctx.config.serverUrl,
-            "--auth-token",
-            ctx.config.authToken || ctx.daemonApiKey,
-            "--runtime",
-            this.id,
-            ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-            "--runtime-actions-only"
-          ]
-        }
-      }
-    };
-  }
 };
 
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os3 from "os";
-import path9 from "path";
+import path7 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
-var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
-var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
-var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
-var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -5542,73 +5527,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os3.homedir(), env = process.env) {
-  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  if (inlineConfig && inlineConfig.trim()) {
-    return {
-      raw: inlineConfig,
-      explicitPath: null,
-      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
-    };
-  }
-  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
-  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
-  try {
-    return {
-      raw: readFileSync3(configPath, "utf8"),
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  } catch {
-    return {
-      raw: null,
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  }
-}
-function buildKimiSpawnEnv(env = process.env) {
-  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
-  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
-  return scrubDaemonChildEnv(spawnEnv);
-}
-function buildKimiEffectiveEnv(ctx, overrideEnv) {
-  return {
-    ...process.env,
-    ...ctx.config.envVars || {},
-    ...overrideEnv || {}
-  };
-}
-function buildKimiLaunchOptions(ctx, opts = {}) {
-  const env = buildKimiEffectiveEnv(ctx, opts.env);
-  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
-  const args = [];
-  let configFilePath = null;
-  let configContent = null;
-  if (source.explicitPath) {
-    configFilePath = source.explicitPath;
-  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
-    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
-    configContent = source.raw;
-    if (opts.writeGeneratedConfig !== false) {
-      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
-      chmodSync(configFilePath, 384);
-    }
-  }
-  if (configFilePath) {
-    args.push("--config-file", configFilePath);
-  }
-  if (ctx.config.model && ctx.config.model !== "default") {
-    args.push("--model", ctx.config.model);
-  }
-  return {
-    args,
-    env: buildKimiSpawnEnv(env),
-    configFilePath,
-    configContent
-  };
-}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -5625,32 +5543,14 @@ var KimiDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId, ctx, opts) => {
-      if (!ctx) return { args: ["--model", modelId] };
-      const launchCtx = {
-        ...ctx,
-        config: {
-          ...ctx.config,
-          model: modelId
-        }
-      };
-      const launch = buildKimiLaunchOptions(launchCtx, {
-        home: opts?.home,
-        writeGeneratedConfig: false
-      });
-      return {
-        args: launch.args,
-        env: launch.env,
-        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -5659,70 +5559,38 @@ var KimiDriver = class {
   sessionId = null;
   sessionAnnounced = false;
   promptRequestId = null;
-  buildChatBridgeArgs(ctx) {
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    return [
-      ...isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath],
-      "--agent-id",
-      ctx.agentId,
-      "--server-url",
-      ctx.config.serverUrl,
-      "--auth-token",
-      ctx.config.authToken || ctx.daemonApiKey,
-      "--runtime",
-      "kimi",
-      ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-      "--runtime-actions-only"
-    ];
-  }
   async spawn(ctx) {
     const isResume = !!ctx.config.sessionId;
     this.sessionId = ctx.config.sessionId || randomUUID2();
     this.sessionAnnounced = false;
     this.promptRequestId = randomUUID2();
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = this.buildChatBridgeArgs(ctx);
-    const systemPromptPath = path9.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
-    const agentFilePath = path9.join(ctx.workingDirectory, KIMI_AGENT_FILE);
-    const mcpConfigPath = path9.join(ctx.workingDirectory, KIMI_MCP_FILE);
-    if (!isResume || !existsSync6(systemPromptPath)) {
-      writeFileSync6(systemPromptPath, ctx.prompt, "utf8");
-    }
-    writeFileSync6(agentFilePath, [
+    const systemPromptPath = path7.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path7.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    if (!isResume || !existsSync5(systemPromptPath)) {
+      writeFileSync3(systemPromptPath, ctx.prompt, "utf8");
+    }
+    writeFileSync3(agentFilePath, [
       "version: 1",
       "agent:",
       "  extend: default",
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
-    writeFileSync6(mcpConfigPath, JSON.stringify({
-      mcpServers: {
-        chat: {
-          command,
-          args: bridgeArgs
-        }
-      }
-    }), "utf8");
-    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
-      "--mcp-config-file",
-      mcpConfigPath,
       "--session",
-      this.sessionId,
-      ...launch.args
+      this.sessionId
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -5730,7 +5598,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -5844,9 +5712,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os3.homedir()) {
+  const configPath = path7.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -5867,9 +5740,9 @@ function detectKimiModels(home = os3.homedir(), opts = {}) {
 
 // src/drivers/opencode.ts
 import { spawn as spawn8, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 import os4 from "os";
-import path10 from "path";
+import path8 from "path";
 var CHAT_MCP_SERVER_NAME = "chat";
 var CHAT_MCP_TOOL_PREFIX = `${CHAT_MCP_SERVER_NAME}_`;
 var SLOCK_AGENT_NAME = "slock";
@@ -5884,23 +5757,6 @@ var OPENCODE_PROVIDER_LABELS = {
   deepseek: "DeepSeek",
   fusecode: "FuseCode"
 };
-function buildChatBridgeCommand(ctx) {
-  const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-  return [
-    isTsSource ? "npx" : "node",
-    ...isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath],
-    "--agent-id",
-    ctx.agentId,
-    "--server-url",
-    ctx.config.serverUrl,
-    "--auth-token",
-    ctx.config.authToken || ctx.daemonApiKey,
-    "--runtime",
-    "opencode",
-    ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-    "--runtime-actions-only"
-  ];
-}
 function parseOpenCodeConfigContent(raw) {
   if (!raw) return {};
   try {
@@ -5917,7 +5773,7 @@ function parseUserOpenCodeConfig(ctx) {
   return parseOpenCodeConfigContent(raw);
 }
 function readLocalOpenCodeConfig(home = os4.homedir()) {
-  const configPath = path10.join(home, ".config", "opencode", "opencode.json");
+  const configPath = path8.join(home, ".config", "opencode", "opencode.json");
   try {
     return parseOpenCodeConfigContent(readFileSync4(configPath, "utf8"));
   } catch {
@@ -5992,14 +5848,7 @@ function buildOpenCodeConfig(ctx, home = os4.homedir()) {
         prompt: ctx.standingPrompt
       }
     },
-    mcp: {
-      ...recordField(userConfig.mcp),
-      [CHAT_MCP_SERVER_NAME]: {
-        type: "local",
-        command: buildChatBridgeCommand(ctx),
-        enabled: true
-      }
-    }
+    mcp: recordField(userConfig.mcp)
   };
 }
 async function buildOpenCodeLaunchOptions(ctx, home = os4.homedir(), version = null) {
@@ -6110,7 +5959,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -6122,11 +5971,11 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   };
 }
 function isWindowsCommandShim(commandPath) {
-  const ext = path10.win32.extname(commandPath).toLowerCase();
+  const ext = path8.win32.extname(commandPath).toLowerCase();
   return ext === ".cmd" || ext === ".bat";
 }
 function opencodePackageEntryCandidates(packageRoot) {
-  const winPath = path10.win32;
+  const winPath = path8.win32;
   return [
     winPath.join(packageRoot, "bin", "opencode.exe"),
     winPath.join(packageRoot, "bin", "opencode.js"),
@@ -6135,16 +5984,16 @@ function opencodePackageEntryCandidates(packageRoot) {
   ];
 }
 function openCodeSpecForEntry(entry, commandArgs) {
-  if (path10.win32.extname(entry).toLowerCase() === ".exe") {
+  if (path8.win32.extname(entry).toLowerCase() === ".exe") {
     return { command: entry, args: commandArgs, shell: false };
   }
   return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
 }
 function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync7;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync6;
   const execFileSyncFn = deps.execFileSyncFn;
   const env = deps.env ?? process.env;
-  const winPath = path10.win32;
+  const winPath = path8.win32;
   const candidates = [];
   if (execFileSyncFn) {
     try {
@@ -6172,7 +6021,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
 function extractWindowsShimTargets(commandPath, deps = {}) {
   if (!isWindowsCommandShim(commandPath)) return [];
   const readFileSyncFn = deps.readFileSyncFn ?? readFileSync4;
-  const commandDir = path10.win32.dirname(commandPath);
+  const commandDir = path8.win32.dirname(commandPath);
   let raw;
   try {
     raw = String(readFileSyncFn(commandPath, "utf8"));
@@ -6183,7 +6032,7 @@ function extractWindowsShimTargets(commandPath, deps = {}) {
   const dp0Pattern = /%~dp0\\?([^"\r\n]*?opencode\.(?:exe|js|mjs|cjs))/gi;
   for (const match of raw.matchAll(dp0Pattern)) {
     const relative = match[1]?.replace(/^\\+/, "");
-    if (relative) candidates.push(path10.win32.normalize(path10.win32.join(commandDir, relative)));
+    if (relative) candidates.push(path8.win32.normalize(path8.win32.join(commandDir, relative)));
   }
   return candidates;
 }
@@ -6197,7 +6046,7 @@ function resolveOpenCodeSpawn(commandArgs, deps = {}) {
     };
   }
   const command = resolveCommandOnPath("opencode", deps);
-  if (command && path10.win32.extname(command).toLowerCase() === ".exe") {
+  if (command && path8.win32.extname(command).toLowerCase() === ".exe") {
     return { command, args: commandArgs, shell: false };
   }
   const packageEntry = resolveWindowsOpenCodePackageEntry(command, deps);
@@ -6241,7 +6090,7 @@ var OpenCodeDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -6372,8 +6221,8 @@ var OpenCodeDriver = class {
 // src/drivers/pi.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter } from "events";
-import { mkdirSync as mkdirSync4, readdirSync } from "fs";
-import path11 from "path";
+import { mkdirSync as mkdirSync2, readdirSync } from "fs";
+import path9 from "path";
 import {
   AuthStorage,
   createBashTool,
@@ -6399,7 +6248,7 @@ function createPiSdkEventMappingState(sessionId = null) {
   };
 }
 function buildPiSessionDir(workingDirectory) {
-  return path11.join(workingDirectory, PI_SESSION_DIR);
+  return path9.join(workingDirectory, PI_SESSION_DIR);
 }
 async function buildPiSpawnEnv(ctx) {
   return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
@@ -6421,7 +6270,7 @@ function findPiSessionFile(sessionDir, sessionId) {
   }
   const suffix = `_${sessionId}.jsonl`;
   const match = entries.find((entry) => entry.endsWith(suffix));
-  return match ? path11.join(sessionDir, match) : null;
+  return match ? path9.join(sessionDir, match) : null;
 }
 function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
@@ -6570,13 +6419,15 @@ var PI_RUNTIME_SESSION_DESCRIPTOR = {
   busyDelivery: "direct",
   postTurn: "keep_alive"
 };
+var PI_IDLE_PROMPT_RETRY_MS = 25;
+var PI_IDLE_PROMPT_MAX_WAIT_MS = 1e3;
 async function createPiAgentSessionForContext(ctx, sessionId) {
   const sessionDir = buildPiSessionDir(ctx.workingDirectory);
-  mkdirSync4(sessionDir, { recursive: true });
+  mkdirSync2(sessionDir, { recursive: true });
   const spawnEnv = await buildPiSpawnEnv(ctx);
   const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
-  const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
-  const modelRegistry = ModelRegistry.create(authStorage, path11.join(agentDir, "models.json"));
+  const authStorage = AuthStorage.create(path9.join(agentDir, "auth.json"));
+  const modelRegistry = ModelRegistry.create(authStorage, path9.join(agentDir, "models.json"));
   const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
   const model = resolvePiModelFromRegistry(launchRuntimeFields.model, modelRegistry);
   if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
@@ -6687,7 +6538,8 @@ var PiSdkRuntimeSession = class {
       return { ok: true, acceptedAs: "steer" };
     }
     if (session.isStreaming) {
-      return { ok: false, reason: "busy_rejected", error: "Pi session is still streaming" };
+      this.launchPromptAfterStreaming(input.text);
+      return { ok: true, acceptedAs: "prompt" };
     }
     this.launchPrompt(input.text);
     return { ok: true, acceptedAs: "prompt" };
@@ -6729,6 +6581,27 @@ var PiSdkRuntimeSession = class {
     }
     this.deferSdkCall(() => session.prompt(text));
   }
+  launchPromptAfterStreaming(text) {
+    this.deferSdkCall(async () => {
+      const session = this.session;
+      if (!session) return;
+      const ready = await this.waitForStreamingToClear(session);
+      if (this.didClose || this.session !== session) {
+        return;
+      }
+      await (ready ? session.prompt(text) : session.steer(text));
+    });
+  }
+  async waitForStreamingToClear(session) {
+    const deadline = Date.now() + PI_IDLE_PROMPT_MAX_WAIT_MS;
+    while (!this.didClose && this.session === session && session.isStreaming) {
+      if (Date.now() >= deadline) {
+        return false;
+      }
+      await delay(PI_IDLE_PROMPT_RETRY_MS);
+    }
+    return !this.didClose && this.session === session && !session.isStreaming;
+  }
   deferSdkCall(invoke) {
     setImmediate(() => {
       if (this.didClose) return;
@@ -6840,6 +6713,12 @@ var PiDriver = class {
     });
   }
 };
+function delay(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
 
 // src/drivers/runtimeSession.ts
 import { EventEmitter as EventEmitter2 } from "events";
@@ -6998,7 +6877,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path12 from "path";
+import path10 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -7006,7 +6885,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path12.join(dataDir, directoryName);
+  return path10.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -7055,7 +6934,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path12.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path10.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -7074,7 +6953,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path12.join(dataDir, entry.name);
+      const dirPath = path10.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -7537,12 +7416,12 @@ function findSessionJsonl(root, predicate) {
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isFile() || !predicate(entry.name)) continue;
-      return path13.join(dir, entry.name);
+      return path11.join(dir, entry.name);
     }
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isDirectory()) continue;
-      const found = visit(path13.join(dir, entry.name), depth - 1);
+      const found = visit(path11.join(dir, entry.name), depth - 1);
       if (found) return found;
     }
     return null;
@@ -7555,10 +7434,10 @@ function safeSessionFilename(value) {
 }
 function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   try {
-    const dir = path13.join(fallbackDir, ".slock", "runtime-sessions");
-    mkdirSync5(dir, { recursive: true });
-    const filePath = path13.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
-    writeFileSync7(filePath, JSON.stringify({
+    const dir = path11.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync3(dir, { recursive: true });
+    const filePath = path11.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    writeFileSync4(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
       sessionId,
@@ -7577,7 +7456,7 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   }
 }
 function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), fallbackDir) {
-  const directPath = path13.isAbsolute(sessionId) ? sessionId : null;
+  const directPath = path11.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
       if (statSync(directPath).isFile()) {
@@ -7586,7 +7465,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), f
     } catch {
     }
   }
-  const resolvedPath = runtime === "claude" ? findSessionJsonl(path13.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path13.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
+  const resolvedPath = runtime === "claude" ? findSessionJsonl(path11.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path11.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
   if (!resolvedPath && fallbackDir) {
     const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
     if (fallback) return fallback;
@@ -8189,8 +8068,7 @@ function runtimeProfileTurnControl(kind, key, source) {
     source,
     keyHash: hashRuntimeProfileKey(key) ?? null,
     keyPresent: Boolean(key),
-    injectedAtMs: Date.now(),
-    migrationDoneToolObserved: false
+    injectedAtMs: Date.now()
   };
 }
 function pushRecentLines(lines, chunk, maxLines, maxLineLength) {
@@ -8266,6 +8144,9 @@ function classifyStickyTerminalFailure(ap) {
   if (isRuntimeStartTimeoutText(terminalFailure.detail)) return null;
   return null;
 }
+function isAuthClassTerminalLine(text) {
+  return buildRuntimeErrorDiagnosticEnvelope(text).spanAttrs.runtime_error_action_required === true;
+}
 function isProviderStreamFailureText(text) {
   return /stream closed before response\.completed|error decoding response body/i.test(text);
 }
@@ -8583,7 +8464,6 @@ var AgentProcessManager = class _AgentProcessManager {
   startingInboxes = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
-  chatBridgePath;
   slockCliPath;
   sendToServer;
   daemonApiKey;
@@ -8601,8 +8481,7 @@ var AgentProcessManager = class _AgentProcessManager {
   agentVisibleMessageIds = /* @__PURE__ */ new Map();
   daemonVersion;
   computerVersion;
-  constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
-    this.chatBridgePath = chatBridgePath;
+  constructor(sendToServer, daemonApiKey, opts) {
     this.slockCliPath = opts.slockCliPath ?? "";
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
@@ -9129,7 +9008,7 @@ var AgentProcessManager = class _AgentProcessManager {
         );
         wakeMessage = void 0;
       }
-      const agentDataDir = path13.join(this.dataDir, agentId);
+      const agentDataDir = path11.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       let runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
       const legacyRuntimeProfileControl = runtimeConfig.runtimeProfileControl?.kind === "migration" ? runtimeConfig.runtimeProfileControl : null;
@@ -9143,23 +9022,23 @@ var AgentProcessManager = class _AgentProcessManager {
         );
         runtimeConfig = { ...runtimeConfig, runtimeProfileControl: null };
       }
-      const memoryMdPath = path13.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path11.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
         const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      const notesDir = path13.join(agentDataDir, "notes");
+      const notesDir = path11.join(agentDataDir, "notes");
       await mkdir(notesDir, { recursive: true });
       if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
         const seedFiles = buildOnboardingSeedFiles();
         for (const { relativePath, content } of seedFiles) {
-          const fullPath = path13.join(agentDataDir, relativePath);
+          const fullPath = path11.join(agentDataDir, relativePath);
           try {
             await access(fullPath);
           } catch {
-            await mkdir(path13.dirname(fullPath), { recursive: true });
+            await mkdir(path11.dirname(fullPath), { recursive: true });
             await writeFile(fullPath, content);
           }
         }
@@ -9267,7 +9146,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         standingPrompt,
         prompt,
         workingDirectory: agentDataDir,
-        chatBridgePath: this.chatBridgePath,
         slockCliPath: this.slockCliPath,
         daemonApiKey: this.daemonApiKey,
         launchId: launchId || null,
@@ -9414,7 +9292,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           const startupTimeoutTermination = ap.expectedTerminationReason === "startup_timeout";
           const expectedTermination = Boolean(ap.expectedTerminationReason);
           const stickyTerminalFailureDetail = classifyStickyTerminalFailure(ap);
-          const processEndedCleanly = !stickyTerminalFailureDetail && (finalCode === 0 || expectedTermination && !ap.lastRuntimeError);
+          const processEndedCleanly = !stickyTerminalFailureDetail && !startupTimeoutTermination && (finalCode === 0 || expectedTermination && !ap.lastRuntimeError);
           const terminalFailureDetail = processEndedCleanly ? null : stickyTerminalFailureDetail ?? classifyTerminalFailure(ap);
           const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
           const shouldColdStartResumeSession = resumeRecoveryReason !== null;
@@ -9980,20 +9858,37 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }));
         return true;
       }
-      ap.inbox.push(message);
-      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
-        outcome: "queued_terminal_runtime_error",
-        accepted: true,
-        process_present: true,
-        runtime: ap.config.runtime,
-        session_id_present: Boolean(ap.sessionId),
-        launchId: ap.launchId || void 0,
-        is_idle: ap.isIdle,
-        inbox_count: ap.inbox.length
-      }));
-      this.sendAgentStatus(agentId, "inactive", ap.launchId);
-      this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
-      return true;
+      if (stickyTerminalFailure.actionRequired) {
+        if (ap.lastRuntimeError && isAuthClassTerminalLine(ap.lastRuntimeError)) {
+          ap.lastRuntimeError = null;
+        }
+        ap.recentStderr = ap.recentStderr.filter((line) => !isAuthClassTerminalLine(line));
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "user_turn_recover_from_sticky_terminal_error",
+          accepted: true,
+          process_present: true,
+          runtime: ap.config.runtime,
+          session_id_present: Boolean(ap.sessionId),
+          launchId: ap.launchId || void 0,
+          is_idle: ap.isIdle,
+          inbox_count: ap.inbox.length
+        }));
+      } else {
+        ap.inbox.push(message);
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "queued_terminal_runtime_error",
+          accepted: true,
+          process_present: true,
+          runtime: ap.config.runtime,
+          session_id_present: Boolean(ap.sessionId),
+          launchId: ap.launchId || void 0,
+          is_idle: ap.isIdle,
+          inbox_count: ap.inbox.length
+        }));
+        this.sendAgentStatus(agentId, "inactive", ap.launchId);
+        this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+        return true;
+      }
     }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       if (transientDelivery) {
@@ -10161,7 +10056,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return true;
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path13.join(this.dataDir, agentId);
+    const agentDataDir = path11.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -10222,7 +10117,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path13.join(this.dataDir, agentId);
+    const workspacePath = path11.join(this.dataDir, agentId);
     return {
       agentId,
       launchId,
@@ -10481,7 +10376,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path13.join(this.dataDir, agentId);
+    const agentDir = path11.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -10489,8 +10384,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path13.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path13.sep) && resolved !== agentDir) {
+      const resolved = path11.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -10498,14 +10393,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path13.join(this.dataDir, agentId);
-    const resolved = path13.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path13.sep) && resolved !== agentDir) {
+    const agentDir = path11.join(this.dataDir, agentId);
+    const resolved = path11.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
-    const ext = path13.extname(resolved).toLowerCase();
+    const ext = path11.extname(resolved).toLowerCase();
     if (WORKSPACE_TEXT_EXTENSIONS.has(ext) || ext === "") {
       if (info.size > WORKSPACE_TEXT_FILE_MAX_BYTES) throw new Error("File too large");
       const content = await readFile(resolved, "utf-8");
@@ -10540,13 +10435,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
     const home = os5.homedir();
-    const workspaceDir = path13.join(this.dataDir, agentId);
+    const workspaceDir = path11.join(this.dataDir, agentId);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
     const globalResults = await Promise.all(
-      paths.global.map((p) => this.scanSkillsDir(path13.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path11.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path13.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path11.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -10575,7 +10470,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path13.join(dir, entry.name, "SKILL.md");
+        const skillMd = path11.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -10586,7 +10481,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path13.join(dir, entry.name), "utf-8");
+          const content = await readFile(path11.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -10906,8 +10801,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       runtime_profile_key_hash: control.keyHash || void 0,
       runtime_profile_key_present: control.keyPresent,
       runtime_profile_pending_age_ms: pendingAgeMs,
-      runtime_profile_requires_ack: false,
-      runtime_profile_migration_done_observed: control.kind === "migration" ? control.migrationDoneToolObserved : void 0
+      runtime_profile_requires_ack: false
     };
   }
   activateRuntimeProfileTurnControl(ap, control) {
@@ -10919,16 +10813,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (!notification) return null;
     return runtimeProfileTurnControl(notification.kind, notification.key, source);
   }
-  noteRuntimeProfileToolCall(agentId, ap, toolName) {
-    const control = ap.runtimeProfileTurnControl;
-    if (!control || control.kind !== "migration") return;
-    if (!toolName.includes("runtime_profile_migration_done")) return;
-    control.migrationDoneToolObserved = true;
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime_profile.migration_done_tool.observed", {
-      ...this.runtimeProfileTurnControlTraceAttrs(control),
-      tool: toolName
-    });
-  }
   finalizeRuntimeProfileTurnControl(agentId, ap, terminal) {
     const control = ap.runtimeProfileTurnControl;
     if (!control) return {};
@@ -10937,7 +10821,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return {
       ...attrs,
       runtime_profile_turn_terminal: terminal,
-      runtime_profile_turn_outcome: control.kind === "migration" ? control.migrationDoneToolObserved ? "deprecated_migration_done_observed" : "reset_session_notice" : "notice_only"
+      runtime_profile_turn_outcome: control.kind === "migration" ? "reset_session_notice" : "notice_only"
     };
   }
   startRuntimeTrace(agentId, ap, reason, messages, inputTraceAttrs = {}) {
@@ -11342,7 +11226,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         const invocation = normalizeToolDisplayInvocation(event.name, event.input);
         if (ap) {
           const reduction = reduceApmGatedToolUse(ap.gatedSteering, { kind: "tool_call" });
-          this.noteRuntimeProfileToolCall(agentId, ap, invocation.toolName);
           this.recordRuntimeTraceEvent(agentId, ap, "tool.call.started", { tool: invocation.toolName });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, {
             event: "tool_call",
@@ -11923,8 +11806,8 @@ ${RESPONSE_TARGET_HINT}`);
     const nodes = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path13.join(dir, entry.name);
-      const relativePath = path13.relative(rootDir, fullPath);
+      const fullPath = path11.join(dir, entry.name);
+      const relativePath = path11.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -12215,7 +12098,7 @@ var ReminderCache = class {
       logger.warn(`[ReminderCache] Invalid fireAt for ${job.reminderId}: ${job.fireAt}`);
       return null;
     }
-    const delay = Math.max(0, Math.min(this.maxDelayMs, fireAt - this.clock.now()));
+    const delay2 = Math.max(0, Math.min(this.maxDelayMs, fireAt - this.clock.now()));
     return this.clock.setTimeout(() => {
       this.entries.delete(job.reminderId);
       try {
@@ -12223,15 +12106,15 @@ var ReminderCache = class {
       } catch (err) {
         logger.error(`[ReminderCache] onFire threw for ${job.reminderId}`, err);
       }
-    }, delay);
+    }, delay2);
   }
 };
 
 // src/machineLock.ts
 import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
 import os6 from "os";
-import path14 from "path";
+import path12 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -12253,7 +12136,7 @@ function resolveDefaultMachineStateRoot() {
   return resolveSlockHomePath("machines");
 }
 function ownerPath(lockDir) {
-  return path14.join(lockDir, "owner.json");
+  return path12.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
@@ -12283,13 +12166,13 @@ function acquireDaemonMachineLock(options) {
   const rootDir = options.rootDir ?? resolveDefaultMachineStateRoot();
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
-  const machineDir = path14.join(rootDir, lockId);
-  const lockDir = path14.join(machineDir, "daemon.lock");
+  const machineDir = path12.join(rootDir, lockId);
+  const lockDir = path12.join(machineDir, "daemon.lock");
   const token = randomUUID4();
-  mkdirSync6(machineDir, { recursive: true });
+  mkdirSync4(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync6(lockDir);
+      mkdirSync4(lockDir);
       const owner = {
         pid: process.pid,
         token,
@@ -12299,7 +12182,7 @@ function acquireDaemonMachineLock(options) {
         apiKeyFingerprint: fingerprint.slice(0, 16)
       };
       try {
-        writeFileSync8(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+        writeFileSync5(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
 `, { mode: 384 });
       } catch (err) {
         rmSync3(lockDir, { recursive: true, force: true });
@@ -12314,7 +12197,7 @@ function acquireDaemonMachineLock(options) {
           if (currentOwner?.pid === process.pid && currentOwner.token === token) {
             const released = { ...currentOwner, pid: 0 };
             try {
-              writeFileSync8(ownerPath(lockDir), `${JSON.stringify(released, null, 2)}
+              writeFileSync5(ownerPath(lockDir), `${JSON.stringify(released, null, 2)}
 `, {
                 mode: 384
               });
@@ -12344,8 +12227,8 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
-import path15 from "path";
+import { appendFileSync, mkdirSync as mkdirSync5, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import path13 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
@@ -12382,7 +12265,7 @@ var LocalRotatingTraceSink = class {
   currentSize = 0;
   sequence = 0;
   constructor(options) {
-    this.traceDir = path15.join(options.machineDir, "traces");
+    this.traceDir = path13.join(options.machineDir, "traces");
     this.maxFileBytes = Math.max(1024, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
     const baseAgeMs = Math.max(1e3, Math.floor(options.maxFileAgeMs ?? DEFAULT_MAX_FILE_AGE_MS));
     const ageJitterMs = Math.max(0, Math.floor(options.maxFileAgeJitterMs ?? 0));
@@ -12408,15 +12291,15 @@ var LocalRotatingTraceSink = class {
     return this.currentFile;
   }
   ensureFile(nextBytes) {
-    mkdirSync7(this.traceDir, { recursive: true, mode: 448 });
+    mkdirSync5(this.traceDir, { recursive: true, mode: 448 });
     const nowMs = this.nowMsProvider();
     const shouldRotateForAge = this.currentFileOpenedAtMs !== null && nowMs - this.currentFileOpenedAtMs >= this.maxFileAgeMs;
     if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes || shouldRotateForAge) {
-      this.currentFile = path15.join(
+      this.currentFile = path13.join(
         this.traceDir,
         `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
-      writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
+      writeFileSync6(this.currentFile, "", { flag: "a", mode: 384 });
       this.currentSize = statSync3(this.currentFile).size;
       this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
@@ -12427,7 +12310,7 @@ var LocalRotatingTraceSink = class {
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
-      rmSync4(path15.join(this.traceDir, file), { force: true });
+      rmSync4(path13.join(this.traceDir, file), { force: true });
     }
   }
 };
@@ -12518,11 +12401,108 @@ function isDiagnosticErrorAttr(key) {
 import { createHash as createHash6, randomUUID as randomUUID5 } from "crypto";
 import { gzipSync } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import path16 from "path";
+import path14 from "path";
+
+// src/chatBridgeRequest.ts
+var DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS = Number.parseInt(
+  process.env.SLOCK_CHAT_BRIDGE_TOOL_TIMEOUT_MS || "",
+  10
+) || 6e4;
+var ChatBridgeToolTimeoutError = class extends Error {
+  toolName;
+  target;
+  timeoutMs;
+  durationMs;
+  constructor(toolName, target, timeoutMs, durationMs) {
+    super(`${toolName} timed out after ${timeoutMs}ms${target ? ` (target: ${target})` : ""}`);
+    this.name = "ChatBridgeToolTimeoutError";
+    this.toolName = toolName;
+    this.target = target;
+    this.timeoutMs = timeoutMs;
+    this.durationMs = durationMs;
+  }
+};
+function describeError(err) {
+  if (err instanceof Error) return `${err.name}: ${err.message}`;
+  return String(err);
+}
+async function executeJsonRequest(url, init, {
+  toolName,
+  target = null,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
+  fetchImpl,
+  now = () => Date.now(),
+  warn = (message) => logger.warn(message)
+}) {
+  const startedAt = now();
+  const timeoutController = new AbortController();
+  const signals = [timeoutController.signal];
+  if (init.signal) signals.push(init.signal);
+  const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+  const timeout = setTimeout(() => {
+    timeoutController.abort();
+  }, timeoutMs);
+  timeout.unref?.();
+  try {
+    const response = await fetchImpl(url, { ...init, signal });
+    const data = await response.json();
+    return { response, data, durationMs: now() - startedAt };
+  } catch (err) {
+    const durationMs = now() - startedAt;
+    if (timeoutController.signal.aborted && !init.signal?.aborted) {
+      warn(
+        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
+      );
+      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
+    }
+    warn(
+      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
+    );
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function executeResponseRequest(url, init, {
+  toolName,
+  target = null,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
+  fetchImpl,
+  now = () => Date.now(),
+  warn = (message) => logger.warn(message)
+}) {
+  const startedAt = now();
+  const timeoutController = new AbortController();
+  const signals = [timeoutController.signal];
+  if (init.signal) signals.push(init.signal);
+  const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+  const timeout = setTimeout(() => {
+    timeoutController.abort();
+  }, timeoutMs);
+  timeout.unref?.();
+  try {
+    const response = await fetchImpl(url, { ...init, signal });
+    return { response, durationMs: now() - startedAt };
+  } catch (err) {
+    const durationMs = now() - startedAt;
+    if (timeoutController.signal.aborted && !init.signal?.aborted) {
+      warn(
+        `[ChatBridgeTimeout] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} timeout_ms=${timeoutMs} outcome=timeout`
+      );
+      throw new ChatBridgeToolTimeoutError(toolName, target, timeoutMs, durationMs);
+    }
+    warn(
+      `[ChatBridgeError] tool=${toolName} target=${target ?? "-"} duration_ms=${durationMs} outcome=error error=${describeError(err)}`
+    );
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 
 // src/directUploadCapability.ts
-function joinUrl(base, path18) {
-  return `${base.replace(/\/+$/, "")}${path18}`;
+function joinUrl(base, path16) {
+  return `${base.replace(/\/+$/, "")}${path16}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -12741,7 +12721,7 @@ var DaemonTraceBundleUploader = class {
     }, nextMs);
   }
   async findUploadCandidates() {
-    const traceDir = path16.join(this.options.machineDir, "traces");
+    const traceDir = path14.join(this.options.machineDir, "traces");
     let names;
     try {
       names = await readdir3(traceDir);
@@ -12753,8 +12733,8 @@ var DaemonTraceBundleUploader = class {
     const currentFile = this.options.currentFileProvider?.();
     const candidates = [];
     for (const name of names.filter((entry) => entry.startsWith("daemon-trace-") && entry.endsWith(".jsonl")).sort()) {
-      const file = path16.join(traceDir, name);
-      if (currentFile && path16.resolve(file) === path16.resolve(currentFile)) continue;
+      const file = path14.join(traceDir, name);
+      if (currentFile && path14.resolve(file) === path14.resolve(currentFile)) continue;
       if (await this.isUploaded(file)) continue;
       try {
         const info = await stat3(file);
@@ -12828,8 +12808,8 @@ var DaemonTraceBundleUploader = class {
     }
   }
   uploadStatePath(file) {
-    const stateDir = path16.join(this.options.machineDir, "trace-uploads");
-    return path16.join(stateDir, `${path16.basename(file)}.uploaded.json`);
+    const stateDir = path14.join(this.options.machineDir, "trace-uploads");
+    return path14.join(stateDir, `${path14.basename(file)}.uploaded.json`);
   }
   async isUploaded(file) {
     try {
@@ -12841,9 +12821,9 @@ var DaemonTraceBundleUploader = class {
   }
   async markUploaded(file, metadata) {
     const stateFile = this.uploadStatePath(file);
-    await mkdir2(path16.dirname(stateFile), { recursive: true, mode: 448 });
+    await mkdir2(path14.dirname(stateFile), { recursive: true, mode: 448 });
     await writeFile2(stateFile, `${JSON.stringify({
-      file: path16.basename(file),
+      file: path14.basename(file),
       uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...metadata
     }, null, 2)}
@@ -12865,7 +12845,7 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
-var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -12901,9 +12881,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -12919,24 +12899,14 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
     return "0.0.0-dev";
   }
 }
-function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path17.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path17.resolve(dirname, "chat-bridge.js");
-  try {
-    accessSync(jsPath);
-    return jsPath;
-  } catch {
-    return path17.resolve(dirname, "chat-bridge.ts");
-  }
-}
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path17.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path17.resolve(thisDir, "cli", "index.js");
+  const thisDir = path15.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path15.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path17.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path15.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -13073,7 +13043,6 @@ var DaemonCore = class {
   // bundle version). Reported in `ready` so the server can surface the
   // Computer's own version (distinct from the underlying daemonVersion).
   computerVersion;
-  chatBridgePath;
   slockCliPath;
   slockHome;
   runtimeDetector;
@@ -13089,7 +13058,6 @@ var DaemonCore = class {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
     this.computerVersion = (process.env.SLOCK_COMPUTER_VERSION || "").trim() || null;
-    this.chatBridgePath = options.chatBridgePath ?? resolveChatBridgePath();
     this.slockCliPath = options.slockCliPath ?? resolveSlockCliPath();
     this.slockHome = resolveSlockHome();
     process.env[SLOCK_HOME_ENV] = this.slockHome;
@@ -13110,7 +13078,7 @@ var DaemonCore = class {
       daemonVersion: this.daemonVersion,
       computerVersion: this.computerVersion
     };
-    this.agentManager = options.agentManagerFactory ? options.agentManagerFactory(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions);
+    this.agentManager = options.agentManagerFactory ? options.agentManagerFactory((msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager((msg) => connection.send(msg), options.apiKey, agentManagerOptions);
     const connectionFactory = options.connectionFactory ?? ((connOptions) => new DaemonConnection(connOptions));
     connection = connectionFactory({
       serverUrl: options.serverUrl,
@@ -13125,7 +13093,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path17.join(path17.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path15.join(path15.dirname(this.options.dataDir), "machines");
     return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
@@ -13151,7 +13119,7 @@ var DaemonCore = class {
       sink: this.localTraceSink
     }));
     this.agentManager.setTracer(this.tracer);
-    this.agentManager.setCliTransportTraceDir(path17.join(machineDir, "traces"));
+    this.agentManager.setCliTransportTraceDir(path15.join(machineDir, "traces"));
   }
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
@@ -13684,15 +13652,13 @@ var DaemonCore = class {
 };
 
 export {
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
+  subscribeDaemonLogs,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,
   DAEMON_CLI_USAGE,
   parseDaemonCliArgs,
   readDaemonVersion,
-  resolveChatBridgePath,
   resolveSlockCliPath,
   detectRuntimes,
   DaemonCore