fivocell 4.0.0 → 4.1.1

package/dist/daemon/server.js

@@ -117,6 +117,12 @@ const database_1 = require("../core/database");
 const logger_1 = require("../core/logger");
 const CELL_DIR = path.join(os.homedir(), '.fivo', 'cell');
 (0, database_1.initializeDatabase)();
+try {
+    require('../behavioral-tracker').initBehaviorTables();
+}
+catch (e) {
+    console.error('Behavior tables init failed:', e);
+}
 const META_PATH = path.join(CELL_DIR, 'cell-meta.json');
 const PORT = 9876;
 function getCloudConfig() {
@@ -132,18 +138,19 @@ function getCloudConfig() {
 const app = (0, express_1.default)();
 exports.app = app;
 // All 40 modules instantiated — verifies they work in daemon context
+const sharedPatternStore = new pattern_store_1.PatternStore(CELL_DIR);
 const engines = {
     signalCapture: new signal_capture_1.SignalCapture(),
-    patternStore: new pattern_store_1.PatternStore(CELL_DIR),
+    patternStore: sharedPatternStore,
     learningLayer: null,
     confidenceEngine: new confidence_engine_1.ConfidenceEngine(),
     extractionCascade: new extraction_cascade_1.ExtractionCascade(),
     decayEngine: new decay_engine_1.DecayEngine(),
-    configAttribution: new config_attribution_1.ConfigAttribution(process.cwd()),
+    configAttribution: new config_attribution_1.ConfigAttribution(CELL_DIR),
     communityPrior: new community_prior_1.CommunityPrior(CELL_DIR),
     communityLive: new community_live_1.CommunityLive(CELL_DIR),
     communityFull: new community_full_1.CommunityFull(CELL_DIR),
-    teamComposer: new team_composer_1.TeamComposer(new pattern_store_1.PatternStore(CELL_DIR), CELL_DIR),
+    teamComposer: new team_composer_1.TeamComposer(sharedPatternStore, CELL_DIR),
     conflictDetector: new conflict_detector_1.ConflictDetector(CELL_DIR),
     promptConditioner: new prompt_conditioner_1.PromptConditioner(),
     buildFailurePredictor: new build_failure_predictor_1.BuildFailurePredictor(),
@@ -154,7 +161,7 @@ const engines = {
     mergeConflictPredictor: new merge_conflict_predictor_1.MergeConflictPredictor(),
     testAnticipator: new test_anticipator_1.TestAnticipator(),
     contextRestore: new context_restore_1.ContextRestore(CELL_DIR),
-    crossProjectSync: new cross_project_sync_1.CrossProjectSync(new pattern_store_1.PatternStore(CELL_DIR), CELL_DIR),
+    crossProjectSync: new cross_project_sync_1.CrossProjectSync(sharedPatternStore, CELL_DIR),
     solutionIndex: new solution_index_1.SolutionIndex(CELL_DIR),
     languageSwitchAssistant: new language_switch_assistant_1.LanguageSwitchAssistant(),
     interruptionRecovery: new interruption_recovery_1.InterruptionRecovery(CELL_DIR),
@@ -189,7 +196,7 @@ if (cloudConfig.cloudSyncEnabled) {
     if (patterns.length > 0)
         (0, ws_client_1.streamPatterns)(patterns);
 }
-app.use((0, cors_1.default)({ origin: true }));
+app.use((0, cors_1.default)({ origin: ['http://localhost', 'http://127.0.0.1'], credentials: false }));
 app.use(express_1.default.json({ limit: '1mb' }));
 app.use((0, morgan_1.default)('short'));
 app.get('/health', (_req, res) => {
@@ -1717,15 +1724,38 @@ app.get('/behavior/stuck', (req, res) => {
     res.json({ stuck: getStuckPatterns(String(req.query.project || undefined)) });
 });
 // ─── Session Bridge Helper ────────────────────────────────────────────────
-function formatSessionBridge(fromTool, toTool, context, decisions) {
+function formatSessionBridge(fromTool, toTool, context, decisions, options) {
     const lines = [];
     lines.push(`═══ CROSS-SESSION BRIDGE ═══`);
     lines.push(`From: ${fromTool} → To: ${toTool}`);
     if (context)
         lines.push(`Last context: ${context}`);
-    if (decisions && decisions !== 'none' && decisions !== '[]') {
+    if (decisions && decisions !== 'none' && decisions !== '[]' && decisions !== 'undefined') {
         lines.push(`Decisions made: ${decisions}`);
     }
+    if (options?.triedApproaches && options.triedApproaches.length > 0) {
+        lines.push('');
+        lines.push('🔄 TRIED ALREADY (don\'t suggest these):');
+        for (const a of options.triedApproaches.slice(0, 5)) {
+            const countSuffix = a.count > 1 ? ` (${a.count}x)` : '';
+            lines.push(`  → ${a.approach} — ${a.status}${countSuffix}`);
+        }
+    }
+    if (options?.openQuestions && options.openQuestions.length > 0) {
+        lines.push('');
+        lines.push('💭 OPEN QUESTIONS (unresolved):');
+        for (const q of options.openQuestions.slice(0, 5)) {
+            lines.push(`  → [${q.priority}] ${q.question}`);
+        }
+    }
+    if (options?.hotFiles && options.hotFiles.length > 0) {
+        lines.push('');
+        lines.push('🔥 HOT FILES (recently active):');
+        for (const f of options.hotFiles.slice(0, 5)) {
+            lines.push(`  → ${f.filePath} (${f.touchCount} touches)`);
+        }
+    }
+    lines.push('');
     lines.push(`Cell remembers. No need to re-explain.`);
     return lines.join('\n');
 }
@@ -1745,6 +1775,56 @@ const MCP_TOOLS = [
     { name: 'cell_log_context', description: 'Log current context', inputSchema: { type: 'object', properties: { project: { type: 'string' }, task: { type: 'string' }, files: { type: 'array', items: { type: 'string' } } }, required: ['task'] } },
     { name: 'cell_log_stuck', description: 'Log when stuck', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, description: { type: 'string' } }, required: ['description'] } },
     { name: 'cell_session_bridge', description: 'Cross-session memory bridge — get last session context when switching tools', inputSchema: { type: 'object', properties: { project: { type: 'string' }, tool: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_session_end', description: 'End a session — save final files, decisions, context snapshot', inputSchema: { type: 'object', properties: { sessionId: { type: 'number' }, filesTouched: { type: 'array', items: { type: 'string' } }, keyDecisions: { type: 'array', items: { type: 'string' } }, contextSnapshot: { type: 'string' } }, required: ['sessionId'] } },
+    { name: 'cell_session_log', description: 'Log session activity — approach (tried/failed), file (touched), question (open), resolve (answered)', inputSchema: { type: 'object', properties: { type: { type: 'string' }, sessionId: { type: 'number' }, project: { type: 'string' }, approach: { type: 'string' }, status: { type: 'string' }, reason: { type: 'string' }, filePath: { type: 'string' }, question: { type: 'string' }, priority: { type: 'string' }, questionId: { type: 'number' }, answer: { type: 'string' } }, required: ['type'] } },
+    { name: 'cell_session_start', description: 'Start a new session explicitly — returns session ID for tracking', inputSchema: { type: 'object', properties: { project: { type: 'string' }, tool: { type: 'string' } }, required: ['project', 'tool'] } },
+    { name: 'cell_session_status', description: 'Get current status of a session — files, approaches, active state', inputSchema: { type: 'object', properties: { sessionId: { type: 'number' } }, required: ['sessionId'] } },
+    { name: 'cell_session_recent', description: 'Get recent sessions for a project (or all projects)', inputSchema: { type: 'object', properties: { project: { type: 'string' }, limit: { type: 'number' } }, required: [] } },
+    { name: 'cell_session_recommendations', description: 'Get AI guidance — what to avoid, open questions, hot files for context', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_list_projects', description: 'List all registered projects in the workspace', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_get_project', description: 'Get full metadata for a project — stack, file count, last scan', inputSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] } },
+    { name: 'cell_detect_project', description: 'Auto-detect project from current working directory path', inputSchema: { type: 'object', properties: { cwd: { type: 'string' } }, required: ['cwd'] } },
+    { name: 'cell_register_project', description: 'Register a new project explicitly (auto-detected on scan too)', inputSchema: { type: 'object', properties: { name: { type: 'string' }, path: { type: 'string' }, stack: { type: 'string' }, fileCount: { type: 'number' } }, required: ['name', 'path'] } },
+    { name: 'cell_graph_files', description: 'Get file dependency graph (complexity, coupling, risk) for project', inputSchema: { type: 'object', properties: { project: { type: 'string' }, limit: { type: 'number', description: 'Max files to return (default 20)' } }, required: ['project'] } },
+    { name: 'cell_graph_blast_radius', description: 'Compute blast radius — which files break if I change this one?', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' } }, required: ['project', 'file'] } },
+    { name: 'cell_graph_tech', description: 'Show technology proficiency (languages, frameworks, architecture)', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_graph_stats', description: 'Get knowledge graph statistics (file + pattern + tech nodes/edges)', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_team_silos', description: 'Detect knowledge silos (bus factor risks) in the team', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_team_bus_factor', description: 'Calculate bus factor report — who knows what, single points of failure', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_team_health', description: 'Team health score (bus factor, silos, skill gaps, strengths)', inputSchema: { type: 'object', properties: { project: { type: 'string' } } } },
+    { name: 'cell_team_onboard', description: 'Generate onboarding doc for new team member', inputSchema: { type: 'object', properties: { teamName: { type: 'string' }, project: { type: 'string' } }, required: ['teamName'] } },
+    { name: 'cell_team_retro', description: 'Sprint retrospective (commits, files, contributors, key decisions)', inputSchema: { type: 'object', properties: { days: { type: 'number', description: 'Days to look back (default 14)' }, project: { type: 'string' } } } },
+    { name: 'cell_team_handoff', description: 'Generate handoff context when transferring work between team members', inputSchema: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' }, project: { type: 'string' } }, required: ['from', 'to', 'project'] } },
+    { name: 'cell_team_knowledge_transfer', description: 'Suggest knowledge transfer pairs to reduce bus factor risk', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_team_style', description: 'Compose team coding style (languages, patterns, conventions)', inputSchema: { type: 'object', properties: { project: { type: 'string' } } } },
+    { name: 'cell_team_dashboard', description: 'Combined team intelligence — silos, bus factor, health, style, all in one call', inputSchema: { type: 'object', properties: { project: { type: 'string' } } } },
+    { name: 'cell_community_stats', description: 'Community-wide stats: total patterns, insights, benchmarks, top contributors', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_community_share', description: 'Share an anonymized pattern with the community (privacy-validated)', inputSchema: { type: 'object', properties: { category: { type: 'string' }, rule: { type: 'string' }, language: { type: 'string' }, framework: { type: 'string' }, successRate: { type: 'number' } }, required: ['category', 'rule'] } },
+    { name: 'cell_community_patterns', description: 'Browse community patterns (top voted, by category, by language)', inputSchema: { type: 'object', properties: { category: { type: 'string' }, language: { type: 'string' }, minVotes: { type: 'number' }, limit: { type: 'number' } } } },
+    { name: 'cell_community_vote', description: 'Upvote or downvote a community pattern', inputSchema: { type: 'object', properties: { patternId: { type: 'string' }, upvote: { type: 'boolean' } }, required: ['patternId', 'upvote'] } },
+    { name: 'cell_community_insights', description: 'Get community insights (failure patterns, security warnings, best practices)', inputSchema: { type: 'object', properties: { severity: { type: 'string', enum: ['critical', 'warning', 'info'] }, category: { type: 'string' }, limit: { type: 'number' } } } },
+    { name: 'cell_community_benchmarks', description: 'Get benchmarks — your code vs community averages', inputSchema: { type: 'object', properties: { category: { type: 'string' }, limit: { type: 'number' } } } },
+    { name: 'cell_community_trends', description: 'Technology evolution signals — adoption phase, 30d/90d trends, migrations', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_community_failures', description: 'Failure pattern library — most common errors by language with mitigations', inputSchema: { type: 'object', properties: { language: { type: 'string' }, limit: { type: 'number' } } } },
+    { name: 'cell_community_validate', description: 'Validate a rule string for privacy safety before sharing', inputSchema: { type: 'object', properties: { rule: { type: 'string' } }, required: ['rule'] } },
+    { name: 'cell_community_dashboard', description: 'Combined community dashboard — stats + trends + insights + benchmarks', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_usage_decision_log', description: 'Log a decision with outcome (was it the right call?)', inputSchema: { type: 'object', properties: { project: { type: 'string' }, technology: { type: 'string' }, reason: { type: 'string' }, outcome: { type: 'string' }, wasRight: { type: 'boolean' }, confidence: { type: 'number' } }, required: ['project', 'technology', 'wasRight'] } },
+    { name: 'cell_usage_decision_patterns', description: 'Detect decision patterns — e.g. always picks MongoDB, always regrets it', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_usage_repeat_mistakes', description: 'Find repeated error patterns — "you keep making this mistake" alerts', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_usage_ai_stats', description: 'AI interaction stats — acceptance rate, iterations, recommendations per model', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_usage_productivity', description: 'Productivity signals — flow state, friction, context switches', inputSchema: { type: 'object', properties: { project: { type: 'string' }, signalType: { type: 'string', enum: ['flow', 'friction', 'context_switch', 'long_session'] }, durationMinutes: { type: 'number' }, filesTouched: { type: 'number' }, contextSwitches: { type: 'number' } }, required: ['project'] } },
+    { name: 'cell_usage_skills', description: 'Skill progression map — improving/regressing/plateau per technology', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_usage_burnout', description: 'Burnout risk detection from session patterns and friction signals', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_usage_dashboard', description: 'Combined usage intelligence dashboard — decisions + mistakes + AI + productivity + skills + burnout', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_watch_start', description: 'Start live file watcher for a project directory', inputSchema: { type: 'object', properties: { project: { type: 'string' }, dir: { type: 'string' } }, required: ['project', 'dir'] } },
+    { name: 'cell_watch_stop', description: 'Stop the live file watcher for a project', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_watch_status', description: 'Get watcher status (active, event count, last event)', inputSchema: { type: 'object', properties: { project: { type: 'string' } } } },
+    { name: 'cell_watch_events', description: 'Get recent live events (file save/create/delete) for a project', inputSchema: { type: 'object', properties: { project: { type: 'string' }, limit: { type: 'number' }, eventType: { type: 'string', enum: ['file_save', 'file_create', 'file_delete', 'file_rename', 'git_commit', 'package_change'] } } } },
+    { name: 'cell_watch_refresh', description: 'Manually trigger auto-refresh; force=true to bypass staleness check', inputSchema: { type: 'object', properties: { project: { type: 'string' }, force: { type: 'boolean' } }, required: ['project'] } },
+    { name: 'cell_watch_check', description: 'Check if project needs refresh (staleness detection)', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_blindspots_scan', description: 'Scan a directory for 15+ types of blind spots (error handling, null safety, perf, quality, etc.)', inputSchema: { type: 'object', properties: { dir: { type: 'string' }, maxFiles: { type: 'number' } } } },
+    { name: 'cell_blindspots_report', description: 'Get a formatted blind spot report with severity groupings and recommendations', inputSchema: { type: 'object', properties: { dir: { type: 'string' }, maxFiles: { type: 'number' } } } },
+    { name: 'cell_blindspots_summary', description: 'Get blind spot counts by category only (quick check)', inputSchema: { type: 'object', properties: { dir: { type: 'string' } } } },
     { name: 'cell_predict', description: 'Predictive intelligence — repeat mistakes, decision regret, energy warnings, complexity traps', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: [] } },
     { name: 'cell_model_track', description: 'Track AI model interaction — which tool was used, what task, accepted/rejected', inputSchema: { type: 'object', properties: { modelName: { type: 'string' }, taskType: { type: 'string' }, accepted: { type: 'boolean' }, responseTimeMs: { type: 'number' }, project: { type: 'string' }, suggestion: { type: 'string' } }, required: ['modelName', 'taskType', 'accepted'] } },
     { name: 'cell_model_recommend', description: 'Get AI model recommendations — which tool works best for which task', inputSchema: { type: 'object', properties: {} } },
@@ -1787,9 +1867,10 @@ async function handleMCPToolCall(name, args) {
             return { recorded: true };
         }
         case 'cell_get_context': {
-            const { buildContext, formatContextForInjection } = require('../core/prompt-builder');
+            const { buildContext, formatContextForTool } = require('../core/prompt-builder');
             const ctx = buildContext(args.project, args.tool);
-            return { content: [{ type: 'text', text: formatContextForInjection(ctx, false) }], context: ctx };
+            const toolName = args.tool || (args.project ? 'claude-code' : undefined);
+            return { content: [{ type: 'text', text: formatContextForTool(ctx, toolName) }], context: ctx };
         }
         case 'cell_scan_full_pc': {
             const { scanFullPC } = require('../pc-scanner');
@@ -1827,23 +1908,26 @@ async function handleMCPToolCall(name, args) {
             const project = args.project;
             const tool = args.tool || 'unknown';
             try {
-                // Get last session for this project
                 const lastSession = memory.getLastSessionForProject(project);
-                // Start new session for current tool
                 const newSessionId = memory.startSession(tool, project);
-                // If there was a previous session with a different tool, bridge it
                 let bridgeContext = '';
                 if (lastSession && lastSession.toolName !== tool) {
-                    const decisions = lastSession.keyDecisions ? JSON.stringify(lastSession.keyDecisions) : 'none';
-                    bridgeContext = formatSessionBridge(lastSession.toolName, tool, lastSession.contextSnapshot, decisions);
+                    const triedApproaches = memory.getRecentApproaches(project, 5);
+                    const openQuestions = memory.getOpenQuestions(project);
+                    const hotFiles = memory.getMostTouchedFiles(project, 5);
+                    const decisions = Array.isArray(lastSession.keyDecisions) ? JSON.stringify(lastSession.keyDecisions) : 'none';
+                    bridgeContext = formatSessionBridge(lastSession.toolName, tool, lastSession.contextSnapshot, decisions, {
+                        triedApproaches,
+                        openQuestions,
+                        hotFiles,
+                    });
                 }
-                // Get recent sessions for context chain
                 const recentSessions = memory.getRecentSessions(3).filter((s) => s.project === project);
                 const sessionHistory = recentSessions.map((s) => ({
                     tool: s.toolName,
                     when: s.startTime,
-                    files: JSON.parse(String(s.filesTouched || '[]')),
-                    decisions: JSON.parse(String(s.keyDecisions || '[]')),
+                    files: s.filesTouched,
+                    decisions: s.keyDecisions,
                 }));
                 return {
                     newSessionId,
@@ -1854,6 +1938,9 @@ async function handleMCPToolCall(name, args) {
                     } : null,
                     bridgeContext,
                     sessionHistory,
+                    triedApproaches: memory.getRecentApproaches(project, 5),
+                    openQuestions: memory.getOpenQuestions(project),
+                    hotFiles: memory.getMostTouchedFiles(project, 5),
                     message: bridgeContext || 'No previous session to bridge. Start a new session!',
                 };
             }
@@ -1862,6 +1949,819 @@ async function handleMCPToolCall(name, args) {
                 return { error: `Session bridge failed: ${msg}`, crossedSession: false };
             }
         }
+        case 'cell_session_end': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            const sessionId = args.sessionId;
+            try {
+                memory.endSession(sessionId, {
+                    filesTouched: Array.isArray(args.filesTouched) ? args.filesTouched : [],
+                    keyDecisions: Array.isArray(args.keyDecisions) ? args.keyDecisions : [],
+                    contextSnapshot: args.contextSnapshot || '',
+                });
+                return { ended: true, sessionId };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session end failed: ${msg}`, ended: false };
+            }
+        }
+        case 'cell_session_log': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            try {
+                const sessionId = args.sessionId || 0;
+                const project = args.project || 'unknown';
+                if (args.type === 'approach' && args.approach) {
+                    const id = memory.recordApproach({
+                        sessionId: sessionId || undefined,
+                        project,
+                        approach: args.approach,
+                        status: args.status || 'tried',
+                        reason: args.reason,
+                    });
+                    return { recorded: 'approach', id };
+                }
+                if (args.type === 'file' && args.filePath) {
+                    memory.recordFileTouch({ sessionId: sessionId || undefined, project, filePath: args.filePath });
+                    return { recorded: 'file' };
+                }
+                if (args.type === 'question' && args.question) {
+                    const id = memory.recordQuestion({
+                        sessionId: sessionId || undefined,
+                        project,
+                        question: args.question,
+                        priority: args.priority || 'medium',
+                    });
+                    return { recorded: 'question', id };
+                }
+                if (args.type === 'resolve' && args.questionId) {
+                    memory.resolveQuestion(args.questionId, args.answer || '');
+                    return { recorded: 'resolve' };
+                }
+                return { error: 'unknown log type or missing field' };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session log failed: ${msg}` };
+            }
+        }
+        case 'cell_session_start': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            try {
+                const project = args.project || 'unknown';
+                const tool = args.tool || 'unknown';
+                const sessionId = memory.startSession(tool, project);
+                return {
+                    sessionId,
+                    project,
+                    tool,
+                    startedAt: new Date().toISOString(),
+                    message: `Session ${sessionId} started for ${project} on ${tool}`,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session start failed: ${msg}` };
+            }
+        }
+        case 'cell_session_status': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            try {
+                const sessionId = args.sessionId;
+                const db = (0, database_1.getDb)();
+                const sess = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId);
+                if (!sess)
+                    return { error: 'Session not found', sessionId };
+                const files = memory.getSessionFiles(sessionId);
+                const approaches = memory.getSessionApproaches(sessionId);
+                const isActive = !sess.end_time;
+                return {
+                    sessionId,
+                    tool: String(sess.tool_name || ''),
+                    project: String(sess.project || ''),
+                    startTime: String(sess.start_time || ''),
+                    endTime: sess.end_time ? String(sess.end_time) : null,
+                    isActive,
+                    filesCount: files.length,
+                    approachesCount: approaches.length,
+                    files: files.slice(0, 10),
+                    approaches: approaches.slice(0, 10),
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session status failed: ${msg}` };
+            }
+        }
+        case 'cell_session_recent': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            try {
+                const project = args.project;
+                const limit = args.limit || 10;
+                let sessions = memory.getRecentSessions(limit);
+                if (project)
+                    sessions = sessions.filter((s) => s.project === project);
+                return {
+                    count: sessions.length,
+                    sessions: sessions.slice(0, limit).map((s) => ({
+                        sessionId: s.id,
+                        tool: s.toolName,
+                        project: s.project,
+                        startTime: s.startTime,
+                        endTime: s.endTime || null,
+                        filesCount: s.filesTouched.length,
+                        decisionsCount: s.keyDecisions.length,
+                    })),
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session recent failed: ${msg}` };
+            }
+        }
+        case 'cell_session_recommendations': {
+            const { SessionMemory } = require('../core/session-memory');
+            const memory = new SessionMemory();
+            try {
+                const project = args.project || 'unknown';
+                const triedApproaches = memory.getRecentApproaches(project, 10);
+                const openQuestions = memory.getOpenQuestions(project);
+                const hotFiles = memory.getMostTouchedFiles(project, 10);
+                const lastSession = memory.getLastSessionForProject(project);
+                const avoid = [];
+                for (const a of triedApproaches) {
+                    if (a.status === 'failed') {
+                        avoid.push({ approach: a.approach, reason: `failed ${a.count}x` });
+                    }
+                    else if (a.status === 'partial') {
+                        avoid.push({ approach: a.approach, reason: `partial (${a.count}x)` });
+                    }
+                }
+                return {
+                    avoid,
+                    openQuestions: openQuestions.map((q) => ({ id: q.id, question: q.question, priority: q.priority })),
+                    hotFiles: hotFiles.slice(0, 5).map((f) => ({ path: f.filePath, touches: f.touchCount })),
+                    lastSession: lastSession ? {
+                        tool: lastSession.toolName,
+                        when: lastSession.endTime,
+                        context: lastSession.contextSnapshot,
+                    } : null,
+                    message: avoid.length > 0
+                        ? `Don't suggest: ${avoid.map(a => a.approach).slice(0, 3).join(', ')}`
+                        : 'No anti-repetition data yet',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Session recommendations failed: ${msg}` };
+            }
+        }
+        case 'cell_list_projects': {
+            const { ProjectRegistry } = require('../core/project-registry');
+            const registry = new ProjectRegistry();
+            try {
+                const projects = registry.listProjects();
+                return {
+                    count: projects.length,
+                    projects: projects.map((p) => ({
+                        name: p.name,
+                        path: p.path,
+                        stack: p.stack,
+                        fileCount: p.fileCount,
+                        lastScanAt: p.lastScanAt,
+                    })),
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `List projects failed: ${msg}` };
+            }
+        }
+        case 'cell_get_project': {
+            const { ProjectRegistry } = require('../core/project-registry');
+            const registry = new ProjectRegistry();
+            try {
+                const name = args.name || '';
+                const project = registry.getProject(name);
+                if (!project)
+                    return { error: 'Project not found', name };
+                return {
+                    name: project.name,
+                    path: project.path,
+                    stack: project.stack,
+                    fileCount: project.fileCount,
+                    lastScanAt: project.lastScanAt,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Get project failed: ${msg}` };
+            }
+        }
+        case 'cell_detect_project': {
+            const { ProjectRegistry } = require('../core/project-registry');
+            const registry = new ProjectRegistry();
+            try {
+                const cwd = args.cwd || '';
+                const detected = registry.detectProjectFromCwd(cwd);
+                if (!detected) {
+                    return { detected: null, cwd, message: 'No matching project found for this path' };
+                }
+                const project = registry.getProject(detected);
+                return {
+                    detected,
+                    cwd,
+                    project: project ? {
+                        name: project.name,
+                        stack: project.stack,
+                        fileCount: project.fileCount,
+                        lastScanAt: project.lastScanAt,
+                    } : null,
+                    message: `Detected project: ${detected}`,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Detect project failed: ${msg}` };
+            }
+        }
+        case 'cell_register_project': {
+            const { ProjectRegistry } = require('../core/project-registry');
+            const registry = new ProjectRegistry();
+            try {
+                const id = registry.registerProject({
+                    name: args.name || '',
+                    path: args.path || '',
+                    stack: args.stack,
+                    fileCount: args.fileCount,
+                });
+                return { id, name: args.name, registered: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Register project failed: ${msg}` };
+            }
+        }
+        case 'cell_graph_files': {
+            try {
+                const project = args.project || '';
+                const limit = args.limit || 20;
+                const { getFileKnowledgeGraph } = require('../core/knowledge-graph-store');
+                const graph = getFileKnowledgeGraph(project);
+                return {
+                    stats: graph.stats,
+                    topRiskFiles: graph.files.slice(0, limit),
+                    entryPoints: graph.files.filter((f) => f.isEntryPoint).slice(0, 10),
+                    sampleDeps: graph.deps.slice(0, limit),
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Graph files failed: ${msg}` };
+            }
+        }
+        case 'cell_graph_blast_radius': {
+            try {
+                const project = args.project || '';
+                const file = args.file || '';
+                const { computeBlastRadius } = require('../core/knowledge-graph-store');
+                const radius = computeBlastRadius(project, file);
+                return radius;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Blast radius failed: ${msg}` };
+            }
+        }
+        case 'cell_graph_tech': {
+            try {
+                const project = args.project || '';
+                const { getTechProficiency } = require('../core/knowledge-graph-store');
+                const techs = getTechProficiency(project);
+                const strong = techs.filter((t) => t.proficiencyScore >= 70);
+                const learning = techs.filter((t) => t.proficiencyScore < 50);
+                return {
+                    totalTechs: techs.length,
+                    strong,
+                    learning,
+                    all: techs,
+                    message: strong.length > 0
+                        ? `Strong in: ${strong.map((t) => t.technology).slice(0, 3).join(', ')}`
+                        : 'No strong tech tracked yet',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Graph tech failed: ${msg}` };
+            }
+        }
+        case 'cell_graph_stats': {
+            try {
+                const project = args.project || '';
+                const { getPatternGraphStats, getFileKnowledgeGraph, getTechProficiency } = require('../core/knowledge-graph-store');
+                const patternStats = getPatternGraphStats(project);
+                const fileGraph = getFileKnowledgeGraph(project);
+                const techs = getTechProficiency(project);
+                return {
+                    patternGraph: patternStats,
+                    fileGraph: fileGraph.stats,
+                    techCount: techs.length,
+                    highRiskFiles: fileGraph.files.filter((f) => f.riskScore >= 50).length,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Graph stats failed: ${msg}` };
+            }
+        }
+        case 'cell_team_silos': {
+            try {
+                const { detectKnowledgeSilos } = require('../team-collaboration');
+                const silos = detectKnowledgeSilos();
+                return {
+                    count: silos.length,
+                    high: silos.filter((s) => s.riskLevel === 'high').length,
+                    silos,
+                    message: silos.length > 0
+                        ? `${silos.filter((s) => s.riskLevel === 'high').length} high-risk silos detected`
+                        : 'No knowledge silos detected',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Team silos failed: ${msg}` };
+            }
+        }
+        case 'cell_team_bus_factor': {
+            try {
+                const { calculateBusFactor } = require('../team-collaboration');
+                return calculateBusFactor();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Bus factor failed: ${msg}` };
+            }
+        }
+        case 'cell_team_health': {
+            try {
+                const { getTeamHealth } = require('../team-collaboration');
+                return getTeamHealth(args.project || undefined);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Team health failed: ${msg}` };
+            }
+        }
+        case 'cell_team_onboard': {
+            try {
+                const { generateOnboardingDoc } = require('../team-collaboration');
+                const teamName = args.teamName || 'Team';
+                const project = args.project || undefined;
+                return generateOnboardingDoc(teamName, project);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Onboard failed: ${msg}` };
+            }
+        }
+        case 'cell_team_retro': {
+            try {
+                const { generateSprintRetro } = require('../team-collaboration');
+                const days = args.days || 14;
+                const project = args.project || undefined;
+                return generateSprintRetro(days, project);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Retro failed: ${msg}` };
+            }
+        }
+        case 'cell_team_handoff': {
+            try {
+                const { generateHandoff } = require('../team-collaboration');
+                return generateHandoff(args.from || '', args.to || '', args.project || '');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Handoff failed: ${msg}` };
+            }
+        }
+        case 'cell_team_knowledge_transfer': {
+            try {
+                const { suggestKnowledgeTransfer } = require('../team-collaboration');
+                const suggestions = suggestKnowledgeTransfer();
+                return {
+                    count: suggestions.length,
+                    suggestions,
+                    message: suggestions.length > 0
+                        ? `${suggestions.length} transfer pairs suggested`
+                        : 'No urgent transfers needed',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Knowledge transfer failed: ${msg}` };
+            }
+        }
+        case 'cell_team_style': {
+            try {
+                const { composeTeamStyle } = require('../team-collaboration');
+                return composeTeamStyle(args.project || undefined);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Team style failed: ${msg}` };
+            }
+        }
+        case 'cell_team_dashboard': {
+            try {
+                const { detectKnowledgeSilos, calculateBusFactor, getTeamHealth, composeTeamStyle } = require('../team-collaboration');
+                const project = args.project || undefined;
+                const silos = detectKnowledgeSilos();
+                const busFactor = calculateBusFactor();
+                const health = getTeamHealth(project);
+                const style = composeTeamStyle(project);
+                return {
+                    silos: { count: silos.length, high: silos.filter((s) => s.riskLevel === 'high').length, top: silos.slice(0, 5) },
+                    busFactor,
+                    health,
+                    style,
+                    generatedAt: new Date().toISOString(),
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Team dashboard failed: ${msg}` };
+            }
+        }
+        case 'cell_community_stats': {
+            try {
+                const { getCommunityStats } = require('../core/community-store');
+                return getCommunityStats();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community stats failed: ${msg}` };
+            }
+        }
+        case 'cell_community_share': {
+            try {
+                const { shareCommunityPattern, validatePrivacy } = require('../core/community-store');
+                const rule = args.rule || '';
+                const validation = validatePrivacy(rule);
+                if (!validation.safe) {
+                    return { shared: false, errors: validation.errors, warnings: validation.warnings };
+                }
+                const result = shareCommunityPattern({
+                    category: args.category || 'unknown',
+                    rule,
+                    language: args.language,
+                    framework: args.framework,
+                    successRate: args.successRate,
+                });
+                return { ...result, warnings: [...validation.warnings, ...result.warnings] };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community share failed: ${msg}` };
+            }
+        }
+        case 'cell_community_patterns': {
+            try {
+                const { getCommunityPatterns } = require('../core/community-store');
+                const patterns = getCommunityPatterns({
+                    category: args.category,
+                    language: args.language,
+                    minVotes: args.minVotes,
+                    limit: args.limit || 20,
+                });
+                return { count: patterns.length, patterns };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community patterns failed: ${msg}` };
+            }
+        }
+        case 'cell_community_vote': {
+            try {
+                const { voteCommunityPattern } = require('../core/community-store');
+                return voteCommunityPattern(args.patternId || '', args.upvote !== false);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community vote failed: ${msg}` };
+            }
+        }
+        case 'cell_community_insights': {
+            try {
+                const { getCommunityInsights } = require('../core/community-store');
+                const insights = getCommunityInsights({
+                    severity: args.severity,
+                    category: args.category,
+                    limit: args.limit || 20,
+                });
+                return { count: insights.length, insights };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community insights failed: ${msg}` };
+            }
+        }
+        case 'cell_community_benchmarks': {
+            try {
+                const { getBenchmarks } = require('../core/community-store');
+                const benchmarks = getBenchmarks({
+                    category: args.category,
+                    limit: args.limit || 50,
+                });
+                return { count: benchmarks.length, benchmarks };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community benchmarks failed: ${msg}` };
+            }
+        }
+        case 'cell_community_trends': {
+            try {
+                const { getTechEvolution } = require('../core/community-store');
+                return getTechEvolution();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community trends failed: ${msg}` };
+            }
+        }
+        case 'cell_community_failures': {
+            try {
+                const { getFailurePatterns } = require('../core/community-store');
+                const failures = getFailurePatterns({
+                    language: args.language,
+                    limit: args.limit || 10,
+                });
+                return { count: failures.length, failures };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community failures failed: ${msg}` };
+            }
+        }
+        case 'cell_community_validate': {
+            try {
+                const { validatePrivacy } = require('../core/community-store');
+                return validatePrivacy(args.rule || '');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community validate failed: ${msg}` };
+            }
+        }
+        case 'cell_community_dashboard': {
+            try {
+                const { getCommunityStats, getTechEvolution, getCommunityInsights, getBenchmarks } = require('../core/community-store');
+                const stats = getCommunityStats();
+                const trends = getTechEvolution();
+                const insights = getCommunityInsights({ severity: 'critical', limit: 5 });
+                const benchmarks = getBenchmarks({ limit: 5 });
+                return {
+                    stats,
+                    trends: trends.slice(0, 10),
+                    insights,
+                    benchmarks,
+                    generatedAt: new Date().toISOString(),
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Community dashboard failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_decision_log': {
+            try {
+                const { logDecisionOutcome } = require('../core/usage-intelligence-store');
+                return logDecisionOutcome({
+                    project: args.project || 'unknown',
+                    technology: args.technology || '',
+                    reason: args.reason || '',
+                    outcome: args.outcome || '',
+                    wasRight: args.wasRight === true,
+                    confidence: args.confidence,
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Decision log failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_decision_patterns': {
+            try {
+                const { getDecisionPatterns } = require('../core/usage-intelligence-store');
+                const patterns = getDecisionPatterns(args.project || 'unknown');
+                return {
+                    count: patterns.length,
+                    patterns,
+                    message: patterns.length > 0
+                        ? `Analyzed ${patterns.length} technology decision patterns`
+                        : 'Need more decisions (>= 2 per tech) to detect patterns',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Decision patterns failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_repeat_mistakes': {
+            try {
+                const { detectRepeatMistakes } = require('../core/usage-intelligence-store');
+                const mistakes = detectRepeatMistakes(args.project || 'unknown');
+                return {
+                    count: mistakes.length,
+                    critical: mistakes.filter((m) => m.severity === 'critical').length,
+                    mistakes: mistakes.slice(0, 20),
+                    message: mistakes.length > 0
+                        ? `Found ${mistakes.length} repeated error patterns`
+                        : 'No repeated mistakes — clean track record',
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Repeat mistakes failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_ai_stats': {
+            try {
+                const { getAIInteractionStats } = require('../core/usage-intelligence-store');
+                return getAIInteractionStats(args.project || 'unknown');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `AI stats failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_productivity': {
+            try {
+                const { logProductivitySignal, getProductivitySignals } = require('../core/usage-intelligence-store');
+                const project = args.project || 'unknown';
+                // If signalType + duration provided, log; otherwise just read
+                if (args.signalType && args.durationMinutes !== undefined) {
+                    const result = logProductivitySignal({
+                        project,
+                        signalType: args.signalType,
+                        durationMinutes: args.durationMinutes,
+                        filesTouched: args.filesTouched || 0,
+                        contextSwitches: args.contextSwitches || 0,
+                    });
+                    return { logged: true, ...result };
+                }
+                return getProductivitySignals(project, 30);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Productivity failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_skills': {
+            try {
+                const { getSkillProgression } = require('../core/usage-intelligence-store');
+                return getSkillProgression(args.project || 'unknown');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Skill progression failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_burnout': {
+            try {
+                const { getBurnoutSignals } = require('../core/usage-intelligence-store');
+                return getBurnoutSignals(args.project || 'unknown');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Burnout check failed: ${msg}` };
+            }
+        }
+        case 'cell_usage_dashboard': {
+            try {
+                const { getUsageDashboard } = require('../core/usage-intelligence-store');
+                return getUsageDashboard(args.project || 'unknown');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Usage dashboard failed: ${msg}` };
+            }
+        }
+        case 'cell_watch_start': {
+            try {
+                const { startWatcher } = require('../core/live-watcher');
+                return startWatcher(args.project || 'unknown', args.dir || process.cwd());
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Watch start failed: ${msg}` };
+            }
+        }
+        case 'cell_watch_stop': {
+            try {
+                const { stopWatcher } = require('../core/live-watcher');
+                return stopWatcher(args.project || 'unknown');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Watch stop failed: ${msg}` };
+            }
+        }
+        case 'cell_watch_status': {
+            try {
+                const { getWatcherStatus, getActiveWatchers } = require('../core/live-watcher');
+                if (args.project) {
+                    const status = getWatcherStatus(args.project);
+                    if (!status)
+                        return { project: args.project, active: false, message: 'No watcher found' };
+                    const isLive = status.active;
+                    return { ...status, message: isLive ? 'Live' : 'Stopped' };
+                }
+                return { active: getActiveWatchers() };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Watch status failed: ${msg}` };
+            }
+        }
+        case 'cell_watch_events': {
+            try {
+                const { getLiveEvents } = require('../core/live-watcher');
+                return { events: getLiveEvents(args.project || 'unknown', args.limit || 50, args.eventType) };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Watch events failed: ${msg}` };
+            }
+        }
+        case 'cell_watch_refresh': {
+            try {
+                const { performAutoRefresh } = require('../core/live-watcher');
+                return performAutoRefresh(args.project || 'unknown', args.force === true);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Auto-refresh failed: ${msg}` };
+            }
+        }
+        case 'cell_watch_check': {
+            try {
+                const { checkIfNeedsRefresh } = require('../core/live-watcher');
+                return checkIfNeedsRefresh(args.project || 'unknown');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Refresh check failed: ${msg}` };
+            }
+        }
+        case 'cell_blindspots_scan': {
+            try {
+                const { scanDirectoryForBlindSpots } = require('../core/enhanced-blind-spots');
+                const dir = args.dir || process.cwd();
+                const max = args.maxFiles || 200;
+                const spots = scanDirectoryForBlindSpots(dir, max);
+                return { directory: dir, scanned: max, count: spots.length, blindSpots: spots };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Blind spot scan failed: ${msg}` };
+            }
+        }
+        case 'cell_blindspots_report': {
+            try {
+                const { scanDirectoryForBlindSpots, formatBlindSpotReport, summarizeBlindSpots } = require('../core/enhanced-blind-spots');
+                const dir = args.dir || process.cwd();
+                const max = args.maxFiles || 200;
+                const spots = scanDirectoryForBlindSpots(dir, max);
+                return {
+                    directory: dir,
+                    summary: summarizeBlindSpots(spots),
+                    report: formatBlindSpotReport(spots),
+                    blindSpots: spots,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Blind spot report failed: ${msg}` };
+            }
+        }
+        case 'cell_blindspots_summary': {
+            try {
+                const { getCategoryCounts } = require('../core/enhanced-blind-spots');
+                const dir = args.dir || process.cwd();
+                return { directory: dir, byCategory: getCategoryCounts(dir) };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { error: `Blind spot summary failed: ${msg}` };
+            }
+        }
         case 'cell_predict': {
             const { generatePredictions } = require('../predictive-engine');
             return generatePredictions(args.project);
@@ -1887,9 +2787,28 @@ async function handleMCPToolCall(name, args) {
     }
 }
 app.post('/mcp', async (req, res) => {
+    // ─── Security: rate limit + input validation ─────────────────────────
+    const { checkRateLimit, getClientId, validateToolArgs, securityHeaders } = require('../core/security');
+    for (const [k, v] of Object.entries(securityHeaders()))
+        res.setHeader(k, v);
+    const clientId = getClientId(req);
+    const rl = checkRateLimit(clientId);
+    res.setHeader('X-RateLimit-Remaining', String(rl.remaining));
+    if (!rl.allowed) {
+        res.status(429).json({ jsonrpc: '2.0', id: null, error: { code: -32000, message: `Rate limit exceeded. Retry in ${Math.ceil(rl.resetIn / 1000)}s` } });
+        return;
+    }
     const rpc = req.body;
     const { method, params, id } = rpc;
     try {
+        // Validate tool args before execution
+        if (method === 'tools/call') {
+            const validation = validateToolArgs(params?.name || '', params?.arguments);
+            if (!validation.valid) {
+                res.status(400).json({ jsonrpc: '2.0', id, error: { code: -32602, message: `Invalid arguments: ${validation.reason}` } });
+                return;
+            }
+        }
         let result;
         switch (method) {
             case 'initialize':