cortex-mcp 2.5.0 → 2.7.0

package/dist/server/mcp-handler.js

@@ -23,24 +23,10 @@ const git_memory_1 = require("../memory/git-memory");
 const export_map_1 = require("../scanners/export-map");
 const architecture_graph_1 = require("../scanners/architecture-graph");
 const rate_limiter_1 = require("../security/rate-limiter");
+const license_1 = require("../security/license");
 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 success_tracker_1 = require("../memory/success-tracker");
-const error_learner_1 = require("../memory/error-learner");
-const completion_resolver_1 = require("../memory/completion-resolver");
-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 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'],
@@ -157,7 +143,7 @@ const MCP_TOOLS = [
     },
     {
         name: 'force_recall',
-        description: 'MANDATORY: Call this at the START of every conversation. Returns ALL corrections, decisions, conventions, and bug fixes. Also searches for topic-specific memories. This is the single entry point for complete context injection. Without calling this, you WILL repeat past mistakes, contradict previous decisions, and miss critical conventions. The user expects you to remember everything from past sessions.',
+        description: 'MANDATORY: Call this at the START of every conversation. Returns ALL corrections, decisions, conventions, and bug fixes. Also searches for topic-specific memories. This is the single entry point for complete context injection.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -216,7 +202,7 @@ const MCP_TOOLS = [
     },
     {
         name: 'auto_learn',
-        description: 'CALL THIS AFTER EVERY RESPONSE. Pass the text of your response and Cortex will automatically extract and store any decisions, corrections, conventions, or bug fixes — with zero manual effort. This is how Cortex learns passively. If you skip this, everything you said in this conversation is LOST FOREVER — the user will have to repeat themselves next time.',
+        description: 'CALL THIS AFTER EVERY RESPONSE. Pass the text of your response and Cortex will automatically extract and store any decisions, corrections, conventions, or bug fixes — with zero manual effort. This is how Cortex learns passively.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -254,47 +240,157 @@ const MCP_TOOLS = [
         },
     },
     {
-        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.',
+        name: 'search_by_file',
+        description: 'Find all memories related to a specific file. Use this when working on a file to see what decisions, bugs, and conventions have been recorded for it.',
         inputSchema: {
             type: 'object',
             properties: {
-                code: { type: 'string', description: 'The code to review' },
-                filename: { type: 'string', description: 'Optional filename for context-aware review' },
+                filePath: { type: 'string', description: 'The file path to search for (e.g. "src/auth.ts" or "auth")' },
+                limit: { type: 'number', description: 'Maximum results to return (default 20)' },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'pin_memory',
+        description: 'Pin a memory so it is ALWAYS injected into context, regardless of topic. Use for critical rules like "never commit to main" or "always use TypeScript strict mode".',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the memory to pin (from list_memories or recall_memory)' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'unpin_memory',
+        description: 'Unpin a previously pinned memory so it returns to normal priority ranking.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the memory to unpin' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'undo_last',
+        description: 'Undo the last N memories that were stored. Use this if auto_learn stored garbage or if you made a mistake. Deletes the most recently created memories.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                count: { type: 'number', description: 'How many recent memories to undo (default 1, max 10)' },
             },
-            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. Skipping this risks reintroducing bugs that were already fixed.',
+        name: 'clear_memories',
+        description: 'Bulk delete memories by type or age. Use to clean up an entire category of memories or remove old stale memories.',
         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)' },
+                type: { type: 'string', enum: ['DECISION', 'CORRECTION', 'CONVENTION', 'BUG_FIX', 'INSIGHT', 'ALL'], description: 'Delete all memories of this type (or ALL for everything)' },
+                olderThanDays: { type: 'number', description: 'Only delete memories older than N days (optional safety filter)' },
             },
+            required: ['type'],
         },
     },
     {
-        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.',
+        name: 'search_timeline',
+        description: 'Search memories by date range. Use to answer questions like "what did we decide last week?" or "what bugs did we fix yesterday?".',
         inputSchema: {
             type: 'object',
             properties: {
-                file: { type: 'string', description: 'The file you plan to modify' },
+                from: { type: 'string', description: 'Start date (ISO format or relative like "7 days ago", "yesterday")' },
+                to: { type: 'string', description: 'End date (ISO format or "now"). Default: now' },
+                type: { type: 'string', enum: ['DECISION', 'CORRECTION', 'CONVENTION', 'BUG_FIX', 'INSIGHT', 'ALL'], description: 'Filter by type (optional)' },
             },
-            required: ['file'],
+            required: ['from'],
+        },
+    },
+    {
+        name: 'thumbs_up',
+        description: 'Mark a memory as useful/accurate. This boosts its importance and helps Cortex learn which memories matter most over time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the memory to upvote' },
+            },
+            required: ['id'],
         },
     },
     {
-        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.',
+        name: 'thumbs_down',
+        description: 'Mark a memory as not useful or incorrect. This demotes its importance. Repeatedly downvoted memories will be auto-deactivated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the memory to downvote' },
+                reason: { type: 'string', description: 'Why this memory is wrong or not useful (optional)' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'backup_brain',
+        description: 'Create a local backup of the entire memory database file. Run this periodically to ensure the user NEVER loses their project knowledge.',
         inputSchema: {
             type: 'object',
             properties: {},
         },
     },
+    {
+        name: 'get_daily_summary',
+        description: 'Read the AI-generated summary of what happened on a specific date. If no date is given, summarize today and store it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                date: { type: 'string', description: 'Date in YYYY-MM-DD format (optional, defaults to today)' },
+            },
+        },
+    },
+    {
+        name: 'analytics',
+        description: 'Get deep analytics about the brain: memory distribution, top accessed memories, and database health. Use this to understand what the AI knows best.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'export_memories',
+        description: 'Export ALL memories to a JSON file on disk. Use this to back up your project knowledge, share it with teammates, or migrate to a new machine. The JSON file can later be imported with import_memories.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Full path where the export JSON should be saved (e.g. /Users/me/cortex-backup.json)' },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'import_memories',
+        description: 'Import memories from a previously exported JSON file. Skips duplicates automatically. Use this to restore a backup or share project knowledge with a teammate.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Full path to the cortex export JSON file to import' },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'get_related_memories',
+        description: 'Follow the graph of memory relationships to find connected memories. Given a memory ID, traverses CAUSED_BY, FIXED_BY, RELATED_TO, and DEPENDS_ON edges to surface related context you might not have found with search.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the starting memory (from recall_memory or list_memories)' },
+                maxHops: { type: 'number', description: 'How many relationship hops to traverse (default 2, max 4)' },
+            },
+            required: ['id'],
+        },
+    },
 ];
 // --- Dynamic Context via ContextBuilder ---
 let cachedContextBuilder = null;
@@ -316,12 +412,68 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     result: {
                         protocolVersion: '2024-11-05',
                         capabilities: { tools: {}, resources: {}, prompts: {} },
-                        serverInfo: { name: 'Cortex', version: require('../../package.json').version },
+                        serverInfo: { name: 'cortex', version: '2.7.0' },
                     },
                 };
             case 'notifications/initialized':
-            case 'notifications/cancelled':
                 return null;
+            case 'prompts/list':
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        prompts: [
+                            {
+                                name: 'cortex_system_context',
+                                description: 'Injects crucial persistent project memories, decisions, corrections, and conventions directly into the system context. Use this to start every conversation with full project awareness.',
+                                arguments: [
+                                    {
+                                        name: 'currentFile',
+                                        description: 'The currently active file path (optional, improves relevance)',
+                                        required: false,
+                                    },
+                                    {
+                                        name: 'topic',
+                                        description: 'What the user is asking about (optional, improves topic search)',
+                                        required: false,
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                };
+            case 'prompts/get': {
+                const promptName = rpc.params?.name;
+                const promptArgs = rpc.params?.arguments || {};
+                if (promptName === 'cortex_system_context') {
+                    const builder = getContextBuilder(memoryStore);
+                    const memoryPayload = builder.build({
+                        currentFile: promptArgs.currentFile,
+                        maxChars: 6000,
+                    });
+                    return {
+                        jsonrpc: '2.0',
+                        id,
+                        result: {
+                            description: 'Cortex Auto-Injected System Context',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `You are connected to Cortex MCP — a persistent memory system. The following are critical memories, rules, and decisions from previous sessions. YOU MUST OBEY THESE RULES and reference this context when relevant:\n\n${memoryPayload}`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    error: { code: -32602, message: `Unknown prompt: ${promptName}` },
+                };
+            }
             case 'tools/list':
                 return {
                     jsonrpc: '2.0',
@@ -335,7 +487,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     result: {
                         resources: [{
                                 uri: 'memory://brain/context',
-                                name: 'Cortex MCP Context',
+                                name: 'Brain Context',
                                 description: 'Top memories — corrections, decisions, conventions. Read this before every response.',
                                 mimeType: 'text/plain',
                             }],
@@ -362,97 +514,6 @@ 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 || {};
@@ -463,10 +524,10 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                         result: { content: [{ type: 'text', text: 'Error: query too long (max 1000 chars)' }], isError: true },
                     };
                 }
-                if (args.content && typeof args.content === 'string' && args.content.length > 50000) {
+                if (args.content && typeof args.content === 'string' && args.content.length > 5000) {
                     return {
                         jsonrpc: '2.0', id,
-                        result: { content: [{ type: 'text', text: 'Error: content too long (max 50000 chars)' }], isError: true },
+                        result: { content: [{ type: 'text', text: 'Error: content too long (max 5000 chars)' }], isError: true },
                     };
                 }
                 if (toolName === 'recall_memory') {
@@ -509,25 +570,49 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     return handleAutoLearn(id, args);
                 }
                 else if (toolName === 'export_memories') {
-                    return handleExportMemories(id);
+                    return handleExportMemoriesFn(memoryStore, id, args);
                 }
                 else if (toolName === 'import_memories') {
-                    return handleImportMemories(id, args);
+                    return handleImportMemoriesFn(memoryStore, memory_cache_1, id, args);
+                }
+                else if (toolName === 'get_related_memories') {
+                    return handleGetRelatedMemoriesFn(memoryStore, id, args);
                 }
                 else if (toolName === 'health_check') {
                     return handleHealthCheck(id);
                 }
-                else if (toolName === 'review_code') {
-                    return handleReviewCode(id, args);
+                else if (toolName === 'search_by_file') {
+                    return handleSearchByFile(id, args);
+                }
+                else if (toolName === 'pin_memory') {
+                    return handlePinMemory(id, args);
                 }
-                else if (toolName === 'pre_check') {
-                    return handlePreCheck(id, args);
+                else if (toolName === 'unpin_memory') {
+                    return handleUnpinMemory(id, args);
                 }
-                else if (toolName === 'check_impact') {
-                    return handleCheckImpact(id, args);
+                else if (toolName === 'undo_last') {
+                    return handleUndoLast(id, args);
                 }
-                else if (toolName === 'resume_work') {
-                    return handleResumeWork(id);
+                else if (toolName === 'clear_memories') {
+                    return handleClearMemories(id, args);
+                }
+                else if (toolName === 'search_timeline') {
+                    return handleSearchTimeline(id, args);
+                }
+                else if (toolName === 'thumbs_up') {
+                    return handleThumbsUp(id, args);
+                }
+                else if (toolName === 'thumbs_down') {
+                    return handleThumbsDown(id, args);
+                }
+                else if (toolName === 'backup_brain') {
+                    return handleBackupBrain(id);
+                }
+                else if (toolName === 'get_daily_summary') {
+                    return handleGetDailySummary(id, args);
+                }
+                else if (toolName === 'analytics') {
+                    return handleAnalytics(id);
                 }
                 else {
                     return {
@@ -597,32 +682,10 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 ...r,
                 matchMethod: 'hybrid'
             }));
-            // 3b. Project-aware boost (memories from current project rank higher)
-            if (workspaceRoot) {
-                try {
-                    const pkgPath = require('path').join(workspaceRoot, 'package.json');
-                    let projectTag = '';
-                    if (require('fs').existsSync(pkgPath)) {
-                        const pkg = JSON.parse(require('fs').readFileSync(pkgPath, 'utf-8'));
-                        projectTag = (pkg.name || '').toLowerCase();
-                    }
-                    if (!projectTag)
-                        projectTag = require('path').basename(workspaceRoot).toLowerCase();
-                    if (projectTag) {
-                        ranked = ranked.map(r => {
-                            const tags = r.memory.tags || [];
-                            const hasProjectTag = tags.some(t => t.toLowerCase().includes(projectTag));
-                            const hasDiffProject = tags.some(t => t.startsWith('project:') && !t.toLowerCase().includes(projectTag));
-                            if (hasProjectTag)
-                                return { ...r, score: r.score * 1.3 };
-                            if (hasDiffProject)
-                                return { ...r, score: r.score * 0.7 };
-                            return r;
-                        });
-                        ranked.sort((a, b) => b.score - a.score);
-                    }
-                }
-                catch { /* project detection failed — skip boost */ }
+            // 3b. Context-based boost (if current file provided)
+            if (args.currentFile) {
+                // Boost memories related to this file or its directory
+                // Implementation in memory-ranker.ts (pending)
             }
             // 3c. Apply attention-based re-ranking (debugging→bugs, coding→conventions)
             const recallContext = (0, attention_ranker_1.detectActionContext)(queryText, currentFile);
@@ -655,14 +718,14 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             ranked = ranked.slice(0, maxResults);
             // 4. Touch for access tracking (reinforcement — used memories get stronger)
             if (ranked.length > 0) {
-                memoryStore.runTransaction(() => {
-                    for (const m of ranked) {
-                        try {
-                            memoryStore.touch(m.memory.id);
-                        }
-                        catch { /* non-fatal */ }
+                await Promise.all(ranked.map(m => {
+                    try {
+                        return memoryStore.touch(m.memory.id);
+                    }
+                    catch {
+                        return Promise.resolve();
                     }
-                });
+                }));
                 (0, confidence_decay_1.runDecayMaintenance)(memoryStore); // Opportunistic decay
             }
             (0, memory_cache_1.setCache)(cacheKey, ranked);
@@ -715,7 +778,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
         }
         try {
             // License check — gate memory storage
-            const activeCount = memoryStore.activeCount();
+            const activeCount = memoryStore.getActive(9999).length;
             const storeCheck = (0, feature_gate_1.canStoreMemory)(activeCount);
             if (!storeCheck.allowed) {
                 return {
@@ -813,15 +876,6 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
         }
     }
     function handleGetStats(id) {
-        const health = (0, usage_stats_1.calculateBrainHealth)(memoryStore);
-        const lifetime = (0, usage_stats_1.getLifetimeStats)();
-        const streak = (0, usage_stats_1.getStreakDisplay)();
-        let llmProvider = 'none';
-        try {
-            if ((0, llm_enhancer_1.isLLMAvailable)())
-                llmProvider = (0, llm_enhancer_1.getLLMProvider)();
-        }
-        catch { /* */ }
         return {
             jsonrpc: '2.0', id,
             result: {
@@ -833,16 +887,6 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                             totalEvents: eventLog.count(),
                             vectorSearchReady: (0, embedding_manager_1.isWorkerReady)(),
                             cacheSize: (0, memory_cache_1.cacheSize)(),
-                            brainHealth: { score: health.score, grade: health.grade, tips: health.tips },
-                            savedYouCount: lifetime.savedYouCount,
-                            totalSessions: lifetime.totalSessions,
-                            timeSaved: lifetime.totalMemoriesServed * 15 + lifetime.totalHallucationsCaught * 300,
-                            streak: streak || 'Day 1',
-                            longestStreak: lifetime.longestStreak || 0,
-                            totalAutoLearns: lifetime.totalAutoLearns,
-                            successPatternsLearned: lifetime.totalSuccessPatterns || 0,
-                            errorsLearned: lifetime.totalErrorsLearned || 0,
-                            llmProvider,
                         }, null, 2),
                     }],
             },
@@ -872,46 +916,16 @@ 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, coding conventions).${gapReport}`
-                                : `Project was already scanned. No new memories created.${gapReport}`,
+                                ? `Project scanned successfully. ${total} memories created (stack, structure, config, git history, export map, architecture graph).`
+                                : 'Project was already scanned. No new memories created.',
                         }],
                 },
             };
@@ -987,9 +1001,6 @@ 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
@@ -1016,20 +1027,6 @@ 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
@@ -1048,12 +1045,6 @@ 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') }] },
@@ -1137,67 +1128,12 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
     }
     async function handleForceRecall(id, args) {
         try {
-            // Fix #17: Cache force_recall with short TTL to avoid redundant rebuilds
-            const cacheKey = `force_recall:${args.topic || ''}:${args.currentFile || ''}`;
-            const cached = (0, memory_cache_1.getCached)(cacheKey);
-            if (cached) {
-                console.log(`  [CACHE] force_recall hit`);
-                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: cached }] } };
-            }
             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 });
-            // ─── Project Detection (for project isolation) ───────────────────
-            let projectName = '';
-            if (workspaceRoot) {
-                try {
-                    const pkgPath = require('path').join(workspaceRoot, 'package.json');
-                    if (require('fs').existsSync(pkgPath)) {
-                        const pkg = JSON.parse(require('fs').readFileSync(pkgPath, 'utf-8'));
-                        projectName = pkg.name || require('path').basename(workspaceRoot);
-                    }
-                    else {
-                        projectName = require('path').basename(workspaceRoot);
-                    }
-                }
-                catch {
-                    projectName = require('path').basename(workspaceRoot || '');
-                }
-                if (projectName) {
-                    (0, session_tracker_1.feedSession)({ project: projectName });
-                }
-            }
-            // ─── 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
@@ -1210,6 +1146,15 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 }
             }
             catch { /* maintenance errors are non-fatal */ }
+            // ─── BRAIN LAYER 1.5: PINNED MEMORIES (Critical Rules) ───────────
+            // Scan ALL memories for pinned — critical rules must never be missed
+            const pinnedMemories = memoryStore.getActive(10000).filter(m => (m.tags || []).includes('pinned'));
+            if (pinnedMemories.length > 0) {
+                parts.push('\n## 📌 PINNED CRITICAL RULES (Must Follow)');
+                for (const p of pinnedMemories) {
+                    parts.push(`- **[${p.type}]** ${p.intent}`);
+                }
+            }
             // ─── BRAIN LAYER 2: Attention Context ────────────────────────────
             const actionContext = (0, feature_gate_1.isFeatureAllowed)('attentionRanking') ? (0, attention_ranker_1.detectActionContext)(args.topic, args.currentFile) : {};
             const attentionLabel = (0, feature_gate_1.isFeatureAllowed)('attentionRanking') ? (0, attention_ranker_1.formatAttentionContext)(actionContext) : '';
@@ -1233,326 +1178,149 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 maxChars: 8000, // leave room for brain layers
             });
             parts.push(fullContext);
-            // ─── BRAIN LAYERS 6-12: Run in parallel (independent of each other) ───
-            const parallelResults = await Promise.allSettled([
-                // Layer 6: Anticipation
-                (async () => {
-                    if (args.currentFile && (0, feature_gate_1.isFeatureAllowed)('anticipation')) {
-                        return (0, anticipation_engine_1.formatAnticipation)((0, anticipation_engine_1.anticipate)(memoryStore, args.currentFile));
-                    }
-                    return '';
-                })(),
-                // Layer 6.5: Proactive Warnings — ⚠️ for files with past bugs/corrections
-                (async () => {
-                    if (!args.currentFile)
-                        return '';
-                    try {
-                        const fileMemories = memoryStore.getByFile(args.currentFile, 50);
-                        const warnings = fileMemories.filter((m) => (m.type === 'CORRECTION' || m.type === 'BUG_FIX') && m.is_active);
-                        if (warnings.length === 0)
-                            return '';
-                        const lines = warnings.slice(0, 5).map((m) => `⚠️ **${m.type}**: ${m.intent}${m.reason && !m.reason.startsWith('Auto-detected') ? ` — _${m.reason}_` : ''}`);
-                        return `\n## ⚠️ Watch Out (past issues with this file)\n${lines.join('\n')}`;
-                    }
-                    catch {
-                        return '';
-                    }
-                })(),
-                // Layer 7: Temporal Context
-                (async () => {
-                    if ((0, feature_gate_1.isFeatureAllowed)('temporalContext')) {
-                        return (0, temporal_engine_1.formatTemporalContext)(memoryStore);
-                    }
-                    return '';
-                })(),
-                // Layer 8: Workspace State (git)
-                (async () => {
-                    try {
-                        return (0, temporal_engine_1.getWorkspaceDiff)(workspaceRoot || '');
-                    }
-                    catch {
-                        return '';
-                    }
-                })(),
-                // Layer 8.5: Git Memory
-                (async () => {
-                    if (!(0, feature_gate_1.isFeatureAllowed)('gitMemory'))
-                        return '';
-                    try {
-                        const commitsCaptured = (0, git_memory_1.captureGitCommits)(memoryStore, workspaceRoot || '', 5);
-                        const commitText = commitsCaptured > 0
-                            ? `\n> Captured ${commitsCaptured} new git commit(s) as memories`
-                            : '';
-                        const fileChanges = (0, git_memory_1.detectFileChanges)(workspaceRoot || '');
-                        const fileChangeText = (0, git_memory_1.formatFileChanges)(fileChanges);
-                        return [commitText, fileChangeText].filter(Boolean).join('\n');
-                    }
-                    catch {
-                        return '';
+            // ─── BRAIN LAYER 6: Anticipation (file-aware proactive recall) ───
+            if (args.currentFile && (0, feature_gate_1.isFeatureAllowed)('anticipation')) {
+                const anticipated = (0, anticipation_engine_1.formatAnticipation)((0, anticipation_engine_1.anticipate)(memoryStore, args.currentFile));
+                if (anticipated)
+                    parts.push('\n' + anticipated);
+            }
+            // ─── BRAIN LAYER 7: Temporal Context (what changed recently) ─────
+            if ((0, feature_gate_1.isFeatureAllowed)('temporalContext')) {
+                const temporal = (0, temporal_engine_1.formatTemporalContext)(memoryStore);
+                if (temporal)
+                    parts.push('\n' + temporal);
+            }
+            // ─── BRAIN LAYER 8: Workspace State (git changes) ────────────────
+            try {
+                const workspace = (0, temporal_engine_1.getWorkspaceDiff)(workspaceRoot || '');
+                if (workspace)
+                    parts.push('\n' + workspace);
+            }
+            catch { /* git not available */ }
+            // ─── BRAIN LAYER 8.5: Git Memory (commit capture + file changes) ───
+            if ((0, feature_gate_1.isFeatureAllowed)('gitMemory')) {
+                try {
+                    // Capture recent commits as memories
+                    const commitsCaptured = (0, git_memory_1.captureGitCommits)(memoryStore, workspaceRoot || '', 5);
+                    if (commitsCaptured > 0) {
+                        parts.push(`\n> Captured ${commitsCaptured} new git commit(s) as memories`);
                     }
-                })(),
-                // Layer 9: Topic Search — Hybrid (FTS + Vector) for deeper relevance
-                (async () => {
-                    if (!args.topic)
-                        return '';
-                    try {
-                        // 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 ranked) {
-                            if (seen.has(r.memory.id))
-                                continue;
-                            seen.add(r.memory.id);
-                            enriched.push(r);
-                            try {
-                                const related = memoryStore.getRelated(r.memory.id, 1, 3);
-                                for (const rel of related) {
-                                    if (!seen.has(rel.memory.id)) {
-                                        seen.add(rel.memory.id);
-                                        enriched.push({ ...rel, score: rel.score * 0.7 });
-                                    }
+                    // Show uncommitted file changes
+                    const fileChanges = (0, git_memory_1.detectFileChanges)(workspaceRoot || '');
+                    const fileChangeText = (0, git_memory_1.formatFileChanges)(fileChanges);
+                    if (fileChangeText)
+                        parts.push('\n' + fileChangeText);
+                }
+                catch { /* git not available */ }
+            } // end isPro() for git memory
+            // ─── BRAIN LAYER 9: Topic-Specific Search ────────────────────────
+            if (args.topic) {
+                try {
+                    let ftsResults = memoryStore.searchFTS(args.topic, 15);
+                    // Apply confidence decay + attention ranking
+                    ftsResults = (0, confidence_decay_1.applyConfidenceDecay)(ftsResults);
+                    ftsResults = (0, attention_ranker_1.rankByAttention)(ftsResults, actionContext);
+                    // Causal chain: follow graph edges for top results
+                    const seen = new Set();
+                    const enriched = [];
+                    for (const r of ftsResults) {
+                        if (seen.has(r.memory.id))
+                            continue;
+                        seen.add(r.memory.id);
+                        enriched.push(r);
+                        // Follow causal links (1 hop)
+                        try {
+                            const related = memoryStore.getRelated(r.memory.id, 1, 3);
+                            for (const rel of related) {
+                                if (!seen.has(rel.memory.id)) {
+                                    seen.add(rel.memory.id);
+                                    enriched.push({ ...rel, score: rel.score * 0.7 });
                                 }
                             }
-                            catch { }
                         }
-                        if (enriched.length > 0) {
-                            const lines = ['\n## Topic: "' + args.topic + '"'];
-                            for (const m of enriched.slice(0, 15)) {
-                                lines.push(`- [${m.memory.type}] ${m.memory.intent}${m.memory.reason ? ` — ${m.memory.reason}` : ''}`);
-                            }
-                            return lines.join('\n');
-                        }
-                        return '';
-                    }
-                    catch {
-                        return '\n> Note: Topic search unavailable (FTS index needs rebuild).';
-                    }
-                })(),
-                // Layer 10: Knowledge Gaps (skip when topic is specific — saves tokens)
-                (async () => {
-                    if (args.topic)
-                        return ''; // Skip heavy layer for focused queries
-                    try {
-                        const gaps = (0, meta_memory_1.detectKnowledgeGaps)(memoryStore, workspaceRoot || '');
-                        return (0, meta_memory_1.formatKnowledgeGaps)(gaps);
-                    }
-                    catch {
-                        return '';
+                        catch { }
                     }
-                })(),
-                // Layer 11: Export Map (skip when topic is specific — saves tokens)
-                (async () => {
-                    if (args.topic)
-                        return ''; // Skip heavy layer for focused queries
-                    if (!workspaceRoot || !(0, feature_gate_1.isFeatureAllowed)('exportMap'))
-                        return '';
-                    try {
-                        const exportMap = (0, export_map_1.buildExportMap)(workspaceRoot);
-                        return exportMap.totalExports > 0 ? (0, export_map_1.formatExportMap)(exportMap) : '';
-                    }
-                    catch {
-                        return '';
-                    }
-                })(),
-                // Layer 12: Architecture Graph (skip when topic is specific — saves tokens)
-                (async () => {
-                    if (args.topic)
-                        return ''; // Skip heavy layer for focused queries
-                    if (!workspaceRoot || !(0, feature_gate_1.isFeatureAllowed)('architectureGraph'))
-                        return '';
-                    try {
-                        const archGraph = (0, architecture_graph_1.buildArchitectureGraph)(workspaceRoot);
-                        return archGraph.totalFiles > 0 ? (0, architecture_graph_1.formatArchitectureGraph)(archGraph) : '';
-                    }
-                    catch {
-                        return '';
+                    if (enriched.length > 0) {
+                        parts.push('\n## Topic: "' + args.topic + '"');
+                        for (const m of enriched.slice(0, 15)) {
+                            parts.push(`- [${m.memory.type}] ${m.memory.intent}${m.memory.reason ? ` — ${m.memory.reason}` : ''}`);
+                        }
                     }
-                })(),
-            ]);
-            // Collect results (in order) — only push non-empty strings
-            for (const result of parallelResults) {
-                if (result.status === 'fulfilled' && result.value) {
-                    parts.push('\n' + result.value);
                 }
-            }
-            // ─── 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) {
-                // 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);
+                catch {
+                    parts.push('\n> Note: Topic search unavailable (FTS index needs rebuild).');
                 }
-                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)
+            // ─── BRAIN LAYER 10: Knowledge Gaps (meta-memory) ────────────────
             try {
-                const prefText = (0, preference_learner_1.getStoredPreferences)(memoryStore);
-                if (prefText)
-                    output += '\n\n' + prefText;
+                const gaps = (0, meta_memory_1.detectKnowledgeGaps)(memoryStore, workspaceRoot || '');
+                const gapText = (0, meta_memory_1.formatKnowledgeGaps)(gaps);
+                if (gapText)
+                    parts.push('\n' + gapText);
             }
             catch { /* non-fatal */ }
-            // Append stats footer (makes value visible — THE KEY TO ADDICTION)
-            const statsFooter = (0, usage_stats_1.formatStatsFooter)(memoryStore);
-            if (statsFooter)
-                output += statsFooter;
-            // Count corrections recalled as "saved you" moments
-            const correctionsRecalled = (output.match(/\[CORRECTION\]/g) || []).length;
-            for (let i = 0; i < correctionsRecalled; i++)
-                (0, usage_stats_1.trackSaved)();
-            // Cache the result for short-lived reuse
-            (0, memory_cache_1.setCache)(cacheKey, output);
-            return {
-                jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: output }] },
-            };
-        }
-        catch (err) {
-            return {
-                jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `Force recall error: ${err.message}` }], isError: true },
-            };
-        }
-    }
-    // ─── 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}\``);
-                        }
+            // ─── BRAIN LAYER 11: Export Map (anti-hallucination) ──────────────
+            if (workspaceRoot && (0, feature_gate_1.isFeatureAllowed)('exportMap')) {
+                try {
+                    const exportMap = (0, export_map_1.buildExportMap)(workspaceRoot);
+                    if (exportMap.totalExports > 0) {
+                        const exportText = (0, export_map_1.formatExportMap)(exportMap);
+                        if (exportText)
+                            parts.push('\n' + exportText);
                     }
                 }
+                catch { /* non-fatal */ }
             }
-            // 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}"`);
+            // ─── BRAIN LAYER 12: Architecture Graph (deep understanding) ──────
+            if (workspaceRoot && (0, feature_gate_1.isFeatureAllowed)('architectureGraph')) {
+                try {
+                    const archGraph = (0, architecture_graph_1.buildArchitectureGraph)(workspaceRoot);
+                    if (archGraph.totalFiles > 0) {
+                        const archText = (0, architecture_graph_1.formatArchitectureGraph)(archGraph);
+                        if (archText)
+                            parts.push('\n' + archText);
+                    }
                 }
+                catch { /* non-fatal */ }
             }
-            // 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}"`);
+            // ─── SMART CONTEXT SELECTION: Trim to token budget ───────────────
+            // ─── SMART CONTEXT TRIMMING: Remove low-priority sections first ─
+            const MAX_CHARS = 12000; // ~3000 tokens — fits any model
+            let output;
+            if (parts.join('\n').length > MAX_CHARS) {
+                // Priority order: keep critical layers, trim optional ones from the end
+                // Parts are added in priority order (sessions, corrections, core context first)
+                // So we trim from the END (architecture graph, export map, knowledge gaps)
+                let trimmedParts = [...parts];
+                let totalLen = trimmedParts.join('\n').length;
+                while (totalLen > MAX_CHARS && trimmedParts.length > 3) {
+                    trimmedParts.pop(); // Remove lowest priority section
+                    totalLen = trimmedParts.join('\n').length;
+                }
+                output = trimmedParts.join('\n');
+                if (output.length > MAX_CHARS) {
+                    output = output.slice(0, MAX_CHARS);
                 }
+                output += '\n\n> (Lower-priority context removed to fit token budget. Use `recall_memory` for specific queries.)';
+            } else {
+                output = parts.join('\n');
             }
-            (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._`);
+            // ─── DAY 1 EMPTY BRAIN: Guide new users ──────────────────────────
+            if (memoryStore.activeCount() === 0) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: '## 🧠 Cortex Brain — Day 1\n\nNo memories yet. Here is how to build your brain:\n\n1. **Scan this project** — call `scan_project` with the workspace root. This creates memories from your package.json, README, git history, and code structure.\n2. **Just work normally** — after every response, `auto_learn` will automatically extract and store decisions, corrections, and bug fixes.\n3. **Store manually** — use `store_memory` or `quick_store` for important rules.\n\nOnce you have memories, `force_recall` will inject them here automatically.' }] },
+                };
             }
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+                result: { content: [{ type: 'text', text: output }] },
             };
         }
         catch (err) {
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `Review error: ${err.message}` }], isError: true },
+                result: { content: [{ type: 'text', text: `Force recall error: ${err.message}` }], isError: true },
             };
         }
     }
@@ -1696,7 +1464,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
     }
     async function handleAutoLearn(id, args) {
         try {
-            // Feature gate (launch mode: all features unlocked)
+            // Feature gate check (auto_learn is now free!)
             if (!(0, feature_gate_1.isFeatureAllowed)('autoLearn')) {
                 return {
                     jsonrpc: '2.0', id,
@@ -1720,50 +1488,6 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             }
             // Extract memory-worthy patterns (regex-based)
             const extracted = (0, auto_learner_1.extractMemories)(text);
-            (0, usage_stats_1.trackAutoLearn)(); // Track for Brain Health Score + Streak
-            // SUCCESS DETECTION: capture proven approaches
-            try {
-                const successSignals = (0, success_tracker_1.detectSuccess)(text);
-                for (const signal of successSignals) {
-                    const successMemory = (0, success_tracker_1.buildSuccessMemory)(signal, text);
-                    extracted.push({
-                        type: 'INSIGHT',
-                        content: successMemory.intent,
-                        confidence: signal.confidence,
-                        reason: successMemory.reason,
-                    });
-                    (0, usage_stats_1.trackSuccess)();
-                }
-            }
-            catch { /* success detection failed — non-fatal */ }
-            // ERROR FINGERPRINT: capture error patterns for instant recall
-            try {
-                if ((0, error_learner_1.containsErrors)(text)) {
-                    const errorPatterns = (0, error_learner_1.extractErrorPatterns)(text);
-                    for (const ep of errorPatterns.slice(0, 3)) {
-                        extracted.push({
-                            type: 'BUG_FIX',
-                            content: ep.message,
-                            confidence: ep.confidence,
-                            reason: `Error pattern: ${ep.errorType} — auto-captured for instant fix recall`,
-                        });
-                        (0, usage_stats_1.trackErrorLearned)();
-                    }
-                }
-            }
-            catch { /* error learning failed — non-fatal */ }
-            // COMPLETION DETECTION: demote old memories about completed topics
-            try {
-                const completionSignals = (0, completion_resolver_1.detectCompletion)(text);
-                for (const signal of completionSignals) {
-                    const resolved = (0, completion_resolver_1.resolveRelatedMemories)(memoryStore, signal.topic, signal.confidence);
-                    if (resolved > 0) {
-                        console.log(`  🏁 Completion: "${signal.topic}" — demoted ${resolved} old memories`);
-                        (0, memory_cache_1.invalidateCache)();
-                    }
-                }
-            }
-            catch { /* completion detection failed — non-fatal */ }
             // LLM enhancement: when API key is available and regex found nothing,
             // use LLM to catch implicit patterns that keywords miss
             if (extracted.length === 0 && (0, llm_enhancer_1.isLLMAvailable)() && text.length > 50) {
@@ -1791,62 +1515,6 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 };
             }
             // Store each extracted memory + feed session tracker
-            // --- Helper: Independent importance scoring ---
-            function calculateImportance(item) {
-                // Base importance by type (corrections/bugs are more important than insights)
-                const TYPE_IMPORTANCE = {
-                    CORRECTION: 0.85, BUG_FIX: 0.85, CONVENTION: 0.80,
-                    DECISION: 0.75, GOTCHA: 0.75, BUSINESS_RULE: 0.70,
-                    FAILED_ATTEMPT: 0.65, CURRENT_TASK: 0.60, INSIGHT: 0.55,
-                };
-                let importance = TYPE_IMPORTANCE[item.type] || 0.60;
-                // Boost for content signals that indicate higher value
-                if (/\b(always|never|must|critical|important|breaking)\b/i.test(item.content))
-                    importance += 0.08;
-                if (/\b(error|bug|crash|fail|exception)\b/i.test(item.content))
-                    importance += 0.05;
-                if (/\.(ts|js|py|go|rs|java|tsx|jsx)\b/.test(item.content))
-                    importance += 0.03; // file-specific
-                if (/v?\d+\.\d+/.test(item.content))
-                    importance += 0.02; // version numbers
-                // Blend with regex confidence (40% type-based, 60% regex confidence)
-                importance = importance * 0.4 + item.confidence * 0.6;
-                return Math.min(importance, 1.0);
-            }
-            // --- Helper: Extract topic tags from content ---
-            function extractTopicTags(item) {
-                const tags = [item.type.toLowerCase()];
-                const content = item.content.toLowerCase();
-                // Extract technology/framework mentions
-                const techPatterns = /\b(react|vue|angular|next\.?js|node|express|typescript|javascript|python|rust|go|docker|kubernetes|postgres|mongodb|redis|graphql|rest|api|css|html|webpack|vite|eslint|git|npm|yarn)\b/gi;
-                const techMatches = item.content.match(techPatterns);
-                if (techMatches) {
-                    for (const tech of new Set(techMatches.map(t => t.toLowerCase()))) {
-                        tags.push(tech);
-                    }
-                }
-                // Extract file extensions as topic hints
-                const fileExts = content.match(/\.(ts|js|py|go|rs|java|tsx|jsx|css|html|json|yaml|yml|md)\b/g);
-                if (fileExts) {
-                    for (const ext of new Set(fileExts)) {
-                        tags.push(ext.replace('.', ''));
-                    }
-                }
-                // Extract key action verbs as context
-                if (/\b(migrat|switch|chang|replac|upgrad|delet|remov)\w*/i.test(content))
-                    tags.push('migration');
-                if (/\b(test|spec|assert|expect|mock)\b/i.test(content))
-                    tags.push('testing');
-                if (/\b(deploy|ci|cd|pipeline|build|release)\b/i.test(content))
-                    tags.push('devops');
-                if (/\b(auth|login|token|session|permission|role)\b/i.test(content))
-                    tags.push('auth');
-                if (/\b(database|query|schema|table|index|sql)\b/i.test(content))
-                    tags.push('database');
-                if (/\b(performance|speed|slow|fast|optimize|cache)\b/i.test(content))
-                    tags.push('performance');
-                return [...new Set(tags)].slice(0, 8); // Cap at 8 tags
-            }
             const stored = [];
             const skipped = [];
             for (const item of extracted) {
@@ -1872,16 +1540,30 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                             (0, session_tracker_1.feedSession)({ topic: item.content.slice(0, 60) });
                             break;
                     }
+                    // Map auto_learn string types to MemoryType enum values
+                    // (auto_learner returns uppercase like "DECISION", but MemoryType enum uses lowercase like "decision")
+                    const autoLearnTypeMap = {
+                        'DECISION': types_1.MemoryType.DECISION || 'decision',
+                        'CORRECTION': types_1.MemoryType.CORRECTION || 'correction',
+                        'BUG_FIX': types_1.MemoryType.BUG_FIX || 'bug_fix',
+                        'CONVENTION': types_1.MemoryType.CONVENTION || 'convention',
+                        'INSIGHT': types_1.MemoryType.INSIGHT || 'insight',
+                        'FAILED_ATTEMPT': types_1.MemoryType.FAILED_SUGGESTION || 'failed_suggestion',
+                        'BUSINESS_RULE': types_1.MemoryType.DECISION || 'decision',
+                        'GOTCHA': types_1.MemoryType.CORRECTION || 'correction',
+                        'CURRENT_TASK': types_1.MemoryType.INSIGHT || 'insight',
+                    };
+                    const mappedType = autoLearnTypeMap[item.type] || item.type.toLowerCase();
                     const result = (0, memory_quality_1.storeWithQuality)(memoryStore, {
-                        type: item.type,
+                        type: mappedType,
                         intent: item.content,
-                        action: `auto_learn:${item.type.toLowerCase()}`,
+                        action: item.content,
                         reason: item.reason,
                         confidence: item.confidence,
-                        importance: calculateImportance(item),
-                        tags: extractTopicTags(item),
+                        importance: item.confidence,
+                        tags: [item.type.toLowerCase()],
                     });
-                    if (result.stored) {
+                    if (result) {
                         stored.push(`[${item.type}] ${item.content.slice(0, 60)}${item.content.length > 60 ? '…' : ''}`);
                     }
                     else {
@@ -1894,137 +1576,6 @@ 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) {
@@ -2107,12 +1658,14 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 '# Cortex Health Check\n',
                 `| Metric | Value |`,
                 `|--------|-------|`,
+                `| Plan | **Full Brain — 100% Free** |`,
                 `| Active Memories | ${activeCount} |`,
-                `| Session Store Count | ${stats.storeCount}/100 |`,
-                `| Session Auto-Learn Count | ${stats.autoLearnCount}/500 |`,
-                `| Session Total Calls | ${stats.totalCalls}/2000 |`,
+                `| Brain Layers | All 12 Active |`,
+                `| Session Store Count | ${stats.storeCount}/500 |`,
+                `| Session Auto-Learn Count | ${stats.autoLearnCount}/1000 |`,
+                `| Session Total Calls | ${stats.totalCalls}/5000 |`,
                 `| Uptime | ${Math.floor(stats.uptime / 60)}m ${stats.uptime % 60}s |`,
-                `| Status | Healthy |`,
+                `| Status | ✅ Healthy |`,
             ];
             return {
                 jsonrpc: '2.0', id,
@@ -2126,101 +1679,428 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             };
         }
     }
-    // ─── Pre-Flight Check Handler ───────────────────────────────────────────────
-    function handlePreCheck(id, args) {
+    // ═══ NEW TOOLS: search_by_file, pin, unpin, undo, clear, timeline, thumbs ═══
+    function handleSearchByFile(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');
-                }
+            const filePath = args.filePath;
+            const limit = args.limit || 20;
+            if (!filePath) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: 'Error: filePath is required' }], isError: true },
+                };
             }
-            // Add architecture context — show file's role in the system
-            if (args.filename && workspaceRoot) {
+            // Use the existing getByFile method + FTS fallback
+            let memories = memoryStore.getByFile(filePath, limit);
+            // Also do FTS search for the filename
+            if (memories.length < limit) {
+                const basename = filePath.split(/[\\/]/).pop() || filePath;
                 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(', ')}`;
+                    const ftsResults = memoryStore.searchFTS(basename, limit - memories.length);
+                    const existingIds = new Set(memories.map(m => m.id));
+                    for (const r of ftsResults) {
+                        if (!existingIds.has(r.memory.id)) {
+                            memories.push(r.memory);
                         }
                     }
-                }
-                catch { /* non-fatal */ }
+                } catch { /* FTS may fail on special characters */ }
+            }
+            if (memories.length === 0) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: `No memories found for file: "${filePath}"` }] },
+                };
+            }
+            const lines = [`# Memories related to "${filePath}"\n`];
+            for (const m of memories) {
+                const age = Math.floor((Date.now() - m.createdAt) / 86400000);
+                lines.push(`- **[${m.type}]** ${m.intent}`);
+                if (m.reason) lines.push(`  _${m.reason}_`);
+                lines.push(`  \`id: ${m.id}\` · ${age}d old`);
             }
+            lines.push(`\n_Total: ${memories.length} memories for this file._`);
+            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 }] },
+                result: { content: [{ type: 'text', text: `search_by_file error: ${err.message}` }], isError: true },
             };
         }
-        catch (err) {
+    }
+    function handlePinMemory(id, args) {
+        try {
+            const memoryId = args.id;
+            if (!memoryId) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: id is required' }], isError: true } };
+            }
+            const existing = memoryStore.get(memoryId);
+            if (!existing) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: Memory ${memoryId} not found` }], isError: true } };
+            }
+            const tags = existing.tags || [];
+            if (!tags.includes('pinned')) tags.push('pinned');
+            memoryStore.update(memoryId, { importance: 1.0, tags });
+            (0, memory_cache_1.invalidateCache)();
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `Pre-check error: ${err.message}` }], isError: true },
+                result: { content: [{ type: 'text', text: `📌 Memory PINNED: "${existing.intent}"\n\nThis memory will ALWAYS be included in context, regardless of topic.` }] },
             };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `pin error: ${err.message}` }], isError: true } };
         }
     }
-    // ─── Impact Analysis Handler ───────────────────────────────────────────────
-    function handleCheckImpact(id, args) {
+    function handleUnpinMemory(id, args) {
         try {
-            const file = args.file;
-            if (!file) {
+            const memoryId = args.id;
+            if (!memoryId) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: id is required' }], isError: true } };
+            }
+            const existing = memoryStore.get(memoryId);
+            if (!existing) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: Memory ${memoryId} not found` }], isError: true } };
+            }
+            const tags = (existing.tags || []).filter(t => t !== 'pinned');
+            memoryStore.update(memoryId, { importance: 0.7, tags });
+            (0, memory_cache_1.invalidateCache)();
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `📌 Memory UNPINNED: "${existing.intent}"\n\nThis memory will now use normal priority ranking.` }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `unpin error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleUndoLast(id, args) {
+        try {
+            const count = Math.min(Math.max(args.count || 1, 1), 10);
+            // Get the N most recently CREATED active memories (order by created_at, not timestamp)
+            const db = memoryStore.db;
+            const recentRows = db.prepare('SELECT * FROM memory_units WHERE is_active = 1 ORDER BY created_at DESC LIMIT ?').all(count);
+            const recent = recentRows.map(r => memoryStore.get(r.id)).filter(Boolean);
+            if (recent.length === 0) {
                 return {
                     jsonrpc: '2.0', id,
-                    result: { content: [{ type: 'text', text: 'Error: file parameter is required' }], isError: true },
+                    result: { content: [{ type: 'text', text: 'No memories to undo.' }] },
                 };
             }
-            const wsRoot = args.workspaceRoot || process.cwd();
-            const result = (0, impact_analyzer_1.analyzeImpact)(file, wsRoot);
-            const text = (0, impact_analyzer_1.formatImpact)(result);
+            const toUndo = recent;
+            const undone = [];
+            for (const m of toUndo) {
+                memoryStore.deactivate(m.id);
+                undone.push(`- [${m.type}] "${m.intent.slice(0, 80)}"`);
+            }
+            (0, memory_cache_1.invalidateCache)();
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text }] },
+                result: { content: [{ type: 'text', text: `⏪ Undone ${undone.length} memory(ies):\n\n${undone.join('\n')}` }] },
             };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `undo error: ${err.message}` }], isError: true } };
         }
-        catch (err) {
+    }
+    function handleClearMemories(id, args) {
+        try {
+            const type = args.type;
+            const olderThanDays = args.olderThanDays;
+            if (!type) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: type is required' }], isError: true } };
+            }
+            let query = 'SELECT * FROM memory_units WHERE is_active = 1';
+            const params = [];
+            if (type !== 'ALL') {
+                query += ' AND type = ?';
+                params.push(type);
+            }
+            if (olderThanDays) {
+                const cutoff = Date.now() - (olderThanDays * 86400000);
+                query += ' AND created_at < ?';
+                params.push(cutoff);
+            }
+            const rows = memoryStore.db ? memoryStore.db.prepare(query).all.apply(memoryStore.db.prepare(query), params) : [];
+            let cleared = 0;
+            for (const row of rows) {
+                memoryStore.deactivate(row.id);
+                cleared++;
+            }
+            (0, memory_cache_1.invalidateCache)();
+            const ageMsg = olderThanDays ? ` older than ${olderThanDays} days` : '';
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `Impact analysis error: ${err.message}` }], isError: true },
+                result: { content: [{ type: 'text', text: `🗑️ Cleared ${cleared} ${type === 'ALL' ? '' : type + ' '}memories${ageMsg}.` }] },
             };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `clear error: ${err.message}` }], isError: true } };
         }
     }
-    // ─── Resume Work Handler ───────────────────────────────────────────────────
-    function handleResumeWork(id) {
+    function parseRelativeDate(str) {
+        if (!str) return Date.now();
+        const lower = str.toLowerCase().trim();
+        if (lower === 'now' || lower === 'today') return Date.now();
+        if (lower === 'yesterday') return Date.now() - 86400000;
+        // "N days ago", "N hours ago", "N weeks ago"
+        const relMatch = lower.match(/^(\d+)\s+(day|hour|week|month)s?\s+ago$/);
+        if (relMatch) {
+            const n = parseInt(relMatch[1], 10);
+            const unit = relMatch[2];
+            const multipliers = { hour: 3600000, day: 86400000, week: 604800000, month: 2592000000 };
+            return Date.now() - (n * (multipliers[unit] || 86400000));
+        }
+        // Try ISO date
+        const parsed = new Date(str).getTime();
+        return isNaN(parsed) ? Date.now() - 604800000 : parsed; // default to 7 days ago
+    }
+    function handleSearchTimeline(id, args) {
         try {
-            const ctx = (0, resume_work_1.buildResumeContext)(memoryStore);
-            const text = (0, resume_work_1.formatResumeContext)(ctx);
+            const fromTs = parseRelativeDate(args.from);
+            const toTs = parseRelativeDate(args.to || 'now');
+            const type = args.type;
+            let query = 'SELECT * FROM memory_units WHERE is_active = 1 AND created_at >= ? AND created_at <= ?';
+            const params = [fromTs, toTs];
+            if (type && type !== 'ALL') {
+                query += ' AND type = ?';
+                params.push(type);
+            }
+            query += ' ORDER BY created_at DESC LIMIT 50';
+            const db = memoryStore.db || memoryStore.connection;
+            const stmt = db.prepare(query);
+            const rows = stmt.all.apply(stmt, params);
+            if (rows.length === 0) {
+                return {
+                    jsonrpc: '2.0', id,
+                    result: { content: [{ type: 'text', text: `No memories found between ${new Date(fromTs).toLocaleDateString()} and ${new Date(toTs).toLocaleDateString()}.` }] },
+                };
+            }
+            const lines = [`# Timeline: ${new Date(fromTs).toLocaleDateString()} → ${new Date(toTs).toLocaleDateString()}\n`];
+            let lastDate = '';
+            for (const row of rows) {
+                const dateStr = new Date(row.created_at).toLocaleDateString();
+                if (dateStr !== lastDate) {
+                    lines.push(`\n## ${dateStr}`);
+                    lastDate = dateStr;
+                }
+                lines.push(`- **[${row.type}]** ${row.intent}`);
+                if (row.reason) lines.push(`  _${row.reason}_`);
+            }
+            lines.push(`\n_Total: ${rows.length} memories in this period._`);
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text }] },
+                result: { content: [{ type: 'text', text: lines.join('\n') }] },
             };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `timeline error: ${err.message}` }], isError: true } };
         }
-        catch (err) {
+    }
+    function handleThumbsUp(id, args) {
+        try {
+            const memoryId = args.id;
+            if (!memoryId) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: id is required' }], isError: true } };
+            }
+            const existing = memoryStore.get(memoryId);
+            if (!existing) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: Memory ${memoryId} not found` }], isError: true } };
+            }
+            // Boost importance (cap at 1.0)
+            const newImportance = Math.min(1.0, (existing.importance || 0.5) + 0.1);
+            memoryStore.update(memoryId, { importance: newImportance });
+            // Record in user_signals table
+            try {
+                const db = memoryStore.db || memoryStore.connection;
+                db.prepare('INSERT INTO user_signals (memory_id, signal, timestamp) VALUES (?, ?, ?)')
+                    .run(memoryId, 'thumbs_up', Date.now());
+            } catch { /* table might not exist */ }
+            (0, memory_cache_1.invalidateCache)();
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: `👍 Upvoted: "${existing.intent.slice(0, 80)}"\nImportance: ${(newImportance * 100).toFixed(0)}%` }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `thumbs_up error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleThumbsDown(id, args) {
+        try {
+            const memoryId = args.id;
+            const reason = args.reason || 'Not useful';
+            if (!memoryId) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: id is required' }], isError: true } };
+            }
+            const existing = memoryStore.get(memoryId);
+            if (!existing) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Error: Memory ${memoryId} not found` }], isError: true } };
+            }
+            // Demote importance
+            const newImportance = Math.max(0.0, (existing.importance || 0.5) - 0.15);
+            memoryStore.update(memoryId, { importance: newImportance });
+            // Record in user_signals table
+            let downvoteCount = 0;
+            try {
+                const db = memoryStore.db || memoryStore.connection;
+                db.prepare('INSERT INTO user_signals (memory_id, signal, correction, timestamp) VALUES (?, ?, ?, ?)')
+                    .run(memoryId, 'thumbs_down', reason, Date.now());
+                // Count total downvotes for this memory
+                const row = db.prepare('SELECT COUNT(*) as cnt FROM user_signals WHERE memory_id = ? AND signal = ?')
+                    .get(memoryId, 'thumbs_down');
+                downvoteCount = row ? row.cnt : 0;
+            } catch { /* table might not exist */ }
+            // Auto-deactivate if 3+ downvotes
+            let deactivated = false;
+            if (downvoteCount >= 3) {
+                memoryStore.deactivate(memoryId);
+                deactivated = true;
+            }
+            (0, memory_cache_1.invalidateCache)();
+            let msg = `👎 Downvoted: "${existing.intent.slice(0, 80)}"\nImportance: ${(newImportance * 100).toFixed(0)}%\nReason: ${reason}`;
+            if (deactivated) {
+                msg += `\n\n⚠️ Memory auto-deactivated (received ${downvoteCount} downvotes).`;
+            }
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: msg }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `thumbs_down error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleBackupBrain(id) {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const dbPath = memoryStore.db?.name || memoryStore._dbPath;
+            if (!dbPath || !fs.existsSync(dbPath)) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: Cannot locate database file.' }], isError: true } };
+            }
+            const backupDate = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = path.join(path.dirname(dbPath), `cognitive-backup-${backupDate}.db`);
+            // Close active WAL before backup
+            memoryStore.checkpoint?.();
+            fs.copyFileSync(dbPath, backupPath);
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `Resume work error: ${err.message}` }], isError: true },
+                result: { content: [{ type: 'text', text: `✅ Database backed up successfully!\n\nSaved to: ${backupPath}\nSize: ${(fs.statSync(backupPath).size / 1024 / 1024).toFixed(2)} MB` }] },
             };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `backup error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleGetDailySummary(id, args) {
+        try {
+            const dateStr = args.date || new Date().toISOString().split('T')[0];
+            const db = memoryStore.db || memoryStore.connection;
+            // First check if it exists
+            const row = db.prepare('SELECT summary FROM daily_summaries WHERE date = ?').get(dateStr);
+            if (row) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `# Summary for ${dateStr}\n\n${row.summary}` }] } };
+            }
+            // If checking today and no summary exists, let's create a dynamic one
+            const isToday = dateStr === new Date().toISOString().split('T')[0];
+            if (!isToday) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `No summary found for ${dateStr}.` }] } };
+            }
+            // Generate dynamic summary for today
+            const startOfDay = new Date(dateStr).setHours(0,0,0,0);
+            const todayMemories = db.prepare('SELECT * FROM memory_units WHERE is_active = 1 AND created_at >= ? ORDER BY created_at ASC').all(startOfDay);
+            if (todayMemories.length === 0) {
+                return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `No memories recorded yet today (${dateStr}).` }] } };
+            }
+            const lines = [];
+            let types = { DECISION: 0, BUG_FIX: 0, CORRECTION: 0, CONVENTION: 0 };
+            for (const m of todayMemories) {
+                if (types[m.type] !== undefined) types[m.type]++;
+                lines.push(`- **[${m.type}]** ${m.intent}`);
+            }
+            const summaryText = `Today we recorded ${todayMemories.length} memories (${types.DECISION} decisions, ${types.BUG_FIX} fixes, ${types.CORRECTION} corrections, ${types.CONVENTION} conventions).\n\nKey updates:\n${lines.join('\n')}`;
+            // Save it
+            db.prepare('INSERT OR REPLACE INTO daily_summaries (date, summary, created_at) VALUES (?, ?, ?)')
+                .run(dateStr, summaryText, Date.now());
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `# Summary for Today (${dateStr})\n\n${summaryText}` }] } };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `summary error: ${err.message}` }], isError: true } };
+        }
+    }
+    function handleAnalytics(id) {
+        try {
+            const db = memoryStore.db || memoryStore.connection;
+            const stats = [];
+            // Basic counts
+            const total = db.prepare('SELECT COUNT(*) as c FROM memory_units').get().c;
+            const active = db.prepare('SELECT COUNT(*) as c FROM memory_units WHERE is_active = 1').get().c;
+            const pinned = db.prepare("SELECT COUNT(*) as c FROM memory_units WHERE is_active = 1 AND tags LIKE '%pinned%'").get().c;
+            stats.push(`## 📊 Brain Health\n- Total Memories: ${total}\n- Active Memories: ${active}\n- Pinned Rules: ${pinned}`);
+            // By Type
+            stats.push('\n## 🧩 Distribution by Type');
+            const types = db.prepare('SELECT type, COUNT(*) as c FROM memory_units WHERE is_active = 1 GROUP BY type ORDER BY c DESC').all();
+            for (const t of types) stats.push(`- **${t.type}**: ${t.c}`);
+            // Most Accessed
+            stats.push('\n## 🔥 Most Accessed Memories (Top 5)');
+            const hot = db.prepare('SELECT id, type, intent, access_count FROM memory_units WHERE is_active = 1 AND access_count > 0 ORDER BY access_count DESC LIMIT 5').all();
+            if (hot.length) {
+                for (const h of hot) stats.push(`- [${h.access_count}x] **${h.type}**: ${h.intent} (id: ${h.id})`);
+            } else {
+                stats.push('- No memory accesses recorded yet.');
+            }
+            // Feedback stats
+            try {
+                const up = db.prepare("SELECT COUNT(*) as c FROM user_signals WHERE signal = 'thumbs_up'").get().c;
+                const down = db.prepare("SELECT COUNT(*) as c FROM user_signals WHERE signal = 'thumbs_down'").get().c;
+                if (up > 0 || down > 0) {
+                    stats.push(`\n## 👍 User Feedback\n- Upvotes: ${up}\n- Downvotes: ${down}`);
+                }
+            } catch { /* ignore if table missing */ }
+            return {
+                jsonrpc: '2.0', id,
+                result: { content: [{ type: 'text', text: stats.join('\n') }] },
+            };
+        } catch (err) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `analytics error: ${err.message}` }], isError: true } };
         }
     }
     return { handleMCPRequest };
 }
+// ─── NEW: Export/Import/Graph Handlers ─────────────────────────────────────
+async function handleExportMemoriesFn(memoryStore, id, args) {
+    try {
+        const { filePath } = args;
+        if (!filePath) return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: filePath is required' }], isError: true } };
+        const result = (0, export_import_1.exportToFile)(memoryStore, filePath);
+        return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: '✅ Exported ' + result.count + ' memories to:\n' + result.path + '\n\nShare this file with teammates or use import_memories to restore.' }] } };
+    } catch (err) {
+        return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'export error: ' + err.message }], isError: true } };
+    }
+}
+async function handleImportMemoriesFn(memoryStore, memory_cache_1, id, args) {
+    try {
+        const { filePath } = args;
+        if (!filePath) return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: filePath is required' }], isError: true } };
+        const result = (0, export_import_1.importFromFile)(memoryStore, filePath);
+        if (result.imported > 0) (0, memory_cache_1.invalidateCache)();
+        return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: '✅ Import complete!\n\n- Imported: ' + result.imported + ' memories\n- Skipped (duplicates): ' + result.skipped + '\n- Errors: ' + result.errors }] } };
+    } catch (err) {
+        return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'import error: ' + err.message }], isError: true } };
+    }
+}
+async function handleGetRelatedMemoriesFn(memoryStore, id, args) {
+    try {
+        const memoryId = args.id;
+        const maxHops = args.maxHops || 2;
+        if (!memoryId) return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: id is required' }], isError: true } };
+        const hops = Math.min(4, Math.max(1, maxHops));
+        const starting = memoryStore.get(memoryId);
+        if (!starting) return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'No memory found with id: ' + memoryId }] } };
+        const related = memoryStore.getRelated(memoryId, hops, 20);
+        if (related.length === 0) {
+            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Memory: [' + starting.type + '] ' + starting.intent + '\n\nNo related memories found yet (no graph edges). Use store_memory to build connections.' }] } };
+        }
+        const lines = ['## Starting Memory', '[' + starting.type + '] ' + starting.intent + ' (id: ' + starting.id + ')', '', '## Related Memories (via graph)'];
+        for (const r of related) {
+            lines.push('- [' + r.memory.type + '] ' + r.memory.intent + ' (id: ' + r.memory.id + ') (' + (r.score * 100).toFixed(0) + '% relevance)');
+        }
+        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: 'get_related error: ' + err.message }], isError: true } };
+    }
+}
 //# sourceMappingURL=mcp-handler.js.map