fivocell 1.0.5 → 3.0.0

package/dist/daemon/server.js

@@ -113,7 +113,10 @@ const recommendation_store_1 = require("../core/recommendation-store");
 const community_intelligence_1 = require("../core/community-intelligence");
 const org_intelligence_1 = require("../core/org-intelligence");
 const cross_layer_intelligence_1 = require("../core/cross-layer-intelligence");
+const database_1 = require("../core/database");
+const logger_1 = require("../core/logger");
 const CELL_DIR = path.join(os.homedir(), '.fivo', 'cell');
+(0, database_1.initializeDatabase)();
 const META_PATH = path.join(CELL_DIR, 'cell-meta.json');
 const PORT = 9876;
 function getCloudConfig() {
@@ -121,7 +124,9 @@ function getCloudConfig() {
         if (fs.existsSync(META_PATH))
             return JSON.parse(fs.readFileSync(META_PATH, 'utf-8'));
     }
-    catch { }
+    catch (e) {
+        logger_1.logger.warn('Failed to read cell-meta.json: ' + String(e));
+    }
     return { cloudSyncEnabled: true };
 }
 const app = (0, express_1.default)();
@@ -199,16 +204,104 @@ app.get('/health', (_req, res) => {
     });
 });
 app.post('/signal', (req, res) => {
-    const { type, originalCode, editedCode, context } = req.body;
-    if (!type || !context) {
-        res.status(400).json({ error: 'type and context required' });
+    const { type, originalCode, editedCode, context, file, fromFile, costMs, durationMs, switchCount, language, errorMessage, errorType, line, fixApplied, fixWorked, timeToFixMs, decision, approach, result, worked, task, files, description, stuckId, resolution, project } = req.body;
+    if (!type) {
+        res.status(400).json({ error: 'type required' });
+        return;
+    }
+    // ─── Behavioral Signals ───────────────────────────────────────
+    if (type === 'error') {
+        const { logError, getErrorPatterns } = require('../behavioral-tracker');
+        const r = logError({ project, file, errorType, errorMessage, line });
+        // Check if repeat mistake — send warning
+        let warning = null;
+        try {
+            const patterns = getErrorPatterns(project);
+            const match = patterns.find((p) => p.error_type === errorType);
+            if (match && match.count >= 2) {
+                warning = `⚠ Repeat mistake! "${errorType}" has occurred ${match.count}x before. Fix the root cause.`;
+            }
+        }
+        catch { }
+        res.json({ recorded: true, id: r.id, warning });
+        return;
+    }
+    if (type === 'error_fix') {
+        const { logErrorFix } = require('../behavioral-tracker');
+        logErrorFix({ errorId: stuckId || 0, fixApplied: fixApplied || '', worked: fixWorked || false, timeToFixMs: timeToFixMs || 0 });
+        res.json({ recorded: true });
+        return;
+    }
+    if (type === 'decision') {
+        const { logDecision } = require('../behavioral-tracker');
+        const r = logDecision({ project, file, decision, approach, result, worked, context: req.body.context || '' });
+        // Auto-track in session memory
+        try {
+            const { SessionMemory } = require('../core/session-memory');
+            const mem = new SessionMemory();
+            const lastSess = mem.getLastSessionForProject(project || '');
+            if (lastSess && !lastSess.endTime) {
+                const decs = JSON.parse(String(lastSess.keyDecisions || '[]'));
+                decs.push(`${decision}: ${approach || result || ''}`);
+                mem.endSession(lastSess.id, { keyDecisions: decs, contextSnapshot: req.body.context || decision });
+            }
+        }
+        catch { }
+        res.json({ recorded: true, id: r.id });
+        return;
+    }
+    if (type === 'context') {
+        const { logContext } = require('../behavioral-tracker');
+        const r = logContext({ project, task, files });
+        // Auto-start session if none exists
+        try {
+            const { SessionMemory } = require('../core/session-memory');
+            const mem = new SessionMemory();
+            const lastSess = mem.getLastSessionForProject(project || '');
+            if (!lastSess || lastSess.endTime) {
+                const tool = req.body.tool || 'cli';
+                mem.startSession(tool, project || '');
+                if (files && files.length > 0) {
+                    const newSess = mem.getLastSessionForProject(project || '');
+                    if (newSess)
+                        mem.endSession(newSess.id, { filesTouched: files, contextSnapshot: task });
+                }
+            }
+        }
+        catch { }
+        res.json({ recorded: true, id: r.id });
+        return;
+    }
+    if (type === 'stuck') {
+        const { logStuck } = require('../behavioral-tracker');
+        const r = logStuck({ project, file, description });
+        res.json({ recorded: true, id: r.id });
+        return;
+    }
+    if (type === 'stuck_resolved') {
+        const { logStuckResolved } = require('../behavioral-tracker');
+        logStuckResolved(stuckId || 0, resolution || '');
+        res.json({ recorded: true });
         return;
     }
+    // ─── IDE Signals ──────────────────────────────────────────────
+    if (type === 'tab_switch' || type === 'focus_block' || type === 'file_save') {
+        try {
+            const db = (0, database_1.getDb)();
+            db.prepare('INSERT INTO behavior_events (event_type, project, file_path, description, severity, evidence) VALUES (?, ?, ?, ?, ?, ?)')
+                .run(type, '', file || '', JSON.stringify({ fromFile, costMs, durationMs, switchCount, language }), 'low', JSON.stringify(req.body));
+        }
+        catch { }
+        res.json({ recorded: true, type });
+        return;
+    }
+    // ─── Legacy Signals ──────────────────────────────────────────
+    const ctx = context || {};
     let signal;
     let patternsExtracted = 0;
     switch (type) {
         case 'edit_diff': {
-            signal = engines.signalCapture.captureEditDiff(originalCode || '', editedCode || '', context);
+            signal = engines.signalCapture.captureEditDiff(originalCode || '', editedCode || '', ctx);
             try {
                 const result = engines.extractionCascade.extract(originalCode || '', editedCode || '');
                 patternsExtracted = engines.learningLayer.process(result, true);
@@ -221,35 +314,28 @@ app.post('/signal', (req, res) => {
             break;
         }
         case 'accept': {
-            signal = engines.signalCapture.captureAccept(originalCode || '', context);
+            signal = engines.signalCapture.captureAccept(originalCode || '', ctx);
             const dummy = engines.patternStore.getAllPatterns().slice(0, 1);
             for (const p of dummy) {
                 const step = (0, workflow_tracker_1.recordStep)(p, 'accept');
                 (0, outcome_recorder_1.recordOutcome)(p, 'accept', step.sessionId, true, 0);
-                (0, failure_memory_1.recordFailure)(p, false, context?.language || 'unknown');
-                (0, time_saved_1.recordTimeSaved)({
-                    patternId: p.patternId,
-                    category: p.category,
-                    description: p.description,
-                    from: p.from,
-                    to: p.to,
-                    language: context?.language || 'unknown',
-                });
+                (0, failure_memory_1.recordFailure)(p, false, ctx.language || 'unknown');
+                (0, time_saved_1.recordTimeSaved)({ patternId: p.patternId, category: p.category, description: p.description, from: p.from, to: p.to, language: ctx.language || 'unknown' });
             }
             break;
         }
         case 'reject': {
-            signal = engines.signalCapture.captureReject(originalCode || '', context);
+            signal = engines.signalCapture.captureReject(originalCode || '', ctx);
             const dummyR = engines.patternStore.getAllPatterns().slice(0, 1);
             for (const p of dummyR) {
                 const step = (0, workflow_tracker_1.recordStep)(p, 'reject');
                 (0, outcome_recorder_1.recordOutcome)(p, 'reject', step.sessionId, false, 0);
-                (0, failure_memory_1.recordFailure)(p, true, context?.language || 'unknown');
+                (0, failure_memory_1.recordFailure)(p, true, ctx.language || 'unknown');
             }
             break;
         }
         case 'retry': {
-            signal = engines.signalCapture.captureRetry(originalCode || '', context);
+            signal = engines.signalCapture.captureRetry(originalCode || '', ctx);
             const dummyRt = engines.patternStore.getAllPatterns().slice(0, 1);
             for (const p of dummyRt) {
                 const step = (0, workflow_tracker_1.recordStep)(p, 'retry');
@@ -318,15 +404,25 @@ app.get('/confidence/:patternId', (req, res) => {
 });
 // ─── IMPACT TRACKING ──────────────────────────────────
 const impactLog = [];
+function persistImpact(entry) {
+    try {
+        const db = (0, database_1.getDb)();
+        db.prepare('INSERT INTO outcomes (outcome_type, pattern_id, project, description, created_at) VALUES (?, ?, ?, ?, ?)')
+            .run('impact', entry.patternId, '', `Applied via ${entry.surface}`, new Date(entry.timestamp).toISOString());
+    }
+    catch { /* best-effort */ }
+}
 app.post('/impact/record', (req, res) => {
     const { patternId, surface } = req.body;
     if (!patternId) {
         res.status(400).json({ error: 'patternId required' });
         return;
     }
-    impactLog.push({ patternId, timestamp: Date.now(), surface: surface || 'unknown' });
+    const entry = { patternId, timestamp: Date.now(), surface: surface || 'unknown' };
+    impactLog.push(entry);
     if (impactLog.length > 10000)
         impactLog.splice(0, impactLog.length - 10000);
+    persistImpact(entry);
     res.json({ recorded: true });
 });
 app.get('/impact/weekly', (_req, res) => {
@@ -368,7 +464,9 @@ app.post('/onboarding/scan', (req, res) => {
                 insights.push('TypeScript strict mode → You likely prefer const over let');
         }
     }
-    catch { }
+    catch (e) {
+        logger_1.logger.warn('Failed to read tsconfig: ' + String(e));
+    }
     try {
         const eslintPaths = ['.eslintrc.json', '.eslintrc.js', '.eslintrc.yaml', '.eslintrc.yml', 'eslint.config.js'];
         for (const eslintFile of eslintPaths) {
@@ -379,12 +477,16 @@ app.post('/onboarding/scan', (req, res) => {
                     if (JSON.stringify(eslint).includes('singlequote') || JSON.stringify(eslint).includes('single'))
                         insights.push('ESLint single quotes → You prefer \' over \"');
                 }
-                catch { }
+                catch (e) {
+                    logger_1.logger.warn('Failed to parse eslint config: ' + String(e));
+                }
                 break;
             }
         }
     }
-    catch { }
+    catch (e) {
+        logger_1.logger.warn('Failed to read eslint: ' + String(e));
+    }
     try {
         const pkgPath = path.join(dir, 'package.json');
         if (fs.existsSync(pkgPath)) {
@@ -404,7 +506,9 @@ app.post('/onboarding/scan', (req, res) => {
                 insights.push('Zod → You prefer schema validation');
         }
     }
-    catch { }
+    catch (e) {
+        logger_1.logger.warn('Failed to read package.json: ' + String(e));
+    }
     res.json({ insights, count: insights.length, projectPath: dir });
 });
 // ─── LOCAL DASHBOARD HTML ─────────────────────────────
@@ -1299,20 +1403,528 @@ app.post('/intelligence/reset', (_req, res) => {
     (0, cross_layer_intelligence_1.resetCrossLayer)();
     res.json({ reset: true });
 });
+// ─── CONTEXT INJECTION ───────────────────────────────
+const prompt_builder_1 = require("../core/prompt-builder");
+const session_memory_1 = require("../core/session-memory");
+const sessionMemory = new session_memory_1.SessionMemory();
+app.post('/session/start', (req, res) => {
+    const { toolName, project } = req.body;
+    const id = sessionMemory.startSession(toolName || 'unknown', project || 'unknown');
+    res.json({ sessionId: id });
+});
+app.post('/session/end', (req, res) => {
+    const { sessionId, filesTouched, keyDecisions, contextSnapshot } = req.body;
+    sessionMemory.endSession(Number(sessionId), { filesTouched, keyDecisions, contextSnapshot });
+    res.json({ ended: true });
+});
+app.get('/session/history', (req, res) => {
+    const limit = Number(req.query.limit) || 10;
+    const sessions = sessionMemory.getRecentSessions(limit);
+    const stats = sessionMemory.getSessionStats();
+    const chain = sessionMemory.buildContextChain();
+    res.json({ sessions, stats, contextChain: chain });
+});
+app.get('/session/search', (req, res) => {
+    const query = String(req.query.q || '');
+    const results = query ? sessionMemory.searchSessions(query) : [];
+    res.json({ query, results: results.slice(0, 10) });
+});
+app.get('/session/bugs', (req, res) => {
+    const bugs = sessionMemory.getBugHistory(String(req.query.project || ''));
+    const repeats = sessionMemory.getRepeatBugs();
+    res.json({ bugs: bugs.slice(0, 20), repeatBugs: repeats });
+});
+app.get('/session/decisions', (req, res) => {
+    const decisions = sessionMemory.getDecisionHistory(String(req.query.project || ''));
+    const summary = sessionMemory.getDecisionSummary();
+    res.json({ decisions: decisions.slice(0, 20), summary });
+});
+app.get('/context/inject', (req, res) => {
+    const projectPath = req.query.projectPath;
+    const toolName = req.query.tool;
+    const compact = req.query.compact === 'true' || req.query.compact === '1';
+    const ctx = (0, prompt_builder_1.buildContext)(projectPath, toolName);
+    const text = (0, prompt_builder_1.formatContextForInjection)(ctx, compact);
+    res.json({ content: [{ type: 'text', text }], context: ctx });
+});
+app.get('/predict', (req, res) => {
+    const project = String(req.query.project || '');
+    const type = String(req.query.type || '');
+    Promise.resolve().then(() => __importStar(require('../predictive-intelligence'))).then(({ getAllPredictions }) => {
+        const predictions = getAllPredictions(project || undefined);
+        const filtered = type ? predictions.filter(p => p.type === type) : predictions;
+        res.json({ predictions: filtered, count: filtered.length });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/predict-risk/:file', (req, res) => {
+    const file = req.params.file;
+    Promise.resolve().then(() => __importStar(require('../predictive-intelligence'))).then(({ calculateFileRisk }) => {
+        res.json(calculateFileRisk(file));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/predict-time/:feature', (req, res) => {
+    const feature = req.params.feature;
+    Promise.resolve().then(() => __importStar(require('../predictive-intelligence'))).then(({ estimateFeatureTime }) => {
+        res.json(estimateFeatureTime(feature));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/tools/compare', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../cross-model-memory'))).then(({ compareTools }) => {
+        res.json({ tools: compareTools() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/tools/suggest', (req, res) => {
+    const taskType = String(req.query.task || '');
+    if (!taskType) {
+        res.status(400).json({ error: 'task query param required' });
+        return;
+    }
+    Promise.resolve().then(() => __importStar(require('../cross-model-memory'))).then(({ suggestTool }) => {
+        res.json({ suggestions: suggestTool(taskType) });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/tools/history', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../cross-model-memory'))).then(({ getModelHistory }) => {
+        res.json({ history: getModelHistory() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/tools/context/:tool', (req, res) => {
+    const tool = req.params.tool;
+    Promise.resolve().then(() => __importStar(require('../cross-model-memory'))).then(({ buildToolSpecificContext }) => {
+        res.json({ context: buildToolSpecificContext(tool) });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/team/health', (req, res) => {
+    const project = String(req.query.project || '') || undefined;
+    Promise.resolve().then(() => __importStar(require('../team-collaboration'))).then(({ getTeamHealth }) => {
+        res.json(getTeamHealth(project));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/team/silos', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../team-collaboration'))).then(({ detectKnowledgeSilos, calculateBusFactor, suggestKnowledgeTransfer }) => {
+        res.json({ silos: detectKnowledgeSilos(), busFactor: calculateBusFactor(), transfers: suggestKnowledgeTransfer() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/team/style', (req, res) => {
+    const project = String(req.query.project || '') || undefined;
+    Promise.resolve().then(() => __importStar(require('../team-collaboration'))).then(({ composeTeamStyle }) => {
+        res.json(composeTeamStyle(project));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/team/retro', (req, res) => {
+    const days = parseInt(String(req.query.days || '14')) || 14;
+    const project = String(req.query.project || '') || undefined;
+    Promise.resolve().then(() => __importStar(require('../team-collaboration'))).then(({ generateSprintRetro }) => {
+        res.json(generateSprintRetro(days, project));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/team/onboard/:team', (req, res) => {
+    const team = req.params.team;
+    const project = String(req.query.project || '') || undefined;
+    Promise.resolve().then(() => __importStar(require('../team-collaboration'))).then(({ generateOnboardingDoc }) => {
+        res.json(generateOnboardingDoc(team, project));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/community/compare', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../community-v2'))).then(({ benchmarkPersonal, benchmarkBlindSpots }) => {
+        res.json({ benchmarks: benchmarkPersonal(), blindSpots: benchmarkBlindSpots() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/community/trends', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../community-v2'))).then(({ detectTrends, getCommunityStats }) => {
+        res.json({ trends: detectTrends(), stats: getCommunityStats() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/community/insights', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../community-v2'))).then(({ generateInsights }) => {
+        res.json({ insights: generateInsights() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/personal/rhythm', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../personal-intelligence'))).then(({ detectCodingRhythm }) => {
+        res.json(detectCodingRhythm());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/personal/burnout', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../personal-intelligence'))).then(({ detectBurnout }) => {
+        res.json(detectBurnout());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/personal/mastery', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../personal-intelligence'))).then(({ getTechMasteryMap }) => {
+        res.json({ mastery: getTechMasteryMap() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/personal/growth', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../personal-intelligence'))).then(({ getCareerTrajectory }) => {
+        res.json(getCareerTrajectory());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/personal/weekly', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../personal-intelligence'))).then(({ generateWeeklyDigest }) => {
+        res.json(generateWeeklyDigest());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/production/health', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../production'))).then(({ getHealthStatus }) => {
+        res.json(getHealthStatus());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/production/metrics', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../production'))).then(({ getMetrics }) => {
+        res.json(getMetrics());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/production/security', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../production'))).then(() => {
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+        const secFile = path.join(os.homedir(), '.fivo', 'cell', 'security.json');
+        if (fs.existsSync(secFile)) {
+            res.json(JSON.parse(fs.readFileSync(secFile, 'utf-8')));
+        }
+        else {
+            res.status(404).json({ error: 'no security config' });
+        }
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.post('/production/backup', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../production'))).then(({ autoBackup }) => {
+        res.json(autoBackup());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.post('/production/optimize', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../production'))).then(({ optimizeDatabase }) => {
+        res.json(optimizeDatabase());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/ide/debug-style', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../ide-intelligence'))).then(({ initializeIDETables, getDebugStyle }) => {
+        initializeIDETables();
+        res.json(getDebugStyle());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/ide/prompt-style', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../ide-intelligence'))).then(({ initializeIDETables, getPromptStyle }) => {
+        initializeIDETables();
+        res.json(getPromptStyle());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/ide/focus', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../ide-intelligence'))).then(({ initializeIDETables, getFocusAnalysis }) => {
+        initializeIDETables();
+        res.json(getFocusAnalysis());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/ide/insights', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../ide-intelligence'))).then(({ initializeIDETables, getIDEInsights }) => {
+        initializeIDETables();
+        res.json(getIDEInsights());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/cloud/status', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../cloud-sync'))).then(({ getSyncStatus }) => {
+        res.json(getSyncStatus());
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.post('/cloud/validate', (req, res) => {
+    Promise.resolve().then(() => __importStar(require('../cloud-sync'))).then(({ validatePayload }) => {
+        res.json(validatePayload(req.body || {}));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/cloud/queue', (_req, res) => {
+    Promise.resolve().then(() => __importStar(require('../cloud-sync'))).then(({ getPendingQueue, retryFailedEntries }) => {
+        res.json({ pending: getPendingQueue(), retryable: retryFailedEntries() });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.post('/cloud/push', (req, res) => {
+    Promise.resolve().then(() => __importStar(require('../cloud-sync'))).then(({ pushToCloud }) => {
+        pushToCloud(req.body?.data || {}, req.body?.type || 'pattern').then(r => res.json(r));
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+// ─── CODE SCANNER (Deep Learning) ──────────────────────
+app.post('/scan/codebase', (req, res) => {
+    const { dir, project } = req.body;
+    if (!dir) {
+        res.status(400).json({ error: 'dir required' });
+        return;
+    }
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ scanCodebase }) => {
+        const result = scanCodebase(dir, project || require('path').basename(dir));
+        res.json(result);
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/scan/profile/:project', (req, res) => {
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ getDeveloperProfile }) => {
+        const profile = getDeveloperProfile(req.params.project);
+        if (!profile) {
+            res.status(404).json({ error: 'no profile — run scan first' });
+            return;
+        }
+        res.json(profile);
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/scan/patterns/:project', (req, res) => {
+    const category = req.query.category;
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ getCodePatterns }) => {
+        res.json({ patterns: getCodePatterns(req.params.project, category) });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+app.get('/scan/report/:project', (req, res) => {
+    Promise.resolve().then(() => __importStar(require('../code-scanner'))).then(({ getDeveloperProfile, getCodePatterns }) => {
+        const profile = getDeveloperProfile(req.params.project);
+        const patterns = getCodePatterns(req.params.project);
+        res.json({ project: req.params.project, profile, patterns, patternCount: patterns.length });
+    }).catch(e => res.status(500).json({ error: String(e) }));
+});
+// ─── BEHAVIORAL TRACKING ──────────────────────────────────────
+app.get('/behavior/summary', (req, res) => {
+    const { getBehaviorSummary } = require('../behavioral-tracker');
+    res.json(getBehaviorSummary(String(req.query.project || undefined)));
+});
+app.get('/behavior/errors', (req, res) => {
+    const { getErrorPatterns, getRecentErrors } = require('../behavioral-tracker');
+    res.json({ patterns: getErrorPatterns(String(req.query.project || undefined)), recent: getRecentErrors(10, String(req.query.project || undefined)) });
+});
+app.get('/behavior/decisions', (req, res) => {
+    const { getDecisions } = require('../behavioral-tracker');
+    res.json({ decisions: getDecisions(String(req.query.project || undefined), 20) });
+});
+app.get('/behavior/context', (req, res) => {
+    const { getCurrentContext } = require('../behavioral-tracker');
+    res.json(getCurrentContext(String(req.query.project || undefined)) || { task: 'none', files: [] });
+});
+app.get('/behavior/stuck', (req, res) => {
+    const { getStuckPatterns } = require('../behavioral-tracker');
+    res.json({ stuck: getStuckPatterns(String(req.query.project || undefined)) });
+});
+// ─── Session Bridge Helper ────────────────────────────────────────────────
+function formatSessionBridge(fromTool, toTool, context, decisions) {
+    const lines = [];
+    lines.push(`═══ CROSS-SESSION BRIDGE ═══`);
+    lines.push(`From: ${fromTool} → To: ${toTool}`);
+    if (context)
+        lines.push(`Last context: ${context}`);
+    if (decisions && decisions !== 'none' && decisions !== '[]') {
+        lines.push(`Decisions made: ${decisions}`);
+    }
+    lines.push(`Cell remembers. No need to re-explain.`);
+    return lines.join('\n');
+}
+// ─── MCP ENDPOINTS (merged from mcp-server.ts) ─────────────────────────────
+const MCP_TOOLS = [
+    { name: 'cell_get_dev_profile', description: 'Developer profile — naming, style, errors, architecture', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_get_code_patterns', description: 'Code patterns by category', inputSchema: { type: 'object', properties: { project: { type: 'string' }, category: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_deep_scan', description: 'Deep scan codebase', inputSchema: { type: 'object', properties: { dir: { type: 'string' }, project: { type: 'string' } }, required: ['dir'] } },
+    { name: 'cell_scan_report', description: 'Full scan report', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_send_signal', description: 'Send learning signal', inputSchema: { type: 'object', properties: { type: { type: 'string' }, originalCode: { type: 'string' }, editedCode: { type: 'string' }, file: { type: 'string' }, language: { type: 'string' } }, required: ['type'] } },
+    { name: 'cell_get_context', description: 'Full context injection', inputSchema: { type: 'object', properties: { project: { type: 'string' }, tool: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_scan_full_pc', description: 'Scan entire PC for all code projects', inputSchema: { type: 'object', properties: {} } },
+    { name: 'cell_behavior_summary', description: 'Behavioral summary', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_log_error', description: 'Log an error encounter', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, errorType: { type: 'string' }, errorMessage: { type: 'string' }, line: { type: 'number' } }, required: ['errorType', 'errorMessage'] } },
+    { name: 'cell_log_fix', description: 'Log how an error was fixed', inputSchema: { type: 'object', properties: { errorId: { type: 'number' }, fixApplied: { type: 'string' }, worked: { type: 'boolean' }, timeToFixMs: { type: 'number' } }, required: ['errorId', 'fixApplied', 'worked'] } },
+    { name: 'cell_log_decision', description: 'Log a coding decision', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, decision: { type: 'string' }, approach: { type: 'string' }, worked: { type: 'boolean' } }, required: ['decision'] } },
+    { name: 'cell_log_context', description: 'Log current context', inputSchema: { type: 'object', properties: { project: { type: 'string' }, task: { type: 'string' }, files: { type: 'array', items: { type: 'string' } } }, required: ['task'] } },
+    { name: 'cell_log_stuck', description: 'Log when stuck', inputSchema: { type: 'object', properties: { project: { type: 'string' }, file: { type: 'string' }, description: { type: 'string' } }, required: ['description'] } },
+    { name: 'cell_session_bridge', description: 'Cross-session memory bridge — get last session context when switching tools', inputSchema: { type: 'object', properties: { project: { type: 'string' }, tool: { type: 'string' } }, required: ['project'] } },
+    { name: 'cell_predict', description: 'Predictive intelligence — repeat mistakes, decision regret, energy warnings, complexity traps', inputSchema: { type: 'object', properties: { project: { type: 'string' } }, required: [] } },
+];
+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, formatContextForInjection } = require('../core/prompt-builder');
+            const ctx = buildContext(args.project, args.tool);
+            return { content: [{ type: 'text', text: formatContextForInjection(ctx, false) }], 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 {
+                // Get last session for this project
+                const lastSession = memory.getLastSessionForProject(project);
+                // Start new session for current tool
+                const newSessionId = memory.startSession(tool, project);
+                // If there was a previous session with a different tool, bridge it
+                let bridgeContext = '';
+                if (lastSession && lastSession.toolName !== tool) {
+                    const decisions = lastSession.keyDecisions ? JSON.stringify(lastSession.keyDecisions) : 'none';
+                    bridgeContext = formatSessionBridge(lastSession.toolName, tool, lastSession.contextSnapshot, decisions);
+                }
+                // Get recent sessions for context chain
+                const recentSessions = memory.getRecentSessions(3).filter((s) => s.project === project);
+                const sessionHistory = recentSessions.map((s) => ({
+                    tool: s.toolName,
+                    when: s.startTime,
+                    files: JSON.parse(String(s.filesTouched || '[]')),
+                    decisions: JSON.parse(String(s.keyDecisions || '[]')),
+                }));
+                return {
+                    newSessionId,
+                    lastSession: lastSession ? {
+                        tool: lastSession.toolName,
+                        startedAt: lastSession.startTime,
+                        context: lastSession.contextSnapshot,
+                    } : null,
+                    bridgeContext,
+                    sessionHistory,
+                    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_predict': {
+            const { generatePredictions } = require('../predictive-engine');
+            return generatePredictions(args.project);
+        }
+        default:
+            return { error: `unknown tool: ${name}` };
+    }
+}
+app.post('/mcp', async (req, res) => {
+    const rpc = req.body;
+    const { method, params, id } = rpc;
+    try {
+        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);
+        res.status(200).json({ jsonrpc: '2.0', id, error: { code: -1, message } });
+    }
+});
 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' });
 });
+// ─── Self-Healing ──────────────────────────────────────────────────────
+process.on('uncaughtException', (err) => {
+    console.error('[cell] Uncaught:', err.message);
+    // Don't exit — keep serving
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[cell] Unhandled rejection:', String(reason));
+});
 try {
     (0, ai_memory_1.initializeMemory)();
 }
 catch (e) {
     console.error('AI memory init failed:', e);
 }
-app.listen(PORT, () => {
+// ─── Start with port conflict handling ─────────────────────────────────
+const server = app.listen(PORT, () => {
     console.log(`Cell Daemon running on http://localhost:${PORT}`);
-    console.log(`Modules loaded: ${Object.keys(engines).length}`);
+    console.log(`MCP endpoint: POST http://localhost:${PORT}/mcp`);
     console.log(`Health: http://localhost:${PORT}/health`);
 });
+server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+        console.error(`[cell] Port ${PORT} in use. Kill existing daemon first: cell stop`);
+    }
+    else {
+        console.error(`[cell] Server error: ${err.message}`);
+    }
+});
+server.on('close', () => {
+    console.log('[cell] Daemon stopped.');
+});
+// Graceful shutdown
+const gracefulShutdown = () => {
+    console.log('[cell] Daemon shutting down...');
+    server.close();
+    process.exit(0);
+};
+process.on('SIGTERM', gracefulShutdown);
+process.on('SIGINT', gracefulShutdown);
 //# sourceMappingURL=server.js.map