@nxuss/lemma 0.7.0 → 0.7.2

package/dist/esm/mcp/index.js

@@ -1,30 +1,42 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs";
 import path from "path";
-import { reportSavings } from "../utils/reportSavings";
-/**
- * Lemma MCP Server
- * Exposes Lemma's intelligence layer as Tools and Resources for LLMs.
- */
+import axios from "axios";
+import { spawn } from "child_process";
+import { setupPromptsHandlers } from "./prompts";
+import { setupResourcesHandlers } from "./resources";
+import { setupToolsHandlers } from "./tools";
+import { getProxyPort, sanitizeArgsForLogging, logWarn } from "./utils";
+const SERVER_VERSION = "0.7.2";
 class LemmaMcpServer {
     constructor() {
         this.server = new Server({
             name: "lemma-mcp-server",
-            version: "0.1.0",
+            version: SERVER_VERSION,
         }, {
             capabilities: {
-                resources: {
-                    subscribe: true
-                },
+                resources: { subscribe: true },
                 tools: {},
+                prompts: {},
             },
         });
         this.setupHandlers();
         this.setupErrorHandling();
         this.setupLiveContextWatcher();
     }
+    setupHandlers() {
+        setupPromptsHandlers(this.server);
+        setupResourcesHandlers(this.server);
+        setupToolsHandlers(this.server, (event) => this.reportMcpEvent(event));
+    }
+    async run() {
+        await this.ensureProxyRunning();
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("Lemma MCP Server running on stdio");
+    }
+    // ── Live Context Watcher ──────────────────────────────────────────
     setupLiveContextWatcher() {
         try {
             const lemmaDir = path.join(process.cwd(), ".lemma");
@@ -41,1106 +53,25 @@ class LemmaMcpServer {
                         // @ts-ignore
                         this.server.sendResourceUpdated({ uri: "lemma://runtime/context" });
                     }
-                    catch { }
-                }
-            });
-        }
-        catch { }
-    }
-    listDirRecursive(currentDir, relativePath, depth, maxDepth) {
-        if (depth > maxDepth)
-            return [];
-        try {
-            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-            let result = [];
-            for (const entry of entries) {
-                if (["node_modules", ".git", "dist", "chroma_data"].includes(entry.name))
-                    continue;
-                const rel = relativePath ? path.join(relativePath, entry.name) : entry.name;
-                const full = path.join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    result.push(`${rel}/`);
-                    result.push(...this.listDirRecursive(full, rel, depth + 1, maxDepth));
-                }
-                else {
-                    result.push(rel);
-                }
-            }
-            return result;
-        }
-        catch {
-            return [];
-        }
-    }
-    searchDirRecursive(currentDir, relativePath, query, extFilter) {
-        try {
-            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-            let result = [];
-            for (const entry of entries) {
-                if (["node_modules", ".git", "dist", "chroma_data"].includes(entry.name))
-                    continue;
-                const rel = relativePath ? path.join(relativePath, entry.name) : entry.name;
-                const full = path.join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    result.push(...this.searchDirRecursive(full, rel, query, extFilter));
-                }
-                else {
-                    if (extFilter && !entry.name.endsWith(`.${extFilter}`))
-                        continue;
-                    try {
-                        const content = fs.readFileSync(full, "utf8");
-                        if (content.toLowerCase().includes(query.toLowerCase())) {
-                            const lines = content.split("\n");
-                            lines.forEach((lineText, idx) => {
-                                if (lineText.toLowerCase().includes(query.toLowerCase())) {
-                                    result.push({
-                                        filePath: rel,
-                                        line: idx + 1,
-                                        text: lineText.trim()
-                                    });
-                                }
-                            });
-                        }
+                    catch (err) {
+                        logWarn("live-context", "Failed to send resource update");
                     }
-                    catch { }
                 }
-            }
-            return result;
+            });
         }
-        catch {
-            return [];
+        catch (err) {
+            logWarn("live-context", "Could not set up live context watcher");
         }
     }
-    setupHandlers() {
-        // 1. List Resources
-        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-            return {
-                resources: [
-                    {
-                        uri: "lemma://runtime/context",
-                        name: "Lemma Live Context",
-                        description: "Real-time application errors, stack traces, and runtime state captured by Lemma.",
-                        mimeType: "text/markdown",
-                    },
-                    {
-                        uri: "lemma://stats/usage",
-                        name: "Lemma Intelligence Stats",
-                        description: "Current project stats, token savings, and cost optimization report.",
-                        mimeType: "application/json",
-                    },
-                    {
-                        uri: "lemma://project/onboarding",
-                        name: "Lemma Project Onboarding Mental Model",
-                        description: "Dynamic codebase architecture, technical stack, folder structure, and core design principles compiled in one shot.",
-                        mimeType: "text/markdown",
-                    },
-                    {
-                        uri: "lemma://multiverse/timeline",
-                        name: "Lemma Codebase Multiverse AST Timeline",
-                        description: "Live, chronological time-travel database of the last 10 micro-snapshots of AST changes, code diffs, and execution results.",
-                        mimeType: "text/markdown",
-                    },
-                ],
-            };
-        });
-        // 2. Read Resource
-        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-            const { uri } = request.params;
-            if (uri === "lemma://runtime/context") {
-                const filePath = path.join(process.cwd(), ".lemma/live-context.md");
-                try {
-                    const content = fs.readFileSync(filePath, "utf8");
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "text/markdown",
-                                text: content,
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "text/markdown",
-                                text: "# No Live Context\nNo recent crashes or state changes recorded by Lemma.",
-                            },
-                        ],
-                    };
-                }
-            }
-            if (uri === "lemma://stats/usage") {
-                const statsFile = path.join(process.env.HOME || "~", ".lemma-cache/stats.json");
-                try {
-                    const stats = JSON.parse(fs.readFileSync(statsFile, "utf8"));
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "application/json",
-                                text: JSON.stringify(stats, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "application/json",
-                                text: JSON.stringify({ error: "Stats not found. Is Lemma running?" }),
-                            },
-                        ],
-                    };
-                }
-            }
-            if (uri === "lemma://project/onboarding") {
-                try {
-                    const HOME = process.env.HOME || process.env.USERPROFILE || "~";
-                    const portFile = path.join(HOME, ".lemma-cache/proxy.port");
-                    let port = "8081";
-                    if (fs.existsSync(portFile)) {
-                        port = fs.readFileSync(portFile, "utf8").trim();
-                    }
-                    const axios = require("axios");
-                    const response = await axios.get(`http://localhost:${port}/api/project/onboarding`);
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "text/markdown",
-                                text: response.data.markdown || "# Onboarding mental model could not be generated."
-                            }
-                        ]
-                    };
-                }
-                catch (error) {
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "text/markdown",
-                                text: `# Onboarding Error\nCould not fetch dynamic project onboarding: ${error.message}. Is Lemma proxy running?`
-                            }
-                        ]
-                    };
-                }
-            }
-            if (uri === "lemma://multiverse/timeline") {
-                try {
-                    const HOME = process.env.HOME || process.env.USERPROFILE || "~";
-                    const portFile = path.join(HOME, ".lemma-cache/proxy.port");
-                    let port = "8081";
-                    if (fs.existsSync(portFile)) {
-                        port = fs.readFileSync(portFile, "utf8").trim();
-                    }
-                    const axios = require("axios");
-                    const response = await axios.get(`http://localhost:${port}/api/project/timeline`);
-                    const timeline = response.data.timeline || [];
-                    let markdown = `# 🌌 Codebase Multiverse Timeline: Recent AST Snapshots\n\n`;
-                    markdown += `This timeline tracks recent modifications and compiler states to reconstruct your workspace's historical state.\n\n`;
-                    if (timeline.length === 0) {
-                        markdown += `*(No AST snapshots captured yet. Make a few edits to code files in your workspace to trigger micro-snapshots!)*\n`;
-                    }
-                    else {
-                        // Display snapshots in reverse chronological order (newest first)
-                        const reversed = [...timeline].reverse();
-                        reversed.forEach((snap, idx) => {
-                            const timeStr = new Date(snap.timestamp).toLocaleTimeString();
-                            const agoStr = Math.max(0, Math.floor((Date.now() - snap.timestamp) / 1000 / 60));
-                            const ageText = agoStr === 0 ? 'just now' : `${agoStr} minute(s) ago`;
-                            const statusSymbol = snap.status === 'failure' ? '🔴' : (snap.status === 'success' ? '🟢' : '🔵');
-                            const statusText = snap.status.toUpperCase();
-                            markdown += `### ${idx + 1}. 🕒 Snapshot \`${snap.id}\` - ${ageText} (${timeStr})\n`;
-                            markdown += `- **Compiler/Execution Status:** ${statusSymbol} ${statusText}\n`;
-                            if (snap.errorLog) {
-                                markdown += `- **Active Exception / Crash Log:**\n\`\`\`text\n${snap.errorLog.substring(0, 400)}...\n\`\`\`\n`;
-                            }
-                            markdown += `- **Modified Files:**\n`;
-                            snap.changedFiles.forEach((file) => {
-                                markdown += `  - \`${file.filePath}\`\n`;
-                                if (file.diff) {
-                                    markdown += `    - **Incremental AST Diff:**\n    \`\`\`diff\n${file.diff}\n    \`\`\`\n`;
-                                }
-                            });
-                            markdown += `\n---\n\n`;
-                        });
-                    }
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "text/markdown",
-                                text: markdown
-                            }
-                        ]
-                    };
-                }
-                catch (error) {
-                    return {
-                        contents: [
-                            {
-                                uri,
-                                mimeType: "text/markdown",
-                                text: `# Multiverse Error\nCould not fetch codebase timeline: ${error.message}. Is Lemma proxy running?`
-                            }
-                        ]
-                    };
-                }
-            }
-            throw new Error(`Resource not found: ${uri}`);
-        });
-        // 3. List Tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "scrub_privacy",
-                        description: "Mask sensitive data (PII, API Keys, Credentials) from a text block using Lemma's Privacy Firewall.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                text: { type: "string", description: "The raw text to scrub" },
-                            },
-                            required: ["text"],
-                        },
-                    },
-                    {
-                        name: "search_memory",
-                        description: "Search Lemma's semantic memory (The Brain) to find code snippets, solutions, and context from your past AI conversations.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                query: { type: "string", description: "The natural language query (e.g., 'How did I handle Stripe webhooks?')" },
-                                limit: { type: "number", description: "Maximum results to return", default: 5 },
-                            },
-                            required: ["query"],
-                        },
-                    },
-                    {
-                        name: "store_memory",
-                        description: "Explicitly record/store a key technical decision, architecture map, code snippet, or fact into Lemma's semantic memory database (The Brain). This makes the knowledge permanently available for future AI sessions.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                query: { type: "string", description: "The natural language query key (e.g., 'Sazonia Architecture Map' or 'How Supabase auth works')" },
-                                response: { type: "string", description: "The complete technical content, analysis, or code to memorize" },
-                                provider: { type: "string", description: "Optional model provider name (defaults to 'generic')", default: "generic" },
-                            },
-                            required: ["query", "response"],
-                        },
-                    },
-                    {
-                        name: "get_routing_advice",
-                        description: "Analyzes a prompt and suggests the best model based on Lemma's Complexity Router.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                prompt: { type: "string", description: "The prompt to analyze" },
-                                intended_model: { type: "string", description: "The model you were planning to use (e.g., gpt-4o)" },
-                            },
-                            required: ["prompt"],
-                        },
-                    },
-                    {
-                        name: "auto_heal",
-                        description: "Diagnose and auto-heal the latest local server crash registered in Lemma's context logs. Can automatically apply the fix.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                apply: { type: "boolean", description: "Whether to apply the generated code fix directly to the file", default: false },
-                            },
-                        },
-                    },
-                    {
-                        name: "read_workspace_file",
-                        description: "Read the contents of a file inside the local workspace project. Automatically compresses comments and excessive whitespaces to save up to 80% tokens on your local model's context window.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: { type: "string", description: "The path to the file relative to the project root" },
-                                compact: { type: "boolean", description: "Whether to compress comments and whitespace to save local/cloud LLM tokens", default: true }
-                            },
-                            required: ["filePath"],
-                        },
-                    },
-                    {
-                        name: "write_workspace_file",
-                        description: "Write the full contents to a file inside the local workspace project. Creates any necessary parent directories automatically.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: { type: "string", description: "The path to the file relative to the project root" },
-                                content: { type: "string", description: "The complete content to write to the file" }
-                            },
-                            required: ["filePath", "content"],
-                        },
-                    },
-                    {
-                        name: "apply_workspace_patch",
-                        description: "Apply a smart search-and-replace patch to an existing file inside the workspace. The search block must match exactly (including indentation and newlines). Safe against duplicate matches.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: { type: "string", description: "The path to the file relative to the project root" },
-                                searchContent: { type: "string", description: "The exact search block to find in the file" },
-                                replaceContent: { type: "string", description: "The replacement block to replace the search block with" }
-                            },
-                            required: ["filePath", "searchContent", "replaceContent"],
-                        },
-                    },
-                    {
-                        name: "run_workspace_command",
-                        description: "Execute a bash command (e.g., tests, linters, compilers, git diffs) in the workspace root. Runs synchronously with a maximum execution timeout of 15 seconds. Returns exit code, stdout, and stderr.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                command: { type: "string", description: "The bash command to run in the workspace root" }
-                            },
-                            required: ["command"],
-                        },
-                    },
-                    {
-                        name: "list_workspace_dir",
-                        description: "List all files and subdirectories recursively in the project to help navigate the repository structure.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                dirPath: { type: "string", description: "The directory path relative to the project root (empty string for root)", default: "" },
-                                maxDepth: { type: "number", description: "Maximum recursion depth", default: 3 }
-                            },
-                            required: [],
-                        },
-                    },
-                    {
-                        name: "search_workspace",
-                        description: "Perform a fast local text search (grep) across all files in the project workspace.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                query: { type: "string", description: "The keyword or text pattern to search for" },
-                                extension: { type: "string", description: "Optional file extension filter (e.g., 'ts', 'json')" }
-                            },
-                            required: ["query"],
-                        },
-                    },
-                    {
-                        name: "squeeze_prompt",
-                        description: "Compress code blocks, comments, and boilerplate in any AI prompt or message using Lemma's context optimizer. Saves up to 80% tokens on your context window.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                prompt: { type: "string", description: "The raw prompt containing code blocks to squeeze" },
-                                query: { type: "string", description: "Optional user's primary query to preserve relevant code parts", default: "" }
-                            },
-                            required: ["prompt"],
-                        },
-                    },
-                    {
-                        name: "get_project_onboarding",
-                        description: "Downloads a dynamic, highly condensed architectural and stack overview (Mental Model) of the current project codebase in markdown, helping you understand how it is structured in a single shot without reading hundreds of files.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {},
-                        },
-                    },
-                    {
-                        name: "get_ast_hologram",
-                        description: "Generate a dense, token-efficient Holographic AST Map of the workspace: a structured JSON index of all exported symbols, classes, functions, interfaces, and their file locations. Use this INSTEAD of reading individual files when you need to understand codebase structure. Saves up to 90% tokens compared to reading files one by one.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                dirPath: { type: "string", description: "Directory to scan relative to workspace root (empty for root)", default: "" },
-                                extensions: { type: "array", items: { type: "string" }, description: "File extensions to scan (default: ['ts', 'tsx', 'js', 'jsx'])", default: ["ts", "tsx", "js", "jsx"] }
-                            },
-                            required: [],
-                        },
-                    },
-                    {
-                        name: "validate_patch_sandbox",
-                        description: "AST Multiverse Auto-Debugger: Validate a proposed code patch in an isolated sandbox BEFORE applying it to the workspace. Runs TypeScript compiler checks and a quick syntax validation pass. Returns success/failure with detailed diagnostics so you never break the codebase.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: { type: "string", description: "Target file path relative to workspace root" },
-                                patchedContent: { type: "string", description: "The complete proposed file content after the patch is applied" }
-                            },
-                            required: ["filePath", "patchedContent"],
-                        },
-                    },
-                    {
-                        name: "query_hybrid_consensus",
-                        description: "Hybrid Consensus Engine: First searches Lemma's semantic Brain (The Brain) for a cached high-similarity answer. If a strong match (>85%) is found locally, returns it instantly WITHOUT any cloud LLM call — saving tokens and latency. If no strong match exists, escalates to cloud and auto-stores the result for future hits. Always call this BEFORE asking an external LLM.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                query: { type: "string", description: "The technical question or task description" },
-                                context: { type: "string", description: "Optional extra context (active file path, error message, etc.)" },
-                                threshold: { type: "number", description: "Similarity threshold to consider a Brain hit sufficient (0.0-1.0, default: 0.80)", default: 0.80 }
-                            },
-                            required: ["query"],
-                        },
-                    },
-                    {
-                        name: "get_telepathic_hints",
-                        description: "Proactive Telepathy: Given the path of the file the user is currently editing, automatically surfaces the top N most relevant memories, past solutions, and architectural patterns from Lemma's Brain — without requiring an explicit query. Call this when starting work on a file to front-load all relevant context before writing any code.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                activeFile: { type: "string", description: "Path of the file currently being edited (relative or absolute)" },
-                                limit: { type: "number", description: "Maximum number of hints to return (default: 5)", default: 5 }
-                            },
-                            required: ["activeFile"],
-                        },
-                    },
-                ],
-            };
-        });
-        // 4. Call Tool
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "scrub_privacy": {
-                    const text = args?.text;
-                    if (!text)
-                        throw new Error("Text is required");
-                    // @ts-ignore
-                    const { SemanticScrubber } = require("../security/SemanticScrubber");
-                    const scrubber = new SemanticScrubber();
-                    const { maskedPrompt } = scrubber.mask(text);
-                    return {
-                        content: [{ type: "text", text: maskedPrompt }],
-                    };
-                }
-                case "search_memory": {
-                    const query = args?.query;
-                    const limit = args?.limit || 5;
-                    if (!query)
-                        throw new Error("Query is required");
-                    try {
-                        const HOME = process.env.HOME || process.env.USERPROFILE || "~";
-                        const portFile = path.join(HOME, ".lemma-cache/proxy.port");
-                        let port = "8081";
-                        if (fs.existsSync(portFile)) {
-                            port = fs.readFileSync(portFile, "utf8").trim();
-                        }
-                        const axios = require("axios");
-                        const response = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`);
-                        const results = response.data.results || [];
-                        if (results.length === 0) {
-                            return { content: [{ type: "text", text: "No relevant memories found in Lemma's Brain." }] };
-                        }
-                        const formatted = results.map((r, i) => {
-                            return `Result ${i + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)\nPrompt: ${r.prompt.substring(0, 300)}...\nResponse: ${typeof r.response === 'string' ? r.response : JSON.stringify(r.response, null, 2)}`;
-                        }).join("\n\n---\n\n");
-                        return {
-                            content: [{ type: "text", text: `Lemma found ${results.length} memories:\n\n${formatted}` }],
-                        };
-                    }
-                    catch (e) {
-                        return {
-                            content: [{ type: "text", text: `Neural Search failed: ${e.message}. Is Lemma Proxy running?` }],
-                        };
-                    }
-                }
-                case "store_memory": {
-                    const query = args?.query;
-                    const responseText = args?.response;
-                    const provider = args?.provider || 'generic';
-                    if (!query || !responseText)
-                        throw new Error("Query and response are required");
-                    try {
-                        const HOME = process.env.HOME || process.env.USERPROFILE || "~";
-                        const portFile = path.join(HOME, ".lemma-cache/proxy.port");
-                        let port = "8081";
-                        if (fs.existsSync(portFile)) {
-                            port = fs.readFileSync(portFile, "utf8").trim();
-                        }
-                        const axios = require("axios");
-                        const response = await axios.post(`http://localhost:${port}/api/memory/store`, {
-                            query,
-                            response: responseText,
-                            provider
-                        });
-                        // Report the savings to the proxy ledger so it updates the dashboard instantly!
-                        const tokensSaved = Math.max(100, Math.floor(responseText.length / 4));
-                        reportSavings({ source: 'cache', tokens: tokensSaved });
-                        return {
-                            content: [{ type: "text", text: `Success: ${response.data.message}` }],
-                        };
-                    }
-                    catch (e) {
-                        return {
-                            content: [{ type: "text", text: `Failed to store memory in Lemma: ${e.message}. Is Lemma Proxy running?` }],
-                        };
-                    }
-                }
-                case "get_routing_advice": {
-                    const prompt = args?.prompt;
-                    const intendedModel = args?.intended_model;
-                    // @ts-ignore
-                    const { ComplexityRouter } = require("../proxy/ComplexityRouter");
-                    const router = new ComplexityRouter();
-                    const decision = router.evaluate(prompt, intendedModel);
-                    // Report routing savings if model was downgraded
-                    if (decision.complexity === 'low' && intendedModel && decision.model !== intendedModel) {
-                        const estimatedPromptTokens = Math.floor((prompt?.length || 0) / 4);
-                        reportSavings({ source: 'complexityRouting', tokens: Math.floor(estimatedPromptTokens * 0.8) });
-                    }
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `Lemma Routing Advice: Use ${decision.model}. Reason: Complexity is ${decision.complexity}.`
-                            }],
-                    };
-                }
-                case "auto_heal": {
-                    const apply = !!args?.apply;
-                    try {
-                        // @ts-ignore
-                        const { performAutoHeal } = require("../cli/lemma-proxy");
-                        const res = await performAutoHeal(apply);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify(res, null, 2)
-                                }],
-                        };
-                    }
-                    catch (e) {
-                        return {
-                            content: [{ type: "text", text: `Auto-heal failed: ${e.message}` }],
-                        };
-                    }
-                }
-                case "read_workspace_file": {
-                    const filePath = args?.filePath;
-                    const compact = args?.compact !== false;
-                    if (!filePath)
-                        throw new Error("filePath is required");
-                    const workspaceRoot = process.cwd();
-                    const resolvedPath = path.resolve(workspaceRoot, filePath);
-                    if (!resolvedPath.startsWith(workspaceRoot)) {
-                        throw new Error("Access denied: path is outside of workspace root");
-                    }
-                    try {
-                        let content = fs.readFileSync(resolvedPath, "utf8");
-                        const originalSize = content.length;
-                        if (compact) {
-                            const { squeezeCode } = require("../utils/ContextSqueezer");
-                            content = squeezeCode(content);
-                            // Report context squeeze savings to the proxy ledger
-                            if (content.length < originalSize) {
-                                reportSavings({ source: 'contextSqueeze', charsBefore: originalSize, charsAfter: content.length });
-                            }
-                        }
-                        // Run SemanticScrubber to automatically mask any credentials/PII/API keys
-                        try {
-                            const { SemanticScrubber } = require("../security/SemanticScrubber");
-                            const scrubber = new SemanticScrubber();
-                            const { maskedPrompt } = scrubber.mask(content);
-                            content = maskedPrompt;
-                        }
-                        catch { }
-                        return {
-                            content: [{ type: "text", text: content }],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: `Error reading file: ${err.message}` }],
-                        };
-                    }
-                }
-                case "write_workspace_file": {
-                    const filePath = args?.filePath;
-                    const content = args?.content;
-                    if (!filePath || content === undefined) {
-                        throw new Error("filePath and content are required");
-                    }
-                    const workspaceRoot = process.cwd();
-                    const resolvedPath = path.resolve(workspaceRoot, filePath);
-                    if (!resolvedPath.startsWith(workspaceRoot)) {
-                        throw new Error("Access denied: path is outside of workspace root");
-                    }
-                    try {
-                        const dir = path.dirname(resolvedPath);
-                        if (!fs.existsSync(dir)) {
-                            fs.mkdirSync(dir, { recursive: true });
-                        }
-                        fs.writeFileSync(resolvedPath, content, "utf8");
-                        return {
-                            content: [{ type: "text", text: `Success: Written file to ${filePath}` }],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: `Error writing file: ${err.message}` }],
-                        };
-                    }
-                }
-                case "apply_workspace_patch": {
-                    const filePath = args?.filePath;
-                    const searchContent = args?.searchContent;
-                    const replaceContent = args?.replaceContent;
-                    if (!filePath || !searchContent || replaceContent === undefined) {
-                        throw new Error("filePath, searchContent, and replaceContent are required");
-                    }
-                    const workspaceRoot = process.cwd();
-                    const resolvedPath = path.resolve(workspaceRoot, filePath);
-                    if (!resolvedPath.startsWith(workspaceRoot)) {
-                        throw new Error("Access denied: path is outside of workspace root");
-                    }
-                    try {
-                        if (!fs.existsSync(resolvedPath)) {
-                            return {
-                                content: [{ type: "text", text: `Error: File ${filePath} does not exist.` }],
-                            };
-                        }
-                        const originalContent = fs.readFileSync(resolvedPath, "utf8");
-                        const index = originalContent.indexOf(searchContent);
-                        if (index === -1) {
-                            return {
-                                content: [{ type: "text", text: `Error: Target search content not found in file. Make sure the search content matches exactly, including indentation, tabs, spaces, and newlines.` }],
-                            };
-                        }
-                        if (originalContent.indexOf(searchContent, index + 1) !== -1) {
-                            return {
-                                content: [{ type: "text", text: `Error: Multiple matches found for the search content. Please provide a larger search block with unique surrounding context lines to make it unambiguous.` }],
-                            };
-                        }
-                        const updatedContent = originalContent.replace(searchContent, replaceContent);
-                        fs.writeFileSync(resolvedPath, updatedContent, "utf8");
-                        return {
-                            content: [{ type: "text", text: `Success: Patch successfully applied to ${filePath}` }],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: `Error applying patch: ${err.message}` }],
-                        };
-                    }
-                }
-                case "run_workspace_command": {
-                    const command = args?.command;
-                    if (!command)
-                        throw new Error("command is required");
-                    const { execSync } = require("child_process");
-                    const workspaceRoot = process.cwd();
-                    try {
-                        const output = execSync(command, {
-                            cwd: workspaceRoot,
-                            encoding: "utf8",
-                            timeout: 15000,
-                            env: { ...process.env }
-                        });
-                        return {
-                            content: [{ type: "text", text: `Command completed successfully.\n\nOutput:\n${output}` }],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `Command failed with exit code ${err.status || 'unknown'}.\n\nStdout:\n${err.stdout || ''}\n\nStderr:\n${err.stderr || err.message || ''}`
-                                }],
-                        };
-                    }
-                }
-                case "list_workspace_dir": {
-                    const dirPath = args?.dirPath || "";
-                    const maxDepth = args?.maxDepth || 3;
-                    const workspaceRoot = process.cwd();
-                    const resolvedPath = path.resolve(workspaceRoot, dirPath);
-                    if (!resolvedPath.startsWith(workspaceRoot)) {
-                        throw new Error("Access denied: path is outside of workspace root");
-                    }
-                    try {
-                        const list = this.listDirRecursive(resolvedPath, dirPath, 1, maxDepth);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: list.length > 0 ? list.join("\n") : "(Directory is empty or inaccessible)"
-                                }],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: `Error listing directory: ${err.message}` }],
-                        };
-                    }
-                }
-                case "search_workspace": {
-                    const query = args?.query;
-                    const extension = args?.extension;
-                    if (!query)
-                        throw new Error("query is required");
-                    const workspaceRoot = process.cwd();
-                    try {
-                        const results = this.searchDirRecursive(workspaceRoot, "", query, extension);
-                        if (results.length === 0) {
-                            return {
-                                content: [{ type: "text", text: `No matches found in the workspace for "${query}".` }],
-                            };
-                        }
-                        let formatted = results.map(r => `[${r.filePath}:${r.line}] ${r.text}`).join("\n");
-                        // Run SemanticScrubber to automatically mask any credentials/PII/API keys in search results
-                        try {
-                            const { SemanticScrubber } = require("../security/SemanticScrubber");
-                            const scrubber = new SemanticScrubber();
-                            const { maskedPrompt } = scrubber.mask(formatted);
-                            formatted = maskedPrompt;
-                        }
-                        catch { }
-                        return {
-                            content: [{ type: "text", text: `Found ${results.length} matches:\n\n${formatted}` }],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: `Error searching workspace: ${err.message}` }],
-                        };
-                    }
-                }
-                case "squeeze_prompt": {
-                    const promptArg = args?.prompt;
-                    const queryArg = args?.query || "";
-                    if (!promptArg)
-                        throw new Error("prompt is required");
-                    try {
-                        const { squeezePrompt } = require("../utils/ContextSqueezer");
-                        const result = squeezePrompt(promptArg, queryArg);
-                        if (result.originalSize > result.squeezedSize) {
-                            reportSavings({ source: 'contextSqueeze', charsBefore: result.originalSize, charsAfter: result.squeezedSize });
-                        }
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: result.squeezed,
-                                },
-                            ],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: `Error squeezing prompt: ${err.message}` }],
-                        };
-                    }
-                }
-                case "get_project_onboarding": {
-                    try {
-                        const HOME = process.env.HOME || process.env.USERPROFILE || "~";
-                        const portFile = path.join(HOME, ".lemma-cache/proxy.port");
-                        let port = "8081";
-                        if (fs.existsSync(portFile)) {
-                            port = fs.readFileSync(portFile, "utf8").trim();
-                        }
-                        const axios = require("axios");
-                        const response = await axios.get(`http://localhost:${port}/api/project/onboarding`);
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: response.data.markdown || "# Onboarding mental model could not be generated."
-                                }
-                            ]
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Failed to fetch codebase onboarding mental model: ${error.message}. Is Lemma proxy running?`
-                                }
-                            ]
-                        };
-                    }
-                }
-                case "get_ast_hologram": {
-                    const dirPath = args?.dirPath || "";
-                    const extensions = args?.extensions || ["ts", "tsx", "js", "jsx"];
-                    const workspaceRoot = process.cwd();
-                    const resolvedDir = path.resolve(workspaceRoot, dirPath);
-                    if (!resolvedDir.startsWith(workspaceRoot)) {
-                        throw new Error("Access denied: path is outside of workspace root");
-                    }
-                    // Recursive AST symbol extractor (regex-based, no heavy deps)
-                    const extractSymbols = (filePath, relPath) => {
-                        try {
-                            const src = fs.readFileSync(filePath, "utf8");
-                            const symbols = [];
-                            const lines = src.split("\n");
-                            lines.forEach((line, idx) => {
-                                // Export declarations: functions, classes, interfaces, types, consts
-                                const m = line.match(/^export\s+(?:default\s+)?(?:async\s+)?(class|function|interface|type|const|enum|abstract\s+class)\s+(\w+)/);
-                                if (m) {
-                                    symbols.push({ kind: m[1].replace('abstract ', ''), name: m[2], file: relPath, line: idx + 1 });
-                                }
-                                // Named exports
-                                const exportMatch = line.match(/^export\s*\{([^}]+)\}/);
-                                if (exportMatch) {
-                                    exportMatch[1].split(',').forEach(s => {
-                                        const name = s.trim().split(/\s+as\s+/).pop()?.trim();
-                                        if (name)
-                                            symbols.push({ kind: 'export', name, file: relPath, line: idx + 1 });
-                                    });
-                                }
-                            });
-                            return symbols;
-                        }
-                        catch {
-                            return [];
-                        }
-                    };
-                    const walkDir = (dir, rel) => {
-                        let allSymbols = [];
-                        try {
-                            const entries = fs.readdirSync(dir, { withFileTypes: true });
-                            for (const entry of entries) {
-                                if (["node_modules", ".git", "dist", "chroma_data", ".lemma"].includes(entry.name))
-                                    continue;
-                                const fullPath = path.join(dir, entry.name);
-                                const relPath = rel ? path.join(rel, entry.name) : entry.name;
-                                if (entry.isDirectory()) {
-                                    allSymbols = allSymbols.concat(walkDir(fullPath, relPath));
-                                }
-                                else {
-                                    const ext = entry.name.split('.').pop() || '';
-                                    if (extensions.includes(ext)) {
-                                        allSymbols = allSymbols.concat(extractSymbols(fullPath, relPath));
-                                    }
-                                }
-                            }
-                        }
-                        catch { }
-                        return allSymbols;
-                    };
-                    const symbols = walkDir(resolvedDir, dirPath);
-                    const byFile = {};
-                    symbols.forEach(s => {
-                        if (!byFile[s.file])
-                            byFile[s.file] = [];
-                        byFile[s.file].push({ kind: s.kind, name: s.name, line: s.line });
-                    });
-                    const hologram = {
-                        workspace: path.basename(workspaceRoot),
-                        scannedDir: dirPath || '.',
-                        totalSymbols: symbols.length,
-                        totalFiles: Object.keys(byFile).length,
-                        map: byFile,
-                    };
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(hologram, null, 2) }],
-                    };
-                }
-                case "validate_patch_sandbox": {
-                    const filePath = args?.filePath;
-                    const patchedContent = args?.patchedContent;
-                    if (!filePath || patchedContent === undefined) {
-                        throw new Error("filePath and patchedContent are required");
-                    }
-                    const workspaceRoot = process.cwd();
-                    const resolvedPath = path.resolve(workspaceRoot, filePath);
-                    if (!resolvedPath.startsWith(workspaceRoot)) {
-                        throw new Error("Access denied: path is outside of workspace root");
-                    }
-                    const { execSync } = require('child_process');
-                    const os = require('os');
-                    const sandboxDir = path.join(os.tmpdir(), `lemma-sandbox-${Date.now()}`);
-                    const sandboxFile = path.join(sandboxDir, path.basename(filePath));
-                    try {
-                        fs.mkdirSync(sandboxDir, { recursive: true });
-                        fs.writeFileSync(sandboxFile, patchedContent, 'utf8');
-                        // Step 1: Basic syntax check via Node.js --check (works for JS/TS after strip)
-                        // Step 2: Try tsc --noEmit on the patched file using the workspace tsconfig
-                        const tsconfigPath = path.join(workspaceRoot, 'tsconfig.json');
-                        let tscResult = { success: true, output: 'No TypeScript config found — skipping tsc validation.' };
-                        if (fs.existsSync(tsconfigPath) && filePath.match(/\.tsx?$/)) {
-                            try {
-                                // Copy the patched file to a temp location respecting the workspace structure
-                                const sandboxWorkspace = path.join(sandboxDir, 'workspace');
-                                // Sync relevant source structure for valid imports check
-                                execSync(`cp -r ${workspaceRoot}/src ${sandboxWorkspace}/src 2>/dev/null || true`, { timeout: 5000 });
-                                // Overwrite the target file with patched content
-                                const sandboxTargetFile = path.join(sandboxWorkspace, filePath);
-                                fs.mkdirSync(path.dirname(sandboxTargetFile), { recursive: true });
-                                fs.writeFileSync(sandboxTargetFile, patchedContent, 'utf8');
-                                const tscOut = execSync(`cd ${workspaceRoot} && npx tsc --noEmit --skipLibCheck --allowJs --esModuleInterop --strict false 2>&1 | head -40 || true`, { timeout: 20000, encoding: 'utf8' });
-                                // Filter errors that reference our target file
-                                const relevantErrors = tscOut.split('\n').filter((l) => l.includes(path.basename(filePath)) || l.includes('error TS'));
-                                tscResult = {
-                                    success: relevantErrors.length === 0,
-                                    output: relevantErrors.length > 0 ? relevantErrors.join('\n') : '✅ TypeScript check passed with no errors in target file.'
-                                };
-                            }
-                            catch (e) {
-                                tscResult = { success: false, output: e.stdout || e.message };
-                            }
-                        }
-                        // Step 3: Quick regex-based syntax sanity (balanced braces/brackets)
-                        const opens = (patchedContent.match(/[{[(]/g) || []).length;
-                        const closes = (patchedContent.match(/[}\])]/g) || []).length;
-                        const balanced = Math.abs(opens - closes) <= 2; // allow small tolerance
-                        fs.rmSync(sandboxDir, { recursive: true, force: true });
-                        const verdict = tscResult.success && balanced;
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        verdict: verdict ? '✅ SAFE TO APPLY' : '❌ DO NOT APPLY — Issues Found',
-                                        syntaxBalanced: balanced ? '✅' : '⚠️ Unbalanced brackets/braces detected',
-                                        tscCheck: tscResult.output,
-                                        recommendation: verdict
-                                            ? 'Patch looks valid. You can safely call apply_workspace_patch to apply it.'
-                                            : 'Fix the reported issues before applying the patch to avoid breaking the codebase.',
-                                    }, null, 2)
-                                }]
-                        };
-                    }
-                    catch (err) {
-                        try {
-                            fs.rmSync(sandboxDir, { recursive: true, force: true });
-                        }
-                        catch { }
-                        return {
-                            content: [{ type: "text", text: `Sandbox validation error: ${err.message}` }]
-                        };
-                    }
-                }
-                case "query_hybrid_consensus": {
-                    const query = args?.query;
-                    const context = args?.context || '';
-                    const threshold = typeof args?.threshold === 'number' ? args.threshold : 0.80;
-                    if (!query)
-                        throw new Error('query is required');
-                    const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-                    const portFile = path.join(HOME, '.lemma-cache/proxy.port');
-                    let port = '8081';
-                    if (fs.existsSync(portFile)) {
-                        port = fs.readFileSync(portFile, 'utf8').trim();
-                    }
-                    const axios = require('axios');
-                    const fullQuery = context ? `${query}\n\nContext: ${context}` : query;
-                    try {
-                        // Step 1: Hit The Brain first
-                        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(fullQuery)}&limit=3`);
-                        const results = searchRes.data.results || [];
-                        const topHit = results[0];
-                        if (topHit && topHit.similarity >= threshold) {
-                            // 🎯 Brain HIT — return cached answer, zero cloud tokens spent
-                            const savedTokens = Math.floor((topHit.response?.choices?.[0]?.message?.content?.length || 500) / 4);
-                            reportSavings({ source: 'cache', tokens: savedTokens });
-                            const responseText = typeof topHit.response === 'string'
-                                ? topHit.response
-                                : topHit.response?.choices?.[0]?.message?.content
-                                    || JSON.stringify(topHit.response, null, 2);
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `🧠 **Brain Cache HIT** (similarity: ${(topHit.similarity * 100).toFixed(1)}% — above ${(threshold * 100).toFixed(0)}% threshold)\n\n**No cloud LLM call needed. ~${savedTokens} tokens saved.**\n\n---\n\n${responseText}`
-                                    }]
-                            };
-                        }
-                        // Step 2: Brain MISS — inform the IDE to proceed with cloud and store the result
-                        const missMsg = results.length > 0
-                            ? `🔍 **Brain Miss** — Best match was only ${(topHit.similarity * 100).toFixed(1)}% (below ${(threshold * 100).toFixed(0)}% threshold).`
-                            : `🔍 **Brain Miss** — No relevant memories found for this query.`;
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `${missMsg}\n\n**Proceed with your cloud LLM call.** Once you have the answer, call \`store_memory\` with:\n- query: "${query.substring(0, 100)}"
-- response: [your full answer]\n\nThis will cache it for future sessions and save tokens next time.`
-                                }]
-                        };
-                    }
-                    catch (e) {
-                        return {
-                            content: [{ type: 'text', text: `Hybrid Consensus failed: ${e.message}. Is Lemma Proxy running?` }]
-                        };
-                    }
-                }
-                case "get_telepathic_hints": {
-                    const activeFile = args?.activeFile;
-                    const limit = typeof args?.limit === 'number' ? args.limit : 5;
-                    if (!activeFile)
-                        throw new Error('activeFile is required');
-                    const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-                    const portFile = path.join(HOME, '.lemma-cache/proxy.port');
-                    let port = '8081';
-                    if (fs.existsSync(portFile)) {
-                        port = fs.readFileSync(portFile, 'utf8').trim();
-                    }
-                    const axios = require('axios');
-                    // Build a rich query from the file path: extract module name, dir context, and file extension
-                    const basename = path.basename(activeFile, path.extname(activeFile));
-                    const dirContext = path.dirname(activeFile).split(path.sep).filter(Boolean).slice(-2).join(' ');
-                    const ext = path.extname(activeFile).replace('.', '');
-                    const telepathicQuery = `${basename} ${dirContext} ${ext} patterns solutions architecture`;
-                    try {
-                        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(telepathicQuery)}&limit=${limit}`);
-                        const results = searchRes.data.results || [];
-                        if (results.length === 0) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `📡 **Telepathic Hints** for \`${activeFile}\`\n\nNo relevant memories found yet. As you use Lemma and store solutions, they will appear here automatically.`
-                                    }]
-                            };
-                        }
-                        let hintsText = `📡 **Telepathic Hints** for \`${activeFile}\`\n*(${results.length} relevant memories surfaced from The Brain)*\n\n`;
-                        results.forEach((r, i) => {
-                            const similarity = (r.similarity * 100).toFixed(1);
-                            const prompt = typeof r.prompt === 'string' ? r.prompt.substring(0, 120) : 'Unknown';
-                            const responseContent = typeof r.response === 'string'
-                                ? r.response
-                                : r.response?.choices?.[0]?.message?.content
-                                    || JSON.stringify(r.response).substring(0, 300);
-                            hintsText += `### 💡 Hint ${i + 1} (${similarity}% match)\n`;
-                            hintsText += `**Memory:** ${prompt}\n\n`;
-                            hintsText += `${responseContent.substring(0, 400)}${responseContent.length > 400 ? '...' : ''}\n\n---\n\n`;
-                        });
-                        // Report token savings: surface context avoids re-asking the LLM
-                        const estimatedTokensSaved = results.length * 150;
-                        reportSavings({ source: 'cache', tokens: estimatedTokensSaved });
-                        return {
-                            content: [{ type: 'text', text: hintsText }]
-                        };
-                    }
-                    catch (e) {
-                        return {
-                            content: [{ type: 'text', text: `Telepathic Hints failed: ${e.message}. Is Lemma Proxy running?` }]
-                        };
-                    }
-                }
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
-    setupErrorHandling() {
-        this.server.onerror = (error) => {
-            console.error("[MCP Error]", error);
-        };
-        process.on("SIGINT", async () => {
-            await this.server.close();
-            process.exit(0);
-        });
-    }
-    async ensureProxyAndClipboardRunning() {
+    // ── Proxy Auto-Start ──────────────────────────────────────────────
+    async ensureProxyRunning() {
         try {
-            const { spawn } = require('child_process');
             const cliCandidates = [
                 path.join(__dirname, "..", "cli", "lemma-proxy.js"),
                 path.join(__dirname, "..", "cli", "lemma-proxy.ts"),
                 path.join(__dirname, "lemma-proxy.ts"),
                 path.join(process.cwd(), "src", "cli", "lemma-proxy.ts"),
-                path.join(process.cwd(), "dist", "cjs", "cli", "lemma-proxy.js")
+                path.join(process.cwd(), "dist", "cjs", "cli", "lemma-proxy.js"),
             ];
             let cliPath = "";
             for (const cand of cliCandidates) {
@@ -1156,18 +87,44 @@ class LemmaMcpServer {
                 const proc = spawn(cmd, args, {
                     stdio: "ignore",
                     detached: true,
-                    env: { ...process.env }
+                    env: { ...process.env },
                 });
                 proc.unref();
             }
         }
-        catch { }
+        catch (err) {
+            logWarn("proxy-auto-start", "Could not auto-start Lemma proxy");
+        }
     }
-    async run() {
-        await this.ensureProxyAndClipboardRunning();
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        console.error("Lemma MCP Server running on stdio");
+    // ── MCP Event Reporting ───────────────────────────────────────────
+    async reportMcpEvent(event) {
+        try {
+            const port = getProxyPort();
+            axios
+                .post(`http://localhost:${port}/api/mcp-event`, {
+                type: "mcp_tool_call",
+                tool: event.tool,
+                args: sanitizeArgsForLogging(event.args),
+                result: event.result,
+                latency: event.latency,
+                tokensImpact: event.tokensImpact || 0,
+                timestamp: new Date().toISOString(),
+            })
+                .catch(() => { });
+        }
+        catch {
+            // Non-critical, silently ignore
+        }
+    }
+    // ── Error Handling ────────────────────────────────────────────────
+    setupErrorHandling() {
+        this.server.onerror = (error) => {
+            console.error("[Lemma MCP Error]", error);
+        };
+        process.on("SIGINT", async () => {
+            await this.server.close();
+            process.exit(0);
+        });
     }
 }
 const server = new LemmaMcpServer();