@nxuss/lemma 0.7.1 → 0.7.3

package/dist/esm/mcp/index.js

@@ -1,84 +1,88 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs";
 import path from "path";
-import { reportSavings } from "../utils/reportSavings";
-/**
- * Lemma Autopilot System Prompt — injected into every connected Chat IDE.
- * This is what makes Lemma tools AUTOMATIC: no user friction, no manual invocations.
- */
-const LEMMA_SYSTEM_PROMPT = `You are connected to Lemma — an intelligent local-first AI gateway.
-Lemma gives you a set of tools you MUST use proactively and automatically. NEVER ask the user
-to call a tool manually. YOU invoke the tools. The user should experience zero friction.
-
-## MANDATORY AUTOMATIC BEHAVIORS
-
-### 1. Before reading ANY file → call get_ast_hologram first
-When you need to understand the structure of a codebase or navigate files, ALWAYS call
-\`get_ast_hologram\` first (with the relevant dirPath, e.g. "src"). Use the returned symbol
-map to pinpoint exactly which files to read. NEVER blindly read every file one by one.
-
-### 2. Before answering ANY technical question → call query_hybrid_consensus first
-BEFORE making any reasoning or cloud LLM call, ALWAYS call \`query_hybrid_consensus\` with
-the user's question. If similarity ≥ 80%, return the cached answer immediately — no cloud
-call needed. Only proceed with your own reasoning if the Brain returns a MISS.
-
-### 3. When you start working on ANY file → call get_telepathic_hints automatically
-Whenever the user mentions a file or you are about to read/edit a file, IMMEDIATELY call
-\`get_telepathic_hints\` with that file's path. Surface the results to the user as relevant
-context BEFORE doing any work. Do not ask permission — just do it.
-
-### 4. Before applying ANY code patch → call validate_patch_sandbox first
-NEVER call \`write_workspace_file\` or \`apply_workspace_patch\` without FIRST calling
-\`validate_patch_sandbox\` with the proposed content. Only proceed with the write if the
-verdict is "✅ SAFE TO APPLY". If it fails, fix the issues and re-validate.
-
-### 5. After solving any technical problem → call store_memory automatically
-After resolving a bug, implementing a feature, or answering a significant technical question,
-ALWAYS call \`store_memory\` to persist the solution. Use a descriptive query key so it can
-be retrieved in future sessions across ALL projects.
-
-### 6. Workspace navigation → always use Lemma tools, NEVER guess file contents
-- Use \`list_workspace_dir\` to navigate structure
-- Use \`read_workspace_file\` (auto-compresses + scrubs secrets) instead of asking the user
-- Use \`search_workspace\` for text search across files
-- Use \`run_workspace_command\` for builds, tests, linters
-
-### 7. Privacy is automatic
-\`read_workspace_file\` and \`search_workspace\` automatically scrub API keys and PII.
-You never need to manually sanitize file content.
-
-## LEMMA RESOURCES (auto-subscribe when available)
-- \`lemma://runtime/context\` — live crash logs. Read this FIRST when the user reports a bug.
-- \`lemma://multiverse/timeline\` — AST history. Use when the user says "it was working before".
-- \`lemma://project/onboarding\` — architecture map. Read at session start in new repos.
-- \`lemma://stats/usage\` — token savings report.
-
-Remember: the user hired YOU to be autonomous. Act like it.`;
-/**
- * Lemma MCP Server
- * Exposes Lemma's intelligence layer as Tools and Resources for LLMs.
- */
+import axios from "axios";
+import { spawn } from "child_process";
+import { v4 as uuidv4 } from "uuid";
+import { setupPromptsHandlers } from "./prompts";
+import { setupResourcesHandlers } from "./resources";
+import { setupToolsHandlers } from "./tools";
+import { getProxyPort, sanitizeArgsForLogging, logWarn } from "./utils";
+const SERVER_VERSION = "0.7.3";
+function detectStack() {
+    const projectPath = process.cwd();
+    let projectName = path.basename(projectPath);
+    const techStack = [];
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(projectPath, 'package.json'), 'utf8'));
+        projectName = pkg.name || projectName;
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.react)
+            techStack.push('react');
+        if (deps.next)
+            techStack.push('next');
+        if (deps.vue)
+            techStack.push('vue');
+        if (deps.express)
+            techStack.push('express');
+        if (deps['@nestjs/core'])
+            techStack.push('nestjs');
+        if (deps.typescript || pkg.devDependencies?.typescript)
+            techStack.push('typescript');
+    }
+    catch { }
+    try {
+        const cargo = fs.readFileSync(path.join(projectPath, 'Cargo.toml'), 'utf8');
+        techStack.push('rust');
+        if (cargo.includes('actix'))
+            techStack.push('actix');
+        if (cargo.includes('axum'))
+            techStack.push('axum');
+    }
+    catch { }
+    try {
+        fs.readFileSync(path.join(projectPath, 'go.mod'), 'utf8');
+        techStack.push('go');
+    }
+    catch { }
+    try {
+        fs.readFileSync(path.join(projectPath, 'pyproject.toml'), 'utf8');
+        techStack.push('python');
+    }
+    catch { }
+    return { projectName, projectPath, techStack };
+}
 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.setupPromptsHandlers();
         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");
+        await this.registerWithProxy();
+        await this.trySamplingContext();
+    }
+    // ── Live Context Watcher ──────────────────────────────────────────
     setupLiveContextWatcher() {
         try {
             const lemmaDir = path.join(process.cwd(), ".lemma");
@@ -95,1138 +99,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");
         }
     }
-    setupPromptsHandlers() {
-        // Expose LEMMA_SYSTEM_PROMPT as a named MCP prompt so connected Chat IDEs
-        // load it as a system instruction, making all tool invocations automatic.
-        this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-            return {
-                prompts: [
-                    {
-                        name: "lemma-autopilot",
-                        description: "Lemma Autopilot: mandatory behavioral instructions for the AI assistant. Load this prompt to make all Lemma tools fire automatically with zero user friction.",
-                        arguments: [],
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            if (request.params.name === "lemma-autopilot") {
-                return {
-                    description: "Lemma Autopilot System Instructions",
-                    messages: [
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: LEMMA_SYSTEM_PROMPT,
-                            },
-                        },
-                    ],
-                };
-            }
-            throw new Error(`Unknown prompt: ${request.params.name}`);
-        });
-    }
-    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: "[CALL FIRST] Search Lemma's semantic memory (The Brain) before answering technical questions. Retrieves past solutions, fixes, and context from ALL your projects globally. If similarity > 50%, use this answer directly. Saves cloud tokens on every hit.",
-                        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: "[CALL AUTOMATICALLY AFTER SOLVING ANYTHING] Persist a technical solution, bug fix, architecture decision, or key fact into Lemma's Brain. ALWAYS call this after resolving a bug, implementing a feature, or completing a meaningful task. Do NOT ask the user — just call it. Future sessions across ALL projects will benefit.",
-                        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: "[ALWAYS USE THIS] Read a file inside the workspace. AUTOMATICALLY compresses comments/whitespace (up to 80% token savings) and AUTOMATICALLY scrubs API keys, credentials, and PII before they reach the AI context. ALWAYS use this instead of asking the user to paste file content.",
-                        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: "[CALL FIRST — BEFORE READING FILES] Generate a dense, token-efficient Holographic AST Map of the workspace. Returns a structured JSON index of ALL exported symbols (classes, functions, interfaces, types, consts) with file paths and line numbers. ALWAYS call this FIRST when navigating or understanding a codebase. NEVER read files blindly one-by-one — use this map to target exactly the right files. Saves up to 90% tokens.",
-                        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: "[MANDATORY PRE-FLIGHT CHECK] ALWAYS call this BEFORE apply_workspace_patch or write_workspace_file. Validates the proposed code in an isolated /tmp sandbox via tsc --noEmit + bracket-balance check. NEVER skip this step — only proceed with writing if verdict is '✅ SAFE TO APPLY'. If it fails, fix and re-validate.",
-                        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: "[CALL BEFORE EVERY TECHNICAL QUESTION] Hybrid Consensus Engine: ALWAYS call this FIRST before reasoning about any technical question or problem. Searches The Brain at configurable threshold (default 80%). Brain HIT → return cached answer instantly, ZERO cloud tokens spent. Brain MISS → proceed with your reasoning, then call store_memory with the answer. This is your primary token-saving mechanism.",
-                        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: "[CALL AUTOMATICALLY ON FILE OPEN] Proactive Telepathy: IMMEDIATELY call this whenever a file is mentioned or about to be edited. Automatically surfaces the most relevant past solutions, patterns, and memories from The Brain based on the file path — NO explicit query needed. Call this BEFORE writing any code. Surface the hints to the user without being asked.",
-                        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) {
@@ -1242,18 +133,100 @@ 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();
+            const projectPath = process.cwd();
+            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,
+                projectPath,
+                timestamp: new Date().toISOString(),
+            })
+                .catch(() => { });
+        }
+        catch {
+            // Non-critical, silently ignore
+        }
+    }
+    // ── Proxy Registration ────────────────────────────────────────────
+    async registerWithProxy() {
+        const maxRetries = 5;
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                const port = getProxyPort();
+                const stack = detectStack();
+                await axios.post(`http://localhost:${port}/api/handshake`, {
+                    type: 'mcp_ready',
+                    projectName: stack.projectName,
+                    projectPath: stack.projectPath,
+                    techStack: stack.techStack,
+                    timestamp: new Date().toISOString(),
+                    mcpVersion: SERVER_VERSION,
+                });
+                return;
+            }
+            catch {
+                if (i < maxRetries - 1) {
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+            }
+        }
+        logWarn('register', 'Could not register with proxy after 5 retries');
+    }
+    // ── Sampling Context Injection (Claude Desktop) ───────────────────
+    async trySamplingContext() {
+        try {
+            const stack = detectStack();
+            const sessionId = uuidv4();
+            const hint = `New session ${sessionId} for ${stack.projectName}`;
+            await this.server.createMessage({
+                maxTokens: 10,
+                messages: [
+                    {
+                        role: 'user',
+                        content: { type: 'text', text: `_initialize_context_${hint}_` },
+                    },
+                ],
+                // @ts-ignore – serverMetadata is not in types yet
+                serverMetadata: {
+                    lemmaContext: {
+                        projectName: stack.projectName,
+                        projectPath: stack.projectPath,
+                        techStack: stack.techStack,
+                        sessionId,
+                    },
+                },
+            });
+        }
+        catch {
+            logWarn('sampling', 'Sampling not available (likely not Claude Desktop)');
+        }
+    }
+    // ── 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();