@nxuss/lemma 0.9.2 → 1.0.0

package/dist/esm/mcp/tools.js

@@ -13,6 +13,12 @@ import { getProxyPort, safeResolvePath, logError, logWarn, estimateTokensFromRes
 import { runAnalysis, parseDiff } from "../pr-review/PRReviewEngine";
 import { ReviewStore } from "../pr-review/ReviewStore";
 import { runPRReview } from "../pr-review/reviewRunner";
+import { getBrain } from "../subconscious/TheBrainV2";
+import { collapseContext } from "../utils/ContextCollapser";
+import { getSymbolSurgicalContext } from "../utils/SymbolSurgicalContext";
+import { compressWormhole } from "../utils/WormholeCompressor";
+import { generateExecutiveReport } from "../utils/ExecutiveReport";
+import { surgicalASTInsert } from "../utils/SurgicalASTInsert";
 // ── Pro License Gate ──────────────────────────────────────────────────────────
 const LICENSE_FILE = path.join(os.homedir(), '.lemma-cache', 'license.json');
 let _proStatusCache = null;
@@ -320,6 +326,67 @@ const toolDefinitions = [
             required: ["text"],
         },
     },
+    {
+        name: "get_symbol_surgical_context",
+        description: "Extrae quirúrgicamente la implementación de un símbolo específico (clase, función, interfaz) y las firmas (pero no la implementación completa) de todas sus dependencias locales del workspace. Ahorra hasta 90% de tokens.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Ruta relativa del archivo que contiene el símbolo" },
+                symbolName: { type: "string", description: "Nombre de la función, clase, tipo o interfaz a extraer" },
+            },
+            required: ["filePath", "symbolName"],
+        },
+    },
+    {
+        name: "wormhole_squeeze",
+        description: "Comprime código a formato WORMHOLE súper denso usando tokens de palabra clave y abreviación de variables reversible. Ideal para alimentar contextos de lectura al LLM.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "El código fuente a comprimir" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "generate_executive_roi_report",
+        description: "Genera un reporte ejecutivo en formato Markdown de Retorno de Inversión (ROI), dinero ahorrado en API, horas de desarrollo recuperadas y proyecciones de escala para la gerencia.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                teamSize: { type: "number", description: "Número de ingenieros en el equipo (default: 10)", default: 10 },
+                costPerDevHour: { type: "number", description: "Costo estimado en USD por hora de desarrollador (default: 50)", default: 50 },
+                targetPath: { type: "string", description: "Nombre de archivo del reporte generado (default: LEMMA_ROI_REPORT.md)", default: "LEMMA_ROI_REPORT.md" },
+            },
+        },
+    },
+    {
+        name: "surgical_ast_insert",
+        description: "Inserta quirúrgicamente código (métodos, propiedades, funciones) en una clase, interfaz o ámbito de archivo de TypeScript utilizando el AST Compiler. Evita escribir diffs de búsqueda y reemplazo grandes o reescribir todo el archivo. Ahorra 95% de tokens de salida.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Ruta del archivo TypeScript (relativo al root)" },
+                symbolName: { type: "string", description: "Nombre de la clase o interfaz donde insertar (opcional)" },
+                anchorSymbol: { type: "string", description: "Nombre del método o propiedad como anclaje (ej. 'login')" },
+                insertPosition: { type: "string", enum: ["before", "after", "start", "end"], description: "Posición relativa al anclaje (default: 'after')", default: "after" },
+                codeToInsert: { type: "string", description: "El código fuente exacto a insertar" },
+            },
+            required: ["filePath", "codeToInsert"],
+        },
+    },
+    {
+        name: "local_semantic_autofix",
+        description: "Intenta resolver errores de compilación o ejecución localmente consultando The Brain por tracebacks/mensajes similares. Si hay coincidencia, devuelve la solución/parche instantáneamente sin gastar tokens de LLM.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                errorMessage: { type: "string", description: "El traceback del error o mensaje de error a resolver" },
+            },
+            required: ["errorMessage"],
+        },
+    },
     {
         name: "compress_context",
         description: "Comprime el historial de conversación: resume turns antiguos vía Ollama, mantiene solo los últimos N intactos. Reduce contexto 70-80%. USAR antes de cada turno extendido.",
@@ -491,6 +558,39 @@ const toolDefinitions = [
             required: ["platform"],
         },
     },
+    {
+        name: "depgraph",
+        description: "Builds a real-time dependency graph for any file in the workspace using the TypeScript Compiler API. Shows what a file imports, what imports it (reverse deps), and what it exports. Zero LLM calls. Essential before any refactor to understand blast radius.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Target file path relative to workspace root" },
+                reverse: { type: "boolean", description: "Include reverse dependencies (who imports this file)", default: true },
+                depth: { type: "number", description: "Graph traversal depth 1-5 (default: 1)", default: 1 },
+                format: { type: "string", enum: ["text", "mermaid", "json"], description: "Output format: text tree, Mermaid flowchart, or JSON", default: "text" },
+                external: { type: "boolean", description: "Include node_modules dependencies (default: false)", default: false },
+                circular: { type: "boolean", description: "Detect and highlight circular dependencies", default: false },
+            },
+            required: ["filePath"],
+        },
+    },
+    {
+        name: "refactor",
+        description: "Declarative multi-file codemod engine. Rename symbols across the entire workspace or move files updating all imports. Uses TypeScript Compiler API — zero LLM calls. Supports dry-run diff preview and post-refactor tsc verification.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                operation: { type: "string", enum: ["rename", "move"], description: "Refactor operation: 'rename' a symbol everywhere, or 'move' a file updating all importers" },
+                from: { type: "string", description: "Symbol name to rename (rename op) OR source file path relative to workspace root (move op)" },
+                to: { type: "string", description: "New symbol name (rename op) OR destination file path relative to workspace root (move op)" },
+                file: { type: "string", description: "File where the symbol is declared — required for 'rename' operation" },
+                dryRun: { type: "boolean", description: "Preview changes as a unified diff without applying them", default: false },
+                tscCheck: { type: "boolean", description: "Run tsc --noEmit after applying to guarantee zero TypeScript errors", default: false },
+                backup: { type: "boolean", description: "Create .bak backup of each modified file before changing", default: false },
+            },
+            required: ["operation", "from", "to"],
+        },
+    },
 ];
 const toolHandlers = {
     scrub_privacy: handleScrubPrivacy,
@@ -515,6 +615,11 @@ const toolHandlers = {
     diff_only: handleDiffOnly,
     batch_tool_calls: handleBatchToolCalls,
     turbosqueeze: handleTurboSqueeze,
+    get_symbol_surgical_context: handleGetSymbolSurgicalContext,
+    wormhole_squeeze: handleWormholeSqueeze,
+    generate_executive_roi_report: handleGenerateExecutiveRoiReport,
+    surgical_ast_insert: handleSurgicalAstInsert,
+    local_semantic_autofix: handleLocalSemanticAutofix,
     compress_context: handleCompressContext,
     smarter_cache: handleSmarterCache,
     token_budget: handleTokenBudget,
@@ -529,6 +634,8 @@ const toolHandlers = {
     review_pr: handleReviewPR,
     pr_status: handlePRStatus,
     generate_pr_workflow: handleGeneratePRWorkflow,
+    depgraph: handleDepgraph,
+    refactor: handleRefactor,
 };
 export function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -601,22 +708,21 @@ async function handleSearchMemory(args) {
     if (!query)
         throw new Error("Query is required");
     try {
-        const port = getProxyPort();
-        const response = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`);
-        const results = response.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(query, limit);
         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)}`;
+            return `Result ${i + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)\nPrompt: ${r.query.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) {
         logError("search_memory", e);
-        return { content: [{ type: "text", text: `Neural Search failed: ${e.message}. Is Lemma Proxy running?` }] };
+        return { content: [{ type: "text", text: `Local Search failed: ${e.message}` }] };
     }
 }
 async function handleStoreMemory(args) {
@@ -626,12 +732,8 @@ async function handleStoreMemory(args) {
     if (!query || !responseText)
         throw new Error("Query and response are required");
     try {
-        const port = getProxyPort();
-        const response = await axios.post(`http://localhost:${port}/api/memory/store`, {
-            query,
-            response: responseText,
-            provider,
-        });
+        const brain = getBrain();
+        const storeRes = brain.store(query, responseText, provider);
         const tokensSaved = Math.max(100, Math.floor(responseText.length / 4));
         reportSavings({
             source: "cache",
@@ -639,11 +741,11 @@ async function handleStoreMemory(args) {
             toolName: "store_memory",
             query: query.substring(0, 100),
         });
-        return { content: [{ type: "text", text: `Success: ${response.data.message}` }] };
+        return { content: [{ type: "text", text: `Success: Memory stored. ${storeRes.reason}` }] };
     }
     catch (e) {
         logError("store_memory", e);
-        return { content: [{ type: "text", text: `Failed to store memory in Lemma: ${e.message}. Is Lemma Proxy running?` }] };
+        return { content: [{ type: "text", text: `Failed to store memory in local Brain: ${e.message}` }] };
     }
 }
 async function handleGetRoutingAdvice(args) {
@@ -1211,24 +1313,20 @@ async function handleQueryHybridConsensus(args) {
     const threshold = typeof args?.threshold === "number" ? args.threshold : 0.8;
     if (!query)
         throw new Error("query is required");
-    const port = getProxyPort();
     const fullQuery = context ? `${query}\n\nContext: ${context}` : query;
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(fullQuery)}&limit=3`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(fullQuery, 3);
         const topHit = results[0];
         if (topHit && topHit.similarity >= threshold) {
-            const savedTokens = Math.floor((topHit.response?.choices?.[0]?.message?.content?.length || 500) / 4);
+            const savedTokens = Math.floor((topHit.response?.length || 500) / 4);
             reportSavings({
                 source: "cache",
                 tokens: savedTokens,
                 toolName: "query_hybrid_consensus",
                 query: query.substring(0, 100),
             });
-            const responseText = typeof topHit.response === "string"
-                ? topHit.response
-                : topHit.response?.choices?.[0]?.message?.content ||
-                    JSON.stringify(topHit.response, null, 2);
+            const responseText = topHit.response;
             return {
                 content: [
                     {
@@ -1254,7 +1352,7 @@ async function handleQueryHybridConsensus(args) {
         logError("query_hybrid_consensus", e);
         return {
             content: [
-                { type: "text", text: `Hybrid Consensus failed: ${e.message}. Is Lemma Proxy running?` },
+                { type: "text", text: `Hybrid Consensus failed: ${e.message}` },
             ],
         };
     }
@@ -1265,7 +1363,6 @@ async function handleGetTelepathicHints(args) {
     const limit = typeof args?.limit === "number" ? args.limit : 5;
     if (!activeFile)
         throw new Error("activeFile is required");
-    const port = getProxyPort();
     const basename = path.basename(activeFile, path.extname(activeFile));
     const dirContext = path
         .dirname(activeFile)
@@ -1276,8 +1373,8 @@ async function handleGetTelepathicHints(args) {
     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 || [];
+        const brain = getBrain();
+        const results = brain.search(telepathicQuery, limit);
         if (results.length === 0) {
             return {
                 content: [
@@ -1291,11 +1388,8 @@ async function handleGetTelepathicHints(args) {
         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);
+            const prompt = r.query || "Unknown";
+            const responseContent = r.response || "";
             hintsText += `### Hint ${i + 1} (${similarity}% match)\n`;
             hintsText += `**Memory:** ${prompt}\n\n`;
             hintsText += `${responseContent.substring(0, 400)}${responseContent.length > 400 ? "..." : ""}\n\n---\n\n`;
@@ -1315,7 +1409,7 @@ async function handleGetTelepathicHints(args) {
             content: [
                 {
                     type: "text",
-                    text: `Telepathic Hints failed: ${e.message}. Is Lemma Proxy running?`,
+                    text: `Telepathic Hints failed: ${e.message}`,
                 },
             ],
         };
@@ -1327,17 +1421,8 @@ async function handleSummarizeLongText(args) {
     const maxLength = args?.maxLength || 500;
     if (!text)
         throw new Error("text is required");
-    const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
-    const model = process.env.OLLAMA_GEN_MODEL || 'llama3';
     try {
-        const prompt = `TASK: Summarize the following text concisely. Max ${maxLength} characters. Focus on key facts, decisions, and action items.\n\nTEXT:\n${text}`;
-        const resp = await axios.post(`${host}/api/generate`, {
-            model,
-            prompt,
-            stream: false,
-            options: { temperature: 0.1, num_predict: maxLength * 2 },
-        });
-        const summary = resp.data.response.trim();
+        const summary = collapseContext(text, { maxLength });
         reportSavings({
             source: "contextSqueeze",
             charsBefore: text.length,
@@ -1348,7 +1433,7 @@ async function handleSummarizeLongText(args) {
     }
     catch (e) {
         logError("summarize_long_text", e);
-        return { content: [{ type: "text", text: `Summarization failed: ${e.message}. Is Ollama running?` }] };
+        return { content: [{ type: "text", text: `Summarization failed: ${e.message}` }] };
     }
 }
 // ── Prune Conversation History ──────────────────────────────────────
@@ -1497,21 +1582,14 @@ async function handleCompressContext(args) {
     const recent = messages.slice(-keepRecent);
     const old = messages.slice(0, -keepRecent);
     let summary = "";
-    let summaryMethod = "trim";
+    let summaryMethod = "local-collapser";
     try {
-        const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
-        const model = process.env.OLLAMA_GEN_MODEL || 'llama3';
-        const summaryPrompt = `Summarize the following conversation history into 2-3 concise sentences. Capture ONLY: key decisions made, code patterns established, unresolved issues. Be extremely brief.\n\n${JSON.stringify(old.map((m) => ({ role: m.role, content: typeof m.content === 'string' ? m.content.substring(0, 400) : '...' })))}`;
-        const resp = await axios.post(`${host}/api/generate`, {
-            model, prompt: summaryPrompt, stream: false,
-            options: { temperature: 0.1, num_predict: 300 },
-        });
-        summary = resp.data.response.trim();
-        summaryMethod = "ollama";
+        const oldText = old.map((m, i) => `[Turn ${i + 1} / ${m.role}]: ${typeof m.content === 'string' ? m.content : '...'}`).join('\n');
+        summary = collapseContext(oldText, { maxLength: 800 });
     }
-    catch {
+    catch (err) {
         summary = old.map((m, i) => `[Turn ${i + 1} / ${m.role}]: ${typeof m.content === 'string' ? m.content.substring(0, 150).replace(/\n/g, ' ') : '...'}`).join('\n').substring(0, 2000);
-        summaryMethod = "truncate";
+        summaryMethod = "truncate-fallback";
     }
     const oldLength = JSON.stringify(old).length;
     const summaryLength = summary.length;
@@ -1539,16 +1617,13 @@ async function handleSmarterCache(args) {
     const threshold = typeof args?.threshold === "number" ? args.threshold : 0.75;
     if (!query)
         throw new Error("query is required");
-    const port = getProxyPort();
     const fullQuery = context ? `${query}\n\nContext: ${context}` : query;
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(fullQuery)}&limit=5`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(fullQuery, 5);
         const topHit = results[0];
         if (topHit && topHit.similarity >= threshold) {
-            const responseText = typeof topHit.response === "string"
-                ? topHit.response
-                : topHit.response?.choices?.[0]?.message?.content || JSON.stringify(topHit.response, null, 2);
+            const responseText = topHit.response;
             const tokensSaved = Math.floor(responseText.length / 4);
             try {
                 const { reportSavings } = await import("../utils/reportSavings");
@@ -1593,7 +1668,7 @@ async function handleSmarterCache(args) {
                         hit: false,
                         error: e.message,
                         source: "cache-unavailable",
-                        hint: "Lemma Proxy no está corriendo. El LLM funcionará normalmente sin cache.",
+                        hint: "El cache local del brain falló. El LLM funcionará normalmente sin cache.",
                     }, null, 2),
                 }],
         };
@@ -2246,10 +2321,9 @@ async function handleSemanticDedupGuard(args) {
     const threshold = typeof args?.threshold === "number" ? args.threshold : 0.92;
     if (!query || !response)
         throw new Error("query and response are required");
-    const port = getProxyPort();
     try {
-        const searchRes = await axios.get(`http://localhost:${port}/api/search?q=${encodeURIComponent(query)}&limit=3`);
-        const results = searchRes.data.results || [];
+        const brain = getBrain();
+        const results = brain.search(query, 3);
         const topHit = results[0];
         if (!topHit) {
             return {
@@ -2260,17 +2334,18 @@ async function handleSemanticDedupGuard(args) {
                         }, null, 2) }],
             };
         }
-        const sim = topHit.similarity || 0;
+        let sim = topHit.similarity || 0;
+        if (topHit.query.trim().toLowerCase() === query.trim().toLowerCase()) {
+            sim = 1.0;
+        }
         if (sim >= threshold) {
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             verdict: "DUPLICATE_REJECTED",
                             reason: `Duplicado exacto detectado (${(sim * 100).toFixed(1)}% ≥ ${(threshold * 100).toFixed(0)}%). NO hagas store_memory — ya existe.`,
                             similarity: sim,
-                            existingQuery: typeof topHit.prompt === "string" ? topHit.prompt.substring(0, 200) : "N/A",
-                            existingResponse: (typeof topHit.response === "string"
-                                ? topHit.response
-                                : topHit.response?.choices?.[0]?.message?.content || "").substring(0, 300),
+                            existingQuery: typeof topHit.query === "string" ? topHit.query.substring(0, 200) : "N/A",
+                            existingResponse: (topHit.response || "").substring(0, 300),
                             tokensSaved: Math.floor(response.length / 4),
                         }, null, 2) }],
             };
@@ -2281,7 +2356,7 @@ async function handleSemanticDedupGuard(args) {
                             verdict: "SIMILAR_WARNING",
                             reason: `Contenido similar detectado (${(sim * 100).toFixed(1)}%). Decide si es distinto suficiente para guardar.`,
                             similarity: sim,
-                            existingQuery: typeof topHit.prompt === "string" ? topHit.prompt.substring(0, 200) : "N/A",
+                            existingQuery: typeof topHit.query === "string" ? topHit.query.substring(0, 200) : "N/A",
                             recommendation: "Si aporta info nueva → procede con store_memory. Si es redundante → descarta.",
                         }, null, 2) }],
             };
@@ -2299,7 +2374,7 @@ async function handleSemanticDedupGuard(args) {
         return {
             content: [{ type: "text", text: JSON.stringify({
                         verdict: "STORE_ALLOWED",
-                        reason: "No se pudo consultar The Brain (proxy no disponible). Procediendo con store.",
+                        reason: "El cache local del brain falló. Procediendo con store.",
                         error: e.message,
                     }, null, 2) }],
         };
@@ -2621,4 +2696,769 @@ function generateAzurePipelineYaml(threshold) {
         `      AZURE_DEVOPS_TOKEN: \$(AZURE_DEVOPS_TOKEN)`,
     ].join("\n");
 }
+function buildDepGraphMap(workspaceRoot) {
+    const map = new Map();
+    const IGNORE_DG = new Set(["node_modules", ".git", "dist", "chroma_data", ".lemma", "build", "coverage", ".next"]);
+    function walkDG(dir) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE_DG.has(e.name))
+                continue;
+            const abs = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walkDG(abs);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
+                const rel = path.relative(workspaceRoot, abs).replace(/\\/g, "/");
+                map.set(rel, { rel, abs, imports: [], importedBy: [], externalImports: [], exports: [] });
+            }
+        }
+    }
+    walkDG(workspaceRoot);
+    for (const [, node] of map) {
+        try {
+            const src = fs.readFileSync(node.abs, "utf8");
+            const sf = ts.createSourceFile(node.abs, src, ts.ScriptTarget.Latest, true);
+            ts.forEachChild(sf, (n) => {
+                if (ts.isImportDeclaration(n) && ts.isStringLiteral(n.moduleSpecifier)) {
+                    const spec = n.moduleSpecifier.text;
+                    if (spec.startsWith(".")) {
+                        const dir = path.dirname(node.abs);
+                        let resolved = path.resolve(dir, spec);
+                        for (const ext of [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"]) {
+                            if (fs.existsSync(resolved + ext)) {
+                                resolved += ext;
+                                break;
+                            }
+                        }
+                        const rel = path.relative(workspaceRoot, resolved).replace(/\\/g, "/");
+                        if (!node.imports.includes(rel))
+                            node.imports.push(rel);
+                    }
+                    else {
+                        const pkg = spec.split("/")[0];
+                        if (!node.externalImports.includes(pkg))
+                            node.externalImports.push(pkg);
+                    }
+                }
+                const hasExportMod = (nd) => ts.canHaveModifiers(nd) &&
+                    (ts.getModifiers(nd) ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+                if (hasExportMod(n)) {
+                    if (ts.isFunctionDeclaration(n) && n.name)
+                        node.exports.push(n.name.text);
+                    else if (ts.isClassDeclaration(n) && n.name)
+                        node.exports.push(n.name.text);
+                    else if (ts.isVariableStatement(n)) {
+                        for (const decl of n.declarationList.declarations) {
+                            if (ts.isIdentifier(decl.name))
+                                node.exports.push(decl.name.text);
+                        }
+                    }
+                    else if (ts.isInterfaceDeclaration(n))
+                        node.exports.push(n.name.text);
+                    else if (ts.isTypeAliasDeclaration(n))
+                        node.exports.push(n.name.text);
+                    else if (ts.isEnumDeclaration(n))
+                        node.exports.push(n.name.text);
+                }
+                if (ts.isExportDeclaration(n) && n.exportClause && ts.isNamedExports(n.exportClause)) {
+                    for (const el of n.exportClause.elements)
+                        node.exports.push(el.name.text);
+                }
+            });
+        }
+        catch { /* skip unparseable */ }
+    }
+    for (const [, node] of map) {
+        for (const imp of node.imports) {
+            const target = map.get(imp);
+            if (target && !target.importedBy.includes(node.rel))
+                target.importedBy.push(node.rel);
+        }
+    }
+    return map;
+}
+function bfsDepGraph(map, startRel, direction, maxDepth) {
+    const visited = new Map();
+    const queue = [{ rel: startRel, depth: 0 }];
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (visited.has(item.rel) || item.depth > maxDepth)
+            continue;
+        const node = map.get(item.rel);
+        if (!node)
+            continue;
+        visited.set(item.rel, { node, depth: item.depth });
+        if (item.depth < maxDepth) {
+            const neighbors = direction === "forward" ? node.imports : node.importedBy;
+            for (const n of neighbors)
+                queue.push({ rel: n, depth: item.depth + 1 });
+        }
+    }
+    return visited;
+}
+function detectDepCycles(map, subset) {
+    const cycles = [];
+    const visited = new Set();
+    const stack = new Set();
+    function dfs(rel, currentPath) {
+        if (stack.has(rel)) {
+            const idx = currentPath.indexOf(rel);
+            if (idx >= 0)
+                cycles.push([...currentPath.slice(idx), rel]);
+            return;
+        }
+        if (visited.has(rel))
+            return;
+        visited.add(rel);
+        stack.add(rel);
+        const node = map.get(rel);
+        if (node) {
+            for (const imp of node.imports) {
+                if (!subset || subset.has(imp))
+                    dfs(imp, [...currentPath, rel]);
+            }
+        }
+        stack.delete(rel);
+    }
+    const keys = subset ? [...subset] : [...map.keys()];
+    for (const k of keys)
+        dfs(k, []);
+    return cycles;
+}
+function formatDGText(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse) {
+    const lines = [`📦 ${targetNode.rel}`];
+    const directImports = targetNode.imports;
+    const externalImps = includeExternal ? targetNode.externalImports : [];
+    const allImports = [...directImports, ...externalImps];
+    if (allImports.length > 0) {
+        lines.push("├── importa:");
+        allImports.forEach((imp, i) => {
+            const isLast = i === allImports.length - 1;
+            const prefix = isLast ? "│   └──" : "│   ├──";
+            const isExt = externalImps.includes(imp);
+            if (isExt) {
+                lines.push(`${prefix} ${imp}  (external)`);
+            }
+            else {
+                const impNode = forwardVisited.get(imp)?.node;
+                const expSuffix = impNode && impNode.exports.length > 0
+                    ? `  → ${impNode.exports.slice(0, 3).join(", ")}${impNode.exports.length > 3 ? "…" : ""}`
+                    : "";
+                lines.push(`${prefix} ${imp}${expSuffix}`);
+                if (impNode && impNode.imports.length > 0) {
+                    impNode.imports.forEach((subImp, si) => {
+                        const subPrefix = si === impNode.imports.length - 1 ? "│       └──" : "│       ├──";
+                        if (subImp !== targetNode.rel)
+                            lines.push(`${subPrefix} ${subImp}`);
+                    });
+                }
+            }
+        });
+    }
+    else {
+        lines.push("├── importa: (ninguno)");
+    }
+    if (showReverse) {
+        const revDeps = targetNode.importedBy;
+        if (revDeps.length > 0) {
+            lines.push("├── es importado por:");
+            revDeps.forEach((dep, i) => {
+                const prefix = i === revDeps.length - 1 ? "│   └──" : "│   ├──";
+                lines.push(`${prefix} ${dep}`);
+                const depNode = backwardVisited.get(dep)?.node;
+                if (depNode && depNode.importedBy.length > 0) {
+                    depNode.importedBy.forEach((subDep, si) => {
+                        const subPrefix = si === depNode.importedBy.length - 1 ? "│       └──" : "│       ├──";
+                        if (subDep !== targetNode.rel)
+                            lines.push(`${subPrefix} ${subDep}`);
+                    });
+                }
+            });
+        }
+        else {
+            lines.push("├── es importado por: (nadie — posible dead export)");
+        }
+    }
+    if (targetNode.exports.length > 0) {
+        lines.push("└── exporta:");
+        targetNode.exports.forEach((exp, i) => {
+            const prefix = i === targetNode.exports.length - 1 ? "    └──" : "    ├──";
+            lines.push(`${prefix} ${exp}`);
+        });
+    }
+    else {
+        lines.push("└── exporta: (ningún export detectado)");
+    }
+    if (cycles.length > 0) {
+        lines.push("");
+        lines.push("⚠️  DEPENDENCIAS CIRCULARES DETECTADAS:");
+        cycles.slice(0, 5).forEach((c) => lines.push(`  🔄 ${c.join(" → ")}`));
+    }
+    return lines.join("\n");
+}
+function formatDGMermaid(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse) {
+    const lines = ["flowchart LR"];
+    const addedEdges = new Set();
+    const safeId = (s) => s.replace(/[^a-zA-Z0-9_]/g, "_");
+    const tid = safeId(targetNode.rel);
+    lines.push(`  ${tid}["📦 ${path.basename(targetNode.rel)}"]`);
+    lines.push(`  style ${tid} fill:#6366f1,color:#fff,stroke:#4f46e5`);
+    for (const imp of targetNode.imports) {
+        const eid = `${tid}-->${safeId(imp)}`;
+        if (!addedEdges.has(eid)) {
+            addedEdges.add(eid);
+            lines.push(`  ${tid} --> ${safeId(imp)}["${path.basename(imp)}"]`);
+        }
+    }
+    if (includeExternal) {
+        for (const ext of targetNode.externalImports) {
+            const extId = safeId(`ext_${ext}`);
+            lines.push(`  ${tid} --> ${extId}["📦 ${ext}"]`);
+            lines.push(`  style ${extId} fill:#374151,color:#9ca3af,stroke:#374151`);
+        }
+    }
+    for (const [rel, { node }] of forwardVisited) {
+        if (rel === targetNode.rel)
+            continue;
+        for (const imp of node.imports) {
+            const eid = `${safeId(rel)}-->${safeId(imp)}`;
+            if (!addedEdges.has(eid)) {
+                addedEdges.add(eid);
+                lines.push(`  ${safeId(rel)} --> ${safeId(imp)}["${path.basename(imp)}"]`);
+            }
+        }
+    }
+    if (showReverse) {
+        for (const dep of targetNode.importedBy) {
+            const eid = `${safeId(dep)}-->${tid}`;
+            if (!addedEdges.has(eid)) {
+                addedEdges.add(eid);
+                lines.push(`  ${safeId(dep)}["${path.basename(dep)}"] --> ${tid}`);
+                lines.push(`  style ${safeId(dep)} fill:#065f46,color:#fff,stroke:#047857`);
+            }
+        }
+        for (const [rel, { node }] of backwardVisited) {
+            if (rel === targetNode.rel)
+                continue;
+            for (const dep of node.importedBy) {
+                const eid = `${safeId(dep)}-->${safeId(rel)}`;
+                if (!addedEdges.has(eid)) {
+                    addedEdges.add(eid);
+                    lines.push(`  ${safeId(dep)}["${path.basename(dep)}"] --> ${safeId(rel)}["${path.basename(rel)}"]`);
+                }
+            }
+        }
+    }
+    if (cycles.length > 0) {
+        lines.push(`  %% ⚠️ Cycles: ${cycles.length}`);
+        cycles.slice(0, 3).forEach(c => lines.push(`  %% ${c.join(" → ")}`));
+    }
+    return lines.join("\n");
+}
+async function handleDepgraph(args) {
+    const filePath = args?.filePath;
+    const showReverse = args?.reverse !== false;
+    const depth = Math.min(Math.max(typeof args?.depth === "number" ? args.depth : 1, 1), 5);
+    const format = args?.format || "text";
+    const includeExternal = !!(args?.external);
+    const detectCircular = !!(args?.circular);
+    const workspaceRoot = process.cwd();
+    if (!filePath)
+        throw new Error("filePath is required");
+    try {
+        const { resolved } = safeResolvePath(workspaceRoot, filePath);
+        const relTarget = path.relative(workspaceRoot, resolved).replace(/\\/g, "/");
+        const map = buildDepGraphMap(workspaceRoot);
+        const targetNode = map.get(relTarget);
+        if (!targetNode) {
+            return { content: [{ type: "text", text: `File not found in workspace graph: ${relTarget}\nCheck path is correct and has .ts/.tsx/.js/.jsx extension.` }] };
+        }
+        const forwardVisited = bfsDepGraph(map, relTarget, "forward", depth);
+        const backwardVisited = showReverse ? bfsDepGraph(map, relTarget, "backward", depth) : new Map();
+        const allRelInScope = new Set([...forwardVisited.keys(), ...(showReverse ? backwardVisited.keys() : [])]);
+        const cycles = detectCircular ? detectDepCycles(map, allRelInScope) : [];
+        let output;
+        if (format === "json") {
+            const jsonResult = {
+                target: relTarget,
+                imports: targetNode.imports,
+                importedBy: showReverse ? targetNode.importedBy : undefined,
+                externalImports: includeExternal ? targetNode.externalImports : undefined,
+                exports: targetNode.exports,
+                cycles: cycles.length > 0 ? cycles : undefined,
+                subGraph: {
+                    forward: Object.fromEntries([...forwardVisited.entries()].map(([k, v]) => [k, { depth: v.depth, imports: v.node.imports }])),
+                    backward: showReverse ? Object.fromEntries([...backwardVisited.entries()].map(([k, v]) => [k, { depth: v.depth, importedBy: v.node.importedBy }])) : undefined,
+                },
+            };
+            output = JSON.stringify(jsonResult, null, 2);
+        }
+        else if (format === "mermaid") {
+            output = formatDGMermaid(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse);
+        }
+        else {
+            output = formatDGText(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse);
+        }
+        const stats = `\n\n📊 Stats: ${forwardVisited.size} nodos forward, ${backwardVisited.size} nodos reverse, depth=${depth}`;
+        return { content: [{ type: "text", text: output + (format === "json" ? "" : stats) }] };
+    }
+    catch (err) {
+        logError("depgraph", err);
+        return { content: [{ type: "text", text: `depgraph failed: ${err.message}` }] };
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// ─── refactor ─────────────────────────────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════════
+function escapeRegexStr(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findSymbolRefs(workspaceRoot, symbolName) {
+    const results = [];
+    const IGNORE_RF = new Set(["node_modules", ".git", "dist", "chroma_data", ".lemma", "build", "coverage", ".next"]);
+    function walkRF(dir) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE_RF.has(e.name))
+                continue;
+            const abs = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walkRF(abs);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
+                const rel = path.relative(workspaceRoot, abs).replace(/\\/g, "/");
+                try {
+                    const content = fs.readFileSync(abs, "utf8");
+                    if (!content.includes(symbolName))
+                        continue;
+                    const sf = ts.createSourceFile(abs, content, ts.ScriptTarget.Latest, true);
+                    const contentLines = content.split("\n");
+                    const identifierLines = new Set();
+                    function collectIdents(node) {
+                        if (ts.isIdentifier(node) && node.text === symbolName) {
+                            const { line } = sf.getLineAndCharacterOfPosition(node.getStart());
+                            identifierLines.add(line);
+                        }
+                        ts.forEachChild(node, collectIdents);
+                    }
+                    collectIdents(sf);
+                    const matchingLines = [...identifierLines].map(li => ({ lineIndex: li, lineContent: contentLines[li] ?? "" }));
+                    if (matchingLines.length > 0)
+                        results.push({ abs, rel, lines: matchingLines });
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    walkRF(workspaceRoot);
+    return results;
+}
+function applySymbolRenameInContent(content, fromName, toName) {
+    const regex = new RegExp(`(?<![a-zA-Z0-9_$])${escapeRegexStr(fromName)}(?![a-zA-Z0-9_$])`, "g");
+    return content.replace(regex, toName);
+}
+function buildUnifiedDiff(filePath, before, after) {
+    if (before === after)
+        return "";
+    const bl = before.split("\n");
+    const al = after.split("\n");
+    const diffLines = [`--- a/${filePath}`, `+++ b/${filePath}`];
+    const changed = new Set();
+    const maxLen = Math.max(bl.length, al.length);
+    for (let i = 0; i < maxLen; i++) {
+        if (bl[i] !== al[i])
+            changed.add(i);
+    }
+    let i = 0;
+    while (i < maxLen) {
+        if (!changed.has(i)) {
+            i++;
+            continue;
+        }
+        const hunkStart = Math.max(0, i - 2);
+        let hunkEnd = i + 1;
+        while (hunkEnd < maxLen && changed.has(hunkEnd))
+            hunkEnd++;
+        hunkEnd = Math.min(maxLen, hunkEnd + 2);
+        const bc = Math.min(hunkEnd, bl.length) - hunkStart;
+        const ac = Math.min(hunkEnd, al.length) - hunkStart;
+        diffLines.push(`@@ -${hunkStart + 1},${bc} +${hunkStart + 1},${ac} @@`);
+        for (let j = hunkStart; j < hunkEnd; j++) {
+            if (j >= maxLen)
+                break;
+            if (changed.has(j)) {
+                if (j < bl.length)
+                    diffLines.push(`-${bl[j]}`);
+                if (j < al.length)
+                    diffLines.push(`+${al[j]}`);
+            }
+            else {
+                if (j < bl.length)
+                    diffLines.push(` ${bl[j]}`);
+            }
+        }
+        i = hunkEnd;
+    }
+    return diffLines.join("\n");
+}
+async function handleRefactorRename(args, workspaceRoot) {
+    const fromName = args.from;
+    const toName = args.to;
+    const dryRun = !!(args.dryRun);
+    const tscCheck = !!(args.tscCheck);
+    const backup = !!(args.backup);
+    if (!fromName || !toName)
+        throw new Error("'from' and 'to' are required for rename");
+    const refs = findSymbolRefs(workspaceRoot, fromName);
+    if (refs.length === 0) {
+        return { content: [{ type: "text", text: `No references found to symbol "${fromName}" in the workspace.` }] };
+    }
+    let filesModified = 0;
+    let totalRefs = 0;
+    const report = [];
+    const diffs = [];
+    for (const ref of refs) {
+        const before = fs.readFileSync(ref.abs, "utf8");
+        const after = applySymbolRenameInContent(before, fromName, toName);
+        if (before === after)
+            continue;
+        const count = (before.match(new RegExp(`(?<![a-zA-Z0-9_$])${escapeRegexStr(fromName)}(?![a-zA-Z0-9_$])`, "g")) || []).length;
+        totalRefs += count;
+        filesModified++;
+        if (dryRun) {
+            const d = buildUnifiedDiff(ref.rel, before, after);
+            if (d)
+                diffs.push(d);
+        }
+        else {
+            if (backup)
+                fs.writeFileSync(ref.abs + ".bak", before, "utf8");
+            fs.writeFileSync(ref.abs, after, "utf8");
+            report.push(`  ✅ ${ref.rel} (${count} refs)`);
+        }
+    }
+    if (dryRun) {
+        return { content: [{ type: "text", text: [`🔍 DRY RUN — Rename "${fromName}" → "${toName}"`, ``, `Archivos que cambiarían: ${filesModified} | Referencias: ${totalRefs}`, ``, `=== DIFF PREVIEW ===`, ...diffs].join("\n") }] };
+    }
+    let tscOutput = "";
+    if (tscCheck && filesModified > 0) {
+        try {
+            const out = execSync("npx tsc --noEmit 2>&1 | head -30 || true", { cwd: workspaceRoot, encoding: "utf8", timeout: 30000 });
+            const errors = out.split("\n").filter((l) => l.includes("error TS"));
+            tscOutput = errors.length === 0 ? "\n\n✅ tsc --noEmit: 0 errores" : `\n\n⚠️ tsc: ${errors.length} error(es):\n${errors.join("\n")}`;
+        }
+        catch (e) {
+            tscOutput = `\n\n⚠️ tsc check falló: ${e.message}`;
+        }
+    }
+    return { content: [{ type: "text", text: [`✅ Rename: "${fromName}" → "${toName}"`, ``, `📁 ${filesModified} archivos | 🔗 ${totalRefs} refs`, ``, ...report].join("\n") + tscOutput }] };
+}
+async function handleRefactorMove(args, workspaceRoot) {
+    const fromRel = args.from;
+    const toRel = args.to;
+    const dryRun = !!(args.dryRun);
+    const tscCheck = !!(args.tscCheck);
+    const backup = !!(args.backup);
+    const { resolved: fromAbs } = safeResolvePath(workspaceRoot, fromRel);
+    const toAbs = path.resolve(workspaceRoot, toRel);
+    const fromRelNorm = path.relative(workspaceRoot, fromAbs).replace(/\\/g, "/");
+    const toRelNorm = path.relative(workspaceRoot, toAbs).replace(/\\/g, "/");
+    if (!fs.existsSync(fromAbs)) {
+        return { content: [{ type: "text", text: `Source file not found: ${fromRelNorm}` }] };
+    }
+    const IGNORE_MV = new Set(["node_modules", ".git", "dist", "chroma_data", ".lemma", "build", "coverage", ".next"]);
+    const importers = [];
+    function walkMV(dir) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE_MV.has(e.name))
+                continue;
+            const abs = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walkMV(abs);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
+                const rel = path.relative(workspaceRoot, abs).replace(/\\/g, "/");
+                if (rel === fromRelNorm)
+                    return;
+                try {
+                    const content = fs.readFileSync(abs, "utf8");
+                    const sf = ts.createSourceFile(abs, content, ts.ScriptTarget.Latest, true);
+                    let found = false;
+                    ts.forEachChild(sf, (n) => {
+                        if (!found && ts.isImportDeclaration(n) && ts.isStringLiteral(n.moduleSpecifier)) {
+                            const spec = n.moduleSpecifier.text;
+                            if (spec.startsWith(".")) {
+                                const res = path.resolve(path.dirname(abs), spec).replace(/\\/g, "/");
+                                const fromN = fromAbs.replace(/\\/g, "/");
+                                const fromNoExt = fromN.replace(/\.(ts|tsx|js|jsx)$/, "");
+                                if (res === fromN || res === fromNoExt)
+                                    found = true;
+                            }
+                        }
+                    });
+                    if (found)
+                        importers.push({ abs, rel, content });
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    walkMV(workspaceRoot);
+    const addDot = (p) => p.startsWith(".") ? p : `./${p}`;
+    const patches = [];
+    for (const imp of importers) {
+        const oldRelImport = path.relative(path.dirname(imp.abs), fromAbs).replace(/\\/g, "/");
+        const newRelImport = path.relative(path.dirname(imp.abs), toAbs).replace(/\\/g, "/");
+        const oldSpec = addDot(oldRelImport.replace(/\.(ts|tsx|js|jsx)$/, ""));
+        const newSpec = addDot(newRelImport.replace(/\.(ts|tsx|js|jsx)$/, ""));
+        const after = imp.content.replace(new RegExp(`(['"])${escapeRegexStr(oldSpec)}(['"])`, "g"), `$1${newSpec}$2`);
+        if (after !== imp.content)
+            patches.push({ rel: imp.rel, abs: imp.abs, before: imp.content, after });
+    }
+    if (dryRun) {
+        const diffs = patches.map(p => buildUnifiedDiff(p.rel, p.before, p.after)).filter(Boolean);
+        return { content: [{ type: "text", text: [`🔍 DRY RUN — Move "${fromRelNorm}" → "${toRelNorm}"`, ``, `Importadores que se actualizarían: ${patches.length}`, ``, `=== DIFF PREVIEW ===`, ...diffs].join("\n") }] };
+    }
+    fs.mkdirSync(path.dirname(toAbs), { recursive: true });
+    if (backup)
+        fs.copyFileSync(fromAbs, fromAbs + ".bak");
+    fs.copyFileSync(fromAbs, toAbs);
+    fs.unlinkSync(fromAbs);
+    for (const p of patches) {
+        if (backup)
+            fs.writeFileSync(p.abs + ".bak", p.before, "utf8");
+        fs.writeFileSync(p.abs, p.after, "utf8");
+    }
+    let tscOutput = "";
+    if (tscCheck) {
+        try {
+            const out = execSync("npx tsc --noEmit 2>&1 | head -30 || true", { cwd: workspaceRoot, encoding: "utf8", timeout: 30000 });
+            const errors = out.split("\n").filter((l) => l.includes("error TS"));
+            tscOutput = errors.length === 0 ? "\n\n✅ tsc --noEmit: 0 errores" : `\n\n⚠️ tsc: ${errors.length} error(es):\n${errors.join("\n")}`;
+        }
+        catch (e) {
+            tscOutput = `\n\n⚠️ tsc check falló: ${e.message}`;
+        }
+    }
+    return { content: [{ type: "text", text: [`✅ Move: "${fromRelNorm}" → "${toRelNorm}"`, ``, `📁 ${patches.length} importadores actualizados:`, ...patches.map(p => `  ✅ ${p.rel}`)].join("\n") + tscOutput }] };
+}
+async function handleRefactor(args) {
+    const operation = args?.operation;
+    const workspaceRoot = process.cwd();
+    if (!operation)
+        throw new Error("'operation' is required (rename | move)");
+    try {
+        switch (operation) {
+            case "rename": return await handleRefactorRename(args, workspaceRoot);
+            case "move": return await handleRefactorMove(args, workspaceRoot);
+            default:
+                return { content: [{ type: "text", text: `Unknown operation: "${operation}". Supported: rename, move` }] };
+        }
+    }
+    catch (err) {
+        logError("refactor", err);
+        return { content: [{ type: "text", text: `refactor failed: ${err.message}` }] };
+    }
+}
+// ── Surgical Symbol Context ──────────────────────────────────────────
+async function handleGetSymbolSurgicalContext(args) {
+    const filePath = args?.filePath;
+    const symbolName = args?.symbolName;
+    if (!filePath || !symbolName)
+        throw new Error("filePath and symbolName are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const res = getSymbolSurgicalContext(workspaceRoot, filePath, symbolName);
+        const lines = [];
+        lines.push(`# 🧬 Surgical Context: Symbol \`${symbolName}\` in \`${filePath}\``);
+        lines.push(`## Implementation`);
+        lines.push(`\`\`\`typescript\n${res.implementation}\n\`\`\``);
+        if (res.dependencies.length > 0) {
+            lines.push(`## Workspace Dependencies (Signatures ONLY)`);
+            for (const dep of res.dependencies) {
+                lines.push(`### \`${dep.name}\` (${dep.type}) declared in \`${dep.filePath}\``);
+                lines.push(`\`\`\`typescript\n${dep.signature}\n\`\`\``);
+            }
+        }
+        else {
+            lines.push(`*No local workspace dependencies detected for this symbol.*`);
+        }
+        const output = lines.join("\n\n");
+        const originalSize = fs.readFileSync(path.resolve(workspaceRoot, filePath), "utf8").length;
+        const totalRawSize = originalSize + res.dependencies.reduce((sum, dep) => {
+            try {
+                return sum + fs.readFileSync(path.resolve(workspaceRoot, dep.filePath), "utf8").length;
+            }
+            catch {
+                return sum;
+            }
+        }, 0);
+        reportSavings({
+            source: "contextSqueeze",
+            charsBefore: totalRawSize,
+            charsAfter: output.length,
+            toolName: "get_symbol_surgical_context",
+            filePath
+        });
+        return {
+            content: [{ type: "text", text: output }]
+        };
+    }
+    catch (err) {
+        logError("get_symbol_surgical_context", err);
+        return {
+            content: [{ type: "text", text: `Surgical context extraction failed: ${err.message}` }]
+        };
+    }
+}
+// ── Wormhole Squeeze ────────────────────────────────────────────────
+async function handleWormholeSqueeze(args) {
+    const text = args?.text;
+    if (!text)
+        throw new Error("text is required");
+    try {
+        const compressed = compressWormhole(text);
+        reportSavings({
+            source: "contextSqueeze",
+            charsBefore: text.length,
+            charsAfter: compressed.length,
+            toolName: "wormhole_squeeze"
+        });
+        return {
+            content: [{ type: "text", text: compressed }]
+        };
+    }
+    catch (err) {
+        logError("wormhole_squeeze", err);
+        return {
+            content: [{ type: "text", text: `Wormhole compression failed: ${err.message}` }]
+        };
+    }
+}
+// ── Executive ROI Report ──────────────────────────────────────────────
+async function handleGenerateExecutiveRoiReport(args) {
+    const teamSize = typeof args?.teamSize === "number" ? args.teamSize : 10;
+    const costPerDevHour = typeof args?.costPerDevHour === "number" ? args.costPerDevHour : 50;
+    const targetPath = args?.targetPath || "LEMMA_ROI_REPORT.md";
+    const workspaceRoot = process.cwd();
+    try {
+        const res = generateExecutiveReport(workspaceRoot, {
+            teamSize,
+            costPerDevHour,
+            targetPath
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Success: ROI Report generated at ${targetPath}.\n\nTotal Business Value Saved: $${res.metrics.totalBusinessValue.toFixed(2)} USD\nEstimated Dev Time Saved: ${res.metrics.devHoursSaved} Hours\nDirect API Cost Saved: $${res.metrics.totalCostSaved.toFixed(4)} USD`
+                }]
+        };
+    }
+    catch (err) {
+        logError("generate_executive_roi_report", err);
+        return {
+            content: [{ type: "text", text: `ROI Report generation failed: ${err.message}` }]
+        };
+    }
+}
+// ── Surgical AST Insert ──────────────────────────────────────────────
+async function handleSurgicalAstInsert(args) {
+    const filePath = args?.filePath;
+    const symbolName = args?.symbolName;
+    const anchorSymbol = args?.anchorSymbol;
+    const insertPosition = args?.insertPosition;
+    const codeToInsert = args?.codeToInsert;
+    if (!filePath || !codeToInsert)
+        throw new Error("filePath and codeToInsert are required");
+    const workspaceRoot = process.cwd();
+    try {
+        const resolvedPath = surgicalASTInsert(workspaceRoot, {
+            filePath,
+            symbolName,
+            anchorSymbol,
+            insertPosition,
+            codeToInsert
+        });
+        const newTextSize = fs.readFileSync(resolvedPath, "utf8").length;
+        const outputCharsSaved = Math.max(0, newTextSize - codeToInsert.length);
+        const tokensSaved = Math.floor(outputCharsSaved / 4);
+        reportSavings({
+            source: "contextSqueeze",
+            tokens: tokensSaved,
+            toolName: "surgical_ast_insert",
+            filePath
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Success: Surgically inserted code into ${filePath} using AST compiler.`
+                }]
+        };
+    }
+    catch (err) {
+        logError("surgical_ast_insert", err);
+        return {
+            content: [{ type: "text", text: `Surgical AST insertion failed: ${err.message}` }]
+        };
+    }
+}
+// ── Local Semantic Autofix ────────────────────────────────────────────
+async function handleLocalSemanticAutofix(args) {
+    const errorMessage = args?.errorMessage;
+    if (!errorMessage)
+        throw new Error("errorMessage is required");
+    try {
+        const brain = getBrain();
+        const results = brain.search(errorMessage, 3, 0.70);
+        const topHit = results[0];
+        if (topHit) {
+            const responseText = topHit.response;
+            const tokensSaved = Math.max(100, Math.floor(responseText.length / 4));
+            reportSavings({
+                source: "cache",
+                tokens: tokensSaved,
+                toolName: "local_semantic_autofix",
+                query: errorMessage.substring(0, 100)
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `🎯 Local Auto-Fix HIT (similarity: ${(topHit.similarity * 100).toFixed(1)}%)\n\nFound matching resolution in global memory. Cost: 0 tokens.\n\n---\n\n${responseText}`
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Brain MISS (No matching resolutions for this error in local memory).\n\nPlease proceed to ask the LLM for guidance. Once resolved, make sure to call store_memory with:\n- query: "[Error description/traceback]"\n- response: "[Exact code patch or steps used to fix]"\n\nThis will allow resolving this error instantly with 0 tokens next time!`
+                }]
+        };
+    }
+    catch (err) {
+        logError("local_semantic_autofix", err);
+        return {
+            content: [{ type: "text", text: `Local auto-fix failed: ${err.message}` }]
+        };
+    }
+}
 //# sourceMappingURL=tools.js.map