fivocell 4.1.0 → 4.1.2

package/dist/daemon/server.js

@@ -1830,1017 +1830,1050 @@ const MCP_TOOLS = [
     { name: 'cell_model_recommend', description: 'Get AI model recommendations — which tool works best for which task', inputSchema: { type: 'object', properties: {} } },
 ];
 async function handleMCPToolCall(name, args) {
-    switch (name) {
-        case 'cell_get_dev_profile': {
-            const { getDeveloperProfile } = require('../code-scanner');
-            const profile = getDeveloperProfile(args.project);
-            if (!profile)
-                return { error: 'no profile — run cell scan first' };
-            return { project: args.project, profile };
-        }
-        case 'cell_get_code_patterns': {
-            const { getCodePatterns } = require('../code-scanner');
-            return { project: args.project, patterns: getCodePatterns(args.project, args.category) };
-        }
-        case 'cell_deep_scan': {
-            const { scanCodebase } = require('../code-scanner');
-            const result = scanCodebase(args.dir, args.project || path.basename(args.dir));
-            return { project: result.project, filesScanned: result.filesScanned, totalLines: result.totalLines, profile: result.profile, strengths: result.profile.strengths, improvements: result.profile.improvements };
-        }
-        case 'cell_scan_report': {
-            const { getDeveloperProfile, getCodePatterns } = require('../code-scanner');
-            const profile = getDeveloperProfile(args.project);
-            const patterns = getCodePatterns(args.project);
-            return { project: args.project, profile, patterns, patternCount: patterns.length };
-        }
-        case 'cell_send_signal': {
-            const { logError, logDecision, logContext, logStuck } = require('../behavioral-tracker');
-            const type = args.type;
-            if (type === 'error')
-                return logError({ project: args.project, file: args.file, errorType: 'manual', errorMessage: String(args.editedCode || ''), line: 0 });
-            if (type === 'decision')
-                return logDecision({ project: args.project, file: args.file, decision: String(args.originalCode || ''), approach: String(args.editedCode || ''), worked: true });
-            if (type === 'context')
-                return logContext({ project: args.project, task: String(args.originalCode || ''), files: [] });
-            if (type === 'stuck')
-                return logStuck({ project: args.project, file: args.file, description: String(args.originalCode || '') });
-            return { recorded: true };
-        }
-        case 'cell_get_context': {
-            const { buildContext, formatContextForTool } = require('../core/prompt-builder');
-            const ctx = buildContext(args.project, args.tool);
-            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');
-            const result = scanFullPC();
-            return { totalProjects: result.totalProjects, totalFiles: result.totalFiles, totalLines: result.totalLines, profile: result.aggregatedProfile };
-        }
-        case 'cell_behavior_summary': {
-            const { getBehaviorSummary } = require('../behavioral-tracker');
-            return getBehaviorSummary(args.project);
-        }
-        case 'cell_log_error': {
-            const { logError } = require('../behavioral-tracker');
-            return logError({ project: args.project, file: args.file, errorType: args.errorType, errorMessage: args.errorMessage, line: args.line });
-        }
-        case 'cell_log_fix': {
-            const { logErrorFix } = require('../behavioral-tracker');
-            logErrorFix({ errorId: args.errorId, fixApplied: args.fixApplied, worked: args.worked, timeToFixMs: args.timeToFixMs });
-            return { recorded: true };
-        }
-        case 'cell_log_decision': {
-            const { logDecision } = require('../behavioral-tracker');
-            return logDecision({ project: args.project, file: args.file, decision: args.decision, approach: args.approach, worked: args.worked });
-        }
-        case 'cell_log_context': {
-            const { logContext } = require('../behavioral-tracker');
-            return logContext({ project: args.project, task: args.task, files: args.files });
-        }
-        case 'cell_log_stuck': {
-            const { logStuck } = require('../behavioral-tracker');
-            return logStuck({ project: args.project, file: args.file, description: args.description });
-        }
-        case 'cell_session_bridge': {
-            const { SessionMemory } = require('../core/session-memory');
-            const memory = new SessionMemory();
-            const project = args.project;
-            const tool = args.tool || 'unknown';
-            try {
-                const lastSession = memory.getLastSessionForProject(project);
-                const newSessionId = memory.startSession(tool, project);
-                let bridgeContext = '';
-                if (lastSession && lastSession.toolName !== tool) {
-                    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,
-                    });
-                }
-                const recentSessions = memory.getRecentSessions(3).filter((s) => s.project === project);
-                const sessionHistory = recentSessions.map((s) => ({
-                    tool: s.toolName,
-                    when: s.startTime,
-                    files: s.filesTouched,
-                    decisions: s.keyDecisions,
-                }));
-                return {
-                    newSessionId,
-                    lastSession: lastSession ? {
-                        tool: lastSession.toolName,
-                        startedAt: lastSession.startTime,
-                        context: lastSession.contextSnapshot,
-                    } : 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!',
-                };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                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 };
+    try {
+        switch (name) {
+            case 'cell_get_dev_profile': {
+                const { getDeveloperProfile } = require('../code-scanner');
+                const profile = getDeveloperProfile(args.project);
+                if (!profile)
+                    return { error: 'no profile — run cell scan first' };
+                return { project: args.project, profile };
+            }
+            case 'cell_get_code_patterns': {
+                const { getCodePatterns } = require('../code-scanner');
+                return { project: args.project, patterns: getCodePatterns(args.project, args.category) };
+            }
+            case 'cell_deep_scan': {
+                const { scanCodebase } = require('../code-scanner');
+                const result = scanCodebase(args.dir, args.project || path.basename(args.dir));
+                return { project: result.project, filesScanned: result.filesScanned, totalLines: result.totalLines, profile: result.profile, strengths: result.profile.strengths, improvements: result.profile.improvements };
+            }
+            case 'cell_scan_report': {
+                const { getDeveloperProfile, getCodePatterns } = require('../code-scanner');
+                const profile = getDeveloperProfile(args.project);
+                const patterns = getCodePatterns(args.project);
+                return { project: args.project, profile, patterns, patternCount: patterns.length };
+            }
+            case 'cell_send_signal': {
+                const { logError, logDecision, logContext, logStuck } = require('../behavioral-tracker');
+                const type = args.type;
+                if (type === 'error')
+                    return logError({ project: args.project, file: args.file, errorType: 'manual', errorMessage: String(args.editedCode || ''), line: 0 });
+                if (type === 'decision')
+                    return logDecision({ project: args.project, file: args.file, decision: String(args.originalCode || ''), approach: String(args.editedCode || ''), worked: true });
+                if (type === 'context')
+                    return logContext({ project: args.project, task: String(args.originalCode || ''), files: [] });
+                if (type === 'stuck')
+                    return logStuck({ project: args.project, file: args.file, description: String(args.originalCode || '') });
+                return { recorded: true };
+            }
+            case 'cell_get_context': {
+                const { buildContext, formatContextForTool } = require('../core/prompt-builder');
+                const ctx = buildContext(args.project, args.tool);
+                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');
+                const result = scanFullPC();
+                return { totalProjects: result.totalProjects, totalFiles: result.totalFiles, totalLines: result.totalLines, profile: result.aggregatedProfile };
+            }
+            case 'cell_behavior_summary': {
+                const { getBehaviorSummary } = require('../behavioral-tracker');
+                return getBehaviorSummary(args.project);
+            }
+            case 'cell_log_error': {
+                const { logError } = require('../behavioral-tracker');
+                return logError({ project: args.project, file: args.file, errorType: args.errorType, errorMessage: args.errorMessage, line: args.line });
+            }
+            case 'cell_log_fix': {
+                const { logErrorFix } = require('../behavioral-tracker');
+                logErrorFix({ errorId: args.errorId, fixApplied: args.fixApplied, worked: args.worked, timeToFixMs: args.timeToFixMs });
+                return { recorded: true };
+            }
+            case 'cell_log_decision': {
+                const { logDecision } = require('../behavioral-tracker');
+                return logDecision({ project: args.project, file: args.file, decision: args.decision, approach: args.approach, worked: args.worked });
+            }
+            case 'cell_log_context': {
+                const { logContext } = require('../behavioral-tracker');
+                return logContext({ project: args.project, task: args.task, files: args.files });
+            }
+            case 'cell_log_stuck': {
+                const { logStuck } = require('../behavioral-tracker');
+                return logStuck({ project: args.project, file: args.file, description: args.description });
+            }
+            case 'cell_session_bridge': {
+                const { SessionMemory } = require('../core/session-memory');
+                const memory = new SessionMemory();
+                const project = args.project;
+                const tool = args.tool || 'unknown';
+                try {
+                    const lastSession = memory.getLastSessionForProject(project);
+                    const newSessionId = memory.startSession(tool, project);
+                    let bridgeContext = '';
+                    if (lastSession && lastSession.toolName !== tool) {
+                        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,
+                        });
+                    }
+                    const recentSessions = memory.getRecentSessions(3).filter((s) => s.project === project);
+                    const sessionHistory = recentSessions.map((s) => ({
+                        tool: s.toolName,
+                        when: s.startTime,
+                        files: s.filesTouched,
+                        decisions: s.keyDecisions,
+                    }));
+                    return {
+                        newSessionId,
+                        lastSession: lastSession ? {
+                            tool: lastSession.toolName,
+                            startedAt: lastSession.startTime,
+                            context: lastSession.contextSnapshot,
+                        } : 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!',
+                    };
                 }
-                if (args.type === 'file' && args.filePath) {
-                    memory.recordFileTouch({ sessionId: sessionId || undefined, project, filePath: args.filePath });
-                    return { recorded: 'file' };
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return { error: `Session bridge failed: ${msg}`, crossedSession: false };
                 }
-                if (args.type === 'question' && args.question) {
-                    const id = memory.recordQuestion({
-                        sessionId: sessionId || undefined,
-                        project,
-                        question: args.question,
-                        priority: args.priority || 'medium',
+            }
+            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 { recorded: 'question', id };
+                    return { ended: true, sessionId };
                 }
-                if (args.type === 'resolve' && args.questionId) {
-                    memory.resolveQuestion(args.questionId, args.answer || '');
-                    return { recorded: 'resolve' };
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return { error: `Session end failed: ${msg}`, ended: false };
                 }
-                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` });
+            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 };
                     }
-                    else if (a.status === 'partial') {
-                        avoid.push({ approach: a.approach, reason: `partial (${a.count}x)` });
+                    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}` };
                 }
-                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_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_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,
-                    })),
-                };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `List projects 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_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,
-                };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Get project 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_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 ? {
+            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,
-                    } : 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: `Get project failed: ${msg}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Community insights 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_community_benchmarks': {
-            try {
-                const { getBenchmarks } = require('../core/community-store');
-                const benchmarks = getBenchmarks({
-                    category: args.category,
-                    limit: args.limit || 50,
-                });
-                return { count: benchmarks.length, benchmarks };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Community benchmarks 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_community_trends': {
-            try {
-                const { getTechEvolution } = require('../core/community-store');
-                return getTechEvolution();
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Community trends 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_community_failures': {
-            try {
-                const { getFailurePatterns } = require('../core/community-store');
-                const failures = getFailurePatterns({
-                    language: args.language,
-                    limit: args.limit || 10,
-                });
-                return { count: failures.length, failures };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Community failures 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_community_validate': {
-            try {
-                const { validatePrivacy } = require('../core/community-store');
-                return validatePrivacy(args.rule || '');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Community validate 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_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(),
-                };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Community dashboard 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_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,
-                });
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Decision log 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_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',
-                };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Decision patterns 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_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',
-                };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Repeat mistakes 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_usage_ai_stats': {
-            try {
-                const { getAIInteractionStats } = require('../core/usage-intelligence-store');
-                return getAIInteractionStats(args.project || 'unknown');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `AI stats 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_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,
+            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 { logged: true, ...result };
+                    return { count: insights.length, insights };
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return { error: `Community insights failed: ${msg}` };
                 }
-                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');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Skill progression 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_usage_burnout': {
-            try {
-                const { getBurnoutSignals } = require('../core/usage-intelligence-store');
-                return getBurnoutSignals(args.project || 'unknown');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Burnout check 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_usage_dashboard': {
-            try {
-                const { getUsageDashboard } = require('../core/usage-intelligence-store');
-                return getUsageDashboard(args.project || 'unknown');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Usage 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_watch_start': {
-            try {
-                const { startWatcher } = require('../core/live-watcher');
-                return startWatcher(args.project || 'unknown', args.dir || process.cwd());
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Watch start 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_watch_stop': {
-            try {
-                const { stopWatcher } = require('../core/live-watcher');
-                return stopWatcher(args.project || 'unknown');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Watch stop 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_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' };
+            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}` };
                 }
-                return { active: getActiveWatchers() };
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Watch status 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_watch_events': {
-            try {
-                const { getLiveEvents } = require('../core/live-watcher');
-                return { events: getLiveEvents(args.project || 'unknown', args.limit || 50, args.eventType) };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Watch events 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_refresh': {
-            try {
-                const { performAutoRefresh } = require('../core/live-watcher');
-                return performAutoRefresh(args.project || 'unknown', args.force === true);
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Auto-refresh 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_check': {
-            try {
-                const { checkIfNeedsRefresh } = require('../core/live-watcher');
-                return checkIfNeedsRefresh(args.project || 'unknown');
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Refresh check 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_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 };
+            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}` };
+                }
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Blind spot scan 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,
-                };
+            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}` };
+                }
             }
-            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_blindspots_summary': {
-            try {
-                const { getCategoryCounts } = require('../core/enhanced-blind-spots');
-                const dir = args.dir || process.cwd();
-                return { directory: dir, byCategory: getCategoryCounts(dir) };
+            case 'cell_predict': {
+                const { generatePredictions } = require('../predictive-engine');
+                return generatePredictions(args.project);
+            }
+            case 'cell_model_track': {
+                const { recordModelInteraction } = require('../cross-model-engine');
+                recordModelInteraction({
+                    modelName: args.modelName,
+                    taskType: args.taskType,
+                    accepted: args.accepted,
+                    responseTimeMs: args.responseTimeMs,
+                    project: args.project,
+                    suggestion: args.suggestion,
+                });
+                return { recorded: true };
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { error: `Blind spot summary failed: ${msg}` };
+            case 'cell_model_recommend': {
+                const { getModelRecommendations } = require('../cross-model-engine');
+                return { recommendations: getModelRecommendations() };
             }
+            default:
+                return { error: `unknown tool: ${name}` };
         }
-        case 'cell_predict': {
-            const { generatePredictions } = require('../predictive-engine');
-            return generatePredictions(args.project);
-        }
-        case 'cell_model_track': {
-            const { recordModelInteraction } = require('../cross-model-engine');
-            recordModelInteraction({
-                modelName: args.modelName,
-                taskType: args.taskType,
-                accepted: args.accepted,
-                responseTimeMs: args.responseTimeMs,
-                project: args.project,
-                suggestion: args.suggestion,
-            });
-            return { recorded: true };
-        }
-        case 'cell_model_recommend': {
-            const { getModelRecommendations } = require('../cross-model-engine');
-            return { recommendations: getModelRecommendations() };
-        }
-        default:
-            return { error: `unknown tool: ${name}` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const stack = err instanceof Error ? err.stack : String(err);
+        console.error(`[mcp] tool ${name} threw:`, msg, '\n', stack);
+        return { error: `Tool ${name} failed: ${msg}` };
     }
 }
 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;
+    // Wrap entire handler in try/catch so uncaught errors don't 500 silently
     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;
-            }
+        // ─── 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;
         }
-        let result;
-        switch (method) {
-            case 'initialize':
-                result = { protocolVersion: params?.protocolVersion || '2024-11-05', capabilities: { tools: { listChanged: false } }, serverInfo: { name: 'fivo-cell', version: '3.0.0' } };
-                break;
-            case 'notifications/initialized':
-                res.status(204).end();
-                return;
-            case 'ping':
-                result = {};
-                break;
-            case 'tools/list':
-                result = { tools: MCP_TOOLS };
-                break;
-            case 'tools/call':
-                result = await handleMCPToolCall(params?.name || '', params?.arguments || {});
-                break;
-            default:
-                res.status(200).json({ jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } });
-                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':
+                    result = { protocolVersion: params?.protocolVersion || '2024-11-05', capabilities: { tools: { listChanged: false } }, serverInfo: { name: 'fivo-cell', version: '3.0.0' } };
+                    break;
+                case 'notifications/initialized':
+                    res.status(204).end();
+                    return;
+                case 'ping':
+                    result = {};
+                    break;
+                case 'tools/list':
+                    result = { tools: MCP_TOOLS };
+                    break;
+                case 'tools/call':
+                    result = await handleMCPToolCall(params?.name || '', params?.arguments || {});
+                    break;
+                default:
+                    res.status(200).json({ jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } });
+                    return;
+            }
+            res.status(200).json({ jsonrpc: '2.0', id, result });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error ? err.stack : String(err);
+            console.error('[mcp] handler error:', message, '\n', stack);
+            try {
+                res.status(200).json({ jsonrpc: '2.0', id, error: { code: -1, message } });
+            }
+            catch {
+                try {
+                    res.status(500).json({ error: 'internal server error' });
+                }
+                catch { /* noop */ }
+            }
         }
-        res.status(200).json({ jsonrpc: '2.0', id, result });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        res.status(200).json({ jsonrpc: '2.0', id, error: { code: -1, message } });
+        const stack = err instanceof Error ? err.stack : String(err);
+        process.stderr.write(`[mcp] OUTER handler error: ${message}\n${stack}\n`);
+        try {
+            res.status(500).json({ error: 'internal server error' });
+        }
+        catch { /* noop */ }
     }
 });
 app.use((_req, res) => { res.status(404).json({ error: 'not found' }); });
 app.use((err, _req, res, _next) => {
-    console.error('Daemon error:', err.message);
-    res.status(500).json({ error: 'internal server error' });
+    console.error('Daemon error:', err.message, '\n', err.stack);
+    try {
+        res.status(500).json({ error: 'internal server error' });
+    }
+    catch { /* noop */ }
 });
 // ─── Self-Healing ──────────────────────────────────────────────────────
 process.on('uncaughtException', (err) => {