fivocell 2.0.0 → 3.1.0

package/dist/mcp-server.js

@@ -36,10 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RESOURCES = exports.TOOLS = void 0;
 exports.startMCPServer = startMCPServer;
 const http = __importStar(require("http"));
-const senior_features_1 = require("./senior-features");
 const prompt_builder_1 = require("./core/prompt-builder");
 const database_1 = require("./core/database");
-const session_memory_1 = require("./core/session-memory");
 const DAEMON_URL = 'http://localhost:9876';
 const MCP_PORT = 9877;
 let daemonEnsuredAt = 0;
@@ -52,35 +50,31 @@ async function ensureDaemonForMCP() {
     if (now - daemonEnsuredAt < DAEMON_RECHECK_MS)
         return true;
     const { ensureDaemon } = require('./daemon/lifecycle');
-    const p = ensureDaemon({ silent: true }).finally(() => {
-        daemonEnsuring = null;
-    });
+    const p = ensureDaemon({ silent: true }).finally(() => { daemonEnsuring = null; });
     daemonEnsuring = p;
     const ok = await p;
     if (ok)
         daemonEnsuredAt = Date.now();
     return ok;
 }
-function daemonRequest(method, path, body) {
+function daemonRequest(method, urlPath, body) {
     return new Promise(async (resolve, reject) => {
-        if (path !== '/health') {
+        if (urlPath !== '/health') {
             const ok = await ensureDaemonForMCP();
             if (!ok) {
-                reject(new Error('Cell daemon is not running and could not be started. Run `cell start` or `cell daemon install-service`.'));
+                reject(new Error('Cell daemon not running. Run `cell start`.'));
                 return;
             }
         }
-        const url = new URL(path, DAEMON_URL);
+        const url = new URL(urlPath, DAEMON_URL);
         const req = http.request({
-            method,
-            hostname: url.hostname,
-            port: url.port,
+            method, hostname: url.hostname, port: url.port,
             path: url.pathname + url.search,
             headers: { 'Content-Type': 'application/json' },
             timeout: 15000,
         }, (res) => {
             let data = '';
-            res.on('data', (chunk) => (data += chunk));
+            res.on('data', (c) => (data += c));
             res.on('end', () => {
                 try {
                     resolve(JSON.parse(data));
@@ -90,637 +84,255 @@ function daemonRequest(method, path, body) {
                 }
             });
         });
-        req.on('error', (err) => {
-            daemonEnsuredAt = 0;
-            reject(err);
-        });
+        req.on('error', (err) => { daemonEnsuredAt = 0; reject(err); });
         if (body)
             req.write(JSON.stringify(body));
         req.end();
     });
 }
+// ─── 6 Essential MCP Tools ─────────────────────────────────────────────────
 exports.TOOLS = [
     {
-        name: 'cell_get_taste_context',
-        description: 'Get user coding taste for prompt injection. Returns compressed taste string.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                language: { type: 'string', description: 'Programming language' },
-                framework: { type: 'string', description: 'Framework (optional)' },
-            },
-        },
-    },
-    {
-        name: 'cell_send_signal',
-        description: 'Send learning signal when user edits/rejects AI output',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                type: { type: 'string', enum: ['edit_diff', 'accept', 'reject', 'retry'] },
-                originalCode: { type: 'string' },
-                editedCode: { type: 'string' },
-                language: { type: 'string' },
-                framework: { type: 'string' },
-                fileType: { type: 'string' },
-            },
-            required: ['type', 'language'],
-        },
-    },
-    {
-        name: 'cell_get_profile',
-        description: 'Get full taste profile with patterns and confidence scores',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_predict_next_action',
-        description: 'Predict next action based on context',
-        inputSchema: {
-            type: 'object',
-            properties: { context: { type: 'string' } },
-        },
-    },
-    {
-        name: 'cell_check_build',
-        description: 'Check for potential build failures',
-        inputSchema: {
-            type: 'object',
-            properties: { files: { type: 'string' } },
-        },
-    },
-    {
-        name: 'cell_community_stats',
-        description: 'Get community intelligence stats — pattern count, developer count, total outcomes',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_community_rankings',
-        description: 'Get community-wide pattern rankings by category',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: 'Max entries per category (default: 10)' },
-            },
-        },
-    },
-    {
-        name: 'cell_community_trends',
-        description: 'Get rising/declining pattern trends across the community',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: 'Max trends (default: 20)' },
-            },
-        },
-    },
-    {
-        name: 'cell_community_insights',
-        description: 'Get actionable community insights — adoption, language-specific best patterns',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_community_playbooks',
-        description: 'Get community-generated playbooks for specific categories',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                category: { type: 'string', description: 'Filter by category (optional)' },
-            },
-        },
-    },
-    {
-        name: 'cell_community_reputation',
-        description: 'Get top community pattern entries by reputation score',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: 'Max entries (default: 20)' },
-            },
-        },
-    },
-    {
-        name: 'cell_org_benchmarks',
-        description: 'Get organization-wide benchmarks — success rate, testing adoption, CI adoption per team',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: { type: 'string', description: 'Organization ID' },
-            },
-            required: ['orgId'],
-        },
-    },
-    {
-        name: 'cell_org_silos',
-        description: 'Detect knowledge silos within an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: { type: 'string', description: 'Organization ID' },
-            },
-            required: ['orgId'],
-        },
-    },
-    {
-        name: 'cell_org_bus_factor',
-        description: 'Compute bus factor — identifies patterns owned by too few members',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: { type: 'string', description: 'Organization ID' },
-            },
-            required: ['orgId'],
-        },
-    },
-    {
-        name: 'cell_org_risks',
-        description: 'Get team-level risk reports for an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: { type: 'string', description: 'Organization ID' },
-            },
-            required: ['orgId'],
-        },
-    },
-    {
-        name: 'cell_org_insights',
-        description: 'Get executive insights for an organization',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: { type: 'string', description: 'Organization ID' },
-            },
-            required: ['orgId'],
-        },
-    },
-    {
-        name: 'cell_org_playbooks',
-        description: 'Get organization-specific playbooks',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                orgId: { type: 'string', description: 'Organization ID' },
-            },
-            required: ['orgId'],
-        },
-    },
-    {
-        name: 'cell_intelligence_score',
-        description: 'Compute a developer\'s intelligence score across 7 dimensions (outcome, confidence, health, project, community, org, knowledge)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                developerId: { type: 'string', description: 'Developer ID' },
-                patterns: { type: 'array', description: 'Array of patterns' },
-                outcomesMap: { type: 'object', description: 'Pattern outcomes map', additionalProperties: true },
-                communityStats: { type: 'object', description: 'Community statistics', additionalProperties: true },
-                orgStats: { type: 'object', description: 'Organization statistics', additionalProperties: true },
-                projectDNA: { type: 'object', description: 'Project DNA profile', additionalProperties: true },
-                weights: { type: 'object', description: 'Optional dimension weights', additionalProperties: true },
-            },
-            required: ['developerId', 'patterns'],
-        },
-    },
-    {
-        name: 'cell_analyze_risks',
-        description: 'Analyze risks with root cause, probability, impact, and recommendations',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                developerId: { type: 'string' },
-                teamId: { type: 'string' },
-                orgId: { type: 'string' },
-                patterns: { type: 'array' },
-                outcomesMap: { type: 'object' },
-                teamProfiles: { type: 'array' },
-                orgBenchmarks: { type: 'array' },
-                knowledgeGaps: { type: 'array' },
-            },
-            required: ['developerId', 'patterns'],
-        },
-    },
-    {
-        name: 'cell_find_opportunities',
-        description: 'Find improvement opportunities — success, testing, CI, code review, community adoption',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                developerId: { type: 'string' },
-                patterns: { type: 'array' },
-                outcomesMap: { type: 'object' },
-                projectDNA: { type: 'object' },
-                communityStats: { type: 'object' },
-                orgBenchmarks: { type: 'array' },
-            },
-            required: ['developerId', 'patterns'],
-        },
-    },
-    {
-        name: 'cell_generate_decisions',
-        description: 'Generate priority-ranked decisions from risks, opportunities, and knowledge gaps',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                developerId: { type: 'string' },
-                patterns: { type: 'array' },
-                risks: { type: 'array' },
-                opportunities: { type: 'array' },
-                knowledgeGaps: { type: 'array' },
-                orgBenchmarks: { type: 'array' },
-            },
-            required: ['developerId'],
-        },
-    },
-    {
-        name: 'cell_intelligence_report',
-        description: 'Generate a full intelligence report with score, strengths, weaknesses, and recommended actions',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                developerId: { type: 'string' },
-                intelligenceScore: { type: 'object' },
-                risks: { type: 'array' },
-                opportunities: { type: 'array' },
-                decisions: { type: 'array' },
-                knowledgeGaps: { type: 'array' },
-                benchmarks: { type: 'array' },
-                lifecycles: { type: 'array' },
-            },
-            required: ['developerId', 'intelligenceScore'],
-        },
-    },
-    {
-        name: 'cell_get_recommendations',
-        description: 'Get personalized pattern recommendations based on developer profile and similar developers',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                developerId: { type: 'string', description: 'Developer ID' },
-                patterns: { type: 'array', description: 'All patterns' },
-                outcomesMap: { type: 'object', description: 'Pattern outcomes map' },
-                allProfiles: { type: 'object', description: 'All developer profiles map' },
-            },
-            required: ['developerId', 'patterns'],
-        },
-    },
-    {
-        name: 'cell_outcome_leaderboard',
-        description: 'Get pattern outcome leaderboard — top patterns by evidence-based confidence',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                minEvents: { type: 'number', description: 'Minimum events (default: 0)' },
-                limit: { type: 'number', description: 'Max entries (default: 20)' },
-            },
-        },
-    },
-    {
-        name: 'cell_project_dna',
-        description: 'Build or get Project DNA profile for a repository path',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                projectPath: { type: 'string', description: 'Absolute path to project' },
-            },
-            required: ['projectPath'],
-        },
-    },
-    {
-        name: 'cell_get_stack_summary',
-        description: 'Get detected stack: language, frameworks, libraries, tools, and confidence score',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_lint_style',
-        description: 'Lint a code snippet for style match against community best practices (returns match %, off-brand patterns, suggestions)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file: { type: 'string', description: 'File path or name' },
-                code: { type: 'string', description: 'Code content to lint' },
-            },
-            required: ['file', 'code'],
-        },
-    },
-    {
-        name: 'cell_suggest_pattern',
-        description: 'Suggest community-validated pattern for a given file and context (returns suggestion, adoption %, top-dev usage)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file: { type: 'string', description: 'File path or name' },
-                context: { type: 'string', description: 'Context tag: testing, async, validation, error, state, api, types, import' },
-            },
-            required: ['file', 'context'],
-        },
-    },
-    {
-        name: 'cell_predict_next_file',
-        description: 'Predict the next file the developer will likely create or edit, based on workflow history',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_daily_brief',
-        description: 'Get a daily brief: yesterday summary (patterns, files, signals), today predictions, weekly trend',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_inject_context',
-        description: 'Inject your complete developer context — style, patterns, blind spots, predictions. Use @cell in any AI tool.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                projectPath: { type: 'string', description: 'Optional — project path for specific context' },
-                toolName: { type: 'string', description: 'Optional — AI tool name (cursor, claude, windsurf, copilot, antigravity)' },
-                compact: { type: 'boolean', description: 'Compact format for prompt injection (default: false)' },
-            },
-        },
-    },
-    {
-        name: 'cell_session_start',
-        description: 'Start a new session with tool name and project',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                toolName: { type: 'string', description: 'AI tool name (cursor, claude, windsurf, etc.)' },
-                project: { type: 'string', description: 'Project name or path' },
-            },
-            required: ['toolName', 'project'],
-        },
-    },
-    {
-        name: 'cell_session_end',
-        description: 'End a session with files touched and key decisions',
+        name: 'cell_get_dev_profile',
+        description: 'Developer profile — naming, style, errors, architecture, strengths, improvements',
         inputSchema: {
             type: 'object',
-            properties: {
-                sessionId: { type: 'number', description: 'Session ID from cell_session_start' },
-                filesTouched: { type: 'array', items: { type: 'string' }, description: 'Files worked on' },
-                keyDecisions: { type: 'array', items: { type: 'string' }, description: 'Key decisions made' },
-                contextSnapshot: { type: 'string', description: 'Summary of what was done' },
-            },
-            required: ['sessionId'],
+            properties: { project: { type: 'string' } },
+            required: ['project'],
         },
     },
     {
-        name: 'cell_get_sessions',
-        description: 'Get recent cross-tool session history with decisions and context chains',
+        name: 'cell_get_code_patterns',
+        description: 'Code patterns by category — naming, imports, error_handling, style, architecture, testing, functions',
         inputSchema: {
             type: 'object',
             properties: {
-                limit: { type: 'number', description: 'Max sessions (default 10)' },
-                project: { type: 'string', description: 'Filter by project' },
+                project: { type: 'string' },
+                category: { type: 'string' },
             },
+            required: ['project'],
         },
     },
     {
-        name: 'cell_predict',
-        description: 'Get all predictive intelligence — pre-failures, decision regrets, scope creep, energy, stack warnings',
+        name: 'cell_deep_scan',
+        description: 'Deep scan codebase — extracts real coding patterns, style, architecture',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: 'Filter by project' },
-                type: { type: 'string', description: 'Filter: pre_failure|decision_regret|complexity_trap|scope_creep|energy|stack' },
+                dir: { type: 'string' },
+                project: { type: 'string' },
             },
+            required: ['dir'],
         },
     },
     {
-        name: 'cell_predict_risk',
-        description: 'Calculate risk score for a specific file based on bug history, recurrence, and touch frequency',
+        name: 'cell_scan_report',
+        description: 'Full scan report — profile + all patterns for a project',
         inputSchema: {
             type: 'object',
-            properties: {
-                file: { type: 'string', description: 'File path to assess risk for' },
-            },
-            required: ['file'],
+            properties: { project: { type: 'string' } },
+            required: ['project'],
         },
     },
     {
-        name: 'cell_predict_time',
-        description: 'Estimate completion time for a feature based on historical session data',
+        name: 'cell_send_signal',
+        description: 'Send learning signal — edit_diff, accept, reject, tab_switch, focus_block, file_save',
         inputSchema: {
             type: 'object',
             properties: {
-                feature: { type: 'string', description: 'Feature or task name to estimate' },
+                type: { type: 'string' },
+                originalCode: { type: 'string' },
+                editedCode: { type: 'string' },
+                file: { type: 'string' },
+                language: { type: 'string' },
             },
-            required: ['feature'],
+            required: ['type'],
         },
     },
     {
-        name: 'cell_tool_compare',
-        description: 'Compare all AI tools — acceptance rate, best/worst tasks, recommendations',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_tool_suggest',
-        description: 'Suggest best AI tool for a specific task type',
+        name: 'cell_get_context',
+        description: 'Full context injection — profile + patterns + blind spots for current project',
         inputSchema: {
             type: 'object',
             properties: {
-                taskType: { type: 'string', description: 'Task type (e.g., debugging, architecture, boilerplate)' },
+                project: { type: 'string' },
+                tool: { type: 'string' },
             },
-            required: ['taskType'],
+            required: ['project'],
         },
     },
     {
-        name: 'cell_model_history',
-        description: 'Per-model interaction history — sessions, files, decisions',
+        name: 'cell_scan_full_pc',
+        description: 'Scan entire PC for all code projects — builds comprehensive developer profile',
         inputSchema: { type: 'object', properties: {} },
     },
     {
-        name: 'cell_tool_context',
-        description: 'Show tool-specific @cell context for an AI tool',
+        name: 'cell_behavior_summary',
+        description: 'Behavioral summary — errors, decisions, context, stuck issues for this project',
         inputSchema: {
             type: 'object',
-            properties: {
-                toolName: { type: 'string', description: 'AI tool name (cursor, claude, antigravity, etc.)' },
-            },
-            required: ['toolName'],
+            properties: { project: { type: 'string' } },
+            required: ['project'],
         },
     },
     {
-        name: 'cell_team_health',
-        description: 'Get team health score — bus factor, silos, skill gaps, strengths',
+        name: 'cell_log_error',
+        description: 'Log an error encounter — error type, message, file, line',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: 'Filter by project' },
+                project: { type: 'string' },
+                file: { type: 'string' },
+                errorType: { type: 'string' },
+                errorMessage: { type: 'string' },
+                line: { type: 'number' },
             },
+            required: ['errorType', 'errorMessage'],
         },
     },
     {
-        name: 'cell_team_silos',
-        description: 'Detect knowledge silos and single points of failure',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_team_style',
-        description: 'Show merged team coding style — stack, patterns, conventions',
+        name: 'cell_log_fix',
+        description: 'Log how an error was fixed — fix applied, whether it worked, time taken',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: 'Filter by project' },
+                errorId: { type: 'number' },
+                fixApplied: { type: 'string' },
+                worked: { type: 'boolean' },
+                timeToFixMs: { type: 'number' },
             },
+            required: ['errorId', 'fixApplied', 'worked'],
         },
     },
     {
-        name: 'cell_team_retro',
-        description: 'Auto-generate sprint retrospective from git + pattern data',
+        name: 'cell_log_decision',
+        description: 'Log a coding decision — what approach was taken and if it worked',
         inputSchema: {
             type: 'object',
             properties: {
-                days: { type: 'number', description: 'Lookback period in days (default 14)' },
-                project: { type: 'string', description: 'Filter by project' },
+                project: { type: 'string' },
+                file: { type: 'string' },
+                decision: { type: 'string' },
+                approach: { type: 'string' },
+                worked: { type: 'boolean' },
             },
+            required: ['decision'],
         },
     },
     {
-        name: 'cell_team_onboard',
-        description: 'Generate onboarding package for a new team member',
+        name: 'cell_log_context',
+        description: 'Log current context — what task is being worked on, which files involved',
         inputSchema: {
             type: 'object',
             properties: {
-                teamName: { type: 'string', description: 'Team name' },
-                project: { type: 'string', description: 'Filter by project' },
+                project: { type: 'string' },
+                task: { type: 'string' },
+                files: { type: 'array', items: { type: 'string' } },
             },
-            required: ['teamName'],
+            required: ['task'],
         },
     },
     {
-        name: 'cell_handoff',
-        description: 'Generate context handoff for team member transition',
+        name: 'cell_log_stuck',
+        description: 'Log when stuck — what the issue is, which file',
         inputSchema: {
             type: 'object',
             properties: {
-                from: { type: 'string', description: 'Person handing off' },
-                to: { type: 'string', description: 'Person receiving' },
-                project: { type: 'string', description: 'Project name' },
+                project: { type: 'string' },
+                file: { type: 'string' },
+                description: { type: 'string' },
             },
-            required: ['from', 'to', 'project'],
+            required: ['description'],
         },
     },
-    {
-        name: 'cell_community_compare',
-        description: 'Compare personal skills against community benchmarks',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_community_trends',
-        description: 'Show technology and pattern trends from community',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_community_insights',
-        description: 'Actionable community insights — benchmarks, blind spots, trends',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_community_stats',
-        description: 'Community overview — developers, patterns, languages',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_rhythm',
-        description: 'Show coding rhythm — best hours, best days, flow patterns',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_burnout',
-        description: 'Check for burnout signals — error rate, session length, reverts',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_mastery',
-        description: 'Technology mastery map — per-language progress and confidence',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_growth',
-        description: 'Career trajectory — current level, senior readiness, recommendations',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_insights_weekly',
-        description: 'Weekly digest — sessions, bugs, decisions, highlights',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_health',
-        description: 'System health — DB status, memory, uptime, platform',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_metrics',
-        description: 'System metrics — queries/sec, patterns, sessions, DB tables',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_security',
-        description: 'Security status — auth token, rate limits, encryption',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_backup',
-        description: 'Create backup of cell database',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_optimize',
-        description: 'Optimize database — VACUUM, ANALYZE, prune',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_debug_style',
-        description: 'Debugging style — console.log vs debugger, efficiency, recommendations',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_prompt_style',
-        description: 'Prompt style — length, structure, iteration patterns',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_focus',
-        description: 'Focus analysis — deep work, shallow work, tab switching',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_ide_insights',
-        description: 'Full IDE intelligence — debug, prompt, focus, copy-paste, refactor combined',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_cloud_status',
-        description: 'Cloud sync status — pending, sent, failed, device ID',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'cell_cloud_validate',
-        description: 'Validate payload for cloud — forbidden fields + 300-byte limit',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: { type: 'object', description: 'Payload to validate' },
-            },
-            required: ['data'],
-        },
-    },
-    {
-        name: 'cell_cloud_queue',
-        description: 'Offline sync queue — pending, failed, retryable',
-        inputSchema: { type: 'object', properties: {} },
-    },
 ];
 exports.RESOURCES = [
-    { uri: 'cell://taste/profile', name: 'Taste Profile', description: 'Full taste profile' },
-    { uri: 'cell://community/stats', name: 'Community Stats', description: 'Aggregate community patterns' },
-    { uri: 'cell://community/v2/stats', name: 'Community Intelligence Stats', description: 'Full community intelligence statistics' },
-    { uri: 'cell://community/v2/insights', name: 'Community Insights', description: 'Actionable community insights' },
-    { uri: 'cell://team/composite', name: 'Team Composite', description: 'Team taste composite' },
-    { uri: 'cell://org/v2/benchmarks', name: 'Org Benchmarks', description: 'Organization-wide benchmarks' },
-    { uri: 'cell://intelligence/reports', name: 'Intelligence Reports', description: 'All generated intelligence reports' },
     { uri: 'cell://health', name: 'Health', description: 'Daemon health status' },
 ];
+// ─── Tool Handler ───────────────────────────────────────────────────────────
+async function handleToolCall(params) {
+    const name = params?.name;
+    const args = params?.arguments || {};
+    switch (name) {
+        case 'cell_get_dev_profile': {
+            const { getDeveloperProfile } = await Promise.resolve().then(() => __importStar(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 } = await Promise.resolve().then(() => __importStar(require('./code-scanner')));
+            return { project: args.project, patterns: getCodePatterns(args.project, args.category) };
+        }
+        case 'cell_deep_scan': {
+            const { scanCodebase } = await Promise.resolve().then(() => __importStar(require('./code-scanner')));
+            const result = scanCodebase(args.dir, args.project || require('path').basename(args.dir));
+            return { project: result.project, filesScanned: result.filesScanned, totalLines: result.totalLines, languages: result.languages, profile: result.profile, patternCount: result.patterns.length, strengths: result.profile.strengths, improvements: result.profile.improvements };
+        }
+        case 'cell_scan_report': {
+            const { getDeveloperProfile, getCodePatterns } = await Promise.resolve().then(() => __importStar(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': {
+            return daemonRequest('POST', '/signal', {
+                type: args.type,
+                originalCode: args.originalCode || '',
+                editedCode: args.editedCode || '',
+                file: args.file || '',
+                language: args.language || '',
+            });
+        }
+        case 'cell_get_context': {
+            (0, database_1.initializeDatabase)();
+            const ctx = (0, prompt_builder_1.buildContext)(args.project, args.tool);
+            const formatted = (0, prompt_builder_1.formatContextForInjection)(ctx, false);
+            return { content: [{ type: 'text', text: formatted }], context: ctx };
+        }
+        case 'cell_scan_full_pc': {
+            const { scanFullPC } = await Promise.resolve().then(() => __importStar(require('./pc-scanner')));
+            const result = scanFullPC();
+            return { totalProjects: result.totalProjects, totalFiles: result.totalFiles, totalLines: result.totalLines, languages: result.allLanguages, profile: result.aggregatedProfile, projects: result.projects.map((p) => ({ name: p.name, files: p.fileCount, lines: p.lineCount })) };
+        }
+        case 'cell_behavior_summary': {
+            const { getBehaviorSummary } = await Promise.resolve().then(() => __importStar(require('./behavioral-tracker')));
+            return getBehaviorSummary(args.project);
+        }
+        case 'cell_log_error': {
+            const { logError } = await Promise.resolve().then(() => __importStar(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 } = await Promise.resolve().then(() => __importStar(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 } = await Promise.resolve().then(() => __importStar(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 } = await Promise.resolve().then(() => __importStar(require('./behavioral-tracker')));
+            return logContext({ project: args.project, task: args.task, files: args.files });
+        }
+        case 'cell_log_stuck': {
+            const { logStuck } = await Promise.resolve().then(() => __importStar(require('./behavioral-tracker')));
+            return logStuck({ project: args.project, file: args.file, description: args.description });
+        }
+        default:
+            return { error: `unknown tool: ${name}` };
+    }
+}
+// ─── Resource Handler ───────────────────────────────────────────────────────
+async function handleResourceRead(params) {
+    const uri = params?.uri;
+    if (uri === 'cell://health')
+        return daemonRequest('GET', '/health');
+    return { error: `unknown resource: ${uri}` };
+}
+// ─── MCP Server ─────────────────────────────────────────────────────────────
 function startMCPServer(port = MCP_PORT) {
     const server = http.createServer(async (req, res) => {
         if (req.method === 'GET' && req.url === '/health') {
@@ -753,14 +365,8 @@ function startMCPServer(port = MCP_PORT) {
                     case 'initialize':
                         result = {
                             protocolVersion: params?.protocolVersion || '2024-11-05',
-                            capabilities: {
-                                tools: { listChanged: false },
-                                resources: { subscribe: false, listChanged: false },
-                            },
-                            serverInfo: {
-                                name: 'fivo-cell',
-                                version: '1.0.5',
-                            },
+                            capabilities: { tools: { listChanged: false }, resources: { subscribe: false, listChanged: false } },
+                            serverInfo: { name: 'fivo-cell', version: '2.0.0' },
                         };
                         break;
                     case 'notifications/initialized':
@@ -787,11 +393,7 @@ function startMCPServer(port = MCP_PORT) {
                         break;
                     default:
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            jsonrpc: '2.0',
-                            id,
-                            error: { code: -32601, message: `Method not found: ${method}` },
-                        }));
+                        res.end(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } }));
                         return;
                 }
                 res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -805,316 +407,8 @@ function startMCPServer(port = MCP_PORT) {
         });
     });
     server.listen(port, () => {
-        console.log(`Cell MCP Server running on http://localhost:${port}`);
-        console.log(`MCP endpoint: http://localhost:${port}/mcp`);
+        console.log(`Cell MCP Server on http://localhost:${port}/mcp`);
     });
     return server;
 }
-async function handleToolCall(params) {
-    const name = params?.name;
-    const args = params?.arguments || {};
-    switch (name) {
-        case 'cell_get_taste_context': {
-            const q = new URLSearchParams();
-            if (args.language)
-                q.set('language', args.language);
-            if (args.framework)
-                q.set('framework', args.framework);
-            return daemonRequest('GET', `/taste/context?${q.toString()}`);
-        }
-        case 'cell_send_signal':
-            return daemonRequest('POST', '/signal', {
-                type: args.type,
-                originalCode: args.originalCode || '',
-                editedCode: args.editedCode || '',
-                context: {
-                    language: args.language || '',
-                    framework: args.framework || '',
-                    fileType: args.fileType || '',
-                    strictness: 'standard',
-                    projectId: 'mcp-session',
-                },
-            });
-        case 'cell_get_profile':
-            return daemonRequest('GET', '/taste/profile');
-        case 'cell_predict_next_action':
-            return daemonRequest('GET', `/predict/next-action?context=${encodeURIComponent(args.context || '')}`);
-        case 'cell_check_build':
-            return daemonRequest('GET', `/predict/build-failure?files=${encodeURIComponent(args.files || '')}`);
-        case 'cell_community_stats':
-            return daemonRequest('GET', '/community/v2/stats');
-        case 'cell_community_rankings':
-            return daemonRequest('GET', `/community/v2/rankings?limit=${args.limit || 10}`);
-        case 'cell_community_trends':
-            return daemonRequest('GET', `/community/v2/trends?limit=${args.limit || 20}`);
-        case 'cell_community_insights':
-            return daemonRequest('GET', '/community/v2/insights');
-        case 'cell_community_playbooks':
-            return daemonRequest('POST', '/community/v2/playbooks', { developerProfiles: args.developerProfiles || [] });
-        case 'cell_community_reputation':
-            return daemonRequest('GET', `/community/v2/reputation?limit=${args.limit || 20}`);
-        case 'cell_org_benchmarks':
-            return daemonRequest('POST', `/org/v2/${args.orgId}/benchmarks`, {});
-        case 'cell_org_silos':
-            return daemonRequest('GET', `/org/v2/${args.orgId}/silos`);
-        case 'cell_org_bus_factor':
-            return daemonRequest('GET', `/org/v2/${args.orgId}/bus-factor`);
-        case 'cell_org_risks':
-            return daemonRequest('GET', `/org/v2/${args.orgId}/risks`);
-        case 'cell_org_insights':
-            return daemonRequest('GET', `/org/v2/${args.orgId}/insights`);
-        case 'cell_org_playbooks':
-            return daemonRequest('GET', `/org/v2/${args.orgId}/playbooks`);
-        case 'cell_intelligence_score':
-            return daemonRequest('POST', '/intelligence/score', args);
-        case 'cell_analyze_risks':
-            return daemonRequest('POST', '/intelligence/risks', args);
-        case 'cell_find_opportunities':
-            return daemonRequest('POST', '/intelligence/opportunities', args);
-        case 'cell_generate_decisions':
-            return daemonRequest('POST', '/intelligence/decisions', args);
-        case 'cell_intelligence_report':
-            return daemonRequest('POST', '/intelligence/report', args);
-        case 'cell_get_recommendations':
-            return daemonRequest('POST', '/recommendations', {
-                developerId: args.developerId,
-                patterns: args.patterns || [],
-                outcomesMap: args.outcomesMap || {},
-                allProfiles: args.allProfiles || {},
-            });
-        case 'cell_outcome_leaderboard':
-            return daemonRequest('GET', `/outcomes/leaderboard?minEvents=${args.minEvents || 0}&limit=${args.limit || 20}`);
-        case 'cell_project_dna':
-            return daemonRequest('POST', '/project/dna-build', { projectPath: args.projectPath });
-        case 'cell_get_stack_summary':
-            return await (0, senior_features_1.getStackSummary)();
-        case 'cell_lint_style':
-            return await (0, senior_features_1.lintStyle)(args.file || 'unknown', args.code || '');
-        case 'cell_suggest_pattern':
-            return await (0, senior_features_1.suggestPattern)(args.file || 'unknown', args.context || '');
-        case 'cell_predict_next_file':
-            return await (0, senior_features_1.predictNextFile)();
-        case 'cell_daily_brief':
-            return await (0, senior_features_1.getDailyBrief)();
-        case 'cell_inject_context': {
-            (0, database_1.initializeDatabase)();
-            const ctx = (0, prompt_builder_1.buildContext)(args.projectPath, args.toolName);
-            const formatted = (0, prompt_builder_1.formatContextForInjection)(ctx, args.compact);
-            return {
-                content: [{ type: 'text', text: formatted }],
-                context: ctx,
-            };
-        }
-        case 'cell_session_start': {
-            (0, database_1.initializeDatabase)();
-            const sm = new session_memory_1.SessionMemory();
-            const sessionId = sm.startSession(args.toolName, args.project);
-            return { sessionId };
-        }
-        case 'cell_session_end': {
-            (0, database_1.initializeDatabase)();
-            const sm = new session_memory_1.SessionMemory();
-            sm.endSession(args.sessionId, {
-                filesTouched: args.filesTouched,
-                keyDecisions: args.keyDecisions,
-                contextSnapshot: args.contextSnapshot,
-            });
-            return { ended: true };
-        }
-        case 'cell_get_sessions': {
-            (0, database_1.initializeDatabase)();
-            const sm = new session_memory_1.SessionMemory();
-            const sessions = sm.getRecentSessions(args.limit || 10);
-            const stats = sm.getSessionStats();
-            const chain = sm.buildContextChain();
-            return { sessions, stats, contextChain: chain };
-        }
-        case 'cell_predict': {
-            const { getAllPredictions } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
-            const predictions = getAllPredictions(args.project);
-            const filtered = args.type ? predictions.filter((p) => p.type === args.type) : predictions;
-            return { predictions: filtered, count: filtered.length };
-        }
-        case 'cell_predict_risk': {
-            const { calculateFileRisk } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
-            return calculateFileRisk(args.file);
-        }
-        case 'cell_predict_time': {
-            const { estimateFeatureTime } = await Promise.resolve().then(() => __importStar(require('./predictive-intelligence')));
-            return estimateFeatureTime(args.feature);
-        }
-        case 'cell_tool_compare': {
-            const { compareTools } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
-            return { tools: compareTools() };
-        }
-        case 'cell_tool_suggest': {
-            const { suggestTool } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
-            return { suggestions: suggestTool(args.taskType) };
-        }
-        case 'cell_model_history': {
-            const { getModelHistory } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
-            return { history: getModelHistory() };
-        }
-        case 'cell_tool_context': {
-            const { buildToolSpecificContext } = await Promise.resolve().then(() => __importStar(require('./cross-model-memory')));
-            return { context: buildToolSpecificContext(args.toolName) };
-        }
-        case 'cell_team_health': {
-            const { getTeamHealth } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
-            return getTeamHealth(args.project);
-        }
-        case 'cell_team_silos': {
-            const { detectKnowledgeSilos, calculateBusFactor, suggestKnowledgeTransfer } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
-            return { silos: detectKnowledgeSilos(), busFactor: calculateBusFactor(), transfers: suggestKnowledgeTransfer() };
-        }
-        case 'cell_team_style': {
-            const { composeTeamStyle } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
-            return composeTeamStyle(args.project);
-        }
-        case 'cell_team_retro': {
-            const { generateSprintRetro } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
-            return generateSprintRetro(args.days || 14, args.project);
-        }
-        case 'cell_team_onboard': {
-            const { generateOnboardingDoc } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
-            return generateOnboardingDoc(args.teamName, args.project);
-        }
-        case 'cell_handoff': {
-            const { generateHandoff } = await Promise.resolve().then(() => __importStar(require('./team-collaboration')));
-            return generateHandoff(args.from, args.to, args.project);
-        }
-        case 'cell_community_compare': {
-            const { benchmarkPersonal, benchmarkBlindSpots } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
-            return { benchmarks: benchmarkPersonal(), blindSpots: benchmarkBlindSpots() };
-        }
-        case 'cell_community_trends': {
-            const { detectTrends, getCommunityStats } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
-            return { trends: detectTrends(), stats: getCommunityStats() };
-        }
-        case 'cell_community_insights': {
-            const { generateInsights } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
-            return { insights: generateInsights() };
-        }
-        case 'cell_community_stats': {
-            const { getCommunityStats } = await Promise.resolve().then(() => __importStar(require('./community-v2')));
-            return getCommunityStats();
-        }
-        case 'cell_rhythm': {
-            const { detectCodingRhythm } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
-            return detectCodingRhythm();
-        }
-        case 'cell_burnout': {
-            const { detectBurnout } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
-            return detectBurnout();
-        }
-        case 'cell_mastery': {
-            const { getTechMasteryMap } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
-            return { mastery: getTechMasteryMap() };
-        }
-        case 'cell_growth': {
-            const { getCareerTrajectory } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
-            return getCareerTrajectory();
-        }
-        case 'cell_insights_weekly': {
-            const { generateWeeklyDigest } = await Promise.resolve().then(() => __importStar(require('./personal-intelligence')));
-            return generateWeeklyDigest();
-        }
-        case 'cell_health': {
-            const { getHealthStatus } = await Promise.resolve().then(() => __importStar(require('./production')));
-            return getHealthStatus();
-        }
-        case 'cell_metrics': {
-            const { getMetrics } = await Promise.resolve().then(() => __importStar(require('./production')));
-            return getMetrics();
-        }
-        case 'cell_security': {
-            const { generateToken } = await Promise.resolve().then(() => __importStar(require('./production')));
-            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-            const pathMod = await Promise.resolve().then(() => __importStar(require('path')));
-            const osMod = await Promise.resolve().then(() => __importStar(require('os')));
-            const secFile = pathMod.join(osMod.homedir(), '.fivo', 'cell', 'security.json');
-            if (fs.existsSync(secFile)) {
-                return JSON.parse(fs.readFileSync(secFile, 'utf-8'));
-            }
-            return { error: 'no security config found' };
-        }
-        case 'cell_backup': {
-            const { autoBackup } = await Promise.resolve().then(() => __importStar(require('./production')));
-            return autoBackup();
-        }
-        case 'cell_optimize': {
-            const { optimizeDatabase } = await Promise.resolve().then(() => __importStar(require('./production')));
-            return optimizeDatabase();
-        }
-        case 'cell_debug_style': {
-            const { initializeIDETables, getDebugStyle } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
-            initializeIDETables();
-            return getDebugStyle();
-        }
-        case 'cell_prompt_style': {
-            const { initializeIDETables, getPromptStyle } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
-            initializeIDETables();
-            return getPromptStyle();
-        }
-        case 'cell_focus': {
-            const { initializeIDETables, getFocusAnalysis } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
-            initializeIDETables();
-            return getFocusAnalysis();
-        }
-        case 'cell_ide_insights': {
-            const { initializeIDETables, getIDEInsights } = await Promise.resolve().then(() => __importStar(require('./ide-intelligence')));
-            initializeIDETables();
-            return getIDEInsights();
-        }
-        case 'cell_cloud_status': {
-            const { getSyncStatus } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
-            return getSyncStatus();
-        }
-        case 'cell_cloud_validate': {
-            const { validatePayload } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
-            const data = params?.arguments?.data;
-            return validatePayload(data || {});
-        }
-        case 'cell_cloud_queue': {
-            const { getPendingQueue, retryFailedEntries } = await Promise.resolve().then(() => __importStar(require('./cloud-sync')));
-            return { pending: getPendingQueue(), retryable: retryFailedEntries() };
-        }
-        default:
-            return { error: `unknown tool: ${name}` };
-    }
-}
-async function handleResourceRead(params) {
-    const uri = params?.uri;
-    switch (uri) {
-        case 'cell://taste/profile':
-            return daemonRequest('GET', '/taste/profile');
-        case 'cell://community/stats':
-            return daemonRequest('GET', '/community/prior');
-        case 'cell://community/v2/stats':
-            return daemonRequest('GET', '/community/v2/stats');
-        case 'cell://community/v2/insights':
-            return daemonRequest('GET', '/community/v2/insights');
-        case 'cell://team/composite':
-            return daemonRequest('GET', '/team/composite');
-        case 'cell://org/v2/benchmarks': {
-            const { orgId } = params?.arguments || {};
-            if (!orgId)
-                return { error: 'orgId argument required' };
-            return daemonRequest('POST', `/org/v2/${orgId}/benchmarks`, {});
-        }
-        case 'cell://intelligence/reports': {
-            const reports = await daemonRequest('GET', '/intelligence/reports');
-            const full = [];
-            for (const id of reports.reports || []) {
-                const report = await daemonRequest('GET', `/intelligence/report/${encodeURIComponent(id)}`);
-                full.push(report);
-            }
-            return { reports: full };
-        }
-        case 'cell://health':
-            return daemonRequest('GET', '/health');
-        default:
-            return { error: `unknown resource: ${uri}` };
-    }
-}
 //# sourceMappingURL=mcp-server.js.map