fivocell 3.1.0 → 4.1.0

package/dist/code-scanner.js

@@ -41,8 +41,10 @@ exports.formatScanReportCompact = formatScanReportCompact;
 exports.ensureCodePatternTable = ensureCodePatternTable;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const ts = __importStar(require("typescript"));
 const database_1 = require("./core/database");
+const stack_detector_1 = require("./stack-detector");
 // ─── Language Detection ──────────────────────────────────────────────────────
 const EXT_MAP = {
     '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript',
@@ -394,9 +396,32 @@ function extractASTPatterns(content, filePath) {
         let zodImports = false;
         let nestDepth = 0;
         let maxNestDepth = 0;
+        let controlFlowDepth = 0;
+        let maxControlFlowDepth = 0;
+        let nPlusOne = 0;
+        let hardcodedSecrets = 0;
+        let missingNullCheck = 0;
+        let missingInputValidation = 0;
         const visit = (node, depth) => {
             nestDepth = Math.max(nestDepth, depth);
             maxNestDepth = Math.max(maxNestDepth, depth);
+            const isControlFlow = ts.isIfStatement(node) ||
+                ts.isForStatement(node) ||
+                ts.isForInStatement(node) ||
+                ts.isForOfStatement(node) ||
+                ts.isWhileStatement(node) ||
+                ts.isDoStatement(node) ||
+                ts.isSwitchStatement(node) ||
+                ts.isTryStatement(node) ||
+                ts.isConditionalExpression(node);
+            if (isControlFlow) {
+                controlFlowDepth = depth;
+                maxControlFlowDepth = Math.max(maxControlFlowDepth, depth);
+            }
+            if (isControlFlow) {
+                ts.forEachChild(node, (child) => visit(child, depth + 1));
+                return;
+            }
             // ── Async without try/catch ──────────────────────────────────────
             if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node)) {
                 const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
@@ -414,7 +439,10 @@ function extractASTPatterns(content, filePath) {
                     if (!hasTryCatch)
                         asyncNoTryCatch++;
                     // Return type check
-                    if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
+                    if (ts.isFunctionDeclaration(node) ||
+                        ts.isMethodDeclaration(node) ||
+                        ts.isFunctionExpression(node) ||
+                        ts.isArrowFunction(node)) {
                         const hasReturnType = node.type !== undefined;
                         if (hasReturnType)
                             functionsWithType++;
@@ -452,6 +480,128 @@ function extractASTPatterns(content, filePath) {
                     if (expr.expression.getText().startsWith('z.'))
                         zodImports = true;
                 }
+                // N+1 query detection: await/query inside loop
+                if (ts.isCallExpression(node)) {
+                    const callText = expr.getText();
+                    if (callText.includes('.find') || callText.includes('.query') || callText.includes('.execute') ||
+                        callText.includes('fetch') || callText.includes('prisma.') || callText.includes('db.')) {
+                        let parent = node.parent;
+                        while (parent) {
+                            if (ts.isForStatement(parent) ||
+                                ts.isForInStatement(parent) ||
+                                ts.isForOfStatement(parent) ||
+                                ts.isWhileStatement(parent) ||
+                                ts.isDoStatement(parent) ||
+                                (ts.isCallExpression(parent) &&
+                                    ts.isPropertyAccessExpression(parent.expression) &&
+                                    (parent.expression.name.text === 'map' || parent.expression.name.text === 'forEach'))) {
+                                nPlusOne++;
+                                break;
+                            }
+                            parent = parent.parent;
+                        }
+                    }
+                }
+                // Missing null check detection — any property access on awaited API call
+                if (ts.isPropertyAccessExpression(expr)) {
+                    let base = expr.expression;
+                    while (ts.isPropertyAccessExpression(base))
+                        base = base.expression;
+                    const baseText = base.getText();
+                    if (baseText.includes('fetch') ||
+                        baseText.includes('axios') ||
+                        baseText.includes('request') ||
+                        baseText.includes('http.get') ||
+                        baseText.includes('prisma.') ||
+                        baseText.includes('db.')) {
+                        let hasAwait = false;
+                        let hasNullCheck = false;
+                        let ancestor = expr.parent;
+                        while (ancestor && (!hasAwait || !hasNullCheck)) {
+                            if (ts.isAwaitExpression(ancestor))
+                                hasAwait = true;
+                            if (ts.isExpressionStatement(ancestor) || ts.isVariableDeclaration(ancestor))
+                                break;
+                            if (ts.isIfStatement(ancestor)) {
+                                const condText = ancestor.expression.getText();
+                                if (condText.includes('!') ||
+                                    condText.includes('null') ||
+                                    condText.includes('undefined') ||
+                                    condText.includes('?.')) {
+                                    hasNullCheck = true;
+                                }
+                            }
+                            if (ts.isBinaryExpression(ancestor) &&
+                                (ancestor.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
+                                    ancestor.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+                                    ancestor.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
+                                    ancestor.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken)) {
+                                const text = ancestor.getText();
+                                if (text.includes('null') || text.includes('undefined')) {
+                                    hasNullCheck = true;
+                                }
+                            }
+                            ancestor = ancestor.parent;
+                        }
+                        if (hasAwait && !hasNullCheck)
+                            missingNullCheck++;
+                    }
+                }
+            }
+            // ── Hardcoded secrets detection ─────────────────────────────────
+            if (ts.isVariableDeclaration(node)) {
+                const varNode = node;
+                const varName = ts.isIdentifier(varNode.name) ? varNode.name.text : '';
+                const lower = varName.toLowerCase();
+                if ((lower.includes('password') || lower.includes('secret') || lower.includes('api_key') ||
+                    lower.includes('apikey') || (lower.includes('token') && lower.includes('auth'))) &&
+                    varNode.initializer && ts.isStringLiteral(varNode.initializer)) {
+                    const val = varNode.initializer.text;
+                    if (val.length > 6 && !val.includes('${') && !val.startsWith('process.env')) {
+                        hardcodedSecrets++;
+                    }
+                }
+            }
+            // ── Missing input validation in API handlers ────────────────────
+            const isHandlerLike = ts.isFunctionDeclaration(node) ||
+                ts.isFunctionExpression(node) ||
+                ts.isArrowFunction(node);
+            if (isHandlerLike) {
+                let funcName = '';
+                let body;
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    funcName = node.name.text;
+                    body = node.body;
+                }
+                else if (ts.isFunctionExpression(node) ||
+                    ts.isArrowFunction(node)) {
+                    let p = node.parent;
+                    while (p) {
+                        if (ts.isVariableDeclaration(p) && ts.isIdentifier(p.name)) {
+                            funcName = p.name.text;
+                            break;
+                        }
+                        p = p.parent;
+                    }
+                    body = node.body;
+                }
+                if (funcName.toLowerCase().includes('handler') || funcName.toLowerCase().includes('route') || funcName.toLowerCase().includes('endpoint') || funcName.toLowerCase().includes('controller')) {
+                    let hasValidation = false;
+                    const checkBody = (n) => {
+                        if (ts.isCallExpression(n)) {
+                            const ct = n.expression.getText();
+                            if (ct.includes('.parse') || ct.includes('.validate') || ct.includes('.safeParse') ||
+                                ct.includes('check(') || ct.includes('body(') || ct.includes('query(')) {
+                                hasValidation = true;
+                            }
+                        }
+                        ts.forEachChild(n, checkBody);
+                    };
+                    if (body)
+                        checkBody(body);
+                    if (!hasValidation)
+                        missingInputValidation++;
+                }
             }
             // ── any type usage ──────────────────────────────────────────────
             if (ts.isToken(node) && node.kind === ts.SyntaxKind.AnyKeyword)
@@ -505,12 +655,12 @@ function extractASTPatterns(content, filePath) {
                 trustScore: 85,
             });
         }
-        if (maxNestDepth > 4) {
+        if (maxControlFlowDepth > 4) {
             patterns.push({
                 type: 'blind_spot_deep_nesting',
                 category: 'blind_spots',
-                value: `max_nesting:${maxNestDepth}`,
-                count: maxNestDepth,
+                value: `max_nesting:${maxControlFlowDepth}`,
+                count: maxControlFlowDepth,
                 trustScore: 80,
             });
         }
@@ -532,6 +682,42 @@ function extractASTPatterns(content, filePath) {
                 trustScore: 90,
             });
         }
+        if (nPlusOne > 0) {
+            patterns.push({
+                type: 'blind_spot_n_plus_one',
+                category: 'blind_spots',
+                value: `n_plus_one_queries:${nPlusOne}`,
+                count: nPlusOne,
+                trustScore: 85,
+            });
+        }
+        if (hardcodedSecrets > 0) {
+            patterns.push({
+                type: 'blind_spot_hardcoded_secret',
+                category: 'blind_spots',
+                value: `hardcoded_secrets:${hardcodedSecrets}`,
+                count: hardcodedSecrets,
+                trustScore: 95,
+            });
+        }
+        if (missingNullCheck > 0) {
+            patterns.push({
+                type: 'blind_spot_null_check',
+                category: 'blind_spots',
+                value: `missing_null_checks:${missingNullCheck}`,
+                count: missingNullCheck,
+                trustScore: 80,
+            });
+        }
+        if (missingInputValidation > 0) {
+            patterns.push({
+                type: 'blind_spot_no_validation',
+                category: 'blind_spots',
+                value: `missing_input_validation:${missingInputValidation}`,
+                count: missingInputValidation,
+                trustScore: 85,
+            });
+        }
     }
     catch { /* AST parse may fail on broken files */ }
     return patterns;
@@ -602,8 +788,9 @@ function aggregatePatterns(analyses) {
             const key = `${pattern.type}:${pattern.value}`;
             const existing = patternMap.get(key);
             if (existing) {
-                existing.count += pattern.count;
-                existing.trustScore = Math.min(95, Math.round((existing.trustScore + pattern.trustScore) / 2));
+                const totalCount = existing.count + pattern.count;
+                existing.trustScore = Math.min(95, Math.round((existing.trustScore * existing.count + pattern.trustScore * pattern.count) / totalCount));
+                existing.count = totalCount;
             }
             else {
                 patternMap.set(key, { ...pattern });
@@ -688,6 +875,23 @@ function buildDeveloperProfile(patterns) {
         strengths.push('Uses Zod validation for inputs');
     else
         improvements.push('Add input validation (Zod/Joi/Yup)');
+    // Blind spots v2
+    const nPlusOne = patterns.find(p => p.type === 'blind_spot_n_plus_one');
+    if (nPlusOne && nPlusOne.count > 0) {
+        improvements.push(`${nPlusOne.count} N+1 query patterns — DB calls inside loops`);
+    }
+    const secrets = patterns.find(p => p.type === 'blind_spot_hardcoded_secret');
+    if (secrets && secrets.count > 0) {
+        improvements.push(`${secrets.count} hardcoded secrets/API keys — move to env vars`);
+    }
+    const nullChecks = patterns.find(p => p.type === 'blind_spot_null_check');
+    if (nullChecks && nullChecks.count > 0) {
+        improvements.push(`${nullChecks.count} API responses used without null check`);
+    }
+    const noValidation = patterns.find(p => p.type === 'blind_spot_no_validation');
+    if (noValidation && noValidation.count > 0) {
+        improvements.push(`${noValidation.count} API handlers missing input validation`);
+    }
     if (asyncNoTry && asyncNoTry.count === 0 && patterns.find(p => p.type === 'error_trycatch')) {
         strengths.push('All async functions have try/catch error handling');
     }
@@ -713,54 +917,68 @@ function buildDeveloperProfile(patterns) {
 // ─── Database Storage ────────────────────────────────────────────────────────
 function ensureCodePatternTable() {
     const db = (0, database_1.getDb)();
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS code_patterns (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      project TEXT NOT NULL,
-      file_path TEXT NOT NULL,
-      pattern_type TEXT NOT NULL,
-      pattern_value TEXT NOT NULL,
-      category TEXT NOT NULL,
-      count INTEGER DEFAULT 1,
-      trust_score INTEGER DEFAULT 50,
-      language TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_code_patterns_project ON code_patterns(project);
-    CREATE INDEX IF NOT EXISTS idx_code_patterns_type ON code_patterns(pattern_type);
-    CREATE INDEX IF NOT EXISTS idx_code_patterns_category ON code_patterns(category);
-
-    CREATE TABLE IF NOT EXISTS developer_profiles (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      project TEXT NOT NULL UNIQUE,
-      naming_style TEXT,
-      import_style TEXT,
-      export_style TEXT,
-      error_handling TEXT,
-      function_style TEXT,
-      async_style TEXT,
-      comment_style TEXT,
-      indent_style TEXT,
-      quote_style TEXT,
-      semicolon_style TEXT,
-      architecture_style TEXT,
-      test_pattern TEXT,
-      top_patterns TEXT,
-      strengths TEXT,
-      improvements TEXT,
-      files_scanned INTEGER DEFAULT 0,
-      total_lines INTEGER DEFAULT 0,
-      languages TEXT,
-      scanned_at TEXT DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_dev_profile_project ON developer_profiles(project);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS code_patterns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      pattern_type TEXT NOT NULL,
+      pattern_value TEXT NOT NULL,
+      category TEXT NOT NULL,
+      count INTEGER DEFAULT 1,
+      trust_score INTEGER DEFAULT 50,
+      language TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_code_patterns_project ON code_patterns(project);
+    CREATE INDEX IF NOT EXISTS idx_code_patterns_type ON code_patterns(pattern_type);
+    CREATE INDEX IF NOT EXISTS idx_code_patterns_category ON code_patterns(category);
+
+    CREATE TABLE IF NOT EXISTS developer_profiles (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project TEXT NOT NULL UNIQUE,
+      naming_style TEXT,
+      import_style TEXT,
+      export_style TEXT,
+      error_handling TEXT,
+      function_style TEXT,
+      async_style TEXT,
+      comment_style TEXT,
+      indent_style TEXT,
+      quote_style TEXT,
+      semicolon_style TEXT,
+      architecture_style TEXT,
+      test_pattern TEXT,
+      top_patterns TEXT,
+      strengths TEXT,
+      improvements TEXT,
+      files_scanned INTEGER DEFAULT 0,
+      total_lines INTEGER DEFAULT 0,
+      languages TEXT,
+      scanned_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_dev_profile_project ON developer_profiles(project);
   `);
 }
-function saveToDatabase(project, result) {
+function saveToDatabase(project, result, projectPath) {
     const db = (0, database_1.getDb)();
     ensureCodePatternTable();
+    try {
+        const { ProjectRegistry } = require('./core/project-registry');
+        const registry = new ProjectRegistry();
+        const stack = Object.keys(result.languages || {}).slice(0, 3).join('+') || 'unknown';
+        registry.registerProject({
+            name: project,
+            path: projectPath || project,
+            stack,
+            fileCount: result.filesScanned,
+        });
+    }
+    catch (e) {
+        console.warn('[cell] Project registration failed (non-fatal):', e instanceof Error ? e.message : String(e));
+    }
     db.prepare('DELETE FROM code_patterns WHERE project = ?').run(project);
-    const insertPattern = db.prepare('INSERT INTO code_patterns (project, file_path, pattern_type, pattern_value, category, count, confidence, language) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
+    const insertPattern = db.prepare('INSERT INTO code_patterns (project, file_path, pattern_type, pattern_value, category, count, trust_score, language) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
     const insertMany = db.transaction((patterns) => {
         for (const p of patterns) {
             insertPattern.run(project, 'scan', p.type, p.value, p.category, p.count, p.trustScore, '');
@@ -768,16 +986,23 @@ function saveToDatabase(project, result) {
     });
     insertMany(result.patterns);
     db.prepare('DELETE FROM developer_profiles WHERE project = ?').run(project);
-    db.prepare(`INSERT INTO developer_profiles 
-    (project, naming_style, import_style, export_style, error_handling, function_style, 
-     async_style, comment_style, indent_style, quote_style, semicolon_style, 
-     architecture_style, test_pattern, top_patterns, strengths, improvements,
-     files_scanned, total_lines, languages, scanned_at)
+    db.prepare(`INSERT INTO developer_profiles 
+    (project, naming_style, import_style, export_style, error_handling, function_style, 
+     async_style, comment_style, indent_style, quote_style, semicolon_style, 
+     architecture_style, test_pattern, top_patterns, strengths, improvements,
+     files_scanned, total_lines, languages, scanned_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
         .run(project, result.profile.namingStyle, result.profile.importStyle, result.profile.exportStyle, result.profile.errorHandling, result.profile.functionStyle, result.profile.asyncStyle, result.profile.commentStyle, result.profile.indentStyle, result.profile.quoteStyle, result.profile.semicolonStyle, result.profile.architectureStyle, result.profile.testPattern, JSON.stringify(result.profile.topPatterns), JSON.stringify(result.profile.strengths), JSON.stringify(result.profile.improvements), result.filesScanned, result.totalLines, JSON.stringify(result.languages));
-    db.prepare(`INSERT OR REPLACE INTO scans (project, scanned_at, file_count, line_count, stack, patterns, hubs, issues) 
-    VALUES (?, datetime('now'), ?, ?, ?, ?, ?, ?)`)
-        .run(project, result.filesScanned, result.totalLines, JSON.stringify(result.languages), JSON.stringify(result.patterns.slice(0, 20)), JSON.stringify({}), JSON.stringify(result.profile.improvements));
+    try {
+        const stmt = db.prepare(`INSERT OR REPLACE INTO scans (project, scanned_at, file_count, line_count, stack, patterns, hubs, issues)
+      VALUES (?, datetime('now'), ?, ?, ?, ?, ?, ?)`);
+        if (stmt) {
+            stmt.run(project, result.filesScanned, result.totalLines, JSON.stringify(result.languages), JSON.stringify(result.patterns.slice(0, 20)), JSON.stringify({}), JSON.stringify(result.profile.improvements));
+        }
+    }
+    catch (e) {
+        console.warn('[cell] scans table insert failed (schema mismatch, non-fatal):', e instanceof Error ? e.message : String(e));
+    }
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
 function scanCodebase(dirPath, projectName) {
@@ -807,11 +1032,71 @@ function scanCodebase(dirPath, projectName) {
         patterns,
         profile,
     };
-    saveToDatabase(project, result);
+    saveToDatabase(project, result, dirPath);
+    // ─── PHASE 3: Build Knowledge Graphs (file deps + pattern entities) ───
+    try {
+        const { saveFileKnowledgeGraph, saveTechProficiency } = require('./core/knowledge-graph-store');
+        const fileGraph = saveFileKnowledgeGraph(project, dirPath);
+        // Tech proficiency: use languages + architecture style
+        const archTech = profile.architectureStyle || 'unknown';
+        saveTechProficiency(project, {
+            technology: archTech,
+            category: 'architecture',
+            signalsCount: 1,
+            proficiencyScore: 70,
+            lastSeen: new Date().toISOString(),
+            trend: 'stable',
+        });
+        for (const [lang, count] of Object.entries(languages)) {
+            const score = Math.min(100, 40 + Math.log10(count + 1) * 20);
+            saveTechProficiency(project, {
+                technology: lang,
+                category: 'language',
+                signalsCount: count,
+                proficiencyScore: Math.round(score),
+                lastSeen: new Date().toISOString(),
+                trend: 'stable',
+            });
+        }
+        // Save pattern entities + relationships
+        if (result.patterns && result.patterns.length > 0) {
+            const { savePatternEntities, savePatternRelationships } = require('./core/knowledge-graph-store');
+            const entities = result.patterns.slice(0, 200).map((p, i) => ({
+                id: `${p.category || 'pattern'}-${i}`,
+                type: p.category || 'pattern',
+                label: p.value || '',
+                weight: p.trustScore || 1,
+            }));
+            savePatternEntities(project, entities);
+            // Co-occurrence: patterns in same category from same file are related
+            const filePatterns = new Map();
+            for (let i = 0; i < Math.min(200, result.patterns.length); i++) {
+                const p = result.patterns[i];
+                const f = p.file || 'global';
+                const key = `${f}`;
+                const arr = filePatterns.get(key) || [];
+                arr.push(`${p.category || 'pattern'}-${i}`);
+                filePatterns.set(key, arr);
+            }
+            const edges = [];
+            for (const arr of filePatterns.values()) {
+                for (let i = 0; i < arr.length; i++) {
+                    for (let j = i + 1; j < arr.length; j++) {
+                        edges.push({ from: arr[i], to: arr[j], type: 'co_occurs', weight: 1 });
+                    }
+                }
+            }
+            if (edges.length > 0)
+                savePatternRelationships(project, edges);
+        }
+    }
+    catch (e) {
+        console.warn('[cell] Knowledge graph build failed (non-fatal):', e instanceof Error ? e.message : String(e));
+    }
+    const hookResults = [];
     // ─── CONNECT: Scanner → Behavioral Tracker ───────────────────────────────
     try {
         const { logError, logDecision, logContext } = require('./behavioral-tracker');
-        // Log blind spots as errors
         if (profile.improvements.length > 0) {
             for (const imp of profile.improvements) {
                 logError({
@@ -823,7 +1108,6 @@ function scanCodebase(dirPath, projectName) {
                 });
             }
         }
-        // Log architecture decision
         logDecision({
             project,
             file: 'scan-auto',
@@ -831,33 +1115,106 @@ function scanCodebase(dirPath, projectName) {
             approach: `Scan detected ${files.length} files, ${result.languages ? Object.keys(result.languages).join(', ') : 'unknown'}`,
             worked: true,
         });
-        // Log current context
         logContext({
             project,
             task: `Codebase scan completed — ${files.length} files, ${totalLines.toLocaleString()} lines`,
             files: [dirPath],
         });
+        hookResults.push({ hook: 'behavioral-tracker', ok: true });
+    }
+    catch (e) {
+        hookResults.push({ hook: 'behavioral-tracker', ok: false, error: String(e) });
+        console.warn('[cell] Hook failed: behavioral-tracker:', e instanceof Error ? e.message : String(e));
     }
-    catch { /* behavioral tracker may not be initialized yet */ }
-    // ─── CONNECT: Git Intelligence (behavior + journey + user analysis) ──────
+    // ─── CONNECT: Git Intelligence ──────
     try {
         const { buildDeveloperIntelligence } = require('./developer-intelligence');
         const gitIntel = buildDeveloperIntelligence(dirPath);
         if (gitIntel) {
             console.log(`[cell] Git intelligence: ${gitIntel.topBlindSpots.length} blind spots, ${gitIntel.topMistakes.length} repeat mistakes, score: ${gitIntel.behavioralScore}/100`);
         }
+        hookResults.push({ hook: 'developer-intelligence', ok: true });
     }
-    catch { /* git intelligence may not be available */ }
-    // ─── CONNECT: Style Pull → Generate .cursorrules, CLAUDE.md, etc. ────
+    catch (e) {
+        hookResults.push({ hook: 'developer-intelligence', ok: false, error: String(e) });
+        console.warn('[cell] Hook failed: developer-intelligence:', e instanceof Error ? e.message : String(e));
+    }
+    // ─── CONNECT: Style Pull ────
     try {
         const { writeStyleFiles, buildStyleSummary } = require('./style-pull');
         const summary = buildStyleSummary(dirPath);
-        const result = writeStyleFiles(dirPath, summary, { force: false });
-        if (result.written.length > 0) {
-            console.log(`[cell] Generated: ${result.written.join(', ')}`);
+        const styleResult = writeStyleFiles(dirPath, summary, { force: false });
+        if (styleResult.written.length > 0) {
+            console.log(`[cell] Generated: ${styleResult.written.join(', ')}`);
+        }
+        hookResults.push({ hook: 'style-pull', ok: true });
+    }
+    catch (e) {
+        hookResults.push({ hook: 'style-pull', ok: false, error: String(e) });
+        console.warn('[cell] Hook failed: style-pull:', e instanceof Error ? e.message : String(e));
+    }
+    // ─── CONNECT: Stack Detector ──────────
+    try {
+        const dna = (0, stack_detector_1.detectProjectDNA)(dirPath);
+        const projectName = dna.name || project;
+        const db = (0, database_1.getDb)();
+        db.prepare('INSERT OR REPLACE INTO code_patterns (project, file_path, pattern_type, pattern_value, category, count, trust_score, language) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(projectName, 'stack-dna', 'project_dna', JSON.stringify(dna.stack), 'stack_detect', 1, dna.stack.trustScore, dna.stack.languages[0] || '');
+        db.prepare('INSERT OR REPLACE INTO code_patterns (project, file_path, pattern_type, pattern_value, category, count, trust_score, language) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(projectName, 'arch-dna', 'architecture', JSON.stringify(dna.architecture), 'architecture', 1, dna.architecture.confidence === 'high' ? 90 : 50, '');
+        console.log('[cell] Stack: ' + dna.stack.frontend + ' + ' + dna.stack.backend + ', DB: ' + dna.stack.database.join(', ') + ', ORM: ' + dna.stack.orm + ', Test: ' + dna.stack.testing.join(', '));
+        console.log('[cell] Arch: ' + dna.architecture.type + ' (' + dna.architecture.confidence + '), Entry: ' + dna.architecture.entryPoints.join(', '));
+        hookResults.push({ hook: 'stack-detector', ok: true });
+    }
+    catch (e) {
+        hookResults.push({ hook: 'stack-detector', ok: false, error: String(e) });
+        console.warn('[cell] Hook failed: stack-detector:', e instanceof Error ? e.message : String(e));
+    }
+    // ─── CONNECT: Knowledge Graph ────────────────────────────────────
+    try {
+        const { buildKnowledgeGraph } = require('./knowledge-graph-builder');
+        const graph = buildKnowledgeGraph(dirPath);
+        console.log(`[cell] Graph: ${graph.nodes.length} nodes, ${graph.mostCoupled.length} most-coupled, Entry: ${graph.entryPoints.join(', ')}`);
+        hookResults.push({ hook: 'knowledge-graph', ok: true });
+    }
+    catch (e) {
+        hookResults.push({ hook: 'knowledge-graph', ok: false, error: String(e) });
+        console.warn('[cell] Hook failed: knowledge-graph:', e instanceof Error ? e.message : String(e));
+    }
+    // ─── CONNECT: Blind Spot Engine ──────────────────────────────
+    try {
+        const { BlindSpotEngine } = require('./core/blind-spot-engine');
+        const engine = new BlindSpotEngine(path.join(os.homedir(), '.fivo', 'cell'));
+        let totalBlindSpots = 0;
+        let totalHit = 0;
+        let totalMissed = 0;
+        let analyzed = 0;
+        for (const analysis of analyses) {
+            try {
+                if (!analysis.filePath || typeof analysis.filePath !== 'string')
+                    continue;
+                const content = fs.readFileSync(analysis.filePath, 'utf-8');
+                const spots = engine.analyze(content, analysis.language);
+                analyzed++;
+                totalBlindSpots += spots.length;
+                for (const s of spots) {
+                    totalHit += Math.round(s.hitRate);
+                    totalMissed += Math.round(s.missedRate);
+                }
+            }
+            catch { }
         }
+        console.log(`[cell] Blind spots: ${totalBlindSpots} categories, ${totalMissed} missed checks, ${totalHit} hits across ${analyzed}/${analyses.length} files`);
+        result.blindSpotStats = { totalBlindSpots, totalHit, totalMissed, files: analyzed };
+        hookResults.push({ hook: 'blind-spot-engine', ok: true });
+    }
+    catch (e) {
+        hookResults.push({ hook: 'blind-spot-engine', ok: false, error: String(e) });
+        console.warn('[cell] Hook failed: blind-spot-engine:', e instanceof Error ? e.message : String(e));
+    }
+    const failed = hookResults.filter(h => !h.ok);
+    if (failed.length > 0) {
+        console.warn(`[cell] Scan completed with ${failed.length} hook failures: ${failed.map(f => f.hook).join(', ')}`);
     }
-    catch { /* style-pull may not be available */ }
+    result.hookResults = hookResults;
     return result;
 }
 function getDeveloperProfile(project) {