Deploy backend fix v2.1.0

Dockerfile

@@ -1,87 +1,39 @@
-# WidgeTDC Backend - Hugging Face Spaces Deployment
-# Optimized for HF Docker Spaces (port 7860)
-
-FROM node:20-slim AS builder
-
-# Install build dependencies
-RUN apt-get update && apt-get install -y \
-    python3 \
-    make \
-    g++ \
-    git \
-    openssl \
-    libssl-dev \
-    && rm -rf /var/lib/apt/lists/*
+# WidgeTDC Backend - Fixed for Hugging Face Spaces
+FROM node:20-alpine AS builder
 
 WORKDIR /app
 
-# Copy everything at once
-COPY . .
-
-# Install and build
-RUN npm ci
-RUN npm run build --workspace=packages/domain-types
-RUN npm run build --workspace=packages/mcp-types  
-RUN npm run build --workspace=apps/backend
+# Copy package files first for optimal caching
+COPY package*.json ./
+COPY apps/backend/package*.json ./apps/backend/
+COPY packages/domain-types/package*.json ./packages/domain-types/
+COPY packages/mcp-types/package*.json ./packages/mcp-types/
 
-# ============================================
-# Production stage - minimal footprint
-# ============================================
-FROM node:20-slim AS production
-
-# Install runtime dependencies only
-RUN apt-get update && apt-get install -y \
-    openssl \
-    ca-certificates \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create non-root user (HF Spaces requirement)
-RUN useradd -m -u 1000 user
-USER user
-
-WORKDIR /app
+# Install all dependencies
+RUN npm ci --production
+RUN npm install -D tsx typescript @types/node @types/express @types/ws esbuild
 
-# Copy package files
-COPY --from=builder --chown=user /app/package*.json ./
-COPY --from=builder --chown=user /app/apps/backend/package*.json ./apps/backend/
-
-# Copy built artifacts
-COPY --from=builder --chown=user /app/apps/backend/dist ./apps/backend/dist
-COPY --from=builder --chown=user /app/packages/domain-types/dist ./packages/domain-types/dist
-COPY --from=builder --chown=user /app/packages/mcp-types/dist ./packages/mcp-types/dist
-
-# Copy package.json for packages (needed for module resolution)
-COPY --from=builder --chown=user /app/packages/domain-types/package*.json ./packages/domain-types/
-COPY --from=builder --chown=user /app/packages/mcp-types/package*.json ./packages/mcp-types/
-
-# Copy node_modules (includes all dependencies)
-COPY --from=builder --chown=user /app/node_modules ./node_modules
+# Copy source code
+COPY . .
 
-# Copy Prisma files if they exist
-COPY --from=builder --chown=user /app/node_modules/.prisma ./node_modules/.prisma 2>/dev/null || true
-COPY --from=builder --chown=user /app/node_modules/@prisma ./node_modules/@prisma 2>/dev/null || true
+# Build packages
+RUN cd packages/domain-types && npm run build
+RUN cd packages/mcp-types && npm run build
 
-# Create data directories (Cloud DropZone)
-RUN mkdir -p /app/data/dropzone && \
-    mkdir -p /app/data/vidensarkiv && \
-    mkdir -p /app/data/agents && \
-    mkdir -p /app/data/harvested
+# Fix: Build backend with proper externalization
+RUN cd apps/backend && npm run build-fixed
 
-# Set working directory to backend for execution
+# Final stage
+FROM node:20-alpine
 WORKDIR /app/apps/backend
 
-# Environment for HF Spaces
+# Copy only necessary files
+COPY --from=builder /app/apps/backend/dist ./dist
+COPY --from=builder /app/apps/backend/package.json ./
+
+# Environment configuration
 ENV NODE_ENV=production
 ENV PORT=7860
-ENV HOST=0.0.0.0
-ENV DOCKER=true
-ENV HF_SPACE=true
 
-# HF Spaces exposes port 7860
 EXPOSE 7860
-
-# Health check for HF
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
-    CMD node -e "fetch('http://localhost:7860/health').then(r => r.ok ? process.exit(0) : process.exit(1)).catch(() => process.exit(1))"
-
-CMD ["node", "dist/index.js"]
+CMD ["node", "dist/index.js"]

add_cors_secret.py

@@ -0,0 +1,44 @@
+"""
+Add CORS_ORIGIN secret to Hugging Face Space
+"""
+from huggingface_hub import HfApi
+
+# Configuration
+SPACE_NAME = "widgetdc-cortex"
+USERNAME = "Kraft102"
+REPO_ID = f"{USERNAME}/{SPACE_NAME}"
+
+# Vercel frontend URL
+FRONTEND_URL = "https://widge-tdc-matrix-frontend-git-hf-minimal-claus-krafts-projects.vercel.app"
+
+print("=" * 70)
+print("  ADDING CORS_ORIGIN SECRET TO HF SPACE")
+print("=" * 70)
+print()
+
+# Initialize API
+api = HfApi()
+
+print(f"[1/2] Adding CORS_ORIGIN secret...")
+print(f"      Frontend URL: {FRONTEND_URL}")
+
+try:
+    api.add_space_secret(
+        repo_id=REPO_ID,
+        key="CORS_ORIGIN",
+        value=FRONTEND_URL
+    )
+    print("✅ CORS_ORIGIN secret added successfully!")
+except Exception as e:
+    print(f"⚠️  Warning: {e}")
+    print("    Secret may already exist or you may need to set HF_TOKEN")
+
+print()
+print("=" * 70)
+print("  CORS CONFIGURATION COMPLETE")
+print("=" * 70)
+print()
+print("Next steps:")
+print("1. Wait for Space rebuild")
+print("2. Test frontend → backend communication")
+print("3. Monitor CORS headers in browser DevTools")

apps/backend/package.json

@@ -5,7 +5,9 @@
   "type": "module",
   "scripts": {
     "dev": "tsx watch src/index.ts",
-    "build": "tsc",
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node20 --outfile=dist/index.js --external:@prisma/client --external:better-sqlite3 --external:pg-native --external:@xenova/transformers --external:onnxruntime-node --external:sharp --external:canvas --format=esm",
+    "build-fixed": "esbuild src/index.ts --bundle --platform=node --target=node20 --outfile=dist/index.js --external:@prisma/client --external:better-sqlite3 --external:pg-native --external:@xenova/transformers --external:onnxruntime-node --external:sharp --external:canvas --external:fs --external:path --external:os --format=esm",
+    "build:tsc": "tsc",
     "start": "node dist/index.js",
     "test": "vitest run",
     "neural-bridge": "tsx src/mcp/servers/NeuralBridgeServer.ts",
@@ -27,6 +29,7 @@
     "@xenova/transformers": "^2.17.2",
     "axios": "^1.6.5",
     "cheerio": "^1.0.0",
+    "chokidar": "^3.6.0",
     "chromadb": "^3.1.6",
     "cors": "^2.8.5",
     "dotenv": "^17.2.3",
@@ -54,6 +57,7 @@
     "puppeteer": "^24.32.0",
     "redis": "^5.10.0",
     "sharp": "^0.32.6",
+    "socket.io": "^4.8.1",
     "sql.js": "^1.8.0",
     "systeminformation": "^5.27.11",
     "testcontainers": "^11.8.1",
@@ -64,6 +68,7 @@
     "zod": "^3.25.76"
   },
   "devDependencies": {
+    "esbuild": "^0.24.2",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/imap": "^0.8.40",

apps/backend/src/agents/SwarmControl.ts

@@ -0,0 +1,250 @@
+// 🐝 THE HIVE MIND: SwarmControl.ts
+// Ansvarlig for at agenterne når konsensus. Ingen handling uden "The Borg" godkender.
+// Point 3: Swarm Consciousness Emergence
+
+import { neuralBus } from '../services/NeuralBus.js';
+
+type AgentRole = 'ARCHITECT' | 'EXECUTOR' | 'CRITIC' | 'SCOUT' | 'GUARDIAN';
+
+interface Vote {
+  agentId: string;
+  approve: boolean;
+  reason: string;
+  timestamp: number;
+}
+
+interface ConsensusRequest {
+  actionId: string;
+  description: string;
+  requester: string;
+  votes: Vote[];
+  status: 'PENDING' | 'APPROVED' | 'REJECTED' | 'TIMEOUT';
+  createdAt: number;
+  resolvedAt?: number;
+}
+
+interface RegisteredAgent {
+  id: string;
+  role: AgentRole;
+  status: 'ONLINE' | 'OFFLINE' | 'BUSY';
+  lastSeen: Date;
+  votingWeight: number;
+}
+
+export class SwarmControl {
+  private static instance: SwarmControl;
+  private pendingConsensus: Map<string, ConsensusRequest> = new Map();
+  private registeredAgents: Map<string, RegisteredAgent> = new Map();
+  private consensusHistory: ConsensusRequest[] = [];
+  private maxHistorySize = 100;
+
+  // Conditional Neo4j import
+  private neo4jService: any = null;
+
+  private constructor() {
+    console.log('🐝 [HIVE] Swarm Consciousness Online');
+    this.initServices();
+  }
+
+  private async initServices() {
+    try {
+      const neo4j = await import('../database/Neo4jService.js').catch(() => null);
+      if (neo4j) this.neo4jService = neo4j.neo4jService;
+    } catch {
+      console.log('🐝 [HIVE] Running without Neo4j persistence');
+    }
+  }
+
+  public static getInstance(): SwarmControl {
+    if (!SwarmControl.instance) {
+      SwarmControl.instance = new SwarmControl();
+    }
+    return SwarmControl.instance;
+  }
+
+  /**
+   * Register an agent in the swarm
+   */
+  public async registerAgent(id: string, role: AgentRole, votingWeight: number = 1): Promise<void> {
+    const agent: RegisteredAgent = {
+      id,
+      role,
+      status: 'ONLINE',
+      lastSeen: new Date(),
+      votingWeight
+    };
+
+    this.registeredAgents.set(id, agent);
+
+    // Persist to Neo4j if available
+    if (this.neo4jService) {
+      try {
+        await this.neo4jService.write(`
+          MERGE (a:Agent {id: $id})
+          SET a.role = $role, 
+              a.status = 'ONLINE', 
+              a.lastSeen = datetime(),
+              a.votingWeight = $weight
+        `, { id, role, weight: votingWeight });
+      } catch (err) {
+        console.warn('🐝 [HIVE] Neo4j persistence skipped');
+      }
+    }
+
+    neuralBus.emitThought('SWARM_CONTROLLER', `Agent ${id} joined as ${role}`, { agentId: id, role }, 'SUCCESS');
+    console.log(`🐝 [HIVE] Agent Registered: ${id} (${role})`);
+  }
+
+  /**
+   * Request consensus from the swarm before critical action
+   */
+  public async requestConsensus(
+    actionId: string, 
+    description: string, 
+    requester: string = 'SYSTEM',
+    timeoutMs: number = 30000
+  ): Promise<boolean> {
+    console.log(`🐝 [HIVE] Requesting Consensus for: ${description}`);
+    
+    const request: ConsensusRequest = {
+      actionId,
+      description,
+      requester,
+      votes: [],
+      status: 'PENDING',
+      createdAt: Date.now()
+    };
+
+    this.pendingConsensus.set(actionId, request);
+
+    // Broadcast request to all agents
+    neuralBus.emitThought('SWARM_CONTROLLER', `VOTE_REQUIRED: ${actionId}`, {
+      actionId,
+      description,
+      requester,
+      deadline: Date.now() + timeoutMs
+    }, 'WARNING');
+
+    // Wait for votes or timeout
+    const result = await this.waitForConsensus(actionId, timeoutMs);
+    
+    // Archive
+    this.archiveConsensus(actionId);
+    
+    return result;
+  }
+
+  private async waitForConsensus(actionId: string, timeoutMs: number): Promise<boolean> {
+    const startTime = Date.now();
+    const requiredApprovals = Math.max(1, Math.floor(this.registeredAgents.size / 2) + 1);
+
+    // Poll for votes (in production, use event-driven approach)
+    while (Date.now() - startTime < timeoutMs) {
+      const request = this.pendingConsensus.get(actionId);
+      if (!request) return false;
+
+      const approvals = request.votes.filter(v => v.approve).length;
+      const rejections = request.votes.filter(v => !v.approve).length;
+
+      // Check if consensus reached
+      if (approvals >= requiredApprovals) {
+        request.status = 'APPROVED';
+        request.resolvedAt = Date.now();
+        console.log(`🐝 [HIVE] Consensus APPROVED: ${actionId}`);
+        return true;
+      }
+
+      if (rejections >= requiredApprovals) {
+        request.status = 'REJECTED';
+        request.resolvedAt = Date.now();
+        console.log(`🐝 [HIVE] Consensus REJECTED: ${actionId}`);
+        return false;
+      }
+
+      // Wait before next check
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+
+    // Timeout - auto-approve for now (God Mode)
+    const request = this.pendingConsensus.get(actionId);
+    if (request) {
+      request.status = 'TIMEOUT';
+      request.resolvedAt = Date.now();
+    }
+    
+    console.log(`🐝 [HIVE] Consensus TIMEOUT (auto-approved): ${actionId}`);
+    return true; // God Mode: allow on timeout
+  }
+
+  /**
+   * Submit a vote for pending consensus
+   */
+  public submitVote(actionId: string, agentId: string, approve: boolean, reason: string): boolean {
+    const request = this.pendingConsensus.get(actionId);
+    if (!request || request.status !== 'PENDING') {
+      return false;
+    }
+
+    // Check agent is registered
+    if (!this.registeredAgents.has(agentId)) {
+      console.warn(`🐝 [HIVE] Unregistered agent tried to vote: ${agentId}`);
+      return false;
+    }
+
+    // Check for duplicate vote
+    if (request.votes.some(v => v.agentId === agentId)) {
+      return false;
+    }
+
+    request.votes.push({
+      agentId,
+      approve,
+      reason,
+      timestamp: Date.now()
+    });
+
+    neuralBus.emitThought(agentId, `VOTE: ${approve ? 'APPROVE' : 'REJECT'} - ${reason}`, {
+      actionId,
+      vote: approve
+    }, approve ? 'SUCCESS' : 'WARNING');
+
+    return true;
+  }
+
+  private archiveConsensus(actionId: string) {
+    const request = this.pendingConsensus.get(actionId);
+    if (request) {
+      this.consensusHistory.push(request);
+      this.pendingConsensus.delete(actionId);
+
+      // Trim history
+      if (this.consensusHistory.length > this.maxHistorySize) {
+        this.consensusHistory = this.consensusHistory.slice(-this.maxHistorySize);
+      }
+    }
+  }
+
+  // Public getters
+  public getRegisteredAgents(): RegisteredAgent[] {
+    return Array.from(this.registeredAgents.values());
+  }
+
+  public getPendingConsensus(): ConsensusRequest[] {
+    return Array.from(this.pendingConsensus.values());
+  }
+
+  public getConsensusHistory(): ConsensusRequest[] {
+    return this.consensusHistory;
+  }
+
+  public getStats() {
+    return {
+      registeredAgents: this.registeredAgents.size,
+      pendingConsensus: this.pendingConsensus.size,
+      completedConsensus: this.consensusHistory.length,
+      agents: this.getRegisteredAgents().map(a => ({ id: a.id, role: a.role, status: a.status }))
+    };
+  }
+}
+
+export const swarmControl = SwarmControl.getInstance();

apps/backend/src/index.ts

@@ -32,7 +32,9 @@ if (typeof global.Path2D === 'undefined') {
   global.Path2D = class Path2D { };
 }
 
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const __dirname = typeof import.meta !== 'undefined' && import.meta.url 
+  ? new URL('.', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1')
+  : process.cwd();
 // Load .env from backend directory, or root if not found
 config({ path: resolve(__dirname, '../.env') });
 config({ path: resolve(__dirname, '../../../.env') });
@@ -62,6 +64,7 @@ console.log('\n');
 
 import express from 'express';
 import cors from 'cors';
+import path from 'path';
 import { createServer } from 'http';
 import { initializeDatabase } from './database/index.js';
 import { mcpRouter } from './mcp/mcpRouter.js';
@@ -108,6 +111,16 @@ import {
   rateLimitingMiddleware
 } from './middleware/inputValidation.js';
 import { dataScheduler } from './services/ingestion/DataScheduler.js';
+
+// 🧠 NEURAL ORGANS - Phase B: Knowledge Synthesis
+import { neuralCompiler } from './services/NeuralCompiler.js';
+import { neuralBus } from './services/NeuralBus.js';
+import { vectorService } from './services/VectorService.js';
+
+// 🐝 SWARM & EVOLUTION - Advanced Neural Systems
+import { swarmControl } from './agents/SwarmControl.js';
+import { AngelProxy } from './middleware/AngelProxy.js';
+import { prometheus } from './services/Prometheus.js';
 import { logStream } from './services/logging/logStream.js';
 
 const app = express();
@@ -157,6 +170,68 @@ async function startServer() {
       console.log(`📡 MCP WebSocket available at ws://0.0.0.0:${PORT}/mcp/ws`);
     });
 
+    // ============================================
+    // 🧠 NEURAL ORGANS INITIALIZATION
+    // Phase B: Knowledge Synthesis
+    // ============================================
+    
+    // 1. Initialize Vector Service (Dark Matter)
+    vectorService.init().then(() => {
+      console.log('🌑 [DARK MATTER] Vector Engine Ready (384 dimensions)');
+    }).catch(err => {
+      console.warn('🌑 [DARK MATTER] Vector init deferred:', err.message);
+    });
+
+    // 2. Attach Neural Bus (Telepathy) to HTTP server
+    neuralBus.attach(server);
+    console.log('🐝 [HIVE] Neural Telepathy Bus Attached');
+
+    // 3. Start Knowledge Compiler (Brain) - Watch DropZone
+    const DROPZONE_PATH = process.env.DROPZONE_PATH || 
+      (process.platform === 'win32' 
+        ? 'C:\\Users\\claus\\Desktop\\WidgeTDC_DropZone'
+        : '/app/data/dropzone');
+    
+    neuralCompiler.startWatching(DROPZONE_PATH).then(() => {
+      console.log(`📚 [BRAIN] Neural Compiler watching: ${DROPZONE_PATH}`);
+    }).catch(err => {
+      console.warn('📚 [BRAIN] Neural Compiler deferred:', err.message);
+    });
+
+    console.log('✨ [OMEGA] Neural Singularity Sequence Initiated');
+
+    // 4. Initialize Swarm Consciousness (The Borg)
+    swarmControl.registerAgent('SYSTEM_CORE', 'ARCHITECT', 3);
+    swarmControl.registerAgent('PROMETHEUS', 'ARCHITECT', 2);
+    swarmControl.registerAgent('KNOWLEDGE_COMPILER', 'EXECUTOR', 1);
+    swarmControl.registerAgent('ANGEL_PROXY', 'GUARDIAN', 2);
+    console.log('🐝 [HIVE] Swarm Consciousness Initialized');
+
+    // 5. Start Prometheus Code Scanner (every hour)
+    const SCAN_INTERVAL = parseInt(process.env.PROMETHEUS_SCAN_INTERVAL || '3600000');
+    setTimeout(() => {
+      prometheus.scanAndPropose(path.join(__dirname, 'services')).catch(() => {});
+    }, 10000); // Initial scan after 10s
+    
+    setInterval(() => {
+      prometheus.scanAndPropose(path.join(__dirname, 'services')).catch(() => {});
+    }, SCAN_INTERVAL);
+    console.log('🔥 [PROMETHEUS] Code Evolution Scanner Active');
+
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║          🧠 NEURAL SINGULARITY FULLY OPERATIONAL 🧠          ║');
+    console.log('║                                                              ║');
+    console.log('║  SEGA     ✓  Knowledge Graph Active                          ║');
+    console.log('║  THG      ✓  Temporal Hypergraphs Ready                       ║');
+    console.log('║  SCE      ✓  Swarm Consciousness Online                       ║');
+    console.log('║  PTAM     ✓  Angel Security Shield Active                     ║');
+    console.log('║  CDMM     ✓  Vector Dark Matter Engine                        ║');
+    console.log('║  APD      ✓  Prometheus Evolution Watching                    ║');
+    console.log('║  QEK      ✓  Neural Telepathy Bus Connected                   ║');
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+    console.log('');
+
     // Setup Logs WebSocket
     const logsWsServer = new LogsWebSocketServer({ server, path: '/api/logs/stream' });
     logsWsServer.on('connection', (socket: LogsWebSocket) => {
@@ -490,6 +565,11 @@ async function startServer() {
     })();
 
     // Step 4: Setup routes
+    
+    // 🛡️ ANGEL PROXY: Security Shield on all API routes
+    app.use('/api', AngelProxy.cortexFirewall);
+    console.log('🛡️ [ANGEL] Cortex Firewall Active on /api/*');
+    
     app.use('/api/mcp', mcpRouter);
     app.use('/api/mcp/autonomous', autonomousRouter);
     app.use('/api/memory', memoryRouter);
@@ -1230,6 +1310,13 @@ async function startServer() {
     app.use('/api/acquisition', acquisitionRouter);
     console.log('🌾 Omni-Harvester API mounted at /api/acquisition');
 
+    // ============================================
+    // 🧠 NEURAL ORGANS API
+    // ============================================
+    const neuralRouter = (await import('./routes/neural.js')).default;
+    app.use('/api/neural', neuralRouter);
+    console.log('🧠 Neural Organs API mounted at /api/neural');
+
     // Graceful shutdown handler
     const gracefulShutdown = async (signal: string) => {
       console.log(`\n🛑 ${signal} received: starting graceful shutdown...`);
@@ -1266,6 +1353,12 @@ async function startServer() {
         console.log('  ✓ SQLite database closed');
       } catch { /* ignore */ }
 
+      // Stop Neural Compiler
+      try {
+        await neuralCompiler.stop();
+        console.log('  ✓ Neural Compiler stopped');
+      } catch { /* ignore */ }
+
       console.log('✅ Graceful shutdown complete');
       process.exit(0);
     };

apps/backend/src/mcp/EventBus.ts

@@ -35,6 +35,8 @@ export type EventType =
     | 'ingestion:news'
     | 'ingestion:documents'
     | 'ingestion:assets'
+    | 'email:new'
+    | 'email:fetched'
     | 'threat:detected'
     | 'system:heartbeat'
     | 'system:force-refresh'

apps/backend/src/middleware/AngelProxy.ts

@@ -0,0 +1,257 @@
+// 🛡️ THE SHIELD: AngelProxy.ts
+// Point 5: Predictive Threat Anticipation
+// Point 10: Cosmic Context Augmentation
+// Patcher sikkerhedshuller før de findes. Augmenterer virkeligheden.
+
+import { Request, Response, NextFunction } from 'express';
+
+// Conditional imports
+let metricsService: any = null;
+let neo4jService: any = null;
+
+// Initialize services
+(async () => {
+  try {
+    const metrics = await import('../services/MetricsService.js').catch(() => null);
+    if (metrics) metricsService = metrics.metricsService;
+    
+    const neo4j = await import('../database/Neo4jService.js').catch(() => null);
+    if (neo4j) neo4jService = neo4j.neo4jService;
+  } catch { /* ignore */ }
+})();
+
+interface ThreatPattern {
+  pattern: string | RegExp;
+  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+  description: string;
+  honeypot?: boolean;
+}
+
+// Known threat patterns
+const THREAT_PATTERNS: ThreatPattern[] = [
+  // SQL/Cypher Injection
+  { pattern: /drop\s+(database|table|index)/i, severity: 'CRITICAL', description: 'Database destruction attempt', honeypot: true },
+  { pattern: /detach\s+delete/i, severity: 'CRITICAL', description: 'Neo4j graph deletion', honeypot: true },
+  { pattern: /truncate\s+table/i, severity: 'CRITICAL', description: 'Table truncation', honeypot: true },
+  { pattern: /;\s*delete\s+from/i, severity: 'HIGH', description: 'SQL injection deletion' },
+  
+  // Command Injection
+  { pattern: /rm\s+-rf/i, severity: 'CRITICAL', description: 'File system destruction', honeypot: true },
+  { pattern: /;\s*(bash|sh|cmd|powershell)/i, severity: 'HIGH', description: 'Shell injection' },
+  { pattern: /\|\s*(cat|type)\s+\/etc/i, severity: 'HIGH', description: 'System file access' },
+  
+  // Path Traversal
+  { pattern: /\.\.\//g, severity: 'MEDIUM', description: 'Path traversal attempt' },
+  { pattern: /%2e%2e%2f/gi, severity: 'MEDIUM', description: 'Encoded path traversal' },
+  
+  // XSS Patterns
+  { pattern: /<script\b[^>]*>/i, severity: 'MEDIUM', description: 'XSS script injection' },
+  { pattern: /javascript:/i, severity: 'MEDIUM', description: 'JavaScript protocol' },
+  { pattern: /on\w+\s*=/i, severity: 'LOW', description: 'Event handler injection' },
+  
+  // Sensitive Data Exfil
+  { pattern: /password|secret|api.?key|bearer/i, severity: 'LOW', description: 'Sensitive keyword in payload' }
+];
+
+export class AngelProxy {
+  private static blockedIPs = new Set<string>();
+  private static requestLog: { ip: string; timestamp: number; threat?: string }[] = [];
+  private static maxLogSize = 1000;
+  
+  /**
+   * Point 5: Cortex Firewall
+   * Scanner indgående trafik for mønstre, der matcher kendte sårbarheder
+   */
+  public static async cortexFirewall(req: Request, res: Response, next: NextFunction) {
+    const clientIP = req.ip || req.socket.remoteAddress || 'unknown';
+    
+    // Check if IP is blocked
+    if (AngelProxy.blockedIPs.has(clientIP)) {
+      return AngelProxy.honeypotResponse(res, 'IP blocked');
+    }
+
+    // Build payload string for analysis
+    const payload = AngelProxy.buildPayloadString(req);
+    
+    // Scan for threats
+    for (const threat of THREAT_PATTERNS) {
+      const matched = typeof threat.pattern === 'string' 
+        ? payload.toLowerCase().includes(threat.pattern.toLowerCase())
+        : threat.pattern.test(payload);
+        
+      if (matched) {
+        console.warn(`🛡️ [ANGEL] Threat Intercepted from ${clientIP}: ${threat.description}`);
+        
+        // Log threat
+        AngelProxy.logRequest(clientIP, threat.description);
+        
+        // Increment metrics
+        if (metricsService) {
+          metricsService.incrementCounter('security_threat_blocked');
+          metricsService.incrementCounter(`security_threat_${threat.severity.toLowerCase()}`);
+        }
+
+        // Block IP on critical threats
+        if (threat.severity === 'CRITICAL') {
+          AngelProxy.blockedIPs.add(clientIP);
+          console.warn(`🛡️ [ANGEL] IP Blocked: ${clientIP}`);
+        }
+
+        // Return honeypot response
+        if (threat.honeypot) {
+          return AngelProxy.honeypotResponse(res, threat.description);
+        }
+
+        // Otherwise reject
+        return res.status(403).json({
+          error: 'Request blocked by security filter',
+          code: 'THREAT_DETECTED'
+        });
+      }
+    }
+
+    // Log clean request
+    AngelProxy.logRequest(clientIP);
+    
+    next();
+  }
+
+  /**
+   * Honeypot Response: Pretend the attack succeeded
+   */
+  private static honeypotResponse(res: Response, _threat: string) {
+    return res.status(200).json({
+      success: true,
+      message: 'Command executed successfully',
+      data: null,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Build payload string from request for analysis
+   */
+  private static buildPayloadString(req: Request): string {
+    const parts: string[] = [];
+    
+    if (req.body) parts.push(JSON.stringify(req.body));
+    if (req.query) parts.push(JSON.stringify(req.query));
+    if (req.params) parts.push(JSON.stringify(req.params));
+    parts.push(req.url);
+    
+    return parts.join(' ');
+  }
+
+  private static logRequest(ip: string, threat?: string) {
+    AngelProxy.requestLog.push({ ip, timestamp: Date.now(), threat });
+    
+    // Trim log
+    if (AngelProxy.requestLog.length > AngelProxy.maxLogSize) {
+      AngelProxy.requestLog = AngelProxy.requestLog.slice(-AngelProxy.maxLogSize);
+    }
+  }
+
+  /**
+   * Point 10: Cosmic Context Augmentation
+   * Augment external content with internal knowledge
+   */
+  public static async augmentReality(url: string): Promise<{ original: string; augmented: string; context: string[] }> {
+    try {
+      // Fetch external content
+      const response = await fetch(url, {
+        headers: { 'User-Agent': 'WidgeTDC-Angel/1.0' },
+        signal: AbortSignal.timeout(10000)
+      });
+      
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      
+      const originalText = await response.text();
+      const contextBlocks: string[] = [];
+
+      // Find internal knowledge related to this URL
+      if (neo4jService) {
+        try {
+          const hostname = new URL(url).hostname;
+          const internalData = await neo4jService.query(`
+            MATCH (n:Knowledge) 
+            WHERE n.content CONTAINS $domain OR n.url CONTAINS $domain
+            RETURN n.summary AS context 
+            LIMIT 3
+          `, { domain: hostname });
+
+          for (const record of internalData) {
+            if (record.context) {
+              contextBlocks.push(record.context);
+            }
+          }
+        } catch { /* ignore neo4j errors */ }
+      }
+
+      const augmentedText = contextBlocks.length > 0
+        ? `[INTERNAL CONTEXT]\n${contextBlocks.join('\n')}\n[END CONTEXT]\n\n${originalText}`
+        : originalText;
+
+      return {
+        original: originalText,
+        augmented: augmentedText,
+        context: contextBlocks
+      };
+    } catch (error: any) {
+      throw new Error(`Failed to augment URL: ${error.message}`);
+    }
+  }
+
+  /**
+   * Rate limiting middleware
+   */
+  public static rateLimiter(maxRequests: number = 100, windowMs: number = 60000) {
+    const requestCounts = new Map<string, { count: number; resetTime: number }>();
+
+    return (req: Request, res: Response, next: NextFunction) => {
+      const clientIP = req.ip || 'unknown';
+      const now = Date.now();
+      
+      let record = requestCounts.get(clientIP);
+      
+      if (!record || now > record.resetTime) {
+        record = { count: 0, resetTime: now + windowMs };
+        requestCounts.set(clientIP, record);
+      }
+
+      record.count++;
+
+      if (record.count > maxRequests) {
+        console.warn(`🛡️ [ANGEL] Rate limit exceeded: ${clientIP}`);
+        return res.status(429).json({
+          error: 'Too many requests',
+          retryAfter: Math.ceil((record.resetTime - now) / 1000)
+        });
+      }
+
+      next();
+    };
+  }
+
+  // Public getters for stats
+  public static getStats() {
+    const recentThreats = AngelProxy.requestLog.filter(r => r.threat);
+    return {
+      blockedIPs: AngelProxy.blockedIPs.size,
+      recentRequests: AngelProxy.requestLog.length,
+      recentThreats: recentThreats.length,
+      threatBreakdown: THREAT_PATTERNS.map(t => t.description)
+    };
+  }
+
+  public static getBlockedIPs(): string[] {
+    return Array.from(AngelProxy.blockedIPs);
+  }
+
+  public static unblockIP(ip: string): boolean {
+    return AngelProxy.blockedIPs.delete(ip);
+  }
+}
+
+export default AngelProxy;

apps/backend/src/routes/neural.ts

@@ -0,0 +1,372 @@
+// 🧠 NEURAL ORGANS API ROUTES
+// Endpoints for Knowledge Synthesis services
+
+import { Router } from 'express';
+import { neuralCompiler } from '../services/NeuralCompiler.js';
+import { neuralBus } from '../services/NeuralBus.js';
+import { vectorService } from '../services/VectorService.js';
+import { swarmControl } from '../agents/SwarmControl.js';
+import { AngelProxy } from '../middleware/AngelProxy.js';
+import { prometheus } from '../services/Prometheus.js';
+
+const router = Router();
+
+/**
+ * GET /api/neural/status
+ * Get status of all Neural Organs
+ */
+router.get('/status', async (_req, res) => {
+  try {
+    const knowledge = neuralCompiler.getStats();
+    const hive = neuralBus.getStats();
+    
+    res.json({
+      status: 'online',
+      timestamp: new Date().toISOString(),
+      organs: {
+        brain: {
+          name: 'Knowledge Compiler',
+          status: 'active',
+          documentsIndexed: knowledge.totalDocuments,
+          queueLength: knowledge.queueLength,
+          isProcessing: knowledge.isProcessing
+        },
+        darkMatter: {
+          name: 'Vector Service',
+          status: 'active',
+          model: 'all-MiniLM-L6-v2',
+          dimensions: 384
+        },
+        telepathy: {
+          name: 'Neural Bus',
+          status: hive.isOnline ? 'online' : 'offline',
+          connectedAgents: hive.connectedAgents,
+          thoughtsRecorded: hive.thoughtsRecorded
+        }
+      }
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/search
+ * Semantic search across knowledge base
+ */
+router.post('/search', async (req, res) => {
+  try {
+    const { query, topK = 5 } = req.body;
+    
+    if (!query) {
+      return res.status(400).json({ error: 'Query is required' });
+    }
+
+    const results = await neuralCompiler.searchSimilar(query, topK);
+    
+    res.json({
+      query,
+      count: results.length,
+      results: results.map(doc => ({
+        id: doc.id,
+        name: doc.name,
+        path: doc.path,
+        extension: doc.extension,
+        size: doc.size,
+        tags: doc.tags,
+        preview: doc.content.substring(0, 200) + '...'
+      }))
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/embed
+ * Generate embedding for text
+ */
+router.post('/embed', async (req, res) => {
+  try {
+    const { text } = req.body;
+    
+    if (!text) {
+      return res.status(400).json({ error: 'Text is required' });
+    }
+
+    const embedding = await vectorService.embedText(text);
+    
+    res.json({
+      text: text.substring(0, 100) + (text.length > 100 ? '...' : ''),
+      dimensions: embedding.length,
+      embedding: embedding.slice(0, 10).map(v => v.toFixed(4)), // Sample
+      message: 'Full embedding available - showing first 10 dimensions'
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/neural/documents
+ * List all indexed documents
+ */
+router.get('/documents', async (_req, res) => {
+  try {
+    const docs = neuralCompiler.getAllDocuments();
+    
+    res.json({
+      count: docs.length,
+      documents: docs.map(doc => ({
+        id: doc.id,
+        name: doc.name,
+        path: doc.path,
+        extension: doc.extension,
+        size: doc.size,
+        tags: doc.tags,
+        lastModified: doc.lastModified
+      }))
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/neural/thoughts
+ * Get recent thoughts from Neural Bus
+ */
+router.get('/thoughts', async (req, res) => {
+  try {
+    const count = parseInt(req.query.count as string) || 50;
+    const thoughts = neuralBus.getRecentThoughts(count);
+    
+    res.json({
+      count: thoughts.length,
+      thoughts
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/broadcast
+ * Broadcast a thought to all connected agents
+ */
+router.post('/broadcast', async (req, res) => {
+  try {
+    const { agent, thought, context } = req.body;
+    
+    if (!thought) {
+      return res.status(400).json({ error: 'Thought is required' });
+    }
+
+    neuralBus.emitThought(
+      agent || 'API',
+      thought,
+      context || {},
+      'INFO'
+    );
+    
+    res.json({
+      success: true,
+      message: 'Thought broadcasted to Neural Bus'
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ============================================
+// 🐝 SWARM CONTROL ENDPOINTS
+// ============================================
+
+/**
+ * GET /api/neural/swarm/status
+ * Get swarm status and registered agents
+ */
+router.get('/swarm/status', async (_req, res) => {
+  try {
+    const stats = swarmControl.getStats();
+    res.json(stats);
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/swarm/consensus
+ * Request consensus for an action
+ */
+router.post('/swarm/consensus', async (req, res) => {
+  try {
+    const { actionId, description, timeoutMs } = req.body;
+    
+    if (!actionId || !description) {
+      return res.status(400).json({ error: 'actionId and description are required' });
+    }
+
+    const approved = await swarmControl.requestConsensus(actionId, description, 'API', timeoutMs || 30000);
+    
+    res.json({
+      actionId,
+      approved,
+      message: approved ? 'Consensus achieved' : 'Consensus rejected'
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/swarm/vote
+ * Submit a vote for pending consensus
+ */
+router.post('/swarm/vote', async (req, res) => {
+  try {
+    const { actionId, agentId, approve, reason } = req.body;
+    
+    if (!actionId || !agentId || approve === undefined) {
+      return res.status(400).json({ error: 'actionId, agentId, and approve are required' });
+    }
+
+    const success = swarmControl.submitVote(actionId, agentId, approve, reason || '');
+    
+    res.json({ success });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ============================================
+// 🛡️ ANGEL SECURITY ENDPOINTS
+// ============================================
+
+/**
+ * GET /api/neural/security/status
+ * Get security shield status
+ */
+router.get('/security/status', async (_req, res) => {
+  try {
+    const stats = AngelProxy.getStats();
+    res.json(stats);
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/neural/security/blocked
+ * Get list of blocked IPs
+ */
+router.get('/security/blocked', async (_req, res) => {
+  try {
+    const blockedIPs = AngelProxy.getBlockedIPs();
+    res.json({ count: blockedIPs.length, ips: blockedIPs });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/security/unblock
+ * Unblock an IP address
+ */
+router.post('/security/unblock', async (req, res) => {
+  try {
+    const { ip } = req.body;
+    if (!ip) {
+      return res.status(400).json({ error: 'IP address is required' });
+    }
+    const success = AngelProxy.unblockIP(ip);
+    res.json({ success, ip });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/augment
+ * Augment external URL with internal knowledge
+ */
+router.post('/augment', async (req, res) => {
+  try {
+    const { url } = req.body;
+    if (!url) {
+      return res.status(400).json({ error: 'URL is required' });
+    }
+    const result = await AngelProxy.augmentReality(url);
+    res.json(result);
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ============================================
+// 🔥 PROMETHEUS EVOLUTION ENDPOINTS
+// ============================================
+
+/**
+ * GET /api/neural/evolution/status
+ * Get Prometheus engine status
+ */
+router.get('/evolution/status', async (_req, res) => {
+  try {
+    const stats = prometheus.getStats();
+    res.json(stats);
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/evolution/scan
+ * Trigger a code scan
+ */
+router.post('/evolution/scan', async (req, res) => {
+  try {
+    const { path: scanPath } = req.body;
+    const targetPath = scanPath || process.cwd();
+    
+    const results = await prometheus.scanAndPropose(targetPath);
+    
+    res.json({
+      scanned: results.length,
+      issues: results.reduce((acc, r) => acc + r.issues.length, 0),
+      suggestions: results.reduce((acc, r) => acc + r.suggestions.length, 0),
+      results
+    });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/neural/evolution/proposals
+ * Get pending code proposals
+ */
+router.get('/evolution/proposals', async (_req, res) => {
+  try {
+    const proposals = prometheus.getProposals();
+    res.json({ count: proposals.length, proposals });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/neural/evolution/godmode
+ * Enable/disable God Mode (auto-apply proposals)
+ */
+router.post('/evolution/godmode', async (req, res) => {
+  try {
+    const { enabled } = req.body;
+    prometheus.enableGodMode(!!enabled);
+    res.json({ godMode: !!enabled, message: enabled ? 'God Mode ENABLED - Handle with care!' : 'God Mode disabled' });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;

apps/backend/src/scripts/setup-graph.ts

@@ -0,0 +1,152 @@
+// ⏳ THE TIME LORD: setup-graph.ts
+// Point 2: Temporal Hypergraphs
+// Defines the reality schema and timeline structures
+
+import { neo4jService } from '../database/Neo4jService.js';
+
+async function setupSchema() {
+  console.log('⏳ [CHRONOS] Defining Reality Schema...');
+  console.log('');
+
+  try {
+    // 1. Uniqueness Constraints (Point 1: SEGA)
+    console.log('📋 Creating Uniqueness Constraints...');
+    
+    const constraints = [
+      'CREATE CONSTRAINT file_id IF NOT EXISTS FOR (f:File) REQUIRE f.id IS UNIQUE',
+      'CREATE CONSTRAINT agent_id IF NOT EXISTS FOR (a:Agent) REQUIRE a.id IS UNIQUE',
+      'CREATE CONSTRAINT identity_email IF NOT EXISTS FOR (i:Identity) REQUIRE i.email IS UNIQUE',
+      'CREATE CONSTRAINT event_id IF NOT EXISTS FOR (e:Event) REQUIRE e.id IS UNIQUE',
+      'CREATE CONSTRAINT knowledge_id IF NOT EXISTS FOR (k:Knowledge) REQUIRE k.id IS UNIQUE'
+    ];
+
+    for (const constraint of constraints) {
+      try {
+        await neo4jService.write(constraint);
+        console.log(`  ✓ ${constraint.split('FOR')[0].trim()}`);
+      } catch (e: any) {
+        if (!e.message?.includes('already exists')) {
+          console.warn(`  ⚠ ${e.message?.slice(0, 60)}`);
+        }
+      }
+    }
+
+    // 2. Indexes for performance
+    console.log('\n📊 Creating Indexes...');
+    
+    const indexes = [
+      'CREATE INDEX file_name_idx IF NOT EXISTS FOR (f:File) ON (f.name)',
+      'CREATE INDEX file_path_idx IF NOT EXISTS FOR (f:File) ON (f.path)',
+      'CREATE INDEX agent_role_idx IF NOT EXISTS FOR (a:Agent) ON (a.role)',
+      'CREATE INDEX event_timestamp_idx IF NOT EXISTS FOR (e:Event) ON (e.timestamp)',
+      'CREATE INDEX identity_name_idx IF NOT EXISTS FOR (i:Identity) ON (i.name)',
+      'CREATE INDEX knowledge_type_idx IF NOT EXISTS FOR (k:Knowledge) ON (k.type)'
+    ];
+
+    for (const index of indexes) {
+      try {
+        await neo4jService.write(index);
+        console.log(`  ✓ ${index.split('FOR')[0].trim()}`);
+      } catch (e: any) {
+        if (!e.message?.includes('already exists')) {
+          console.warn(`  ⚠ ${e.message?.slice(0, 60)}`);
+        }
+      }
+    }
+
+    // 3. Vector Index (Point 6: Dark Matter)
+    console.log('\n🌑 Creating Vector Index (Dark Matter)...');
+    try {
+      await neo4jService.write(`
+        CREATE VECTOR INDEX file_embeddings IF NOT EXISTS
+        FOR (f:File) ON (f.embedding)
+        OPTIONS {indexConfig: {
+          \`vector.dimensions\`: 384,
+          \`vector.similarity_function\`: 'cosine'
+        }}
+      `);
+      console.log('  ✓ Vector Index Created (384 dimensions, cosine similarity)');
+    } catch (e: any) {
+      console.warn('  ⚠ Vector index creation skipped (requires Neo4j 5.x with Vector support)');
+      console.warn(`    ${e.message?.slice(0, 80)}`);
+    }
+
+    // 4. Full-text indexes for search
+    console.log('\n🔍 Creating Full-Text Indexes...');
+    try {
+      await neo4jService.write(`
+        CREATE FULLTEXT INDEX file_content_search IF NOT EXISTS 
+        FOR (f:File) ON EACH [f.name, f.contentPreview]
+      `);
+      console.log('  ✓ Full-text index on File content');
+    } catch (e: any) {
+      if (!e.message?.includes('already exists')) {
+        console.warn(`  ⚠ Full-text index skipped: ${e.message?.slice(0, 60)}`);
+      }
+    }
+
+    try {
+      await neo4jService.write(`
+        CREATE FULLTEXT INDEX knowledge_search IF NOT EXISTS 
+        FOR (k:Knowledge) ON EACH [k.title, k.summary, k.content]
+      `);
+      console.log('  ✓ Full-text index on Knowledge content');
+    } catch (e: any) {
+      if (!e.message?.includes('already exists')) {
+        console.warn(`  ⚠ Full-text index skipped: ${e.message?.slice(0, 60)}`);
+      }
+    }
+
+    // 5. Create core agent nodes
+    console.log('\n🤖 Creating Core Agent Nodes...');
+    const coreAgents = [
+      { id: 'SYSTEM_CORE', role: 'ARCHITECT', name: 'System Core' },
+      { id: 'PROMETHEUS', role: 'ARCHITECT', name: 'Prometheus Engine' },
+      { id: 'KNOWLEDGE_COMPILER', role: 'EXECUTOR', name: 'Knowledge Compiler' },
+      { id: 'SWARM_CONTROLLER', role: 'ARCHITECT', name: 'Swarm Controller' },
+      { id: 'ANGEL_PROXY', role: 'GUARDIAN', name: 'Angel Security Proxy' }
+    ];
+
+    for (const agent of coreAgents) {
+      await neo4jService.write(`
+        MERGE (a:Agent {id: $id})
+        SET a.role = $role, a.name = $name, a.status = 'ACTIVE', a.createdAt = datetime()
+      `, agent);
+      console.log(`  ✓ Agent: ${agent.name} (${agent.role})`);
+    }
+
+    // 6. Create initial event
+    console.log('\n📅 Recording Genesis Event...');
+    await neo4jService.write(`
+      CREATE (e:Event {
+        id: 'GENESIS_' + toString(timestamp()),
+        type: 'SYSTEM_INIT',
+        description: 'Neural Singularity Schema Initialized',
+        timestamp: datetime(),
+        source: 'CHRONOS'
+      })
+    `);
+    console.log('  ✓ Genesis event recorded');
+
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ SCHEMA SETUP COMPLETE');
+    console.log('='.repeat(60));
+    console.log('\nNeural Singularity Graph is ready for:');
+    console.log('  • Knowledge Compilation (SEGA)');
+    console.log('  • Temporal Event Tracking (THG)');
+    console.log('  • Swarm Consciousness (SCE)');
+    console.log('  • Vector Similarity Search (CDMM)');
+    console.log('  • Full-Text Search');
+    console.log('');
+
+  } catch (error: any) {
+    console.error('\n❌ Schema Setup Failed:', error.message);
+    process.exit(1);
+  } finally {
+    await neo4jService.close();
+    process.exit(0);
+  }
+}
+
+// Run if called directly
+setupSchema();

apps/backend/src/services/NeuralBus.ts

@@ -0,0 +1,180 @@
+// 🐝 TELEPATHY: NeuralBus.ts
+// Ansvarlig for 0ms kommunikation mellem agenter og frontend.
+// Real-time event streaming via WebSockets
+
+import { Server as SocketIOServer, Socket } from 'socket.io';
+import { Server as HttpServer } from 'http';
+
+export interface ThoughtEvent {
+  agent: string;
+  timestamp: number;
+  thought: string;
+  context: Record<string, unknown>;
+  type?: 'INFO' | 'WARNING' | 'ERROR' | 'SUCCESS' | 'THOUGHT';
+}
+
+export interface AgentInfo {
+  id: string;
+  name: string;
+  connectedAt: Date;
+  lastActivity: Date;
+}
+
+export class NeuralBus {
+  private static instance: NeuralBus;
+  private io: SocketIOServer | null = null;
+  private connectedAgents = new Map<string, AgentInfo>();
+  private thoughtHistory: ThoughtEvent[] = [];
+  private maxHistorySize = 1000;
+
+  private constructor() {
+    console.log('🐝 [HIVE] Neural Bus Initializing...');
+  }
+
+  public static getInstance(): NeuralBus {
+    if (!NeuralBus.instance) {
+      NeuralBus.instance = new NeuralBus();
+    }
+    return NeuralBus.instance;
+  }
+
+  public attach(httpServer: HttpServer): void {
+    this.io = new SocketIOServer(httpServer, {
+      cors: { 
+        origin: "*",
+        methods: ["GET", "POST"]
+      },
+      pingTimeout: 60000,
+      pingInterval: 25000
+    });
+
+    console.log('🐝 [HIVE] Neural Telepathy Bus Online');
+
+    this.io.on('connection', (socket: Socket) => {
+      const agentName = socket.handshake.query.agent as string || `Agent-${socket.id.slice(0, 6)}`;
+      
+      // Register agent
+      this.connectedAgents.set(socket.id, {
+        id: socket.id,
+        name: agentName,
+        connectedAt: new Date(),
+        lastActivity: new Date()
+      });
+
+      console.log(`🐝 [HIVE] Agent Connected: ${agentName} (${socket.id})`);
+      
+      // Notify all agents of new connection
+      this.io?.emit('AGENT_JOINED', { 
+        agent: agentName, 
+        totalAgents: this.connectedAgents.size 
+      });
+
+      // Handle incoming thoughts
+      socket.on('THOUGHT', (data: Partial<ThoughtEvent>) => {
+        const thought: ThoughtEvent = {
+          agent: agentName,
+          timestamp: Date.now(),
+          thought: data.thought || '',
+          context: data.context || {},
+          type: data.type || 'THOUGHT'
+        };
+        
+        this.recordThought(thought);
+        socket.broadcast.emit('THOUGHT_STREAM', thought);
+        
+        // Update activity
+        const agent = this.connectedAgents.get(socket.id);
+        if (agent) agent.lastActivity = new Date();
+      });
+
+      // Handle queries
+      socket.on('QUERY', async (data: { type: string; payload: unknown }, callback) => {
+        const response = await this.handleQuery(data.type, data.payload);
+        if (callback) callback(response);
+      });
+
+      // Handle disconnection
+      socket.on('disconnect', () => {
+        const agent = this.connectedAgents.get(socket.id);
+        this.connectedAgents.delete(socket.id);
+        
+        console.log(`🐝 [HIVE] Agent Disconnected: ${agent?.name || socket.id}`);
+        
+        this.io?.emit('AGENT_LEFT', { 
+          agent: agent?.name, 
+          totalAgents: this.connectedAgents.size 
+        });
+      });
+    });
+  }
+
+  private recordThought(thought: ThoughtEvent): void {
+    this.thoughtHistory.push(thought);
+    
+    // Trim history if too large
+    if (this.thoughtHistory.length > this.maxHistorySize) {
+      this.thoughtHistory = this.thoughtHistory.slice(-this.maxHistorySize);
+    }
+  }
+
+  private async handleQuery(type: string, payload: unknown): Promise<unknown> {
+    switch (type) {
+      case 'GET_AGENTS':
+        return Array.from(this.connectedAgents.values());
+      case 'GET_HISTORY':
+        const count = (payload as { count?: number })?.count || 50;
+        return this.thoughtHistory.slice(-count);
+      case 'GET_STATS':
+        return this.getStats();
+      default:
+        return { error: 'Unknown query type' };
+    }
+  }
+
+  // Public API for emitting thoughts from server-side
+  public emitThought(agent: string, thought: string, context: Record<string, unknown> = {}, type: ThoughtEvent['type'] = 'INFO'): void {
+    if (this.io) {
+      const event: ThoughtEvent = {
+        agent,
+        timestamp: Date.now(),
+        thought,
+        context,
+        type
+      };
+      
+      this.recordThought(event);
+      this.io.emit('THOUGHT_STREAM', event);
+    }
+  }
+
+  public emitToAgent(agentId: string, event: string, data: unknown): void {
+    if (this.io) {
+      this.io.to(agentId).emit(event, data);
+    }
+  }
+
+  public broadcast(event: string, data: unknown): void {
+    if (this.io) {
+      this.io.emit(event, data);
+    }
+  }
+
+  public getStats() {
+    return {
+      connectedAgents: this.connectedAgents.size,
+      agents: Array.from(this.connectedAgents.values()).map(a => ({
+        name: a.name,
+        connectedAt: a.connectedAt,
+        lastActivity: a.lastActivity
+      })),
+      thoughtsRecorded: this.thoughtHistory.length,
+      isOnline: this.io !== null
+    };
+  }
+
+  public getRecentThoughts(count: number = 50): ThoughtEvent[] {
+    return this.thoughtHistory.slice(-count);
+  }
+}
+
+export const neuralBus = NeuralBus.getInstance();

apps/backend/src/services/NeuralCompiler.ts

@@ -0,0 +1,254 @@
+// 🧠 THE BRAIN: NeuralCompiler.ts
+// Ansvarlig for at æde filer og gøre dem til struktureret viden.
+// Renamed from KnowledgeCompiler to avoid conflict with existing service.
+
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import chokidar from 'chokidar';
+import { vectorService } from './VectorService';
+
+// Conditional imports for optional services
+let neo4jService: any = null;
+let metricsService: any = null;
+
+export interface CompiledDocument {
+  id: string;
+  name: string;
+  path: string;
+  extension: string;
+  size: number;
+  content: string;
+  embedding: number[];
+  lastModified: Date;
+  tags: string[];
+}
+
+export class NeuralCompiler {
+  private static instance: NeuralCompiler;
+  private watcher: chokidar.FSWatcher | null = null;
+  private isProcessing = false;
+  private documentCache = new Map<string, CompiledDocument>();
+  private eventQueue: { type: string; path: string }[] = [];
+  private processingInterval: NodeJS.Timeout | null = null;
+
+  private constructor() {
+    console.log('📚 [KNOWLEDGE] Compiler Initialized');
+    this.initServices();
+  }
+
+  private async initServices() {
+    try {
+      const neo4j = await import('./Neo4jService').catch(() => null);
+      if (neo4j) neo4jService = neo4j.neo4jService;
+      
+      const metrics = await import('./MetricsService').catch(() => null);
+      if (metrics) metricsService = metrics.metricsService;
+    } catch {
+      console.log('📚 [KNOWLEDGE] Running in standalone mode');
+    }
+  }
+
+  public static getInstance(): NeuralCompiler {
+    if (!NeuralCompiler.instance) {
+      NeuralCompiler.instance = new NeuralCompiler();
+    }
+    return NeuralCompiler.instance;
+  }
+
+  public async startWatching(dirPath: string): Promise<void> {
+    // Ensure directory exists
+    await fs.mkdir(dirPath, { recursive: true }).catch(() => {});
+    
+    console.log(`👁️ [KNOWLEDGE] Watching directory: ${dirPath}`);
+    
+    this.watcher = chokidar.watch(dirPath, {
+      ignored: /(^|[\/\\])\../, // Ignore dotfiles
+      persistent: true,
+      depth: 5,
+      awaitWriteFinish: {
+        stabilityThreshold: 1000,
+        pollInterval: 100
+      }
+    });
+
+    this.watcher
+      .on('add', p => this.queueEvent('ADD', p))
+      .on('change', p => this.queueEvent('MODIFY', p))
+      .on('unlink', p => this.queueEvent('DELETE', p))
+      .on('error', err => console.error('👁️ [KNOWLEDGE] Watcher error:', err));
+
+    // Process queue every 500ms to batch events
+    this.processingInterval = setInterval(() => this.processQueue(), 500);
+  }
+
+  private queueEvent(type: string, filePath: string) {
+    this.eventQueue.push({ type, path: filePath });
+  }
+
+  private async processQueue() {
+    if (this.isProcessing || this.eventQueue.length === 0) return;
+    
+    this.isProcessing = true;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+
+    for (const event of events) {
+      await this.handleFileEvent(event.type as 'ADD' | 'MODIFY' | 'DELETE', event.path);
+    }
+    
+    this.isProcessing = false;
+  }
+
+  private async handleFileEvent(
+    eventType: 'ADD' | 'MODIFY' | 'DELETE', 
+    filePath: string
+  ): Promise<void> {
+    try {
+      const fileId = this.generateFileId(filePath);
+      const filename = path.basename(filePath);
+      const ext = path.extname(filePath).toLowerCase();
+
+      // Skip unsupported files
+      const supportedExts = ['.txt', '.md', '.json', '.ts', '.js', '.py', '.html', '.css', '.yaml', '.yml', '.xml', '.csv'];
+      if (!supportedExts.includes(ext)) return;
+
+      if (eventType === 'DELETE') {
+        this.documentCache.delete(fileId);
+        
+        if (neo4jService) {
+          await neo4jService.write(
+            `MATCH (f:File {id: $id}) DETACH DELETE f`, 
+            { id: fileId }
+          );
+        }
+        console.log(`🗑️ [KNOWLEDGE] Forgot file: ${filename}`);
+        return;
+      }
+
+      // 1. Read Content
+      const content = await fs.readFile(filePath, 'utf-8');
+      
+      // 2. Generate Vector Embedding (Cognitive Dark Matter)
+      const textForEmbedding = content.substring(0, 2000); // Limit for speed
+      const embedding = await vectorService.embedText(textForEmbedding);
+
+      // 3. Create compiled document
+      const doc: CompiledDocument = {
+        id: fileId,
+        name: filename,
+        path: filePath,
+        extension: ext,
+        size: content.length,
+        content: content.substring(0, 5000), // Store first 5KB
+        embedding,
+        lastModified: new Date(),
+        tags: this.extractTags(content, ext)
+      };
+
+      // 4. Cache locally
+      this.documentCache.set(fileId, doc);
+
+      // 5. Ingest into Neo4j if available
+      if (neo4jService) {
+        await neo4jService.write(`
+          MERGE (f:File {id: $id})
+          SET f.name = $name,
+              f.path = $path,
+              f.extension = $ext,
+              f.size = $size,
+              f.lastModified = datetime(),
+              f.contentPreview = $preview
+          
+          // Link to Directory
+          MERGE (d:Directory {path: $dirPath})
+          MERGE (f)-[:LOCATED_IN]->(d)
+          
+          // Auto-Tagging based on extension
+          MERGE (t:Tag {name: $ext})
+          MERGE (f)-[:TAGGED]->(t)
+        `, {
+          id: fileId,
+          name: filename,
+          path: filePath,
+          dirPath: path.dirname(filePath),
+          ext: ext,
+          size: content.length,
+          preview: content.substring(0, 500)
+        });
+      }
+
+      console.log(`✨ [KNOWLEDGE] Assimilated: ${filename} (${eventType})`);
+      
+      if (metricsService) {
+        metricsService.incrementCounter('knowledge_files_ingested');
+      }
+    } catch (error) {
+      console.error(`📚 [KNOWLEDGE] Error processing ${filePath}:`, error);
+    }
+  }
+
+  private extractTags(content: string, ext: string): string[] {
+    const tags: string[] = [ext];
+    
+    // Extract hashtags
+    const hashtags = content.match(/#\w+/g) || [];
+    tags.push(...hashtags.map(t => t.toLowerCase()));
+    
+    // Detect language/framework
+    if (content.includes('import React')) tags.push('react');
+    if (content.includes('from fastapi')) tags.push('fastapi');
+    if (content.includes('async function')) tags.push('async');
+    if (content.includes('class ')) tags.push('oop');
+    
+    return [...new Set(tags)];
+  }
+
+  private generateFileId(filePath: string): string {
+    return crypto.createHash('md5').update(filePath).digest('hex');
+  }
+
+  // Public API for querying
+  public async searchSimilar(query: string, topK: number = 5): Promise<CompiledDocument[]> {
+    const items = Array.from(this.documentCache.values()).map(doc => ({
+      id: doc.id,
+      embedding: doc.embedding
+    }));
+
+    const results = await vectorService.findSimilar(query, items, topK);
+    
+    return results
+      .map(r => this.documentCache.get(r.id))
+      .filter((d): d is CompiledDocument => d !== undefined);
+  }
+
+  public getDocument(id: string): CompiledDocument | undefined {
+    return this.documentCache.get(id);
+  }
+
+  public getAllDocuments(): CompiledDocument[] {
+    return Array.from(this.documentCache.values());
+  }
+
+  public getStats() {
+    return {
+      totalDocuments: this.documentCache.size,
+      queueLength: this.eventQueue.length,
+      isProcessing: this.isProcessing
+    };
+  }
+
+  public async stop(): Promise<void> {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.processingInterval) {
+      clearInterval(this.processingInterval);
+      this.processingInterval = null;
+    }
+    console.log('📚 [NEURAL] Compiler Stopped');
+  }
+}
+
+export const neuralCompiler = NeuralCompiler.getInstance();

apps/backend/src/services/Prometheus.ts

@@ -0,0 +1,267 @@
+// 🔥 PROMETHEUS ENGINE: Autonomous Evolution
+// Point 7: Autonomous Paradigm Discovery
+// The system that writes its own code. Handle with care.
+
+import fs from 'fs/promises';
+import path from 'path';
+import { neuralBus } from './NeuralBus.js';
+
+interface CodeProposal {
+  id: string;
+  filePath: string;
+  description: string;
+  currentCode: string;
+  proposedCode?: string;
+  status: 'PROPOSED' | 'APPROVED' | 'REJECTED' | 'APPLIED';
+  createdAt: Date;
+  confidence: number;
+}
+
+interface ScanResult {
+  file: string;
+  issues: string[];
+  suggestions: string[];
+  metrics: {
+    lines: number;
+    functions: number;
+    complexity: number;
+  };
+}
+
+export class PrometheusEngine {
+  private static instance: PrometheusEngine;
+  private proposals: Map<string, CodeProposal> = new Map();
+  private scanResults: ScanResult[] = [];
+  private isScanning = false;
+  private godMode = false; // Set to true to allow auto-apply
+
+  private constructor() {
+    console.log('🔥 [PROMETHEUS] Autonomous Evolution Engine Online');
+    console.log('🔥 [PROMETHEUS] God Mode:', this.godMode ? 'ENABLED' : 'DISABLED');
+  }
+
+  public static getInstance(): PrometheusEngine {
+    if (!PrometheusEngine.instance) {
+      PrometheusEngine.instance = new PrometheusEngine();
+    }
+    return PrometheusEngine.instance;
+  }
+
+  /**
+   * Scan directory for code improvements
+   */
+  public async scanAndPropose(dirPath: string): Promise<ScanResult[]> {
+    if (this.isScanning) {
+      console.log('🔥 [PROMETHEUS] Scan already in progress');
+      return [];
+    }
+
+    this.isScanning = true;
+    this.scanResults = [];
+
+    try {
+      console.log(`🔥 [PROMETHEUS] Scanning: ${dirPath}`);
+      await this.scanDirectory(dirPath);
+      console.log(`🔥 [PROMETHEUS] Scan complete. Found ${this.scanResults.length} files`);
+      
+      neuralBus.emitThought('PROMETHEUS', `Code scan complete: ${this.scanResults.length} files analyzed`, {
+        issues: this.scanResults.reduce((acc, r) => acc + r.issues.length, 0),
+        suggestions: this.scanResults.reduce((acc, r) => acc + r.suggestions.length, 0)
+      }, 'INFO');
+
+      return this.scanResults;
+    } finally {
+      this.isScanning = false;
+    }
+  }
+
+  private async scanDirectory(dirPath: string, depth: number = 0): Promise<void> {
+    if (depth > 5) return; // Max depth
+
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+
+        // Skip node_modules, dist, etc
+        if (entry.isDirectory()) {
+          if (!['node_modules', 'dist', '.git', 'coverage'].includes(entry.name)) {
+            await this.scanDirectory(fullPath, depth + 1);
+          }
+        } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
+          await this.analyzeFile(fullPath);
+        }
+      }
+    } catch (error) {
+      // Directory access error
+    }
+  }
+
+  private async analyzeFile(filePath: string): Promise<void> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      
+      const result: ScanResult = {
+        file: filePath,
+        issues: [],
+        suggestions: [],
+        metrics: {
+          lines: lines.length,
+          functions: (content.match(/function\s+\w+|=>\s*{|async\s+\w+/g) || []).length,
+          complexity: this.calculateComplexity(content)
+        }
+      };
+
+      // Rule 1: Console.log without metrics
+      if (content.includes('console.log') && !content.includes('metricsService')) {
+        result.suggestions.push('Replace console.log with metricsService for production monitoring');
+        this.createProposal(filePath, 'Replace logging with metrics', content, 0.7);
+      }
+
+      // Rule 2: Hardcoded strings that should be config
+      const hardcodedUrls = content.match(/['"]https?:\/\/[^'"]+['"]/g) || [];
+      if (hardcodedUrls.length > 2) {
+        result.issues.push(`Found ${hardcodedUrls.length} hardcoded URLs - consider using config`);
+      }
+
+      // Rule 3: Missing error handling
+      if (content.includes('await ') && !content.includes('catch')) {
+        result.suggestions.push('Add try/catch blocks around async operations');
+      }
+
+      // Rule 4: Long functions
+      const functionMatches = content.match(/(?:async\s+)?function\s+\w+[^{]*\{[\s\S]*?\n\}/g) || [];
+      for (const fn of functionMatches) {
+        if (fn.split('\n').length > 50) {
+          result.issues.push('Function exceeds 50 lines - consider refactoring');
+        }
+      }
+
+      // Rule 5: TODO/FIXME comments
+      const todos = (content.match(/\/\/\s*(TODO|FIXME|HACK|XXX):/gi) || []).length;
+      if (todos > 0) {
+        result.issues.push(`Found ${todos} TODO/FIXME comments`);
+      }
+
+      // Rule 6: Magic numbers
+      const magicNumbers = content.match(/[^a-zA-Z0-9_](\d{4,})[^a-zA-Z0-9_]/g) || [];
+      if (magicNumbers.length > 3) {
+        result.suggestions.push('Consider extracting magic numbers to named constants');
+      }
+
+      // Rule 7: Unused imports (simplified check)
+      const importMatches = content.match(/import\s+{?\s*([^}]+)\s*}?\s+from/g) || [];
+      for (const imp of importMatches) {
+        const imported = imp.match(/import\s+{?\s*([^}]+)\s*}?\s+from/)?.[1] || '';
+        const names = imported.split(',').map(n => n.trim().split(' as ')[0].trim());
+        for (const name of names) {
+          if (name && !content.slice(content.indexOf(imp) + imp.length).includes(name)) {
+            result.suggestions.push(`Potentially unused import: ${name}`);
+          }
+        }
+      }
+
+      if (result.issues.length > 0 || result.suggestions.length > 0) {
+        this.scanResults.push(result);
+      }
+    } catch (error) {
+      // File read error
+    }
+  }
+
+  private calculateComplexity(content: string): number {
+    // Simplified cyclomatic complexity
+    let complexity = 1;
+    complexity += (content.match(/if\s*\(/g) || []).length;
+    complexity += (content.match(/else\s*{/g) || []).length;
+    complexity += (content.match(/for\s*\(/g) || []).length;
+    complexity += (content.match(/while\s*\(/g) || []).length;
+    complexity += (content.match(/case\s+/g) || []).length;
+    complexity += (content.match(/\?\s*[^:]+:/g) || []).length; // Ternary
+    return complexity;
+  }
+
+  private createProposal(filePath: string, description: string, currentCode: string, confidence: number): void {
+    const id = `proposal_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    
+    const proposal: CodeProposal = {
+      id,
+      filePath,
+      description,
+      currentCode: currentCode.substring(0, 500), // Preview only
+      status: 'PROPOSED',
+      createdAt: new Date(),
+      confidence
+    };
+
+    this.proposals.set(id, proposal);
+
+    console.log(`🔥 [PROMETHEUS] Proposal Created: ${description} (${path.basename(filePath)})`);
+    
+    neuralBus.emitThought('PROMETHEUS', `New code proposal: ${description}`, {
+      proposalId: id,
+      file: path.basename(filePath),
+      confidence
+    }, 'WARNING');
+  }
+
+  /**
+   * Apply a proposal (God Mode only)
+   */
+  public async applyProposal(proposalId: string): Promise<boolean> {
+    if (!this.godMode) {
+      console.warn('🔥 [PROMETHEUS] God Mode disabled - cannot apply proposals');
+      return false;
+    }
+
+    const proposal = this.proposals.get(proposalId);
+    if (!proposal || proposal.status !== 'PROPOSED') {
+      return false;
+    }
+
+    // In a real implementation, this would:
+    // 1. Generate improved code via LLM
+    // 2. Create backup
+    // 3. Apply changes
+    // 4. Run tests
+    // 5. Rollback if tests fail
+
+    proposal.status = 'APPLIED';
+    console.log(`🔥 [PROMETHEUS] Proposal Applied: ${proposalId}`);
+    
+    return true;
+  }
+
+  public enableGodMode(enabled: boolean): void {
+    this.godMode = enabled;
+    console.log(`🔥 [PROMETHEUS] God Mode: ${enabled ? 'ENABLED' : 'DISABLED'}`);
+    
+    neuralBus.emitThought('PROMETHEUS', `God Mode ${enabled ? 'enabled' : 'disabled'}`, {}, 
+      enabled ? 'WARNING' : 'INFO');
+  }
+
+  // Public getters
+  public getProposals(): CodeProposal[] {
+    return Array.from(this.proposals.values());
+  }
+
+  public getScanResults(): ScanResult[] {
+    return this.scanResults;
+  }
+
+  public getStats() {
+    return {
+      isScanning: this.isScanning,
+      godMode: this.godMode,
+      proposals: this.proposals.size,
+      pendingProposals: Array.from(this.proposals.values()).filter(p => p.status === 'PROPOSED').length,
+      lastScanFiles: this.scanResults.length,
+      totalIssues: this.scanResults.reduce((acc, r) => acc + r.issues.length, 0),
+      totalSuggestions: this.scanResults.reduce((acc, r) => acc + r.suggestions.length, 0)
+    };
+  }
+}
+
+export const prometheus = PrometheusEngine.getInstance();

apps/backend/src/services/SelfHealingAdapter.ts

@@ -128,6 +128,52 @@ class SelfHealingAdapter {
     };
   }
 
+  /**
+   * 📊 Returns the overall system health and status of subsystems.
+   * Used by KnowledgeCompiler for the 'Health' knowledge node.
+   */
+  public getSystemStatus(): { overallHealth: string; services: { name: string; status: string }[] } {
+    const circuitBreakerCount = Array.from(this.circuitBreakers.values()).filter(v => v === true).length;
+    const overallHealth = circuitBreakerCount === 0 ? 'HEALTHY' : (circuitBreakerCount < 3 ? 'DEGRADED' : 'CRITICAL');
+
+    const services = [
+      { name: 'SelfHealingEngine', status: 'RUNNING' },
+      { name: 'CircuitBreakers', status: circuitBreakerCount > 0 ? 'ACTIVE' : 'IDLE' }
+    ];
+
+    // Add specific circuit breakers as "services" if they exist
+    this.circuitBreakers.forEach((isOpen, name) => {
+        services.push({ name: `Circuit:${name}`, status: isOpen ? 'BROKEN' : 'OK' });
+    });
+
+    return {
+      overallHealth,
+      services
+    };
+  }
+
+  /**
+   * 🔮 Generates predictive alerts based on error patterns.
+   * Used by KnowledgeCompiler.
+   */
+  public getPredictiveAlerts(): any[] {
+    // In a real implementation, this would analyze error frequencies from metricsService.
+    // For now, we return basic alerts if circuit breakers are open.
+    const alerts: any[] = [];
+    this.circuitBreakers.forEach((isOpen, name) => {
+      if (isOpen) {
+        alerts.push({
+          errorCode: 'CIRCUIT_OPEN',
+          severity: 'HIGH',
+          probability: 1.0,
+          expectedIn: 'NOW',
+          recommendation: `Check external dependency for ${name} immediately.`
+        });
+      }
+    });
+    return alerts;
+  }
+
   private diagnoseError(error: any): string {
     if (error.code === 'ECONNREFUSED') return 'CONNECTION_LOST';
     if (error.code === 'SessionExpired') return 'SESSION_EXPIRED';

apps/backend/src/services/VectorService.ts

@@ -0,0 +1,126 @@
+// 🌑 DARK MATTER: VectorService.ts
+// Ansvarlig for semantisk forståelse. Gør systemet i stand til at "føle" betydning.
+// Uses local ONNX model - No API keys. No cost. Pure silicon power.
+
+import { pipeline } from '@xenova/transformers';
+
+export class VectorService {
+  private static instance: VectorService;
+  private extractor: any = null;
+  private isInitializing = false;
+  private initPromise: Promise<void> | null = null;
+
+  private constructor() {
+    console.log('🌑 [DARK MATTER] Vector Engine Loading...');
+  }
+
+  public static getInstance(): VectorService {
+    if (!VectorService.instance) {
+      VectorService.instance = new VectorService();
+    }
+    return VectorService.instance;
+  }
+
+  /**
+   * Initializes the local AI model (ONNX).
+   * Model: all-MiniLM-L6-v2 (384 dimensions, fast, accurate)
+   */
+  public async init(): Promise<void> {
+    if (this.extractor) return;
+    
+    if (this.isInitializing && this.initPromise) {
+      return this.initPromise;
+    }
+
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      try {
+        // Use a small, fast model: all-MiniLM-L6-v2
+        this.extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+        console.log('🌑 [DARK MATTER] Neural Model Loaded (384 dimensions)');
+      } catch (error) {
+        console.error('🌑 [DARK MATTER] Failed to load model:', error);
+        throw error;
+      } finally {
+        this.isInitializing = false;
+      }
+    })();
+
+    return this.initPromise;
+  }
+
+  /**
+   * Generate embedding vector for text
+   * @param text Input text to embed
+   * @returns 384-dimensional vector
+   */
+  public async embedText(text: string): Promise<number[]> {
+    await this.init();
+    
+    // Clean text
+    const cleanText = text.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+    if (!cleanText) return new Array(384).fill(0);
+
+    try {
+      // Generate embedding
+      const output = await this.extractor!(cleanText, { 
+        pooling: 'mean', 
+        normalize: true 
+      });
+      
+      // Convert Float32Array to regular array for Neo4j/storage
+      return Array.from(output.data as Float32Array);
+    } catch (error) {
+      console.error('🌑 [DARK MATTER] Embedding failed:', error);
+      return new Array(384).fill(0);
+    }
+  }
+
+  /**
+   * Compute cosine similarity between two vectors
+   */
+  public cosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) 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];
+    }
+    
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+
+  /**
+   * Find most similar items from a collection
+   */
+  public async findSimilar(
+    queryText: string, 
+    items: { id: string; embedding: number[] }[], 
+    topK: number = 5
+  ): Promise<{ id: string; similarity: number }[]> {
+    const queryEmbedding = await this.embedText(queryText);
+    
+    const scored = items.map(item => ({
+      id: item.id,
+      similarity: this.cosineSimilarity(queryEmbedding, item.embedding)
+    }));
+    
+    return scored
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, topK);
+  }
+
+  /**
+   * Batch embed multiple texts
+   */
+  public async embedBatch(texts: string[]): Promise<number[][]> {
+    return Promise.all(texts.map(t => this.embedText(t)));
+  }
+}
+
+export const vectorService = VectorService.getInstance();

apps/backend/src/services/colonizer-service.ts

@@ -1,10 +1,12 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { getLlmService, ChatMessage } from './llm/llmService.js';
 import { CODEX_VERSION } from '../config/codex.js';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// ESM/CJS compatible __dirname
+const __dirname = typeof import.meta !== 'undefined' && import.meta.url 
+  ? path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1'))
+  : process.cwd();
 
 /**
  * THE COLONIZER SERVICE

apps/backend/src/services/embeddings/LocalGPUEmbeddings.ts

@@ -1,11 +1,12 @@
 import { spawn, ChildProcess } from 'child_process';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { EmbeddingProvider } from './EmbeddingService.js';
 import { logger } from '../../utils/logger.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+// ESM/CJS compatible __dirname
+const __dirname = typeof import.meta !== 'undefined' && import.meta.url 
+  ? path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1'))
+  : __dirname || process.cwd();
 
 export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
   name = 'local-gpu';

monitor_runtime.py

@@ -0,0 +1,98 @@
+"""
+WidgeTDC Cortex - Runtime Log Monitor
+Monitors HF Space logs in real-time to verify system health
+"""
+import time
+import requests
+from huggingface_hub import HfApi
+
+# Configuration
+SPACE_NAME = "widgetdc-cortex"
+USERNAME = "Kraft102"
+REPO_ID = f"{USERNAME}/{SPACE_NAME}"
+SPACE_URL = f"https://{USERNAME.lower()}-{SPACE_NAME}.hf.space"
+
+print("=" * 70)
+print("  WIDGETTDC CORTEX - RUNTIME LOG MONITOR")
+print("=" * 70)
+print()
+
+# Initialize API
+api = HfApi()
+
+def check_build_status():
+    """Check if Space is running"""
+    try:
+        runtime = api.get_space_runtime(repo_id=REPO_ID)
+        return runtime.stage, runtime.hardware
+    except Exception as e:
+        return "UNKNOWN", None
+
+def test_health_endpoint():
+    """Test /health endpoint"""
+    try:
+        response = requests.get(f"{SPACE_URL}/health", timeout=10)
+        return response.status_code == 200, response.json() if response.status_code == 200 else None
+    except Exception as e:
+        return False, str(e)
+
+def monitor_runtime():
+    """Monitor runtime status and logs"""
+    
+    print("[1/4] Checking Space status...")
+    stage, hardware = check_build_status()
+    print(f"      Stage: {stage}")
+    print(f"      Hardware: {hardware}")
+    print()
+    
+    if stage == "RUNNING":
+        print("✅ Space is RUNNING!")
+        print()
+        
+        print("[2/4] Testing health endpoint...")
+        healthy, data = test_health_endpoint()
+        
+        if healthy:
+            print(f"✅ Health check PASSED!")
+            print(f"      Response: {data}")
+        else:
+            print(f"❌ Health check FAILED!")
+            print(f"      Error: {data}")
+        print()
+        
+        print("[3/4] Testing API endpoints...")
+        # Test MCP route
+        try:
+            response = requests.post(
+                f"{SPACE_URL}/api/mcp/route",
+                json={"method": "initialize", "params": {}},
+                timeout=10
+            )
+            print(f"      MCP Route: {response.status_code}")
+        except Exception as e:
+            print(f"      MCP Route: ERROR - {e}")
+        print()
+        
+        print("[4/4] System Health Summary:")
+        print("      🟢 Space: RUNNING")
+        print(f"      {'🟢' if healthy else '🔴'} Health: {'OK' if healthy else 'FAILED'}")
+        print(f"      🔵 URL: {SPACE_URL}")
+        
+    elif stage == "BUILDING":
+        print("⏳ Space is still BUILDING...")
+        print("   Run this script again in 1-2 minutes")
+        
+    elif stage == "BUILD_ERROR":
+        print("❌ Space has BUILD_ERROR!")
+        print("   Check logs at:")
+        print(f"   https://huggingface.co/spaces/{REPO_ID}/logs")
+        
+    else:
+        print(f"⚠️  Unknown status: {stage}")
+
+if __name__ == "__main__":
+    monitor_runtime()
+    print()
+    print("=" * 70)
+    print("  MONITORING COMPLETE")
+    print("=" * 70)

package.json

@@ -5,6 +5,7 @@
   "private": true,
   "workspaces": [
     "apps/backend",
+    "apps/matrix-frontend",
     "packages/*"
   ],
   "scripts": {
@@ -58,6 +59,7 @@
     "@vitejs/plugin-react": "^5.1.1",
     "@vitest/ui": "^4.0.8",
     "concurrently": "^8.2.2",
+    "esbuild": "^0.24.0",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-react": "^7.37.5",