cc-claw 0.26.0 → 0.27.1

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.26.0" : (() => {
+    VERSION = true ? "0.27.1" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -417,8 +417,8 @@ function updateAgentResult(db3, id, opts) {
     id
   );
 }
-function updateAgentMcpsAdded(db3, id, mcps2) {
-  db3.prepare("UPDATE agents SET mcpsAdded = ? WHERE id = ?").run(JSON.stringify(mcps2), id);
+function updateAgentMcpsAdded(db3, id, mcps) {
+  db3.prepare("UPDATE agents SET mcpsAdded = ? WHERE id = ?").run(JSON.stringify(mcps), id);
 }
 function createTask(db3, opts) {
   const result = db3.prepare(`
@@ -535,6 +535,7 @@ var store_exports2 = {};
 __export(store_exports2, {
   addMcpServer: () => addMcpServer,
   addPropagation: () => addPropagation,
+  getEnabledMcps: () => getEnabledMcps,
   getMcpServer: () => getMcpServer,
   getPropagationsForRunner: () => getPropagationsForRunner,
   initMcpTables: () => initMcpTables,
@@ -637,6 +638,11 @@ function getMcpServer(db3, name) {
 function listMcpServers(db3) {
   return db3.prepare("SELECT * FROM mcp_servers ORDER BY name").all();
 }
+function getEnabledMcps(db3) {
+  return db3.prepare(
+    "SELECT * FROM mcp_servers WHERE enabledByDefault = 1 ORDER BY name"
+  ).all();
+}
 function addPropagation(db3, mcpName, runnerId, scope) {
   db3.prepare(`
     INSERT OR IGNORE INTO mcp_propagation (mcpName, runnerId, scope, addedAt) VALUES (?, ?, ?, datetime('now'))
@@ -1770,6 +1776,12 @@ function initSchema(db3) {
       whitelist TEXT
     );
   `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS chat_api_web_search (
+      chat_id TEXT PRIMARY KEY,
+      enabled INTEGER DEFAULT 1
+    );
+  `);
   db3.exec(`
     CREATE TABLE IF NOT EXISTS api_backend_models (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -5174,7 +5186,6 @@ var init_claude = __esm({
         switch (opts.permMode) {
           case "plan":
             args.push("--permission-mode", "plan");
-            args.push("--strict-mcp-config");
             break;
           case "safe":
             args.push("--permission-mode", "bypassPermissions");
@@ -6276,8 +6287,11 @@ __export(api_whitelist_exports, {
   addCliToWhitelist: () => addCliToWhitelist,
   clearApiCliWhitelist: () => clearApiCliWhitelist,
   getApiCliWhitelist: () => getApiCliWhitelist,
+  getApiWebSearchEnabled: () => getApiWebSearchEnabled,
   removeCliFromWhitelist: () => removeCliFromWhitelist,
   setApiCliWhitelist: () => setApiCliWhitelist,
+  setApiWebSearchEnabled: () => setApiWebSearchEnabled,
+  toggleApiWebSearchEnabled: () => toggleApiWebSearchEnabled,
   updateCliCapabilities: () => updateCliCapabilities
 });
 function getApiCliWhitelist(chatId) {
@@ -6328,6 +6342,28 @@ function updateCliCapabilities(chatId, cli, capabilities) {
 function clearApiCliWhitelist(chatId) {
   getDb().prepare("DELETE FROM chat_api_cli_whitelist WHERE chat_id = ?").run(chatId);
 }
+function getApiWebSearchEnabled(chatId) {
+  try {
+    const row = getDb().prepare(
+      "SELECT enabled FROM chat_api_web_search WHERE chat_id = ?"
+    ).get(chatId);
+    return row ? row.enabled !== 0 : true;
+  } catch {
+    return true;
+  }
+}
+function setApiWebSearchEnabled(chatId, enabled) {
+  getDb().prepare(`
+    INSERT INTO chat_api_web_search (chat_id, enabled)
+    VALUES (?, ?)
+    ON CONFLICT(chat_id) DO UPDATE SET enabled = ?
+  `).run(chatId, enabled ? 1 : 0, enabled ? 1 : 0);
+}
+function toggleApiWebSearchEnabled(chatId) {
+  const next = !getApiWebSearchEnabled(chatId);
+  setApiWebSearchEnabled(chatId, next);
+  return next;
+}
 var init_api_whitelist = __esm({
   "src/memory/api-whitelist.ts"() {
     "use strict";
@@ -6410,29 +6446,32 @@ function isSensitivePath(filePath) {
   if (SENSITIVE_EXACT.has(normalized)) return true;
   return SENSITIVE_PATTERNS.some((pattern) => pattern.test(normalized));
 }
-function createRestrictedBashTool(chatId) {
+function createRestrictedBashTool(chatId, permMode, whitelist) {
+  const isYolo = permMode === "yolo";
   return tool({
-    description: "Run a shell command. Only commands starting with a whitelisted CLI are allowed. Use this for tasks like searching, fetching URLs, running scripts, or interacting with tools the user has approved.",
+    description: isYolo ? `Run any shell command. Use this for ALL external CLI tools. No restrictions. Format: restrictedBash({command: 'gsearch "query" --type news'})` : "Run a whitelisted shell command. Use this for ANY external CLI tool \u2014 do NOT call CLIs as separate tools by name, always route them through restrictedBash. Format: restrictedBash({command: 'toolname args...'})",
     inputSchema: z.object({
       command: z.string().describe("The shell command to run")
     }),
     execute: async ({ command }) => {
-      const whitelist = getApiCliWhitelist(chatId);
       const trimmed = command.trim();
       const firstWord = trimmed.split(/\s+/)[0];
       if (!firstWord) {
         return { error: "Empty command" };
       }
-      const entry = whitelist.find((w) => w.cli === firstWord);
-      if (!entry) {
-        const allowed = whitelist.map((w) => w.cli).join(", ") || "(none)";
-        return {
-          error: `Command "${firstWord}" is not in the allowed CLI list. Allowed: ${allowed}. The user can add CLIs via /tools.`
-        };
-      }
-      const dangerousPatterns = /[;|&`$(){}]|>>|<<|\n/;
-      if (dangerousPatterns.test(trimmed.slice(firstWord.length))) {
-        return { output: `Error: Command contains disallowed shell operators. Only simple arguments are allowed with whitelisted commands.`, exitCode: 1 };
+      if (!isYolo) {
+        const list = whitelist ?? getApiCliWhitelist(chatId);
+        const entry = list.find((w) => w.cli === firstWord);
+        if (!entry) {
+          const allowed = list.map((w) => w.cli).join(", ") || "(none)";
+          return {
+            error: `Command "${firstWord}" is not whitelisted. Allowed commands: ${allowed}. IMPORTANT: Stop retrying. Tell the user exactly this: "I tried to run '${firstWord}' but it's not in your approved tools list. Go to /tools \u2192 Add Command \u2192 type '${firstWord}' to allow it, then ask me again."`
+          };
+        }
+        const dangerousPatterns = /[;|&`$(){}]|>>|<<|\n/;
+        if (dangerousPatterns.test(trimmed.slice(firstWord.length))) {
+          return { output: `Error: Command contains disallowed shell operators. Only simple arguments are allowed with whitelisted commands.`, exitCode: 1 };
+        }
       }
       log(`[api-tools] Executing whitelisted command: ${trimmed.slice(0, 100)}`);
       try {
@@ -6569,13 +6608,19 @@ function createListFilesTool() {
 }
 function createWebSearchTool() {
   return tool({
-    description: "Search the web using DuckDuckGo for current information. Use this when you need up-to-date facts, news, documentation, or answers that may not be in your training data.",
+    description: "Search the web using DuckDuckGo for current information. Use this when you need up-to-date facts, news, documentation, or answers that may not be in your training data. If whitelisted search CLIs (pwm, gemcli) are available, prefer those instead.",
     inputSchema: z.object({
       query: z.string().describe("The search query"),
       maxResults: z.number().optional().describe("Maximum results to return (default: 5, max: 10)")
     }),
     execute: async ({ query, maxResults }) => {
       log(`[api-tools] Web search: ${query.slice(0, 80)}`);
+      const now = Date.now();
+      const gap = now - lastDdgSearchAt;
+      if (gap < DDG_MIN_GAP_MS) {
+        await new Promise((r) => setTimeout(r, DDG_MIN_GAP_MS - gap));
+      }
+      lastDdgSearchAt = Date.now();
       try {
         const response = await searchWeb(query, maxResults ?? 5);
         if (response.results.length === 0) {
@@ -6597,27 +6642,26 @@ function createWebSearchTool() {
     }
   });
 }
-function buildApiTools(chatId, permMode, mcpTools) {
-  const webSearch = createWebSearchTool();
+function buildApiTools(chatId, permMode, mcpTools, webSearchEnabled) {
+  const searchEnabled = webSearchEnabled ?? getApiWebSearchEnabled(chatId);
   const readOnly = {
     readFile: createReadFileTool(),
     listFiles: createListFilesTool(),
-    webSearch
-  };
-  const writable = {
-    ...readOnly,
-    restrictedBash: createRestrictedBashTool(chatId)
+    ...searchEnabled ? { webSearch: createWebSearchTool() } : {}
   };
   if (mcpTools) {
-    Object.assign(writable, mcpTools);
     Object.assign(readOnly, filterReadOnlyMcpTools(mcpTools));
   }
   switch (permMode) {
-    case "yolo":
-      return writable;
+    case "yolo": {
+      const all = { ...readOnly, ...mcpTools ?? {}, restrictedBash: createRestrictedBashTool(chatId, permMode) };
+      return all;
+    }
     case "safe": {
       const whitelist = getApiCliWhitelist(chatId);
-      return whitelist.length > 0 ? writable : readOnly;
+      const base = { ...readOnly, ...mcpTools ?? {} };
+      if (whitelist.length === 0) return base;
+      return { ...base, restrictedBash: createRestrictedBashTool(chatId, permMode, whitelist) };
     }
     case "plan":
       return readOnly;
@@ -6635,7 +6679,7 @@ function filterReadOnlyMcpTools(mcpTools) {
   }
   return filtered;
 }
-var execFileAsync2, HOME, SENSITIVE_PATTERNS, SENSITIVE_EXACT, MAX_READ_BYTES;
+var execFileAsync2, HOME, SENSITIVE_PATTERNS, SENSITIVE_EXACT, MAX_READ_BYTES, lastDdgSearchAt, DDG_MIN_GAP_MS;
 var init_api_tools = __esm({
   "src/backends/api-tools.ts"() {
     "use strict";
@@ -6667,6 +6711,151 @@ var init_api_tools = __esm({
       normalize(resolve(CC_CLAW_HOME, ".env"))
     ]);
     MAX_READ_BYTES = 1e5;
+    lastDdgSearchAt = 0;
+    DDG_MIN_GAP_MS = 3e3;
+  }
+});
+
+// src/mcps/pool.ts
+var pool_exports = {};
+__export(pool_exports, {
+  McpConnectionPool: () => McpConnectionPool,
+  getMcpPool: () => getMcpPool,
+  shutdownMcpPool: () => shutdownMcpPool
+});
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+function getMcpPool() {
+  if (!poolInstance) poolInstance = new McpConnectionPool();
+  return poolInstance;
+}
+async function shutdownMcpPool() {
+  if (poolInstance) {
+    await poolInstance.shutdown();
+    poolInstance = null;
+  }
+}
+var MAX_RETRIES, BASE_BACKOFF_MS, MAX_BACKOFF_MS, McpConnectionPool, poolInstance;
+var init_pool = __esm({
+  "src/mcps/pool.ts"() {
+    "use strict";
+    init_env();
+    init_log();
+    MAX_RETRIES = 5;
+    BASE_BACKOFF_MS = 2e3;
+    MAX_BACKOFF_MS = 6e4;
+    McpConnectionPool = class {
+      connections = /* @__PURE__ */ new Map();
+      connecting = /* @__PURE__ */ new Map();
+      /** Cached merged tool set — invalidated on connect/disconnect. */
+      cachedAllTools = null;
+      /**
+       * Connect to an MCP server and cache the connection.
+       * Returns the tool set. Reuses existing connection if already connected.
+       */
+      async connect(name, config2) {
+        const existing = this.connections.get(name);
+        if (existing) {
+          existing.lastUsedAt = Date.now();
+          return existing.tools;
+        }
+        const inflight = this.connecting.get(name);
+        if (inflight) {
+          const conn = await inflight;
+          return conn?.tools ?? {};
+        }
+        const promise = this.doConnect(name, config2);
+        this.connecting.set(name, promise);
+        try {
+          const conn = await promise;
+          return conn?.tools ?? {};
+        } finally {
+          this.connecting.delete(name);
+        }
+      }
+      async doConnect(name, config2, retryCount = 0) {
+        try {
+          const transport = new Experimental_StdioMCPTransport({
+            command: config2.command,
+            args: config2.args,
+            env: buildBaseEnv(config2.env)
+          });
+          const client = await createMCPClient({ transport });
+          const tools2 = await client.tools();
+          const conn = {
+            name,
+            client,
+            tools: tools2,
+            config: config2,
+            connectedAt: Date.now(),
+            lastUsedAt: Date.now()
+          };
+          this.connections.set(name, conn);
+          this.cachedAllTools = null;
+          log(`[mcp-pool] Connected to ${name} (${Object.keys(tools2).length} tools)`);
+          return conn;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          warn(`[mcp-pool] Failed to connect to ${name}: ${msg}`);
+          if (retryCount < MAX_RETRIES) {
+            const backoff = Math.min(BASE_BACKOFF_MS * 2 ** retryCount, MAX_BACKOFF_MS);
+            log(`[mcp-pool] Retrying ${name} in ${backoff}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`);
+            await new Promise((r) => setTimeout(r, backoff));
+            return this.doConnect(name, config2, retryCount + 1);
+          }
+          warn(`[mcp-pool] Giving up on ${name} after ${MAX_RETRIES} retries`);
+          return null;
+        }
+      }
+      /** Get tools for a specific MCP. Returns empty object if not connected. */
+      async getTools(name) {
+        const conn = this.connections.get(name);
+        if (conn) {
+          conn.lastUsedAt = Date.now();
+          return conn.tools;
+        }
+        return {};
+      }
+      /** Get aggregated tools from ALL connected MCPs. Result is cached until a connect/disconnect. */
+      async getAllTools() {
+        if (this.cachedAllTools) return this.cachedAllTools;
+        const all = {};
+        for (const conn of this.connections.values()) {
+          conn.lastUsedAt = Date.now();
+          Object.assign(all, conn.tools);
+        }
+        this.cachedAllTools = all;
+        return all;
+      }
+      /** Disconnect a specific MCP and remove from pool. */
+      async disconnect(name) {
+        const conn = this.connections.get(name);
+        if (!conn) return;
+        try {
+          await conn.client.close();
+        } catch (err) {
+          warn(`[mcp-pool] Error closing ${name}: ${err instanceof Error ? err.message : err}`);
+        }
+        this.connections.delete(name);
+        this.cachedAllTools = null;
+        log(`[mcp-pool] Disconnected ${name}`);
+      }
+      /** Close all connections. Called on SIGTERM. */
+      async shutdown() {
+        const names = [...this.connections.keys()];
+        await Promise.allSettled(names.map((n) => this.disconnect(n)));
+        log(`[mcp-pool] Shutdown complete (${names.length} connection(s) closed)`);
+      }
+      /** Check if a specific MCP is currently connected. */
+      isConnected(name) {
+        return this.connections.has(name);
+      }
+      /** List names of all connected MCPs. */
+      listConnected() {
+        return [...this.connections.keys()];
+      }
+    };
+    poolInstance = null;
   }
 });
 
@@ -6714,6 +6903,17 @@ function writeMcpConfigFile(config2) {
   }
   return configPath;
 }
+function writeUnifiedMcpConfigFile(config2) {
+  const filePath = join8(MCP_CONFIG_DIR, "mcp-unified.json");
+  const content = JSON.stringify(config2, null, 2);
+  if (lastWrittenConfig.get(filePath) === content) return filePath;
+  if (!existsSync9(MCP_CONFIG_DIR)) {
+    mkdirSync3(MCP_CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  writeFileSync2(filePath, content, { mode: 384 });
+  lastWrittenConfig.set(filePath, content);
+  return filePath;
+}
 function deleteMcpConfigFile(mcpName) {
   const safeName = mcpName.replace(/[^a-zA-Z0-9-]/g, "_");
   const configPath = join8(MCP_CONFIG_DIR, `mcp-${safeName}.json`);
@@ -6751,35 +6951,27 @@ var init_mcp_config = __esm({
 });
 
 // src/backends/api-mcp.ts
-import { createMCPClient } from "@ai-sdk/mcp";
-import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
-var ALLOWED_MCP_TOOL_PREFIXES, McpClientManager;
+var McpClientManager;
 var init_api_mcp = __esm({
   "src/backends/api-mcp.ts"() {
     "use strict";
+    init_pool();
+    init_store2();
+    init_store5();
     init_mcp_config();
     init_paths();
     init_log();
-    ALLOWED_MCP_TOOL_PREFIXES = [
-      "cc_claw_memory",
-      "cc_claw_schedule",
-      "cc_claw_comms"
-    ];
     McpClientManager = class {
       constructor(chatId, port) {
         this.chatId = chatId;
         this.port = port;
       }
-      client = null;
-      /**
-       * Check if the dashboard (and thus MCP server) is available.
-       * The dashboard must be running for the MCP server to work.
-       */
       isDashboardAvailable() {
         return process.env.DASHBOARD_ENABLED === "1";
       }
       /**
-       * Connect to the orchestrator MCP server and return filtered tools.
+       * Get all MCP tools from the connection pool.
+       * Lazily connects MCPs not yet in the pool.
        * Returns empty object if dashboard is unavailable.
        */
       async getTools() {
@@ -6788,79 +6980,69 @@ var init_api_mcp = __esm({
           return {};
         }
         try {
+          const pool = getMcpPool();
+          const db3 = getDb();
           const token = readApiToken();
           if (!token) {
-            warn("[api-mcp] No API token found, skipping MCP tools");
-            return {};
+            warn("[api-mcp] No API token \u2014 orchestrator MCP unavailable");
           }
-          const config2 = generateOrchestratorMcpConfig({
-            chatId: this.chatId,
-            agentId: "api-backend",
-            token,
-            port: this.port ?? process.env.DASHBOARD_PORT ?? "3141"
-          });
-          const cleanEnv = {};
-          for (const [k, v] of Object.entries(process.env)) {
-            if (v !== void 0) cleanEnv[k] = v;
+          if (token) {
+            const orchConfig = generateOrchestratorMcpConfig({
+              chatId: this.chatId,
+              agentId: "api-backend",
+              token,
+              port: this.port ?? process.env.DASHBOARD_PORT ?? "3141"
+            });
+            if (!pool.isConnected(orchConfig.name)) {
+              await pool.connect(orchConfig.name, {
+                command: orchConfig.command,
+                args: orchConfig.args ?? [],
+                env: orchConfig.env ?? {}
+              });
+            }
           }
-          if (config2.env) Object.assign(cleanEnv, config2.env);
-          if (!config2.command) {
-            warn("[api-mcp] MCP command not configured \u2014 skipping orchestrator connection");
-            return {};
+          const mcps = getEnabledMcps(db3);
+          for (const mcp2 of mcps) {
+            if (mcp2.transport !== "stdio" || !mcp2.command) continue;
+            if (pool.isConnected(mcp2.name)) continue;
+            let args = [];
+            let env = {};
+            try {
+              args = mcp2.args ? JSON.parse(mcp2.args) : [];
+              env = mcp2.env ? JSON.parse(mcp2.env) : {};
+            } catch {
+              warn(`[api-mcp] Skipping ${mcp2.name}: malformed args/env JSON in DB`);
+              continue;
+            }
+            const config2 = {
+              command: mcp2.command,
+              args,
+              env
+            };
+            pool.connect(mcp2.name, config2).catch((err) => {
+              warn(`[api-mcp] Failed to connect ${mcp2.name}: ${err instanceof Error ? err.message : err}`);
+            });
           }
-          const transport = new Experimental_StdioMCPTransport({
-            command: config2.command,
-            args: config2.args ?? [],
-            env: cleanEnv
-          });
-          this.client = await createMCPClient({ transport });
-          const allTools = await this.client.tools();
-          return this.filterTools(allTools);
+          const tools2 = await pool.getAllTools();
+          log(`[api-mcp] Loaded ${Object.keys(tools2).length} tool(s) from pool`);
+          return tools2;
         } catch (err) {
-          warn(
-            "[api-mcp] Failed to connect to MCP server:",
-            err instanceof Error ? err.message : String(err)
-          );
+          warn("[api-mcp] Failed to get tools from pool:", err instanceof Error ? err.message : String(err));
           return {};
         }
       }
       /**
-       * Close the MCP client connection. MUST be called after each request.
-       * Safe to call multiple times.
+       * No-op — pool connections are persistent, managed by the pool lifecycle.
+       * close() is called by api-common.ts in a finally block; keeping it safe to call.
        */
       async close() {
-        if (this.client) {
-          try {
-            await this.client.close();
-          } catch (err) {
-            warn(
-              "[api-mcp] Error closing MCP client:",
-              err instanceof Error ? err.message : String(err)
-            );
-          }
-          this.client = null;
-        }
-      }
-      /**
-       * Filter MCP tools to only allowed prefixes.
-       * Excludes agent orchestration tools that don't work with API backends.
-       */
-      filterTools(allTools) {
-        const filtered = {};
-        for (const [name, t] of Object.entries(allTools)) {
-          if (ALLOWED_MCP_TOOL_PREFIXES.some((prefix) => name.startsWith(prefix))) {
-            filtered[name] = t;
-          }
-        }
-        log(`[api-mcp] Loaded ${Object.keys(filtered).length} MCP tools (of ${Object.keys(allTools).length} total)`);
-        return filtered;
       }
     };
   }
 });
 
 // src/backends/api-common.ts
-import { streamText, stepCountIs } from "ai";
+import { streamText, stepCountIs, NoOutputGeneratedError } from "ai";
 function toModelMessage(msg) {
   switch (msg.role) {
     case "system":
@@ -6883,6 +7065,7 @@ var init_api_common = __esm({
     "use strict";
     init_api_context();
     init_api_tools();
+    init_api_whitelist();
     init_api_mcp();
     init_log();
     ApiBackendBase = class {
@@ -6933,7 +7116,7 @@ var init_api_common = __esm({
         } catch (err) {
           log(`[api-common] MCP tools unavailable: ${err instanceof Error ? err.message : String(err)}`);
         }
-        const tools2 = buildApiTools(chatId, permMode, mcpTools);
+        const tools2 = buildApiTools(chatId, permMode, mcpTools, getApiWebSearchEnabled(chatId));
         const hasTools = Object.keys(tools2).length > 0;
         let abortSignal = signal;
         let timeoutHandle;
@@ -6957,7 +7140,7 @@ var init_api_common = __esm({
             // Tool calling: provide tools and allow up to 5 steps
             ...hasTools ? {
               tools: tools2,
-              stopWhen: stepCountIs(5),
+              stopWhen: stepCountIs(15),
               onStepFinish: ({ toolCalls, toolResults }) => {
                 if (onToolAction && toolCalls.length > 0) {
                   for (const tc of toolCalls) {
@@ -7005,6 +7188,9 @@ var init_api_common = __esm({
           if (abortSignal?.aborted || signal?.aborted || err instanceof Error && (err.name === "AbortError" || err.message.toLowerCase().includes("abort") || err.message.toLowerCase().includes("cancel"))) {
             return { text: "", cost: null };
           }
+          if (NoOutputGeneratedError.isInstance(err)) {
+            return { text: "", cost: null };
+          }
           throw err;
         } finally {
           if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
@@ -8281,7 +8467,7 @@ var init_ollama2 = __esm({
 });
 
 // src/backends/openrouter.ts
-import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible as createOpenAICompatible2 } from "@ai-sdk/openai-compatible";
 var OPENROUTER_HTTP_SENTINEL, DEFAULT_FREE_MODEL, OpenRouterAdapter;
 var init_openrouter = __esm({
   "src/backends/openrouter.ts"() {
@@ -8336,7 +8522,8 @@ var init_openrouter = __esm({
        */
       createProvider(model2) {
         const apiKey = this.getApiKey();
-        const openrouterProvider = createOpenAI({
+        const openrouterProvider = createOpenAICompatible2({
+          name: "openrouter",
           baseURL: "https://openrouter.ai/api/v1",
           apiKey: apiKey || "sk-or-no-key",
           headers: {
@@ -8356,7 +8543,7 @@ var init_openrouter = __esm({
       async streamDirect(prompt, model2, opts) {
         const onToolAction = opts?.onToolAction ? (event) => {
           const input = event.input ?? {};
-          const result2 = event.type === "tool_end" ? String(event.output ?? "") : void 0;
+          const result2 = event.type === "tool_end" ? typeof event.output === "string" ? event.output : JSON.stringify(event.output ?? "") : void 0;
           opts.onToolAction(event.toolName, input, result2);
         } : void 0;
         const apiOpts = {
@@ -9630,58 +9817,73 @@ var init_init = __esm({
 });
 
 // src/bootstrap/loader.ts
-import { readFileSync as readFileSync7, existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
+import { readFileSync as readFileSync7, readdirSync as readdirSync4 } from "fs";
 import { join as join10 } from "path";
-function loadContextFiles() {
-  if (contextCache && Date.now() - contextCache.timestamp < CONTEXT_CACHE_TTL_MS) {
-    return contextCache.files;
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3)
+  );
+}
+function stripFrontmatter(content) {
+  if (!content.startsWith("---")) return content;
+  const end = content.indexOf("---", 3);
+  return end === -1 ? content : content.slice(end + 3).trim();
+}
+function loadMarkdownDir(dir, cacheRef, wordSource = (c) => c) {
+  if (cacheRef.v && Date.now() - cacheRef.v.timestamp < CACHE_TTL_MS2) {
+    return cacheRef.v.files;
   }
   const files = /* @__PURE__ */ new Map();
   try {
-    const entries = readdirSync4(CONTEXT_DIR2).filter((f) => f.endsWith(".md"));
-    for (const entry of entries) {
+    for (const entry of readdirSync4(dir)) {
+      if (!entry.endsWith(".md")) continue;
       try {
-        const content = readFileSync7(join10(CONTEXT_DIR2, entry), "utf-8").trim();
-        if (content) files.set(entry, content);
+        const content = readFileSync7(join10(dir, entry), "utf-8").trim();
+        if (content) files.set(entry, { content, words: tokenize(wordSource(content)) });
       } catch {
         continue;
       }
     }
-  } catch (err) {
-    warn("[bootstrap] Failed to load context directory:", err instanceof Error ? err.message : err);
+  } catch {
   }
-  contextCache = { files, timestamp: Date.now() };
+  cacheRef.v = { files, timestamp: Date.now() };
   return files;
 }
-function searchContext(userMessage) {
-  if (!existsSync12(CONTEXT_DIR2)) return null;
-  const msgWords = new Set(
-    userMessage.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3)
-  );
+function findBestMatch(userMessage, files, opts) {
+  const msgWords = tokenize(userMessage);
   if (msgWords.size === 0) return null;
-  let bestMatch = null;
-  const contextFiles = loadContextFiles();
-  for (const [file, content] of contextFiles) {
-    const fileWords = new Set(
-      content.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 3)
-    );
+  let best = null;
+  for (const entry of files.values()) {
+    if (opts.filter && !opts.filter(entry)) continue;
     let score = 0;
     for (const word of msgWords) {
-      if (fileWords.has(word)) score++;
+      if (entry.words.has(word)) score++;
     }
-    if (score > 0 && (!bestMatch || score > bestMatch.score)) {
-      bestMatch = { file, score, content };
+    if (score >= 2 && (!best || score > best.score)) {
+      best = { score, content: entry.content };
     }
   }
-  if (bestMatch && bestMatch.score >= 2) {
-    if (bestMatch.content.length > MAX_CONTEXT_CHARS) {
-      return bestMatch.content.slice(0, MAX_CONTEXT_CHARS) + "\n\u2026(truncated)";
+  if (!best) return null;
+  return best.content.length > opts.maxChars ? best.content.slice(0, opts.maxChars) + "\n\u2026(truncated)" : best.content;
+}
+function searchContext(userMessage) {
+  return findBestMatch(
+    userMessage,
+    loadMarkdownDir(CONTEXT_DIR2, contextCacheRef),
+    { maxChars: MAX_CONTEXT_CHARS }
+  );
+}
+function searchSkill(userMessage) {
+  return findBestMatch(
+    userMessage,
+    loadMarkdownDir(SKILLS_DIR, skillCacheRef, stripFrontmatter),
+    {
+      maxChars: MAX_SKILL_CHARS,
+      filter: ({ content }) => content.includes("status: approved") || content.includes("status: imported")
     }
-    return bestMatch.content;
-  }
-  return null;
+  );
 }
-async function assembleBootstrapPrompt(userMessage, entityType = "main", profile = "interactive", chatId, permMode, responseStyle, agentMode, sideQuestContext, planningDirective, chatContext) {
+async function assembleBootstrapPrompt(userMessage, entityType = "main", profile = "interactive", chatId, permMode, responseStyle, agentMode, sideQuestContext, planningDirective, chatContext, backendType) {
   const sections = [];
   if (planningDirective) {
     sections.push(planningDirective);
@@ -9693,6 +9895,15 @@ async function assembleBootstrapPrompt(userMessage, entityType = "main", profile
   if (permMode && permMode !== "yolo") {
     sections.push(buildPermissionNotice(permMode));
   }
+  if (backendType === "api" && profile !== "minimal") {
+    sections.push(`[API Backend \u2014 Tool Usage]
+You are operating as a direct API model (not a CLI like Claude Code or Gemini CLI).
+External tools (gsearch, pwm, gws, gemcli, nlm, curl, python3, etc.) are accessed ONLY via the \`restrictedBash\` tool.
+NEVER call external CLIs as direct tools by name \u2014 they are not registered as native tools.
+Correct: restrictedBash({"command": "gsearch \\"query\\" --type news"})
+Incorrect: gsearch({"query": "..."})  \u2190 this will fail silently
+If a skill or instruction says to use a CLI tool, always route it through restrictedBash.`);
+  }
   if (responseStyle) {
     if (responseStyle === "concise") {
       sections.push("[Response Style]\nYou must be as concise and direct as possible. Avoid unnecessary verbosity, pleasantries, or long explanations.");
@@ -9720,6 +9931,13 @@ ${parts.join("\n")}`);
 ${ctx}`);
     }
   }
+  if (profile === "interactive" || profile === "chat") {
+    const skill = searchSkill(userMessage);
+    if (skill) {
+      sections.push(`[Relevant skill]
+${skill}`);
+    }
+  }
   if (chatId && profile !== "minimal" && profile !== "chat") {
     if (sideQuestContext) {
       const bridge = buildContextBridge(sideQuestContext.parentChatId, 15);
@@ -9879,7 +10097,7 @@ ${parts.join("\n")}${MEMORY_DISCIPLINE}`;
   }
   return null;
 }
-var lastSyncMs, CONTEXT_DIR2, MAX_CONTEXT_CHARS, contextCache, CONTEXT_CACHE_TTL_MS, ACTIVITY_TOKEN_BUDGET, INBOX_TOKEN_BUDGET, WHITEBOARD_TOKEN_BUDGET;
+var lastSyncMs, CONTEXT_DIR2, SKILLS_DIR, MAX_CONTEXT_CHARS, MAX_SKILL_CHARS, CACHE_TTL_MS2, contextCacheRef, skillCacheRef, ACTIVITY_TOKEN_BUDGET, INBOX_TOKEN_BUDGET, WHITEBOARD_TOKEN_BUDGET;
 var init_loader = __esm({
   "src/bootstrap/loader.ts"() {
     "use strict";
@@ -9893,9 +10111,12 @@ var init_loader = __esm({
     init_backends();
     lastSyncMs = 0;
     CONTEXT_DIR2 = join10(WORKSPACE_PATH, "context");
+    SKILLS_DIR = join10(WORKSPACE_PATH, "skills");
     MAX_CONTEXT_CHARS = 4e3;
-    contextCache = null;
-    CONTEXT_CACHE_TTL_MS = 3e4;
+    MAX_SKILL_CHARS = 6e3;
+    CACHE_TTL_MS2 = 3e4;
+    contextCacheRef = { v: null };
+    skillCacheRef = { v: null };
     ACTIVITY_TOKEN_BUDGET = 1500;
     INBOX_TOKEN_BUDGET = 2e3;
     WHITEBOARD_TOKEN_BUDGET = 500;
@@ -10192,7 +10413,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         const key = `${targetAdapter.id}:${model2}`;
         if (!tried.has(key)) {
           tried.add(key);
-          const result = await attemptSummarize(chatId, targetAdapter, model2, entries);
+          const result = targetAdapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => targetAdapter.streamDirect(p, model2), targetAdapter.id, model2, entries, getTranscriptCap(model2)) : await attemptSummarize(chatId, targetAdapter, model2, entries);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, targetAdapter.id, model2);
             if (clearLogAfter) clearLog(chatId);
@@ -10210,7 +10431,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         const key = `${adapter.id}:${model2}`;
         if (!tried.has(key)) {
           tried.add(key);
-          const result = await attemptSummarize(chatId, adapter, model2, entries);
+          const result = adapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => adapter.streamDirect(p, model2), adapter.id, model2, entries, adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2)) : await attemptSummarize(chatId, adapter, model2, entries);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, adapter.id, model2);
             if (clearLogAfter) clearLog(chatId);
@@ -11199,7 +11420,7 @@ __export(discover_exports, {
   discoverAllSkills: () => discoverAllSkills,
   invalidateSkillCache: () => invalidateSkillCache,
   resolveSkillForTask: () => resolveSkillForTask,
-  stripFrontmatter: () => stripFrontmatter
+  stripFrontmatter: () => stripFrontmatter2
 });
 import { readdir, readFile } from "fs/promises";
 import { createHash } from "crypto";
@@ -11211,7 +11432,7 @@ function invalidateSkillCache() {
 }
 async function discoverAllSkills() {
   const now = Date.now();
-  if (cachedSkills !== null && now - cacheTimestamp < CACHE_TTL_MS2) {
+  if (cachedSkills !== null && now - cacheTimestamp < CACHE_TTL_MS3) {
     return cachedSkills;
   }
   if (pendingScan !== null) {
@@ -11371,7 +11592,7 @@ function parseFrontmatter(content, fallbackName, source) {
     requires
   };
 }
-function stripFrontmatter(content) {
+function stripFrontmatter2(content) {
   return content.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "").trim();
 }
 function resolveSkillForTask(skillName) {
@@ -11379,15 +11600,15 @@ function resolveSkillForTask(skillName) {
   for (const candidate of SKILL_FILE_CANDIDATES3) {
     const skillPath = join11(SKILLS_PATH, skillName, candidate);
     try {
-      const { readFileSync: readFileSync34, existsSync: existsSync63 } = __require("fs");
-      if (!existsSync63(skillPath)) continue;
-      const raw = readFileSync34(skillPath, "utf-8");
+      const { readFileSync: readFileSync35, existsSync: existsSync62 } = __require("fs");
+      if (!existsSync62(skillPath)) continue;
+      const raw = readFileSync35(skillPath, "utf-8");
       const fm = parseFrontmatter(raw, skillName, "cc-claw");
       if (fm.status !== "approved") {
         log(`[skills] Skill "${skillName}" has status "${fm.status}" \u2014 only approved skills can be used as task worker identity`);
         return null;
       }
-      const content = stripFrontmatter(raw);
+      const content = stripFrontmatter2(raw);
       return { content, requires: fm.requires };
     } catch {
       continue;
@@ -11395,7 +11616,7 @@ function resolveSkillForTask(skillName) {
   }
   return null;
 }
-var SKILL_FILE_CANDIDATES, BACKEND_SKILL_DIRS, CACHE_TTL_MS2, cachedSkills, cacheTimestamp, pendingScan;
+var SKILL_FILE_CANDIDATES, BACKEND_SKILL_DIRS, CACHE_TTL_MS3, cachedSkills, cacheTimestamp, pendingScan;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
@@ -11415,7 +11636,7 @@ var init_discover = __esm({
         join11(homedir4(), ".cursor", "skills-cursor")
       ]
     };
-    CACHE_TTL_MS2 = 3e5;
+    CACHE_TTL_MS3 = 3e5;
     cachedSkills = null;
     cacheTimestamp = 0;
     pendingScan = null;
@@ -11425,9 +11646,9 @@ var init_discover = __esm({
 // src/agents/spawn.ts
 import { spawn as spawn2 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
-import { readFileSync as readFileSync8, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync12 } from "fs";
 import { join as join12 } from "path";
-function stripFrontmatter2(text) {
+function stripFrontmatter3(text) {
   const lines = text.split("\n");
   if (lines.length < 2 || lines[0].trim() !== "---") return text;
   for (let i = 1; i < lines.length; i++) {
@@ -11442,10 +11663,10 @@ function resolveSkillContent(skillName) {
   const SKILL_FILE_CANDIDATES3 = ["SKILL.md", "skill.md"];
   for (const candidate of SKILL_FILE_CANDIDATES3) {
     const skillPath = join12(SKILLS_PATH, skillName, candidate);
-    if (existsSync13(skillPath)) {
+    if (existsSync12(skillPath)) {
       try {
         const raw = readFileSync8(skillPath, "utf-8");
-        return stripFrontmatter2(raw).trim();
+        return stripFrontmatter3(raw).trim();
       } catch {
         return null;
       }
@@ -11501,7 +11722,7 @@ function buildAgentPrompt(opts, runnerSkillPath) {
     if (runnerSkillPath) {
       try {
         const raw = readFileSync8(runnerSkillPath, "utf-8");
-        const content = stripFrontmatter2(raw).trim();
+        const content = stripFrontmatter3(raw).trim();
         if (content) parts.push(content, "");
       } catch {
       }
@@ -11512,7 +11733,7 @@ function buildAgentPrompt(opts, runnerSkillPath) {
     if (runnerSkillPath) {
       try {
         const raw = readFileSync8(runnerSkillPath, "utf-8");
-        const content = stripFrontmatter2(raw).trim();
+        const content = stripFrontmatter3(raw).trim();
         if (content) parts.push(content);
         parts.push("");
       } catch {
@@ -11697,8 +11918,15 @@ var init_cost = __esm({
 });
 
 // src/mcps/propagate.ts
+var propagate_exports = {};
+__export(propagate_exports, {
+  cleanupMcps: () => cleanupMcps,
+  diffMcps: () => diffMcps,
+  discoverExistingMcps: () => discoverExistingMcps,
+  injectMcps: () => injectMcps
+});
 import { execFile as execFile2 } from "child_process";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync14 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync13 } from "fs";
 import { promisify as promisify3 } from "util";
 import { homedir as homedir5 } from "os";
 import { join as join13 } from "path";
@@ -11777,7 +12005,7 @@ function injectMcpToCursorConfig(config2) {
   const configPath = join13(homedir5(), ".cursor", "mcp.json");
   let existing = {};
   try {
-    if (existsSync14(configPath)) {
+    if (existsSync13(configPath)) {
       existing = JSON.parse(readFileSync9(configPath, "utf-8"));
     }
   } catch {
@@ -11830,10 +12058,10 @@ async function injectMcps(runner, mcpNames, db3, scope) {
   }
   return added;
 }
-async function cleanupMcps(runner, mcps2, db3, scope) {
+async function cleanupMcps(runner, mcps, db3, scope) {
   const exe = runner.getExecutablePath();
   const runnerId = runner.id;
-  for (const name of mcps2) {
+  for (const name of mcps) {
     try {
       const removeCmd = runner.getMcpRemoveCommand(name);
       const args = removeCmd.slice(1);
@@ -11930,14 +12158,14 @@ function scanTemplates() {
   }
 }
 function getTemplate(name) {
-  if (Date.now() - lastScanMs > CACHE_TTL_MS3) scanTemplates();
+  if (Date.now() - lastScanMs > CACHE_TTL_MS4) scanTemplates();
   return templateCache.get(name) ?? null;
 }
 function listTemplates() {
-  if (Date.now() - lastScanMs > CACHE_TTL_MS3) scanTemplates();
+  if (Date.now() - lastScanMs > CACHE_TTL_MS4) scanTemplates();
   return Array.from(templateCache.values());
 }
-var templateCache, lastScanMs, CACHE_TTL_MS3;
+var templateCache, lastScanMs, CACHE_TTL_MS4;
 var init_loader2 = __esm({
   "src/agents/templates/loader.ts"() {
     "use strict";
@@ -11945,7 +12173,7 @@ var init_loader2 = __esm({
     init_log();
     templateCache = /* @__PURE__ */ new Map();
     lastScanMs = 0;
-    CACHE_TTL_MS3 = 3e4;
+    CACHE_TTL_MS4 = 3e4;
   }
 });
 
@@ -12062,7 +12290,7 @@ __export(orchestrator_exports, {
   spawnSubAgent: () => spawnSubAgent,
   suppressNotifications: () => suppressNotifications
 });
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 async function withRunnerLock(runnerId, fn) {
   const prev = runnerLocks.get(runnerId) ?? Promise.resolve();
   const next = prev.then(fn, () => fn());
@@ -12194,7 +12422,7 @@ async function spawnSubAgent(chatId, opts) {
 async function startAgent(agentId, chatId, opts) {
   const db3 = getDb();
   const runner = getRunner(opts.runner);
-  if (opts.cwd && !existsSync15(opts.cwd)) {
+  if (opts.cwd && !existsSync14(opts.cwd)) {
     const msg = `Directory not found: ${opts.cwd}`;
     error(`[orchestrator] Agent ${agentId}: ${msg}`);
     updateAgentStatus(db3, agentId, "failed");
@@ -12216,7 +12444,7 @@ async function startAgent(agentId, chatId, opts) {
     return;
   }
   const exePath = runner.getExecutablePath();
-  if (exePath.startsWith("/") && !existsSync15(exePath)) {
+  if (exePath.startsWith("/") && !existsSync14(exePath)) {
     const msg = `Executable not found: ${exePath}`;
     error(`[orchestrator] Agent ${agentId}: ${msg}`);
     updateAgentStatus(db3, agentId, "failed");
@@ -12503,10 +12731,10 @@ async function startAgent(agentId, chatId, opts) {
 function diagnoseSpawnError(err, exePath, cwd) {
   const nodeErr = err;
   if (nodeErr.code === "ENOENT") {
-    if (cwd && !existsSync15(cwd)) {
+    if (cwd && !existsSync14(cwd)) {
       return `Directory not found: ${cwd}`;
     }
-    if (exePath.startsWith("/") && !existsSync15(exePath)) {
+    if (exePath.startsWith("/") && !existsSync14(exePath)) {
       return `Executable not found: ${exePath}`;
     }
     return `ENOENT spawning ${exePath} (cwd: ${cwd ?? "inherited"}) \u2014 check that both the binary and directory exist`;
@@ -12905,7 +13133,7 @@ var init_registry2 = __esm({
 });
 
 // src/dashboard/routes/orchestrator.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 var handleSpawn, handleCancel, handleCancelAll, handleCreateTask, handleUpdateTask, handleSendMessage, handleReadInbox, handleSetState, handleGetState, handleListState, handleBroadcast, handleListRunners, handleListMcps, handleListTemplates, handleCheckAgent;
 var init_orchestrator2 = __esm({
   "src/dashboard/routes/orchestrator.ts"() {
@@ -12921,7 +13149,7 @@ var init_orchestrator2 = __esm({
     handleSpawn = async (req, res) => {
       try {
         const body = JSON.parse(await readBody(req));
-        if (body.cwd && !existsSync16(body.cwd)) {
+        if (body.cwd && !existsSync15(body.cwd)) {
           return jsonResponse(res, { error: `Directory not found: ${body.cwd}` }, 400);
         }
         if (!body.permMode || body.permMode === "inherit") {
@@ -13163,28 +13391,28 @@ async function checkHttpHealth(url) {
   }
 }
 async function runHealthChecks(db3) {
-  const mcps2 = listMcpServers(db3);
-  const sorted = mcps2.sort((a, b) => {
+  const mcps = listMcpServers(db3);
+  const sorted = mcps.sort((a, b) => {
     const aTime = a.lastHealthCheck ?? "0";
     const bTime = b.lastHealthCheck ?? "0";
     return aTime < bTime ? -1 : aTime > bTime ? 1 : 0;
   });
   const batch = sorted.slice(0, MAX_CHECKS_PER_CYCLE);
-  for (const mcp of batch) {
+  for (const mcp2 of batch) {
     let status = "unhealthy";
     try {
-      if (mcp.transport === "stdio" && mcp.command) {
-        const args = mcp.args ? JSON.parse(mcp.args) : [];
-        status = await checkStdioHealth(mcp.command, args);
-      } else if ((mcp.transport === "sse" || mcp.transport === "streamable-http") && mcp.url) {
-        status = await checkHttpHealth(mcp.url);
+      if (mcp2.transport === "stdio" && mcp2.command) {
+        const args = mcp2.args ? JSON.parse(mcp2.args) : [];
+        status = await checkStdioHealth(mcp2.command, args);
+      } else if ((mcp2.transport === "sse" || mcp2.transport === "streamable-http") && mcp2.url) {
+        status = await checkHttpHealth(mcp2.url);
       } else {
         status = "unknown";
       }
     } catch {
       status = "unhealthy";
     }
-    updateMcpHealth(db3, mcp.name, status);
+    updateMcpHealth(db3, mcp2.name, status);
   }
 }
 function startHealthMonitor(db3) {
@@ -13252,8 +13480,8 @@ var init_mcps = __esm({
       try {
         const { runHealthChecks: runHealthChecks2 } = await Promise.resolve().then(() => (init_health(), health_exports));
         await runHealthChecks2(getDb());
-        const mcps2 = listMcpServers(getDb());
-        jsonResponse(res, mcps2);
+        const mcps = listMcpServers(getDb());
+        jsonResponse(res, mcps);
       } catch (err) {
         jsonResponse(res, { error: errorMessage(err) }, 400);
       }
@@ -14293,7 +14521,7 @@ __export(stt_exports, {
 import crypto from "crypto";
 import { execFile as execFile3, execFileSync } from "child_process";
 import { readFile as readFile2, unlink, writeFile } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { join as join16, sep } from "path";
 import { promisify as promisify4 } from "util";
 import { createRequire } from "module";
@@ -14394,13 +14622,13 @@ function isWhisperModelDownloaded(model2) {
     if (idx >= 0) {
       const pkgRoot = hfMain.slice(0, idx + marker.length - 1);
       const v4CacheDir = join16(pkgRoot, ".cache", org, modelName);
-      if (existsSync17(v4CacheDir)) return true;
+      if (existsSync16(v4CacheDir)) return true;
     }
   } catch {
   }
   const home = process.env.HOME ?? "/tmp";
   const hubCacheDir = join16(home, ".cache", "huggingface", "hub", `models--${hfId.replace("/", "--")}`);
-  return existsSync17(hubCacheDir);
+  return existsSync16(hubCacheDir);
 }
 async function downloadWhisperModel(model2, onProgress) {
   const info = LOCAL_WHISPER_MODELS[model2];
@@ -14583,8 +14811,8 @@ async function mp3ToOgg(mp3Buffer) {
   const id = crypto.randomUUID();
   const tmpMp3 = `/tmp/cc-claw-tts-${id}.mp3`;
   const tmpOgg = `/tmp/cc-claw-tts-${id}.ogg`;
-  const { writeFile: writeFile7 } = await import("fs/promises");
-  await writeFile7(tmpMp3, mp3Buffer);
+  const { writeFile: writeFile6 } = await import("fs/promises");
+  await writeFile6(tmpMp3, mp3Buffer);
   await execFileAsync4("ffmpeg", ["-y", "-i", tmpMp3, "-c:a", "libopus", "-b:a", "64k", tmpOgg]);
   const oggBuffer = await readFile2(tmpOgg);
   unlink(tmpMp3).catch((err) => {
@@ -14762,7 +14990,7 @@ function is429(err) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES, RETRY_DELAY_MS, MAX_QUEUE_SIZE, MAX_TOTAL_PAUSE_MS, _activeThrottle, TelegramThrottle;
+var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, MAX_TOTAL_PAUSE_MS, _activeThrottle, TelegramThrottle;
 var init_telegram_throttle = __esm({
   "src/channels/telegram-throttle.ts"() {
     "use strict";
@@ -14770,7 +14998,7 @@ var init_telegram_throttle = __esm({
     PER_DM_INTERVAL_MS = 1e3;
     PER_GROUP_INTERVAL_MS = 3500;
     GLOBAL_INTERVAL_MS = 100;
-    MAX_RETRIES = 2;
+    MAX_RETRIES2 = 2;
     RETRY_DELAY_MS = 1e3;
     MAX_QUEUE_SIZE = 100;
     MAX_TOTAL_PAUSE_MS = 30 * 60 * 1e3;
@@ -14903,13 +15131,13 @@ var init_telegram_throttle = __esm({
       }
       // ── Retry logic (non-429 errors only) ───────────────────────────────
       async execWithRetry(label2, fn) {
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
           try {
             return await fn();
           } catch (err) {
             if (is429(err)) throw err;
-            if (attempt < MAX_RETRIES && err instanceof GrammyError) {
-              warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES} failed (${err.error_code}), retrying`);
+            if (attempt < MAX_RETRIES2 && err instanceof GrammyError) {
+              warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES2} failed (${err.error_code}), retrying`);
               await sleep(RETRY_DELAY_MS);
               continue;
             }
@@ -14969,10 +15197,10 @@ var init_telegram_throttle = __esm({
 });
 
 // src/health/checks.ts
-import { existsSync as existsSync18, statSync as statSync5, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync17, statSync as statSync5, readFileSync as readFileSync11 } from "fs";
 import { execFileSync as execFileSync2, execSync as execSync3 } from "child_process";
 function getRecentErrors() {
-  if (!existsSync18(ERROR_LOG_PATH)) return null;
+  if (!existsSync17(ERROR_LOG_PATH)) return null;
   const logContent = readFileSync11(ERROR_LOG_PATH, "utf-8");
   const allLines = logContent.split("\n").filter(Boolean).slice(-500);
   const last24h = Date.now() - 864e5;
@@ -14994,7 +15222,7 @@ function getRecentErrors() {
 }
 function checkDatabase() {
   const checks = [];
-  if (existsSync18(DB_PATH)) {
+  if (existsSync17(DB_PATH)) {
     const size = statSync5(DB_PATH).size;
     checks.push({ name: "Database", status: "ok", message: `${(size / 1024).toFixed(0)}KB` });
   } else {
@@ -15202,7 +15430,7 @@ __export(heartbeat_exports, {
   stopHeartbeatForChat: () => stopHeartbeatForChat,
   updateHeartbeatConfig: () => updateHeartbeatConfig
 });
-import { readFileSync as readFileSync12, existsSync as existsSync19 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync18 } from "fs";
 import { join as join17 } from "path";
 function findHeartbeatJob() {
   try {
@@ -15382,7 +15610,7 @@ ${healthText}`);
     sections.push(`[Active Watches \u2014 execute these checks using your tools]
 ${watchLines.join("\n")}`);
   }
-  if (existsSync19(HEARTBEAT_MD_PATH)) {
+  if (existsSync18(HEARTBEAT_MD_PATH)) {
     try {
       const custom = readFileSync12(HEARTBEAT_MD_PATH, "utf-8").trim();
       if (custom) {
@@ -15646,7 +15874,6 @@ __export(ui_exports, {
   sendBackendThinkingPicker: () => sendBackendThinkingPicker,
   sendCouncilResults: () => sendCouncilResults,
   sendCurrentProposal: () => sendCurrentProposal,
-  sendEscalationKeyboard: () => sendEscalationKeyboard,
   sendForgetPicker: () => sendForgetPicker,
   sendHeartbeatEngine: () => sendHeartbeatEngine,
   sendHeartbeatFallbacks: () => sendHeartbeatFallbacks,
@@ -17285,45 +17512,18 @@ async function doBackendSwitch(chatId, backendId, channel, opts) {
     }
   }
 }
-async function sendEscalationKeyboard(chatId, channel, currentBackendId, messageId) {
-  if (typeof channel.sendKeyboard !== "function") return void 0;
-  const cliBackends = getAvailableChatBackendIds().filter((id) => {
-    try {
-      return getAdapter(id).type === "cli";
-    } catch {
-      return false;
-    }
-  });
-  const text = [
-    "\u{1F504} This looks like an agentic task (code changes, file ops, etc.).",
-    "",
-    `Your current backend (${currentBackendId}) uses the API with limited tools.`,
-    "For full capabilities, switch to a CLI backend:"
-  ].join("\n");
-  const buttons = [];
-  for (const id of cliBackends) {
-    const adapter = getAdapter(id);
-    buttons.push([{
-      label: `Switch to ${adapter.displayName}`,
-      data: `escalate:switch:${id}`,
-      style: "primary"
-    }]);
-  }
-  buttons.push([
-    { label: "\u26A1 Bypass (30 min)", data: "escalate:bypass" },
-    { label: "\u2192 Proceed anyway", data: "escalate:proceed" }
-  ]);
-  return sendOrEditKeyboard(chatId, channel, messageId, text, buttons);
-}
 async function sendApiToolsKeyboard(chatId, channel, messageId) {
-  const { getApiCliWhitelist: getApiCliWhitelist2 } = await Promise.resolve().then(() => (init_api_whitelist(), api_whitelist_exports));
+  const { getApiCliWhitelist: getApiCliWhitelist2, getApiWebSearchEnabled: getApiWebSearchEnabled2 } = await Promise.resolve().then(() => (init_api_whitelist(), api_whitelist_exports));
   const entries = getApiCliWhitelist2(chatId);
   const whitelist = entries.map((e) => e.cli);
+  const webSearchEnabled = getApiWebSearchEnabled2(chatId);
   const lines = [
-    "\u{1F527} API Backend \u2014 CLI Whitelist",
+    "\u{1F527} API Backend \u2014 Tools",
     buildSectionHeader("", 26),
     "",
-    "Commands the AI can run in Safe mode:",
+    `\u{1F50D} Built-in web search (DuckDuckGo): ${webSearchEnabled ? "\u{1F7E2} On" : "\u26AB Off"}`,
+    "",
+    "CLI Whitelist \u2014 commands the AI can run:",
     ""
   ];
   if (whitelist.length > 0) {
@@ -17336,6 +17536,11 @@ async function sendApiToolsKeyboard(chatId, channel, messageId) {
   lines.push("");
   lines.push("Tap \u2795 to add a command pattern.");
   const buttons = [];
+  buttons.push([{
+    label: webSearchEnabled ? "\u{1F50D} Disable Web Search" : "\u{1F50D} Enable Web Search",
+    data: "apitools:toggle-web-search",
+    style: webSearchEnabled ? "danger" : "success"
+  }]);
   for (const cmd of whitelist.slice(0, 10)) {
     buttons.push([{
       label: `\u2715 ${cmd.length > 25 ? cmd.slice(0, 25) + "\u2026" : cmd}`,
@@ -18721,7 +18926,7 @@ __export(analyze_exports, {
 });
 import { spawn as spawn4 } from "child_process";
 import { createInterface as createInterface3 } from "readline";
-import { readFileSync as readFileSync13, existsSync as existsSync20, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync19, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
 import { join as join18 } from "path";
 import { homedir as homedir6 } from "os";
 function applySignalDecay(confidence, createdAt) {
@@ -18735,12 +18940,12 @@ function discoverReflectionTargets() {
   const targets = [];
   try {
     const skillsDir = join18(ccClawHome, "workspace", "skills");
-    if (existsSync20(skillsDir)) {
+    if (existsSync19(skillsDir)) {
       for (const entry of readdirSync7(skillsDir)) {
         const entryPath = join18(skillsDir, entry);
         if (!statSync6(entryPath).isDirectory()) continue;
         const skillFile = join18(entryPath, "SKILL.md");
-        if (!existsSync20(skillFile)) continue;
+        if (!existsSync19(skillFile)) continue;
         let desc = "skill";
         try {
           const content = readFileSync13(skillFile, "utf-8");
@@ -18755,7 +18960,7 @@ function discoverReflectionTargets() {
   }
   try {
     const contextDir = join18(ccClawHome, "workspace", "context");
-    if (existsSync20(contextDir)) {
+    if (existsSync19(contextDir)) {
       for (const entry of readdirSync7(contextDir)) {
         if (!entry.endsWith(".md")) continue;
         const name = entry.replace(/\.md$/, "");
@@ -19110,7 +19315,7 @@ async function runAnalysisImpl(chatId, opts) {
     if (!isRelevant) continue;
     try {
       const fullPath = join18(ccClawHome, target.path);
-      if (existsSync20(fullPath)) {
+      if (existsSync19(fullPath)) {
         const content = readFileSync13(fullPath, "utf-8");
         if (totalSkillChars + content.length > SKILL_CONTENT_CAP) break;
         skillContents.push({ path: target.path, content });
@@ -19491,7 +19696,7 @@ __export(apply_exports, {
   isTargetAllowed: () => isTargetAllowed,
   rollbackInsight: () => rollbackInsight
 });
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7, existsSync as existsSync21, mkdirSync as mkdirSync7, readdirSync as readdirSync8, unlinkSync as unlinkSync5 } from "fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync7, existsSync as existsSync20, mkdirSync as mkdirSync7, readdirSync as readdirSync8, unlinkSync as unlinkSync5 } from "fs";
 import { join as join19, dirname as dirname4 } from "path";
 function isTargetAllowed(relativePath) {
   if (relativePath.includes("..")) return false;
@@ -19578,7 +19783,7 @@ async function applyInsight(insightId) {
   }
   const absolutePath = join19(CC_CLAW_HOME, insight.targetFile);
   if (insight.proposedAction === "append" && insight.targetFile === "identity/SOUL.md") {
-    if (existsSync21(absolutePath)) {
+    if (existsSync20(absolutePath)) {
       const currentContent = readFileSync14(absolutePath, "utf-8");
       const lineCount = currentContent.split("\n").length;
       if (lineCount >= SOUL_LINE_CAP) {
@@ -19600,7 +19805,7 @@ async function applyInsight(insightId) {
     };
   }
   let original = "";
-  if (existsSync21(absolutePath)) {
+  if (existsSync20(absolutePath)) {
     original = readFileSync14(absolutePath, "utf-8");
   } else if (insight.proposedAction !== "create") {
     return { success: false, message: `Target file "${insight.targetFile}" does not exist` };
@@ -19609,7 +19814,7 @@ async function applyInsight(insightId) {
   const backupPath = absolutePath + `.bak.${timestamp}`;
   try {
     const parentDir = dirname4(absolutePath);
-    if (!existsSync21(parentDir)) {
+    if (!existsSync20(parentDir)) {
       mkdirSync7(parentDir, { recursive: true });
     }
     if (original) {
@@ -19741,7 +19946,7 @@ function computeLineDrift(baseline, absolutePath) {
   if (!baseline) return 0;
   let current = "";
   try {
-    if (existsSync21(absolutePath)) {
+    if (existsSync20(absolutePath)) {
       current = readFileSync14(absolutePath, "utf-8");
     }
   } catch {
@@ -19841,12 +20046,12 @@ var init_evolve = __esm({
         const body = JSON.parse(await readBody(req));
         const { setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
         const { existsSync: fileExists, readFileSync: fileRead } = await import("fs");
-        const { join: join41 } = await import("path");
+        const { join: join42 } = await import("path");
         const { CC_CLAW_HOME: home } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const chatId = resolveChatId(body);
         if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
-        const soulPath = join41(home, "identity/SOUL.md");
-        const userPath = join41(home, "identity/USER.md");
+        const soulPath = join42(home, "identity/SOUL.md");
+        const userPath = join42(home, "identity/USER.md");
         const soul = fileExists(soulPath) ? fileRead(soulPath, "utf-8") : "";
         const user = fileExists(userPath) ? fileRead(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
@@ -19899,7 +20104,7 @@ var init_evolve = __esm({
 });
 
 // src/dashboard/routes/files.ts
-import { createWriteStream, existsSync as existsSync22 } from "fs";
+import { createWriteStream, existsSync as existsSync21 } from "fs";
 import { readdir as readdir2, stat, unlink as unlink2, mkdir } from "fs/promises";
 import { join as join20, extname } from "path";
 function getUploadHtml(token, host) {
@@ -20107,7 +20312,7 @@ async function handleFileServe(req, res, url) {
     return;
   }
   const filePath = join20(INCOMING_PATH, filename);
-  if (!existsSync22(filePath)) {
+  if (!existsSync21(filePath)) {
     res.writeHead(404, { "Content-Type": "text/plain" });
     res.end("File not found");
     return;
@@ -20533,6 +20738,36 @@ var init_detect_subagent = __esm({
   }
 });
 
+// src/mcps/unified-config.ts
+function buildUnifiedMcpConfig(orchestratorOpts) {
+  const orchestrator = generateOrchestratorMcpConfig(orchestratorOpts);
+  const servers = {};
+  servers[orchestrator.name] = {
+    command: orchestrator.command,
+    args: orchestrator.args,
+    env: orchestrator.env
+  };
+  const db3 = getDb();
+  const mcps = getEnabledMcps(db3);
+  for (const mcp2 of mcps) {
+    if (mcp2.transport !== "stdio") continue;
+    servers[mcp2.name] = {
+      command: mcp2.command ?? void 0,
+      args: mcp2.args ? JSON.parse(mcp2.args) : void 0,
+      env: mcp2.env ? JSON.parse(mcp2.env) : void 0
+    };
+  }
+  return { mcpServers: servers };
+}
+var init_unified_config = __esm({
+  "src/mcps/unified-config.ts"() {
+    "use strict";
+    init_store5();
+    init_store2();
+    init_mcp_config();
+  }
+});
+
 // src/reflection/detect.ts
 var detect_exports = {};
 __export(detect_exports, {
@@ -21288,7 +21523,7 @@ async function askAgentImpl(chatId, userMessage, opts) {
   const { entityType, bootstrapProfile: profile } = optsEntityType && optsProfile ? { entityType: optsEntityType, bootstrapProfile: optsProfile } : resolveFromLegacyTier(bootstrapTier ?? "full");
   const effectiveAgentMode = optsAgentMode ?? getAgentMode(settingsChat);
   const sideQuestCtx = settingsSourceChatId ? { parentChatId: settingsSourceChatId, actualChatId: chatId } : void 0;
-  const fullPrompt = await assembleBootstrapPrompt(userMessage, entityType, profile, settingsChat, mode, responseStyle, effectiveAgentMode, sideQuestCtx, planningDirective, opts?.chatContext);
+  const fullPrompt = await assembleBootstrapPrompt(userMessage, entityType, profile, settingsChat, mode, responseStyle, effectiveAgentMode, sideQuestCtx, planningDirective, opts?.chatContext, adapter.type);
   if (adapter.streamDirect) {
     const resolvedModel2 = model2 ?? adapter.defaultModel;
     const abortController = new AbortController();
@@ -21334,8 +21569,9 @@ async function askAgentImpl(chatId, userMessage, opts) {
       if (cancelState2.cancelled) {
         return { text: "Stopped.", usage: { input: sdUsage.input, output: sdUsage.output, cacheRead: 0 } };
       }
+      const fallbackText = adapter.type === "api" ? `I wasn't able to complete that request. This can happen when a required tool is blocked or unavailable. Check /tools to see what commands are whitelisted, then try again.` : `(No response from ${adapter.displayName})`;
       return {
-        text: sdResult.text || `(No response from ${adapter.displayName})`,
+        text: sdResult.text || fallbackText,
         usage: { input: sdUsage.input, output: sdUsage.output, cacheRead: 0 },
         resolvedModel: resolvedModel2
       };
@@ -21655,13 +21891,19 @@ async function askAgentImpl(chatId, userMessage, opts) {
 function getMcpConfigPath(chatId) {
   if (process.env.DASHBOARD_ENABLED !== "1") return null;
   const token = getDashboardToken();
-  const config2 = generateOrchestratorMcpConfig({ chatId, agentId: "main", token });
-  return writeMcpConfigFile(config2);
+  if (!token) return null;
+  const config2 = buildUnifiedMcpConfig({
+    chatId,
+    agentId: "main",
+    token,
+    port: process.env.DASHBOARD_PORT ?? "3141"
+  });
+  return writeUnifiedMcpConfigFile(config2);
 }
 function injectMcpConfig(adapterId, args, mcpConfigPath) {
   const flag = MCP_CONFIG_FLAG[adapterId];
   if (!flag) return args;
-  return [...args, ...flag, mcpConfigPath];
+  return [...args, ...flag, mcpConfigPath, "--strict-mcp-config"];
 }
 var activeChats, staleSweepTimer, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
 var init_agent = __esm({
@@ -21686,9 +21928,10 @@ var init_agent = __esm({
     init_store5();
     init_store5();
     init_server();
-    init_mcp_config();
     init_store5();
     init_detect_subagent();
+    init_unified_config();
+    init_mcp_config();
     activeChats = /* @__PURE__ */ new Map();
     chatLocks = /* @__PURE__ */ new Map();
     SPAWN_TIMEOUT_MS = 10 * 60 * 1e3;
@@ -21925,7 +22168,7 @@ function getBackoffMs(retryCount) {
   const jitter = Math.floor(base * 0.2 * (Math.random() * 2 - 1));
   return base + jitter;
 }
-var EXHAUSTED_PATTERNS, TRANSIENT_PATTERNS, PERMANENT_PATTERNS, BACKOFF_MS, MAX_RETRIES2, AUTO_PAUSE_THRESHOLD;
+var EXHAUSTED_PATTERNS, TRANSIENT_PATTERNS, PERMANENT_PATTERNS, BACKOFF_MS, MAX_RETRIES3, AUTO_PAUSE_THRESHOLD;
 var init_retry = __esm({
   "src/scheduler/retry.ts"() {
     "use strict";
@@ -21975,13 +22218,13 @@ var init_retry = __esm({
       /subscription.*expired/i
     ];
     BACKOFF_MS = [3e4, 6e4, 3e5];
-    MAX_RETRIES2 = 3;
+    MAX_RETRIES3 = 3;
     AUTO_PAUSE_THRESHOLD = 5;
   }
 });
 
 // src/bootstrap/profile.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, existsSync as existsSync23 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, existsSync as existsSync22 } from "fs";
 import { join as join21 } from "path";
 function hasActiveProfile(chatId) {
   return activeProfiles.has(chatId);
@@ -22111,7 +22354,7 @@ function extractUserUpdates(text) {
   return { cleanText, updates };
 }
 function appendToUserProfile(key, value) {
-  if (!existsSync23(USER_PATH2)) return;
+  if (!existsSync22(USER_PATH2)) return;
   const content = readFileSync15(USER_PATH2, "utf-8");
   const line = `- **${key}**: ${value}`;
   if (content.includes(line)) return;
@@ -22132,203 +22375,13 @@ var init_profile = __esm({
   }
 });
 
-// src/router/state.ts
-var state_exports = {};
-__export(state_exports, {
-  activeSideQuests: () => activeSideQuests,
-  bypassBusyCheck: () => bypassBusyCheck,
-  clearEscalationBypass: () => clearEscalationBypass,
-  clearHistoryFilter: () => clearHistoryFilter,
-  clearPendingCliAddition: () => clearPendingCliAddition,
-  clearPendingModelResults: () => clearPendingModelResults,
-  clearPendingModelSearch: () => clearPendingModelSearch,
-  consumeAgenticBypass: () => consumeAgenticBypass,
-  councilResults: () => councilResults,
-  dashboardClawWarnings: () => dashboardClawWarnings,
-  getActiveSideQuestCount: () => getActiveSideQuestCount,
-  hasEscalationBypass: () => hasEscalationBypass,
-  historyFilters: () => historyFilters,
-  parseSideQuestPrefix: () => parseSideQuestPrefix,
-  pendingCliAdditions: () => pendingCliAdditions,
-  pendingInterrupts: () => pendingInterrupts,
-  pendingModelResults: () => pendingModelResults,
-  pendingModelSearch: () => pendingModelSearch,
-  pendingNewchatUndo: () => pendingNewchatUndo,
-  pendingSummaryUndo: () => pendingSummaryUndo,
-  setAgenticBypass: () => setAgenticBypass,
-  setCouncilResult: () => setCouncilResult,
-  setEscalationBypass: () => setEscalationBypass,
-  setHistoryFilter: () => setHistoryFilter,
-  setPendingCliAddition: () => setPendingCliAddition,
-  setPendingModelResults: () => setPendingModelResults,
-  setPendingModelSearch: () => setPendingModelSearch,
-  startStateSweep: () => startStateSweep,
-  stopAllSideQuests: () => stopAllSideQuests,
-  stopStateSweep: () => stopStateSweep
-});
-function setHistoryFilter(chatId, filter) {
-  historyFilters.set(chatId, filter);
-  historyFilterTimestamps.set(chatId, Date.now());
-}
-function clearHistoryFilter(chatId) {
-  historyFilters.delete(chatId);
-  historyFilterTimestamps.delete(chatId);
-}
-function setCouncilResult(chatId, result) {
-  councilResults.set(chatId, result);
-  councilResultTimestamps.set(chatId, Date.now());
-}
-function setPendingModelSearch(chatId, state) {
-  pendingModelSearch.set(chatId, state);
-  pendingModelSearchTimestamps.set(chatId, Date.now());
-}
-function clearPendingModelSearch(chatId) {
-  pendingModelSearch.delete(chatId);
-  pendingModelSearchTimestamps.delete(chatId);
-}
-function setPendingModelResults(chatId, results) {
-  pendingModelResults.set(chatId, results);
-}
-function clearPendingModelResults(chatId) {
-  pendingModelResults.delete(chatId);
-}
-function parseSideQuestPrefix(text) {
-  const match = text.match(/^(?:sq|btw):\s*/i);
-  if (match) return { isSideQuest: true, cleanText: text.slice(match[0].length) };
-  return { isSideQuest: false, cleanText: text };
-}
-function getActiveSideQuestCount(chatId) {
-  return activeSideQuests.get(chatId)?.size ?? 0;
-}
-function stopAllSideQuests(chatId) {
-  const active = activeSideQuests.get(chatId);
-  if (active) {
-    for (const sqId of active) {
-      stopAgent(sqId);
-    }
-  }
-}
-function startStateSweep() {
-  if (sweepTimer) return;
-  sweepTimer = setInterval(() => {
-    const now = Date.now();
-    for (const [chatId, ts2] of dashboardClawWarnings) {
-      if (now - ts2 > STALE_THRESHOLD_MS) dashboardClawWarnings.delete(chatId);
-    }
-    for (const [cid, ts2] of historyFilterTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        historyFilters.delete(cid);
-        historyFilterTimestamps.delete(cid);
-      }
-    }
-    for (const [cid, ts2] of councilResultTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        councilResults.delete(cid);
-        councilResultTimestamps.delete(cid);
-      }
-    }
-    for (const [cid, ts2] of pendingModelSearchTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        pendingModelSearch.delete(cid);
-        pendingModelSearchTimestamps.delete(cid);
-      }
-    }
-    for (const chatId of pendingInterrupts.keys()) {
-      if (!_interruptSeen.has(chatId)) {
-        _interruptSeen.add(chatId);
-      } else {
-        pendingInterrupts.delete(chatId);
-        _interruptSeen.delete(chatId);
-      }
-    }
-    for (const chatId of _interruptSeen) {
-      if (!pendingInterrupts.has(chatId)) _interruptSeen.delete(chatId);
-    }
-    for (const [chatId, expiry] of escalationBypasses) {
-      if (now > expiry) escalationBypasses.delete(chatId);
-    }
-    for (const [cid, ts2] of pendingCliTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        pendingCliAdditions.delete(cid);
-        pendingCliTimestamps.delete(cid);
-      }
-    }
-  }, SWEEP_INTERVAL_MS);
-  sweepTimer.unref();
-}
-function stopStateSweep() {
-  if (sweepTimer) {
-    clearInterval(sweepTimer);
-    sweepTimer = null;
-  }
-}
-function setEscalationBypass(chatId) {
-  escalationBypasses.set(chatId, Date.now() + ESCALATION_BYPASS_MS);
-}
-function hasEscalationBypass(chatId) {
-  const expiry = escalationBypasses.get(chatId);
-  if (!expiry) return false;
-  if (Date.now() > expiry) {
-    escalationBypasses.delete(chatId);
-    return false;
-  }
-  return true;
-}
-function clearEscalationBypass(chatId) {
-  escalationBypasses.delete(chatId);
-}
-function setAgenticBypass(chatId) {
-  agenticBypass.add(chatId);
-}
-function consumeAgenticBypass(chatId) {
-  return agenticBypass.delete(chatId);
-}
-function setPendingCliAddition(chatId, messageId) {
-  pendingCliAdditions.set(chatId, messageId);
-  pendingCliTimestamps.set(chatId, Date.now());
-}
-function clearPendingCliAddition(chatId) {
-  pendingCliAdditions.delete(chatId);
-  pendingCliTimestamps.delete(chatId);
-}
-var pendingInterrupts, bypassBusyCheck, activeSideQuests, dashboardClawWarnings, pendingSummaryUndo, pendingNewchatUndo, historyFilters, historyFilterTimestamps, councilResults, councilResultTimestamps, pendingModelSearch, pendingModelSearchTimestamps, pendingModelResults, SWEEP_INTERVAL_MS, STALE_THRESHOLD_MS, sweepTimer, _interruptSeen, ESCALATION_BYPASS_MS, escalationBypasses, agenticBypass, pendingCliAdditions, pendingCliTimestamps;
-var init_state = __esm({
-  "src/router/state.ts"() {
-    "use strict";
-    init_agent();
-    pendingInterrupts = /* @__PURE__ */ new Map();
-    bypassBusyCheck = /* @__PURE__ */ new Set();
-    activeSideQuests = /* @__PURE__ */ new Map();
-    dashboardClawWarnings = /* @__PURE__ */ new Map();
-    pendingSummaryUndo = /* @__PURE__ */ new Map();
-    pendingNewchatUndo = /* @__PURE__ */ new Map();
-    historyFilters = /* @__PURE__ */ new Map();
-    historyFilterTimestamps = /* @__PURE__ */ new Map();
-    councilResults = /* @__PURE__ */ new Map();
-    councilResultTimestamps = /* @__PURE__ */ new Map();
-    pendingModelSearch = /* @__PURE__ */ new Map();
-    pendingModelSearchTimestamps = /* @__PURE__ */ new Map();
-    pendingModelResults = /* @__PURE__ */ new Map();
-    SWEEP_INTERVAL_MS = 30 * 60 * 1e3;
-    STALE_THRESHOLD_MS = 30 * 60 * 1e3;
-    sweepTimer = null;
-    _interruptSeen = /* @__PURE__ */ new Set();
-    ESCALATION_BYPASS_MS = 30 * 60 * 1e3;
-    escalationBypasses = /* @__PURE__ */ new Map();
-    agenticBypass = /* @__PURE__ */ new Set();
-    pendingCliAdditions = /* @__PURE__ */ new Map();
-    pendingCliTimestamps = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/intent/classify.ts
 var classify_exports = {};
 __export(classify_exports, {
   classifyIntent: () => classifyIntent,
   classifyIntentAsync: () => classifyIntentAsync,
   getIntentStats: () => getIntentStats,
-  resetIntentStats: () => resetIntentStats,
-  shouldEscalate: () => shouldEscalate
+  resetIntentStats: () => resetIntentStats
 });
 function getIntentStats() {
   return { ...intentCounts };
@@ -22338,7 +22391,6 @@ function resetIntentStats() {
   intentCounts.agentic = 0;
 }
 function classifyIntentFast(text, chatId) {
-  if (consumeAgenticBypass(chatId)) return "agentic";
   const trimmed = text.trim();
   if (trimmed.startsWith(">>")) return "agentic";
   if (trimmed.startsWith("/")) return "agentic";
@@ -22508,16 +22560,12 @@ async function classifyIntentAsync(text, chatId) {
   intentCounts.agentic++;
   return "agentic";
 }
-function shouldEscalate(backendType, intent) {
-  return backendType === "api" && intent === "agentic";
-}
 var intentCounts, CHAT_EXACT, MUTATION_PATTERNS, CHAT_QUESTION_PATTERNS, STRUCTURAL_PATTERNS, LLM_CLASSIFY_PROMPT, LLM_CLASSIFY_TIMEOUT_MS;
 var init_classify = __esm({
   "src/intent/classify.ts"() {
     "use strict";
     init_store5();
     init_session_log();
-    init_state();
     init_log();
     intentCounts = { chat: 0, agentic: 0 };
     CHAT_EXACT = /* @__PURE__ */ new Set([
@@ -23305,7 +23353,7 @@ __export(session_log_exports2, {
   startSessionLogCleanupTimer: () => startSessionLogCleanupTimer,
   tailSessionLog: () => tailSessionLog
 });
-import { existsSync as existsSync24, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync9, unlinkSync as unlinkSync6, statSync as statSync7, createReadStream } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync9, unlinkSync as unlinkSync6, statSync as statSync7, createReadStream } from "fs";
 import { join as join22, basename } from "path";
 import { createInterface as createInterface6 } from "readline";
 function getRetentionDays() {
@@ -23318,7 +23366,7 @@ function getRetentionDays() {
 }
 function cleanupSessionLogs(retentionDays) {
   const days = retentionDays ?? getRetentionDays();
-  if (!existsSync24(SESSION_LOGS_PATH)) return 0;
+  if (!existsSync23(SESSION_LOGS_PATH)) return 0;
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
   let cleaned = 0;
   try {
@@ -23350,7 +23398,7 @@ function startSessionLogCleanupTimer() {
   return timer;
 }
 function listSessionLogs() {
-  if (!existsSync24(SESSION_LOGS_PATH)) return [];
+  if (!existsSync23(SESSION_LOGS_PATH)) return [];
   const logs = [];
   for (const file of readdirSync9(SESSION_LOGS_PATH)) {
     if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
@@ -23373,7 +23421,7 @@ function listSessionLogs() {
   return logs;
 }
 async function* tailSessionLog(filePath, lines = 50) {
-  if (!existsSync24(filePath)) {
+  if (!existsSync23(filePath)) {
     yield `File not found: ${filePath}`;
     return;
   }
@@ -23401,7 +23449,7 @@ var init_session_log2 = __esm({
       constructor(chatId, backend2, model2) {
         this.backend = backend2;
         this.model = model2;
-        if (!existsSync24(SESSION_LOGS_PATH)) {
+        if (!existsSync23(SESSION_LOGS_PATH)) {
           mkdirSync8(SESSION_LOGS_PATH, { recursive: true });
         }
         const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
@@ -23887,7 +23935,7 @@ var init_gate = __esm({
 });
 
 // src/media/image-gen.ts
-import { mkdirSync as mkdirSync9, existsSync as existsSync25, unlink as unlink3, readdir as readdir3, stat as stat2 } from "fs";
+import { mkdirSync as mkdirSync9, existsSync as existsSync24, unlink as unlink3, readdir as readdir3, stat as stat2 } from "fs";
 import { writeFile as writeFile2 } from "fs/promises";
 import { join as join23 } from "path";
 async function generateImage(prompt) {
@@ -23936,7 +23984,7 @@ async function generateImage(prompt) {
   if (!imageData) {
     throw new Error(textResponse ?? "Gemini did not generate an image. The prompt may have been filtered.");
   }
-  if (!existsSync25(IMAGE_OUTPUT_DIR)) {
+  if (!existsSync24(IMAGE_OUTPUT_DIR)) {
     mkdirSync9(IMAGE_OUTPUT_DIR, { recursive: true });
   }
   const ext = mimeType.includes("jpeg") || mimeType.includes("jpg") ? "jpg" : "png";
@@ -24765,6 +24813,168 @@ var init_media = __esm({
   }
 });
 
+// src/router/state.ts
+var state_exports = {};
+__export(state_exports, {
+  activeSideQuests: () => activeSideQuests,
+  bypassBusyCheck: () => bypassBusyCheck,
+  clearHistoryFilter: () => clearHistoryFilter,
+  clearPendingCliAddition: () => clearPendingCliAddition,
+  clearPendingModelResults: () => clearPendingModelResults,
+  clearPendingModelSearch: () => clearPendingModelSearch,
+  councilResults: () => councilResults,
+  dashboardClawWarnings: () => dashboardClawWarnings,
+  getActiveSideQuestCount: () => getActiveSideQuestCount,
+  historyFilters: () => historyFilters,
+  parseSideQuestPrefix: () => parseSideQuestPrefix,
+  pendingCliAdditions: () => pendingCliAdditions,
+  pendingInterrupts: () => pendingInterrupts,
+  pendingMcpImports: () => pendingMcpImports,
+  pendingModelResults: () => pendingModelResults,
+  pendingModelSearch: () => pendingModelSearch,
+  pendingNewchatUndo: () => pendingNewchatUndo,
+  pendingSummaryUndo: () => pendingSummaryUndo,
+  setCouncilResult: () => setCouncilResult,
+  setHistoryFilter: () => setHistoryFilter,
+  setPendingCliAddition: () => setPendingCliAddition,
+  setPendingModelResults: () => setPendingModelResults,
+  setPendingModelSearch: () => setPendingModelSearch,
+  startStateSweep: () => startStateSweep,
+  stopAllSideQuests: () => stopAllSideQuests,
+  stopStateSweep: () => stopStateSweep
+});
+function setHistoryFilter(chatId, filter) {
+  historyFilters.set(chatId, filter);
+  historyFilterTimestamps.set(chatId, Date.now());
+}
+function clearHistoryFilter(chatId) {
+  historyFilters.delete(chatId);
+  historyFilterTimestamps.delete(chatId);
+}
+function setCouncilResult(chatId, result) {
+  councilResults.set(chatId, result);
+  councilResultTimestamps.set(chatId, Date.now());
+}
+function setPendingModelSearch(chatId, state) {
+  pendingModelSearch.set(chatId, state);
+  pendingModelSearchTimestamps.set(chatId, Date.now());
+}
+function clearPendingModelSearch(chatId) {
+  pendingModelSearch.delete(chatId);
+  pendingModelSearchTimestamps.delete(chatId);
+}
+function setPendingModelResults(chatId, results) {
+  pendingModelResults.set(chatId, results);
+}
+function clearPendingModelResults(chatId) {
+  pendingModelResults.delete(chatId);
+}
+function parseSideQuestPrefix(text) {
+  const match = text.match(/^(?:sq|btw):\s*/i);
+  if (match) return { isSideQuest: true, cleanText: text.slice(match[0].length) };
+  return { isSideQuest: false, cleanText: text };
+}
+function getActiveSideQuestCount(chatId) {
+  return activeSideQuests.get(chatId)?.size ?? 0;
+}
+function stopAllSideQuests(chatId) {
+  const active = activeSideQuests.get(chatId);
+  if (active) {
+    for (const sqId of active) {
+      stopAgent(sqId);
+    }
+  }
+}
+function startStateSweep() {
+  if (sweepTimer) return;
+  sweepTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [chatId, ts2] of dashboardClawWarnings) {
+      if (now - ts2 > STALE_THRESHOLD_MS) dashboardClawWarnings.delete(chatId);
+    }
+    for (const [cid, ts2] of historyFilterTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        historyFilters.delete(cid);
+        historyFilterTimestamps.delete(cid);
+      }
+    }
+    for (const [cid, ts2] of councilResultTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        councilResults.delete(cid);
+        councilResultTimestamps.delete(cid);
+      }
+    }
+    for (const [cid, ts2] of pendingModelSearchTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        pendingModelSearch.delete(cid);
+        pendingModelSearchTimestamps.delete(cid);
+      }
+    }
+    for (const chatId of pendingInterrupts.keys()) {
+      if (!_interruptSeen.has(chatId)) {
+        _interruptSeen.add(chatId);
+      } else {
+        pendingInterrupts.delete(chatId);
+        _interruptSeen.delete(chatId);
+      }
+    }
+    for (const chatId of _interruptSeen) {
+      if (!pendingInterrupts.has(chatId)) _interruptSeen.delete(chatId);
+    }
+    for (const [cid, ts2] of pendingCliTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        pendingCliAdditions.delete(cid);
+        pendingCliTimestamps.delete(cid);
+      }
+    }
+    for (const [cid, state] of pendingMcpImports) {
+      if (now - state.startedAt > STALE_THRESHOLD_MS) pendingMcpImports.delete(cid);
+    }
+  }, SWEEP_INTERVAL_MS);
+  sweepTimer.unref();
+}
+function stopStateSweep() {
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}
+function setPendingCliAddition(chatId, messageId) {
+  pendingCliAdditions.set(chatId, messageId);
+  pendingCliTimestamps.set(chatId, Date.now());
+}
+function clearPendingCliAddition(chatId) {
+  pendingCliAdditions.delete(chatId);
+  pendingCliTimestamps.delete(chatId);
+}
+var pendingInterrupts, bypassBusyCheck, activeSideQuests, dashboardClawWarnings, pendingSummaryUndo, pendingNewchatUndo, historyFilters, historyFilterTimestamps, councilResults, councilResultTimestamps, pendingModelSearch, pendingModelSearchTimestamps, pendingModelResults, SWEEP_INTERVAL_MS, STALE_THRESHOLD_MS, sweepTimer, _interruptSeen, pendingMcpImports, pendingCliAdditions, pendingCliTimestamps;
+var init_state = __esm({
+  "src/router/state.ts"() {
+    "use strict";
+    init_agent();
+    pendingInterrupts = /* @__PURE__ */ new Map();
+    bypassBusyCheck = /* @__PURE__ */ new Set();
+    activeSideQuests = /* @__PURE__ */ new Map();
+    dashboardClawWarnings = /* @__PURE__ */ new Map();
+    pendingSummaryUndo = /* @__PURE__ */ new Map();
+    pendingNewchatUndo = /* @__PURE__ */ new Map();
+    historyFilters = /* @__PURE__ */ new Map();
+    historyFilterTimestamps = /* @__PURE__ */ new Map();
+    councilResults = /* @__PURE__ */ new Map();
+    councilResultTimestamps = /* @__PURE__ */ new Map();
+    pendingModelSearch = /* @__PURE__ */ new Map();
+    pendingModelSearchTimestamps = /* @__PURE__ */ new Map();
+    pendingModelResults = /* @__PURE__ */ new Map();
+    SWEEP_INTERVAL_MS = 30 * 60 * 1e3;
+    STALE_THRESHOLD_MS = 30 * 60 * 1e3;
+    sweepTimer = null;
+    _interruptSeen = /* @__PURE__ */ new Set();
+    pendingMcpImports = /* @__PURE__ */ new Map();
+    pendingCliAdditions = /* @__PURE__ */ new Map();
+    pendingCliTimestamps = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/router/sidequest.ts
 import { randomUUID as randomUUID3 } from "crypto";
 async function handleSideQuest(parentChatId, msg, channel) {
@@ -24954,7 +25164,7 @@ __export(install_exports, {
   installSkillFromGitHub: () => installSkillFromGitHub
 });
 import { mkdir as mkdir3, readdir as readdir5, readFile as readFile5, cp } from "fs/promises";
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { join as join25, basename as basename2 } from "path";
 import { execSync as execSync4 } from "child_process";
 async function installSkillFromGitHub(urlOrShorthand) {
@@ -24973,7 +25183,7 @@ async function installSkillFromGitHub(urlOrShorthand) {
       stdio: "pipe",
       timeout: 3e4
     });
-    if (!existsSync26(join25(tmpDir, ".git"))) {
+    if (!existsSync25(join25(tmpDir, ".git"))) {
       return { success: false, error: "Git clone failed: no .git directory produced" };
     }
     const searchRoot = subPath ? join25(tmpDir, subPath) : tmpDir;
@@ -24983,7 +25193,7 @@ async function installSkillFromGitHub(urlOrShorthand) {
     }
     const skillFolderName = basename2(skillDir);
     const destDir = join25(SKILLS_PATH, skillFolderName);
-    if (existsSync26(destDir)) {
+    if (existsSync25(destDir)) {
       log(`[skill-install] Overwriting existing skill at ${destDir}`);
     }
     await mkdir3(destDir, { recursive: true });
@@ -25030,14 +25240,14 @@ function parseGitHubUrl(input) {
 async function findSkillDir(root) {
   const candidates = ["SKILL.md", "skill.md"];
   for (const c of candidates) {
-    if (existsSync26(join25(root, c))) return root;
+    if (existsSync25(join25(root, c))) return root;
   }
   try {
     const entries = await readdir5(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       for (const c of candidates) {
-        if (existsSync26(join25(root, entry.name, c))) {
+        if (existsSync25(join25(root, entry.name, c))) {
           return join25(root, entry.name);
         }
       }
@@ -25057,7 +25267,7 @@ async function findSkillDir(root) {
       for (const sub of subEntries) {
         if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
         for (const c of candidates) {
-          if (existsSync26(join25(root, entry.name, sub.name, c))) {
+          if (existsSync25(join25(root, entry.name, sub.name, c))) {
             return join25(root, entry.name, sub.name);
           }
         }
@@ -25348,12 +25558,12 @@ async function handleEvolveCallback(chatId, data, channel, messageId) {
         );
         break;
       }
-      const { readFileSync: readFileSync34, existsSync: existsSync63 } = await import("fs");
-      const { join: join41 } = await import("path");
-      const targetPath = join41(homedir7(), ".cc-claw", insight.targetFile);
+      const { readFileSync: readFileSync35, existsSync: existsSync62 } = await import("fs");
+      const { join: join42 } = await import("path");
+      const targetPath = join42(homedir7(), ".cc-claw", insight.targetFile);
       let previewText;
-      if (existsSync63(targetPath)) {
-        const current = readFileSync34(targetPath, "utf-8");
+      if (existsSync62(targetPath)) {
+        const current = readFileSync35(targetPath, "utf-8");
         const diffLines = insight.proposedDiff.split("\n");
         const additions = diffLines.filter((l) => l.startsWith("+")).map((l) => `  + ${l.slice(1).trim()}`);
         const removals = diffLines.filter((l) => l.startsWith("-")).map((l) => `  - ${l.slice(1).trim()}`);
@@ -25425,13 +25635,13 @@ async function handleEvolveCallback(chatId, data, channel, messageId) {
       const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync34, existsSync: existsSync63 } = await import("fs");
-        const { join: join41 } = await import("path");
+        const { readFileSync: readFileSync35, existsSync: existsSync62 } = await import("fs");
+        const { join: join42 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const soulPath = join41(CC_CLAW_HOME3, "identity/SOUL.md");
-        const userPath = join41(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync63(soulPath) ? readFileSync34(soulPath, "utf-8") : "";
-        const user = existsSync63(userPath) ? readFileSync34(userPath, "utf-8") : "";
+        const soulPath = join42(CC_CLAW_HOME3, "identity/SOUL.md");
+        const userPath = join42(CC_CLAW_HOME3, "identity/USER.md");
+        const soul = existsSync62(soulPath) ? readFileSync35(soulPath, "utf-8") : "";
+        const user = existsSync62(userPath) ? readFileSync35(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
         await sendEvolveDashboard(chatId, reflChatId, channel, messageId);
@@ -25568,7 +25778,7 @@ var init_evolve2 = __esm({
 });
 
 // src/optimizer/identity-audit.ts
-import { readFileSync as readFileSync16, existsSync as existsSync27, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync26, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
 import { join as join26 } from "path";
 function readIdentityFile2(filename) {
   try {
@@ -25588,7 +25798,7 @@ function findBackupFiles() {
   const backups = [];
   const dirs = [IDENTITY_PATH];
   const contextDir = join26(IDENTITY_PATH, "..", "workspace", "context");
-  if (existsSync27(contextDir)) dirs.push(contextDir);
+  if (existsSync26(contextDir)) dirs.push(contextDir);
   for (const dir of dirs) {
     try {
       for (const entry of readdirSync10(dir)) {
@@ -25725,7 +25935,7 @@ var init_identity_audit = __esm({
 });
 
 // src/optimizer/skill-audit.ts
-import { readFileSync as readFileSync17, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync27 } from "fs";
 import { join as join27, basename as basename3 } from "path";
 function parseFrontmatter3(content) {
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
@@ -25798,7 +26008,7 @@ function loadDependentSkillContents(depNames, ccClawSkillsDir) {
       join27(ccClawSkillsDir, `${name}-skill`, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync28(candidate)) {
+      if (existsSync27(candidate)) {
         try {
           const content = readFileSync17(candidate, "utf-8");
           results.push({
@@ -25944,7 +26154,7 @@ __export(analyze_exports2, {
 });
 import { spawn as spawn7 } from "child_process";
 import { createInterface as createInterface7 } from "readline";
-import { readFileSync as readFileSync18, existsSync as existsSync29, readdirSync as readdirSync12 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync28, readdirSync as readdirSync12 } from "fs";
 import { join as join28 } from "path";
 import { homedir as homedir8 } from "os";
 function parseOptimizeOutput(raw, validAreas) {
@@ -26080,10 +26290,10 @@ function readIdentityFile3(filename) {
     return "";
   }
 }
-function loadContextFiles2() {
+function loadContextFiles() {
   const contextDir = join28(homedir8(), ".cc-claw", "workspace", "context");
   const results = [];
-  if (!existsSync29(contextDir)) return results;
+  if (!existsSync28(contextDir)) return results;
   try {
     for (const entry of readdirSync12(contextDir)) {
       if (!entry.endsWith(".md")) continue;
@@ -26119,7 +26329,7 @@ async function runIdentityAudit(chatId) {
   const soulMd = readIdentityFile3("SOUL.md");
   const userMd = readIdentityFile3("USER.md");
   const ccClawMd = readIdentityFile3("CC-CLAW.md");
-  const contextFiles = loadContextFiles2();
+  const contextFiles = loadContextFiles();
   const prompt = buildIdentityAuditPrompt(soulMd, userMd, ccClawMd, stats, contextFiles);
   const raw = await spawnAnalysis2(adapter, model2, prompt);
   const findings = parseOptimizeOutput(raw, VALID_IDENTITY_AREAS);
@@ -26156,11 +26366,11 @@ async function runSkillAudit(chatId, skillPath) {
 function listCcClawSkills() {
   const skillsDir = join28(homedir8(), ".cc-claw", "workspace", "skills");
   const entries = [];
-  if (!existsSync29(skillsDir)) return entries;
+  if (!existsSync28(skillsDir)) return entries;
   try {
     for (const dir of readdirSync12(skillsDir)) {
       const skillFile = join28(skillsDir, dir, "SKILL.md");
-      if (!existsSync29(skillFile)) continue;
+      if (!existsSync28(skillFile)) continue;
       let description = "skill";
       try {
         const content = readFileSync18(skillFile, "utf-8");
@@ -26490,7 +26700,7 @@ __export(optimize_exports2, {
   handleOptimizeCallback: () => handleOptimizeCallback,
   handleOptimizeCommand: () => handleOptimizeCommand
 });
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync9, existsSync as existsSync30, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync9, existsSync as existsSync29, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
 import { join as join29, dirname as dirname5 } from "path";
 import { homedir as homedir9 } from "os";
 async function handleOptimizeCommand(chatId, channel, _args, messageId) {
@@ -26715,7 +26925,7 @@ async function applyFinding(chatId, channel, index, messageId) {
   }
   try {
     const targetPath = resolveTargetFile(finding.location, session2.result.target);
-    if (!targetPath || !existsSync30(targetPath)) {
+    if (!targetPath || !existsSync29(targetPath)) {
       session2.skipped.push(index);
       await showFinding(chatId, channel, index + 1, effectiveMsgId);
       return;
@@ -29188,73 +29398,6 @@ ${agentLines.join("\n")}`, buttons);
   const ok = cancelAgent(match.id);
   await channel.sendText(chatId, ok ? `Agent ${match.id.slice(0, 8)} cancelled.` : "Could not cancel agent.", { parseMode: "plain" });
 }
-async function handleMcpCommand(chatId, commandArgs, msg, channel) {
-  const db3 = getDb();
-  const lines = ["<b>\u{1F50C} MCP Servers</b>"];
-  let totalCount = 0;
-  let connectedCount = 0;
-  const centralMcps = listRegisteredMcps(db3);
-  if (centralMcps.length > 0) {
-    lines.push("", "\u2501\u2501 <b>CC-Claw</b> \u2501\u2501");
-    for (const m of centralMcps) {
-      totalCount++;
-      connectedCount++;
-      const autoTag = m.enabledByDefault ? "  \u{1F4CC}" : "";
-      const desc = m.description ? `  <i>${m.description}</i>` : "";
-      lines.push(`  \u2705 <b>${m.name}</b>${autoTag}${desc}`);
-    }
-  }
-  if (process.env.DASHBOARD_ENABLED === "1") {
-    totalCount++;
-    connectedCount++;
-    lines.push("", "\u2501\u2501 <b>Built-in</b> \u2501\u2501");
-    lines.push(`  \u2705 <b>cc-claw</b>  <i>Agent orchestrator (spawn, tasks, inbox)</i>`);
-  }
-  const { execFile: execFile6 } = await import("child_process");
-  const { homedir: homedirImport } = await import("os");
-  const discoveryCwd = homedirImport();
-  const runnerResults = await Promise.allSettled(
-    getAllRunners().map((runner) => {
-      const listCmd = runner.getMcpListCommand();
-      if (!listCmd.length) return Promise.resolve({ runner, output: "" });
-      const exe = runner.getExecutablePath();
-      return new Promise((resolve3) => {
-        execFile6(exe, listCmd.slice(1), {
-          encoding: "utf-8",
-          timeout: 3e4,
-          cwd: discoveryCwd,
-          env: runner.getEnv()
-        }, (_err, stdout, stderr) => {
-          const combined = ((stdout ?? "") + "\n" + (stderr ?? "")).trim();
-          resolve3({ runner, output: combined });
-        });
-      });
-    })
-  );
-  for (const result of runnerResults) {
-    if (result.status !== "fulfilled") continue;
-    const { runner, output: output2 } = result.value;
-    if (!runner.getMcpListCommand().length) continue;
-    const parsed = parseMcpListOutput(output2);
-    lines.push("", `\u2501\u2501 <b>${runner.displayName}</b> \u2501\u2501`);
-    if (parsed.length === 0) {
-      lines.push("  <i>No servers configured</i>");
-      continue;
-    }
-    for (const srv of parsed) {
-      totalCount++;
-      if (srv.connected) connectedCount++;
-      const icon = srv.connected ? "\u2705" : "\u274C";
-      lines.push(`  ${icon} <b>${srv.name}</b>`);
-    }
-  }
-  if (totalCount === 0) {
-    lines.push("", "<i>No MCP servers found.</i>");
-  } else {
-    lines.splice(1, 0, `<i>${connectedCount}/${totalCount} connected</i>`);
-  }
-  await channel.sendText(chatId, lines.join("\n"), { parseMode: "html" });
-}
 async function handleCronCommand(chatId, commandArgs, msg, channel) {
   if (!commandArgs) {
     await sendJobsBoard(chatId, channel, 1);
@@ -29393,6 +29536,514 @@ var init_command_handlers = __esm({
   }
 });
 
+// src/mcps/constants.ts
+function healthIcon(status) {
+  switch (status) {
+    case "healthy":
+      return "\u{1F7E2}";
+    case "unhealthy":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+var SYSTEM_MCP_NAMES;
+var init_constants = __esm({
+  "src/mcps/constants.ts"() {
+    "use strict";
+    SYSTEM_MCP_NAMES = /* @__PURE__ */ new Set(["cc-claw"]);
+  }
+});
+
+// src/cli/api-client.ts
+var api_client_exports = {};
+__export(api_client_exports, {
+  apiDelete: () => apiDelete,
+  apiGet: () => apiGet,
+  apiPost: () => apiPost,
+  apiPut: () => apiPut,
+  isDaemonRunning: () => isDaemonRunning
+});
+import { request as httpRequest, Agent } from "http";
+function getToken() {
+  if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
+  return readApiToken();
+}
+async function isDaemonRunning() {
+  try {
+    const res = await apiGet("/api/health");
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function makeRequest(method, path, body, timeout) {
+  const token = getToken();
+  return new Promise((resolve3, reject) => {
+    const url = new URL(path, BASE_URL);
+    const headers = {
+      ...token ? { "Authorization": `Bearer ${token}` } : {}
+    };
+    if (body !== null) {
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = Buffer.byteLength(body).toString();
+    }
+    const req = httpRequest(url, { method, headers, timeout, agent: keepAliveAgent }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const responseBody = Buffer.concat(chunks).toString();
+        try {
+          const data = JSON.parse(responseBody);
+          resolve3({ ok: res.statusCode === 200, status: res.statusCode ?? 0, data });
+        } catch {
+          resolve3({ ok: false, status: res.statusCode ?? 0, data: responseBody });
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    if (body !== null) req.write(body);
+    req.end();
+  });
+}
+function apiGet(path) {
+  return makeRequest("GET", path, null, 3e3);
+}
+function apiPost(path, body, opts) {
+  return makeRequest("POST", path, JSON.stringify(body), opts?.timeout ?? 3e4);
+}
+function apiPut(path, body, opts) {
+  return makeRequest("PUT", path, JSON.stringify(body), opts?.timeout ?? 3e4);
+}
+function apiDelete(path) {
+  return makeRequest("DELETE", path, null, 1e4);
+}
+var DEFAULT_PORT, API_HOST, BASE_URL, keepAliveAgent;
+var init_api_client = __esm({
+  "src/cli/api-client.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT_PORT = parseInt(process.env.DASHBOARD_PORT ?? "3141", 10);
+    API_HOST = process.env.CC_CLAW_API_HOST ?? "127.0.0.1";
+    BASE_URL = `http://${API_HOST}:${DEFAULT_PORT}`;
+    keepAliveAgent = new Agent({ keepAlive: true, maxSockets: 4 });
+  }
+});
+
+// src/mcps/import.ts
+var import_exports = {};
+__export(import_exports, {
+  discoverFromSource: () => discoverFromSource,
+  mcpImport: () => mcpImport,
+  parseClaudeConfig: () => parseClaudeConfig,
+  parseCursorConfig: () => parseCursorConfig
+});
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join31 } from "path";
+import { homedir as homedir10 } from "os";
+function parseClaudeConfig(config2) {
+  const servers = config2.mcpServers ?? {};
+  return Object.entries(servers).map(([name, s]) => ({
+    name,
+    command: s.command ?? "",
+    args: Array.isArray(s.args) ? s.args : [],
+    env: s.env && typeof s.env === "object" && !Array.isArray(s.env) ? s.env : {}
+  })).filter((s) => Boolean(s.command));
+}
+async function discoverFromSource(source) {
+  switch (source) {
+    case "claude": {
+      const path = join31(homedir10(), ".claude", "settings.json");
+      try {
+        return parseClaudeConfig(JSON.parse(readFileSync20(path, "utf-8")));
+      } catch {
+        warn(`[mcp-import] Could not read ${path}`);
+        return [];
+      }
+    }
+    case "cursor": {
+      const path = join31(homedir10(), ".cursor", "mcp.json");
+      try {
+        return parseCursorConfig(JSON.parse(readFileSync20(path, "utf-8")));
+      } catch {
+        warn(`[mcp-import] Could not read ${path}`);
+        return [];
+      }
+    }
+    case "gemini":
+    case "codex": {
+      try {
+        const { discoverExistingMcps: discoverExistingMcps2 } = await Promise.resolve().then(() => (init_propagate(), propagate_exports));
+        const { getRunner: getRunner2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+        const runner = getRunner2(source);
+        if (!runner) {
+          warn(`[mcp-import] No runner registered for "${source}"`);
+          return [];
+        }
+        const names = await discoverExistingMcps2(runner);
+        return names.map((n) => ({ name: n, command: "", args: [], env: {} }));
+      } catch (err) {
+        warn(`[mcp-import] Failed to discover from ${source}: ${err instanceof Error ? err.message : err}`);
+        return [];
+      }
+    }
+    default:
+      warn(`[mcp-import] Unknown source: ${source}`);
+      return [];
+  }
+}
+async function mcpImport(source, _opts) {
+  const servers = await discoverFromSource(source);
+  const readline = await import("readline");
+  const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask2 = (q) => new Promise((resolve3) => rl2.question(q, resolve3));
+  try {
+    if (servers.length === 0) {
+      console.log(`No MCP servers found in ${source}.`);
+      return;
+    }
+    const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const { listMcpServers: listMcpServers2 } = await Promise.resolve().then(() => (init_store2(), store_exports2));
+    const db3 = openDatabaseReadOnly2();
+    const existing = new Set(listMcpServers2(db3).map((m) => m.name));
+    db3.close();
+    const available = servers.filter((s) => !existing.has(s.name));
+    if (available.length === 0) {
+      console.log(`All MCPs from ${source} are already registered in CC-Claw.`);
+      return;
+    }
+    console.log(`
+Found ${available.length} new MCP(s) in ${source}:
+`);
+    available.forEach((s, i) => {
+      const cmd = s.command ? ` (${s.command})` : "";
+      console.log(`  ${i + 1}. ${s.name}${cmd}`);
+    });
+    console.log();
+    const answer = await ask2(
+      "Select MCPs to import (comma-separated numbers, or 'all', or Enter to cancel): "
+    );
+    const trimmed = answer.trim().toLowerCase();
+    if (!trimmed || trimmed === "cancel") {
+      console.log("Cancelled.");
+      return;
+    }
+    const indices = trimmed === "all" ? available.map((_, i) => i) : trimmed.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((i) => Number.isInteger(i) && i >= 0 && i < available.length);
+    if (indices.length === 0) {
+      console.log("Nothing selected.");
+      return;
+    }
+    const { apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+    let added = 0;
+    for (const i of indices) {
+      const s = available[i];
+      if (!s.command) {
+        console.warn(`  \u26A0 Skipping "${s.name}" \u2014 no command available (discovered from ${source} CLI name only)`);
+        continue;
+      }
+      try {
+        await apiPost2("/api/mcps", {
+          name: s.name,
+          transport: "stdio",
+          command: s.command || void 0,
+          args: s.args.length > 0 ? s.args : void 0,
+          env: Object.keys(s.env).length > 0 ? s.env : void 0,
+          enabledByDefault: true
+        });
+        added++;
+      } catch (err) {
+        warn(`[mcp-import] Failed to add ${s.name}: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    console.log(`
+\u2713 Imported ${added} MCP(s) from ${source}.`);
+  } finally {
+    rl2.close();
+  }
+}
+var parseCursorConfig;
+var init_import = __esm({
+  "src/mcps/import.ts"() {
+    "use strict";
+    init_log();
+    parseCursorConfig = parseClaudeConfig;
+  }
+});
+
+// src/router/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  handleMcpCallback: () => handleMcpCallback,
+  sendMcpDetail: () => sendMcpDetail,
+  sendMcpImportPicker: () => sendMcpImportPicker,
+  sendMcpImportSelect: () => sendMcpImportSelect,
+  sendMcpKeyboard: () => sendMcpKeyboard
+});
+async function sendMcpKeyboard(chatId, channel, messageId) {
+  const db3 = getDb();
+  const mcps = listMcpServers(db3);
+  const lines = ["<b>MCP Servers</b>"];
+  if (mcps.length === 0) {
+    lines.push("\nNo MCPs registered yet. Add one below.");
+  }
+  const buttons = [];
+  for (const mcp2 of mcps) {
+    const isSystem = SYSTEM_MCP_NAMES.has(mcp2.name);
+    const prefix = isSystem ? "\u{1F512}" : healthIcon(mcp2.healthStatus);
+    const label2 = `${prefix} ${mcp2.name}${isSystem ? " (system)" : ""}`;
+    buttons.push([{ label: label2, data: `mcp:detail:${mcp2.name}` }]);
+  }
+  buttons.push([
+    { label: "\u2795 Add", data: "mcp:add" },
+    { label: "\u2B07 Import", data: "mcp:import" }
+  ]);
+  await sendOrEditKeyboard(chatId, channel, messageId, lines.join("\n"), buttons);
+}
+async function sendMcpDetail(chatId, channel, mcpName, messageId) {
+  const db3 = getDb();
+  const mcps = listMcpServers(db3);
+  const mcp2 = mcps.find((m) => m.name === mcpName);
+  if (!mcp2) {
+    await sendOrEditKeyboard(chatId, channel, messageId, `MCP "${mcpName}" not found.`, [
+      [{ label: "\u2190 Back", data: "mcp:back" }]
+    ]);
+    return;
+  }
+  const isSystem = SYSTEM_MCP_NAMES.has(mcp2.name);
+  const argsStr = mcp2.args ? (() => {
+    try {
+      return JSON.parse(mcp2.args).join(" ");
+    } catch {
+      return mcp2.args;
+    }
+  })() : "";
+  const lines = [
+    `<b>${mcp2.name}</b>${isSystem ? " \u{1F512}" : ""}`,
+    `Transport: ${mcp2.transport}`,
+    mcp2.command ? `Command: <code>${mcp2.command}${argsStr ? " " + argsStr : ""}</code>` : "",
+    `Health: ${healthIcon(mcp2.healthStatus)} ${mcp2.healthStatus ?? "unknown"}`,
+    `Status: ${mcp2.enabledByDefault ? "enabled" : "disabled"}`
+  ].filter(Boolean);
+  const buttons = [];
+  if (!isSystem) {
+    const statusBtn = mcp2.enabledByDefault ? { label: "\u23F8 Disable", data: `mcp:disable:${mcp2.name}`, style: "danger" } : { label: "\u25B6 Enable", data: `mcp:enable:${mcp2.name}`, style: "success" };
+    buttons.push([
+      statusBtn,
+      { label: "\u{1F5D1} Remove", data: `mcp:remove:${mcp2.name}`, style: "danger" }
+    ]);
+  }
+  buttons.push([{ label: "\u2190 Back", data: "mcp:back" }]);
+  await sendOrEditKeyboard(chatId, channel, messageId, lines.join("\n"), buttons);
+}
+async function sendMcpImportPicker(chatId, channel, messageId) {
+  const buttons = IMPORT_SOURCES.map((src) => [
+    {
+      label: src.charAt(0).toUpperCase() + src.slice(1),
+      data: `mcp:import:${src}`
+    }
+  ]);
+  buttons.push([{ label: "\u2190 Back", data: "mcp:back" }]);
+  await sendOrEditKeyboard(
+    chatId,
+    channel,
+    messageId,
+    "<b>Import MCPs from:</b>",
+    buttons
+  );
+}
+async function sendMcpImportSelect(chatId, channel, source, selected, candidates, messageId) {
+  if (candidates.length === 0) {
+    await sendOrEditKeyboard(
+      chatId,
+      channel,
+      messageId,
+      `No new MCPs found in <b>${source}</b>.`,
+      [[{ label: "\u2190 Back", data: "mcp:import" }]]
+    );
+    return;
+  }
+  const buttons = candidates.map((name) => {
+    const checked = selected.has(name);
+    return [
+      {
+        label: `${checked ? "\u2713 " : "  "}${name}`,
+        data: `mcp:import:toggle:${source}:${name}`
+      }
+    ];
+  });
+  buttons.push([
+    {
+      label: "\u2713 Import Selected",
+      data: `mcp:import:confirm:${source}`,
+      style: "success"
+    },
+    { label: "\u2190 Back", data: "mcp:import" }
+  ]);
+  await sendOrEditKeyboard(
+    chatId,
+    channel,
+    messageId,
+    `<b>Found ${candidates.length} new MCP(s) in ${source}:</b>`,
+    buttons
+  );
+}
+async function handleMcpCallback(chatId, data, channel, messageId) {
+  const { apiPost: apiPost2, apiPut: apiPut2, apiDelete: apiDelete2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+  const { pendingMcpImports: pendingMcpImports2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const { discoverFromSource: discoverFromSource2 } = await Promise.resolve().then(() => (init_import(), import_exports));
+  if (data === "mcp:back") {
+    await sendMcpKeyboard(chatId, channel, messageId);
+    return;
+  }
+  if (data === "mcp:import") {
+    await sendMcpImportPicker(chatId, channel, messageId);
+    return;
+  }
+  if (data.startsWith("mcp:detail:")) {
+    await sendMcpDetail(chatId, channel, data.slice(11), messageId);
+    return;
+  }
+  if (data.startsWith("mcp:disable:")) {
+    const name = data.slice(12);
+    await apiPut2(`/api/mcps/${encodeURIComponent(name)}`, { enabledByDefault: false });
+    await sendMcpDetail(chatId, channel, name, messageId);
+    return;
+  }
+  if (data.startsWith("mcp:enable:")) {
+    const name = data.slice(11);
+    await apiPut2(`/api/mcps/${encodeURIComponent(name)}`, { enabledByDefault: true });
+    await sendMcpDetail(chatId, channel, name, messageId);
+    return;
+  }
+  if (data.startsWith("mcp:remove:")) {
+    const name = data.slice(11);
+    await apiDelete2(`/api/mcps/${encodeURIComponent(name)}`);
+    await sendMcpKeyboard(chatId, channel, messageId);
+    return;
+  }
+  if (data.startsWith("mcp:import:") && !data.includes(":toggle:") && !data.includes(":confirm:")) {
+    const source = data.slice(11);
+    if (IMPORT_SOURCES.includes(source)) {
+      let servers;
+      try {
+        servers = await discoverFromSource2(source);
+      } catch (err) {
+        await sendOrEditKeyboard(
+          chatId,
+          channel,
+          messageId,
+          `Failed to discover MCPs from ${source}: ${err instanceof Error ? err.message : String(err)}`,
+          [[{ label: "\u2190 Back", data: "mcp:import" }]]
+        );
+        return;
+      }
+      const db3 = getDb();
+      const existing = new Set(listMcpServers(db3).map((m) => m.name));
+      const candidates = servers.map((s) => s.name).filter((n) => !existing.has(n));
+      pendingMcpImports2.set(chatId, {
+        source,
+        servers,
+        selected: /* @__PURE__ */ new Set(),
+        candidates,
+        startedAt: Date.now()
+      });
+      const state = pendingMcpImports2.get(chatId);
+      await sendMcpImportSelect(
+        chatId,
+        channel,
+        source,
+        state.selected,
+        state.candidates,
+        messageId
+      );
+    }
+    return;
+  }
+  if (data.startsWith("mcp:import:toggle:")) {
+    const rest = data.slice(18);
+    const colonIdx = rest.indexOf(":");
+    if (colonIdx === -1) return;
+    const source = rest.slice(0, colonIdx);
+    const name = rest.slice(colonIdx + 1);
+    const state = pendingMcpImports2.get(chatId);
+    if (!state || state.source !== source) return;
+    if (state.selected.has(name)) {
+      state.selected.delete(name);
+    } else {
+      state.selected.add(name);
+    }
+    await sendMcpImportSelect(
+      chatId,
+      channel,
+      source,
+      state.selected,
+      state.candidates,
+      messageId
+    );
+    return;
+  }
+  if (data.startsWith("mcp:import:confirm:")) {
+    const source = data.slice(19);
+    const state = pendingMcpImports2.get(chatId);
+    pendingMcpImports2.delete(chatId);
+    if (!state || state.selected.size === 0) {
+      await sendMcpKeyboard(chatId, channel, messageId);
+      return;
+    }
+    const serverMap = new Map((state.servers ?? []).map((s) => [s.name, s]));
+    let added = 0;
+    for (const name of state.selected) {
+      const s = serverMap.get(name);
+      if (!s || !s.command) continue;
+      try {
+        await apiPost2("/api/mcps", {
+          name: s.name,
+          transport: "stdio",
+          command: s.command,
+          args: s.args.length > 0 ? s.args : void 0,
+          env: Object.keys(s.env).length > 0 ? s.env : void 0,
+          enabledByDefault: true
+        });
+        added++;
+      } catch {
+      }
+    }
+    await sendOrEditKeyboard(
+      chatId,
+      channel,
+      messageId,
+      `\u2713 Imported ${added} MCP(s) from ${source}.`,
+      [[{ label: "\u2190 Back to MCP List", data: "mcp:back" }]]
+    );
+    return;
+  }
+  if (data === "mcp:add") {
+    await sendOrEditKeyboard(
+      chatId,
+      channel,
+      messageId,
+      "To add an MCP, use the CLI:\n<code>cc-claw mcp add &lt;name&gt; &lt;command&gt; [args...]</code>",
+      [[{ label: "\u2190 Back", data: "mcp:back" }]]
+    );
+    return;
+  }
+}
+var IMPORT_SOURCES;
+var init_mcp = __esm({
+  "src/router/mcp.ts"() {
+    "use strict";
+    init_store5();
+    init_store2();
+    init_constants();
+    init_helpers();
+    IMPORT_SOURCES = ["claude", "gemini", "codex", "cursor"];
+  }
+});
+
 // src/router/commands.ts
 async function handleCommand(msg, channel) {
   const { chatId, command, commandArgs } = msg;
@@ -29439,6 +30090,7 @@ async function handleCommand(msg, channel) {
     case "claude":
     case "codex":
     case "cursor":
+    case "openrouter":
       await handleBackendShortcutCommand(chatId, commandArgs, msg, channel);
       break;
     case "gemini_accounts":
@@ -29565,9 +30217,11 @@ async function handleCommand(msg, channel) {
       await handleRunnersCommand(chatId, commandArgs, msg, channel);
       break;
     case "mcp":
-    case "mcps":
-      await handleMcpCommand(chatId, commandArgs, msg, channel);
+    case "mcps": {
+      const { sendMcpKeyboard: sendMcpKeyboard2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await sendMcpKeyboard2(chatId, channel);
       break;
+    }
     case "cron":
       await handleCronCommand(chatId, commandArgs, msg, channel);
       break;
@@ -31383,8 +32037,8 @@ ${lines.join("\n")}`, { parseMode: "plain" });
     }
     try {
       const { readFile: readFileFs } = await import("fs/promises");
-      const { mkdir: mkdir6, writeFile: writeFileFs } = await import("fs/promises");
-      const { join: join41 } = await import("path");
+      const { mkdir: mkdir5, writeFile: writeFileFs } = await import("fs/promises");
+      const { join: join42 } = await import("path");
       const { SKILLS_PATH: SKILLS_PATH2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
       const { updateFrontmatter: updateFrontmatter2, ensureThreeTierFrontmatter: ensureThreeTierFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
       const { invalidateSkillCache: invalidateSkillCache2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
@@ -31392,9 +32046,9 @@ ${lines.join("\n")}`, { parseMode: "plain" });
       let updated = ensureThreeTierFrontmatter2(raw, { name: skillName, source });
       const targetStatus = doApprove ? "approved" : "imported";
       updated = updateFrontmatter2(updated, { status: targetStatus });
-      const targetDir = join41(SKILLS_PATH2, skillName);
-      await mkdir6(targetDir, { recursive: true });
-      await writeFileFs(join41(targetDir, "SKILL.md"), updated, "utf-8");
+      const targetDir = join42(SKILLS_PATH2, skillName);
+      await mkdir5(targetDir, { recursive: true });
+      await writeFileFs(join42(targetDir, "SKILL.md"), updated, "utf-8");
       invalidateSkillCache2();
       if (doApprove) {
         await sendOrEditKeyboard(
@@ -31525,10 +32179,10 @@ ${formatValidationReport2(validation)}` : "\n\n\u2705 Quality checks passed.";
       return;
     }
     try {
-      const { readFileSync: readFileSync34, writeFileSync: writeFileSync16 } = await import("fs");
+      const { readFileSync: readFileSync35, writeFileSync: writeFileSync16 } = await import("fs");
       const { updateFrontmatter: updateFrontmatter2, ensureThreeTierFrontmatter: ensureThreeTierFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
       const { invalidateSkillCache: invalidateSkillCache2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
-      const raw = readFileSync34(skill.filePath, "utf-8");
+      const raw = readFileSync35(skill.filePath, "utf-8");
       let updated = ensureThreeTierFrontmatter2(raw, { name: skillName, source: "cc-claw" });
       updated = updateFrontmatter2(updated, { status: "approved" });
       writeFileSync16(skill.filePath, updated, "utf-8");
@@ -31578,14 +32232,14 @@ ${stillUnapproved.length} more skill${stillUnapproved.length !== 1 ? "s" : ""} t
       return;
     }
     try {
-      const { readFileSync: readFileSync34, writeFileSync: writeFileSync16 } = await import("fs");
+      const { readFileSync: readFileSync35, writeFileSync: writeFileSync16 } = await import("fs");
       const { updateFrontmatter: updateFrontmatter2, ensureThreeTierFrontmatter: ensureThreeTierFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
       const { invalidateSkillCache: invalidateSkillCache2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
       let approvedCount = 0;
       const issues = [];
       for (const skill of unapproved) {
         try {
-          const raw = readFileSync34(skill.filePath, "utf-8");
+          const raw = readFileSync35(skill.filePath, "utf-8");
           let updated = ensureThreeTierFrontmatter2(raw, { name: skill.name, source: "cc-claw" });
           updated = updateFrontmatter2(updated, { status: "approved" });
           writeFileSync16(skill.filePath, updated, "utf-8");
@@ -31636,7 +32290,7 @@ ${issues.join("\n")}`;
       return;
     }
     const raw = await readFile7(skill.filePath, "utf-8");
-    const skillContent = stripFrontmatter(raw);
+    const skillContent = stripFrontmatter2(raw);
     const tags = skill.sources.join(", ");
     await channel.sendText(chatId, `Loading skill: ${skillName} [${tags}]...`, { parseMode: "plain" });
     const skillModel = resolveModel(chatId);
@@ -31711,39 +32365,9 @@ Type a keyword below (e.g. gemma, llama, free, claude)`,
         [[{ label: "\u2190 Back", data: `bconf:model:${backendId}` }]]
       );
     }
-  } else if (data.startsWith("escalate:")) {
-    const rest = data.slice(9);
-    if (rest.startsWith("switch:")) {
-      const backendId = rest.slice(7);
-      if (!getAllBackendIds().includes(backendId)) return;
-      await doBackendSwitch(chatId, backendId, channel, { messageId });
-      const pending = getPendingEscalation(chatId);
-      if (pending) {
-        removePendingEscalation(chatId);
-        const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
-        await handleMessage2({ text: pending, chatId, source: "telegram", type: "text" }, channel);
-      }
-    } else if (rest === "bypass") {
-      const { setEscalationBypass: setEscalationBypass2 } = await Promise.resolve().then(() => (init_state(), state_exports));
-      setEscalationBypass2(chatId);
-      await replaceWithText("\u26A1 Escalation bypassed for 30 minutes. Re-processing\u2026");
-      const pending = getPendingEscalation(chatId);
-      if (pending) {
-        removePendingEscalation(chatId);
-        const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
-        await handleMessage2({ text: pending, chatId, source: "telegram", type: "text" }, channel);
-      }
-    } else if (rest === "proceed") {
-      await replaceWithText("\u2192 Proceeding with API backend.");
-      const pending = getPendingEscalation(chatId);
-      if (pending) {
-        removePendingEscalation(chatId);
-        const { setAgenticBypass: setAgenticBypass2 } = await Promise.resolve().then(() => (init_state(), state_exports));
-        setAgenticBypass2(chatId);
-        const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
-        await handleMessage2({ text: pending, chatId, source: "telegram", type: "text" }, channel);
-      }
-    }
+  } else if (data.startsWith("mcp:")) {
+    const { handleMcpCallback: handleMcpCallback2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+    await handleMcpCallback2(chatId, data, channel, messageId);
   } else if (data.startsWith("apitools:")) {
     const { sendApiToolsKeyboard: sendApiToolsKeyboard2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
     const rest = data.slice(9);
@@ -31772,6 +32396,10 @@ Type a keyword below (e.g. gemma, llama, free, claude)`,
       const { removeCliFromWhitelist: removeCliFromWhitelist2 } = await Promise.resolve().then(() => (init_api_whitelist(), api_whitelist_exports));
       removeCliFromWhitelist2(chatId, cmd);
       await sendApiToolsKeyboard2(chatId, channel, messageId);
+    } else if (rest === "toggle-web-search") {
+      const { toggleApiWebSearchEnabled: toggleApiWebSearchEnabled2 } = await Promise.resolve().then(() => (init_api_whitelist(), api_whitelist_exports));
+      toggleApiWebSearchEnabled2(chatId);
+      await sendApiToolsKeyboard2(chatId, channel, messageId);
     }
   }
 }
@@ -32507,7 +33135,10 @@ Try a different keyword.`,
       const cmd = text.trim();
       if (cmd) {
         const { addCliToWhitelist: addCliToWhitelist2 } = await Promise.resolve().then(() => (init_api_whitelist(), api_whitelist_exports));
-        addCliToWhitelist2(chatId, cmd);
+        const clis = cmd.split(",").map((s) => s.trim()).filter(Boolean);
+        for (const cli of clis) {
+          addCliToWhitelist2(chatId, cli);
+        }
       }
       const { sendApiToolsKeyboard: sendApiToolsKeyboard2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
       await sendApiToolsKeyboard2(chatId, channel, msgId);
@@ -32572,21 +33203,6 @@ Try a different keyword.`,
     }
     effectiveAgentMode = "native";
   }
-  if (intent === "agentic" && !text.startsWith(">>")) {
-    try {
-      const adapter = getAdapterForChat(chatId);
-      if (adapter.type === "api") {
-        const { hasEscalationBypass: hasEscalationBypass2 } = await Promise.resolve().then(() => (init_state(), state_exports));
-        if (!hasEscalationBypass2(chatId)) {
-          storePendingEscalation(chatId, text);
-          const { sendEscalationKeyboard: sendEscalationKeyboard2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
-          await sendEscalationKeyboard2(chatId, channel, adapter.id);
-          return;
-        }
-      }
-    } catch {
-    }
-  }
   const { isSideQuest: hasSqPrefix, cleanText: sqCleanText } = parseSideQuestPrefix(text);
   if (hasSqPrefix && isChatBusy(chatId)) {
     const sqMsg = { ...msg, text: sqCleanText };
@@ -33444,7 +34060,7 @@ async function runWithRetry(job, model2, runId, t0) {
     if (isFallback) {
       log(`[scheduler] Job #${job.id} falling back to ${currentBackend}:${currentModel} (fallback ${chainIdx}/${job.fallbacks.length})`);
     }
-    for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+    for (let attempt = 0; attempt <= MAX_RETRIES3; attempt++) {
       try {
         const { getVerboseLevel: getVerboseLevel4 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
         const vLevel = getVerboseLevel4(chatId);
@@ -33499,11 +34115,11 @@ ${response.text}`;
           log(`[scheduler] Job #${job.id} backend ${currentBackend} exhausted: ${errMsg}`);
           break;
         }
-        if (errorClass === "permanent" || attempt >= MAX_RETRIES2) {
+        if (errorClass === "permanent" || attempt >= MAX_RETRIES3) {
           throw err;
         }
         const backoffMs = getBackoffMs(attempt);
-        log(`[scheduler] Job #${job.id} transient error (attempt ${attempt + 1}/${MAX_RETRIES2}), retrying in ${backoffMs / 1e3}s: ${errorMessage(err)}`);
+        log(`[scheduler] Job #${job.id} transient error (attempt ${attempt + 1}/${MAX_RETRIES3}), retrying in ${backoffMs / 1e3}s: ${errorMessage(err)}`);
         await new Promise((r) => setTimeout(r, backoffMs));
       }
     }
@@ -33566,7 +34182,7 @@ var init_cron = __esm({
 });
 
 // src/agents/runners/wrap-backend.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 function buildMcpCommands(backendId) {
   const exe = backendId === BACKEND.CURSOR ? "agent" : backendId;
   return {
@@ -33663,7 +34279,7 @@ function wrapBackendAdapter(adapter) {
       const configPath = writeMcpConfigFile(server);
       return ["--mcp-config", configPath];
     },
-    getSkillPath: () => join31(SKILLS_PATH, `agent-${adapter.id}.md`)
+    getSkillPath: () => join32(SKILLS_PATH, `agent-${adapter.id}.md`)
   };
 }
 var BACKEND_CAPABILITIES;
@@ -33735,18 +34351,18 @@ var init_wrap_backend = __esm({
 });
 
 // src/agents/runners/config-loader.ts
-import { readFileSync as readFileSync20, readdirSync as readdirSync14, existsSync as existsSync31, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
-import { join as join32 } from "path";
+import { readFileSync as readFileSync21, readdirSync as readdirSync14, existsSync as existsSync30, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
+import { join as join33 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 function resolveExecutable2(config2) {
-  if (existsSync31(config2.executable)) return config2.executable;
+  if (existsSync30(config2.executable)) return config2.executable;
   try {
     return execFileSync3("which", [config2.executable], { encoding: "utf-8" }).trim();
   } catch {
   }
   for (const fallback of config2.executableFallbacks ?? []) {
     const resolved = fallback.replace(/^~/, process.env.HOME ?? "");
-    if (existsSync31(resolved)) return resolved;
+    if (existsSync30(resolved)) return resolved;
   }
   return config2.executable;
 }
@@ -33872,12 +34488,12 @@ function configToRunner(config2) {
     prepareMcpInjection() {
       return [];
     },
-    getSkillPath: () => join32(SKILLS_PATH, `agent-${config2.id}.md`)
+    getSkillPath: () => join33(SKILLS_PATH, `agent-${config2.id}.md`)
   };
 }
 function loadRunnerConfig(filePath) {
   try {
-    const content = readFileSync20(filePath, "utf-8");
+    const content = readFileSync21(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     warn(`[runners] Failed to load config ${filePath}: ${err}`);
@@ -33885,14 +34501,14 @@ function loadRunnerConfig(filePath) {
   }
 }
 function loadAllRunnerConfigs() {
-  if (!existsSync31(RUNNERS_PATH)) {
+  if (!existsSync30(RUNNERS_PATH)) {
     mkdirSync10(RUNNERS_PATH, { recursive: true });
     return [];
   }
   const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   const configs = [];
   for (const file of files) {
-    const config2 = loadRunnerConfig(join32(RUNNERS_PATH, file));
+    const config2 = loadRunnerConfig(join33(RUNNERS_PATH, file));
     if (config2) configs.push(config2);
   }
   return configs;
@@ -33913,16 +34529,16 @@ function registerConfigRunners() {
   return count;
 }
 function watchRunnerConfigs(onChange) {
-  if (!existsSync31(RUNNERS_PATH)) return;
+  if (!existsSync30(RUNNERS_PATH)) return;
   for (const prev of watchedFiles) {
-    if (!existsSync31(prev)) {
+    if (!existsSync30(prev)) {
       unwatchFile(prev);
       watchedFiles.delete(prev);
     }
   }
   const files = readdirSync14(RUNNERS_PATH).filter((f) => f.endsWith(".json"));
   for (const file of files) {
-    const fullPath = join32(RUNNERS_PATH, file);
+    const fullPath = join33(RUNNERS_PATH, file);
     if (watchedFiles.has(fullPath)) continue;
     watchedFiles.add(fullPath);
     watchFile(fullPath, { interval: 5e3 }, () => {
@@ -34502,6 +35118,7 @@ var init_telegram2 = __esm({
           { command: "codex", description: "Switch to Codex backend" },
           { command: "codex_accounts", description: "Manage Codex credentials & rotation" },
           { command: "cursor", description: "Switch to Cursor backend" },
+          { command: "openrouter", description: "Switch to OpenRouter backend" },
           { command: "model", description: "Switch model for active backend" },
           { command: "thinking", description: "Adjust thinking/reasoning level" },
           { command: "summarizer", description: "Configure session summarization model" },
@@ -35220,19 +35837,19 @@ var init_telegram2 = __esm({
 });
 
 // src/skills/bootstrap.ts
-import { existsSync as existsSync32, readFileSync as readFileSync21, writeFileSync as writeFileSync10, copyFileSync as copyFileSync3, readdirSync as readdirSync15 } from "fs";
-import { readdir as readdir6, readFile as readFile8, writeFile as writeFile6, copyFile } from "fs/promises";
-import { join as join33, dirname as dirname6 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync22, writeFileSync as writeFileSync10, copyFileSync as copyFileSync3, readdirSync as readdirSync15 } from "fs";
+import { readdir as readdir6, copyFile } from "fs/promises";
+import { join as join34, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function copyAgentManifestSkills() {
-  if (!existsSync32(PKG_SKILLS)) return;
+  if (!existsSync31(PKG_SKILLS)) return;
   try {
     const entries = await readdir6(PKG_SKILLS, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".md")) continue;
-      const src = join33(PKG_SKILLS, entry.name);
-      const dest = join33(SKILLS_PATH, entry.name);
-      if (existsSync32(dest)) continue;
+      const src = join34(PKG_SKILLS, entry.name);
+      const dest = join34(SKILLS_PATH, entry.name);
+      if (existsSync31(dest)) continue;
       await copyFile(src, dest);
       log(`[skills] Bootstrapped ${entry.name} to ${SKILLS_PATH}`);
     }
@@ -35243,73 +35860,11 @@ async function copyAgentManifestSkills() {
 async function bootstrapSkills() {
   await copyAgentManifestSkills();
   migrateSkillsToThreeTier();
-  const usmDir = join33(SKILLS_PATH, USM_DIR_NAME);
-  if (existsSync32(usmDir)) return;
-  try {
-    const entries = await readdir6(SKILLS_PATH);
-    const dirs = entries.filter((e) => !e.startsWith("."));
-    if (dirs.length > 0) return;
-  } catch (err) {
-    log("[skills] Bootstrap: failed to read skills directory:", err instanceof Error ? err.message : err);
-    return;
-  }
-  log("[skills] First run \u2014 bootstrapping Universal Skills Manager...");
-  try {
-    const result = await installSkillFromGitHub(USM_REPO);
-    if (!result.success) {
-      error(`[skills] USM bootstrap failed: ${result.error}`);
-      return;
-    }
-    await patchUsmForCcClaw(usmDir);
-    log("[skills] Universal Skills Manager bootstrapped successfully");
-  } catch (err) {
-    error(`[skills] USM bootstrap error: ${errorMessage(err)}`);
-  }
-}
-async function patchUsmForCcClaw(usmDir) {
-  const skillPath = join33(usmDir, "SKILL.md");
-  if (!existsSync32(skillPath)) return;
-  try {
-    let content = await readFile8(skillPath, "utf-8");
-    let patched = false;
-    if (!content.includes("CC-Claw")) {
-      const cursorLine = `| **Cursor**`;
-      const cursorIdx = content.indexOf(cursorLine);
-      if (cursorIdx !== -1) {
-        const lineEnd = content.indexOf("\n", cursorIdx);
-        if (lineEnd !== -1) {
-          content = content.slice(0, lineEnd + 1) + CC_CLAW_ECOSYSTEM_PATCH + "\n" + content.slice(lineEnd + 1);
-          patched = true;
-        }
-      }
-    }
-    const findPatterns = [
-      "find ~/.{claude,agents,gemini/antigravity,openclaw/workspace,cursor,config/opencode,config/goose,roo,cline}/skills",
-      "find ~/.{claude,agents,gemini,gemini/antigravity,openclaw/workspace,cursor,config/opencode,config/goose,roo,cline}/skills"
-    ];
-    for (const oldFind of findPatterns) {
-      if (content.includes(oldFind) && !content.includes("cc-claw/workspace")) {
-        const newFind = oldFind.replace("openclaw/workspace,", "openclaw/workspace,cc-claw/workspace,");
-        content = content.replace(oldFind, newFind);
-        patched = true;
-        break;
-      }
-    }
-    const beforeFm = content;
-    content = ensureThreeTierFrontmatter(content, { name: "universal-skills-manager", source: "cc-claw" });
-    if (content !== beforeFm) patched = true;
-    if (patched) {
-      await writeFile6(skillPath, content, "utf-8");
-      log("[skills] Patched USM SKILL.md with CC-Claw support");
-    }
-  } catch (err) {
-    error(`[skills] Failed to patch USM: ${errorMessage(err)}`);
-  }
 }
 function migrateSkillsToThreeTier() {
-  const markerPath = join33(SKILLS_PATH, MIGRATION_MARKER);
-  if (existsSync32(markerPath)) return;
-  if (!existsSync32(SKILLS_PATH)) return;
+  const markerPath = join34(SKILLS_PATH, MIGRATION_MARKER);
+  if (existsSync31(markerPath)) return;
+  if (!existsSync31(SKILLS_PATH)) return;
   let entries;
   try {
     entries = readdirSync15(SKILLS_PATH, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
@@ -35323,15 +35878,15 @@ function migrateSkillsToThreeTier() {
   for (const dirName of entries) {
     let skillPath;
     for (const candidate of SKILL_FILE_CANDIDATES2) {
-      const p = join33(SKILLS_PATH, dirName, candidate);
-      if (existsSync32(p)) {
+      const p = join34(SKILLS_PATH, dirName, candidate);
+      if (existsSync31(p)) {
         skillPath = p;
         break;
       }
     }
     if (!skillPath) continue;
     try {
-      const raw = readFileSync21(skillPath, "utf-8");
+      const raw = readFileSync22(skillPath, "utf-8");
       const fmMatch = raw.match(/^---\s*\n([\s\S]*?)\n---/);
       if (fmMatch) {
         const fm = fmMatch[1];
@@ -35368,20 +35923,16 @@ function migrateSkillsToThreeTier() {
     log(`[skills] Three-tier migration complete: ${migrated} migrated, ${skipped} already current, ${failed} failed`);
   }
 }
-var USM_REPO, USM_DIR_NAME, CC_CLAW_ECOSYSTEM_PATCH, PKG_ROOT, PKG_SKILLS, MIGRATION_MARKER, SKILL_FILE_CANDIDATES2;
+var PKG_ROOT, PKG_SKILLS, MIGRATION_MARKER, SKILL_FILE_CANDIDATES2;
 var init_bootstrap = __esm({
   "src/skills/bootstrap.ts"() {
     "use strict";
     init_paths();
-    init_install();
     init_frontmatter();
     init_discover();
     init_log();
-    USM_REPO = "jacob-bd/universal-skills-manager";
-    USM_DIR_NAME = "universal-skills-manager";
-    CC_CLAW_ECOSYSTEM_PATCH = `| **CC-Claw** | \`~/.cc-claw/workspace/skills/\` | N/A (daemon, no project scope) |`;
-    PKG_ROOT = join33(dirname6(fileURLToPath2(import.meta.url)), "..", "..");
-    PKG_SKILLS = join33(PKG_ROOT, "skills");
+    PKG_ROOT = join34(dirname6(fileURLToPath2(import.meta.url)), "..", "..");
+    PKG_SKILLS = join34(PKG_ROOT, "skills");
     MIGRATION_MARKER = ".three-tier-migrated";
     SKILL_FILE_CANDIDATES2 = ["SKILL.md", "skill.md"];
   }
@@ -35453,19 +36004,19 @@ var init_migrate_embeddings = __esm({
 // src/mcps/bootstrap.ts
 function bootstrapBuiltinMcps(db3) {
   let seeded = 0;
-  for (const mcp of BUILTIN_MCPS) {
-    const existing = getMcpServer(db3, mcp.name);
+  for (const mcp2 of BUILTIN_MCPS) {
+    const existing = getMcpServer(db3, mcp2.name);
     if (existing) continue;
     addMcpServer(db3, {
-      name: mcp.name,
-      transport: mcp.transport,
-      command: mcp.command,
-      args: mcp.args,
-      description: mcp.description,
-      enabledByDefault: mcp.enabledByDefault
+      name: mcp2.name,
+      transport: mcp2.transport,
+      command: mcp2.command,
+      args: mcp2.args,
+      description: mcp2.description,
+      enabledByDefault: mcp2.enabledByDefault
     });
     seeded++;
-    log(`[mcps] Seeded built-in MCP: ${mcp.name}`);
+    log(`[mcps] Seeded built-in MCP: ${mcp2.name}`);
   }
   if (seeded > 0) {
     log(`[mcps] Bootstrapped ${seeded} built-in MCP server(s)`);
@@ -35496,13 +36047,13 @@ __export(ai_skill_exports, {
   generateAiSkill: () => generateAiSkill,
   installAiSkill: () => installAiSkill
 });
-import { existsSync as existsSync33, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11 } from "fs";
-import { join as join34 } from "path";
-import { homedir as homedir10 } from "os";
+import { existsSync as existsSync32, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11 } from "fs";
+import { join as join35 } from "path";
+import { homedir as homedir11 } from "os";
 function generateAiSkill() {
   const version = VERSION;
   let systemState = "";
-  if (existsSync33(DB_PATH)) {
+  if (existsSync32(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = (init_store5(), __toCommonJS(store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -35944,8 +36495,8 @@ function installAiSkill() {
   const failed = [];
   for (const [backend2, dirs] of Object.entries(BACKEND_SKILL_DIRS2)) {
     for (const dir of dirs) {
-      const skillDir = join34(dir, "cc-claw-cli");
-      const skillPath = join34(skillDir, "SKILL.md");
+      const skillDir = join35(dir, "cc-claw-cli");
+      const skillPath = join35(skillDir, "SKILL.md");
       try {
         mkdirSync11(skillDir, { recursive: true });
         writeFileSync11(skillPath, skill, "utf-8");
@@ -35964,11 +36515,11 @@ var init_ai_skill = __esm({
     init_paths();
     init_version();
     BACKEND_SKILL_DIRS2 = {
-      "cc-claw": [join34(homedir10(), ".cc-claw", "workspace", "skills")],
-      claude: [join34(homedir10(), ".claude", "skills")],
-      gemini: [join34(homedir10(), ".gemini", "skills")],
-      codex: [join34(homedir10(), ".agents", "skills")],
-      cursor: [join34(homedir10(), ".cursor", "skills"), join34(homedir10(), ".cursor", "skills-cursor")]
+      "cc-claw": [join35(homedir11(), ".cc-claw", "workspace", "skills")],
+      claude: [join35(homedir11(), ".claude", "skills")],
+      gemini: [join35(homedir11(), ".gemini", "skills")],
+      codex: [join35(homedir11(), ".agents", "skills")],
+      cursor: [join35(homedir11(), ".cursor", "skills"), join35(homedir11(), ".cursor", "skills-cursor")]
     };
   }
 });
@@ -35978,21 +36529,21 @@ var index_exports = {};
 __export(index_exports, {
   main: () => main
 });
-import { mkdirSync as mkdirSync12, existsSync as existsSync34, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync23 } from "fs";
-import { join as join35 } from "path";
+import { mkdirSync as mkdirSync12, existsSync as existsSync33, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync24 } from "fs";
+import { join as join36 } from "path";
 import dotenv from "dotenv";
 function migrateLayout() {
   const moves = [
-    [join35(CC_CLAW_HOME, "cc-claw.db"), join35(DATA_PATH, "cc-claw.db")],
-    [join35(CC_CLAW_HOME, "cc-claw.db-shm"), join35(DATA_PATH, "cc-claw.db-shm")],
-    [join35(CC_CLAW_HOME, "cc-claw.db-wal"), join35(DATA_PATH, "cc-claw.db-wal")],
-    [join35(CC_CLAW_HOME, "cc-claw.log"), join35(LOGS_PATH, "cc-claw.log")],
-    [join35(CC_CLAW_HOME, "cc-claw.log.1"), join35(LOGS_PATH, "cc-claw.log.1")],
-    [join35(CC_CLAW_HOME, "cc-claw.error.log"), join35(LOGS_PATH, "cc-claw.error.log")],
-    [join35(CC_CLAW_HOME, "cc-claw.error.log.1"), join35(LOGS_PATH, "cc-claw.error.log.1")]
+    [join36(CC_CLAW_HOME, "cc-claw.db"), join36(DATA_PATH, "cc-claw.db")],
+    [join36(CC_CLAW_HOME, "cc-claw.db-shm"), join36(DATA_PATH, "cc-claw.db-shm")],
+    [join36(CC_CLAW_HOME, "cc-claw.db-wal"), join36(DATA_PATH, "cc-claw.db-wal")],
+    [join36(CC_CLAW_HOME, "cc-claw.log"), join36(LOGS_PATH, "cc-claw.log")],
+    [join36(CC_CLAW_HOME, "cc-claw.log.1"), join36(LOGS_PATH, "cc-claw.log.1")],
+    [join36(CC_CLAW_HOME, "cc-claw.error.log"), join36(LOGS_PATH, "cc-claw.error.log")],
+    [join36(CC_CLAW_HOME, "cc-claw.error.log.1"), join36(LOGS_PATH, "cc-claw.error.log.1")]
   ];
   for (const [from, to] of moves) {
-    if (existsSync34(from) && !existsSync34(to)) {
+    if (existsSync33(from) && !existsSync33(to)) {
       try {
         renameSync2(from, to);
       } catch {
@@ -36021,7 +36572,7 @@ async function main() {
   let version = "unknown";
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    version = JSON.parse(readFileSync23(pkgPath, "utf-8")).version;
+    version = JSON.parse(readFileSync24(pkgPath, "utf-8")).version;
   } catch {
   }
   log(`[cc-claw] Starting v${version}`);
@@ -36196,10 +36747,10 @@ ${lines.join("\n")}`;
   try {
     const { generateAiSkill: generateAiSkill2 } = await Promise.resolve().then(() => (init_ai_skill(), ai_skill_exports));
     const { writeFileSync: writeFileSync16, mkdirSync: mkdirSync19 } = await import("fs");
-    const { join: join41 } = await import("path");
-    const skillDir = join41(SKILLS_PATH, "cc-claw-cli");
+    const { join: join42 } = await import("path");
+    const skillDir = join42(SKILLS_PATH, "cc-claw-cli");
     mkdirSync19(skillDir, { recursive: true });
-    writeFileSync16(join41(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
+    writeFileSync16(join42(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
     log("[cc-claw] AI skill updated");
   } catch {
   }
@@ -36237,6 +36788,8 @@ ${lines.join("\n")}`;
       const { stopAllActiveAgents: stopAllActiveAgents2, stopStaleChatSweep: stopStaleChatSweep2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
       stopAllActiveAgents2();
       stopStaleChatSweep2();
+      const { shutdownMcpPool: shutdownMcpPool2 } = await Promise.resolve().then(() => (init_pool(), pool_exports));
+      await shutdownMcpPool2();
       stopAllHeartbeats();
       stopHealthMonitor3();
       stopMonitor();
@@ -36299,10 +36852,10 @@ var init_index = __esm({
     init_health3();
     init_image_gen();
     for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SESSION_LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-      if (!existsSync34(dir)) mkdirSync12(dir, { recursive: true });
+      if (!existsSync33(dir)) mkdirSync12(dir, { recursive: true });
     }
     migrateLayout();
-    if (existsSync34(ENV_PATH)) {
+    if (existsSync33(ENV_PATH)) {
       dotenv.config({ path: ENV_PATH });
     } else {
       console.error(`[cc-claw] Config not found at ${ENV_PATH} \u2014 run 'cc-claw setup' first`);
@@ -36316,104 +36869,6 @@ var init_index = __esm({
   }
 });
 
-// src/cli/api-client.ts
-var api_client_exports = {};
-__export(api_client_exports, {
-  apiGet: () => apiGet,
-  apiPost: () => apiPost,
-  isDaemonRunning: () => isDaemonRunning
-});
-import { request as httpRequest, Agent } from "http";
-function getToken() {
-  if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
-  return readApiToken();
-}
-async function isDaemonRunning() {
-  try {
-    const res = await apiGet("/api/health");
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-async function apiGet(path) {
-  const token = getToken();
-  return new Promise((resolve3, reject) => {
-    const url = new URL(path, BASE_URL);
-    const req = httpRequest(url, {
-      method: "GET",
-      headers: token ? { "Authorization": `Bearer ${token}` } : {},
-      timeout: 3e3,
-      agent: keepAliveAgent
-    }, (res) => {
-      const chunks = [];
-      res.on("data", (c) => chunks.push(c));
-      res.on("end", () => {
-        const body = Buffer.concat(chunks).toString();
-        try {
-          const data = JSON.parse(body);
-          resolve3({ ok: res.statusCode === 200, status: res.statusCode ?? 0, data });
-        } catch {
-          resolve3({ ok: false, status: res.statusCode ?? 0, data: body });
-        }
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timed out"));
-    });
-    req.end();
-  });
-}
-async function apiPost(path, body, opts) {
-  const token = getToken();
-  const payload = JSON.stringify(body);
-  return new Promise((resolve3, reject) => {
-    const url = new URL(path, BASE_URL);
-    const req = httpRequest(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(payload).toString(),
-        ...token ? { "Authorization": `Bearer ${token}` } : {}
-      },
-      timeout: opts?.timeout ?? 3e4,
-      agent: keepAliveAgent
-    }, (res) => {
-      const chunks = [];
-      res.on("data", (c) => chunks.push(c));
-      res.on("end", () => {
-        const responseBody = Buffer.concat(chunks).toString();
-        try {
-          const data = JSON.parse(responseBody);
-          resolve3({ ok: res.statusCode === 200, status: res.statusCode ?? 0, data });
-        } catch {
-          resolve3({ ok: false, status: res.statusCode ?? 0, data: responseBody });
-        }
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timed out"));
-    });
-    req.write(payload);
-    req.end();
-  });
-}
-var DEFAULT_PORT, API_HOST, BASE_URL, keepAliveAgent;
-var init_api_client = __esm({
-  "src/cli/api-client.ts"() {
-    "use strict";
-    init_paths();
-    DEFAULT_PORT = parseInt(process.env.DASHBOARD_PORT ?? "3141", 10);
-    API_HOST = process.env.CC_CLAW_API_HOST ?? "127.0.0.1";
-    BASE_URL = `http://${API_HOST}:${DEFAULT_PORT}`;
-    keepAliveAgent = new Agent({ keepAlive: true, maxSockets: 4 });
-  }
-});
-
 // src/service.ts
 var service_exports2 = {};
 __export(service_exports2, {
@@ -36421,10 +36876,10 @@ __export(service_exports2, {
   serviceStatus: () => serviceStatus,
   uninstallService: () => uninstallService
 });
-import { existsSync as existsSync35, mkdirSync as mkdirSync13, writeFileSync as writeFileSync12, unlinkSync as unlinkSync8 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync13, writeFileSync as writeFileSync12, unlinkSync as unlinkSync8 } from "fs";
 import { execFileSync as execFileSync4, execSync as execSync5 } from "child_process";
-import { homedir as homedir11, platform } from "os";
-import { join as join36, dirname as dirname7 } from "path";
+import { homedir as homedir12, platform } from "os";
+import { join as join37, dirname as dirname7 } from "path";
 function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -36433,23 +36888,23 @@ function resolveExecutable3(name) {
     return execFileSync4("which", [name], { encoding: "utf-8" }).trim();
   } catch {
     const fallback = process.argv[1];
-    if (fallback && existsSync35(fallback)) return fallback;
+    if (fallback && existsSync34(fallback)) return fallback;
     throw new Error(`Cannot find '${name}' executable. Install globally: npm install -g cc-claw`);
   }
 }
 function getPathDirs() {
   const nodeBin = dirname7(process.execPath);
-  const home = homedir11();
+  const home = homedir12();
   const dirs = /* @__PURE__ */ new Set([
     nodeBin,
-    join36(home, ".local", "bin"),
+    join37(home, ".local", "bin"),
     "/usr/local/bin",
     "/usr/bin",
     "/bin"
   ]);
   try {
     const prefix = execSync5("npm config get prefix", { encoding: "utf-8" }).trim();
-    if (prefix) dirs.add(join36(prefix, "bin"));
+    if (prefix) dirs.add(join37(prefix, "bin"));
   } catch {
   }
   return [...dirs].join(":");
@@ -36457,7 +36912,7 @@ function getPathDirs() {
 function generatePlist() {
   const ccClawBin = resolveExecutable3("cc-claw");
   const pathDirs = getPathDirs();
-  const home = homedir11();
+  const home = homedir12();
   const safeBin = xmlEscape(ccClawBin);
   const safePaths = xmlEscape(pathDirs);
   const safeHome = xmlEscape(home);
@@ -36508,9 +36963,9 @@ function generatePlist() {
 }
 function installMacOS() {
   const agentsDir = dirname7(PLIST_PATH);
-  if (!existsSync35(agentsDir)) mkdirSync13(agentsDir, { recursive: true });
-  if (!existsSync35(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
-  if (existsSync35(PLIST_PATH)) {
+  if (!existsSync34(agentsDir)) mkdirSync13(agentsDir, { recursive: true });
+  if (!existsSync34(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
+  if (existsSync34(PLIST_PATH)) {
     try {
       execFileSync4("launchctl", ["unload", PLIST_PATH]);
     } catch {
@@ -36522,7 +36977,7 @@ function installMacOS() {
   console.log("  Service loaded and starting.");
 }
 function uninstallMacOS() {
-  if (!existsSync35(PLIST_PATH)) {
+  if (!existsSync34(PLIST_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
@@ -36590,15 +37045,15 @@ Restart=on-failure
 RestartSec=10
 WorkingDirectory=${CC_CLAW_HOME}
 Environment=PATH=${pathDirs}
-Environment=HOME=${homedir11()}
+Environment=HOME=${homedir12()}
 
 [Install]
 WantedBy=default.target
 `;
 }
 function installLinux() {
-  if (!existsSync35(SYSTEMD_DIR)) mkdirSync13(SYSTEMD_DIR, { recursive: true });
-  if (!existsSync35(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
+  if (!existsSync34(SYSTEMD_DIR)) mkdirSync13(SYSTEMD_DIR, { recursive: true });
+  if (!existsSync34(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
   writeFileSync12(UNIT_PATH, generateUnit());
   console.log(`  Installed: ${UNIT_PATH}`);
   execFileSync4("systemctl", ["--user", "daemon-reload"]);
@@ -36607,7 +37062,7 @@ function installLinux() {
   console.log("  Service enabled and started.");
 }
 function uninstallLinux() {
-  if (!existsSync35(UNIT_PATH)) {
+  if (!existsSync34(UNIT_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
@@ -36632,7 +37087,7 @@ function statusLinux() {
   }
 }
 function installService() {
-  if (!existsSync35(join36(CC_CLAW_HOME, ".env"))) {
+  if (!existsSync34(join37(CC_CLAW_HOME, ".env"))) {
     console.error(`  Config not found at ${CC_CLAW_HOME}/.env`);
     console.error("  Run 'cc-claw setup' before installing the service.");
     process.exitCode = 1;
@@ -36661,9 +37116,9 @@ var init_service2 = __esm({
     "use strict";
     init_paths();
     PLIST_LABEL = "com.cc-claw";
-    PLIST_PATH = join36(homedir11(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-    SYSTEMD_DIR = join36(homedir11(), ".config", "systemd", "user");
-    UNIT_PATH = join36(SYSTEMD_DIR, "cc-claw.service");
+    PLIST_PATH = join37(homedir12(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+    SYSTEMD_DIR = join37(homedir12(), ".config", "systemd", "user");
+    UNIT_PATH = join37(SYSTEMD_DIR, "cc-claw.service");
   }
 });
 
@@ -36830,13 +37285,13 @@ var init_daemon = __esm({
 });
 
 // src/cli/resolve-chat.ts
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 function resolveChatId2(globalOpts) {
   const explicit = globalOpts.chat;
   if (explicit) return explicit;
   if (_cachedDefault) return _cachedDefault;
   try {
-    const content = readFileSync25(ENV_PATH, "utf-8");
+    const content = readFileSync26(ENV_PATH, "utf-8");
     const match = content.match(/^ALLOWED_CHAT_ID=(.+)$/m);
     if (match) {
       _cachedDefault = match[1].split(",")[0].trim();
@@ -36860,7 +37315,7 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import { existsSync as existsSync36, statSync as statSync10 } from "fs";
+import { existsSync as existsSync35, statSync as statSync10 } from "fs";
 async function statusCommand(globalOpts, localOpts) {
   try {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
@@ -36900,7 +37355,7 @@ async function statusCommand(globalOpts, localOpts) {
     const cwdRow = readDb.prepare("SELECT cwd FROM chat_cwd WHERE chat_id = ?").get(chatId);
     const voiceRow = readDb.prepare("SELECT enabled FROM chat_voice WHERE chat_id = ?").get(chatId);
     const usageRow = readDb.prepare("SELECT * FROM chat_usage WHERE chat_id = ?").get(chatId);
-    const dbStat = existsSync36(DB_PATH) ? statSync10(DB_PATH) : null;
+    const dbStat = existsSync35(DB_PATH) ? statSync10(DB_PATH) : null;
     let daemonRunning = false;
     let daemonInfo = {};
     try {
@@ -37012,13 +37467,13 @@ __export(doctor_exports, {
   doctorCommand: () => doctorCommand,
   doctorErrors: () => doctorErrors
 });
-import { existsSync as existsSync37, accessSync, constants } from "fs";
+import { existsSync as existsSync36, accessSync, constants } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
 async function doctorCommand(globalOpts, localOpts) {
   const checks = [];
   const dbChecks = checkDatabase();
   checks.push(...dbChecks);
-  if (existsSync37(DB_PATH)) {
+  if (existsSync36(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -37044,7 +37499,7 @@ async function doctorCommand(globalOpts, localOpts) {
       checks.push({ name: "Database health", status: "error", message: err.message });
     }
   }
-  if (existsSync37(ENV_PATH)) {
+  if (existsSync36(ENV_PATH)) {
     checks.push({ name: "Environment", status: "ok", message: `.env loaded` });
   } else {
     checks.push({ name: "Environment", status: "error", message: "No .env found", fix: "cc-claw setup" });
@@ -37087,7 +37542,7 @@ async function doctorCommand(globalOpts, localOpts) {
   } catch {
   }
   const tokenPath = `${DATA_PATH}/api-token`;
-  if (existsSync37(tokenPath)) {
+  if (existsSync36(tokenPath)) {
     try {
       accessSync(tokenPath, constants.R_OK);
       checks.push({ name: "API token", status: "ok", message: "token file readable" });
@@ -37156,7 +37611,7 @@ async function doctorCommand(globalOpts, localOpts) {
     const errorChecks = checks.filter(
       (c) => ["Rate limits", "Content silence", "Spawn timeouts", "Other errors"].includes(c.name) && c.status !== "ok"
     );
-    if (errorChecks.length > 0 && existsSync37(ERROR_LOG_PATH)) {
+    if (errorChecks.length > 0 && existsSync36(ERROR_LOG_PATH)) {
       try {
         const { writeFileSync: writeFileSync16 } = await import("fs");
         writeFileSync16(ERROR_LOG_PATH, "");
@@ -37285,15 +37740,15 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import { existsSync as existsSync38, readFileSync as readFileSync27, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync28, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
 async function logsCommand(opts) {
   const logFile = opts.error ? ERROR_LOG_PATH : LOG_PATH;
-  if (!existsSync38(logFile)) {
+  if (!existsSync37(logFile)) {
     outputError("LOG_NOT_FOUND", `Log file not found: ${logFile}`);
     process.exit(1);
   }
   const maxLines = parseInt(opts.lines ?? "100", 10);
-  const content = readFileSync27(logFile, "utf-8");
+  const content = readFileSync28(logFile, "utf-8");
   const allLines = content.split("\n");
   const tailLines = allLines.slice(-maxLines);
   console.log(muted(`  \u2500\u2500 ${logFile} (last ${tailLines.length} lines) \u2500\u2500`));
@@ -37303,7 +37758,7 @@ async function logsCommand(opts) {
     let lastLength = content.length;
     watchFile2(logFile, { interval: 500 }, () => {
       try {
-        const newContent = readFileSync27(logFile, "utf-8");
+        const newContent = readFileSync28(logFile, "utf-8");
         if (newContent.length > lastLength) {
           const newPart = newContent.slice(lastLength);
           process.stdout.write(newPart);
@@ -37335,7 +37790,7 @@ __export(session_logs_exports, {
   sessionLogsList: () => sessionLogsList,
   sessionLogsTail: () => sessionLogsTail
 });
-import { readFileSync as readFileSync28, watchFile as watchFile3, unwatchFile as unwatchFile3 } from "fs";
+import { readFileSync as readFileSync29, watchFile as watchFile3, unwatchFile as unwatchFile3 } from "fs";
 async function sessionLogsList(opts) {
   const logs = listSessionLogs();
   if (logs.length === 0) {
@@ -37392,12 +37847,12 @@ async function sessionLogsTail(opts) {
     console.log(muted("\n  Following... (Ctrl+C to stop)\n"));
     let lastLength = 0;
     try {
-      lastLength = readFileSync28(targetPath, "utf-8").length;
+      lastLength = readFileSync29(targetPath, "utf-8").length;
     } catch {
     }
     watchFile3(targetPath, { interval: 500 }, () => {
       try {
-        const content = readFileSync28(targetPath, "utf-8");
+        const content = readFileSync29(targetPath, "utf-8");
         if (content.length > lastLength) {
           process.stdout.write(content.slice(lastLength));
           lastLength = content.length;
@@ -37441,11 +37896,11 @@ __export(gemini_exports, {
   geminiReorder: () => geminiReorder,
   geminiRotation: () => geminiRotation
 });
-import { existsSync as existsSync40, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13, readFileSync as readFileSync29, chmodSync } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13, readFileSync as readFileSync30, chmodSync } from "fs";
+import { join as join38 } from "path";
 import { createInterface as createInterface8 } from "readline";
 function requireDb() {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -37470,9 +37925,9 @@ async function resolveSlotId(idOrLabel) {
 function resolveOAuthEmail(configHome) {
   if (!configHome) return null;
   try {
-    const accountsPath = join37(configHome, ".gemini", "google_accounts.json");
-    if (!existsSync40(accountsPath)) return null;
-    const accounts = JSON.parse(readFileSync29(accountsPath, "utf-8"));
+    const accountsPath = join38(configHome, ".gemini", "google_accounts.json");
+    if (!existsSync39(accountsPath)) return null;
+    const accounts = JSON.parse(readFileSync30(accountsPath, "utf-8"));
     return accounts.active || null;
   } catch {
     return null;
@@ -37554,14 +38009,14 @@ async function geminiAddKey(globalOpts, opts) {
 }
 async function geminiAddAccount(globalOpts, opts) {
   await requireWriteDb();
-  const slotsDir = join37(CC_CLAW_HOME, "gemini-slots");
-  if (!existsSync40(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
+  const slotsDir = join38(CC_CLAW_HOME, "gemini-slots");
+  if (!existsSync39(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
   const { addGeminiSlot: addGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const tempId = Date.now();
-  const slotDir = join37(slotsDir, `slot-${tempId}`);
+  const slotDir = join38(slotsDir, `slot-${tempId}`);
   mkdirSync14(slotDir, { recursive: true, mode: 448 });
-  mkdirSync14(join37(slotDir, ".gemini"), { recursive: true });
-  writeFileSync13(join37(slotDir, ".gemini", "settings.json"), JSON.stringify({
+  mkdirSync14(join38(slotDir, ".gemini"), { recursive: true });
+  writeFileSync13(join38(slotDir, ".gemini", "settings.json"), JSON.stringify({
     security: { auth: { selectedType: "oauth-personal" } }
   }, null, 2));
   console.log("");
@@ -37578,8 +38033,8 @@ async function geminiAddAccount(globalOpts, opts) {
     });
   } catch {
   }
-  const oauthPath = join37(slotDir, ".gemini", "oauth_creds.json");
-  if (!existsSync40(oauthPath)) {
+  const oauthPath = join38(slotDir, ".gemini", "oauth_creds.json");
+  if (!existsSync39(oauthPath)) {
     console.log(error2("\n  No OAuth credentials found. Sign-in may have failed."));
     console.log("  The slot directory is preserved at: " + slotDir);
     console.log("  Re-run: cc-claw gemini add-account\n");
@@ -37587,7 +38042,7 @@ async function geminiAddAccount(globalOpts, opts) {
   }
   let accountEmail = "unknown";
   try {
-    const accounts = JSON.parse(__require("fs").readFileSync(join37(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(__require("fs").readFileSync(join38(slotDir, ".gemini", "google_accounts.json"), "utf-8"));
     accountEmail = accounts.active || accountEmail;
   } catch {
   }
@@ -37698,9 +38153,9 @@ async function geminiRelogin(globalOpts, idOrLabel) {
     outputError("NO_CONFIG", `Slot "${idOrLabel}" has no config directory \u2014 cannot re-login.`);
     return;
   }
-  const settingsPath = join37(slot.configHome, ".gemini", "settings.json");
-  if (!existsSync40(settingsPath)) {
-    mkdirSync14(join37(slot.configHome, ".gemini"), { recursive: true });
+  const settingsPath = join38(slot.configHome, ".gemini", "settings.json");
+  if (!existsSync39(settingsPath)) {
+    mkdirSync14(join38(slot.configHome, ".gemini"), { recursive: true });
     writeFileSync13(settingsPath, JSON.stringify({
       security: { auth: { selectedType: "oauth-personal" } }
     }, null, 2));
@@ -37724,8 +38179,8 @@ async function geminiRelogin(globalOpts, idOrLabel) {
     });
   } catch {
   }
-  const oauthPath = join37(slot.configHome, ".gemini", "oauth_creds.json");
-  if (!existsSync40(oauthPath)) {
+  const oauthPath = join38(slot.configHome, ".gemini", "oauth_creds.json");
+  if (!existsSync39(oauthPath)) {
     console.log(error2("\n  Re-login failed \u2014 no OAuth credentials found."));
     console.log(`  Try again: cc-claw gemini re-login ${idOrLabel}
 `);
@@ -37735,7 +38190,7 @@ async function geminiRelogin(globalOpts, idOrLabel) {
   setGeminiSlotEnabled2(slotId, true);
   let accountEmail = slot.label;
   try {
-    const accounts = JSON.parse(readFileSync29(join37(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(readFileSync30(join38(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
     if (accounts.active) accountEmail = accounts.active;
   } catch {
   }
@@ -37794,11 +38249,11 @@ __export(backend_cmd_factory_exports, {
   makeReorder: () => makeReorder,
   registerBackendSlotCommands: () => registerBackendSlotCommands
 });
-import { existsSync as existsSync41, mkdirSync as mkdirSync15, readFileSync as readFileSync30 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync15, readFileSync as readFileSync31 } from "fs";
+import { join as join39 } from "path";
 import { createInterface as createInterface9 } from "readline";
 function requireDb2() {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -37887,10 +38342,10 @@ function makeAddAccount(backend2, displayName) {
       process.exit(1);
     }
     await requireWriteDb2();
-    const slotsDir = join38(CC_CLAW_HOME, config2.slotsSubdir);
-    if (!existsSync41(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
+    const slotsDir = join39(CC_CLAW_HOME, config2.slotsSubdir);
+    if (!existsSync40(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
     const tempId = Date.now();
-    const slotDir = join38(slotsDir, `slot-${tempId}`);
+    const slotDir = join39(slotsDir, `slot-${tempId}`);
     mkdirSync15(slotDir, { recursive: true, mode: 448 });
     if (config2.preSetup) config2.preSetup(slotDir);
     console.log("");
@@ -38141,22 +38596,22 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { ANTHROPIC_API_KEY: void 0 },
         preSetup: (slotDir) => {
-          mkdirSync15(join38(slotDir, ".claude"), { recursive: true });
+          mkdirSync15(join39(slotDir, ".claude"), { recursive: true });
         },
         verifyCredentials: (slotDir) => {
-          const claudeJson = join38(slotDir, ".claude.json");
-          const claudeJsonNested = join38(slotDir, ".claude", ".claude.json");
-          if (existsSync41(claudeJson)) {
+          const claudeJson = join39(slotDir, ".claude.json");
+          const claudeJsonNested = join39(slotDir, ".claude", ".claude.json");
+          if (existsSync40(claudeJson)) {
             try {
-              const data = JSON.parse(readFileSync30(claudeJson, "utf-8"));
+              const data = JSON.parse(readFileSync31(claudeJson, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
             }
           }
-          if (existsSync41(claudeJsonNested)) {
+          if (existsSync40(claudeJsonNested)) {
             try {
-              const data = JSON.parse(readFileSync30(claudeJsonNested, "utf-8"));
+              const data = JSON.parse(readFileSync31(claudeJsonNested, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
@@ -38177,9 +38632,9 @@ var init_backend_cmd_factory = __esm({
           } catch {
           }
           try {
-            const claudeJson = join38(slotDir, ".claude.json");
-            if (existsSync41(claudeJson)) {
-              const data = JSON.parse(readFileSync30(claudeJson, "utf-8"));
+            const claudeJson = join39(slotDir, ".claude.json");
+            if (existsSync40(claudeJson)) {
+              const data = JSON.parse(readFileSync31(claudeJson, "utf-8"));
               if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
             }
           } catch {
@@ -38194,11 +38649,11 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { OPENAI_API_KEY: void 0 },
         verifyCredentials: (slotDir) => {
-          return existsSync41(join38(slotDir, "auth.json"));
+          return existsSync40(join39(slotDir, "auth.json"));
         },
         extractLabel: (slotDir) => {
           try {
-            const authData = JSON.parse(readFileSync30(join38(slotDir, "auth.json"), "utf-8"));
+            const authData = JSON.parse(readFileSync31(join39(slotDir, "auth.json"), "utf-8"));
             if (authData.email) return authData.email;
             if (authData.account_name) return authData.account_name;
             if (authData.user?.email) return authData.user.email;
@@ -38262,9 +38717,9 @@ __export(ollama_exports3, {
   ollamaRemove: () => ollamaRemove,
   ollamaTest: () => ollamaTest
 });
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 function requireDb3() {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -38526,12 +38981,12 @@ __export(backend_exports, {
   backendList: () => backendList,
   backendSet: () => backendSet
 });
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 async function backendList(globalOpts) {
   const { getAvailableAdapters: getAvailableAdapters3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   const chatId = resolveChatId2(globalOpts);
   let activeBackend = null;
-  if (existsSync43(DB_PATH)) {
+  if (existsSync42(DB_PATH)) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     try {
@@ -38562,7 +39017,7 @@ async function backendList(globalOpts) {
 }
 async function backendGet(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -38606,13 +39061,13 @@ __export(model_exports, {
   modelList: () => modelList,
   modelSet: () => modelSet
 });
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 async function modelList(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const { getAdapter: getAdapter3, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
-  if (existsSync44(DB_PATH)) {
+  if (existsSync43(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
     try {
       const row = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
@@ -38645,7 +39100,7 @@ async function modelList(globalOpts) {
 }
 async function modelGet(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -38690,9 +39145,9 @@ __export(memory_exports2, {
   memoryOptimize: () => memoryOptimize,
   memorySearch: () => memorySearch
 });
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 async function memoryList(globalOpts) {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -38716,7 +39171,7 @@ async function memoryList(globalOpts) {
   });
 }
 async function memorySearch(globalOpts, query) {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -38738,7 +39193,7 @@ async function memorySearch(globalOpts, query) {
   });
 }
 async function memoryHistory(globalOpts, opts) {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -38839,7 +39294,7 @@ __export(cron_exports2, {
   cronList: () => cronList,
   cronRuns: () => cronRuns
 });
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 function parseFallbacks(raw) {
   return raw.slice(0, 3).map((f) => {
     const [backend2, ...rest] = f.split(":");
@@ -38860,7 +39315,7 @@ function parseAndValidateTimeout(raw) {
   return val;
 }
 async function cronList(globalOpts) {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -38898,7 +39353,7 @@ async function cronList(globalOpts) {
   });
 }
 async function cronHealth(globalOpts) {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39082,7 +39537,7 @@ async function cronEdit(globalOpts, id, opts) {
   }
 }
 async function cronRuns(globalOpts, jobId, opts) {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39129,9 +39584,9 @@ __export(agents_exports, {
   runnersList: () => runnersList,
   tasksList: () => tasksList
 });
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 async function agentsList(globalOpts) {
-  if (!existsSync47(DB_PATH)) {
+  if (!existsSync46(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39162,7 +39617,7 @@ async function agentsList(globalOpts) {
   });
 }
 async function tasksList(globalOpts) {
-  if (!existsSync47(DB_PATH)) {
+  if (!existsSync46(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39290,10 +39745,10 @@ __export(db_exports, {
   dbPath: () => dbPath,
   dbStats: () => dbStats
 });
-import { existsSync as existsSync48, statSync as statSync11, copyFileSync as copyFileSync4, mkdirSync as mkdirSync16 } from "fs";
+import { existsSync as existsSync47, statSync as statSync11, copyFileSync as copyFileSync4, mkdirSync as mkdirSync16 } from "fs";
 import { dirname as dirname8 } from "path";
 async function dbStats(globalOpts) {
-  if (!existsSync48(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -39301,7 +39756,7 @@ async function dbStats(globalOpts) {
   const readDb = openDatabaseReadOnly2();
   const mainSize = statSync11(DB_PATH).size;
   const walPath = DB_PATH + "-wal";
-  const walSize = existsSync48(walPath) ? statSync11(walPath).size : 0;
+  const walSize = existsSync47(walPath) ? statSync11(walPath).size : 0;
   const tableNames = readDb.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' ORDER BY name"
   ).all();
@@ -39335,7 +39790,7 @@ async function dbPath(globalOpts) {
   output({ path: DB_PATH }, (d) => d.path);
 }
 async function dbBackup(globalOpts, destPath) {
-  if (!existsSync48(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -39344,7 +39799,7 @@ async function dbBackup(globalOpts, destPath) {
     mkdirSync16(dirname8(dest), { recursive: true });
     copyFileSync4(DB_PATH, dest);
     const walPath = DB_PATH + "-wal";
-    if (existsSync48(walPath)) copyFileSync4(walPath, dest + "-wal");
+    if (existsSync47(walPath)) copyFileSync4(walPath, dest + "-wal");
     output({ path: dest, sizeBytes: statSync11(dest).size }, (d) => {
       const b = d;
       return `
@@ -39373,9 +39828,9 @@ __export(usage_exports, {
   usageCost: () => usageCost,
   usageTokens: () => usageTokens
 });
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 function ensureDb() {
-  if (!existsSync49(DB_PATH)) {
+  if (!existsSync48(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -39565,9 +40020,9 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync50, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync32 } from "fs";
 async function configList(globalOpts) {
-  if (!existsSync50(DB_PATH)) {
+  if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39601,7 +40056,7 @@ async function configGet(globalOpts, key) {
     outputError("INVALID_KEY", `Unknown config key "${key}". Valid keys: ${RUNTIME_KEYS.join(", ")}`);
     process.exit(1);
   }
-  if (!existsSync50(DB_PATH)) {
+  if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39647,11 +40102,11 @@ async function configSet(globalOpts, key, value) {
   }
 }
 async function configEnv(_globalOpts) {
-  if (!existsSync50(ENV_PATH)) {
+  if (!existsSync49(ENV_PATH)) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
-  const content = readFileSync31(ENV_PATH, "utf-8");
+  const content = readFileSync32(ENV_PATH, "utf-8");
   const entries = {};
   const secretPatterns = /TOKEN|KEY|SECRET|PASSWORD|CREDENTIALS/i;
   for (const line of content.split("\n")) {
@@ -39701,9 +40156,9 @@ __export(session_exports, {
   sessionGet: () => sessionGet,
   sessionNew: () => sessionNew
 });
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 async function sessionGet(globalOpts) {
-  if (!existsSync51(DB_PATH)) {
+  if (!existsSync50(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39764,9 +40219,9 @@ __export(permissions_exports, {
   verboseGet: () => verboseGet,
   verboseSet: () => verboseSet
 });
-import { existsSync as existsSync52 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 function ensureDb2() {
-  if (!existsSync52(DB_PATH)) {
+  if (!existsSync51(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39913,9 +40368,9 @@ __export(cwd_exports, {
   cwdGet: () => cwdGet,
   cwdSet: () => cwdSet
 });
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync52 } from "fs";
 async function cwdGet(globalOpts) {
-  if (!existsSync53(DB_PATH)) {
+  if (!existsSync52(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -39977,9 +40432,9 @@ __export(voice_exports, {
   voiceGet: () => voiceGet,
   voiceSet: () => voiceSet
 });
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 async function voiceGet(globalOpts) {
-  if (!existsSync54(DB_PATH)) {
+  if (!existsSync53(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -40028,9 +40483,9 @@ __export(heartbeat_exports2, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 async function heartbeatGet(globalOpts) {
-  if (!existsSync55(DB_PATH)) {
+  if (!existsSync54(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -40241,9 +40696,9 @@ __export(summarizer_exports, {
   summarizerGet: () => summarizerGet,
   summarizerSet: () => summarizerSet
 });
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 async function summarizerGet(globalOpts) {
-  if (!existsSync56(DB_PATH)) {
+  if (!existsSync55(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -40287,9 +40742,9 @@ __export(thinking_exports, {
   thinkingGet: () => thinkingGet,
   thinkingSet: () => thinkingSet
 });
-import { existsSync as existsSync57 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 async function thinkingGet(globalOpts) {
-  if (!existsSync57(DB_PATH)) {
+  if (!existsSync56(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -40333,9 +40788,9 @@ __export(chats_exports, {
   chatsList: () => chatsList,
   chatsRemoveAlias: () => chatsRemoveAlias
 });
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 async function chatsList(_globalOpts) {
-  if (!existsSync58(DB_PATH)) {
+  if (!existsSync57(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -40458,41 +40913,186 @@ var init_skills = __esm({
   }
 });
 
-// src/cli/commands/mcps.ts
-var mcps_exports2 = {};
-__export(mcps_exports2, {
-  mcpsList: () => mcpsList
+// src/cli/commands/mcp.ts
+var mcp_exports2 = {};
+__export(mcp_exports2, {
+  mcpAdd: () => mcpAdd,
+  mcpDisable: () => mcpDisable,
+  mcpEnable: () => mcpEnable,
+  mcpExport: () => mcpExport,
+  mcpHealth: () => mcpHealth,
+  mcpList: () => mcpList,
+  mcpRemove: () => mcpRemove
 });
-import { existsSync as existsSync59 } from "fs";
-async function mcpsList(_globalOpts) {
-  if (!existsSync59(DB_PATH)) {
-    outputError("DB_NOT_FOUND", "Database not found.");
+import { existsSync as existsSync58 } from "fs";
+function requireDb4() {
+  if (!existsSync58(DB_PATH)) {
+    outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
+}
+async function mcpList(globalOpts) {
+  requireDb4();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-  const readDb = openDatabaseReadOnly2();
-  const mcps2 = readDb.prepare("SELECT * FROM mcp_servers ORDER BY name").all();
-  readDb.close();
-  output(mcps2, (d) => {
+  const { listMcpServers: listMcpServers2 } = await Promise.resolve().then(() => (init_store2(), store_exports2));
+  const db3 = openDatabaseReadOnly2();
+  const mcps = listMcpServers2(db3);
+  db3.close();
+  output(mcps, (d) => {
     const list = d;
-    if (list.length === 0) return `
-  ${muted("No MCP servers registered.")}
+    if (list.length === 0) {
+      return `
+  ${muted("No MCP servers registered. Use `cc-claw mcp add` or `cc-claw mcp import`.")}
 `;
+    }
     const lines = ["", divider(`MCP Servers (${list.length})`), ""];
     for (const m of list) {
-      const auto = m.enabledByDefault ? " \u{1F4CC}" : "";
-      const desc = m.description ? ` \u2014 ${m.description}` : "";
-      lines.push(`  ${checkMark(true)} ${m.name}${auto}${desc}`);
+      const lock = SYSTEM_MCP_NAMES.has(m.name) ? " \u{1F512}" : "";
+      const pin = m.enabledByDefault ? " \u{1F4CC}" : "";
+      const desc = m.description ? ` \u2014 ${muted(m.description)}` : "";
+      const transport = muted(`[${m.transport}]`);
+      const cmd = m.command ? muted(` ${m.command}`) : "";
+      lines.push(
+        `  ${healthIcon(m.healthStatus)} ${success(m.name)}${lock}${pin} ${transport}${cmd}${desc}`
+      );
     }
     lines.push("");
     return lines.join("\n");
   });
 }
-var init_mcps2 = __esm({
-  "src/cli/commands/mcps.ts"() {
+async function mcpAdd(name, command, args, globalOpts) {
+  if (SYSTEM_MCP_NAMES.has(name)) {
+    outputError("RESERVED_NAME", `"${name}" is a reserved system MCP name.`);
+    process.exit(1);
+  }
+  const { isDaemonRunning: isDaemonRunning2, apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+  if (!await isDaemonRunning2()) {
+    outputError("DAEMON_DOWN", "Daemon is not running. Start it with: cc-claw service start");
+    process.exit(1);
+  }
+  const res = await apiPost2("/api/mcps", {
+    name,
+    transport: "stdio",
+    command,
+    args,
+    enabledByDefault: true
+  });
+  output(
+    res.data,
+    () => res.ok ? `
+  ${success("\u2713")} Added MCP server "${name}"
+` : `
+  ${error2("\u2717")} Failed to add MCP: ${JSON.stringify(res.data)}
+`
+  );
+  if (!res.ok) process.exit(1);
+}
+async function mcpRemove(name, globalOpts) {
+  if (SYSTEM_MCP_NAMES.has(name)) {
+    outputError("PROTECTED", `Cannot remove system MCP "${name}"`);
+    process.exit(1);
+  }
+  const { isDaemonRunning: isDaemonRunning2, apiDelete: apiDelete2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+  if (!await isDaemonRunning2()) {
+    outputError("DAEMON_DOWN", "Daemon is not running. Start it with: cc-claw service start");
+    process.exit(1);
+  }
+  const res = await apiDelete2(`/api/mcps/${encodeURIComponent(name)}`);
+  output(
+    res.data,
+    () => res.ok ? `
+  ${success("\u2713")} Removed MCP server "${name}"
+` : `
+  ${error2("\u2717")} Failed to remove MCP: ${JSON.stringify(res.data)}
+`
+  );
+  if (!res.ok) process.exit(1);
+}
+async function mcpEnable(name, globalOpts) {
+  if (SYSTEM_MCP_NAMES.has(name)) {
+    outputError("PROTECTED", `Cannot enable system MCP "${name}"`);
+    process.exit(1);
+  }
+  const { isDaemonRunning: isDaemonRunning2, apiPut: apiPut2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+  if (!await isDaemonRunning2()) {
+    outputError("DAEMON_DOWN", "Daemon is not running. Start it with: cc-claw service start");
+    process.exit(1);
+  }
+  const res = await apiPut2(`/api/mcps/${encodeURIComponent(name)}`, { enabledByDefault: true });
+  output(
+    res.data,
+    () => res.ok ? `
+  ${success("\u2713")} Enabled "${name}"
+` : `
+  ${error2("\u2717")} Failed to enable MCP: ${JSON.stringify(res.data)}
+`
+  );
+  if (!res.ok) process.exit(1);
+}
+async function mcpDisable(name, globalOpts) {
+  if (SYSTEM_MCP_NAMES.has(name)) {
+    outputError("PROTECTED", `Cannot disable system MCP "${name}"`);
+    process.exit(1);
+  }
+  const { isDaemonRunning: isDaemonRunning2, apiPut: apiPut2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+  if (!await isDaemonRunning2()) {
+    outputError("DAEMON_DOWN", "Daemon is not running. Start it with: cc-claw service start");
+    process.exit(1);
+  }
+  const res = await apiPut2(`/api/mcps/${encodeURIComponent(name)}`, { enabledByDefault: false });
+  output(
+    res.data,
+    () => res.ok ? `
+  ${success("\u2713")} Disabled "${name}"
+` : `
+  ${error2("\u2717")} Failed to disable MCP: ${JSON.stringify(res.data)}
+`
+  );
+  if (!res.ok) process.exit(1);
+}
+async function mcpExport(globalOpts) {
+  requireDb4();
+  const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const { listMcpServers: listMcpServers2 } = await Promise.resolve().then(() => (init_store2(), store_exports2));
+  const db3 = openDatabaseReadOnly2();
+  const mcps = listMcpServers2(db3);
+  db3.close();
+  const servers = {};
+  for (const m of mcps) {
+    if (SYSTEM_MCP_NAMES.has(m.name)) continue;
+    servers[m.name] = {
+      transport: m.transport,
+      command: m.command ?? void 0,
+      args: m.args ? JSON.parse(m.args) : void 0,
+      env: m.env ? JSON.parse(m.env) : void 0
+    };
+  }
+  const exportData = { mcpServers: servers };
+  output(exportData, () => JSON.stringify(exportData, null, 2));
+}
+async function mcpHealth(globalOpts) {
+  const { isDaemonRunning: isDaemonRunning2, apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+  if (!await isDaemonRunning2()) {
+    outputError("DAEMON_DOWN", "Daemon is not running. Start it with: cc-claw service start");
+    process.exit(1);
+  }
+  const res = await apiPost2("/api/mcps/health", {});
+  output(
+    res.data,
+    () => res.ok ? `
+  ${success("\u2713")} Health checks triggered. Run \`cc-claw mcp list\` to see updated status.
+` : `
+  ${error2("\u2717")} Health check failed: ${JSON.stringify(res.data)}
+`
+  );
+  if (!res.ok) process.exit(1);
+}
+var init_mcp2 = __esm({
+  "src/cli/commands/mcp.ts"() {
     "use strict";
     init_format2();
     init_paths();
+    init_constants();
   }
 });
 
@@ -40502,11 +41102,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync32, existsSync as existsSync60 } from "fs";
+import { readFileSync as readFileSync33, existsSync as existsSync59 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync60(TOKEN_PATH)) return readFileSync32(TOKEN_PATH, "utf-8").trim();
+    if (existsSync59(TOKEN_PATH)) return readFileSync33(TOKEN_PATH, "utf-8").trim();
   } catch {
   }
   return null;
@@ -40994,8 +41594,8 @@ __export(completion_exports, {
   completionCommand: () => completionCommand
 });
 import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync17 } from "fs";
-import { join as join39 } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join40 } from "path";
+import { homedir as homedir13 } from "os";
 async function completionCommand(opts) {
   const shell = opts.shell ?? detectShell();
   let script;
@@ -41010,10 +41610,10 @@ async function completionCommand(opts) {
     process.exit(1);
   }
   if (opts.install) {
-    const dir = join39(homedir12(), ".config", "cc-claw", "completions");
+    const dir = join40(homedir13(), ".config", "cc-claw", "completions");
     mkdirSync17(dir, { recursive: true });
     const filename = shell === "zsh" ? "_cc-claw" : shell === "fish" ? "cc-claw.fish" : "cc-claw.bash";
-    const filepath = join39(dir, filename);
+    const filepath = join40(dir, filename);
     writeFileSync14(filepath, script, "utf-8");
     console.log(`\u2713 Completion script written to ${filepath}
 `);
@@ -41186,9 +41786,9 @@ __export(evolve_exports2, {
   evolveStatus: () => evolveStatus,
   evolveUndo: () => evolveUndo
 });
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 function ensureDb3() {
-  if (!existsSync61(DB_PATH)) {
+  if (!existsSync60(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -41662,10 +42262,10 @@ var init_optimize3 = __esm({
 
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync62, writeFileSync as writeFileSync15, readFileSync as readFileSync33, copyFileSync as copyFileSync5, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
+import { existsSync as existsSync61, writeFileSync as writeFileSync15, readFileSync as readFileSync34, copyFileSync as copyFileSync5, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
 import { execFileSync as execFileSync6 } from "child_process";
 import { createInterface as createInterface11 } from "readline";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 function divider2() {
   console.log(dim("\u2500".repeat(55)));
 }
@@ -41746,22 +42346,22 @@ async function setup() {
   console.log("");
   if (!DRY_RUN) {
     for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-      if (!existsSync62(dir)) mkdirSync18(dir, { recursive: true });
+      if (!existsSync61(dir)) mkdirSync18(dir, { recursive: true });
     }
   }
   const env = {};
-  const envSource = existsSync62(ENV_PATH) ? ENV_PATH : existsSync62(".env") ? ".env" : null;
+  const envSource = existsSync61(ENV_PATH) ? ENV_PATH : existsSync61(".env") ? ".env" : null;
   if (envSource) {
     console.log(yellow(`  Found existing config at ${envSource} \u2014 your values will be preserved`));
     console.log(yellow("  unless you enter new ones. Just press Enter to keep existing values.\n"));
-    const existing = readFileSync33(envSource, "utf-8");
+    const existing = readFileSync34(envSource, "utf-8");
     for (const line of existing.split("\n")) {
       const match = line.match(/^([^#=]+)=(.*)$/);
       if (match) env[match[1].trim()] = match[2].trim();
     }
   }
-  const cwdDb = join40(process.cwd(), "cc-claw.db");
-  if (existsSync62(cwdDb) && !existsSync62(DB_PATH)) {
+  const cwdDb = join41(process.cwd(), "cc-claw.db");
+  if (existsSync61(cwdDb) && !existsSync61(DB_PATH)) {
     const { size } = statSync12(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
     const migrate = await confirm("Copy database to ~/.cc-claw/? (preserves memories & history)", true);
@@ -42622,10 +43222,38 @@ skills.command("install <url>").description("Install a skill from GitHub").actio
   const { skillsInstall: skillsInstall2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
   await skillsInstall2(program.opts(), url);
 });
-var mcps = program.command("mcps").description("MCP server management");
-mcps.command("list").description("All registered MCP servers").action(async () => {
-  const { mcpsList: mcpsList2 } = await Promise.resolve().then(() => (init_mcps2(), mcps_exports2));
-  await mcpsList2(program.opts());
+var mcp = program.command("mcp").alias("mcps").description("MCP server management");
+mcp.command("list").description("List all registered MCP servers").action(async () => {
+  const { mcpList: mcpList2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpList2(program.opts());
+});
+mcp.command("add <name> <command> [args...]").description("Add a stdio MCP server").action(async (name, command, args) => {
+  const { mcpAdd: mcpAdd2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpAdd2(name, command, args, program.opts());
+});
+mcp.command("remove <name>").description("Remove an MCP server").action(async (name) => {
+  const { mcpRemove: mcpRemove2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpRemove2(name, program.opts());
+});
+mcp.command("enable <name>").description("Enable an MCP server").action(async (name) => {
+  const { mcpEnable: mcpEnable2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpEnable2(name, program.opts());
+});
+mcp.command("disable <name>").description("Disable an MCP server").action(async (name) => {
+  const { mcpDisable: mcpDisable2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpDisable2(name, program.opts());
+});
+mcp.command("import <source>").description("Import MCPs from another CLI (claude, gemini, codex, cursor)").action(async (source) => {
+  const { mcpImport: mcpImport2 } = await Promise.resolve().then(() => (init_import(), import_exports));
+  await mcpImport2(source, program.opts());
+});
+mcp.command("export").description("Export MCP registry to JSON").action(async () => {
+  const { mcpExport: mcpExport2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpExport2(program.opts());
+});
+mcp.command("health").description("Trigger health checks on all MCPs").action(async () => {
+  const { mcpHealth: mcpHealth2 } = await Promise.resolve().then(() => (init_mcp2(), mcp_exports2));
+  await mcpHealth2(program.opts());
 });
 var chat2 = program.command("chat").description("Chat with the AI");
 chat2.command("send <message>").description("Send a message and get a response").option("--backend <name>", "Override backend").option("--model <name>", "Override model").option("--thinking <level>", "Override thinking level").option("--cwd <path>", "Override working directory").option("--stream", "Stream response tokens as they arrive").action(async (message, opts) => {