cortex-mcp 1.2.4 → 1.4.1

package/dist/server/mcp-handler.js

@@ -26,6 +26,20 @@ const rate_limiter_1 = require("../security/rate-limiter");
 const feature_gate_1 = require("../security/feature-gate");
 const export_import_1 = require("../memory/export-import");
 const llm_enhancer_1 = require("../memory/llm-enhancer");
+const usage_stats_1 = require("../memory/usage-stats");
+const correction_detector_1 = require("../memory/correction-detector");
+const pre_flight_1 = require("../memory/pre-flight");
+const impact_analyzer_1 = require("../memory/impact-analyzer");
+const resume_work_1 = require("../memory/resume-work");
+const preference_learner_1 = require("../memory/preference-learner");
+const convention_detector_1 = require("../memory/convention-detector");
+const export_map_2 = require("../scanners/export-map");
+const error_learner_1 = require("../memory/error-learner");
+const success_tracker_1 = require("../memory/success-tracker");
+const file_relationships_1 = require("../memory/file-relationships");
+const instructions_generator_1 = require("../memory/instructions-generator");
+const tool_recommender_1 = require("../memory/tool-recommender");
+const regression_guard_1 = require("../memory/regression-guard");
 // --- Query Expansion (Synonym Map) ---
 const SYNONYMS = {
     auth: ['authentication', 'login', 'signin', 'sign-in', 'credentials'],
@@ -238,6 +252,48 @@ const MCP_TOOLS = [
             properties: {},
         },
     },
+    {
+        name: 'review_code',
+        description: 'Review code against your stored conventions, past bug patterns, and project decisions. Returns specific violations with memory references — like having a senior dev review your code.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'The code to review' },
+                filename: { type: 'string', description: 'Optional filename for context-aware review' },
+            },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'pre_check',
+        description: 'Pre-flight check: get ALL conventions, gotchas, past bugs, and corrections for a file BEFORE writing code. Like a pilot\'s checklist — call this before making any code changes to avoid repeating past mistakes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filename: { type: 'string', description: 'The file you are about to edit' },
+                task: { type: 'string', description: 'What you plan to do (helps find relevant past failures)' },
+            },
+        },
+    },
+    {
+        name: 'check_impact',
+        description: 'Impact analysis: before editing a file, check which other files depend on it. Shows direct and indirect dependents with risk level. Prevents breaking changes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'The file you plan to modify' },
+            },
+            required: ['file'],
+        },
+    },
+    {
+        name: 'resume_work',
+        description: 'Resume work after a conversation break. Returns: last session summary, current tasks, recent corrections (don\'t repeat!), recent decisions, and activity summary. Call this when starting a new conversation about ongoing work.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
 ];
 // --- Dynamic Context via ContextBuilder ---
 let cachedContextBuilder = null;
@@ -258,8 +314,8 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     id,
                     result: {
                         protocolVersion: '2024-11-05',
-                        capabilities: { tools: {}, resources: {} },
-                        serverInfo: { name: 'cortex', version: '2.0.0' },
+                        capabilities: { tools: {}, resources: {}, prompts: {} },
+                        serverInfo: { name: 'Cortex', version: '2.0.0' },
                     },
                 };
             case 'notifications/initialized':
@@ -277,7 +333,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     result: {
                         resources: [{
                                 uri: 'memory://brain/context',
-                                name: 'Brain Context',
+                                name: 'Cortex MCP Context',
                                 description: 'Top memories — corrections, decisions, conventions. Read this before every response.',
                                 mimeType: 'text/plain',
                             }],
@@ -304,6 +360,97 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     error: { code: -32602, message: `Unknown resource: ${uri}` },
                 };
             }
+            case 'prompts/list':
+                return {
+                    jsonrpc: '2.0', id,
+                    result: {
+                        prompts: [
+                            {
+                                name: 'cortex-review',
+                                description: 'Review code against stored conventions, past bugs, and project decisions. Returns specific violations.',
+                                arguments: [
+                                    { name: 'code', description: 'The code to review', required: true },
+                                    { name: 'filename', description: 'Filename for context-aware review', required: false },
+                                ],
+                            },
+                            {
+                                name: 'cortex-debug',
+                                description: 'Debug an issue using Cortex memory. Checks for similar past bugs, failed attempts, and gotchas.',
+                                arguments: [
+                                    { name: 'error', description: 'The error message or issue description', required: true },
+                                    { name: 'file', description: 'The file where the error occurs', required: false },
+                                ],
+                            },
+                            {
+                                name: 'cortex-new-feature',
+                                description: 'Pre-flight checklist before building a new feature. Gets conventions, gotchas, and architecture context.',
+                                arguments: [
+                                    { name: 'feature', description: 'What feature you plan to build', required: true },
+                                    { name: 'files', description: 'Files you plan to modify', required: false },
+                                ],
+                            },
+                        ],
+                    },
+                };
+            case 'prompts/get': {
+                const promptName = rpc.params?.name;
+                const promptArgs = rpc.params?.arguments || {};
+                if (promptName === 'cortex-review') {
+                    return {
+                        jsonrpc: '2.0', id,
+                        result: {
+                            description: 'Code review against Cortex memory',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `Review this code against all stored conventions, past bug patterns, and project decisions.\n\nFile: ${promptArgs.filename || 'unknown'}\n\n\`\`\`\n${promptArgs.code || '(no code provided)'}\n\`\`\`\n\nUse the review_code and pre_check tools to check against stored memory. Report any violations with memory IDs.`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                if (promptName === 'cortex-debug') {
+                    return {
+                        jsonrpc: '2.0', id,
+                        result: {
+                            description: 'Debug with Cortex memory context',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `I'm debugging this issue:\n\n${promptArgs.error || '(no error provided)'}\n\nFile: ${promptArgs.file || 'unknown'}\n\nUse recall_memory to search for similar past bugs, failed attempts, and gotchas. Check if this matches any known patterns. Use check_impact to see what other files might be affected.`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                if (promptName === 'cortex-new-feature') {
+                    return {
+                        jsonrpc: '2.0', id,
+                        result: {
+                            description: 'New feature pre-flight checklist',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `I'm building a new feature: ${promptArgs.feature || '(no feature described)'}\n\nFiles I plan to modify: ${promptArgs.files || 'unknown'}\n\nBefore I start, run pre_check for each file, check_impact for dependency risks, and recall_memory for any relevant past work. Give me a checklist of things to watch out for.`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                return {
+                    jsonrpc: '2.0', id,
+                    error: { code: -32602, message: `Unknown prompt: ${promptName}` },
+                };
+            }
             case 'tools/call': {
                 const toolName = rpc.params?.name;
                 const args = rpc.params?.arguments || {};
@@ -368,6 +515,18 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 else if (toolName === 'health_check') {
                     return handleHealthCheck(id);
                 }
+                else if (toolName === 'review_code') {
+                    return handleReviewCode(id, args);
+                }
+                else if (toolName === 'pre_check') {
+                    return handlePreCheck(id, args);
+                }
+                else if (toolName === 'check_impact') {
+                    return handleCheckImpact(id, args);
+                }
+                else if (toolName === 'resume_work') {
+                    return handleResumeWork(id);
+                }
                 else {
                     return {
                         jsonrpc: '2.0', id,
@@ -670,16 +829,46 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 extraMemories += (0, architecture_graph_1.storeArchitectureGraph)(memoryStore, archGraph);
             }
             catch { /* non-fatal */ }
+            // Convention auto-detection — analyze actual code patterns
+            try {
+                const conventions = (0, convention_detector_1.detectConventions)(root);
+                for (const conv of conventions) {
+                    try {
+                        (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                            type: 'CONVENTION',
+                            intent: conv.pattern,
+                            action: conv.evidence,
+                            reason: `Auto-detected from code (${conv.category}, confidence: ${conv.confidence})`,
+                            confidence: conv.confidence,
+                            importance: conv.confidence,
+                            tags: ['convention', 'auto-detected', conv.category],
+                        });
+                        extraMemories++;
+                    }
+                    catch { /* skip duplicates */ }
+                }
+            }
+            catch { /* non-fatal */ }
             (0, memory_cache_1.invalidateCache)();
+            (0, usage_stats_1.trackScan)();
             const total = count + extraMemories;
+            // Report knowledge gaps after scan
+            let gapReport = '';
+            try {
+                const gaps = (0, meta_memory_1.detectKnowledgeGaps)(memoryStore, root);
+                if (gaps.length > 0) {
+                    gapReport = `\n\n${(0, meta_memory_1.formatKnowledgeGaps)(gaps)}`;
+                }
+            }
+            catch { /* non-fatal */ }
             return {
                 jsonrpc: '2.0', id,
                 result: {
                     content: [{
                             type: 'text',
                             text: total > 0
-                                ? `Project scanned successfully. ${total} memories created (stack, structure, config, git history, export map, architecture graph).`
-                                : 'Project was already scanned. No new memories created.',
+                                ? `Project scanned successfully. ${total} memories created (stack, structure, config, git history, export map, architecture graph, coding conventions).${gapReport}`
+                                : `Project was already scanned. No new memories created.${gapReport}`,
                         }],
                 },
             };
@@ -755,6 +944,9 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             };
         }
         try {
+            // Track file for relationship mapping
+            if (args.filename)
+                (0, file_relationships_1.recordFileEdit)(args.filename);
             const result = (0, code_verifier_1.verifyCode)(args.code, root);
             const lines = [];
             // Imports
@@ -781,6 +973,20 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     for (const [file, available] of Object.entries(result.exports.available)) {
                         lines.push(`   ${file} exports: ${available.join(', ')}`);
                     }
+                    // Smart fix suggestions — find closest real exports
+                    try {
+                        const wsRoot = args.workspaceRoot || workspaceRoot;
+                        if (wsRoot) {
+                            const exportMap = (0, export_map_1.buildExportMap)(wsRoot);
+                            for (const invalid of result.exports.invalid) {
+                                const suggestions = (0, export_map_2.suggestRealExport)(exportMap, invalid);
+                                if (suggestions.length > 0) {
+                                    lines.push(`   💡 Did you mean: ${suggestions.slice(0, 3).join(', ')}?`);
+                                }
+                            }
+                        }
+                    }
+                    catch { /* non-fatal */ }
                 }
             }
             // Env vars
@@ -799,6 +1005,12 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             if (lines.length === 0) {
                 lines.push('No imports, exports, or env vars detected in the code.');
             }
+            // Track hallucination catches for usage stats
+            const catchCount = result.imports.invalid.length + result.exports.invalid.length + result.envVars.invalid.length;
+            if (catchCount > 0) {
+                for (let i = 0; i < catchCount; i++)
+                    (0, usage_stats_1.trackCatch)();
+            }
             return {
                 jsonrpc: '2.0', id,
                 result: { content: [{ type: 'text', text: lines.join('\n') }] },
@@ -892,9 +1104,37 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             const parts = [];
             // ─── BRAIN LAYER 0: End previous session + start new one ─────────
             (0, session_tracker_1.endSession)(memoryStore); // Save previous session summary
+            (0, file_relationships_1.storeRelationships)(memoryStore); // Persist file co-edit relationships
             (0, session_tracker_1.startSession)();
+            (0, usage_stats_1.resetSessionStats)();
             if (args.topic)
                 (0, session_tracker_1.feedSession)({ topic: args.topic });
+            // ─── BRAIN LAYER 0.5: Auto-scan on first run (Day 1 Empty Brain fix) ───
+            if (memoryStore.activeCount() === 0 && workspaceRoot) {
+                try {
+                    console.log(`  [AUTO-SCAN] First run detected — scanning project...`);
+                    const scanner = new project_scanner_1.ProjectScanner(memoryStore, workspaceRoot);
+                    const scanCount = await scanner.scan();
+                    let extraMemories = 0;
+                    try {
+                        extraMemories += (0, export_map_1.storeExportMap)(memoryStore, (0, export_map_1.buildExportMap)(workspaceRoot));
+                    }
+                    catch { }
+                    try {
+                        extraMemories += (0, architecture_graph_1.storeArchitectureGraph)(memoryStore, (0, architecture_graph_1.buildArchitectureGraph)(workspaceRoot));
+                    }
+                    catch { }
+                    const total = scanCount + extraMemories;
+                    if (total > 0) {
+                        parts.push(`## Welcome to Cortex\n\nFirst run detected — auto-scanned your project and created ${total} memories (stack, structure, config, git history, exports, architecture). Cortex will now remember everything across sessions.`);
+                        (0, memory_cache_1.invalidateCache)();
+                        (0, usage_stats_1.trackScan)();
+                    }
+                }
+                catch (scanErr) {
+                    console.log(`  [AUTO-SCAN] Failed: ${scanErr.message}`);
+                }
+            }
             // ─── BRAIN LAYER 1: Maintenance (runs in background) ─────────────
             try {
                 // Decay old unused memories
@@ -972,17 +1212,30 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                         return '';
                     }
                 })(),
-                // Layer 9: Topic Search (depends on actionContext but is safe to run in parallel)
+                // Layer 9: Topic Search — Hybrid (FTS + Vector) for deeper relevance
                 (async () => {
                     if (!args.topic)
                         return '';
                     try {
-                        let ftsResults = memoryStore.searchFTS(args.topic, 15);
-                        ftsResults = (0, confidence_decay_1.applyConfidenceDecay)(ftsResults);
-                        ftsResults = (0, attention_ranker_1.rankByAttention)(ftsResults, actionContext);
+                        // FTS search
+                        const ftsResults = memoryStore.searchFTS(args.topic, 15);
+                        // Vector search (semantic — catches what FTS misses)
+                        let vectorResults = [];
+                        if ((0, embedding_manager_1.isWorkerReady)()) {
+                            try {
+                                const topicEmbedding = await (0, embedding_manager_1.embedText)(args.topic);
+                                vectorResults = memoryStore.searchVector(new Float32Array(topicEmbedding), 10);
+                            }
+                            catch { /* vector search failure is non-fatal */ }
+                        }
+                        // Merge FTS + Vector, deduplicate by ID
+                        const merged = (0, memory_ranker_1.rankResults)(ftsResults, vectorResults, 20, args.currentFile);
+                        let ranked = merged.map(r => ({ ...r, matchMethod: 'hybrid' }));
+                        ranked = (0, confidence_decay_1.applyConfidenceDecay)(ranked);
+                        ranked = (0, attention_ranker_1.rankByAttention)(ranked, actionContext);
                         const seen = new Set();
                         const enriched = [];
-                        for (const r of ftsResults) {
+                        for (const r of ranked) {
                             if (seen.has(r.memory.id))
                                 continue;
                             seen.add(r.memory.id);
@@ -1052,13 +1305,58 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     parts.push('\n' + result.value);
                 }
             }
-            // ─── SMART CONTEXT SELECTION: Trim to token budget ───────────────
-            let output = parts.join('\n');
+            // ─── SMART CONTEXT SELECTION: Priority-based trimming ────────────
+            // Instead of dumb slicing, trim lowest-priority sections first
             const MAX_CHARS = 12000; // ~3000 tokens — fits any model
+            let output = parts.join('\n');
             if (output.length > MAX_CHARS) {
-                // Keep critical sections, trim lower-priority ones
-                output = output.slice(0, MAX_CHARS) + '\n\n> (Context trimmed to fit token budget. Use `recall_memory` for specific queries.)';
+                // Priority: highest first (kept), lowest first (trimmed)
+                // Layers 0-5 are high priority (welcome, sessions, corrections, core context)
+                // Layers 6-12 are lower priority (anticipation, temporal, git, topic, gaps, exports, arch)
+                // Trim from end (lowest priority) working backwards
+                while (output.length > MAX_CHARS && parts.length > 4) {
+                    parts.pop(); // Remove lowest-priority section
+                    output = parts.join('\n');
+                }
+                if (output.length > MAX_CHARS) {
+                    output = output.slice(0, MAX_CHARS);
+                }
+                output += '\n\n> (Some context trimmed to fit token budget. Use `recall_memory` for specific queries.)';
+            }
+            // Track usage stats
+            const memoriesInOutput = (output.match(/\[(?:CORRECTION|DECISION|CONVENTION|BUG_FIX|INSIGHT)\]/g) || []).length;
+            (0, usage_stats_1.trackRecall)(memoriesInOutput);
+            // Inject contextual instructions (DO/DON'T/WATCH-OUT)
+            try {
+                const instructions = (0, instructions_generator_1.generateInstructions)(memoryStore);
+                const instructionText = (0, instructions_generator_1.formatInstructions)(instructions);
+                if (instructionText)
+                    output += '\n\n' + instructionText;
             }
+            catch { /* non-fatal */ }
+            // Inject tool recommendations (what to use based on context)
+            try {
+                const recs = (0, tool_recommender_1.recommendTools)({
+                    topic: args.topic,
+                    currentFile: args.currentFile,
+                    isNewConversation: true,
+                });
+                const recText = (0, tool_recommender_1.formatRecommendations)(recs);
+                if (recText)
+                    output += '\n\n' + recText;
+            }
+            catch { /* non-fatal */ }
+            // Inject user preferences (adapts AI behavior)
+            try {
+                const prefText = (0, preference_learner_1.getStoredPreferences)(memoryStore);
+                if (prefText)
+                    output += '\n\n' + prefText;
+            }
+            catch { /* non-fatal */ }
+            // Append stats footer (makes value visible)
+            const statsFooter = (0, usage_stats_1.formatStatsFooter)();
+            if (statsFooter)
+                output += statsFooter;
             // Cache the result for short-lived reuse
             (0, memory_cache_1.setCache)(cacheKey, output);
             return {
@@ -1073,6 +1371,102 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             };
         }
     }
+    // ─── REVIEW CODE: Check against conventions + past bugs ─────────────
+    function handleReviewCode(id, args) {
+        try {
+            const code = args.code;
+            const filename = args.filename || '';
+            if (!code || code.length < 10) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: 'Error: provide code to review (min 10 chars)' }], isError: true },
+                };
+            }
+            const violations = [];
+            const suggestions = [];
+            const codeLower = code.toLowerCase();
+            // Check against stored CONVENTIONS
+            const conventions = memoryStore.getByType('CONVENTION', 100);
+            for (const conv of conventions) {
+                const intentLower = conv.intent.toLowerCase();
+                // Check for common pattern violations
+                if (intentLower.includes('never use') || intentLower.includes("don't use") || intentLower.includes('avoid')) {
+                    // Extract the forbidden thing
+                    const match = intentLower.match(/(?:never use|don't use|avoid)\s+(\w+(?:\s+\w+)?)/i);
+                    if (match) {
+                        const forbidden = match[1].toLowerCase();
+                        if (codeLower.includes(forbidden)) {
+                            violations.push(`⚠️ **Convention Violation** \`id:${conv.id}\`: "${conv.intent}" — Found \`${forbidden}\` in your code`);
+                        }
+                    }
+                }
+                if (intentLower.includes('always use') || intentLower.includes('must use')) {
+                    const match = intentLower.match(/(?:always use|must use)\s+(\w+(?:\s+\w+)?)/i);
+                    if (match) {
+                        const required = match[1].toLowerCase();
+                        if (!codeLower.includes(required) && code.length > 50) {
+                            suggestions.push(`💡 **Convention Suggestion** \`id:${conv.id}\`: "${conv.intent}" — Consider using \`${required}\``);
+                        }
+                    }
+                }
+            }
+            // Check against stored BUG_FIX patterns
+            const bugFixes = memoryStore.getByType('BUG_FIX', 50);
+            for (const bug of bugFixes) {
+                const bugLower = bug.intent.toLowerCase();
+                // Extract key terms from bug description
+                const bugTerms = bugLower.split(/\s+/).filter(w => w.length > 4);
+                const matchCount = bugTerms.filter(t => codeLower.includes(t)).length;
+                if (matchCount >= 3) {
+                    violations.push(`🐛 **Similar Bug Pattern** \`id:${bug.id}\`: "${bug.intent}" — This code has similarities to a past bug`);
+                }
+            }
+            // Check for CORRECTION patterns
+            const corrections = memoryStore.getByType('CORRECTION', 50);
+            for (const corr of corrections) {
+                const corrLower = corr.intent.toLowerCase();
+                const corrTerms = corrLower.split(/\s+/).filter(w => w.length > 4);
+                const matchCount = corrTerms.filter(t => codeLower.includes(t)).length;
+                if (matchCount >= 3) {
+                    violations.push(`🔄 **Past Correction Applies** \`id:${corr.id}\`: "${corr.intent}"`);
+                }
+            }
+            // File-specific memories
+            if (filename) {
+                const fileMemories = memoryStore.getByFile(filename, 10);
+                for (const fm of fileMemories) {
+                    suggestions.push(`📄 **File Note** \`id:${fm.id}\`: "${fm.intent}"`);
+                }
+            }
+            (0, usage_stats_1.trackReview)();
+            const lines = ['# Cortex Code Review\n'];
+            if (violations.length > 0) {
+                lines.push(`## ⚠️ ${violations.length} Issue${violations.length > 1 ? 's' : ''} Found\n`);
+                violations.forEach(v => lines.push(v));
+            }
+            if (suggestions.length > 0) {
+                lines.push(`\n## 💡 ${suggestions.length} Suggestion${suggestions.length > 1 ? 's' : ''}\n`);
+                suggestions.forEach(s => lines.push(s));
+            }
+            if (violations.length === 0 && suggestions.length === 0) {
+                lines.push('✅ **No issues found.** Code looks clean against your stored conventions and past bugs.');
+                lines.push(`\n_Checked against ${conventions.length} conventions, ${bugFixes.length} bug fixes, ${corrections.length} corrections._`);
+            }
+            else {
+                lines.push(`\n_Reviewed against ${conventions.length} conventions, ${bugFixes.length} bug fixes, ${corrections.length} corrections._`);
+            }
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+            };
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `Review error: ${err.message}` }], isError: true },
+            };
+        }
+    }
     function handleUpdateMemory(id, args) {
         try {
             const memoryId = args.id;
@@ -1311,6 +1705,137 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             }
             if (stored.length > 0) {
                 (0, memory_cache_1.invalidateCache)();
+                for (let i = 0; i < stored.length; i++)
+                    (0, usage_stats_1.trackStore)();
+            }
+            // ─── Auto-correction capture ─────────────────────────────────────
+            // Scan AI text for self-corrections ("I apologize", "you're right")
+            const aiCorrections = (0, correction_detector_1.detectAIAcknowledgments)(text);
+            for (const corr of aiCorrections) {
+                try {
+                    const corrResult = (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                        type: 'CORRECTION',
+                        intent: `[AUTO-DETECTED] ${corr.fullContext}`,
+                        action: corr.fullContext,
+                        reason: `AI self-correction detected (confidence: ${corr.confidence})`,
+                        confidence: corr.confidence,
+                        importance: 0.90, // High importance — corrections prevent repeats
+                        tags: ['auto-correction', 'ai-acknowledgment'],
+                    });
+                    if (corrResult.stored) {
+                        stored.push(`[CORRECTION] ${corr.fullContext.slice(0, 60)}…`);
+                    }
+                }
+                catch { /* skip */ }
+            }
+            // Scan user context for direct corrections ("no, use X not Y")
+            const userContext = args.context;
+            if (userContext && userContext.length > 10) {
+                const userCorrections = (0, correction_detector_1.detectUserCorrections)(userContext);
+                for (const corr of userCorrections) {
+                    try {
+                        const content = corr.corrected
+                            ? `User correction: use "${corr.corrected}"${corr.original ? ` instead of "${corr.original}"` : ''}`
+                            : `User correction: ${corr.fullContext}`;
+                        const corrResult = (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                            type: 'CORRECTION',
+                            intent: content,
+                            action: corr.fullContext,
+                            reason: `User correction detected (confidence: ${corr.confidence})`,
+                            confidence: corr.confidence,
+                            importance: 0.95, // Very high — user corrections are gospel
+                            tags: ['auto-correction', 'user-correction'],
+                        });
+                        if (corrResult.stored) {
+                            stored.push(`[USER CORRECTION] ${content.slice(0, 60)}…`);
+                            (0, memory_cache_1.invalidateCache)();
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+                // ─── Preference learning ─────────────────────────────────
+                const prefs = (0, preference_learner_1.detectPreferences)(userContext);
+                for (const pref of prefs) {
+                    try {
+                        const prefResult = (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                            type: 'CONVENTION',
+                            intent: pref.preference,
+                            action: `Detected from: "${pref.evidence}"`,
+                            reason: `User preference auto-detected (${pref.category})`,
+                            confidence: pref.confidence,
+                            importance: 0.85,
+                            tags: ['preference', pref.category],
+                        });
+                        if (prefResult.stored) {
+                            stored.push(`[PREFERENCE] ${pref.preference.slice(0, 60)}…`);
+                            (0, memory_cache_1.invalidateCache)();
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            // ─── Build error learning ──────────────────────────────────
+            // Scan for TS errors, test failures in AI text
+            if ((0, error_learner_1.containsErrors)(text)) {
+                const errorPatterns = (0, error_learner_1.extractErrorPatterns)(text);
+                // Extract verification steps for regression prevention
+                const verifySteps = (0, regression_guard_1.extractVerificationSteps)(text);
+                for (const ep of errorPatterns) {
+                    try {
+                        const baseAction = `Auto-captured from build/test output`;
+                        const actionWithVerify = (0, regression_guard_1.attachVerification)(baseAction, verifySteps);
+                        const errResult = (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                            type: 'BUG_FIX',
+                            intent: `[ERROR PATTERN] ${ep.errorType}: ${ep.message}`,
+                            action: actionWithVerify,
+                            reason: `Error pattern auto-detected — avoid this in future`,
+                            confidence: ep.confidence,
+                            importance: 0.90,
+                            tags: ['error-pattern', ep.errorType.toLowerCase(), 'auto-detected'],
+                        });
+                        if (errResult.stored) {
+                            stored.push(`[ERROR LEARNED] ${ep.errorType}: ${ep.message.slice(0, 50)}…`);
+                            (0, memory_cache_1.invalidateCache)();
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            // ─── Success reinforcement ─────────────────────────────────
+            // Scan user context for praise/success signals
+            if (userContext && userContext.length > 5) {
+                const successSignals = (0, success_tracker_1.detectSuccess)(userContext);
+                for (const signal of successSignals) {
+                    try {
+                        const mem = (0, success_tracker_1.buildSuccessMemory)(signal, text);
+                        const successResult = (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                            type: 'INSIGHT',
+                            intent: mem.intent,
+                            action: text.slice(0, 200),
+                            reason: mem.reason,
+                            confidence: signal.confidence,
+                            importance: 0.80,
+                            tags: mem.tags,
+                        });
+                        if (successResult.stored) {
+                            stored.push(`[SUCCESS] Proven approach stored from: "${signal.trigger}"`);
+                            (0, memory_cache_1.invalidateCache)();
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            // ─── File relationship tracking ────────────────────────────
+            // Track files mentioned in context for co-edit detection
+            if (userContext) {
+                const filePatterns = userContext.match(/[\w-]+\.\w{1,5}/g) || [];
+                const codeFileExts = new Set(['ts', 'tsx', 'js', 'jsx', 'css', 'py', 'go', 'rs', 'java']);
+                for (const f of filePatterns) {
+                    const ext = f.split('.').pop()?.toLowerCase() || '';
+                    if (codeFileExts.has(ext)) {
+                        (0, file_relationships_1.recordFileEdit)(f);
+                    }
+                }
             }
             const lines = ['**Auto-Learn Results:**'];
             if (stored.length > 0) {
@@ -1412,6 +1937,101 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             };
         }
     }
+    // ─── Pre-Flight Check Handler ───────────────────────────────────────────────
+    function handlePreCheck(id, args) {
+        try {
+            // Track file for relationship mapping
+            if (args.filename)
+                (0, file_relationships_1.recordFileEdit)(args.filename);
+            const result = (0, pre_flight_1.preFlightCheck)(memoryStore, args.filename, args.task);
+            let text = (0, pre_flight_1.formatPreFlight)(result);
+            // Add file relationship warnings
+            if (args.filename) {
+                const warnings = (0, file_relationships_1.checkMissingRelated)(args.filename, memoryStore);
+                if (warnings.length > 0) {
+                    text += '\n\n## 🔗 File Relationships\n';
+                    warnings.forEach(w => text += w + '\n');
+                }
+            }
+            // Add architecture context — show file's role in the system
+            if (args.filename && workspaceRoot) {
+                try {
+                    const archGraph = (0, architecture_graph_1.buildArchitectureGraph)(workspaceRoot);
+                    const basename = args.filename.replace(/\\/g, '/').split('/').pop() || args.filename;
+                    // nodes is Map<string, ArchNode> — find by key ending with basename
+                    let deps = null;
+                    for (const [key, node] of archGraph.nodes) {
+                        if (key.endsWith(basename)) {
+                            deps = node;
+                            break;
+                        }
+                    }
+                    if (deps && (deps.imports?.length > 0 || deps.importedBy?.length > 0)) {
+                        text += '\n\n## \ud83c\udfd7\ufe0f Architecture Context';
+                        if (deps.imports?.length > 0) {
+                            text += `\n**Imports from:** ${deps.imports.slice(0, 10).join(', ')}`;
+                        }
+                        if (deps.importedBy?.length > 0) {
+                            text += `\n**Imported by:** ${deps.importedBy.slice(0, 10).join(', ')}`;
+                        }
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text }] },
+            };
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `Pre-check error: ${err.message}` }], isError: true },
+            };
+        }
+    }
+    // ─── Impact Analysis Handler ───────────────────────────────────────────────
+    function handleCheckImpact(id, args) {
+        try {
+            const file = args.file;
+            if (!file) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: 'Error: file parameter is required' }], isError: true },
+                };
+            }
+            const wsRoot = args.workspaceRoot || process.cwd();
+            const result = (0, impact_analyzer_1.analyzeImpact)(file, wsRoot);
+            const text = (0, impact_analyzer_1.formatImpact)(result);
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text }] },
+            };
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `Impact analysis error: ${err.message}` }], isError: true },
+            };
+        }
+    }
+    // ─── Resume Work Handler ───────────────────────────────────────────────────
+    function handleResumeWork(id) {
+        try {
+            const ctx = (0, resume_work_1.buildResumeContext)(memoryStore);
+            const text = (0, resume_work_1.formatResumeContext)(ctx);
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text }] },
+            };
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `Resume work error: ${err.message}` }], isError: true },
+            };
+        }
+    }
     return { handleMCPRequest };
 }
 //# sourceMappingURL=mcp-handler.js.map