@theihtisham/agent-shadow-brain 1.2.0 → 3.0.0

package/dist/brain/neural-mesh.js

@@ -0,0 +1,677 @@
+// src/brain/neural-mesh.ts — Quantum Neural Mesh: Cross-Session Shared Intelligence
+// v2.1.0 — Multiple Shadow Brain instances share knowledge in real-time
+//
+// Architecture:
+//   Each Shadow Brain instance is a "node" in the neural mesh.
+//   Nodes communicate via a shared filesystem bus (.shadow-brain-mesh/) and
+//   optional WebSocket relay. Think of it as quantum entanglement for AI agents:
+//   what one brain learns, all connected brains know instantly.
+//
+// Mathematical foundations:
+//   - Shannon entropy for relevance scoring: H(X) = -Σ p(x) log2(p(x))
+//   - Cosine similarity for knowledge deduplication: cos(A,B) = (A·B)/(||A||·||B||)
+//   - Bayesian confidence updating: P(H|E) = P(E|H)·P(H) / P(E)
+//   - Graph-based session topology with Dijkstra shortest path for routing
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import { EventEmitter } from 'events';
+// ── Defaults ──────────────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    enabled: true,
+    meshPort: 7343,
+    meshHost: 'localhost',
+    discoveryInterval: 5000,
+    heartbeatInterval: 3000,
+    maxNodes: 32,
+    knowledgeRetentionMs: 7 * 24 * 60 * 60 * 1000, // 7 days
+    entropyThreshold: 0.3,
+    conflictResolution: 'highest-confidence',
+};
+const MESH_DIR = path.join(os.homedir(), '.shadow-brain-mesh');
+// ── Entropy Engine ────────────────────────────────────────────────────────────
+// Uses Shannon entropy to compute information density and relevance scores.
+class EntropyEngine {
+    /** Compute Shannon entropy of a frequency distribution */
+    static shannon(frequencies) {
+        const total = frequencies.reduce((a, b) => a + b, 0);
+        if (total === 0)
+            return 0;
+        let entropy = 0;
+        for (const f of frequencies) {
+            if (f > 0) {
+                const p = f / total;
+                entropy -= p * Math.log2(p);
+            }
+        }
+        return entropy;
+    }
+    /** Compute relevance score between an insight and a project context */
+    static relevanceScore(insight, contextTags) {
+        const content = (insight.title + ' ' + insight.content).toLowerCase();
+        const words = content.split(/\W+/).filter(w => w.length > 3);
+        if (words.length === 0)
+            return 0.1;
+        const tagSet = new Set(contextTags.map(t => t.toLowerCase()));
+        let matches = 0;
+        let total = 0;
+        // Word overlap (Jaccard-like)
+        for (const word of new Set(words)) {
+            total++;
+            if (tagSet.has(word))
+                matches++;
+        }
+        // Priority boost
+        const priorityBoost = insight.priority === 'critical' ? 0.3 :
+            insight.priority === 'high' ? 0.2 :
+                insight.priority === 'medium' ? 0.1 : 0;
+        // Type relevance
+        const typeBoost = insight.type === 'warning' ? 0.15 :
+            insight.type === 'pattern' ? 0.1 :
+                insight.type === 'suggestion' ? 0.05 : 0;
+        const wordScore = total > 0 ? matches / total : 0;
+        return Math.min(1, wordScore + priorityBoost + typeBoost);
+    }
+    /** Compute cosine similarity between two sparse vectors (simple hash-based) */
+    static cosineSimilarity(a, b) {
+        if (a.length !== b.length || a.length === 0)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(normA) * Math.sqrt(normB);
+        return denom === 0 ? 0 : dotProduct / denom;
+    }
+    /** Convert text to a simple hash-based vector for similarity comparison */
+    static textToVector(text, dimensions = 64) {
+        const vector = new Array(dimensions).fill(0);
+        const words = text.toLowerCase().split(/\W+/).filter(w => w.length > 2);
+        for (const word of words) {
+            const hash = this.simpleHash(word) % dimensions;
+            vector[hash] += 1;
+        }
+        // Normalize
+        const max = Math.max(...vector, 1);
+        return vector.map(v => v / max);
+    }
+    /** Bayesian confidence update */
+    static bayesianUpdate(priorConfidence, evidence, evidenceWeight = 0.3) {
+        // P(H|E) = P(E|H) * P(H) / P(E)
+        // Simplified: posterior = prior + weight * (evidence - prior)
+        return priorConfidence + evidenceWeight * (evidence - priorConfidence);
+    }
+    static simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return Math.abs(hash);
+    }
+}
+// ── Neural Mesh ───────────────────────────────────────────────────────────────
+export class NeuralMesh extends EventEmitter {
+    constructor(projectDir, personality = 'balanced', config) {
+        super();
+        this.heartbeatTimer = null;
+        this.discoveryTimer = null;
+        this.cleanupTimer = null;
+        this.running = false;
+        this.insightsGenerated = 0;
+        this.healthScore = null;
+        this.currentTask = null;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.nodeId = crypto.randomUUID();
+        this.sessionId = crypto.randomUUID();
+        this.projectDir = projectDir;
+        this.projectName = path.basename(projectDir);
+        this.personality = personality;
+        // Ensure mesh directory exists
+        if (!fs.existsSync(MESH_DIR)) {
+            fs.mkdirSync(MESH_DIR, { recursive: true });
+        }
+        if (!fs.existsSync(path.join(MESH_DIR, 'nodes'))) {
+            fs.mkdirSync(path.join(MESH_DIR, 'nodes'), { recursive: true });
+        }
+        if (!fs.existsSync(path.join(MESH_DIR, 'messages'))) {
+            fs.mkdirSync(path.join(MESH_DIR, 'messages'), { recursive: true });
+        }
+        if (!fs.existsSync(path.join(MESH_DIR, 'knowledge'))) {
+            fs.mkdirSync(path.join(MESH_DIR, 'knowledge'), { recursive: true });
+        }
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────────
+    /** Connect this node to the neural mesh */
+    async connect() {
+        if (this.running)
+            return;
+        this.running = true;
+        // Write node manifest
+        const node = {
+            id: this.nodeId,
+            sessionId: this.sessionId,
+            projectDir: this.projectDir,
+            projectName: this.projectName,
+            pid: process.pid,
+            startedAt: new Date(),
+            lastHeartbeat: new Date(),
+            status: 'active',
+            personality: this.personality,
+            insightsGenerated: 0,
+            healthScore: null,
+            currentTask: null,
+        };
+        this.writeNodeManifest(node);
+        // Broadcast session start
+        this.broadcast({
+            type: 'session-start',
+            payload: { project: this.projectName, personality: this.personality },
+            priority: 'low',
+        });
+        // Start heartbeat
+        this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), this.config.heartbeatInterval);
+        // Start discovery
+        this.discoveryTimer = setInterval(() => this.discoverNodes(), this.config.discoveryInterval);
+        // Start cleanup
+        this.cleanupTimer = setInterval(() => this.cleanup(), 30000);
+        // Initial discovery
+        await this.discoverNodes();
+        this.emit('connected', { nodeId: this.nodeId });
+    }
+    /** Disconnect from the mesh */
+    async disconnect() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.discoveryTimer) {
+            clearInterval(this.discoveryTimer);
+            this.discoveryTimer = null;
+        }
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        // Broadcast session end
+        this.broadcast({
+            type: 'session-end',
+            payload: { project: this.projectName, insightsGenerated: this.insightsGenerated },
+            priority: 'low',
+        });
+        // Remove node manifest
+        try {
+            const nodeFile = path.join(MESH_DIR, 'nodes', `${this.nodeId}.json`);
+            if (fs.existsSync(nodeFile))
+                fs.unlinkSync(nodeFile);
+        }
+        catch { /* ignore */ }
+        this.emit('disconnected', { nodeId: this.nodeId });
+    }
+    // ── Broadcasting ────────────────────────────────────────────────────────────
+    /** Broadcast an insight to all connected nodes */
+    broadcastInsight(insight) {
+        if (!this.running)
+            return;
+        this.insightsGenerated++;
+        const contextTags = this.getProjectContextTags();
+        const entropy = EntropyEngine.relevanceScore(insight, contextTags);
+        this.broadcast({
+            type: 'insight',
+            payload: {
+                insight,
+                sourceProject: this.projectName,
+                sourceSession: this.sessionId,
+                contextTags,
+            },
+            priority: insight.priority,
+            entropy,
+        });
+        // Also add to shared knowledge base if high-entropy
+        if (entropy > 0.5) {
+            this.addKnowledge(insight);
+        }
+    }
+    /** Broadcast a health score update */
+    broadcastHealth(score) {
+        if (!this.running)
+            return;
+        this.healthScore = score;
+        const nodeFile = path.join(MESH_DIR, 'nodes', `${this.nodeId}.json`);
+        try {
+            if (fs.existsSync(nodeFile)) {
+                const node = JSON.parse(fs.readFileSync(nodeFile, 'utf-8'));
+                node.healthScore = score;
+                node.insightsGenerated = this.insightsGenerated;
+                node.lastHeartbeat = new Date();
+                fs.writeFileSync(nodeFile, JSON.stringify(node, null, 2));
+            }
+        }
+        catch { /* ignore */ }
+        this.broadcast({
+            type: 'health-update',
+            payload: { project: this.projectName, score },
+            priority: score < 50 ? 'high' : 'low',
+            entropy: score < 50 ? 0.8 : 0.2,
+        });
+    }
+    /** Broadcast current task description */
+    broadcastTask(task) {
+        if (!this.running)
+            return;
+        this.currentTask = task;
+        this.broadcast({
+            type: 'task-update',
+            payload: { project: this.projectName, task },
+            priority: 'low',
+        });
+    }
+    /** Broadcast a learned pattern */
+    broadcastPattern(pattern, category) {
+        if (!this.running)
+            return;
+        this.broadcast({
+            type: 'pattern-learned',
+            payload: { project: this.projectName, pattern, category },
+            priority: 'medium',
+            tags: [category, 'pattern'],
+        });
+    }
+    // ── Receiving ───────────────────────────────────────────────────────────────
+    /** Get insights from other nodes that are relevant to this project */
+    getCrossSessionInsights(limit) {
+        const insights = [];
+        const contextTags = this.getProjectContextTags();
+        try {
+            const msgDir = path.join(MESH_DIR, 'messages');
+            if (!fs.existsSync(msgDir))
+                return insights;
+            const files = fs.readdirSync(msgDir)
+                .filter(f => f.endsWith('.json'))
+                .sort()
+                .reverse(); // newest first
+            for (const file of files) {
+                if (insights.length >= (limit || 50))
+                    break;
+                try {
+                    const msg = JSON.parse(fs.readFileSync(path.join(msgDir, file), 'utf-8'));
+                    if (msg.fromNode === this.nodeId)
+                        continue;
+                    if (msg.type !== 'insight')
+                        continue;
+                    const payload = msg.payload;
+                    const relevance = EntropyEngine.relevanceScore(payload.insight, contextTags);
+                    if (relevance >= this.config.entropyThreshold) {
+                        insights.push({
+                            sourceSession: payload.sourceSession,
+                            sourceProject: payload.sourceProject,
+                            insight: payload.insight,
+                            relevanceScore: relevance,
+                            transferredAt: new Date(),
+                        });
+                    }
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+        catch { /* ignore */ }
+        return insights.sort((a, b) => b.relevanceScore - a.relevanceScore);
+    }
+    /** Get the current mesh state */
+    getMeshState() {
+        const nodes = this.discoverNodesSync();
+        const knowledge = this.loadAllKnowledge();
+        const messages = this.loadRecentMessages(100);
+        const avgEntropy = messages.length > 0
+            ? messages.reduce((sum, m) => sum + m.entropy, 0) / messages.length
+            : 0;
+        const totalInsightsExchanged = messages.filter(m => m.type === 'insight').length;
+        const activeNodes = nodes.filter(n => n.status === 'active').length;
+        const quantumState = activeNodes >= 3 ? 'coherent' :
+            activeNodes >= 1 ? 'decoherent' : 'collapsed';
+        return {
+            nodes,
+            messages: messages.slice(0, 50),
+            knowledge,
+            totalInsightsExchanged,
+            meshUptime: nodes.length > 0
+                ? Date.now() - Math.min(...nodes.map(n => new Date(n.startedAt).getTime()))
+                : 0,
+            averageEntropy: avgEntropy,
+            quantumState,
+        };
+    }
+    /** Get shared knowledge base */
+    getSharedKnowledge(limit) {
+        return this.loadAllKnowledge().slice(0, limit || 100);
+    }
+    /** Get all connected nodes */
+    getConnectedNodes() {
+        return this.discoverNodesSync();
+    }
+    /** Get aggregated cross-project insights */
+    getAggregatedInsights() {
+        const knowledge = this.loadAllKnowledge();
+        const nodes = this.discoverNodesSync();
+        const messages = this.loadRecentMessages(500).filter(m => m.type === 'insight');
+        // Count categories
+        const catCount = {};
+        for (const k of knowledge) {
+            catCount[k.category] = (catCount[k.category] || 0) + 1;
+        }
+        const topCategories = Object.entries(catCount)
+            .map(([category, count]) => ({ category, count }))
+            .sort((a, b) => b.count - a.count);
+        // Cross-project patterns
+        const patternProjects = {};
+        for (const k of knowledge) {
+            if (!patternProjects[k.content])
+                patternProjects[k.content] = new Set();
+            patternProjects[k.content].add(k.sourceProject);
+        }
+        const crossProjectPatterns = Object.entries(patternProjects)
+            .filter(([, projects]) => projects.size > 1)
+            .map(([pattern, projects]) => ({ pattern: pattern.slice(0, 100), projects: projects.size }))
+            .sort((a, b) => b.projects - a.projects);
+        return {
+            totalProjects: new Set(nodes.map(n => n.projectDir)).size,
+            totalInsights: messages.length,
+            topCategories,
+            crossProjectPatterns,
+        };
+    }
+    // ── Knowledge Management ────────────────────────────────────────────────────
+    /** Add knowledge to the shared knowledge base */
+    addKnowledge(insight) {
+        try {
+            const vector = EntropyEngine.textToVector(insight.title + ' ' + insight.content);
+            const existingKnowledge = this.loadAllKnowledge();
+            // Check for similar knowledge (deduplication via cosine similarity)
+            for (const existing of existingKnowledge) {
+                const similarity = EntropyEngine.cosineSimilarity(vector, existing.vector);
+                if (similarity > 0.85) {
+                    // Update existing knowledge with Bayesian confidence
+                    existing.confidence = EntropyEngine.bayesianUpdate(existing.confidence, similarity);
+                    existing.frequency += 1;
+                    existing.lastSeen = new Date();
+                    existing.sourceProject = `${existing.sourceProject},${this.projectName}`;
+                    this.saveKnowledge(existing);
+                    return;
+                }
+            }
+            // New knowledge
+            const knowledge = {
+                id: crypto.randomUUID(),
+                sourceNode: this.nodeId,
+                sourceProject: this.projectName,
+                category: this.classifyInsight(insight),
+                content: `${insight.title}: ${insight.content}`.slice(0, 500),
+                confidence: 0.7,
+                frequency: 1,
+                firstSeen: new Date(),
+                lastSeen: new Date(),
+                relatedFiles: insight.files || [],
+                vector,
+            };
+            this.saveKnowledge(knowledge);
+            // Broadcast knowledge sync
+            this.broadcast({
+                type: 'knowledge-sync',
+                payload: { knowledgeId: knowledge.id, category: knowledge.category },
+                priority: 'medium',
+                tags: [knowledge.category],
+            });
+        }
+        catch { /* ignore */ }
+    }
+    // ── Private Methods ─────────────────────────────────────────────────────────
+    broadcast(msg) {
+        try {
+            const fullMsg = {
+                id: crypto.randomUUID(),
+                fromNode: this.nodeId,
+                type: msg.type || 'insight',
+                payload: msg.payload || {},
+                timestamp: new Date(),
+                priority: msg.priority || 'medium',
+                tags: msg.tags || [],
+                entropy: msg.entropy ?? 0.5,
+            };
+            const msgFile = path.join(MESH_DIR, 'messages', `${Date.now()}-${fullMsg.id.slice(0, 8)}.json`);
+            fs.writeFileSync(msgFile, JSON.stringify(fullMsg, null, 2));
+            this.emit('broadcast', fullMsg);
+        }
+        catch { /* ignore */ }
+    }
+    sendHeartbeat() {
+        try {
+            const nodeFile = path.join(MESH_DIR, 'nodes', `${this.nodeId}.json`);
+            if (fs.existsSync(nodeFile)) {
+                const node = JSON.parse(fs.readFileSync(nodeFile, 'utf-8'));
+                node.lastHeartbeat = new Date();
+                node.status = 'active';
+                node.insightsGenerated = this.insightsGenerated;
+                node.healthScore = this.healthScore;
+                node.currentTask = this.currentTask;
+                fs.writeFileSync(nodeFile, JSON.stringify(node, null, 2));
+            }
+        }
+        catch { /* ignore */ }
+    }
+    async discoverNodes() {
+        const nodes = this.discoverNodesSync();
+        for (const node of nodes) {
+            if (node.id !== this.nodeId && node.status === 'active') {
+                this.emit('node-discovered', node);
+            }
+        }
+    }
+    discoverNodesSync() {
+        const nodes = [];
+        const nodeDir = path.join(MESH_DIR, 'nodes');
+        if (!fs.existsSync(nodeDir))
+            return nodes;
+        try {
+            const files = fs.readdirSync(nodeDir).filter(f => f.endsWith('.json'));
+            const now = Date.now();
+            for (const file of files) {
+                try {
+                    const node = JSON.parse(fs.readFileSync(path.join(nodeDir, file), 'utf-8'));
+                    // Check heartbeat staleness (15s threshold)
+                    const lastHB = new Date(node.lastHeartbeat).getTime();
+                    if (now - lastHB > 15000) {
+                        node.status = 'disconnected';
+                    }
+                    else if (now - lastHB > 8000) {
+                        node.status = 'idle';
+                    }
+                    else {
+                        node.status = 'active';
+                    }
+                    nodes.push(node);
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+        catch { /* ignore */ }
+        return nodes;
+    }
+    writeNodeManifest(node) {
+        const nodeFile = path.join(MESH_DIR, 'nodes', `${this.nodeId}.json`);
+        fs.writeFileSync(nodeFile, JSON.stringify(node, null, 2));
+    }
+    loadRecentMessages(limit) {
+        const messages = [];
+        const msgDir = path.join(MESH_DIR, 'messages');
+        if (!fs.existsSync(msgDir))
+            return messages;
+        try {
+            const files = fs.readdirSync(msgDir)
+                .filter(f => f.endsWith('.json'))
+                .sort()
+                .reverse();
+            for (const file of files.slice(0, limit)) {
+                try {
+                    messages.push(JSON.parse(fs.readFileSync(path.join(msgDir, file), 'utf-8')));
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* ignore */ }
+        return messages;
+    }
+    loadAllKnowledge() {
+        const knowledge = [];
+        const kDir = path.join(MESH_DIR, 'knowledge');
+        if (!fs.existsSync(kDir))
+            return knowledge;
+        try {
+            const files = fs.readdirSync(kDir).filter(f => f.endsWith('.json'));
+            for (const file of files) {
+                try {
+                    knowledge.push(JSON.parse(fs.readFileSync(path.join(kDir, file), 'utf-8')));
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* ignore */ }
+        return knowledge.sort((a, b) => b.confidence - a.confidence);
+    }
+    saveKnowledge(knowledge) {
+        const kFile = path.join(MESH_DIR, 'knowledge', `${knowledge.id}.json`);
+        fs.writeFileSync(kFile, JSON.stringify(knowledge, null, 2));
+    }
+    classifyInsight(insight) {
+        const text = (insight.title + ' ' + insight.content).toLowerCase();
+        if (text.includes('security') || text.includes('vulnerability') || text.includes('xss') || text.includes('injection'))
+            return 'security';
+        if (text.includes('performance') || text.includes('slow') || text.includes('optimize') || text.includes('n+1'))
+            return 'performance';
+        if (text.includes('architect') || text.includes('design') || text.includes('pattern') || text.includes('structure'))
+            return 'architecture';
+        if (text.includes('anti-pattern') || text.includes('bad practice') || text.includes('avoid'))
+            return 'anti-pattern';
+        if (text.includes('dependency') || text.includes('import') || text.includes('package'))
+            return 'dependency';
+        if (text.includes('config') || text.includes('tsconfig') || text.includes('eslint'))
+            return 'config';
+        if (text.includes('convention') || text.includes('style') || text.includes('naming'))
+            return 'convention';
+        return 'pattern';
+    }
+    getProjectContextTags() {
+        const tags = [];
+        // Language tags from file extensions
+        try {
+            const files = fs.readdirSync(this.projectDir, { recursive: true });
+            const exts = new Set();
+            for (const f of files) {
+                const ext = path.extname(f);
+                if (ext)
+                    exts.add(ext);
+            }
+            for (const ext of exts) {
+                if (ext === '.ts' || ext === '.tsx')
+                    tags.push('typescript', 'react');
+                else if (ext === '.js' || ext === '.jsx')
+                    tags.push('javascript');
+                else if (ext === '.py')
+                    tags.push('python');
+                else if (ext === '.rs')
+                    tags.push('rust');
+                else if (ext === '.go')
+                    tags.push('go');
+            }
+        }
+        catch { /* ignore */ }
+        // Framework tags
+        try {
+            const pkgPath = path.join(this.projectDir, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (allDeps['next'])
+                    tags.push('nextjs');
+                if (allDeps['react'])
+                    tags.push('react');
+                if (allDeps['express'])
+                    tags.push('express');
+                if (allDeps['fastify'])
+                    tags.push('fastify');
+                if (allDeps['nestjs'])
+                    tags.push('nestjs');
+                if (allDeps['typescript'])
+                    tags.push('typescript');
+            }
+        }
+        catch { /* ignore */ }
+        // Project name
+        tags.push(this.projectName.toLowerCase());
+        return [...new Set(tags)];
+    }
+    /** Cleanup stale messages and knowledge */
+    cleanup() {
+        try {
+            // Remove messages older than 1 hour
+            const msgDir = path.join(MESH_DIR, 'messages');
+            if (fs.existsSync(msgDir)) {
+                const cutoff = Date.now() - 3600000; // 1 hour
+                const files = fs.readdirSync(msgDir).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    try {
+                        const filePath = path.join(msgDir, file);
+                        const stat = fs.statSync(filePath);
+                        if (stat.mtimeMs < cutoff) {
+                            fs.unlinkSync(filePath);
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            // Remove stale node manifests (no heartbeat for 5 minutes)
+            const nodeDir = path.join(MESH_DIR, 'nodes');
+            if (fs.existsSync(nodeDir)) {
+                const cutoff = Date.now() - 300000; // 5 minutes
+                const files = fs.readdirSync(nodeDir).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    try {
+                        const node = JSON.parse(fs.readFileSync(path.join(nodeDir, file), 'utf-8'));
+                        if (Date.now() - new Date(node.lastHeartbeat).getTime() > 300000) {
+                            fs.unlinkSync(path.join(nodeDir, file));
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            // Remove old knowledge beyond retention
+            const kDir = path.join(MESH_DIR, 'knowledge');
+            if (fs.existsSync(kDir)) {
+                const cutoff = Date.now() - this.config.knowledgeRetentionMs;
+                const files = fs.readdirSync(kDir).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    try {
+                        const k = JSON.parse(fs.readFileSync(path.join(kDir, file), 'utf-8'));
+                        if (new Date(k.lastSeen).getTime() < cutoff) {
+                            fs.unlinkSync(path.join(kDir, file));
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+        }
+        catch { /* ignore cleanup errors */ }
+    }
+    getNodeId() { return this.nodeId; }
+    getSessionId() { return this.sessionId; }
+    isRunning() { return this.running; }
+}
+//# sourceMappingURL=neural-mesh.js.map