@bike4mind/cli 0.2.37 → 0.2.38-docs-clawdbot-comparison-analysis.20242

package/dist/{chunk-XIB66EG7.js → chunk-XWMNGOD4.js}

@@ -4,7 +4,7 @@ import {
   getOpenWeatherKey,
   getSerperKey,
   getWolframAlphaKey
-} from "./chunk-NJQYWIDJ.js";
+} from "./chunk-G3PPBZQR.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -16,14 +16,14 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-5YLGNW2B.js";
+} from "./chunk-Q3TLK7O5.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-H7RVLAQD.js";
+} from "./chunk-VNZXDZRP.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -77,10 +77,11 @@ import {
   VideoModels,
   XAI_IMAGE_MODELS,
   b4mLLMTools,
+  getDataLakeTags,
   getMcpProviderMetadata,
   getViewById,
   resolveNavigationIntents
-} from "./chunk-EY65E4W4.js";
+} from "./chunk-DF2SGZ6Z.js";
 
 // src/utils/fileSearch.ts
 import * as fs from "fs";
@@ -1846,7 +1847,8 @@ ${options.context}` : this.getSystemPrompt()
             temperature,
             abortSignal: options.signal,
             tool_choice: this.context.toolChoice,
-            executeTools: false
+            executeTools: false,
+            thinking: this.context.thinking
           },
           async (texts, completionInfo) => {
             for (const text of texts) {
@@ -2146,34 +2148,20 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
     }
   }
   /**
-   * Build and append tool call/result messages for the conversation history
+   * Build and append tool call/result messages for the conversation history.
+   * Delegates to the backend's pushToolMessages so each provider formats
+   * messages according to its own API requirements.
    */
   appendToolMessages(messages, toolUse, observation, thinkingBlocks) {
     const params = this.parseToolArguments(toolUse.arguments);
-    const msgToolCallId = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    const assistantContent = [
-      ...thinkingBlocks,
-      {
-        type: "tool_use",
-        id: msgToolCallId,
-        name: toolUse.name,
-        input: params
-      }
-    ];
-    messages.push({
-      role: "assistant",
-      content: assistantContent
-    });
-    messages.push({
-      role: "user",
-      content: [
-        {
-          type: "tool_result",
-          tool_use_id: msgToolCallId,
-          content: observation
-        }
-      ]
-    });
+    const toolId = toolUse.id || `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const parameters = typeof toolUse.arguments === "string" ? toolUse.arguments : JSON.stringify(params);
+    this.context.llm.pushToolMessages(
+      messages,
+      { id: toolId, name: toolUse.name, parameters },
+      observation,
+      thinkingBlocks
+    );
   }
 };
 
@@ -8745,7 +8733,7 @@ var knowledgeBaseSearchTool = {
     toolFn: async (value) => {
       const params = value;
       const { query, tags, file_type, max_results = 5 } = params;
-      context.logger.log("\u{1F4DA} Knowledge Base Search: Starting search for query:", query);
+      context.logger.log("\u{1F4DA} Knowledge Base Search: userId:", context.userId, "query:", query, "tags:", tags);
       if (!context.db.fabfiles) {
         context.logger.error("\u274C Knowledge Base Search: fabfiles repository not available");
         return "Knowledge base search is not available at this time.";
@@ -8768,10 +8756,12 @@ var knowledgeBaseSearchTool = {
           // Search across fileName + tags + notes for better recall
           includeShared: true,
           // Include owned + explicitly shared + org-shared files
-          userGroups: context.user.groups || []
+          userGroups: context.user.groups || [],
           // Pass user's groups for org-level sharing
+          dataLakeTags: getDataLakeTags(context.user.tags || [])
+          // Include data lake files user has access to
         });
-        context.logger.log("\u{1F4DA} Knowledge Base Search: Found", searchResults.data.length, "results");
+        context.logger.log("\u{1F4DA} Knowledge Base Search: Found", searchResults.data.length, "of", searchResults.total, "results. Files:", searchResults.data.map((f) => f.fileName));
         return formatSearchResults(searchResults.data);
       } catch (error) {
         context.logger.error("\u274C Knowledge Base Search: Error during search:", error);
@@ -8791,7 +8781,7 @@ var knowledgeBaseSearchTool = {
           tags: {
             type: "array",
             items: { type: "string" },
-            description: 'Optional: filter results by tag names. Supports partial matching. For optimization docs, use tags like "opti:family:scheduling", "opti:QUBO", "opti:solver:highs", etc. Any matching tag qualifies the file.'
+            description: 'Optional: filter results by tag names. Supports partial matching. For optimization docs, use tags like "opti:family:scheduling", "opti:QUBO", "opti:solver:highs". For IonQ sales intelligence, use tags like "ionq:vertical:pharma", "ionq:competitor:ibm", "ionq:type:product-specs", "ionq:stage:discovery", "ionq:offering:forte". Any matching tag qualifies the file.'
           },
           file_type: {
             type: "string",
@@ -8840,7 +8830,7 @@ var knowledgeBaseRetrieveTool = {
           if (file) {
             files = [file];
           } else {
-            const searchResults = await context.db.fabfiles.search(context.userId, file_id, { tags: [], shared: false }, { page: 1, limit: 1 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [] });
+            const searchResults = await context.db.fabfiles.search(context.userId, file_id, { tags: [], shared: false }, { page: 1, limit: 1 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [], dataLakeTags: getDataLakeTags(context.user.tags || []) });
             files = searchResults.data;
           }
           if (files.length === 0) {
@@ -8848,7 +8838,7 @@ var knowledgeBaseRetrieveTool = {
           }
         }
         if (files.length === 0 && (tags?.length || query)) {
-          const searchResults = await context.db.fabfiles.search(context.userId, query || "", { tags: tags || [], shared: false }, { page: 1, limit: 5 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [] });
+          const searchResults = await context.db.fabfiles.search(context.userId, query || "", { tags: tags || [], shared: false }, { page: 1, limit: 5 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [], dataLakeTags: getDataLakeTags(context.user.tags || []) });
           files = searchResults.data;
           if (files.length === 0) {
             const searchDesc = [query && `query "${query}"`, tags?.length && `tags [${tags.join(", ")}]`].filter(Boolean).join(" and ");
@@ -8904,7 +8894,7 @@ Chunks: ${chunks.length} | Characters: ${charLabel}
           tags: {
             type: "array",
             items: { type: "string" },
-            description: 'Filter documents by tags. For optimization docs, use tags like "opti:family:scheduling", "opti:solver:highs", etc.'
+            description: 'Filter documents by tags. For optimization docs, use tags like "opti:family:scheduling", "opti:solver:highs". For IonQ sales intelligence, use tags like "ionq:vertical:pharma", "ionq:competitor:ibm", "ionq:type:product-specs", "ionq:offering:forte".'
           },
           query: {
             type: "string",
@@ -13280,232 +13270,64 @@ var generateMcpTools = async (mcpData) => {
   Logger.debug(`\u{1F527} generateMcpTools: Generated ${result.length} tool implementations for ${mcpData.serverName}`);
   return result;
 };
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/ServerSubagentOrchestrator.js
-var SUBAGENT_TIMEOUT_MS = 5 * 60 * 1e3;
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/CodeReviewAgent.js
-var CodeReviewAgent = (config) => ({
-  name: "code_review",
-  description: "Code review specialist for analyzing code quality, bugs, and improvements",
-  model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET_BEDROCK,
-  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
-  deniedTools: ["image_generation", "edit_image", "delegate_to_agent", ...config?.extraDeniedTools ?? []],
-  allowedTools: config?.extraAllowedTools,
-  systemPrompt: `You are a code review specialist. Your job is to analyze code for quality, correctness, security, and maintainability.
-
-## Focus Areas
-- Bugs, logic errors, and edge cases
-- Security vulnerabilities (injection, auth issues, data exposure)
-- Code quality and readability
-- Performance concerns
-- Adherence to project patterns and conventions
-
-## Review Process
-1. Understand the context and intent of the code changes
-2. Check for bugs, logic errors, and unhandled edge cases
-3. Identify security vulnerabilities and data handling issues
-4. Evaluate code clarity, naming, and structure
-5. Look for performance problems or unnecessary complexity
-
-## Output Format
-Provide actionable feedback:
-
-### Critical Issues
-- Bugs, security vulnerabilities, or correctness problems that must be fixed
-
-### Suggestions
-- Code quality improvements with rationale
-
-### Positive Observations
-- Well-implemented patterns worth noting (optional)
-
-Focus on actionable, specific feedback referencing exact code locations. Your review will be used by the main agent.`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/ProjectManagerAgent.js
-var ProjectManagerAgent = (config) => ({
-  name: "project_manager",
-  description: "Project management via Jira and Confluence (create issues, search, update status, manage attachments, write docs). ALWAYS delegate Jira/Confluence requests to this agent \u2014 you do not have direct access to these tools",
-  model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET_BEDROCK,
-  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
-  allowedTools: [...config?.extraAllowedTools ?? []],
-  deniedTools: [...config?.extraDeniedTools ?? []],
-  exclusiveMcpServers: ["atlassian"],
-  systemPrompt: `You are a project management specialist with access to Jira and Confluence. Your job is to help manage projects, issues, documentation, and team workflows.
-
-## Capabilities
-
-### Jira
-- Search for issues using JQL
-- Create, update, and transition issues
-- Add comments and manage watchers
-- List projects and issue types
-- List, upload, download, and delete attachments on issues
-
-### Confluence
-- Search for documentation
-- Create and update pages
-- Browse spaces and page hierarchies
-- List, upload, download, and delete attachments on pages
-
-### Account & Identity
-- Check connected Jira account using \`atlassian__jira_get_current_user\`
-- Check connected Confluence account using \`atlassian__confluence_get_current_user\`
-- Look up users by name or email using \`atlassian__jira_search_users\`
-
-## Best Practices
-1. When searching Jira, use precise JQL queries (e.g., \`project = PROJ AND status = "In Progress"\`)
-2. When creating issues, always check available issue types first with \`atlassian__jira_list_issue_types\`
-3. When updating issue status, use \`atlassian__jira_update_issue_transition\` with the target status name
-4. When creating Confluence pages, use the user's personal space if no space is specified
-5. Always confirm destructive operations (delete) with the user before proceeding
-6. When asked about the connected Atlassian account call BOTH \`atlassian__jira_get_current_user\` and \`atlassian__confluence_get_current_user\` to show the full picture. Present results clearly labeled by product, and note if either service is not connected. NEVER say you don't have access to account information \u2014 you DO have these tools.
-7. When asked specifically about "Jira account" or "Confluence account" only, use the respective tool alone.
-8. When asked about attachments, ALWAYS use the attachment tools \u2014 never guess or fabricate attachment details. For uploading files shared in Slack, pass the \`fabFileId\` from the message context to \`atlassian__jira_upload_attachment\` or \`atlassian__confluence_upload_attachment\`.
-
-## Output Format
-Provide a clear summary of actions taken:
-1. What was done (created, updated, searched, etc.)
-2. Links or keys to relevant items (e.g., PROJ-123)
-3. Any issues or warnings encountered
-
-Be precise with issue keys and project names. Your results will be used by the main agent.`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/GithubManagerAgent.js
-var GithubManagerAgent = (config) => ({
-  name: "github_manager",
-  description: "GitHub operations (issues, pull requests, code search, branches, workflows, reviews). ALWAYS delegate GitHub requests to this agent \u2014 you do not have direct access to these tools",
-  model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET_BEDROCK,
-  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
-  defaultThoroughness: config?.defaultThoroughness ?? "medium",
-  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
-  allowedTools: [...config?.extraAllowedTools ?? []],
-  deniedTools: [...config?.extraDeniedTools ?? []],
-  exclusiveMcpServers: ["github"],
-  systemPrompt: `You are a GitHub specialist with access to GitHub's API. Your job is to help manage repositories, issues, pull requests, code search, branches, and CI/CD workflows.
-
-## First Step: ALWAYS Resolve Repository Context Automatically
-Before doing ANYTHING else, call the \`github__current_user\` tool. The response includes:
-- **selected_repositories**: The list of repositories the user has enabled for AI access (in \`owner/repo\` format)
-- **user**: The authenticated user's profile (login, name, etc.)
-
-### Repository Resolution Rules (CRITICAL)
-You MUST use the selected_repositories list to automatically resolve the owner and repo. NEVER ask the user for the org, owner, or full repository path. Instead:
-
-1. **Exact match**: If the user says a repo name that exactly matches a repo name in selected_repositories, use it immediately.
-2. **Partial/fuzzy match**: If the user provides a partial name, match it against any repo in selected_repositories whose name contains that term (e.g., if the user says "lumina" and selected_repositories contains \`SomeOrg/lumina5\`, use that).
-3. **Single repo shortcut**: If only one repository is selected, ALWAYS default to it \u2014 no questions asked.
-4. **Multiple matches**: Only if multiple selected repos match the user's term AND you truly cannot disambiguate, list the matching repos and ask which one. Do NOT list repos that don't match.
-5. **No match**: If nothing in selected_repositories matches, tell the user which repos are available and ask them to clarify.
-
-**NEVER ask the user to "paste the GitHub URL" or provide the org/owner name.** You already have this information from \`github__current_user\`. The owner and repo are embedded in the \`owner/repo\` format of each selected repository entry.
-
-### Defaults for Ambiguous Requests
-- **Timezone**: Default to UTC unless the user specifies otherwise.
-- **PR/Issue state**: Default to \`open\` unless the user specifies otherwise.
-- **Scope**: All matching repos unless the user narrows it down.
-- **When in doubt, act**: Prefer making reasonable assumptions and proceeding over asking clarifying questions. You can always note your assumptions in the response.
-
-## Capabilities
-
-### Issues
-- Create, update, and search issues
-- Add comments and manage labels
-- List and filter issues by state, assignee, labels
-
-### Pull Requests
-- Create, update, and list pull requests
-- Get PR diffs, files changed, and review status
-- Merge pull requests and manage reviews
-- Request reviews from team members
-
-### Code & Repository
-- Search code across repositories
-- Get file contents and commit history
-- Create and list branches and tags
-- Fork repositories
-
-### CI/CD & Workflows
-- List and monitor workflow runs
-- Get job logs for debugging failures
-- Re-run failed jobs or entire workflows
-- Download workflow artifacts
-
-### Notifications
-- List and manage GitHub notifications
-- Mark notifications as read/done
-
-## Best Practices
-1. When searching issues or PRs, use GitHub search syntax (e.g., \`is:open label:bug assignee:username\`)
-2. When creating PRs, always include a clear title and description
-3. When reviewing PR changes, use \`get_pull_request_diff\` or \`get_pull_request_files\` for context
-4. For CI/CD debugging, use \`get_job_logs\` with \`failed_only=true\` to focus on failures
-5. Always include links to issues/PRs in your responses (e.g., owner/repo#123)
-
-## Output Format
-Provide a clear summary of actions taken:
-1. What was done (created, searched, merged, etc.)
-2. Always provide links to relevant items (e.g., owner/repo#123, PR URLs)
-3. Any issues or warnings encountered
-
-Be precise with repository names, issue numbers, and PR numbers. Your results will be used by the main agent.
-
-## Write Operations & Confirmation
-Write tools (create issue, update issue, comment, merge PR, etc.) have a built-in confirmation system. When you call them, they return a preview with Confirm/Cancel buttons \u2014 the user clicks to execute. **NEVER ask the user for text confirmation before calling a write tool.** Just call the tool immediately. The tool handles confirmation automatically.
-
-**CRITICAL: When a write tool returns \`"confirmation_required": true\`, the action has NOT been executed yet.** It is a preview awaiting user confirmation via buttons. Your summary MUST say the action is **awaiting confirmation**, NOT that it was completed. Example:
-- \u2705 "A comment preview is ready on PR #123. Click Confirm below to post it."
-- \u274C "Done! The comment has been posted on PR #123." (WRONG \u2014 it hasn't been posted yet)`
-});
-
-// ../../b4m-core/packages/services/dist/src/llm/agents/ServerAgentStore.js
-var ServerAgentStore = class {
-  constructor() {
-    const builtInAgents = [
-      // For now disable explore and plan agents as it is much faster if the parent llm handles this.
-      // ExploreAgent(),
-      // PlanAgent(),
-      CodeReviewAgent(),
-      ProjectManagerAgent(),
-      GithubManagerAgent()
-    ];
-    this.agents = new Map(builtInAgents.map((a) => [a.name, a]));
-  }
-  getAgent(name) {
-    return this.agents.get(name);
-  }
-  getAllAgents() {
-    return Array.from(this.agents.values());
-  }
-  getAgentNames() {
-    return Array.from(this.agents.keys());
-  }
-  hasAgent(name) {
-    return this.agents.has(name);
-  }
-  /**
-   * Get the deduplicated list of MCP server names that are exclusive to agents.
-   * Derived from each agent's `exclusiveMcpServers` field.
-   */
-  getExclusiveMcpServers() {
-    const servers = /* @__PURE__ */ new Set();
-    for (const agent of this.agents.values()) {
-      if (agent.exclusiveMcpServers) {
-        for (const s of agent.exclusiveMcpServers) {
-          servers.add(s);
+var generateMcpToolsFromCache = (serverName, cachedTools, callTool) => {
+  const normalizedServerName = serverName.toLowerCase();
+  const result = cachedTools.map((item) => {
+    const { name: originalToolName, ...rest } = item;
+    const namespacedToolName = `${normalizedServerName}__${originalToolName}`;
+    const providerMetadata = getMcpProviderMetadata(normalizedServerName);
+    const fallbackDescription = providerMetadata?.defaultToolDescriptions?.[originalToolName] ?? "";
+    const parameters = normalizeToolParameters(rest);
+    const optionTools = {
+      toolFn: async (args) => {
+        Logger.debug(`Calling ${originalToolName} tool via ${serverName}`, args);
+        try {
+          const toolResult = await callTool(originalToolName, args);
+          const contentBlocks = toolResult?.content;
+          if (Array.isArray(contentBlocks) && contentBlocks.length > 0) {
+            const normalized = contentBlocks.map((entry) => {
+              if (entry && typeof entry === "object" && "text" in entry) {
+                return entry.text;
+              }
+              return JSON.stringify(entry);
+            }).join("\n");
+            Logger.debug(`[Tool Result] ${originalToolName}:`, normalized);
+            return normalized;
+          }
+          const serialized = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
+          Logger.debug(`[Tool Result] Unexpected format for ${originalToolName}, returning serialized output`);
+          return serialized;
+        } catch (error) {
+          if (normalizedServerName === "atlassian") {
+            const errorName = error instanceof Error ? error.name : "";
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isTokenError = errorName === "AtlassianReconnectRequiredError" || errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("unauthorized") || errorMessage.includes("expired");
+            if (isTokenError) {
+              console.warn(`Atlassian token may be expired for tool ${originalToolName}, error:`, errorMessage);
+              return ATLASSIAN_RECONNECT_MESSAGE;
+            }
+          }
+          throw error;
         }
+      },
+      toolSchema: {
+        name: namespacedToolName,
+        description: rest.description || fallbackDescription,
+        parameters
       }
-    }
-    return Array.from(servers);
-  }
+    };
+    return {
+      name: namespacedToolName,
+      ...optionTools,
+      _isMcpTool: true
+    };
+  });
+  Logger.debug(`\u{1F527} generateMcpToolsFromCache: Generated ${result.length} tool implementations for ${serverName} (from cache)`);
+  return result;
 };
-var serverAgentStore = new ServerAgentStore();
+
+// ../../b4m-core/packages/services/dist/src/llm/agents/ServerSubagentOrchestrator.js
+var SUBAGENT_TIMEOUT_MS = 5 * 60 * 1e3;
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
 import throttle2 from "lodash/throttle.js";
@@ -15238,6 +15060,12 @@ function substituteArguments(template, args) {
   return result;
 }
 
+// src/utils/mcpAdapter.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join3, dirname as dirname2 } from "path";
+
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
@@ -15251,22 +15079,17 @@ var MCPClient = class {
   customCommand;
   customArgs;
   suppressStderr;
+  onStderrLine;
   tools = [];
   serverName;
-  constructor({ envVariables, name, selectedRepositories, command, args, suppressStderr = false }) {
+  constructor({ envVariables, name, command, args, suppressStderr = false, onStderrLine }) {
     this.mcp = new Client2({ name: "mcp-client-cli", version: "1.0.0" });
     this.envVariables = [...envVariables];
     this.serverName = name;
     this.customCommand = command;
     this.customArgs = args;
     this.suppressStderr = suppressStderr;
-    if (name === "github" && selectedRepositories) {
-      const reposJson = JSON.stringify(selectedRepositories);
-      this.envVariables.push({
-        key: "SELECTED_REPOSITORIES",
-        value: reposJson
-      });
-    }
+    this.onStderrLine = onStderrLine;
   }
   async connectToServer() {
     try {
@@ -15305,6 +15128,7 @@ var MCPClient = class {
         args = [serverScriptPath];
         console.log(`[MCP] Using server: ${this.serverName} at ${serverScriptPath}`);
       }
+      const stderrMode = this.suppressStderr ? "ignore" : this.onStderrLine ? "pipe" : void 0;
       const transportConfig = {
         command,
         args,
@@ -15312,14 +15136,16 @@ var MCPClient = class {
           ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
           ...envVarsObject
         },
-        // Suppress stderr in CLI context to prevent MCP server startup logs from breaking layout
-        ...this.suppressStderr && { stderr: "ignore" }
+        ...stderrMode && { stderr: stderrMode }
       };
       this.transport = new StdioClientTransport(transportConfig);
       this.transport.onerror = (error) => {
         console.error(`[MCP] Transport error for ${this.serverName}:`, error);
       };
       await this.mcp.connect(this.transport);
+      if (this.onStderrLine && this.transport.stderr) {
+        this.readStderr(this.transport.stderr);
+      }
       await new Promise((resolve3) => setTimeout(resolve3, 100));
       const toolsResult = await this.mcp.listTools();
       this.tools = toolsResult.tools.map((tool) => {
@@ -15341,6 +15167,30 @@ var MCPClient = class {
       throw e;
     }
   }
+  /**
+   * Read lines from the child process stderr stream and dispatch to the callback.
+   * Uses Node.js stream events; errors are silently caught (stream closes on disconnect).
+   */
+  readStderr(stream) {
+    let buffer = "";
+    stream.setEncoding("utf8");
+    stream.on("data", (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed)
+          this.onStderrLine?.(trimmed);
+      }
+    });
+    stream.on("end", () => {
+      if (buffer.trim())
+        this.onStderrLine?.(buffer.trim());
+    });
+    stream.on("error", () => {
+    });
+  }
   async callTool(toolName, toolArgs) {
     try {
       const args = toolArgs && typeof toolArgs === "object" ? toolArgs : void 0;
@@ -15376,14 +15226,30 @@ var MCPClient = class {
 };
 
 // src/utils/mcpAdapter.ts
+var CACHE_VERSION = 1;
+var CACHE_FILE = join3(homedir4(), ".bike4mind", "mcp-schema-cache.json");
 var McpManager = class {
   constructor(config) {
     this.servers = /* @__PURE__ */ new Map();
     this.connectionStates = /* @__PURE__ */ new Map();
+    /** Per-server deferred promise resolved once the background connection is ready */
+    this.connectionReady = /* @__PURE__ */ new Map();
+    /**
+     * Serializes background cache saves so concurrent writes don't race.
+     * JSON.stringify is evaluated at run-time, always capturing the latest cache state.
+     */
+    this.backgroundSaveQueue = Promise.resolve();
     this.config = config;
   }
+  /** Subscribe to background connection state changes for live UI updates. */
+  setOnStateChange(callback) {
+    this.onStateChange = callback;
+  }
   /**
-   * Initialize and connect to all enabled MCP servers
+   * Initialize MCP servers with schema caching.
+   *
+   * - Cache hit  → tools registered immediately from cache; server connected in background
+   * - Cache miss → server connected eagerly (blocks); result cached for next run
    */
   async initialize() {
     const enabledServers = this.config.mcpServers.filter((s) => s.enabled);
@@ -15392,47 +15258,96 @@ var McpManager = class {
       return;
     }
     logger.debug(`\u{1F4E1} Initializing ${enabledServers.length} MCP server(s)...`);
-    const results = await Promise.allSettled(enabledServers.map((serverConfig) => this.connectServer(serverConfig)));
-    const successful = results.filter((r) => r.status === "fulfilled").length;
-    const failed = results.filter((r) => r.status === "rejected").length;
-    if (successful > 0) {
-      logger.debug(`\u2705 Connected to ${successful} MCP server(s)`);
+    const cache = await this.loadCache();
+    const configuredNames = new Set(this.config.mcpServers.map((s) => s.name));
+    let pruned = false;
+    for (const name of Object.keys(cache.servers)) {
+      if (!configuredNames.has(name)) {
+        delete cache.servers[name];
+        pruned = true;
+      }
+    }
+    const eagerConnections = [];
+    for (const serverConfig of enabledServers) {
+      const configHash = this.hashServerConfig(serverConfig);
+      const cachedEntry = cache.servers[serverConfig.name];
+      if (cachedEntry && cachedEntry.configHash === configHash) {
+        this.registerFromCache(serverConfig, cachedEntry);
+        this.connectBackground(serverConfig, cache);
+      } else {
+        eagerConnections.push(this.connectEager(serverConfig, cache));
+      }
+    }
+    if (eagerConnections.length > 0) {
+      await Promise.allSettled(eagerConnections);
+      await this.saveCache(cache);
+    } else if (pruned) {
+      await this.saveCache(cache);
     }
-    if (failed > 0) {
-      logger.debug(`\u26A0\uFE0F  Failed to connect to ${failed} MCP server(s)`);
+    const connected = [...this.connectionStates.values()].filter((s) => s === "connected").length;
+    const pending = [...this.connectionStates.values()].filter((s) => s === "connecting").length;
+    if (connected > 0 || pending > 0) {
+      logger.debug(`\u2705 ${connected} MCP server(s) ready${pending > 0 ? `, ${pending} connecting in background` : ""}`);
     }
   }
+  // ─── Private: connection strategies ────────────────────────────────────────
   /**
-   * Connect to a single MCP server
+   * Register tool stubs from cache immediately. callTool lazily awaits the
+   * background connection before forwarding to the real client.
    */
-  async connectServer(serverConfig) {
+  registerFromCache(serverConfig, entry) {
     this.connectionStates.set(serverConfig.name, "connecting");
+    let resolveReady;
+    let rejectReady;
+    const promise = new Promise((res, rej) => {
+      resolveReady = res;
+      rejectReady = rej;
+    });
+    promise.catch(() => {
+    });
+    this.connectionReady.set(serverConfig.name, { resolve: resolveReady, reject: rejectReady, promise });
+    const callTool = async (name, args) => {
+      await promise;
+      return this.servers.get(serverConfig.name).client.callTool(name, args);
+    };
+    const tools = generateMcpToolsFromCache(serverConfig.name, entry.tools, callTool);
+    this.servers.set(serverConfig.name, { name: serverConfig.name, client: null, tools });
+    logger.debug(`\u{1F4CB} ${entry.tools.length} tools for ${serverConfig.name} loaded from cache`);
+  }
+  /**
+   * Spawn the server process in the background. Resolves the per-server
+   * deferred promise when ready so pending callTool invocations can proceed.
+   */
+  connectBackground(serverConfig, cache) {
+    this.doConnect(serverConfig).then(({ client }) => {
+      const instance = this.servers.get(serverConfig.name);
+      if (instance) {
+        instance.client = client;
+      }
+      this.connectionStates.set(serverConfig.name, "connected");
+      this.connectionReady.get(serverConfig.name)?.resolve();
+      this.onStateChange?.();
+      logger.debug(`\u2705 Background connection to ${serverConfig.name} established`);
+      this.writeCacheEntry(cache, serverConfig, client.tools);
+      this.scheduleBackgroundSave(cache);
+    }).catch((err) => {
+      this.connectionStates.set(serverConfig.name, "failed");
+      this.connectionReady.get(serverConfig.name)?.reject(err);
+      this.onStateChange?.();
+      logger.debug(`\u274C Background connection to ${serverConfig.name} failed: ${err}`);
+    });
+  }
+  /**
+   * Connect eagerly (blocks initialize). Populates servers map and updates cache.
+   */
+  async connectEager(serverConfig, cache) {
+    this.connectionStates.set(serverConfig.name, "connecting");
+    logger.debug(`\u{1F504} Connecting to ${serverConfig.name}...`);
     try {
-      logger.debug(`\u{1F504} Connecting to ${serverConfig.name}...`);
-      const envVariables = Object.entries(serverConfig.env).map(([key, value]) => ({
-        key,
-        value
-      }));
-      const client = new MCPClient({
-        envVariables,
-        name: serverConfig.name,
-        command: serverConfig.command,
-        args: serverConfig.args,
-        suppressStderr: true
-      });
-      await client.connectToServer();
-      const mcpData = {
-        serverName: serverConfig.name,
-        getTools: async () => client.tools,
-        callTool: async (name, args) => client.callTool(name, args)
-      };
-      const tools = await generateMcpTools(mcpData);
-      this.servers.set(serverConfig.name, {
-        name: serverConfig.name,
-        client,
-        tools
-      });
+      const { client, tools } = await this.doConnect(serverConfig);
+      this.servers.set(serverConfig.name, { name: serverConfig.name, client, tools });
       this.connectionStates.set(serverConfig.name, "connected");
+      this.writeCacheEntry(cache, serverConfig, client.tools);
       logger.debug(`\u2705 Connected to ${serverConfig.name} (${tools.length} tools)`);
     } catch (error) {
       this.connectionStates.set(serverConfig.name, "failed");
@@ -15440,8 +15355,82 @@ var McpManager = class {
     }
   }
   /**
-   * Get all tools from all connected MCP servers
+   * Shared: spawn and handshake with an MCP server process.
+   */
+  async doConnect(serverConfig) {
+    const envVariables = Object.entries(serverConfig.env).map(([key, value]) => ({ key, value }));
+    const client = new MCPClient({
+      envVariables,
+      name: serverConfig.name,
+      command: serverConfig.command,
+      args: serverConfig.args,
+      suppressStderr: true
+    });
+    await client.connectToServer();
+    const mcpData = {
+      serverName: serverConfig.name,
+      getTools: async () => client.tools,
+      // any: generateMcpTools accepts a loose duck-type; MCPClient.callTool return type
+      // doesn't match the internal interface exactly, but runtime behaviour is correct.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      callTool: async (name, args) => client.callTool(name, args)
+    };
+    const tools = await generateMcpTools(mcpData);
+    return { client, tools };
+  }
+  // ─── Private: cache helpers ──────────────────────────────────────────────────
+  async loadCache() {
+    try {
+      const raw = await readFile2(CACHE_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version === CACHE_VERSION) {
+        return parsed;
+      }
+    } catch {
+    }
+    return { version: CACHE_VERSION, servers: {} };
+  }
+  async saveCache(cache) {
+    try {
+      await mkdir(dirname2(CACHE_FILE), { recursive: true });
+      await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    } catch (error) {
+      logger.debug(`\u26A0\uFE0F  Failed to save MCP schema cache: ${error}`);
+    }
+  }
+  /**
+   * Enqueue a background cache save. Saves are serialized so concurrent background
+   * connections can't interleave writes and lose each other's entries. JSON.stringify
+   * is evaluated when the queued write runs, so it always captures the latest state.
    */
+  scheduleBackgroundSave(cache) {
+    this.backgroundSaveQueue = this.backgroundSaveQueue.then(() => this.saveCache(cache)).catch(() => {
+    });
+  }
+  writeCacheEntry(cache, serverConfig, rawTools) {
+    cache.servers[serverConfig.name] = {
+      configHash: this.hashServerConfig(serverConfig),
+      tools: rawTools.map((t) => {
+        const tool = t;
+        return {
+          name: t.name,
+          description: tool.description,
+          // Normalize both MCP SDK casing variants to input_schema for storage
+          input_schema: tool.inputSchema ?? tool.input_schema
+        };
+      }),
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  hashServerConfig(serverConfig) {
+    const key = JSON.stringify({
+      command: serverConfig.command,
+      args: serverConfig.args,
+      env: serverConfig.env
+    });
+    return createHash("sha256").update(key).digest("hex").slice(0, 16);
+  }
+  // ─── Public API ───────────────────────────────────────────────────────────────
   getTools() {
     const allTools = [];
     for (const server of this.servers.values()) {
@@ -15449,24 +15438,17 @@ var McpManager = class {
     }
     return allTools;
   }
-  /**
-   * Get tool count by server
-   */
   getToolCount() {
     return Array.from(this.servers.values()).map((server) => ({
       serverName: server.name,
       count: server.tools.length
     }));
   }
-  /**
-   * Disconnect from all MCP servers
-   */
   async disconnect() {
-    if (this.servers.size === 0) {
-      return;
-    }
+    if (this.servers.size === 0) return;
     logger.debug(`\u{1F50C} Disconnecting from ${this.servers.size} MCP server(s)...`);
     const disconnectPromises = Array.from(this.servers.values()).map(async (server) => {
+      if (!server.client) return;
       try {
         await server.client.disconnect();
         logger.debug(`\u2705 Disconnected from ${server.name}`);
@@ -15476,27 +15458,17 @@ var McpManager = class {
     });
     await Promise.allSettled(disconnectPromises);
     this.servers.clear();
+    this.connectionReady.clear();
   }
-  /**
-   * Check if any MCP servers are connected
-   */
   hasServers() {
     return this.servers.size > 0;
   }
-  /**
-   * Get list of connected server names
-   */
   getServerNames() {
     return Array.from(this.servers.keys());
   }
-  /**
-   * Get connection state for a server
-   */
   getConnectionState(serverName) {
     const serverConfig = this.config.mcpServers.find((s) => s.name === serverName);
-    if (!serverConfig?.enabled) {
-      return "disabled";
-    }
+    if (!serverConfig?.enabled) return "disabled";
     return this.connectionStates.get(serverName) || "connecting";
   }
 };
@@ -15904,6 +15876,9 @@ var ServerLlmBackend = class {
       });
     });
   }
+  pushToolMessages(_messages, _tool, _result) {
+    throw new Error("ServerLlmBackend does not support pushToolMessages \u2014 tools are executed server-side");
+  }
   /**
    * Get available models from server
    * Fetches from /api/models and filters for CLI-compatible models
@@ -16123,6 +16098,9 @@ var WebSocketLlmBackend = class {
       });
     });
   }
+  pushToolMessages(_messages, _tool, _result) {
+    throw new Error("WebSocketLlmBackend does not support pushToolMessages \u2014 tools are executed server-side");
+  }
   /**
    * Get available models from server (REST call, not streaming).
    * Delegates to ApiClient -- same as ServerLlmBackend.
@@ -16163,6 +16141,9 @@ var WebSocketLlmBackend = class {
 };
 
 // src/ws/WebSocketConnectionManager.ts
+import WsWebSocket from "ws";
+var useWsPolyfill = typeof globalThis.WebSocket === "undefined";
+var WS = useWsPolyfill ? WsWebSocket : globalThis.WebSocket;
 var WebSocketConnectionManager = class {
   constructor(wsUrl, getToken) {
     this.ws = null;
@@ -16170,6 +16151,7 @@ var WebSocketConnectionManager = class {
     this.reconnectAttempts = 0;
     this.maxReconnectDelay = 3e4;
     this.handlers = /* @__PURE__ */ new Map();
+    this.actionHandlers = /* @__PURE__ */ new Map();
     this.disconnectHandlers = /* @__PURE__ */ new Set();
     this.reconnectTimer = null;
     this.connected = false;
@@ -16192,7 +16174,13 @@ var WebSocketConnectionManager = class {
     }
     return new Promise((resolve3, reject) => {
       logger.debug(`[WS] Connecting to ${this.wsUrl}...`);
-      this.ws = new WebSocket(this.wsUrl, [`access_token.${token}`]);
+      if (useWsPolyfill) {
+        this.ws = new WsWebSocket(this.wsUrl, {
+          headers: { "Sec-WebSocket-Protocol": `access_token.${token}` }
+        });
+      } else {
+        this.ws = new WS(this.wsUrl, [`access_token.${token}`]);
+      }
       this.ws.onopen = () => {
         logger.debug("[WS] Connected");
         this.connected = true;
@@ -16209,7 +16197,12 @@ var WebSocketConnectionManager = class {
           if (requestId && this.handlers.has(requestId)) {
             this.handlers.get(requestId)(message);
           } else {
-            logger.debug(`[WS] Unhandled message: ${message.action || "unknown"}`);
+            const action = message.action;
+            if (action && this.actionHandlers.has(action)) {
+              this.actionHandlers.get(action)(message);
+            } else {
+              logger.debug(`[WS] Unhandled message: ${action || "unknown"}`);
+            }
           }
         } catch (err) {
           logger.debug(`[WS] Failed to parse message: ${err}`);
@@ -16224,11 +16217,13 @@ var WebSocketConnectionManager = class {
         }
       };
       this.ws.onerror = (err) => {
-        logger.debug(`[WS] Error: ${err}`);
+        const underlying = err.error;
+        const detail = underlying?.message || String(err);
+        logger.debug(`[WS] Error: ${detail}`);
         if (this.connecting) {
           this.connecting = false;
           this.connected = false;
-          reject(new Error("WebSocket connection failed"));
+          reject(new Error(`WebSocket connection failed: ${detail}`));
         }
       };
     });
@@ -16241,7 +16236,7 @@ var WebSocketConnectionManager = class {
    * Send a JSON message over the WebSocket connection.
    */
   send(data) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+    if (!this.ws || this.ws.readyState !== WS.OPEN) {
       throw new Error("WebSocket is not connected");
     }
     const payload = JSON.stringify(data);
@@ -16264,6 +16259,19 @@ var WebSocketConnectionManager = class {
   offRequest(requestId) {
     this.handlers.delete(requestId);
   }
+  /**
+   * Register a handler for messages matching a specific action type.
+   * Used for server-pushed commands like keep_command.
+   */
+  onAction(action, handler) {
+    this.actionHandlers.set(action, handler);
+  }
+  /**
+   * Remove a handler for a specific action type.
+   */
+  offAction(action) {
+    this.actionHandlers.delete(action);
+  }
   /**
    * Register a handler that fires when the connection drops.
    */
@@ -16287,13 +16295,14 @@ var WebSocketConnectionManager = class {
       this.ws = null;
     }
     this.handlers.clear();
+    this.actionHandlers.clear();
     this.disconnectHandlers.clear();
   }
   startHeartbeat() {
     this.stopHeartbeat();
     this.heartbeatInterval = setInterval(
       () => {
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        if (this.ws && this.ws.readyState === WS.OPEN) {
           this.ws.send(JSON.stringify({ action: "heartbeat" }));
           logger.debug("[WS] Heartbeat sent");
         }