cortex-mcp 2.8.0 → 3.0.0

package/dist/server/mcp-handler.js

@@ -23,39 +23,35 @@ 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");
-// --- Query Expansion (Synonym Map) ---
-const SYNONYMS = {
-    auth: ['authentication', 'login', 'signin', 'sign-in', 'credentials'],
-    login: ['auth', 'authentication', 'signin', 'sign-in'],
-    db: ['database', 'sql', 'postgresql', 'postgres', 'mongodb', 'sqlite'],
-    database: ['db', 'sql', 'postgresql', 'postgres', 'mongodb', 'sqlite'],
-    api: ['endpoint', 'route', 'rest', 'graphql', 'http'],
-    error: ['bug', 'fix', 'issue', 'problem', 'crash', 'fail'],
-    bug: ['error', 'fix', 'issue', 'problem', 'crash'],
-    style: ['css', 'design', 'theme', 'color', 'font', 'layout'],
-    test: ['testing', 'jest', 'vitest', 'spec', 'unittest'],
-    deploy: ['deployment', 'ci', 'cd', 'pipeline', 'docker', 'build'],
-};
+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 cross_memory_linker_1 = require("../memory/cross-memory-linker");
+const access_pattern_tracker_1 = require("../memory/access-pattern-tracker");
+const soul_manager_1 = require("../memory/soul-manager");
+const daily_diary_1 = require("../memory/daily-diary");
+const memory_export_md_1 = require("../memory/memory-export-md");
+const mmr_reranker_1 = require("../memory/mmr-reranker");
+const embedding_cache_1 = require("../memory/embedding-cache");
+const query_expansion_1 = require("../memory/query-expansion");
+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");
+// --- OpenClaw-style Query Expansion (replaced basic synonym map) ---
 function expandQuery(query) {
-    const words = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
-    const expanded = new Set(words);
-    for (const word of words) {
-        if (expanded.size >= 8)
-            break; // Cap expansion to prevent FTS hang
-        const syns = SYNONYMS[word];
-        if (syns) {
-            for (const s of syns.slice(0, 2)) {
-                if (expanded.size >= 8)
-                    break;
-                expanded.add(s);
-            }
-        }
-    }
-    return Array.from(expanded).join(' OR ');
+    return (0, query_expansion_1.expandQuery)(query);
 }
 // --- MCP Tool Definitions ---
 const MCP_TOOLS = [
@@ -143,14 +139,14 @@ 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.',
+        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.',
         inputSchema: {
             type: 'object',
             properties: {
                 topic: { type: 'string', description: 'What the user is asking about (used to search for relevant memories)' },
                 currentFile: { type: 'string', description: 'Currently active file path (optional)' },
             },
-            required: [],
+            required: ['topic'],
         },
     },
     {
@@ -159,9 +155,9 @@ const MCP_TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
-                content: { type: 'string', description: 'One sentence describing the decision, correction, convention, or bug fix' },
+                memory: { type: 'string', description: 'One sentence describing the decision, correction, convention, or bug fix' },
             },
-            required: ['content'],
+            required: ['memory'],
         },
     },
     {
@@ -202,7 +198,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.',
+        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.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -240,149 +236,47 @@ const MCP_TOOLS = [
         },
     },
     {
-        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: {
-                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)' },
-            },
-        },
-    },
-    {
-        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: {
-                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: '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?".',
+        name: 'review_code',
+        description: 'Review code against your stored conventions, past bug patterns, and project decisions. Returns specific violations with memory references — like having a senior dev review your code.',
         inputSchema: {
             type: 'object',
             properties: {
-                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)' },
+                code: { type: 'string', description: 'The code to review' },
+                filename: { type: 'string', description: 'Optional filename for context-aware review' },
             },
-            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'],
+            required: ['code'],
         },
     },
     {
-        name: 'thumbs_down',
-        description: 'Mark a memory as not useful or incorrect. This demotes its importance. Repeatedly downvoted memories will be auto-deactivated.',
+        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.',
         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)' },
+                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)' },
             },
-            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.',
+        name: 'check_impact',
+        description: 'Impact analysis: before editing a file, check which other files depend on it. Shows direct and indirect dependents with risk level. Prevents breaking changes.',
         inputSchema: {
             type: 'object',
             properties: {
-                date: { type: 'string', description: 'Date in YYYY-MM-DD format (optional, defaults to today)' },
+                file: { type: 'string', description: 'The file you plan to modify' },
             },
+            required: ['file'],
         },
     },
     {
-        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: 'repair_brain',
-        description: 'Repair and optimize the memory database. Rebuilds the full-text search index, checks database integrity, removes orphaned vectors, and runs VACUUM. Use this if search stops working or the brain feels slow.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'detect_conflicts',
-        description: 'Scan all active memories for contradictions. Finds pairs of memories that say opposite things (e.g. "use PostgreSQL" vs "use MongoDB"). Returns conflicts so the user can resolve which is correct.',
+        name: 'resume_work',
+        description: 'Resume work after a conversation break. Returns: last session summary, current tasks, recent corrections (don\'t repeat!), recent decisions, and activity summary. Call this when starting a new conversation about ongoing work.',
         inputSchema: {
             type: 'object',
             properties: {},
         },
     },
-    {
-        name: 'suggest_cleanup',
-        description: 'Identify stale, low-value memories that should be deleted. Finds memories older than 30 days with low confidence, zero access count, and no pins. Returns a list the user can review and bulk-delete.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                olderThanDays: { type: 'number', description: 'Only suggest memories older than N days (default 30)' },
-            },
-        },
-    },
 ];
 // --- Dynamic Context via ContextBuilder ---
 let cachedContextBuilder = null;
@@ -404,68 +298,12 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     result: {
                         protocolVersion: '2024-11-05',
                         capabilities: { tools: {}, resources: {}, prompts: {} },
-                        serverInfo: { name: 'cortex', version: '2.7.0' },
+                        serverInfo: { name: 'Cortex', version: require('../../package.json').version },
                     },
                 };
             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',
@@ -479,7 +317,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     result: {
                         resources: [{
                                 uri: 'memory://brain/context',
-                                name: 'Brain Context',
+                                name: 'Cortex MCP Context',
                                 description: 'Top memories — corrections, decisions, conventions. Read this before every response.',
                                 mimeType: 'text/plain',
                             }],
@@ -506,6 +344,97 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     error: { code: -32602, message: `Unknown resource: ${uri}` },
                 };
             }
+            case 'prompts/list':
+                return {
+                    jsonrpc: '2.0', id,
+                    result: {
+                        prompts: [
+                            {
+                                name: 'cortex-review',
+                                description: 'Review code against stored conventions, past bugs, and project decisions. Returns specific violations.',
+                                arguments: [
+                                    { name: 'code', description: 'The code to review', required: true },
+                                    { name: 'filename', description: 'Filename for context-aware review', required: false },
+                                ],
+                            },
+                            {
+                                name: 'cortex-debug',
+                                description: 'Debug an issue using Cortex memory. Checks for similar past bugs, failed attempts, and gotchas.',
+                                arguments: [
+                                    { name: 'error', description: 'The error message or issue description', required: true },
+                                    { name: 'file', description: 'The file where the error occurs', required: false },
+                                ],
+                            },
+                            {
+                                name: 'cortex-new-feature',
+                                description: 'Pre-flight checklist before building a new feature. Gets conventions, gotchas, and architecture context.',
+                                arguments: [
+                                    { name: 'feature', description: 'What feature you plan to build', required: true },
+                                    { name: 'files', description: 'Files you plan to modify', required: false },
+                                ],
+                            },
+                        ],
+                    },
+                };
+            case 'prompts/get': {
+                const promptName = rpc.params?.name;
+                const promptArgs = rpc.params?.arguments || {};
+                if (promptName === 'cortex-review') {
+                    return {
+                        jsonrpc: '2.0', id,
+                        result: {
+                            description: 'Code review against Cortex memory',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `Review this code against all stored conventions, past bug patterns, and project decisions.\n\nFile: ${promptArgs.filename || 'unknown'}\n\n\`\`\`\n${promptArgs.code || '(no code provided)'}\n\`\`\`\n\nUse the review_code and pre_check tools to check against stored memory. Report any violations with memory IDs.`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                if (promptName === 'cortex-debug') {
+                    return {
+                        jsonrpc: '2.0', id,
+                        result: {
+                            description: 'Debug with Cortex memory context',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `I'm debugging this issue:\n\n${promptArgs.error || '(no error provided)'}\n\nFile: ${promptArgs.file || 'unknown'}\n\nUse recall_memory to search for similar past bugs, failed attempts, and gotchas. Check if this matches any known patterns. Use check_impact to see what other files might be affected.`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                if (promptName === 'cortex-new-feature') {
+                    return {
+                        jsonrpc: '2.0', id,
+                        result: {
+                            description: 'New feature pre-flight checklist',
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `I'm building a new feature: ${promptArgs.feature || '(no feature described)'}\n\nFiles I plan to modify: ${promptArgs.files || 'unknown'}\n\nBefore I start, run pre_check for each file, check_impact for dependency risks, and recall_memory for any relevant past work. Give me a checklist of things to watch out for.`,
+                                    },
+                                },
+                            ],
+                        },
+                    };
+                }
+                return {
+                    jsonrpc: '2.0', id,
+                    error: { code: -32602, message: `Unknown prompt: ${promptName}` },
+                };
+            }
             case 'tools/call': {
                 const toolName = rpc.params?.name;
                 const args = rpc.params?.arguments || {};
@@ -516,10 +445,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 > 5000) {
+                if (args.content && typeof args.content === 'string' && args.content.length > 50000) {
                     return {
                         jsonrpc: '2.0', id,
-                        result: { content: [{ type: 'text', text: 'Error: content too long (max 5000 chars)' }], isError: true },
+                        result: { content: [{ type: 'text', text: 'Error: content too long (max 50000 chars)' }], isError: true },
                     };
                 }
                 if (toolName === 'recall_memory') {
@@ -562,58 +491,25 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     return handleAutoLearn(id, args);
                 }
                 else if (toolName === 'export_memories') {
-                    return handleExportMemoriesFn(memoryStore, id, args);
+                    return handleExportMemories(id);
                 }
                 else if (toolName === 'import_memories') {
-                    return handleImportMemoriesFn(memoryStore, memory_cache_1, id, args);
-                }
-                else if (toolName === 'get_related_memories') {
-                    return handleGetRelatedMemoriesFn(memoryStore, id, args);
+                    return handleImportMemories(id, args);
                 }
                 else if (toolName === 'health_check') {
                     return handleHealthCheck(id);
                 }
-                else if (toolName === 'search_by_file') {
-                    return handleSearchByFile(id, args);
-                }
-                else if (toolName === 'pin_memory') {
-                    return handlePinMemory(id, args);
-                }
-                else if (toolName === 'unpin_memory') {
-                    return handleUnpinMemory(id, args);
-                }
-                else if (toolName === 'undo_last') {
-                    return handleUndoLast(id, args);
-                }
-                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 === 'review_code') {
+                    return handleReviewCode(id, args);
                 }
-                else if (toolName === 'thumbs_down') {
-                    return handleThumbsDown(id, args);
+                else if (toolName === 'pre_check') {
+                    return handlePreCheck(id, args);
                 }
-                else if (toolName === 'backup_brain') {
-                    return handleBackupBrain(id);
+                else if (toolName === 'check_impact') {
+                    return handleCheckImpact(id, args);
                 }
-                else if (toolName === 'get_daily_summary') {
-                    return handleGetDailySummary(id, args);
-                }
-                else if (toolName === 'analytics') {
-                    return handleAnalytics(id);
-                }
-                else if (toolName === 'repair_brain') {
-                    return handleRepairBrain(id);
-                }
-                else if (toolName === 'detect_conflicts') {
-                    return handleDetectConflicts(id);
-                }
-                else if (toolName === 'suggest_cleanup') {
-                    return handleSuggestCleanup(id, args);
+                else if (toolName === 'resume_work') {
+                    return handleResumeWork(id);
                 }
                 else {
                     return {
@@ -666,32 +562,73 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             if (ftsResults.length === 0) {
                 ftsResults = memoryStore.searchFTS(queryText, maxResults * 2);
             }
+            // OpenClaw: Try alternative queries if still 0 results
+            if (ftsResults.length === 0) {
+                const altQueries = (0, query_expansion_1.generateAlternativeQueries)(queryText);
+                for (const alt of altQueries.slice(1)) { // skip first (original)
+                    ftsResults = memoryStore.searchFTS(alt, maxResults * 2);
+                    if (ftsResults.length > 0)
+                        break;
+                }
+            }
             console.log(`  [FTS] ${ftsResults.length} results`);
-            // 2. Vector Search (if worker ready)
+            // 2. Vector Search (if worker ready) — with OpenClaw-style embedding cache
             let vectorResults = [];
             if ((0, embedding_manager_1.isWorkerReady)()) {
-                const embedding = await (0, embedding_manager_1.embedText)(queryText);
-                vectorResults = memoryStore.searchVector(new Float32Array(embedding), maxResults * 2);
+                // Check cache first (OpenClaw pattern)
+                let embeddingArr = (0, embedding_cache_1.getCachedEmbedding)(queryText);
+                if (!embeddingArr) {
+                    embeddingArr = await (0, embedding_manager_1.embedText)(queryText);
+                    (0, embedding_cache_1.cacheEmbedding)(queryText, embeddingArr);
+                }
+                vectorResults = memoryStore.searchVector(new Float32Array(embeddingArr), maxResults * 2);
                 if (vectorResults.length > 0) {
                     console.log(`  [VECTOR] ${vectorResults.length} results`);
                 }
             }
             // 3. Hybrid Ranking
             const rawRanked = (0, memory_ranker_1.rankResults)(ftsResults, vectorResults, maxResults * 2, currentFile);
-            // Map RankedResult to ScoredMemory
-            ranked = rawRanked.map(r => ({
+            // 3a. Apply MMR re-ranking (OpenClaw-style diversity)
+            const mmrRanked = (0, mmr_reranker_1.applyMMR)(rawRanked.map(r => ({
                 ...r,
                 matchMethod: 'hybrid'
-            }));
-            // 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)
+            })));
+            // Map to ScoredMemory
+            ranked = mmrRanked;
+            // 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 */ }
             }
             // 3c. Apply attention-based re-ranking (debugging→bugs, coding→conventions)
             const recallContext = (0, attention_ranker_1.detectActionContext)(queryText, currentFile);
             ranked = (0, attention_ranker_1.rankByAttention)(ranked, recallContext);
-            // 3d. Causal chain enrichment — follow graph edges from top results
+            // 3d. Apply confidence decay BEFORE causal enrichment
+            // (so related memories don't get double-penalized: score × 0.6 × decay)
+            ranked = (0, confidence_decay_1.applyConfidenceDecay)(ranked.map(r => ({ memory: r.memory, score: r.score, matchMethod: 'hybrid' })));
+            // 3e. Causal chain enrichment — follow graph edges from top results
             const enriched = [];
             const seenIds = new Set();
             for (const r of ranked.slice(0, maxResults)) {
@@ -713,20 +650,21 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     catch { /* non-fatal */ }
                 }
             }
-            // 3b. Apply confidence decay (old unused memories rank lower)
-            ranked = (0, confidence_decay_1.applyConfidenceDecay)(enriched.map(r => ({ memory: r.memory, score: r.score, matchMethod: 'hybrid' })));
+            ranked = enriched;
             // Limit to requested count
             ranked = ranked.slice(0, maxResults);
             // 4. Touch for access tracking (reinforcement — used memories get stronger)
             if (ranked.length > 0) {
-                await Promise.all(ranked.map(m => {
-                    try {
-                        return memoryStore.touch(m.memory.id);
-                    }
-                    catch {
-                        return Promise.resolve();
+                memoryStore.runTransaction(() => {
+                    for (const m of ranked) {
+                        try {
+                            memoryStore.touch(m.memory.id);
+                        }
+                        catch { /* non-fatal */ }
                     }
-                }));
+                });
+                // NEW: Record access patterns for personalized boosting
+                (0, access_pattern_tracker_1.recordBatchAccess)(ranked.map(r => ({ type: r.memory.type })));
                 (0, confidence_decay_1.runDecayMaintenance)(memoryStore); // Opportunistic decay
             }
             (0, memory_cache_1.setCache)(cacheKey, ranked);
@@ -779,7 +717,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
         }
         try {
             // License check — gate memory storage
-            const activeCount = memoryStore.getActive(9999).length;
+            const activeCount = memoryStore.activeCount();
             const storeCheck = (0, feature_gate_1.canStoreMemory)(activeCount);
             if (!storeCheck.allowed) {
                 return {
@@ -791,6 +729,13 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             const sanitized = content.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
             // Optional LLM enhancement (if API key configured)
             let enhancedTags = tags || [type.toLowerCase()];
+            // Auto-tag with project name for isolation (BUG #5)
+            if (workspaceRoot) {
+                const projectName = require('path').basename(workspaceRoot).toLowerCase().replace(/[^a-z0-9-]/g, '');
+                if (projectName && !enhancedTags.includes(`project:${projectName}`)) {
+                    enhancedTags.push(`project:${projectName}`);
+                }
+            }
             let enhancedAction = `Stored via MCP: ${sanitized.slice(0, 200)}`;
             if ((0, llm_enhancer_1.isLLMAvailable)()) {
                 try {
@@ -836,25 +781,24 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 }
             }
             catch { /* non-fatal */ }
-            // Auto-edge creation — link to recent memories of same type/files
+            // Smart cross-memory linking — connects by files, tags, AND word overlap
             try {
-                const recent = memoryStore.getByType(memType, 5);
-                for (const r of recent) {
-                    if (r.id !== memory.id) {
-                        memoryStore.addEdge({
-                            sourceId: memory.id,
-                            targetId: r.id,
-                            relation: 'related_to',
-                            weight: 0.5,
-                            timestamp: Date.now(),
-                        });
-                        break; // Link to most recent only
-                    }
-                }
+                const linksCreated = (0, cross_memory_linker_1.autoLinkMemory)(memoryStore, memory);
+                if (linksCreated > 0)
+                    console.log(`  [LINK] Auto-linked ${linksCreated} related memories`);
             }
             catch { /* non-fatal */ }
             // Feed session tracker
             (0, session_tracker_1.feedSession)({ decision: `[${type}] ${sanitized.slice(0, 60)}` });
+            // OpenClaw: Log to daily diary (store_memory path)
+            try {
+                (0, daily_diary_1.appendDiaryEntry)({
+                    type: type.toLowerCase().replace('_', '_'),
+                    content: sanitized.slice(0, 100),
+                    file: files?.[0],
+                });
+            }
+            catch { /* diary is non-critical */ }
             // Queue background embedding
             if ((0, embedding_manager_1.isWorkerReady)()) {
                 const embedText_ = [sanitized, reason || ''].join(' ').trim();
@@ -877,6 +821,15 @@ 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: {
@@ -888,6 +841,16 @@ 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),
                     }],
             },
@@ -917,16 +880,46 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 extraMemories += (0, architecture_graph_1.storeArchitectureGraph)(memoryStore, archGraph);
             }
             catch { /* non-fatal */ }
+            // Convention auto-detection — analyze actual code patterns
+            try {
+                const conventions = (0, convention_detector_1.detectConventions)(root);
+                for (const conv of conventions) {
+                    try {
+                        (0, memory_quality_1.storeWithQuality)(memoryStore, {
+                            type: 'CONVENTION',
+                            intent: conv.pattern,
+                            action: conv.evidence,
+                            reason: `Auto-detected from code (${conv.category}, confidence: ${conv.confidence})`,
+                            confidence: conv.confidence,
+                            importance: conv.confidence,
+                            tags: ['convention', 'auto-detected', conv.category],
+                        });
+                        extraMemories++;
+                    }
+                    catch { /* skip duplicates */ }
+                }
+            }
+            catch { /* non-fatal */ }
             (0, memory_cache_1.invalidateCache)();
+            (0, usage_stats_1.trackScan)();
             const total = count + extraMemories;
+            // Report knowledge gaps after scan
+            let gapReport = '';
+            try {
+                const gaps = (0, meta_memory_1.detectKnowledgeGaps)(memoryStore, root);
+                if (gaps.length > 0) {
+                    gapReport = `\n\n${(0, meta_memory_1.formatKnowledgeGaps)(gaps)}`;
+                }
+            }
+            catch { /* non-fatal */ }
             return {
                 jsonrpc: '2.0', id,
                 result: {
                     content: [{
                             type: 'text',
                             text: total > 0
-                                ? `Project scanned successfully. ${total} memories created (stack, structure, config, git history, export map, architecture graph).`
-                                : 'Project was already scanned. No new memories created.',
+                                ? `Project scanned successfully. ${total} memories created (stack, structure, config, git history, export map, architecture graph, coding conventions).${gapReport}`
+                                : `Project was already scanned. No new memories created.${gapReport}`,
                         }],
                 },
             };
@@ -1002,6 +995,9 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             };
         }
         try {
+            // Track file for relationship mapping
+            if (args.filename)
+                (0, file_relationships_1.recordFileEdit)(args.filename);
             const result = (0, code_verifier_1.verifyCode)(args.code, root);
             const lines = [];
             // Imports
@@ -1028,6 +1024,20 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                     for (const [file, available] of Object.entries(result.exports.available)) {
                         lines.push(`   ${file} exports: ${available.join(', ')}`);
                     }
+                    // Smart fix suggestions — find closest real exports
+                    try {
+                        const wsRoot = args.workspaceRoot || workspaceRoot;
+                        if (wsRoot) {
+                            const exportMap = (0, export_map_1.buildExportMap)(wsRoot);
+                            for (const invalid of result.exports.invalid) {
+                                const suggestions = (0, export_map_2.suggestRealExport)(exportMap, invalid);
+                                if (suggestions.length > 0) {
+                                    lines.push(`   💡 Did you mean: ${suggestions.slice(0, 3).join(', ')}?`);
+                                }
+                            }
+                        }
+                    }
+                    catch { /* non-fatal */ }
                 }
             }
             // Env vars
@@ -1046,6 +1056,12 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             if (lines.length === 0) {
                 lines.push('No imports, exports, or env vars detected in the code.');
             }
+            // Track hallucination catches for usage stats
+            const catchCount = result.imports.invalid.length + result.exports.invalid.length + result.envVars.invalid.length;
+            if (catchCount > 0) {
+                for (let i = 0; i < catchCount; i++)
+                    (0, usage_stats_1.trackCatch)();
+            }
             return {
                 jsonrpc: '2.0', id,
                 result: { content: [{ type: 'text', text: lines.join('\n') }] },
@@ -1067,7 +1083,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 result: { content: [{ type: 'text', text: `[WARN] Rate limited: ${rateCheck.reason}` }], isError: true },
             };
         }
-        const text = (args.content || args.memory)?.trim();
+        const text = (args.memory || args.content)?.trim(); // Accept both parameter names
         if (!text || text.length < 5) {
             return {
                 jsonrpc: '2.0', id,
@@ -1129,35 +1145,108 @@ 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)();
-            const topic = args.topic || args.query || '';
-            if (topic)
-                (0, session_tracker_1.feedSession)({ topic });
-            // ─── BRAIN LAYER 1: Maintenance (runs in background) ─────────────
-            try {
-                // Decay old unused memories
-                (0, confidence_decay_1.runDecayMaintenance)(memoryStore);
-                // Boost frequently corrected topics
-                (0, learning_rate_1.boostFrequentCorrections)(memoryStore);
-                // Consolidate similar memories if needed
-                if ((0, memory_consolidator_1.shouldConsolidate)(memoryStore)) {
-                    (0, memory_consolidator_1.consolidateMemories)(memoryStore);
+            (0, usage_stats_1.resetSessionStats)();
+            if (args.topic)
+                (0, session_tracker_1.feedSession)({ topic: args.topic });
+            // ─── SOUL LAYER (OpenClaw-style identity) ────────────────────────
+            if (workspaceRoot) {
+                try {
+                    (0, soul_manager_1.initSoul)(workspaceRoot);
+                    const soulContext = (0, soul_manager_1.formatSoul)(workspaceRoot);
+                    if (soulContext)
+                        parts.push(soulContext);
                 }
+                catch { /* soul is non-critical */ }
             }
-            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}`);
+            // ─── 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);
+                    }
                 }
-            }
-            // ─── BRAIN LAYER 2: Attention Context ────────────────────────────
+                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
+                (0, confidence_decay_1.runDecayMaintenance)(memoryStore);
+                // Boost frequently corrected topics
+                (0, learning_rate_1.boostFrequentCorrections)(memoryStore);
+                // Consolidate similar memories if needed
+                if ((0, memory_consolidator_1.shouldConsolidate)(memoryStore)) {
+                    (0, memory_consolidator_1.consolidateMemories)(memoryStore);
+                }
+                // OpenClaw: Auto-learn soul from high-access memories
+                if (workspaceRoot) {
+                    const topMemories = memoryStore.getActive(50).map(m => ({
+                        type: m.type, intent: m.intent, accessCount: m.accessCount
+                    }));
+                    (0, soul_manager_1.autoLearnSoul)(workspaceRoot, topMemories);
+                }
+                // OpenClaw: Load access profile for personalized ranking
+                (0, access_pattern_tracker_1.loadAccessProfile)(memoryStore);
+                // OpenClaw: Auto-import user edits from MEMORY.md
+                if (workspaceRoot) {
+                    try {
+                        const imported = (0, memory_export_md_1.importMemoryMd)(workspaceRoot, memoryStore);
+                        if (imported > 0)
+                            console.log(`  [MEMORY.md] Imported ${imported} user-edited memories`);
+                    }
+                    catch { /* non-fatal */ }
+                }
+            }
+            catch { /* maintenance errors are non-fatal */ }
+            // ─── 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) : '';
             if (attentionLabel)
@@ -1169,28 +1258,6 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 for (const s of sessions)
                     parts.push(s);
             }
-            // ─── BRAIN LAYER 3.5: What's New Since Last Session ──────────────
-            try {
-                const db = memoryStore.db || memoryStore.connection;
-                const oneDayAgo = Date.now() - 86400000;
-                const recentNew = db.prepare(
-                    'SELECT type, intent FROM memory_units WHERE is_active = 1 AND created_at > ? ORDER BY created_at DESC LIMIT 10'
-                ).all(oneDayAgo);
-                if (recentNew.length > 0) {
-                    const typeCounts = {};
-                    for (const m of recentNew) {
-                        typeCounts[m.type] = (typeCounts[m.type] || 0) + 1;
-                    }
-                    const summary = Object.entries(typeCounts).map(([t, c]) => `${c} ${t.toLowerCase()}${c > 1 ? 's' : ''}`).join(', ');
-                    parts.push(`\n## 🆕 Since Last Session\n_${recentNew.length} new memories (${summary})_`);
-                    for (const m of recentNew.slice(0, 5)) {
-                        parts.push(`- [${m.type}] ${m.intent}`);
-                    }
-                    if (recentNew.length > 5) {
-                        parts.push(`_...and ${recentNew.length - 5} more_`);
-                    }
-                }
-            } catch { /* non-fatal */ }
             // ─── BRAIN LAYER 4: Hot Corrections (learning rate) ──────────────
             const hotCorrections = (0, learning_rate_1.formatHotCorrections)(memoryStore);
             if (hotCorrections)
@@ -1202,149 +1269,297 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 maxChars: 8000, // leave room for brain layers
             });
             parts.push(fullContext);
-            // ─── 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`);
+            // ─── 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));
                     }
-                    // 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 (topic) {
-                try {
-                    let ftsResults = memoryStore.searchFTS(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 });
+                    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 7.5: Daily Diary (OpenClaw-style)
+                (async () => {
+                    try {
+                        return (0, daily_diary_1.formatDiaryContext)();
+                    }
+                    catch {
+                        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 '';
+                    }
+                })(),
+                // 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 });
+                                    }
                                 }
                             }
+                            catch { }
                         }
-                        catch { }
-                    }
-                    if (enriched.length > 0) {
-                        parts.push('\n## Topic: "' + topic + '"');
-                        for (const m of enriched.slice(0, 15)) {
-                            parts.push(`- [${m.memory.type}] ${m.memory.intent}${m.memory.reason ? ` — ${m.memory.reason}` : ''}`);
+                        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).';
+                    }
+                }),
+                // Layers 10-12 (Knowledge Gaps, Export Map, Architecture Graph) REMOVED from force_recall.
+                // These are heavy filesystem scans that cause 3-8s delays. They run in scan_project instead.
+            ]);
+            // 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');
                 }
-                catch {
-                    parts.push('\n> Note: Topic search unavailable (FTS index needs rebuild).');
+                if (output.length > MAX_CHARS) {
+                    output = output.slice(0, MAX_CHARS);
                 }
+                output += '\n\n> (Some context trimmed to fit token budget. Use `recall_memory` for specific queries.)';
             }
-            // ─── BRAIN LAYER 10: Knowledge Gaps (meta-memory) ────────────────
+            // 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 gaps = (0, meta_memory_1.detectKnowledgeGaps)(memoryStore, workspaceRoot || '');
-                const gapText = (0, meta_memory_1.formatKnowledgeGaps)(gaps);
-                if (gapText)
-                    parts.push('\n' + gapText);
+                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 */ }
-            // ─── 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);
+            // Inject tool recommendations (what to use based on context)
+            try {
+                const recs = (0, tool_recommender_1.recommendTools)({
+                    topic: args.topic,
+                    currentFile: args.currentFile,
+                    isNewConversation: true,
+                });
+                const recText = (0, tool_recommender_1.formatRecommendations)(recs);
+                if (recText)
+                    output += '\n\n' + recText;
+            }
+            catch { /* non-fatal */ }
+            // Inject user preferences (adapts AI behavior)
+            try {
+                const prefText = (0, preference_learner_1.getStoredPreferences)(memoryStore);
+                if (prefText)
+                    output += '\n\n' + prefText;
+            }
+            catch { /* non-fatal */ }
+            // Append stats footer (makes value visible — 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`);
+                        }
                     }
                 }
-                catch { /* non-fatal */ }
-            }
-            // ─── 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);
+                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}\``);
+                        }
                     }
                 }
-                catch { /* non-fatal */ }
             }
-            // ─── 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);
+            // 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`);
                 }
-                output += '\n\n> (Lower-priority context removed to fit token budget. Use `recall_memory` for specific queries.)';
-            } else {
-                output = parts.join('\n');
             }
-            // ─── 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.' }] },
-                };
+            // Check for CORRECTION patterns
+            const corrections = memoryStore.getByType('CORRECTION', 50);
+            for (const corr of corrections) {
+                const corrLower = corr.intent.toLowerCase();
+                const corrTerms = corrLower.split(/\s+/).filter(w => w.length > 4);
+                const matchCount = corrTerms.filter(t => codeLower.includes(t)).length;
+                if (matchCount >= 3) {
+                    violations.push(`🔄 **Past Correction Applies** \`id:${corr.id}\`: "${corr.intent}"`);
+                }
+            }
+            // File-specific memories
+            if (filename) {
+                const fileMemories = memoryStore.getByFile(filename, 10);
+                for (const fm of fileMemories) {
+                    suggestions.push(`📄 **File Note** \`id:${fm.id}\`: "${fm.intent}"`);
+                }
+            }
+            (0, usage_stats_1.trackReview)();
+            const lines = ['# Cortex Code Review\n'];
+            if (violations.length > 0) {
+                lines.push(`## ⚠️ ${violations.length} Issue${violations.length > 1 ? 's' : ''} Found\n`);
+                violations.forEach(v => lines.push(v));
+            }
+            if (suggestions.length > 0) {
+                lines.push(`\n## 💡 ${suggestions.length} Suggestion${suggestions.length > 1 ? 's' : ''}\n`);
+                suggestions.forEach(s => lines.push(s));
+            }
+            if (violations.length === 0 && suggestions.length === 0) {
+                lines.push('✅ **No issues found.** Code looks clean against your stored conventions and past bugs.');
+                lines.push(`\n_Checked against ${conventions.length} conventions, ${bugFixes.length} bug fixes, ${corrections.length} corrections._`);
+            }
+            else {
+                lines.push(`\n_Reviewed against ${conventions.length} conventions, ${bugFixes.length} bug fixes, ${corrections.length} corrections._`);
             }
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: output }] },
+                result: { content: [{ type: 'text', text: lines.join('\n') }] },
             };
         }
         catch (err) {
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `Force recall error: ${err.message}` }], isError: true },
+                result: { content: [{ type: 'text', text: `Review error: ${err.message}` }], isError: true },
             };
         }
     }
@@ -1488,7 +1703,7 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
     }
     async function handleAutoLearn(id, args) {
         try {
-            // Feature gate check (auto_learn is now free!)
+            // Feature gate (launch mode: all features unlocked)
             if (!(0, feature_gate_1.isFeatureAllowed)('autoLearn')) {
                 return {
                     jsonrpc: '2.0', id,
@@ -1512,6 +1727,50 @@ 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) {
@@ -1539,6 +1798,68 @@ 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');
+                // Auto-tag with project name for isolation (BUG #5)
+                if (workspaceRoot) {
+                    const projName = require('path').basename(workspaceRoot).toLowerCase().replace(/[^a-z0-9-]/g, '');
+                    if (projName)
+                        tags.push(`project:${projName}`);
+                }
+                return [...new Set(tags)].slice(0, 10); // Cap at 10 tags
+            }
             const stored = [];
             const skipped = [];
             for (const item of extracted) {
@@ -1564,31 +1885,25 @@ 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: mappedType,
+                        type: item.type,
                         intent: item.content,
-                        action: item.content,
+                        action: `auto_learn:${item.type.toLowerCase()}`,
                         reason: item.reason,
                         confidence: item.confidence,
-                        importance: item.confidence,
-                        tags: [item.type.toLowerCase()],
+                        importance: calculateImportance(item),
+                        tags: extractTopicTags(item),
                     });
-                    if (result) {
+                    if (result) { // storeWithQuality returns memory object or null
                         stored.push(`[${item.type}] ${item.content.slice(0, 60)}${item.content.length > 60 ? '…' : ''}`);
+                        // OpenClaw-style diary logging
+                        try {
+                            (0, daily_diary_1.appendDiaryEntry)({
+                                type: item.type.toLowerCase().replace('_', '_'),
+                                content: item.content.slice(0, 100),
+                            });
+                        }
+                        catch { /* diary is non-critical */ }
                     }
                     else {
                         skipped.push(`[${item.type}] ${item.content.slice(0, 40)}… (duplicate)`);
@@ -1600,6 +1915,144 @@ 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)();
+                // OpenClaw: Auto-export curated MEMORY.md after storing new memories
+                if (workspaceRoot && stored.length >= 2) {
+                    try {
+                        (0, memory_export_md_1.generateMemoryMd)(memoryStore, workspaceRoot);
+                    }
+                    catch { /* non-fatal */ }
+                }
+            }
+            // ─── 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) { // storeWithQuality returns memory object or null
+                        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) { // storeWithQuality returns memory object or null
+                            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) { // storeWithQuality returns memory object or null
+                            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) { // storeWithQuality returns memory object or null
+                            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) { // storeWithQuality returns memory object or null
+                            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) {
@@ -1682,14 +2135,16 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
                 '# Cortex Health Check\n',
                 `| Metric | Value |`,
                 `|--------|-------|`,
-                `| Plan | **Full Brain — 100% Free** |`,
                 `| Active Memories | ${activeCount} |`,
-                `| Brain Layers | All 12 Active |`,
-                `| Session Store Count | ${stats.storeCount}/500 |`,
-                `| Session Auto-Learn Count | ${stats.autoLearnCount}/1000 |`,
-                `| Session Total Calls | ${stats.totalCalls}/5000 |`,
+                `| Session Store Count | ${stats.storeCount}/100 |`,
+                `| Session Auto-Learn Count | ${stats.autoLearnCount}/500 |`,
+                `| Session Total Calls | ${stats.totalCalls}/2000 |`,
                 `| Uptime | ${Math.floor(stats.uptime / 60)}m ${stats.uptime % 60}s |`,
-                `| Status | ✅ Healthy |`,
+                `| Diary Days | ${(0, daily_diary_1.getDiaryStats)().totalDays} |`,
+                `| Today's Diary Entries | ${(0, daily_diary_1.getDiaryStats)().todayEntries} |`,
+                `| Top Memory Types | ${(0, access_pattern_tracker_1.getTopTypes)(3).map(t => `${t.type}(${t.count})`).join(', ') || 'none yet'} |`,
+                `| Access Profile | ${(0, access_pattern_tracker_1.getAccessProfile)() ? 'loaded' : 'empty'} |`,
+                `| Status | Healthy |`,
             ];
             return {
                 jsonrpc: '2.0', id,
@@ -1703,584 +2158,101 @@ function createMCPHandler(memoryStore, eventLog, workspaceRoot) {
             };
         }
     }
-    // ═══ NEW TOOLS: search_by_file, pin, unpin, undo, clear, timeline, thumbs ═══
-    function handleSearchByFile(id, args) {
+    // ─── Pre-Flight Check Handler ───────────────────────────────────────────────
+    function handlePreCheck(id, args) {
         try {
-            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 },
-                };
-            }
-            // 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;
+            // Track file for relationship mapping
+            if (args.filename)
+                (0, file_relationships_1.recordFileEdit)(args.filename);
+            const result = (0, pre_flight_1.preFlightCheck)(memoryStore, args.filename, args.task);
+            let text = (0, pre_flight_1.formatPreFlight)(result);
+            // Add file relationship warnings
+            if (args.filename) {
+                const warnings = (0, file_relationships_1.checkMissingRelated)(args.filename, memoryStore);
+                if (warnings.length > 0) {
+                    text += '\n\n## 🔗 File Relationships\n';
+                    warnings.forEach(w => text += w + '\n');
+                }
+            }
+            // Add architecture context — show file's role in the system
+            if (args.filename && workspaceRoot) {
                 try {
-                    const 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);
+                    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;
                         }
                     }
-                } 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: `search_by_file error: ${err.message}` }], isError: true },
-            };
-        }
-    }
-    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: `📌 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 } };
-        }
-    }
-    function handleUnpinMemory(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 } };
+                    if (deps && (deps.imports?.length > 0 || deps.importedBy?.length > 0)) {
+                        text += '\n\n## \ud83c\udfd7\ufe0f Architecture Context';
+                        if (deps.imports?.length > 0) {
+                            text += `\n**Imports from:** ${deps.imports.slice(0, 10).join(', ')}`;
+                        }
+                        if (deps.importedBy?.length > 0) {
+                            text += `\n**Imported by:** ${deps.importedBy.slice(0, 10).join(', ')}`;
+                        }
+                    }
+                }
+                catch { /* non-fatal */ }
             }
-            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.` }] },
+                result: { content: [{ type: 'text', text }] },
             };
-        } 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: 'No memories to undo.' }] },
-                };
-            }
-            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: `⏪ 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 } };
-        }
-    }
-    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` : '';
+        catch (err) {
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `🗑️ Cleared ${cleared} ${type === 'ALL' ? '' : type + ' '}memories${ageMsg}.` }] },
+                result: { content: [{ type: 'text', text: `Pre-check error: ${err.message}` }], isError: true },
             };
-        } catch (err) {
-            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `clear error: ${err.message}` }], isError: true } };
-        }
-    }
-    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) {
+    // ─── Impact Analysis Handler ───────────────────────────────────────────────
+    function handleCheckImpact(id, args) {
         try {
-            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) {
+            const file = args.file;
+            if (!file) {
                 return {
                     jsonrpc: '2.0', id,
-                    result: { content: [{ type: 'text', text: `No memories found between ${new Date(fromTs).toLocaleDateString()} and ${new Date(toTs).toLocaleDateString()}.` }] },
+                    result: { content: [{ type: 'text', text: 'Error: file parameter is required' }], isError: true },
                 };
             }
-            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._`);
+            const wsRoot = args.workspaceRoot || process.cwd();
+            const result = (0, impact_analyzer_1.analyzeImpact)(file, wsRoot);
+            const text = (0, impact_analyzer_1.formatImpact)(result);
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+                result: { content: [{ type: 'text', text }] },
             };
-        } catch (err) {
-            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `timeline error: ${err.message}` }], isError: true } };
         }
-    }
-    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: `✅ 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 } };
-        }
-    }
-    // ═══ NEW CORE TOOLS: repair_brain, detect_conflicts, suggest_cleanup ═══
-    function handleRepairBrain(id) {
-        try {
-            const db = memoryStore.db || memoryStore.connection;
-            const repairs = [];
-            // 1. Integrity check
-            const integrityResult = db.pragma('integrity_check');
-            const integrityOk = integrityResult && integrityResult[0] && integrityResult[0].integrity_check === 'ok';
-            repairs.push(integrityOk ? '✅ Database integrity: OK' : '⚠️ Database integrity issues detected');
-            // 2. Rebuild FTS index
-            try {
-                db.exec("INSERT INTO memory_fts(memory_fts) VALUES('rebuild')");
-                repairs.push('✅ Full-text search index: Rebuilt');
-            } catch (e) {
-                repairs.push('⚠️ FTS rebuild failed: ' + e.message);
-            }
-            // 3. Fix orphaned vectors (vectors for deleted memories)
-            try {
-                const orphaned = db.prepare(
-                    "DELETE FROM memory_vectors WHERE memory_id NOT IN (SELECT id FROM memory_units WHERE is_active = 1)"
-                ).run();
-                repairs.push(`✅ Orphaned vectors: Cleaned ${orphaned.changes} entries`);
-            } catch { repairs.push('✅ Orphaned vectors: None (table may not exist)'); }
-            // 4. Fix memories with missing created_at
-            try {
-                const fixed = db.prepare(
-                    "UPDATE memory_units SET created_at = timestamp WHERE created_at = 0 OR created_at IS NULL"
-                ).run();
-                if (fixed.changes > 0) {
-                    repairs.push(`✅ Fixed ${fixed.changes} memories with missing created_at`);
-                }
-            } catch { }
-            // 5. WAL checkpoint + VACUUM
-            try {
-                db.pragma('wal_checkpoint(TRUNCATE)');
-                db.exec('VACUUM');
-                repairs.push('✅ Database compacted (VACUUM)');
-            } catch (e) {
-                repairs.push('⚠️ VACUUM failed: ' + e.message);
-            }
-            // 6. Stats after repair
-            const activeCount = memoryStore.activeCount();
-            repairs.push(`\n📊 Active memories: ${activeCount}`);
-            (0, memory_cache_1.invalidateCache)();
+        catch (err) {
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: `# 🔧 Brain Repair Complete\n\n${repairs.join('\n')}` }] },
+                result: { content: [{ type: 'text', text: `Impact analysis error: ${err.message}` }], isError: true },
             };
-        } catch (err) {
-            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Repair error: ${err.message}` }], isError: true } };
         }
     }
-    function handleDetectConflicts(id) {
+    // ─── Resume Work Handler ───────────────────────────────────────────────────
+    function handleResumeWork(id) {
         try {
-            const memories = memoryStore.getActive(500);
-            // Only look at decisions and conventions — these are the ones that conflict
-            const candidates = memories.filter(m =>
-                ['DECISION', 'CONVENTION', 'CORRECTION'].includes(m.type)
-            );
-            const conflicts = [];
-            // Compare each pair for contradictions
-            const OPPOSITE_PAIRS = [
-                ['always', 'never'], ['use', 'avoid'], ['enable', 'disable'],
-                ['allow', 'block'], ['include', 'exclude'], ['add', 'remove'],
-                ['yes', 'no'], ['true', 'false'], ['must', 'must not'],
-                ['do', "don't"], ['do', 'do not'], ['can', 'cannot'],
-            ];
-            for (let i = 0; i < candidates.length; i++) {
-                for (let j = i + 1; j < candidates.length; j++) {
-                    const a = candidates[i];
-                    const b = candidates[j];
-                    const aText = (a.intent + ' ' + (a.action || '')).toLowerCase();
-                    const bText = (b.intent + ' ' + (b.action || '')).toLowerCase();
-                    // Check if they share a subject but have opposite verbs
-                    let isConflict = false;
-                    for (const [pos, neg] of OPPOSITE_PAIRS) {
-                        if ((aText.includes(pos) && bText.includes(neg)) ||
-                            (aText.includes(neg) && bText.includes(pos))) {
-                            // Check they share at least one significant word (3+ chars)
-                            const aWords = aText.split(/\s+/).filter(w => w.length > 3);
-                            const bWords = new Set(bText.split(/\s+/).filter(w => w.length > 3));
-                            const shared = aWords.filter(w => bWords.has(w));
-                            if (shared.length >= 1) {
-                                isConflict = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (isConflict) {
-                        conflicts.push({
-                            a: { id: a.id, type: a.type, intent: a.intent, age: Math.floor((Date.now() - a.createdAt) / 86400000) },
-                            b: { id: b.id, type: b.type, intent: b.intent, age: Math.floor((Date.now() - b.createdAt) / 86400000) },
-                        });
-                    }
-                }
-            }
-            if (conflicts.length === 0) {
-                return {
-                    jsonrpc: '2.0', id,
-                    result: { content: [{ type: 'text', text: '✅ No conflicts detected! All memories are consistent.' }] },
-                };
-            }
-            const lines = [`# ⚠️ ${conflicts.length} Potential Conflict(s) Detected\n`];
-            for (let i = 0; i < conflicts.length; i++) {
-                const c = conflicts[i];
-                lines.push(`### Conflict ${i + 1}`);
-                lines.push(`**A:** [${c.a.type}] ${c.a.intent} _(${c.a.age}d old, id: ${c.a.id})_`);
-                lines.push(`**B:** [${c.b.type}] ${c.b.intent} _(${c.b.age}d old, id: ${c.b.id})_`);
-                lines.push(`→ Use \`delete_memory\` to remove the outdated one.\n`);
-            }
+            const ctx = (0, resume_work_1.buildResumeContext)(memoryStore);
+            const text = (0, resume_work_1.formatResumeContext)(ctx);
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+                result: { content: [{ type: 'text', text }] },
             };
-        } catch (err) {
-            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `conflict detection error: ${err.message}` }], isError: true } };
         }
-    }
-    function handleSuggestCleanup(id, args) {
-        try {
-            const olderThanDays = args.olderThanDays || 30;
-            const cutoff = Date.now() - (olderThanDays * 86400000);
-            const db = memoryStore.db || memoryStore.connection;
-            // Find stale, low-value memories
-            const stale = db.prepare(`
-                SELECT * FROM memory_units 
-                WHERE is_active = 1 
-                AND created_at < ? 
-                AND confidence < 0.4 
-                AND access_count <= 1
-                AND (tags IS NULL OR tags NOT LIKE '%pinned%')
-                ORDER BY confidence ASC, access_count ASC
-                LIMIT 25
-            `).all(cutoff);
-            if (stale.length === 0) {
-                return {
-                    jsonrpc: '2.0', id,
-                    result: { content: [{ type: 'text', text: `✅ Brain is clean! No stale memories older than ${olderThanDays} days with low value found.` }] },
-                };
-            }
-            const lines = [`# 🧹 ${stale.length} Stale Memories (Cleanup Suggestions)\n`];
-            lines.push(`These memories are older than ${olderThanDays} days, have low confidence, and are rarely accessed:\n`);
-            for (const row of stale) {
-                const age = Math.floor((Date.now() - row.created_at) / 86400000);
-                lines.push(`- **[${row.type}]** ${row.intent}`);
-                lines.push(`  _Confidence: ${(row.confidence * 100).toFixed(0)}% · Accessed: ${row.access_count}x · Age: ${age}d · id: ${row.id}_`);
-            }
-            lines.push(`\n→ Use \`delete_memory\` with each id to remove, or \`clear_memories\` for bulk cleanup.`);
+        catch (err) {
             return {
                 jsonrpc: '2.0', id,
-                result: { content: [{ type: 'text', text: lines.join('\n') }] },
+                result: { content: [{ type: 'text', text: `Resume work error: ${err.message}` }], isError: true },
             };
-        } catch (err) {
-            return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `cleanup suggestion 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