feat: MCP tools dynamic injection into agent TOOL_DEFINITIONS

- agent.ts: Initialize MCP servers from .claw/settings.json config at start of agent loop
- agent.ts: Merge discovered MCP tools with static TOOL_DEFINITIONS for LLM requests
- agent.ts: Convert MCP tool format (name/description/input_schema) to OpenAI function calling format
- executor.ts: Route mcp__* prefixed tool calls through McpServerManager.callTool()
- Non-fatal: MCP init failure doesn't break agent, continues with static tools only
- Matches original claw-code behavior: dynamic tool list with MCP server discovery

server/runtime/agent.ts

@@ -5,7 +5,7 @@
 
 import { ENV } from "../_core/env";
 import { buildSystemPrompt, TOOL_DEFINITIONS } from "./system-prompt";
-import { executeTool, getPlanMode, runPreToolHooks, runPostToolHooks } from "../tools/executor";
+import { executeTool, getPlanMode, runPreToolHooks, runPostToolHooks, initializeMcpFromConfig, getMcpManager } from "../tools/executor";
 // Compact is manual-only via /compact command (matches original claw-code)
 // import { shouldCompact, compactSession, dbMessagesToSession, DEFAULT_COMPACTION_CONFIG } from "./compact";
 import { UsageTracker, pricingForModel, defaultSonnetTierPricing, estimateCostUsdWithPricing, totalCostUsd, formatUsd, summaryLinesForModel } from "./usage";
@@ -259,6 +259,43 @@ export async function runAgentLoop(
   const assistantMessages: AgentMessage[] = [];
   const toolResultMessages: AgentMessage[] = [];
 
+  // ─── MCP Tools Dynamic Injection (matches original claw-code) ──────────
+  // Initialize MCP servers from config and merge discovered tools with static TOOL_DEFINITIONS.
+  // This is how the original claw-code dynamically builds the tool list:
+  //   1. Load MCP server configs from .claw/settings.json
+  //   2. Connect to each server via stdio JSON-RPC
+  //   3. Call tools/list to discover available tools
+  //   4. Prefix tool names as mcp__servername__toolname
+  //   5. Merge with static tool definitions
+  let allTools = [...TOOL_DEFINITIONS];
+  try {
+    const mcpTools = await initializeMcpFromConfig(workDir);
+    if (mcpTools.length > 0) {
+      const mcpManager = getMcpManager();
+      if (mcpManager) {
+        const mcpDefs = mcpManager.getToolDefinitions();
+        // Convert MCP tool format to OpenAI function calling format
+        const mcpToolDefs = mcpDefs.map((t) => ({
+          type: "function" as const,
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema || { type: "object", properties: {} },
+          },
+        }));
+        allTools = [...TOOL_DEFINITIONS, ...mcpToolDefs];
+        console.log(`[agent] MCP tools injected: ${mcpDefs.map((t) => t.name).join(", ")}`);
+        sendSSE(res, "status", {
+          status: "mcp_ready",
+          message: `MCP tools loaded: ${mcpDefs.length} tools from ${mcpManager.getConnectedServers().length} servers`,
+        });
+      }
+    }
+  } catch (err: any) {
+    console.error(`[agent] MCP initialization error (non-fatal):`, err.message);
+    // MCP init failure is non-fatal — agent continues with static tools only
+  }
+
   sendSSE(res, "status", { status: "thinking", message: "Processing your request..." });
 
   while (iterations < MAX_ITERATIONS) {
@@ -279,7 +316,7 @@ export async function runAgentLoop(
         if (m.name) msg.name = m.name;
         return msg;
       }),
-      tools: TOOL_DEFINITIONS,
+      tools: allTools,
       tool_choice: "auto",
       max_tokens: cfg.maxTokens,
       temperature: cfg.temperature,

server/tools/executor.ts

@@ -557,6 +557,23 @@ export async function executeTool(
       case "RemoteTrigger": output = await executeRemoteTrigger(args); break;
       case "SyntheticOutput": output = executeSyntheticOutput(args); break;
       default:
+        // ─── Dynamic MCP tool routing ─────────────────────────────────
+        // When MCP tools are injected into the LLM's tool list, the LLM
+        // will call them by their qualified name (mcp__servername__toolname).
+        // Route these calls through McpServerManager.callTool().
+        if (toolName.startsWith("mcp__") && mcpManager) {
+          try {
+            const result = await mcpManager.callTool(toolName, args);
+            const textParts = result.content
+              .filter((c: any) => c.type === "text" && c.text)
+              .map((c: any) => c.text);
+            output = textParts.join("\n") || JSON.stringify(result.content);
+          } catch (err: any) {
+            output = `MCP tool error: ${err.message}`;
+            return { output, isError: true, durationMs: Date.now() - start };
+          }
+          break;
+        }
         output = `Unknown tool: ${toolName}`;
         return { output, isError: true, durationMs: Date.now() - start };
     }