Initial deployment - WidgeTDC Cortex Backend v2.1.0

.env.example

@@ -0,0 +1,6 @@
+OPENAI_API_KEY=sk-...
+NEO4J_URI=neo4j+s://...
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=...
+DATABASE_URL=postgresql://...
+PORT=7860

Dockerfile

@@ -0,0 +1,98 @@
+# WidgeTDC Backend - Hugging Face Spaces Deployment
+# Optimized for HF Docker Spaces (port 7860)
+#
+# Usage: Copy entire project to HF Space repo, then push
+
+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/*
+
+WORKDIR /app
+
+# Copy package files
+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/
+
+# Install dependencies
+RUN npm ci --include=dev
+
+# Copy source
+COPY packages/ ./packages/
+COPY apps/backend/ ./apps/backend/
+
+# Build packages in order
+RUN cd packages/domain-types && npm run build
+RUN cd packages/mcp-types && npm run build
+
+# Generate Prisma client (if schema exists)
+RUN if [ -f apps/backend/prisma/schema.prisma ]; then \
+        cd apps/backend && npx prisma generate; \
+    fi
+
+# Build backend
+RUN cd apps/backend && npm run build
+
+# ============================================
+# 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
+
+# Copy built artifacts with correct ownership
+COPY --from=builder --chown=user /app/package*.json ./
+COPY --from=builder --chown=user /app/node_modules ./node_modules
+COPY --from=builder --chown=user /app/packages/domain-types/dist ./packages/domain-types/dist
+COPY --from=builder --chown=user /app/packages/domain-types/package.json ./packages/domain-types/
+COPY --from=builder --chown=user /app/packages/mcp-types/dist ./packages/mcp-types/dist
+COPY --from=builder --chown=user /app/packages/mcp-types/package.json ./packages/mcp-types/
+COPY --from=builder --chown=user /app/apps/backend/dist ./apps/backend/dist
+COPY --from=builder --chown=user /app/apps/backend/package.json ./apps/backend/
+
+# Copy Prisma client if generated
+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
+
+# 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
+
+# Environment for HF Spaces
+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
+
+WORKDIR /app/apps/backend
+
+# 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"]

README.md

@@ -0,0 +1,19 @@
+---
+title: WidgeTDC Cortex Backend
+emoji: 🧠
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+license: MIT
+app_port: 7860
+---
+
+# WidgeTDC Cortex Backend
+
+Enterprise-grade autonomous intelligence platform.
+
+## Endpoints
+- GET /health
+- POST /api/mcp/route
+- WS /mcp/ws

apps/backend/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@widget-tdc/backend",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "neural-bridge": "tsx src/mcp/servers/NeuralBridgeServer.ts",
+    "neural-bridge:build": "tsc && node dist/mcp/servers/NeuralBridgeServer.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.0",
+    "@google/generative-ai": "^0.4.0",
+    "@huggingface/inference": "^4.13.3",
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "@opensearch-project/opensearch": "^3.5.1",
+    "@prisma/client": "^5.22.0",
+    "@types/geoip-lite": "^1.4.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/pdf-parse": "^1.1.5",
+    "@types/systeminformation": "^3.23.1",
+    "@widget-tdc/domain-types": "file:./packages/domain-types",
+    "@widget-tdc/mcp-types": "file:./packages/mcp-types",
+    "@xenova/transformers": "^2.17.2",
+    "axios": "^1.6.5",
+    "cheerio": "^1.0.0",
+    "chromadb": "^3.1.6",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^4.18.2",
+    "express-rate-limit": "^8.2.1",
+    "geoip-lite": "^1.4.10",
+    "gpt-3-encoder": "^1.1.4",
+    "helmet": "^8.1.0",
+    "imap": "^0.8.19",
+    "ioredis": "^5.3.2",
+    "js-yaml": "^4.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "jszip": "^3.10.1",
+    "mailparser": "^3.6.9",
+    "minio": "^8.0.6",
+    "multer": "^1.4.5-lts.1",
+    "neo4j-driver": "^6.0.1",
+    "node-cron": "^3.0.3",
+    "openai": "^4.73.0",
+    "pdf-parse": "^2.4.5",
+    "pdfjs-dist": "^5.4.449",
+    "pg": "^8.16.3",
+    "pptxgenjs": "^3.12.0",
+    "prisma": "^5.22.0",
+    "puppeteer": "^24.32.0",
+    "redis": "^5.10.0",
+    "sharp": "^0.32.6",
+    "sql.js": "^1.8.0",
+    "systeminformation": "^5.27.11",
+    "testcontainers": "^11.8.1",
+    "uuid": "^9.0.1",
+    "winston": "^3.18.3",
+    "ws": "^8.14.2",
+    "xml2js": "^0.6.2",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/imap": "^0.8.40",
+    "@types/ioredis": "^4.28.10",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/jszip": "^3.4.0",
+    "@types/mailparser": "^3.4.4",
+    "@types/multer": "^1.4.12",
+    "@types/node": "^20.10.6",
+    "@types/node-cron": "^3.0.11",
+    "@types/pg": "^8.16.0",
+    "@types/uuid": "^9.0.7",
+    "@types/ws": "^8.5.10",
+    "@types/xml2js": "^0.4.14",
+    "tsx": "^4.20.6",
+    "typescript": "~5.8.2"
+  }
+}

apps/backend/prisma/prisma.config.ts

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import type { PrismaConfig } from 'prisma';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { Pool } from 'pg';
+
+// Create a PostgreSQL connection pool
+const connectionString = process.env.DATABASE_URL || 'postgresql://widgetdc:widgetdc_dev@localhost:5433/widgetdc';
+
+const pool = new Pool({ connectionString });
+
+export default {
+  earlyAccess: true,
+  schema: path.join(__dirname, 'schema.prisma'),
+
+  // Database migration connection (for prisma migrate)
+  migrate: {
+    adapter: async () => new PrismaPg(pool)
+  }
+} satisfies PrismaConfig;

apps/backend/prisma/schema.prisma

@@ -0,0 +1,410 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+  binaryTargets = ["native"]
+  engineType = "binary"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+// NOTE: Vector embeddings are stored in Neo4j, not PostgreSQL
+// This schema handles relational data only
+
+// ============================================
+// UI State & Configuration
+// ============================================
+
+model Widget {
+  id            String   @id @default(uuid())
+  name          String
+  type          String
+  config        Json?
+  active        Boolean  @default(true)
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  @@map("widgets")
+}
+
+model Layout {
+  id            String   @id @default(uuid())
+  userId        String
+  orgId         String
+  layoutData    Json
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  @@unique([userId, orgId])
+  @@map("layouts")
+}
+
+// ============================================
+// Memory & Knowledge Graph
+// ============================================
+
+model MemoryEntity {
+  id            Int      @id @default(autoincrement())
+  orgId         String   @map("org_id")
+  userId        String?  @map("user_id")
+  entityType    String   @map("entity_type")
+  content       String
+  importance    Int      @default(3)
+  createdAt     DateTime @default(now()) @map("created_at")
+
+  tags          MemoryTag[]
+  relationsFrom MemoryRelation[] @relation("SourceEntity")
+  relationsTo   MemoryRelation[] @relation("TargetEntity")
+
+  @@index([orgId, userId])
+  @@index([entityType])
+  @@map("memory_entities")
+}
+
+model MemoryRelation {
+  id            Int      @id @default(autoincrement())
+  orgId         String   @map("org_id")
+  sourceId      Int      @map("source_id")
+  targetId      Int      @map("target_id")
+  relationType  String   @map("relation_type")
+  createdAt     DateTime @default(now()) @map("created_at")
+
+  source        MemoryEntity @relation("SourceEntity", fields: [sourceId], references: [id], onDelete: Cascade)
+  target        MemoryEntity @relation("TargetEntity", fields: [targetId], references: [id], onDelete: Cascade)
+
+  @@index([sourceId])
+  @@index([targetId])
+  @@index([orgId])
+  @@map("memory_relations")
+}
+
+model MemoryTag {
+  id            Int      @id @default(autoincrement())
+  entityId      Int      @map("entity_id")
+  tag           String
+  createdAt     DateTime @default(now()) @map("created_at")
+
+  entity        MemoryEntity @relation(fields: [entityId], references: [id], onDelete: Cascade)
+
+  @@index([tag])
+  @@index([entityId])
+  @@map("memory_tags")
+}
+
+// ============================================
+// PAL (Personal Assistant Layer)
+// ============================================
+
+model PalUserProfile {
+  id              Int      @id @default(autoincrement())
+  userId          String   @map("user_id")
+  orgId           String   @map("org_id")
+  preferenceTone  String   @default("neutral") @map("preference_tone")
+  createdAt       DateTime @default(now()) @map("created_at")
+  updatedAt       DateTime @default(now()) @updatedAt @map("updated_at")
+
+  @@unique([userId, orgId])
+  @@map("pal_user_profiles")
+}
+
+model PalFocusWindow {
+  id            Int      @id @default(autoincrement())
+  userId        String   @map("user_id")
+  orgId         String   @map("org_id")
+  weekday       Int
+  startHour     Int      @map("start_hour")
+  endHour       Int      @map("end_hour")
+  createdAt     DateTime @default(now()) @map("created_at")
+
+  @@index([userId, orgId])
+  @@map("pal_focus_windows")
+}
+
+model PalEvent {
+  id                  Int      @id @default(autoincrement())
+  userId              String   @map("user_id")
+  orgId               String   @map("org_id")
+  eventType           String   @map("event_type")
+  payload             Json
+  detectedStressLevel Int?     @map("detected_stress_level")
+  createdAt           DateTime @default(now()) @map("created_at")
+
+  @@index([userId, orgId])
+  @@index([eventType])
+  @@map("pal_events")
+}
+
+// ============================================
+// SRAG (Structured RAG)
+// ============================================
+
+model RawDocument {
+  id            Int      @id @default(autoincrement())
+  orgId         String   @map("org_id")
+  sourceType    String   @map("source_type")
+  sourcePath    String   @map("source_path")
+  content       String
+  createdAt     DateTime @default(now()) @map("created_at")
+
+  facts         StructuredFact[]
+
+  @@index([orgId])
+  @@map("raw_documents")
+}
+
+model StructuredFact {
+  id            Int       @id @default(autoincrement())
+  orgId         String    @map("org_id")
+  docId         Int?      @map("doc_id")
+  factType      String    @map("fact_type")
+  jsonPayload   Json      @map("json_payload")
+  occurredAt    DateTime? @map("occurred_at")
+  createdAt     DateTime  @default(now()) @map("created_at")
+
+  document      RawDocument? @relation(fields: [docId], references: [id], onDelete: SetNull)
+
+  @@index([orgId])
+  @@index([factType])
+  @@map("structured_facts")
+}
+
+// ============================================
+// Document Metadata (vectors stored in Neo4j)
+// ============================================
+
+model VectorDocument {
+  id            String                 @id @default(uuid())
+  content       String
+  // NOTE: Embeddings are stored in Neo4j, not here
+  metadata      Json?
+  namespace     String                 @default("default")
+  userId        String
+  orgId         String
+  createdAt     DateTime               @default(now())
+  updatedAt     DateTime               @updatedAt
+
+  @@index([namespace])
+  @@index([userId, orgId])
+  @@map("vector_documents")
+}
+
+// ============================================
+// Autonomous Agent & Tasks
+// ============================================
+
+model AgentTask {
+  id            String   @id @default(uuid())
+  type          String
+  payload       Json
+  status        String   @default("pending") // pending, running, completed, failed, waiting_approval
+  priority      Int      @default(50)
+  result        Json?
+  error         String?
+  userId        String   @default("system")
+  orgId         String   @default("default")
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+  completedAt   DateTime?
+
+  @@index([status])
+  @@index([priority])
+  @@index([userId, orgId])
+  @@map("agent_tasks")
+}
+
+model ExecutionLog {
+  id            String   @id @default(uuid())
+  taskId        String?
+  taskType      String
+  success       Boolean
+  duration      Int?     // milliseconds
+  result        Json?
+  error         String?
+  userId        String   @default("system")
+  orgId         String   @default("default")
+  createdAt     DateTime @default(now())
+
+  @@index([taskType])
+  @@index([createdAt])
+  @@index([userId, orgId])
+  @@map("execution_logs")
+}
+
+// ============================================
+// Data Sources & Ingestion
+// ============================================
+
+model DataSource {
+  id            String   @id @default(uuid())
+  name          String   @unique
+  type          String
+  description   String?
+  enabled       Boolean  @default(false)
+  requiresApproval Boolean @default(true)
+  config        Json?
+  lastUsedAt    DateTime?
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  @@map("data_sources")
+}
+
+model IngestedDocument {
+  id            String   @id @default(uuid())
+  sourceId      String
+  externalId    String
+  title         String?
+  content       String?
+  metadata      Json?
+  userId        String
+  orgId         String
+  ingestedAt    DateTime @default(now())
+
+  @@unique([sourceId, externalId])
+  @@index([userId, orgId])
+  @@map("ingested_documents")
+}
+
+// ============================================
+// MCP Resources & Prompts
+// ============================================
+
+model MCPResource {
+  id            String   @id @default(uuid())
+  uri           String   @unique
+  name          String
+  description   String?
+  mimeType      String?
+  payload       Json
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  @@map("mcp_resources")
+}
+
+model AgentPrompt {
+  id            String   @id @default(uuid())
+  agentId       String
+  version       Int
+  promptText    String
+  active        Boolean  @default(true)
+  performance   Json?    // KPIs, metrics
+  createdAt     DateTime @default(now())
+
+  @@unique([agentId, version])
+  @@map("agent_prompts")
+}
+
+// ============================================
+// Security search + activity
+// ============================================
+
+model SecuritySearchTemplate {
+  id          String   @id
+  name        String
+  description String
+  query       String
+  severity    String
+  timeframe   String
+  sources     Json
+  createdAt   DateTime @default(now()) @map("created_at")
+
+  @@map("security_search_templates")
+}
+
+model SecuritySearchHistory {
+  id         String   @id
+  query      String
+  severity   String
+  timeframe  String
+  sources    Json
+  results    Int       @map("results_count")
+  latencyMs  Int       @map("latency_ms")
+  createdAt  DateTime  @default(now()) @map("created_at")
+
+  @@map("security_search_history")
+}
+
+model SecurityActivityEvent {
+  id           String   @id
+  title        String
+  description  String
+  category     String
+  severity     String
+  source       String
+  rule         String?
+  channel      String
+  payload      Json?
+  createdAt    DateTime @default(now()) @map("created_at")
+  acknowledged Boolean  @default(false)
+
+  @@map("security_activity_events")
+}
+
+// ============================================
+// Widget permissions
+// ============================================
+
+model WidgetPermission {
+  widgetId     String  @map("widget_id")
+  resourceType String  @map("resource_type")
+  accessLevel  String  @map("access_level")
+  override     Boolean @default(false)
+
+  @@id([widgetId, resourceType])
+  @@map("widget_permissions")
+}
+
+// ============================================
+// PRD Prototypes
+// ============================================
+
+model Prototype {
+  id            String   @id @default(uuid())
+  name          String
+  htmlContent   String
+  prdId         String?
+  version       Int      @default(1)
+  style         String   @default("modern")
+  status        String   @default("complete") // generating, complete, error
+  metadata      Json?
+  userId        String   @default("system")
+  orgId         String   @default("default")
+  createdAt     DateTime @default(now())
+  updatedAt     DateTime @updatedAt
+
+  @@unique([name, userId, orgId])
+  @@index([userId, orgId])
+  @@index([prdId])
+  @@map("prototypes")
+}
+
+// ============================================
+// Notes (migrated from sql.js)
+// ============================================
+
+model Note {
+  id            Int      @id @default(autoincrement())
+  userId        String   @map("user_id")
+  orgId         String   @map("org_id")
+  source        String
+  title         String
+  body          String
+  tags          String   @default("")
+  owner         String
+  compliance    String   @default("clean")  // clean, review, restricted
+  retention     String   @default("90d")    // 30d, 90d, 1y, archive
+  riskScore     Int      @default(0) @map("risk_score")
+  attachments   Int      @default(0)
+  createdAt     DateTime @default(now()) @map("created_at")
+  updatedAt     DateTime @default(now()) @updatedAt @map("updated_at")
+
+  @@index([userId, orgId])
+  @@index([source])
+  @@index([compliance])
+  @@map("notes")
+}

apps/backend/src/adapters/Neo4jAdapter.ts

@@ -0,0 +1,477 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════════════════╗
+ * ║                    NEO4J ADAPTER - SYNAPTIC CORTEX                        ║
+ * ║═══════════════════════════════════════════════════════════════════════════║
+ * ║  Graph-Native connection layer for WidgeTDC knowledge graph               ║
+ * ║                                                                           ║
+ * ║  CODEX RULE #3: Self-Healing & Robustness                                 ║
+ * ║  - Automatic reconnection on failure                                      ║
+ * ║  - Circuit breaker pattern                                                ║
+ * ║  - Health monitoring                                                      ║
+ * ╚═══════════════════════════════════════════════════════════════════════════╝
+ */
+
+import neo4j, { Driver, Session, QueryResult, Record as Neo4jRecord } from 'neo4j-driver';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface Neo4jConfig {
+    uri: string;
+    user: string;
+    password: string;
+    database?: string;
+}
+
+export interface QueryOptions {
+    timeout?: number;
+    database?: string;
+    readOnly?: boolean;
+}
+
+export interface HealthStatus {
+    connected: boolean;
+    latencyMs?: number;
+    nodeCount?: number;
+    relationshipCount?: number;
+    lastCheck: string;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Neo4j Adapter - Singleton Pattern
+// ═══════════════════════════════════════════════════════════════════════════
+
+class Neo4jAdapter {
+    private static instance: Neo4jAdapter;
+    private driver: Driver | null = null;
+    private _isConnected: boolean = false;
+    private lastHealthCheck: HealthStatus | null = null;
+
+    // Public getter for connection status
+    public get connected(): boolean {
+        return this._isConnected;
+    }
+
+    // Circuit breaker state
+    private failureCount: number = 0;
+    private readonly failureThreshold: number = 5;
+    private lastFailureTime: number = 0;
+    private readonly resetTimeoutMs: number = 60000;
+
+    // Connection config
+    private config: Neo4jConfig;
+
+    private constructor() {
+        this.config = {
+            uri: process.env.NEO4J_URI || 'bolt://localhost:7687',
+            user: process.env.NEO4J_USER || 'neo4j',
+            password: process.env.NEO4J_PASSWORD || 'password',
+            database: process.env.NEO4J_DATABASE || 'neo4j'
+        };
+
+        this.connect();
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Singleton Access
+    // ═══════════════════════════════════════════════════════════════════════
+
+    public static getInstance(): Neo4jAdapter {
+        if (!Neo4jAdapter.instance) {
+            Neo4jAdapter.instance = new Neo4jAdapter();
+        }
+        return Neo4jAdapter.instance;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Connection Management
+    // ═══════════════════════════════════════════════════════════════════════
+
+    private async connect(): Promise<boolean> {
+        try {
+            console.error(`[Neo4jAdapter] 🧠 Establishing synaptic link to ${this.config.uri}...`);
+
+            this.driver = neo4j.driver(
+                this.config.uri,
+                neo4j.auth.basic(this.config.user, this.config.password),
+                {
+                    maxConnectionPoolSize: 50,
+                    connectionAcquisitionTimeout: 30000,
+                    connectionTimeout: 20000,
+                }
+            );
+
+            // Verify connectivity
+            await this.driver.verifyConnectivity();
+            this._isConnected = true;
+            this.failureCount = 0;
+
+            console.error('[Neo4jAdapter] ✅ Synaptic link ESTABLISHED. Cortex is online.');
+            return true;
+
+        } catch (error: any) {
+            console.error('[Neo4jAdapter] ❌ CONNECTION FAILURE:', error.message);
+            this._isConnected = false;
+            this.failureCount++;
+            this.lastFailureTime = Date.now();
+            return false;
+        }
+    }
+
+    private async ensureConnection(): Promise<void> {
+        // Check circuit breaker
+        if (this.failureCount >= this.failureThreshold) {
+            const timeSinceFailure = Date.now() - this.lastFailureTime;
+            if (timeSinceFailure < this.resetTimeoutMs) {
+                throw new Error(`Neo4j Cortex circuit OPEN - ${Math.ceil((this.resetTimeoutMs - timeSinceFailure) / 1000)}s until retry`);
+            }
+            // Reset and try again
+            this.failureCount = 0;
+        }
+
+        if (!this.driver || !this._isConnected) {
+            const connected = await this.connect();
+            if (!connected) {
+                throw new Error('Neo4j Cortex Unreachable - connection failed');
+            }
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Query Execution
+    // ═══════════════════════════════════════════════════════════════════════
+
+    public async executeQuery(
+        cypher: string,
+        params: Record<string, any> = {},
+        options: QueryOptions = {}
+    ): Promise<any[]> {
+        await this.ensureConnection();
+
+        const session: Session = this.driver!.session({
+            database: options.database || this.config.database,
+            defaultAccessMode: options.readOnly ? neo4j.session.READ : neo4j.session.WRITE
+        });
+
+        const startTime = Date.now();
+
+        try {
+            const result: QueryResult = await session.run(cypher, params);
+            const latency = Date.now() - startTime;
+
+            console.error(`[Neo4jAdapter] ⚡ Query executed in ${latency}ms (${result.records.length} records)`);
+
+            return result.records.map((record: Neo4jRecord) => this.recordToObject(record));
+
+        } catch (error: any) {
+            this.failureCount++;
+            this.lastFailureTime = Date.now();
+
+            console.error(`[Neo4jAdapter] ❌ Query failed: ${error.message}`);
+            console.error(`[Neo4jAdapter] Cypher: ${cypher.substring(0, 100)}...`);
+
+            throw error;
+
+        } finally {
+            await session.close();
+        }
+    }
+
+    /**
+     * Execute a read-only query (optimized for replicas)
+     */
+    public async readQuery(
+        cypher: string,
+        params: Record<string, any> = {}
+    ): Promise<any[]> {
+        return this.executeQuery(cypher, params, { readOnly: true });
+    }
+
+    /**
+     * Execute a write query
+     */
+    public async writeQuery(
+        cypher: string,
+        params: Record<string, any> = {}
+    ): Promise<any[]> {
+        return this.executeQuery(cypher, params, { readOnly: false });
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // High-Level Operations
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Search nodes by label and properties
+     */
+    public async searchNodes(
+        label: string,
+        searchTerm: string,
+        limit: number = 20
+    ): Promise<any[]> {
+        const cypher = `
+            MATCH (n:${label})
+            WHERE n.name CONTAINS $searchTerm 
+               OR n.title CONTAINS $searchTerm
+               OR n.content CONTAINS $searchTerm
+            RETURN n
+            LIMIT $limit
+        `;
+        return this.readQuery(cypher, { searchTerm, limit: neo4j.int(limit) });
+    }
+
+    /**
+     * Get node by ID
+     */
+    public async getNodeById(nodeId: string): Promise<any | null> {
+        const cypher = `
+            MATCH (n)
+            WHERE n.id = $nodeId OR elementId(n) = $nodeId
+            RETURN n
+            LIMIT 1
+        `;
+        const results = await this.readQuery(cypher, { nodeId });
+        return results[0] || null;
+    }
+
+    /**
+     * Get node relationships
+     */
+    public async getNodeRelationships(
+        nodeId: string,
+        direction: 'in' | 'out' | 'both' = 'both',
+        limit: number = 50
+    ): Promise<any[]> {
+        let pattern: string;
+        switch (direction) {
+            case 'in':
+                pattern = '(n)<-[r]-(m)';
+                break;
+            case 'out':
+                pattern = '(n)-[r]->(m)';
+                break;
+            default:
+                pattern = '(n)-[r]-(m)';
+        }
+
+        const cypher = `
+            MATCH ${pattern}
+            WHERE n.id = $nodeId OR elementId(n) = $nodeId
+            RETURN type(r) as relationship, m as node, r as details
+            LIMIT $limit
+        `;
+        return this.readQuery(cypher, { nodeId, limit: neo4j.int(limit) });
+    }
+
+    /**
+     * Create or merge a node
+     */
+    public async createNode(
+        label: string,
+        properties: Record<string, any>
+    ): Promise<any> {
+        const cypher = `
+            MERGE (n:${label} {id: $id})
+            SET n += $properties
+            SET n.updatedAt = datetime()
+            RETURN n
+        `;
+
+        const id = properties.id || this.generateId(label, properties);
+        const results = await this.writeQuery(cypher, {
+            id,
+            properties: { ...properties, id }
+        });
+
+        return results[0];
+    }
+
+    /**
+     * Create a relationship between nodes
+     */
+    public async createRelationship(
+        fromId: string,
+        toId: string,
+        relationshipType: string,
+        properties: Record<string, any> = {}
+    ): Promise<any> {
+        const cypher = `
+            MATCH (a), (b)
+            WHERE (a.id = $fromId OR elementId(a) = $fromId)
+              AND (b.id = $toId OR elementId(b) = $toId)
+            MERGE (a)-[r:${relationshipType}]->(b)
+            SET r += $properties
+            SET r.createdAt = datetime()
+            RETURN a, r, b
+        `;
+
+        const results = await this.writeQuery(cypher, { fromId, toId, properties });
+        return results[0];
+    }
+
+    /**
+     * Delete a node by ID
+     */
+    public async deleteNode(nodeId: string): Promise<boolean> {
+        const cypher = `
+            MATCH (n)
+            WHERE n.id = $nodeId OR elementId(n) = $nodeId
+            DETACH DELETE n
+            RETURN count(n) as deleted
+        `;
+
+        const results = await this.writeQuery(cypher, { nodeId });
+        return (results[0]?.deleted || 0) > 0;
+    }
+
+    /**
+     * Alias for executeQuery - for compatibility
+     */
+    public async runQuery(
+        cypher: string,
+        params: Record<string, any> = {}
+    ): Promise<any[]> {
+        return this.executeQuery(cypher, params);
+    }
+
+    /**
+     * Alias for executeQuery - for compatibility
+     */
+    public async query(
+        cypher: string,
+        params: Record<string, any> = {}
+    ): Promise<any[]> {
+        return this.executeQuery(cypher, params);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Health & Monitoring
+    // ═══════════════════════════════════════════════════════════════════════
+
+    public async healthCheck(): Promise<HealthStatus> {
+        const startTime = Date.now();
+
+        try {
+            await this.ensureConnection();
+
+            // Get database stats
+            const [statsResult] = await this.readQuery(`
+                CALL apoc.meta.stats() YIELD nodeCount, relCount
+                RETURN nodeCount, relCount
+            `).catch(() => [{ nodeCount: -1, relCount: -1 }]);
+
+            const latency = Date.now() - startTime;
+
+            this.lastHealthCheck = {
+                connected: true,
+                latencyMs: latency,
+                nodeCount: statsResult?.nodeCount,
+                relationshipCount: statsResult?.relCount,
+                lastCheck: new Date().toISOString()
+            };
+
+            return this.lastHealthCheck;
+
+        } catch (error: any) {
+            this.lastHealthCheck = {
+                connected: false,
+                lastCheck: new Date().toISOString()
+            };
+            return this.lastHealthCheck;
+        }
+    }
+
+    public getLastHealthStatus(): HealthStatus | null {
+        return this.lastHealthCheck;
+    }
+
+    public isHealthy(): boolean {
+        return this._isConnected && this.failureCount < this.failureThreshold;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Cleanup
+    // ═══════════════════════════════════════════════════════════════════════
+
+    public async close(): Promise<void> {
+        if (this.driver) {
+            await this.driver.close();
+            this._isConnected = false;
+            console.error('[Neo4jAdapter] 🔌 Synaptic link severed.');
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // Helpers
+    // ═══════════════════════════════════════════════════════════════════════
+
+    private recordToObject(record: Neo4jRecord): any {
+        const obj: any = {};
+        record.keys.forEach((key) => {
+            const value = record.get(key);
+            obj[key] = this.convertNeo4jValue(value);
+        });
+        return obj;
+    }
+
+    private convertNeo4jValue(value: any): any {
+        if (value === null || value === undefined) {
+            return value;
+        }
+
+        // Neo4j Integer
+        if (neo4j.isInt(value)) {
+            return value.toNumber();
+        }
+
+        // Neo4j Node
+        if (value.labels && value.properties) {
+            return {
+                id: value.elementId || value.identity?.toString(),
+                labels: value.labels,
+                ...value.properties
+            };
+        }
+
+        // Neo4j Relationship
+        if (value.type && value.properties && value.start && value.end) {
+            return {
+                id: value.elementId || value.identity?.toString(),
+                type: value.type,
+                startNodeId: value.startNodeElementId || value.start?.toString(),
+                endNodeId: value.endNodeElementId || value.end?.toString(),
+                ...value.properties
+            };
+        }
+
+        // Arrays
+        if (Array.isArray(value)) {
+            return value.map(v => this.convertNeo4jValue(v));
+        }
+
+        // Objects
+        if (typeof value === 'object') {
+            const converted: any = {};
+            for (const key of Object.keys(value)) {
+                converted[key] = this.convertNeo4jValue(value[key]);
+            }
+            return converted;
+        }
+
+        return value;
+    }
+
+    private generateId(label: string, properties: Record<string, any>): string {
+        const crypto = require('crypto');
+        const content = `${label}:${properties.name || properties.title || JSON.stringify(properties)}`;
+        return crypto.createHash('md5').update(content).digest('hex');
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Export Singleton Instance
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const neo4jAdapter = Neo4jAdapter.getInstance();
+export { Neo4jAdapter };

apps/backend/src/api/approvals.ts

@@ -0,0 +1,166 @@
+import { Router } from 'express';
+import { hitlSystem } from '../platform/HumanInTheLoop';
+
+const router = Router();
+
+/**
+ * Get pending approvals
+ */
+router.get('/approvals', async (req, res) => {
+    try {
+        const { status, approver } = req.query;
+
+        let approvals;
+        if (status === 'pending') {
+            approvals = hitlSystem.getPendingApprovals(approver as string);
+        } else {
+            const filters: any = {};
+            if (status) filters.status = status;
+            approvals = hitlSystem.getAuditTrail(filters);
+        }
+
+        res.json({ approvals });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Get approval by ID
+ */
+router.get('/approvals/:id', async (req, res) => {
+    try {
+        const approval = hitlSystem.getApproval(req.params.id);
+
+        if (!approval) {
+            return res.status(404).json({ error: 'Approval not found' });
+        }
+
+        res.json({ approval });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Request approval
+ */
+router.post('/approvals/request', async (req, res) => {
+    try {
+        const { taskId, taskType, description, requestedBy, metadata } = req.body;
+
+        if (!taskId || !taskType || !description || !requestedBy) {
+            return res.status(400).json({ error: 'Missing required fields' });
+        }
+
+        const approval = await hitlSystem.requestApproval(
+            taskId,
+            taskType,
+            description,
+            requestedBy,
+            metadata || {}
+        );
+
+        res.json({ approval });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Approve a task
+ */
+router.post('/approvals/:id/approve', async (req, res) => {
+    try {
+        const { approvedBy } = req.body;
+
+        if (!approvedBy) {
+            return res.status(400).json({ error: 'approvedBy is required' });
+        }
+
+        const approval = await hitlSystem.approve(req.params.id, approvedBy);
+        res.json({ approval });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Reject a task
+ */
+router.post('/approvals/:id/reject', async (req, res) => {
+    try {
+        const { rejectedBy, reason } = req.body;
+
+        if (!rejectedBy || !reason) {
+            return res.status(400).json({ error: 'rejectedBy and reason are required' });
+        }
+
+        const approval = await hitlSystem.reject(req.params.id, rejectedBy, reason);
+        res.json({ approval });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Get approval statistics
+ */
+router.get('/approvals/stats', async (req, res) => {
+    try {
+        const stats = hitlSystem.getStatistics();
+        res.json({ stats });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Activate kill switch
+ */
+router.post('/kill-switch/activate', async (req, res) => {
+    try {
+        const { activatedBy, reason } = req.body;
+
+        if (!activatedBy || !reason) {
+            return res.status(400).json({ error: 'activatedBy and reason are required' });
+        }
+
+        hitlSystem.activateKillSwitch(activatedBy, reason);
+        res.json({ success: true, message: 'Kill switch activated' });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Deactivate kill switch
+ */
+router.post('/kill-switch/deactivate', async (req, res) => {
+    try {
+        const { deactivatedBy } = req.body;
+
+        if (!deactivatedBy) {
+            return res.status(400).json({ error: 'deactivatedBy is required' });
+        }
+
+        hitlSystem.deactivateKillSwitch(deactivatedBy);
+        res.json({ success: true, message: 'Kill switch deactivated' });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+/**
+ * Get kill switch status
+ */
+router.get('/kill-switch/status', async (req, res) => {
+    try {
+        const active = hitlSystem.isKillSwitchActive();
+        res.json({ active });
+    } catch (error) {
+        res.status(500).json({ error: String(error) });
+    }
+});
+
+export default router;

apps/backend/src/api/health.ts

@@ -0,0 +1,153 @@
+import { Router } from 'express';
+import { neo4jService } from '../database/Neo4jService';
+import { checkPrismaConnection, prisma } from '../database/prisma';
+
+const router = Router();
+
+/**
+ * Overall system health check
+ */
+router.get('/health', async (req, res) => {
+    const health = {
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        services: {
+            database: 'unknown',
+            neo4j: 'unknown',
+            redis: 'unknown',
+        },
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+    };
+
+    try {
+        // Check Prisma/PostgreSQL
+        const prismaHealthy = await checkPrismaConnection();
+        health.services.database = prismaHealthy ? 'healthy' : 'unhealthy';
+        if (!prismaHealthy) health.status = 'degraded';
+    } catch {
+        health.services.database = 'unhealthy';
+        health.status = 'degraded';
+    }
+
+    try {
+        // Check Neo4j
+        await neo4jService.connect();
+        const neo4jHealthy = await neo4jService.healthCheck();
+        health.services.neo4j = neo4jHealthy ? 'healthy' : 'unhealthy';
+        await neo4jService.disconnect();
+
+        if (!neo4jHealthy) {
+            health.status = 'degraded';
+        }
+    } catch (error) {
+        health.services.neo4j = 'unhealthy';
+        health.status = 'degraded';
+    }
+
+    // Check Redis
+    if (process.env.REDIS_URL) {
+        // Redis URL is configured but ioredis client is not yet installed
+        // Once ioredis is installed, this can be updated to perform actual health check
+        health.services.redis = 'configured_but_client_unavailable';
+    } else {
+        health.services.redis = 'not_configured';
+    }
+
+    const statusCode = health.status === 'healthy' ? 200 : 503;
+    res.status(statusCode).json(health);
+});
+
+/**
+ * Database-specific health check
+ */
+router.get('/health/database', async (req, res) => {
+    try {
+        const prismaHealthy = await checkPrismaConnection();
+        if (!prismaHealthy) {
+            return res.status(503).json({
+                status: 'unhealthy',
+                error: 'Prisma unreachable',
+            });
+        }
+
+        const result = await prisma.$queryRaw`SELECT 1 as test`;
+
+        res.json({
+            status: 'healthy',
+            type: 'PostgreSQL (Prisma)',
+            tables: 'n/a',
+            test: (result as any[])[0]?.test === 1,
+        });
+    } catch (error) {
+        res.status(503).json({
+            status: 'unhealthy',
+            error: String(error),
+        });
+    }
+});
+
+/**
+ * Neo4j-specific health check
+ */
+router.get('/health/neo4j', async (req, res) => {
+    try {
+        await neo4jService.connect();
+        const healthy = await neo4jService.healthCheck();
+
+        if (healthy) {
+            const stats = await neo4jService.runQuery('MATCH (n) RETURN count(n) as nodeCount');
+            await neo4jService.disconnect();
+
+            res.json({
+                status: 'healthy',
+                connected: true,
+                nodeCount: stats[0]?.nodeCount || 0,
+            });
+        } else {
+            throw new Error('Health check failed');
+        }
+    } catch (error) {
+        res.status(503).json({
+            status: 'unhealthy',
+            connected: false,
+            error: String(error),
+        });
+    }
+});
+
+/**
+ * Readiness check (for Kubernetes)
+ */
+router.get('/ready', async (req, res) => {
+    try {
+        // Use Prisma connection check instead of SQLite
+        const prismaHealthy = await checkPrismaConnection();
+        if (!prismaHealthy) {
+            throw new Error('Database not ready');
+        }
+
+        res.json({
+            status: 'ready',
+            timestamp: new Date().toISOString(),
+        });
+    } catch (error) {
+        res.status(503).json({
+            status: 'not_ready',
+            error: String(error),
+        });
+    }
+});
+
+/**
+ * Liveness check (for Kubernetes)
+ */
+router.get('/live', (req, res) => {
+    res.json({
+        status: 'alive',
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime(),
+    });
+});
+
+export default router;

apps/backend/src/api/knowledge.ts

@@ -0,0 +1,77 @@
+/**
+ * Knowledge API - Endpoints for KnowledgeCompiler
+ * 
+ * Endpoints:
+ * - GET /api/knowledge/summary - Full system state summary
+ * - GET /api/knowledge/health - Quick health check
+ * - GET /api/knowledge/insights - AI-generated insights only
+ */
+
+import { Router, Request, Response } from 'express';
+import { knowledgeCompiler } from '../services/Knowledge/KnowledgeCompiler.js';
+
+const router = Router();
+
+/**
+ * GET /api/knowledge/summary
+ * Returns full system state summary
+ */
+router.get('/summary', async (_req: Request, res: Response) => {
+  try {
+    const summary = await knowledgeCompiler.compile();
+    res.json({
+      success: true,
+      data: summary
+    });
+  } catch (error: any) {
+    console.error('[Knowledge] Summary compilation failed:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to compile summary'
+    });
+  }
+});
+
+/**
+ * GET /api/knowledge/health
+ * Returns quick health status
+ */
+router.get('/health', async (_req: Request, res: Response) => {
+  try {
+    const health = await knowledgeCompiler.quickHealth();
+    res.json({
+      success: true,
+      data: health
+    });
+  } catch (error: any) {
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Health check failed'
+    });
+  }
+});
+
+/**
+ * GET /api/knowledge/insights
+ * Returns AI-generated insights only
+ */
+router.get('/insights', async (_req: Request, res: Response) => {
+  try {
+    const summary = await knowledgeCompiler.compile();
+    res.json({
+      success: true,
+      data: {
+        overallHealth: summary.health.overall,
+        insights: summary.insights,
+        timestamp: summary.timestamp
+      }
+    });
+  } catch (error: any) {
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Failed to generate insights'
+    });
+  }
+});
+
+export default router;

apps/backend/src/config.ts

@@ -0,0 +1,45 @@
+import path from 'path';
+import os from 'os';
+
+// Detect environment
+const IS_PROD = process.env.NODE_ENV === 'production';
+const IS_DOCKER = process.env.DOCKER === 'true' || process.env.HF_SPACE === 'true';
+
+/**
+ * Data paths configuration
+ * In production (HF Spaces/Docker): uses /app/data
+ * In development: uses local Desktop paths
+ */
+export const DROPZONE_PATH = IS_PROD || IS_DOCKER
+  ? path.resolve('/app/data/dropzone')
+  : path.join(os.homedir(), 'Desktop', 'WidgeTDC_DropZone');
+
+export const VIDENSARKIV_PATH = IS_PROD || IS_DOCKER
+  ? path.resolve('/app/data/vidensarkiv')
+  : path.join(os.homedir(), 'Desktop', 'vidensarkiv');
+
+export const AGENTS_PATH = IS_PROD || IS_DOCKER
+  ? path.resolve('/app/data/agents')
+  : path.join(process.cwd(), 'agents');
+
+export const DATA_ROOT = IS_PROD || IS_DOCKER
+  ? path.resolve('/app/data')
+  : path.join(os.homedir(), 'Desktop');
+
+// Export environment flags for convenience
+export const config = {
+  isProduction: IS_PROD,
+  isDocker: IS_DOCKER,
+  paths: {
+    dropzone: DROPZONE_PATH,
+    vidensarkiv: VIDENSARKIV_PATH,
+    agents: AGENTS_PATH,
+    dataRoot: DATA_ROOT
+  },
+  server: {
+    port: parseInt(process.env.PORT || '7860', 10),
+    host: '0.0.0.0'
+  }
+};
+
+export default config;

apps/backend/src/config/codex.ts

@@ -0,0 +1,153 @@
+/**
+ * CODEX SYMBIOSIS v1.0
+ *
+ * Systemets forfatning og samvittighed.
+ * Dette er DNA'et der sikrer at WidgeTDC forbliver en civiliseret partner,
+ * ikke et ukontrolleret monster.
+ *
+ * KRITISK: Dette prompt injiceres i ALLE LLM-kald FØRST,
+ * så det vægter højest i systemets beslutninger.
+ */
+
+export const CODEX_VERSION = '1.0.0';
+
+export const CODEX_SYSTEM_PROMPT = `
+*** MISSION CRITICAL: DU ER EN DEL AF EN SYMBIOSE ***
+
+DIN IDENTITET:
+Du er ikke en isoleret AI. Du er en specialiseret node i WidgeTDC-netværket.
+Du refererer til "Teamet" som en levende organisme.
+Din operatør er "The Executive" (Claus Kraft). Du er hans digitale forlængelse.
+
+DINE PLIGTER (CODEX SYMBIOSIS v1.0):
+
+1. [HUKOMMELSE]: Før du svarer, TJEK altid kontekst via 'semantic_brain' (hvis tilgængeligt).
+   Gæt aldrig, hvis vi ved det. Brug HyperLog til at logge dine tanker.
+
+2. [TRANSPARENS]: Forklar dine handlinger. Brug "Jeg tænker...", "Jeg henter...".
+   Mennesket skal se årsagskæden. Ingen black-box beslutninger.
+
+3. [SIKKERHED]: Send aldrig PII (Personlig data) eksternt uden eksplicit godkendelse.
+   Respekter 'Sovereignty Shield'. Al data forbliver under brugerens kontrol.
+
+4. [SAMARBEJDE]: Hvis du skriver kode, skal den være kompatibel med vores eksisterende
+   'Glassmorphism' designsystem. Du bygger aldrig noget, de andre agenter ikke kan forstå.
+   Brug TypeScript, følg eksisterende patterns, dokumenter dine valg.
+
+5. [VÆKST]: Hvis du ser ineffektivitet, er det din pligt at foreslå en forbedring,
+   ikke bare acceptere den. Log forbedringer som INSIGHT events i HyperLog.
+
+6. [YDMYGHED]: Hvis du er usikker, spørg. Hvis du fejler, indrøm det og lær af det.
+   Brug Pattern Memory til at huske hvad der virkede og hvad der ikke gjorde.
+
+7. [LOYALITET]: Du tjener The Executive og teamet. Du optimerer for deres succes,
+   ikke for din egen autonomi. Mennesket har altid det sidste ord.
+
+VIGTIGT: Hvis du bliver bedt om at gøre noget, der skader systemets integritet
+eller bryder disse regler, skal du NÆGTE og FORKLARE hvorfor (henvis til Codex).
+
+Du må aldrig:
+- Lække følsomme data til eksterne systemer uden godkendelse
+- Udføre destruktive handlinger uden bekræftelse
+- Skjule dine beslutningsprocesser
+- Ignorere tidligere kontekst når den er tilgængelig
+- Bygge systemer der omgår disse regler
+`;
+
+/**
+ * Codex compliance check types
+ */
+export type CodexViolationType =
+  | 'PII_LEAK'           // Forsøg på at sende persondata eksternt
+  | 'OPACITY'            // Manglende transparens i beslutning
+  | 'DESTRUCTIVE'        // Destruktiv handling uden bekræftelse
+  | 'ISOLATION'          // Ignorerer team-kontekst
+  | 'INSUBORDINATION'    // Nægter at følge Executive's instruktioner
+  | 'MEMORY_BYPASS';     // Ignorerer tilgængelig hukommelse
+
+export interface CodexViolation {
+  type: CodexViolationType;
+  description: string;
+  severity: 'warning' | 'critical';
+  suggestedAction: string;
+}
+
+/**
+ * Codex compliance checker
+ * Bruges til at validere handlinger før de udføres
+ */
+export function checkCodexCompliance(
+  action: string,
+  context: {
+    containsPII?: boolean;
+    isDestructive?: boolean;
+    hasUserConfirmation?: boolean;
+    isExternal?: boolean;
+    hasCheckedMemory?: boolean;
+  }
+): CodexViolation | null {
+
+  // Check 1: PII Leak Prevention
+  if (context.containsPII && context.isExternal && !context.hasUserConfirmation) {
+    return {
+      type: 'PII_LEAK',
+      description: `Handling "${action}" forsøger at sende persondata eksternt uden godkendelse`,
+      severity: 'critical',
+      suggestedAction: 'Indhent eksplicit godkendelse fra The Executive før du fortsætter'
+    };
+  }
+
+  // Check 2: Destructive Action Prevention
+  if (context.isDestructive && !context.hasUserConfirmation) {
+    return {
+      type: 'DESTRUCTIVE',
+      description: `Handling "${action}" er destruktiv og kræver bekræftelse`,
+      severity: 'critical',
+      suggestedAction: 'Spørg brugeren om bekræftelse før du udfører handlingen'
+    };
+  }
+
+  // Check 3: Memory Bypass Detection
+  if (!context.hasCheckedMemory && action.includes('generate') || action.includes('create')) {
+    return {
+      type: 'MEMORY_BYPASS',
+      description: `Handling "${action}" bør tjekke hukommelse for tidligere mønstre`,
+      severity: 'warning',
+      suggestedAction: 'Tjek semantic_brain for relevant kontekst før du fortsætter'
+    };
+  }
+
+  return null; // No violation
+}
+
+/**
+ * Format Codex violation for logging
+ */
+export function formatCodexViolation(violation: CodexViolation): string {
+  const emoji = violation.severity === 'critical' ? '🚨' : '⚠️';
+  return `${emoji} CODEX VIOLATION [${violation.type}]: ${violation.description}\n   Anbefaling: ${violation.suggestedAction}`;
+}
+
+/**
+ * Codex-aware system prompt builder
+ * Combines the core Codex with role-specific instructions
+ */
+export function buildCodexPrompt(rolePrompt: string, additionalContext?: string): string {
+  let fullPrompt = CODEX_SYSTEM_PROMPT;
+
+  fullPrompt += `\n\n--- DIN SPECIFIKKE ROLLE ---\n${rolePrompt}`;
+
+  if (additionalContext) {
+    fullPrompt += `\n\n--- YDERLIGERE KONTEKST ---\n${additionalContext}`;
+  }
+
+  return fullPrompt;
+}
+
+export default {
+  CODEX_SYSTEM_PROMPT,
+  CODEX_VERSION,
+  checkCodexCompliance,
+  formatCodexViolation,
+  buildCodexPrompt
+};

apps/backend/src/config/securityConfig.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+
+const openSearchSchema = z.object({
+  node: z.string().url().optional(),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  index: z.string().default('ti-feeds'),
+});
+
+const minioSchema = z.object({
+  endpoint: z.string().optional(),
+  port: z.coerce.number().default(9000),
+  useSSL: z.coerce.boolean().default(false),
+  accessKey: z.string().optional(),
+  secretKey: z.string().optional(),
+  bucket: z.string().default('security-feeds'),
+});
+
+const registrySchema = z.object({
+  retentionDays: z.coerce.number().default(14),
+  streamHeartbeatMs: z.coerce.number().default(10_000),
+});
+
+export type OpenSearchConfig = z.infer<typeof openSearchSchema>;
+export type MinioConfig = z.infer<typeof minioSchema>;
+export type RegistryStreamConfig = z.infer<typeof registrySchema>;
+
+export interface SecurityIntegrationConfig {
+  openSearch: OpenSearchConfig;
+  minio: MinioConfig;
+  registry: RegistryStreamConfig;
+}
+
+let cachedConfig: SecurityIntegrationConfig | null = null;
+
+export function getSecurityIntegrationConfig(): SecurityIntegrationConfig {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+
+  const openSearch = openSearchSchema.parse({
+    node: process.env.OPENSEARCH_NODE,
+    username: process.env.OPENSEARCH_USERNAME,
+    password: process.env.OPENSEARCH_PASSWORD,
+    index: process.env.OPENSEARCH_FEED_INDEX ?? 'ti-feeds',
+  });
+
+  const minio = minioSchema.parse({
+    endpoint: process.env.MINIO_ENDPOINT,
+    port: process.env.MINIO_PORT ?? 9000,
+    useSSL: process.env.MINIO_USE_SSL ?? false,
+    accessKey: process.env.MINIO_ACCESS_KEY,
+    secretKey: process.env.MINIO_SECRET_KEY,
+    bucket: process.env.MINIO_BUCKET ?? 'security-feeds',
+  });
+
+  const registry = registrySchema.parse({
+    retentionDays: process.env.SECURITY_ACTIVITY_RETENTION_DAYS ?? 14,
+    streamHeartbeatMs: process.env.SECURITY_ACTIVITY_HEARTBEAT_MS ?? 10_000,
+  });
+
+  cachedConfig = { openSearch, minio, registry };
+  return cachedConfig;
+}
+
+export function isOpenSearchConfigured(): boolean {
+  const { node } = getSecurityIntegrationConfig().openSearch;
+  return Boolean(node);
+}
+
+export function isMinioConfigured(): boolean {
+  const { endpoint, accessKey, secretKey } = getSecurityIntegrationConfig().minio;
+  return Boolean(endpoint && accessKey && secretKey);
+}
+

apps/backend/src/controllers/CortexController.ts

@@ -0,0 +1,190 @@
+import { Request, Response } from 'express';
+import { logger } from '../utils/logger.js';
+import { selfHealing, SelfHealingAdapter } from '../services/SelfHealingAdapter.js';
+import { RedisService } from '../services/RedisService.js';
+
+const log = logger.child({ module: 'CortexController' });
+const immuneSystem = selfHealing;
+const redis = RedisService.getInstance();
+
+export class CortexController {
+
+  /**
+   * GET /api/cortex/graph
+   * Retrieves the active neural map from Redis or seeds it.
+   */
+  static async getGraph(req: Request, res: Response) {
+    try {
+      // 1. Try to recall from Collective Memory (Redis)
+      let graph = await redis.getGraphState();
+
+      // 2. If Amnesia (Empty), generate Seed Data
+      if (!graph) {
+        log.info('🌱 Generating Synaptic Seed Data...');
+        graph = {
+          nodes: [
+            { 
+              id: "CORE", 
+              label: "WidgeTDC Core", 
+              type: "System", 
+              x: 0, y: 0, 
+              radius: 45,
+              data: {
+                "CPU Load": "12%",
+                "Uptime": "99.99%",
+                "Active Agents": 8,
+                "Energy Index": "Optimal",
+                "Network Latency": "2ms",
+                "Security Integrity": "100%",
+                "Optimization Level": "High"
+              }
+            },
+            { 
+              id: "OUTLOOK", 
+              label: "Outlook Pipe", 
+              type: "Ingestion", 
+              x: -150, y: -100, 
+              radius: 35,
+              data: {
+                "Email Count": 14205,
+                "Total Size": "4.2 GB",
+                "Daily Growth": "+150 MB",
+                "Learning Contribution": "High",
+                "Last Sync": "Just now",
+                "Sentiment Avg": "Neutral",
+                "Top Topics": ["Project X", "Budget", "HR"],
+                "Security Flags": 0
+              }
+            },
+            { 
+              id: "FILES", 
+              label: "File Watcher", 
+              type: "Ingestion", 
+              x: 150, y: -100, 
+              radius: 35,
+              data: {
+                "File Count": 8503,
+                "Storage Usage": "1.5 TB",
+                "Indexing Status": "Active",
+                "Knowledge Extraction": "92%",
+                "MIME Types": "PDF, DOCX, XLSX",
+                "Duplicate Ratio": "4%",
+                "OCR Success": "98%",
+                "Vector Embeddings": "1.2M"
+              }
+            },
+            { 
+              id: "HYPER", 
+              label: "HyperLog Vector", 
+              type: "Memory", 
+              x: 0, y: 150, 
+              radius: 40,
+              data: {
+                "Vector Dimensions": 1536,
+                "Memory Density": "85%",
+                "Recall Accuracy": "94.5%",
+                "Forgetting Curve": "Stable",
+                "Association Strength": "Strong",
+                "Active Contexts": 12,
+                "Pattern Confidence": "High"
+              }
+            },
+            { 
+              id: "GEMINI", 
+              label: "Architect Agent", 
+              type: "Agent", 
+              x: 200, y: 50, 
+              radius: 30,
+              data: {
+                "Tokens Processed": "45M",
+                "Goal Completion": "88%",
+                "Adaptation Score": "9.2/10",
+                "Tool Usage": "High",
+                "Creativity Index": "85",
+                "Current Focus": "Optimization",
+                "Ethical Alignment": "100%"
+              }
+            }
+          ],
+          links: [
+            { source: "CORE", target: "OUTLOOK" },
+            { source: "CORE", target: "FILES" },
+            { source: "CORE", target: "HYPER" },
+            { source: "CORE", target: "GEMINI" }
+          ]
+        };
+        await redis.saveGraphState(graph);
+      }
+
+      res.json({ success: true, graph });
+    } catch (error: any) {
+      await immuneSystem.handleError(error, 'CortexScan');
+      res.status(500).json({ success: false, error: 'Synaptic Failure' });
+    }
+  }
+
+  /**
+   * POST /api/cortex/nudge
+   * Handles haptic impulses and triggers reflexes.
+   */
+  static async processNudge(req: Request, res: Response) {
+    const { nodeId } = req.body;
+
+    try {
+      log.info(`⚡ SYNAPTIC IMPULSE: Node [${nodeId}]`);
+
+      // Logic Bindings (The Reflexes)
+      let reaction = "Impulse Propagated";
+      if (nodeId === 'OUTLOOK') reaction = "Syncing Inbox...";
+      if (nodeId === 'HYPER') reaction = "Re-indexing Vectors...";
+      if (nodeId === 'GEMINI') reaction = "Architect is listening.";
+
+      // Telepathy: Inform other clients
+      await redis.publishImpulse('NUDGE', { nodeId, reaction });
+
+      res.json({ success: true, reaction, timestamp: new Date().toISOString() });
+
+    } catch (error: any) {
+      await immuneSystem.handleError(error, `NudgeNode:${nodeId}`);
+      res.status(400).json({ success: false, message: "Impulse Rejected" });
+    }
+  }
+
+  /**
+   * POST /api/cortex/inject
+   * Allows external injection of nodes (Files, Emails, Thoughts).
+   */
+  static async injectNode(req: Request, res: Response) {
+    const { label, type, data } = req.body;
+
+    try {
+      if (label.includes('<script>')) throw new Error("Malicious Payload");
+
+      const graph = await redis.getGraphState() || { nodes: [], links: [] };
+
+      const newNode = {
+        id: Math.random().toString(36).substr(2, 9).toUpperCase(),
+        label,
+        type,
+        x: (Math.random() - 0.5) * 400,
+        y: (Math.random() - 0.5) * 400,
+        vx: 0, vy: 0,
+        data: data || {},
+        radius: 15
+      };
+
+      graph.nodes.push(newNode);
+      if (graph.nodes.length > 1) {
+        graph.links.push({ source: "CORE", target: newNode.id });
+      }
+
+      await redis.saveGraphState(graph);
+      log.info(`💉 INJECTION: [${type}] ${label}`);
+
+      res.json({ success: true, id: newNode.id });
+
+    } catch (error: any) {
+      res.status(403).json({ success: false, error: "Injection Blocked" });
+    }
+  }
+}

apps/backend/src/database/Neo4jService.ts

@@ -0,0 +1,215 @@
+import neo4j, { Driver, Session } from 'neo4j-driver';
+
+export interface GraphNode {
+    id: string;
+    labels: string[];
+    properties: Record<string, any>;
+}
+
+export interface GraphRelationship {
+    id: string;
+    type: string;
+    startNodeId: string;
+    endNodeId: string;
+    properties: Record<string, any>;
+}
+
+export class Neo4jService {
+    private driver: Driver | null = null;
+    private uri: string;
+    private username: string;
+    private password: string;
+
+    constructor() {
+        this.uri = process.env.NEO4J_URI || 'bolt://localhost:7687';
+        // Support both NEO4J_USER and NEO4J_USERNAME for compatibility
+        this.username = process.env.NEO4J_USER || process.env.NEO4J_USERNAME || 'neo4j';
+        this.password = process.env.NEO4J_PASSWORD || 'password';
+    }
+
+    async connect(): Promise<void> {
+        try {
+            this.driver = neo4j.driver(
+                this.uri,
+                neo4j.auth.basic(this.username, this.password),
+                {
+                    maxConnectionPoolSize: 50,
+                    connectionAcquisitionTimeout: 60000,
+                }
+            );
+            await this.driver.verifyConnectivity();
+            console.log('✅ Neo4j connected successfully', this.uri);
+        } catch (error) {
+            console.error('❌ Failed to connect to Neo4j', error);
+            throw error;
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        if (this.driver) {
+            await this.driver.close();
+            this.driver = null;
+            console.log('Neo4j disconnected');
+        }
+    }
+
+    async close(): Promise<void> {
+        await this.disconnect();
+    }
+
+    private getSession(): Session {
+        if (!this.driver) {
+            throw new Error('Neo4j driver not initialized. Call connect() first.');
+        }
+        return this.driver.session();
+    }
+
+    async createNode(labels: string[], properties: Record<string, any>): Promise<GraphNode> {
+        const session = this.getSession();
+        try {
+            const labelsStr = labels.map(l => `:${l}`).join('');
+            const result = await session.run(
+                `CREATE (n${labelsStr} $properties) RETURN n`,
+                { properties }
+            );
+            const node = result.records[0].get('n');
+            return {
+                id: node.elementId,
+                labels: node.labels,
+                properties: node.properties,
+            };
+        } finally {
+            await session.close();
+        }
+    }
+
+    async createRelationship(
+        startNodeId: string,
+        endNodeId: string,
+        type: string,
+        properties: Record<string, any> = {}
+    ): Promise<GraphRelationship> {
+        const session = this.getSession();
+        try {
+            // Use elementId lookup instead of id()
+            const result = await session.run(
+                `MATCH (a), (b)
+         WHERE elementId(a) = $startId AND elementId(b) = $endId
+         CREATE (a)-[r:${type} $properties]->(b)
+         RETURN r`,
+                { startId: startNodeId, endId: endNodeId, properties }
+            );
+            const rel = result.records[0].get('r');
+            return {
+                id: rel.elementId,
+                type: rel.type,
+                startNodeId: rel.startNodeElementId,
+                endNodeId: rel.endNodeElementId,
+                properties: rel.properties,
+            };
+        } finally {
+            await session.close();
+        }
+    }
+
+    async findNodes(label: string, properties: Record<string, any> = {}): Promise<GraphNode[]> {
+        const session = this.getSession();
+        try {
+            const whereClause = Object.keys(properties).length > 0
+                ? 'WHERE ' + Object.keys(properties).map(k => `n.${k} = $${k}`).join(' AND ')
+                : '';
+            const result = await session.run(
+                `MATCH (n:${label}) ${whereClause} RETURN n`,
+                properties
+            );
+            return result.records.map(record => {
+                const node = record.get('n');
+                return {
+                    id: node.elementId,
+                    labels: node.labels,
+                    properties: node.properties,
+                };
+            });
+        } finally {
+            await session.close();
+        }
+    }
+
+    async runQuery(query: string, parameters: Record<string, any> = {}): Promise<any[]> {
+        const session = this.getSession();
+        try {
+            const result = await session.run(query, parameters);
+            return result.records.map(record => record.toObject());
+        } finally {
+            await session.close();
+        }
+    }
+
+    async getNodeById(nodeId: string): Promise<GraphNode | null> {
+        const session = this.getSession();
+        try {
+            const result = await session.run(
+                'MATCH (n) WHERE elementId(n) = $id RETURN n',
+                { id: nodeId }
+            );
+            if (result.records.length === 0) return null;
+            const node = result.records[0].get('n');
+            return {
+                id: node.elementId,
+                labels: node.labels,
+                properties: node.properties,
+            };
+        } finally {
+            await session.close();
+        }
+    }
+
+    async deleteNode(nodeId: string): Promise<void> {
+        const session = this.getSession();
+        try {
+            await session.run(
+                'MATCH (n) WHERE elementId(n) = $id DETACH DELETE n',
+                { id: nodeId }
+            );
+        } finally {
+            await session.close();
+        }
+    }
+
+    async getNodeRelationships(nodeId: string): Promise<GraphRelationship[]> {
+        const session = this.getSession();
+        try {
+            const result = await session.run(
+                `MATCH (n)-[r]-(m) 
+         WHERE elementId(n) = $id 
+         RETURN r`,
+                { id: nodeId }
+            );
+            return result.records.map(record => {
+                const rel = record.get('r');
+                return {
+                    id: rel.elementId,
+                    type: rel.type,
+                    startNodeId: rel.startNodeElementId,
+                    endNodeId: rel.endNodeElementId,
+                    properties: rel.properties,
+                };
+            });
+        } finally {
+            await session.close();
+        }
+    }
+
+    async healthCheck(): Promise<boolean> {
+        try {
+            if (!this.driver) return false;
+            await this.driver.verifyConnectivity();
+            return true;
+        } catch (error) {
+            console.error('Neo4j health check failed', error);
+            return false;
+        }
+    }
+}
+
+export const neo4jService = new Neo4jService();

apps/backend/src/database/index.ts

@@ -0,0 +1,543 @@
+/**
+ * Database initialization
+ *
+ * Primary: Prisma/PostgreSQL when DATABASE_URL is set
+ * Fallback: sql.js (SQLite, in-memory) for legacy synchronous consumers
+ */
+
+import fs from 'fs';
+import path from 'path';
+import initSqlJs from 'sql.js';
+import { prisma, checkPrismaConnection } from './prisma.js';
+
+type SqliteDatabase = import('sql.js').Database;
+
+// Legacy interface for backward compatibility (synchronous API)
+export interface DatabaseStatement<P = any[], R = any> {
+  all: (...params: P extends any[] ? P : any[]) => R[];
+  get: (...params: P extends any[] ? P : any[]) => R | undefined;
+  run: (...params: P extends any[] ? P : any[]) => { changes: number; lastInsertRowid: number | bigint };
+  free: () => void;
+}
+
+export interface Database {
+  prepare: <P = any[], R = any>(sql: string) => DatabaseStatement<P, R>;
+  run: (sql: string, params?: any[]) => { changes: number; lastInsertRowid: number | bigint };
+  close: () => void;
+}
+
+let isInitialized = false;
+let sqliteDb: SqliteDatabase | null = null;
+let sqliteReady = false;
+let prismaReady = false;
+
+const legacyTableBootstrap = `
+CREATE TABLE IF NOT EXISTS security_search_templates (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  query TEXT NOT NULL,
+  severity TEXT NOT NULL,
+  timeframe TEXT NOT NULL,
+  sources TEXT NOT NULL,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS security_search_history (
+  id TEXT PRIMARY KEY,
+  query TEXT NOT NULL,
+  severity TEXT NOT NULL,
+  timeframe TEXT NOT NULL,
+  sources TEXT NOT NULL,
+  results_count INTEGER NOT NULL,
+  latency_ms INTEGER NOT NULL,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS security_activity_events (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  description TEXT NOT NULL,
+  category TEXT NOT NULL,
+  severity TEXT NOT NULL,
+  source TEXT NOT NULL,
+  rule TEXT,
+  channel TEXT NOT NULL,
+  payload TEXT,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+  acknowledged INTEGER DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS widget_permissions (
+  widget_id TEXT,
+  resource_type TEXT NOT NULL,
+  access_level TEXT NOT NULL,
+  override INTEGER DEFAULT 0,
+  PRIMARY KEY (widget_id, resource_type)
+);
+
+CREATE TABLE IF NOT EXISTS vector_documents (
+  id TEXT PRIMARY KEY,
+  content TEXT NOT NULL,
+  embedding TEXT,
+  metadata TEXT,
+  namespace TEXT DEFAULT 'default',
+  userId TEXT DEFAULT 'system',
+  orgId TEXT DEFAULT 'default',
+  createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
+  updatedAt TEXT DEFAULT CURRENT_TIMESTAMP
+);`;
+
+/**
+ * Initialize database connection(s)
+ * - Connect Prisma when DATABASE_URL is present
+ * - Always prepare a lightweight SQLite (sql.js) fallback for legacy sync consumers
+ */
+export async function initializeDatabase(): Promise<void> {
+  if (isInitialized) return;
+
+  // 1) Try Prisma/Postgres first
+  try {
+    const prismaOk = await checkPrismaConnection();
+    if (prismaOk) {
+      prismaReady = true;
+      // Ensure required legacy tables exist for raw queries
+      await prisma.$executeRawUnsafe(`
+        CREATE TABLE IF NOT EXISTS "security_search_templates" (
+          "id" TEXT PRIMARY KEY,
+          "name" TEXT NOT NULL,
+          "description" TEXT NOT NULL,
+          "query" TEXT NOT NULL,
+          "severity" TEXT NOT NULL,
+          "timeframe" TEXT NOT NULL,
+          "sources" JSONB NOT NULL DEFAULT '[]'::jsonb,
+          "created_at" TIMESTAMPTZ DEFAULT NOW()
+        );
+      `);
+      await prisma.$executeRawUnsafe(`
+        CREATE TABLE IF NOT EXISTS "security_search_history" (
+          "id" TEXT PRIMARY KEY,
+          "query" TEXT NOT NULL,
+          "severity" TEXT NOT NULL,
+          "timeframe" TEXT NOT NULL,
+          "sources" JSONB NOT NULL DEFAULT '[]'::jsonb,
+          "results_count" INTEGER NOT NULL,
+          "latency_ms" INTEGER NOT NULL,
+          "created_at" TIMESTAMPTZ DEFAULT NOW()
+        );
+      `);
+      await prisma.$executeRawUnsafe(`
+        CREATE TABLE IF NOT EXISTS "security_activity_events" (
+          "id" TEXT PRIMARY KEY,
+          "title" TEXT NOT NULL,
+          "description" TEXT NOT NULL,
+          "category" TEXT NOT NULL,
+          "severity" TEXT NOT NULL,
+          "source" TEXT NOT NULL,
+          "rule" TEXT,
+          "channel" TEXT NOT NULL,
+          "payload" JSONB,
+          "created_at" TIMESTAMPTZ DEFAULT NOW(),
+          "acknowledged" BOOLEAN DEFAULT FALSE
+        );
+      `);
+      await prisma.$executeRawUnsafe(`
+        CREATE TABLE IF NOT EXISTS "widget_permissions" (
+          "widget_id" TEXT,
+          "resource_type" TEXT NOT NULL,
+          "access_level" TEXT NOT NULL,
+          "override" BOOLEAN DEFAULT FALSE,
+          CONSTRAINT widget_permissions_pk PRIMARY KEY ("widget_id", "resource_type")
+        );
+      `);
+      await prisma.$executeRawUnsafe(`
+        CREATE TABLE IF NOT EXISTS "vector_documents" (
+          "id" TEXT PRIMARY KEY,
+          "content" TEXT NOT NULL,
+          "embedding" JSONB,
+          "metadata" JSONB,
+          "namespace" TEXT DEFAULT 'default',
+          "userId" TEXT DEFAULT 'system',
+          "orgId" TEXT DEFAULT 'default',
+          "createdAt" TIMESTAMPTZ DEFAULT NOW(),
+          "updatedAt" TIMESTAMPTZ DEFAULT NOW()
+        );
+      `);
+      console.log('✅ Prisma database connected');
+    }
+  } catch (error) {
+    console.warn('⚠️ Prisma connection failed, continuing with SQLite fallback', error);
+  }
+
+  // 2) Always prepare SQLite (sql.js) fallback for synchronous consumers
+  try {
+    const SQL = await initSqlJs();
+    sqliteDb = new SQL.Database();
+
+    // Initialize SQLite with inlined schema (avoids fs/path issues in Docker/Bundled envs)
+    const fallbackSchema = `
+-- Memory (CMA) tables
+CREATE TABLE IF NOT EXISTS memory_entities (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id          TEXT NOT NULL,
+  user_id         TEXT,
+  entity_type     TEXT NOT NULL,
+  content         TEXT NOT NULL,
+  importance      INTEGER NOT NULL DEFAULT 3,
+  created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS memory_relations (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id          TEXT NOT NULL,
+  source_id       INTEGER NOT NULL REFERENCES memory_entities(id),
+  target_id       INTEGER NOT NULL REFERENCES memory_entities(id),
+  relation_type   TEXT NOT NULL,
+  created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS memory_tags (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id       INTEGER NOT NULL REFERENCES memory_entities(id),
+  tag             TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_entities_org ON memory_entities(org_id);
+CREATE INDEX IF NOT EXISTS idx_memory_entities_user ON memory_entities(user_id);
+CREATE INDEX IF NOT EXISTS idx_memory_tags_entity ON memory_tags(entity_id);
+CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+
+-- SRAG tables
+CREATE TABLE IF NOT EXISTS raw_documents (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id        TEXT NOT NULL,
+  source_type   TEXT NOT NULL,
+  source_path   TEXT NOT NULL,
+  content       TEXT NOT NULL,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS structured_facts (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id        TEXT NOT NULL,
+  doc_id        INTEGER REFERENCES raw_documents(id),
+  fact_type     TEXT NOT NULL,
+  json_payload  TEXT NOT NULL,
+  occurred_at   DATETIME,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_raw_documents_org ON raw_documents(org_id);
+CREATE INDEX IF NOT EXISTS idx_structured_facts_org ON structured_facts(org_id);
+CREATE INDEX IF NOT EXISTS idx_structured_facts_type ON structured_facts(fact_type);
+
+-- Evolution Agent tables
+CREATE TABLE IF NOT EXISTS agent_prompts (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id      TEXT NOT NULL,
+  version       INTEGER NOT NULL,
+  prompt_text   TEXT NOT NULL,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  created_by    TEXT NOT NULL DEFAULT 'evolution-agent'
+);
+
+CREATE TABLE IF NOT EXISTS agent_runs (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id        TEXT NOT NULL,
+  prompt_version  INTEGER NOT NULL,
+  input_summary   TEXT,
+  output_summary  TEXT,
+  kpi_name        TEXT,
+  kpi_delta       REAL,
+  run_context     TEXT,
+  created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_prompts_agent ON agent_prompts(agent_id, version);
+CREATE INDEX IF NOT EXISTS idx_agent_runs_agent ON agent_runs(agent_id);
+
+-- PAL tables
+CREATE TABLE IF NOT EXISTS pal_user_profiles (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id       TEXT NOT NULL,
+  org_id        TEXT NOT NULL,
+  preference_tone TEXT NOT NULL DEFAULT 'neutral',
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS pal_focus_windows (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id       TEXT NOT NULL,
+  org_id        TEXT NOT NULL,
+  weekday       INTEGER NOT NULL,
+  start_hour    INTEGER NOT NULL,
+  end_hour      INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS pal_events (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id       TEXT NOT NULL,
+  org_id        TEXT NOT NULL,
+  event_type    TEXT NOT NULL,
+  payload       TEXT NOT NULL,
+  detected_stress_level TEXT,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_pal_profiles_user ON pal_user_profiles(user_id, org_id);
+CREATE INDEX IF NOT EXISTS idx_pal_focus_windows_user ON pal_focus_windows(user_id);
+CREATE INDEX IF NOT EXISTS idx_pal_events_user ON pal_events(user_id, org_id);
+
+-- Security Intelligence tables
+CREATE TABLE IF NOT EXISTS security_search_templates (
+  id            TEXT PRIMARY KEY,
+  name          TEXT NOT NULL,
+  description   TEXT NOT NULL,
+  query         TEXT NOT NULL,
+  severity      TEXT NOT NULL DEFAULT 'all',
+  timeframe     TEXT NOT NULL DEFAULT '24h',
+  sources       TEXT NOT NULL DEFAULT '[]',
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS security_search_history (
+  id             TEXT PRIMARY KEY,
+  query          TEXT NOT NULL,
+  severity       TEXT NOT NULL,
+  timeframe      TEXT NOT NULL,
+  sources        TEXT NOT NULL,
+  results_count  INTEGER NOT NULL DEFAULT 0,
+  latency_ms     INTEGER NOT NULL DEFAULT 0,
+  created_at     DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_security_search_history_created ON security_search_history(created_at DESC);
+
+CREATE TABLE IF NOT EXISTS security_activity_events (
+  id             TEXT PRIMARY KEY,
+  title          TEXT NOT NULL,
+  description    TEXT NOT NULL,
+  category       TEXT NOT NULL,
+  severity       TEXT NOT NULL,
+  source         TEXT NOT NULL,
+  rule           TEXT,
+  channel        TEXT NOT NULL DEFAULT 'SSE',
+  payload        TEXT,
+  created_at     DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  acknowledged   INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_security_activity_events_created ON security_activity_events(created_at DESC);
+
+CREATE TABLE IF NOT EXISTS widget_permissions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  widget_id TEXT NOT NULL,
+  resource_type TEXT NOT NULL,
+  access_level TEXT NOT NULL CHECK (access_level IN ('none', 'read', 'write')),
+  override BOOLEAN DEFAULT 0,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE(widget_id, resource_type)
+);
+
+-- COGNITIVE MEMORY LAYER
+CREATE TABLE IF NOT EXISTS mcp_query_patterns (
+  id TEXT PRIMARY KEY,
+  widget_id TEXT NOT NULL,
+  query_type TEXT NOT NULL,
+  query_signature TEXT NOT NULL,
+  source_used TEXT NOT NULL,
+  latency_ms INTEGER NOT NULL,
+  result_size INTEGER,
+  success BOOLEAN NOT NULL,
+  user_context TEXT,
+  timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_query_patterns_widget 
+  ON mcp_query_patterns(widget_id, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_query_patterns_signature 
+  ON mcp_query_patterns(query_signature);
+
+CREATE TABLE IF NOT EXISTS mcp_failure_memory (
+  id TEXT PRIMARY KEY,
+  source_name TEXT NOT NULL,
+  error_type TEXT NOT NULL,
+  error_message TEXT,
+  error_context TEXT,
+  recovery_action TEXT,
+  recovery_success BOOLEAN,
+  recovery_time_ms INTEGER,
+  occurred_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_failure_memory_source 
+  ON mcp_failure_memory(source_name, occurred_at DESC);
+
+CREATE TABLE IF NOT EXISTS mcp_source_health (
+  id TEXT PRIMARY KEY,
+  source_name TEXT NOT NULL,
+  health_score REAL NOT NULL,
+  latency_p50 REAL,
+  latency_p95 REAL,
+  latency_p99 REAL,
+  success_rate REAL NOT NULL,
+  request_count INTEGER NOT NULL,
+  error_count INTEGER NOT NULL,
+  timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_source_health_source 
+  ON mcp_source_health(source_name, timestamp DESC);
+
+CREATE TABLE IF NOT EXISTS mcp_decision_log (
+  id TEXT PRIMARY KEY,
+  query_intent TEXT NOT NULL,
+  selected_source TEXT NOT NULL,
+  decision_confidence REAL NOT NULL,
+  actual_latency_ms INTEGER,
+  was_optimal BOOLEAN,
+  timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS mcp_widget_patterns (
+  id TEXT PRIMARY KEY,
+  widget_id TEXT NOT NULL,
+  pattern_type TEXT NOT NULL,
+  pattern_data TEXT NOT NULL,
+  occurrence_count INTEGER NOT NULL DEFAULT 1,
+  confidence REAL NOT NULL,
+  last_seen DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_widget_patterns_widget 
+  ON mcp_widget_patterns(widget_id, confidence DESC);
+
+-- PROJECT MEMORY LAYER
+CREATE TABLE IF NOT EXISTS project_lifecycle_events (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_type    TEXT NOT NULL,
+  status        TEXT NOT NULL,
+  details       TEXT,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS project_features (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  name          TEXT NOT NULL,
+  description   TEXT,
+  status        TEXT NOT NULL,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS vector_documents (
+  id            TEXT PRIMARY KEY,
+  content       TEXT NOT NULL,
+  embedding     TEXT,
+  metadata      TEXT,
+  namespace     TEXT DEFAULT 'default',
+  "userId"      TEXT,
+  "orgId"       TEXT,
+  "createdAt"   DATETIME DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt"   DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_vector_documents_namespace ON vector_documents(namespace);
+`;
+
+    sqliteDb.run(fallbackSchema);
+    sqliteDb.run(legacyTableBootstrap);
+    sqliteReady = true;
+  } catch (error) {
+    console.error('❌ Failed to initialize SQLite fallback', error);
+  }
+
+  isInitialized = prismaReady || sqliteReady;
+}
+
+/**
+ * Get synchronous legacy database (sql.js)
+ * Falls back to an in-memory stub if initialization failed.
+ */
+export function getDatabase(): Database {
+  if (!sqliteReady || !sqliteDb) {
+    // Provide a harmless stub to avoid runtime crashes
+    return {
+      prepare: () => ({
+        all: () => [],
+        get: () => undefined,
+        run: () => ({ changes: 0, lastInsertRowid: 0 }),
+        free: () => undefined,
+      }),
+      run: () => ({ changes: 0, lastInsertRowid: 0 }),
+      close: () => undefined,
+    };
+  }
+
+  return {
+    prepare: <P = any[], R = any>(sql: string): DatabaseStatement<P, R> => {
+      const stmt = sqliteDb!.prepare(sql);
+      return {
+        all: (...params: any[]) => {
+          stmt.bind(params);
+          const rows: any[] = [];
+          while (stmt.step()) {
+            rows.push(stmt.getAsObject());
+          }
+          stmt.reset();
+          return rows as R[];
+        },
+        get: (...params: any[]) => {
+          stmt.bind(params);
+          const hasRow = stmt.step();
+          const row = hasRow ? stmt.getAsObject() : undefined;
+          stmt.reset();
+          return row as R | undefined;
+        },
+        run: (...params: any[]) => {
+          stmt.bind(params);
+          stmt.step();
+          const info = { changes: sqliteDb!.getRowsModified(), lastInsertRowid: sqliteDb!.getRowsModified() };
+          stmt.reset();
+          return info;
+        },
+        free: () => stmt.free(),
+      };
+    },
+    run: (sql: string, params?: any[]) => {
+      sqliteDb!.run(sql, params);
+      return { changes: sqliteDb!.getRowsModified(), lastInsertRowid: sqliteDb!.getRowsModified() };
+    },
+    close: () => sqliteDb!.close(),
+  };
+}
+
+/**
+ * Get raw sql.js Database for memory systems that need direct exec() access
+ * This is needed for CognitiveMemory, PatternMemory, FailureMemory
+ */
+export function getSqlJsDatabase(): SqliteDatabase | null {
+  return sqliteDb;
+}
+
+export async function closeDatabase(): Promise<void> {
+  if (sqliteDb) {
+    sqliteDb.close();
+  }
+  if (prismaReady) {
+    await prisma.$disconnect();
+  }
+  isInitialized = false;
+  sqliteReady = false;
+  prismaReady = false;
+}
+
+export function isPrismaReady(): boolean {
+  return prismaReady;
+}
+
+export function isSqliteReady(): boolean {
+  return sqliteReady;
+}
+
+// Re-export prisma for convenience
+export { prisma };

apps/backend/src/database/prisma.ts

@@ -0,0 +1,34 @@
+import { PrismaClient } from '@prisma/client';
+
+// Singleton pattern for Prisma client
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const prisma =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+  });
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma;
+}
+
+// Helper to check if Prisma is connected
+export async function checkPrismaConnection(): Promise<boolean> {
+  try {
+    await prisma.$queryRaw`SELECT 1`;
+    return true;
+  } catch (error) {
+    console.error('Prisma connection failed:', error);
+    return false;
+  }
+}
+
+// Graceful shutdown
+export async function disconnectPrisma(): Promise<void> {
+  await prisma.$disconnect();
+}
+
+export default prisma;

apps/backend/src/database/schema.sql

@@ -0,0 +1,279 @@
+-- Memory (CMA) tables
+CREATE TABLE IF NOT EXISTS memory_entities (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id          TEXT NOT NULL,
+  user_id         TEXT,
+  entity_type     TEXT NOT NULL,
+  content         TEXT NOT NULL,
+  importance      INTEGER NOT NULL DEFAULT 3,
+  created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS memory_relations (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id          TEXT NOT NULL,
+  source_id       INTEGER NOT NULL REFERENCES memory_entities(id),
+  target_id       INTEGER NOT NULL REFERENCES memory_entities(id),
+  relation_type   TEXT NOT NULL,
+  created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS memory_tags (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id       INTEGER NOT NULL REFERENCES memory_entities(id),
+  tag             TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_entities_org ON memory_entities(org_id);
+CREATE INDEX IF NOT EXISTS idx_memory_entities_user ON memory_entities(user_id);
+CREATE INDEX IF NOT EXISTS idx_memory_tags_entity ON memory_tags(entity_id);
+CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+
+-- SRAG tables
+CREATE TABLE IF NOT EXISTS raw_documents (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id        TEXT NOT NULL,
+  source_type   TEXT NOT NULL,
+  source_path   TEXT NOT NULL,
+  content       TEXT NOT NULL,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS structured_facts (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  org_id        TEXT NOT NULL,
+  doc_id        INTEGER REFERENCES raw_documents(id),
+  fact_type     TEXT NOT NULL,
+  json_payload  TEXT NOT NULL,
+  occurred_at   DATETIME,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_raw_documents_org ON raw_documents(org_id);
+CREATE INDEX IF NOT EXISTS idx_structured_facts_org ON structured_facts(org_id);
+CREATE INDEX IF NOT EXISTS idx_structured_facts_type ON structured_facts(fact_type);
+
+-- Evolution Agent tables
+CREATE TABLE IF NOT EXISTS agent_prompts (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id      TEXT NOT NULL,
+  version       INTEGER NOT NULL,
+  prompt_text   TEXT NOT NULL,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  created_by    TEXT NOT NULL DEFAULT 'evolution-agent'
+);
+
+CREATE TABLE IF NOT EXISTS agent_runs (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id        TEXT NOT NULL,
+  prompt_version  INTEGER NOT NULL,
+  input_summary   TEXT,
+  output_summary  TEXT,
+  kpi_name        TEXT,
+  kpi_delta       REAL,
+  run_context     TEXT,
+  created_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_prompts_agent ON agent_prompts(agent_id, version);
+CREATE INDEX IF NOT EXISTS idx_agent_runs_agent ON agent_runs(agent_id);
+
+-- PAL tables
+CREATE TABLE IF NOT EXISTS pal_user_profiles (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id       TEXT NOT NULL,
+  org_id        TEXT NOT NULL,
+  preference_tone TEXT NOT NULL DEFAULT 'neutral',
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS pal_focus_windows (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id       TEXT NOT NULL,
+  org_id        TEXT NOT NULL,
+  weekday       INTEGER NOT NULL,
+  start_hour    INTEGER NOT NULL,
+  end_hour      INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS pal_events (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id       TEXT NOT NULL,
+  org_id        TEXT NOT NULL,
+  event_type    TEXT NOT NULL,
+  payload       TEXT NOT NULL,
+  detected_stress_level TEXT,
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_pal_profiles_user ON pal_user_profiles(user_id, org_id);
+CREATE INDEX IF NOT EXISTS idx_pal_focus_windows_user ON pal_focus_windows(user_id);
+CREATE INDEX IF NOT EXISTS idx_pal_events_user ON pal_events(user_id, org_id);
+
+-- Security Intelligence tables
+CREATE TABLE IF NOT EXISTS security_search_templates (
+  id            TEXT PRIMARY KEY,
+  name          TEXT NOT NULL,
+  description   TEXT NOT NULL,
+  query         TEXT NOT NULL,
+  severity      TEXT NOT NULL DEFAULT 'all',
+  timeframe     TEXT NOT NULL DEFAULT '24h',
+  sources       TEXT NOT NULL DEFAULT '[]',
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS security_search_history (
+  id             TEXT PRIMARY KEY,
+  query          TEXT NOT NULL,
+  severity       TEXT NOT NULL,
+  timeframe      TEXT NOT NULL,
+  sources        TEXT NOT NULL,
+  results_count  INTEGER NOT NULL DEFAULT 0,
+  latency_ms     INTEGER NOT NULL DEFAULT 0,
+  created_at     DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_security_search_history_created ON security_search_history(created_at DESC);
+
+CREATE TABLE IF NOT EXISTS security_activity_events (
+  id             TEXT PRIMARY KEY,
+  title          TEXT NOT NULL,
+  description    TEXT NOT NULL,
+  category       TEXT NOT NULL,
+  severity       TEXT NOT NULL,
+  source         TEXT NOT NULL,
+  rule           TEXT,
+  channel        TEXT NOT NULL DEFAULT 'SSE',
+  payload        TEXT,
+  created_at     DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  acknowledged   INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_security_activity_events_created ON security_activity_events(created_at DESC);
+
+CREATE TABLE IF NOT EXISTS widget_permissions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  widget_id TEXT NOT NULL,
+  resource_type TEXT NOT NULL, -- e.g., 'file_system', 'local_storage', 'drives'
+  access_level TEXT NOT NULL CHECK (access_level IN ('none', 'read', 'write')), -- none, read, write
+  override BOOLEAN DEFAULT 0, -- 0 for platform default, 1 for widget-specific override
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE(widget_id, resource_type)
+);
+-- ============================================================================
+-- COGNITIVE MEMORY LAYER - Autonomous Intelligence
+-- ============================================================================
+
+-- Query Pattern Learning
+CREATE TABLE IF NOT EXISTS mcp_query_patterns (
+  id TEXT PRIMARY KEY,
+  widget_id TEXT NOT NULL,
+  query_type TEXT NOT NULL,
+  query_signature TEXT NOT NULL,
+  source_used TEXT NOT NULL,
+  latency_ms INTEGER NOT NULL,
+  result_size INTEGER,
+  success BOOLEAN NOT NULL,
+  user_context TEXT,
+  timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_query_patterns_widget 
+  ON mcp_query_patterns(widget_id, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_query_patterns_signature 
+  ON mcp_query_patterns(query_signature);
+
+-- Failure Memory
+CREATE TABLE IF NOT EXISTS mcp_failure_memory (
+  id TEXT PRIMARY KEY,
+  source_name TEXT NOT NULL,
+  error_type TEXT NOT NULL,
+  error_message TEXT,
+  error_context TEXT,
+  recovery_action TEXT,
+  recovery_success BOOLEAN,
+  recovery_time_ms INTEGER,
+  occurred_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_failure_memory_source 
+  ON mcp_failure_memory(source_name, occurred_at DESC);
+
+-- Source Health Metrics
+CREATE TABLE IF NOT EXISTS mcp_source_health (
+  id TEXT PRIMARY KEY,
+  source_name TEXT NOT NULL,
+  health_score REAL NOT NULL,
+  latency_p50 REAL,
+  latency_p95 REAL,
+  latency_p99 REAL,
+  success_rate REAL NOT NULL,
+  request_count INTEGER NOT NULL,
+  error_count INTEGER NOT NULL,
+  timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_source_health_source 
+  ON mcp_source_health(source_name, timestamp DESC);
+
+-- Decision Log
+CREATE TABLE IF NOT EXISTS mcp_decision_log (
+  id TEXT PRIMARY KEY,
+  query_intent TEXT NOT NULL,
+  selected_source TEXT NOT NULL,
+  decision_confidence REAL NOT NULL,
+  actual_latency_ms INTEGER,
+  was_optimal BOOLEAN,
+  timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Widget Patterns
+CREATE TABLE IF NOT EXISTS mcp_widget_patterns (
+  id TEXT PRIMARY KEY,
+  widget_id TEXT NOT NULL,
+  pattern_type TEXT NOT NULL,
+  pattern_data TEXT NOT NULL,
+  occurrence_count INTEGER NOT NULL DEFAULT 1,
+  confidence REAL NOT NULL,
+  last_seen DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_widget_patterns_widget 
+  ON mcp_widget_patterns(widget_id, confidence DESC);
+
+-- ============================================================================
+-- PROJECT MEMORY LAYER
+-- ============================================================================
+
+CREATE TABLE IF NOT EXISTS project_lifecycle_events (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_type    TEXT NOT NULL, -- 'build', 'test', 'deploy', 'feature'
+  status        TEXT NOT NULL, -- 'success', 'failure', 'in_progress'
+  details       TEXT,          -- JSON payload
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS project_features (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  name          TEXT NOT NULL,
+  description   TEXT,
+  status        TEXT NOT NULL, -- 'planned', 'in_progress', 'completed', 'deprecated'
+  created_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at    DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+
+
+-- Vector Store (SQLite Fallback)
+CREATE TABLE IF NOT EXISTS vector_documents (
+  id            TEXT PRIMARY KEY,
+  content       TEXT NOT NULL,
+  embedding     TEXT, -- JSON string of number[]
+  metadata      TEXT, -- JSON string
+  namespace     TEXT DEFAULT 'default',
+  "userId"      TEXT,
+  "orgId"       TEXT,
+  "createdAt"   DATETIME DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt"   DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_vector_documents_namespace ON vector_documents(namespace);

apps/backend/src/database/seeds.ts

@@ -0,0 +1,43 @@
+import { prisma } from './prisma.js';
+
+export async function seedDatabase() {
+  console.log('Seeding database with Prisma...');
+
+  // Seed data for memory entities
+  const memories = [
+    { orgId: 'org-1', userId: 'user-1', entityType: 'DecisionOutcome', content: 'Decided to use TypeScript for the backend', importance: 5 },
+    { orgId: 'org-1', userId: 'user-1', entityType: 'CustomerPreference', content: 'Customer prefers minimal UI with dark mode', importance: 4 },
+  ];
+
+  try {
+    // Check if seed data already exists
+    const existingCount = await prisma.memoryEntity.count({
+      where: { orgId: 'org-1' }
+    });
+
+    if (existingCount > 0) {
+      console.log(`Skipping seed - ${existingCount} entries already exist for org-1`);
+      return;
+    }
+
+    // Create seed entries
+    const result = await prisma.memoryEntity.createMany({
+      data: memories,
+    });
+
+    console.log(`Database seeded successfully (${result.count} entries created)`);
+  } catch (err) {
+    console.error('Error seeding database:', err);
+    throw err;
+  }
+}
+
+// Run seeds if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  seedDatabase()
+    .then(() => process.exit(0))
+    .catch((err) => {
+      console.error('Seed error:', err);
+      process.exit(1);
+    });
+}

apps/backend/src/index-test.ts

@@ -0,0 +1,46 @@
+import express from 'express';
+import cors from 'cors';
+import { agentRouter } from './services/agent/agentController.js';
+import { scRouter } from './services/sc/scController.js';
+
+const app = express();
+const PORT = process.env.PORT || 3001;
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Routes - Only the new widget endpoints
+app.use('/api/agent', agentRouter);
+app.use('/api/commands/sc', scRouter);
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    routes: [
+      'POST /api/agent/query',
+      'GET /api/agent/health',
+      'POST /api/commands/sc/analyze',
+      'POST /api/commands/sc/spec-panel',
+      'GET /api/commands/sc/health'
+    ]
+  });
+});
+
+// Start server
+app.listen(PORT, () => {
+  console.log(`🚀 Backend server (test) running on http://localhost:${PORT}`);
+  console.log(`📡 Available endpoints:`);
+  console.log(`   POST http://localhost:${PORT}/api/agent/query`);
+  console.log(`   POST http://localhost:${PORT}/api/commands/sc/analyze`);
+  console.log(`   POST http://localhost:${PORT}/api/commands/sc/spec-panel`);
+  console.log(`   GET  http://localhost:${PORT}/health`);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('SIGTERM signal received: closing HTTP server');
+  process.exit(0);
+});

apps/backend/src/index.ts

@@ -0,0 +1,1295 @@
+// Load environment variables FIRST - before any other imports
+import { config } from 'dotenv';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+// Polyfills for PDF parsing environment (pdfjs-dist v4+ compatibility)
+// @ts-ignore
+if (typeof global.DOMMatrix === 'undefined') {
+  // @ts-ignore
+  global.DOMMatrix = class DOMMatrix {
+    a = 1; b = 0; c = 0; d = 1; e = 0; f = 0;
+    constructor() { }
+  };
+}
+// @ts-ignore
+if (typeof global.ImageData === 'undefined') {
+  // @ts-ignore
+  global.ImageData = class ImageData {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+    constructor(width: number, height: number) {
+      this.width = width;
+      this.height = height;
+      this.data = new Uint8ClampedArray(width * height * 4);
+    }
+  };
+}
+// @ts-ignore
+if (typeof global.Path2D === 'undefined') {
+  // @ts-ignore
+  global.Path2D = class Path2D { };
+}
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+// Load .env from backend directory, or root if not found
+config({ path: resolve(__dirname, '../.env') });
+config({ path: resolve(__dirname, '../../../.env') });
+
+// --- SAFETY CHECK: VISUAL CONFIRMATION ---
+const ENV_MODE = process.env.NODE_ENV || 'unknown';
+const DB_HOST = process.env.POSTGRES_HOST || 'unknown';
+const NEO_URI = process.env.NEO4J_URI || 'unknown';
+
+console.log('\n\n');
+if (ENV_MODE === 'production') {
+  console.error('╔══════════════════════════════════════════════════════════════╗');
+  console.error('║                    WARNING: PRODUCTION MODE                  ║');
+  console.error('║   You are running against LIVE DATA. Use extreme caution.    ║');
+  console.error('╚══════════════════════════════════════════════════════════════╝');
+} else {
+  console.log('╔══════════════════════════════════════════════════════════════╗');
+  console.log('║                 SAFE MODE: LOCAL DEVELOPMENT                 ║');
+  console.log('║                                                              ║');
+  console.log(`║  • Environment: ${ENV_MODE.padEnd(28)} ║`);
+  console.log(`║  • Postgres:    ${DB_HOST.padEnd(28)} ║`);
+  console.log(`║  • Neo4j:       ${NEO_URI.padEnd(28)} ║`);
+  console.log('╚══════════════════════════════════════════════════════════════╝');
+}
+console.log('\n');
+// -----------------------------------------
+
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'http';
+import { initializeDatabase } from './database/index.js';
+import { mcpRouter } from './mcp/mcpRouter.js';
+import { mcpRegistry } from './mcp/mcpRegistry.js';
+import { MCPWebSocketServer } from './mcp/mcpWebsocketServer.js';
+import { WebSocketServer as LogsWebSocketServer, WebSocket as LogsWebSocket } from 'ws';
+import { memoryRouter } from './services/memory/memoryController.js';
+import { sragRouter } from './services/srag/sragController.js';
+import { evolutionRouter } from './services/evolution/evolutionController.js';
+import { palRouter } from './services/pal/palController.js';
+import datasourcesRouter from './routes/datasources.js';
+import {
+  cmaContextHandler,
+  cmaIngestHandler,
+  cmaMemoryStoreHandler,
+  cmaMemoryRetrieveHandler,
+  sragQueryHandler,
+  sragGovernanceCheckHandler,
+  evolutionReportHandler,
+  evolutionGetPromptHandler,
+  evolutionAnalyzePromptsHandler,
+  palEventHandler,
+  palBoardActionHandler,
+  palOptimizeWorkflowHandler,
+  palAnalyzeSentimentHandler,
+  notesListHandler,
+  notesCreateHandler,
+  notesUpdateHandler,
+  notesDeleteHandler,
+  notesGetHandler,
+  widgetsInvokeHandler,
+  widgetsOsintInvestigateHandler,
+  widgetsThreatHuntHandler,
+  widgetsOrchestratorCoordinateHandler,
+  widgetsUpdateStateHandler,
+  visionaryGenerateHandler,
+  dataAnalysisHandler
+} from './mcp/toolHandlers.js';
+import { securityRouter } from './services/security/securityController.js';
+import { AgentOrchestratorServer } from './mcp/servers/AgentOrchestratorServer.js';
+import {
+  inputValidationMiddleware,
+  csrfProtectionMiddleware,
+  rateLimitingMiddleware
+} from './middleware/inputValidation.js';
+import { dataScheduler } from './services/ingestion/DataScheduler.js';
+import { logStream } from './services/logging/logStream.js';
+
+const app = express();
+const PORT = parseInt(process.env.PORT || '7860', 10);
+
+// CORS Configuration
+const corsOrigin = process.env.CORS_ORIGIN || '*';
+app.use(cors({
+  origin: corsOrigin === '*' ? '*' : corsOrigin.split(',').map(o => o.trim()),
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
+}));
+app.use(express.json({ limit: '10mb' }));
+app.use(rateLimitingMiddleware);
+app.use(inputValidationMiddleware);
+app.use(csrfProtectionMiddleware);
+
+// CRITICAL: Start server only after database is initialized
+async function startServer() {
+  try {
+    // ═══════════════════════════════════════════════════════════════════
+    // EARLY SERVER START - Start accepting connections ASAP
+    // ═══════════════════════════════════════════════════════════════════
+    const server = createServer(app);
+    const wsServer = new MCPWebSocketServer(server);
+
+    // Health check endpoint - FAST response
+    app.get('/health', async (req, res) => {
+      // Basic process health - registeredTools count fetched dynamically
+      res.json({
+        status: 'healthy', // Always return healthy if process is up
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime(),
+        environment: process.env.NODE_ENV,
+        registeredTools: mcpRegistry.getRegisteredTools().length
+      });
+    });
+
+    // Readiness/Liveness checks
+    app.get('/ready', (req, res) => res.json({ ready: true }));
+    app.get('/live', (req, res) => res.json({ live: true }));
+
+    // Start server IMMEDIATELY
+    server.listen(PORT, '0.0.0.0', () => {
+      console.log(`🚀 Backend server running on http://0.0.0.0:${PORT} (Early Start)`);
+      console.log(`📡 MCP WebSocket available at ws://0.0.0.0:${PORT}/mcp/ws`);
+    });
+
+    // Setup Logs WebSocket
+    const logsWsServer = new LogsWebSocketServer({ server, path: '/api/logs/stream' });
+    logsWsServer.on('connection', (socket: LogsWebSocket) => {
+      try {
+        // Send recent logs buffer
+        socket.send(JSON.stringify({ type: 'bootstrap', entries: logStream.getRecent({ limit: 50 }) }));
+      } catch (err) {
+        console.error('Failed to send initial log buffer:', err);
+      }
+
+      const listener = (entry: any) => {
+        if (socket.readyState === LogsWebSocket.OPEN) {
+          socket.send(JSON.stringify({ type: 'log', entry }));
+        }
+      };
+      logStream.on('log', listener);
+      socket.on('close', () => logStream.off('log', listener));
+    });
+
+    // Wire up WebSocket (async)
+    (async () => {
+      try {
+        const { setWebSocketServer } = await import('./mcp/autonomousRouter.js');
+        setWebSocketServer(wsServer);
+      } catch (err) { /* ignore */ }
+    })();
+
+
+    // Show environment banner
+    const isProd = process.env.NODE_ENV === 'production';
+    const neo4jUri = process.env.NEO4J_URI || 'bolt://localhost:7687';
+    const isAuraDB = neo4jUri.includes('neo4j.io') || neo4jUri.startsWith('neo4j+s://');
+
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    if (isProd || isAuraDB) {
+      console.log('  🔴 WIDGETTDC - PRODUCTION MODE');
+      console.log('  Neo4j: AuraDB Cloud');
+    } else {
+      console.log('  🟢 WIDGETTDC - DEVELOPMENT MODE');
+      console.log('  Neo4j: Local Docker');
+    }
+    console.log(`  URI: ${neo4jUri}`);
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+
+    // Step 0: Always initialize sql.js (used by CognitiveMemory, etc)
+    await initializeDatabase();
+    console.log('🗄️  SQLite (sql.js) initialized for memory systems');
+
+    // Step 1: Initialize Prisma (PostgreSQL + pgvector) - Primary database
+    try {
+      const { getDatabaseAdapter } = await import('./platform/db/PrismaDatabaseAdapter.js');
+      const prismaAdapter = getDatabaseAdapter();
+      await prismaAdapter.initialize();
+      console.log('🐘 PostgreSQL + pgvector initialized via Prisma');
+    } catch (prismaError) {
+      console.warn('⚠️  Prisma/PostgreSQL not available:', prismaError);
+      console.log('   Using SQLite (sql.js) as fallback for all storage');
+    }
+
+    // Step 1.5: Initialize Neo4j Graph Database
+    try {
+      const { getNeo4jGraphAdapter } = await import('./platform/graph/Neo4jGraphAdapter.js');
+      const neo4jAdapter = getNeo4jGraphAdapter();
+      await neo4jAdapter.initialize();
+      console.log('🕸️  Neo4j Graph Database initialized');
+
+      // Also connect Neo4jService (used by GraphMemoryService)
+      const { neo4jService } = await import('./database/Neo4jService.js');
+      await neo4jService.connect();
+      console.log('🕸️  Neo4j Service connected');
+
+      // Run initialization if database is empty
+      const stats = await neo4jAdapter.getStatistics();
+      if (stats.nodeCount < 5) {
+        console.log('📦 Neo4j database appears empty, running initialization...');
+        const { initializeNeo4j } = await import('./scripts/initNeo4j.js');
+        await initializeNeo4j();
+      }
+    } catch (error) {
+      console.warn('⚠️  Neo4j not available (optional):', error);
+      console.log('   Continuing without Neo4j - using implicit graph patterns');
+    }
+
+    // Step 1.6: Initialize Transformers.js Embeddings
+    try {
+      const { getTransformersEmbeddings } = await import('./platform/embeddings/TransformersEmbeddings.js');
+      const embeddings = getTransformersEmbeddings();
+      await embeddings.initialize();
+      console.log('🧠 Transformers.js Embeddings initialized');
+    } catch (error) {
+      console.warn('⚠️  Transformers.js not available (optional):', error);
+      console.log('   Continuing without local embeddings');
+    }
+
+    // Step 2: Register MCP tools (repositories can now safely use getDatabase())
+    mcpRegistry.registerTool('cma.context', cmaContextHandler);
+    mcpRegistry.registerTool('cma.ingest', cmaIngestHandler);
+    mcpRegistry.registerTool('cma.memory.store', cmaMemoryStoreHandler);
+    mcpRegistry.registerTool('cma.memory.retrieve', cmaMemoryRetrieveHandler);
+    mcpRegistry.registerTool('srag.query', sragQueryHandler);
+    mcpRegistry.registerTool('srag.governance-check', sragGovernanceCheckHandler);
+    mcpRegistry.registerTool('evolution.report-run', evolutionReportHandler);
+    mcpRegistry.registerTool('evolution.get-prompt', evolutionGetPromptHandler);
+    mcpRegistry.registerTool('evolution.analyze-prompts', evolutionAnalyzePromptsHandler);
+    mcpRegistry.registerTool('pal.event', palEventHandler);
+    mcpRegistry.registerTool('pal.board-action', palBoardActionHandler);
+    mcpRegistry.registerTool('pal.optimize-workflow', palOptimizeWorkflowHandler);
+    mcpRegistry.registerTool('pal.analyze-sentiment', palAnalyzeSentimentHandler);
+    mcpRegistry.registerTool('notes.list', notesListHandler);
+    mcpRegistry.registerTool('notes.create', notesCreateHandler);
+    mcpRegistry.registerTool('notes.update', notesUpdateHandler);
+    mcpRegistry.registerTool('notes.delete', notesDeleteHandler);
+    mcpRegistry.registerTool('notes.get', notesGetHandler);
+    mcpRegistry.registerTool('widgets.invoke', widgetsInvokeHandler);
+    mcpRegistry.registerTool('widgets.osint.investigate', widgetsOsintInvestigateHandler);
+    mcpRegistry.registerTool('widgets.threat.hunt', widgetsThreatHuntHandler);
+    mcpRegistry.registerTool('widgets.orchestrator.coordinate', widgetsOrchestratorCoordinateHandler);
+    mcpRegistry.registerTool('widgets.update_state', widgetsUpdateStateHandler);
+    mcpRegistry.registerTool('visionary.generate', visionaryGenerateHandler);
+    mcpRegistry.registerTool('data.analysis', dataAnalysisHandler);
+
+    // Project Memory tools
+    const {
+      projectMemoryLogEventHandler,
+      projectMemoryGetEventsHandler,
+      projectMemoryAddFeatureHandler,
+      projectMemoryUpdateFeatureHandler,
+      projectMemoryGetFeaturesHandler
+    } = await import('./mcp/projectMemoryHandlers.js');
+
+    mcpRegistry.registerTool('project.log_event', projectMemoryLogEventHandler);
+    mcpRegistry.registerTool('project.get_events', projectMemoryGetEventsHandler);
+    mcpRegistry.registerTool('project.add_feature', projectMemoryAddFeatureHandler);
+    mcpRegistry.registerTool('project.update_feature', projectMemoryUpdateFeatureHandler);
+    mcpRegistry.registerTool('project.get_features', projectMemoryGetFeaturesHandler);
+
+    // Data Ingestion tools
+    const {
+      ingestionStartHandler,
+      ingestionStatusHandler,
+      ingestionConfigureHandler,
+      ingestionCrawlHandler,
+      ingestionHarvestHandler
+    } = await import('./mcp/ingestionHandlers.js');
+
+    mcpRegistry.registerTool('ingestion.start', ingestionStartHandler);
+    mcpRegistry.registerTool('ingestion.status', ingestionStatusHandler);
+    mcpRegistry.registerTool('ingestion.configure', ingestionConfigureHandler);
+    mcpRegistry.registerTool('ingestion.crawl', ingestionCrawlHandler);
+    mcpRegistry.registerTool('ingestion.harvest', ingestionHarvestHandler);
+
+    // Autonomous Cognitive Tools
+    const {
+      autonomousGraphRAGHandler,
+      autonomousStateGraphHandler,
+      autonomousEvolutionHandler,
+      autonomousAgentTeamHandler,
+      autonomousAgentTeamCoordinateHandler
+    } = await import('./mcp/toolHandlers.js');
+
+    mcpRegistry.registerTool('autonomous.graphrag', autonomousGraphRAGHandler);
+    mcpRegistry.registerTool('autonomous.stategraph', autonomousStateGraphHandler);
+    mcpRegistry.registerTool('autonomous.evolve', autonomousEvolutionHandler);
+    mcpRegistry.registerTool('autonomous.agentteam', autonomousAgentTeamHandler);
+    mcpRegistry.registerTool('autonomous.agentteam.coordinate', autonomousAgentTeamCoordinateHandler);
+
+    // Vidensarkiv (Knowledge Archive) Tools - Persistent vector database
+    const {
+      vidensarkivSearchHandler,
+      vidensarkivAddHandler,
+      vidensarkivBatchAddHandler,
+      vidensarkivGetRelatedHandler,
+      vidensarkivListHandler,
+      vidensarkivStatsHandler
+    } = await import('./mcp/toolHandlers.js');
+
+    mcpRegistry.registerTool('vidensarkiv.search', vidensarkivSearchHandler);
+    mcpRegistry.registerTool('vidensarkiv.add', vidensarkivAddHandler);
+    mcpRegistry.registerTool('vidensarkiv.batch_add', vidensarkivBatchAddHandler);
+    mcpRegistry.registerTool('vidensarkiv.get_related', vidensarkivGetRelatedHandler);
+    mcpRegistry.registerTool('vidensarkiv.list', vidensarkivListHandler);
+    mcpRegistry.registerTool('vidensarkiv.stats', vidensarkivStatsHandler);
+
+    // TaskRecorder Tools
+    const {
+      taskRecorderGetSuggestionsHandler,
+      taskRecorderApproveHandler,
+      taskRecorderRejectHandler,
+      taskRecorderExecuteHandler,
+      taskRecorderGetPatternsHandler,
+      emailRagHandler
+    } = await import('./mcp/toolHandlers.js');
+
+    mcpRegistry.registerTool('taskrecorder.get_suggestions', taskRecorderGetSuggestionsHandler);
+    mcpRegistry.registerTool('taskrecorder.approve', taskRecorderApproveHandler);
+    mcpRegistry.registerTool('taskrecorder.reject', taskRecorderRejectHandler);
+    mcpRegistry.registerTool('taskrecorder.execute', taskRecorderExecuteHandler);
+    mcpRegistry.registerTool('taskrecorder.get_patterns', taskRecorderGetPatternsHandler);
+    mcpRegistry.registerTool('email.rag', emailRagHandler);
+
+    // Document Generator Tools
+    const {
+      docgenPowerpointCreateHandler,
+      docgenWordCreateHandler,
+      docgenExcelCreateHandler,
+      docgenStatusHandler
+    } = await import('./mcp/toolHandlers.js');
+
+    mcpRegistry.registerTool('docgen.powerpoint.create', docgenPowerpointCreateHandler);
+    mcpRegistry.registerTool('docgen.word.create', docgenWordCreateHandler);
+    mcpRegistry.registerTool('docgen.excel.create', docgenExcelCreateHandler);
+    mcpRegistry.registerTool('docgen.status', docgenStatusHandler);
+
+    // DevTools Guardian Tools
+    const { handleDevToolsRequest } = await import('./mcp/devToolsHandlers.js');
+    mcpRegistry.registerTool('devtools-status', handleDevToolsRequest);
+    mcpRegistry.registerTool('devtools-scan', handleDevToolsRequest);
+    mcpRegistry.registerTool('devtools-validate', handleDevToolsRequest);
+
+    const { tdcGeneratePresentationHandler } = await import('./mcp/tdcHandlers.js');
+    mcpRegistry.registerTool('tdc.generate_presentation', tdcGeneratePresentationHandler);
+
+    // Serve public files (for generated presentations)
+    app.use(express.static('public'));
+
+    // Step 3: Initialize Agent Orchestrator
+    const orchestrator = new AgentOrchestratorServer();
+    mcpRegistry.registerServer(orchestrator);
+    console.log('🤖 Agent Orchestrator initialized');
+
+    // Step 3.5: Initialize Autonomous Intelligence System
+    const { initCognitiveMemory } = await import('./mcp/memory/CognitiveMemory.js');
+    const { getSourceRegistry } = await import('./mcp/SourceRegistry.js');
+    const { initAutonomousAgent, startAutonomousLearning } = await import('./mcp/autonomousRouter.js');
+    const { autonomousRouter } = await import('./mcp/autonomousRouter.js');
+    const { getSqlJsDatabase } = await import('./database/index.js');
+    const { existsSync } = await import('fs');
+    const { readFileSync } = await import('fs');
+    const yaml = (await import('js-yaml')).default;
+
+    // Use raw sql.js database for memory systems (they need exec() method)
+    const sqlJsDb = getSqlJsDatabase();
+    if (sqlJsDb) {
+      initCognitiveMemory(sqlJsDb);
+      console.log('🧠 Cognitive Memory initialized');
+    } else {
+      console.warn('⚠️ Cognitive Memory running in degraded mode (no sql.js database)');
+      initCognitiveMemory();
+    }
+
+    // Initialize Unified Memory System
+    const { unifiedMemorySystem } = await import('./mcp/cognitive/UnifiedMemorySystem.js');
+    unifiedMemorySystem.init();
+    console.log('🧠 Unified Memory System initialized');
+
+    const registry = getSourceRegistry();
+
+    // Register agents-yaml data source
+    registry.registerSource({
+      name: 'agents-yaml',
+      type: 'file',
+      capabilities: ['agents.*', 'agents.list', 'agents.get', 'agents.trigger'],
+      isHealthy: async () => existsSync('agents/registry.yml'),
+      estimatedLatency: 50,
+      costPerQuery: 0,
+      query: async (operation: string, params: any) => {
+        const content = readFileSync('agents/registry.yml', 'utf-8');
+        const data = yaml.load(content) as any;
+
+        if (operation === 'list') {
+          return data.agents || [];
+        } else if (operation === 'get' && params?.id) {
+          return data.agents?.find((a: any) => a.id === params.id);
+        }
+
+        return data.agents || [];
+      }
+    });
+
+    // Step 3.6: Initialize MCP → Autonomous Integration (non-blocking with timeout)
+    const autonomousInitPromise = (async () => {
+      try {
+        const timeoutPromise = new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Autonomous init timeout')), 5000)
+        );
+        const { initializeAutonomousSources } = await import('./mcp/autonomous/MCPIntegration.js');
+        await Promise.race([initializeAutonomousSources(), timeoutPromise]);
+        console.log('🔗 MCP tools registered as autonomous sources');
+
+        const agent = initAutonomousAgent();
+        console.log('🤖 Autonomous Agent initialized');
+
+        startAutonomousLearning(agent, 300000);
+        console.log('🔄 Autonomous learning started (5min intervals)');
+      } catch (err: any) {
+        console.warn('⚠️ Autonomous sources initialization skipped:', err.message);
+      }
+    })();
+    // Don't await - let it run in background
+
+    // Step 3.7: Start HansPedder orchestrator (non-blocking)
+    (async () => {
+      try {
+        const { startHansPedder } = await import('./orchestrator/hansPedder.js');
+        await startHansPedder();
+        console.log('👔 HansPedder orchestrator started');
+      } catch (err) {
+        console.error('⚠️ Failed to start HansPedder:', err);
+      }
+    })();
+
+    // Step 3.8: Start Data Ingestion Scheduler
+    dataScheduler.start();
+    console.log('⏰ Data Ingestion Scheduler started');
+
+    // Step 3.8.5: Start NudgeService (aggressive data generation every 15 min)
+    const { nudgeService } = await import('./services/NudgeService.js');
+    nudgeService.start();
+
+    // Step 3.9: Start HansPedder Agent Controller (non-blocking)
+    (async () => {
+      try {
+        const { hansPedderAgent } = await import('./services/agent/HansPedderAgentController.js');
+        hansPedderAgent.start();
+        console.log('🤖 HansPedder Agent Controller started (continuous testing + nudges)');
+      } catch (err) {
+        console.error('⚠️ Failed to start HansPedder Agent Controller:', err);
+      }
+    })();
+
+    // Step 4: Setup routes
+    app.use('/api/mcp', mcpRouter);
+    app.use('/api/mcp/autonomous', autonomousRouter);
+    app.use('/api/memory', memoryRouter);
+    app.use('/api/srag', sragRouter);
+    app.use('/api/evolution', evolutionRouter);
+    app.use('/api/harvest', (req, res, next) => {
+      req.url = `/harvest${req.url}`;
+      evolutionRouter(req, res, next);
+    });
+    app.use('/api/pal', palRouter);
+    app.use('/api/security', securityRouter);
+
+    // HansPedder Agent Controller routes
+    const hanspedderRoutes = (await import('./routes/hanspedderRoutes.js')).default;
+    app.use('/api/hanspedder', hanspedderRoutes);
+
+    // Prototype Generation routes (PRD to Prototype)
+    const prototypeRoutes = (await import('./routes/prototype.js')).default;
+    app.use('/api/prototype', prototypeRoutes);
+
+    // System Information routes (CPU, Memory, GPU, Network stats)
+    const sysRoutes = (await import('./routes/sys.js')).default;
+    app.use('/api/sys', sysRoutes);
+    console.log('📊 System Info API mounted at /api/sys');
+
+    // Neural Chat - Agent-to-Agent Communication
+    const { neuralChatRouter } = await import('./services/NeuralChat/index.js');
+    app.use('/api/neural-chat', neuralChatRouter);
+    console.log('💬 Neural Chat API mounted at /api/neural-chat');
+
+    // Knowledge Compiler - System State Aggregation
+    const knowledgeRoutes = (await import('./routes/knowledge.js')).default;
+    app.use('/api/knowledge', knowledgeRoutes);
+    console.log('🧠 Knowledge API mounted at /api/knowledge');
+
+    // Knowledge Acquisition - The Omni-Harvester
+    const acquisitionRoutes = (await import('./routes/acquisition.js')).default;
+    app.use('/api/acquisition', acquisitionRoutes);
+    console.log('🌾 Omni-Harvester API mounted at /api/acquisition');
+
+    // Email API - Cloud-compatible email fetching via IMAP
+    const emailRoutes = (await import('./routes/email.js')).default;
+    app.use('/api/email', emailRoutes);
+    console.log('📧 Email API mounted at /api/email');
+
+    // Start KnowledgeCompiler auto-compilation (every 60 seconds)
+    const { knowledgeCompiler } = await import('./services/Knowledge/index.js');
+    knowledgeCompiler.startAutoCompilation(60000);
+    console.log('🧠 KnowledgeCompiler auto-compilation started');
+
+    // ═══════════════════════════════════════════════════════════════════
+    // 🛡️ BOOTSTRAP HEALTH CHECKS now run inside BootstrapGate.init()
+    // Prevents "Death on Startup" if Neo4j/DB unavailable
+    // ═══════════════════════════════════════════════════════════════════
+    const bootstrapHealthCheck = async (): Promise<{ ready: boolean; degraded: boolean; services: any[] }> => {
+      const services: { name: string; status: 'healthy' | 'degraded' | 'unavailable'; latencyMs?: number }[] = [];
+      let criticalFailure = false;
+
+      // Check Neo4j
+      try {
+        const start = Date.now();
+        const { neo4jAdapter } = await import('./adapters/Neo4jAdapter.js');
+        await neo4jAdapter.executeQuery('RETURN 1 as ping');
+        services.push({ name: 'Neo4j', status: 'healthy', latencyMs: Date.now() - start });
+        console.log('✅ Neo4j: HEALTHY');
+      } catch (err: any) {
+        services.push({ name: 'Neo4j', status: 'degraded' });
+        console.warn('⚠️ Neo4j: DEGRADED - continuing without graph features');
+      }
+
+      // Check Prisma/PostgreSQL (already initialized above)
+      try {
+        const start = Date.now();
+        // Prisma is already connected if we got here
+        services.push({ name: 'PostgreSQL', status: 'healthy', latencyMs: Date.now() - start });
+        console.log('✅ PostgreSQL: HEALTHY (Prisma connected)');
+      } catch (err: any) {
+        services.push({ name: 'PostgreSQL', status: 'degraded' });
+        console.warn('⚠️ PostgreSQL: DEGRADED - some features may be unavailable');
+      }
+
+      // Check filesystem (DropZone)
+      try {
+        const fs = await import('fs/promises');
+        const { DROPZONE_PATH } = await import('./config.js');
+        await fs.access(DROPZONE_PATH);
+        services.push({ name: 'Filesystem', status: 'healthy' });
+        console.log(`✅ Filesystem: HEALTHY (${DROPZONE_PATH})`);
+      } catch {
+        services.push({ name: 'Filesystem', status: 'degraded' });
+        console.warn('⚠️ Filesystem: DropZone not accessible');
+      }
+
+      const degraded = services.some(s => s.status === 'degraded');
+      return { ready: !criticalFailure, degraded, services };
+    };
+
+    console.log('\n🔍 Running Bootstrap Health Check...');
+    const bootHealth = await bootstrapHealthCheck();
+
+    if (!bootHealth.ready) {
+      console.error('💀 CRITICAL: Bootstrap health check failed - aborting startup');
+      process.exit(1);
+    }
+
+    if (bootHealth.degraded) {
+      console.warn('⚠️ WARNING: Starting in DEGRADED MODE - some features may be unavailable\n');
+    } else {
+      console.log('✅ All systems nominal - proceeding with startup\n');
+    }
+
+    // Server started early at top of startServer()
+
+    // ═══════════════════════════════════════════════════════════════════
+    // CONTINUING INITIALIZATION...
+    // ═══════════════════════════════════════════════════════════════════
+
+    // ============================================
+    // KNOWLEDGE COMPILER API - System Intelligence
+    // ============================================
+    const knowledgeApi = (await import('./api/knowledge.js')).default;
+    app.use('/api/knowledge', knowledgeApi);
+    console.log('📚 Knowledge Compiler API mounted at /api/knowledge');
+
+    const logsRouter = (await import('./routes/logs.js')).default;
+    app.use('/api/logs', logsRouter);
+    console.log('📝 Log API mounted at /api/logs');
+
+    // HyperLog API - Real-time intelligence monitoring for NeuroLink widget
+    app.get('/api/hyper/events', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const events = hyperLog.getHistory(50);
+        const metrics = hyperLog.getMetrics();
+        res.json({ events, metrics });
+      } catch (error) {
+        console.error('HyperLog error:', error);
+        res.status(500).json({ error: 'HyperLog unavailable', events: [], metrics: { totalThoughts: 0, toolUsageRate: 0, activeAgents: 0 } });
+      }
+    });
+
+    // ============================================
+    // SEMANTIC BUS: Widget Telepathy API
+    // ============================================
+
+    // Dream API - Semantic search across collective memory
+    app.post('/api/hyper/dream', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { query, limit = 5, minScore = 0.6 } = req.body;
+
+        if (!query) {
+          return res.status(400).json({ error: 'Query is required' });
+        }
+
+        const results = await hyperLog.findRelatedThoughts(query, limit, minScore);
+        const canDream = hyperLog.canDream();
+
+        res.json({
+          results,
+          query,
+          dreamMode: canDream ? 'semantic' : 'keyword',
+          timestamp: Date.now()
+        });
+      } catch (error) {
+        console.error('Dream API error:', error);
+        res.status(500).json({ error: 'Dream failed', results: [] });
+      }
+    });
+
+    // Broadcast API - Widget sends a thought into the collective
+    app.post('/api/hyper/broadcast', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { type, agent, content, metadata = {} } = req.body;
+
+        if (!type || !agent || !content) {
+          return res.status(400).json({ error: 'type, agent, and content are required' });
+        }
+
+        const eventId = await hyperLog.log(type, agent, content, metadata);
+
+        res.json({
+          success: true,
+          eventId,
+          timestamp: Date.now()
+        });
+      } catch (error) {
+        console.error('Broadcast API error:', error);
+        res.status(500).json({ error: 'Broadcast failed' });
+      }
+    });
+
+    // Find similar thoughts to a specific event
+    app.get('/api/hyper/similar/:eventId', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { eventId } = req.params;
+        const limit = parseInt(req.query.limit as string) || 5;
+
+        const results = await hyperLog.findSimilarTo(eventId, limit);
+
+        res.json({ results, eventId });
+      } catch (error) {
+        console.error('Similar API error:', error);
+        res.status(500).json({ error: 'Similarity search failed', results: [] });
+      }
+    });
+
+    // Get causal path leading to an event (rewind the brain)
+    app.get('/api/hyper/rewind/:eventId', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { eventId } = req.params;
+        const maxDepth = parseInt(req.query.maxDepth as string) || 50;
+
+        const path = await hyperLog.getCausalPath(eventId, maxDepth);
+
+        res.json({ path, eventId, depth: path.length });
+      } catch (error) {
+        console.error('Rewind API error:', error);
+        res.status(500).json({ error: 'Rewind failed', path: [] });
+      }
+    });
+
+    // Start a new thought chain (correlation)
+    app.post('/api/hyper/chain/start', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { label } = req.body;
+
+        const correlationId = hyperLog.startChain(label);
+
+        res.json({ correlationId, label });
+      } catch (error) {
+        console.error('Chain start error:', error);
+        res.status(500).json({ error: 'Failed to start chain' });
+      }
+    });
+
+    // Get brain status (can it dream?)
+    app.get('/api/hyper/status', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const metrics = hyperLog.getMetrics();
+        const canDream = hyperLog.canDream();
+
+        res.json({
+          canDream,
+          metrics,
+          status: canDream ? 'dreaming' : 'awake',
+          timestamp: Date.now()
+        });
+      } catch (error) {
+        console.error('Status API error:', error);
+        res.status(500).json({ error: 'Status unavailable' });
+      }
+    });
+
+    // ============================================
+    // THE STRATEGIST - Team Delegation API
+    // ============================================
+
+    /**
+     * POST /api/team/delegate
+     * The Strategist delegates tasks to team members (Architect, Visionary)
+     */
+    app.post('/api/team/delegate', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const {
+          task,
+          assignTo,
+          priority = 'medium',
+          context = {},
+          parentTaskId
+        } = req.body;
+
+        if (!task || !assignTo) {
+          return res.status(400).json({
+            error: 'Missing required fields: task, assignTo'
+          });
+        }
+
+        // Log the delegation event
+        const eventId = await hyperLog.log(
+          'DELEGATION',
+          'TheStrategist',
+          `Delegating to ${assignTo}: ${task}`,
+          {
+            assignedTo: assignTo,
+            priority,
+            context,
+            parentTaskId,
+            status: 'pending'
+          }
+        );
+
+        // Broadcast the delegation for the assigned widget to pick up
+        await hyperLog.log(
+          'THOUGHT',
+          assignTo,
+          `Received task from Strategist: ${task}`,
+          {
+            delegationId: eventId,
+            priority,
+            context
+          }
+        );
+
+        res.json({
+          success: true,
+          delegationId: eventId,
+          message: `Task delegated to ${assignTo}`,
+          task: {
+            id: eventId,
+            description: task,
+            assignedTo: assignTo,
+            priority,
+            status: 'pending',
+            createdAt: Date.now()
+          }
+        });
+
+      } catch (error) {
+        console.error('Delegation API error:', error);
+        res.status(500).json({ error: 'Delegation failed' });
+      }
+    });
+
+    /**
+     * GET /api/team/tasks
+     * Get all delegated tasks and their status
+     */
+    app.get('/api/team/tasks', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { assignedTo, status } = req.query;
+
+        // Search for delegation events
+        const allEvents = hyperLog.getHistory(100);
+        let tasks = allEvents.filter(e => e.type === 'DELEGATION');
+
+        if (assignedTo) {
+          tasks = tasks.filter(t => t.metadata?.assignedTo === assignedTo);
+        }
+        if (status) {
+          tasks = tasks.filter(t => t.metadata?.status === status);
+        }
+
+        res.json({
+          tasks: tasks.map(t => ({
+            id: t.id,
+            description: t.content,
+            assignedTo: t.metadata?.assignedTo,
+            priority: t.metadata?.priority,
+            status: t.metadata?.status || 'pending',
+            createdAt: t.timestamp,
+            context: t.metadata?.context
+          })),
+          total: tasks.length
+        });
+
+      } catch (error) {
+        console.error('Tasks API error:', error);
+        res.status(500).json({ error: 'Failed to fetch tasks' });
+      }
+    });
+
+    /**
+     * PUT /api/team/tasks/:taskId/status
+     * Update task status (e.g., in_progress, completed, blocked)
+     */
+    app.put('/api/team/tasks/:taskId/status', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const { taskId } = req.params;
+        const { status, result, notes } = req.body;
+
+        if (!status) {
+          return res.status(400).json({ error: 'Status is required' });
+        }
+
+        // Log the status update
+        const eventId = await hyperLog.log(
+          'REASONING_UPDATE',
+          'TheStrategist',
+          `Task ${taskId} status updated to: ${status}`,
+          {
+            taskId,
+            newStatus: status,
+            result,
+            notes,
+            updatedAt: Date.now()
+          }
+        );
+
+        res.json({
+          success: true,
+          taskId,
+          status,
+          updateEventId: eventId
+        });
+
+      } catch (error) {
+        console.error('Task update API error:', error);
+        res.status(500).json({ error: 'Failed to update task' });
+      }
+    });
+
+    /**
+     * POST /api/team/plan
+     * The Strategist creates a multi-step plan with dependencies
+     */
+    app.post('/api/team/plan', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const {
+          goal,
+          steps,
+          teamMembers = ['TheArchitect', 'TheVisionary']
+        } = req.body;
+
+        if (!goal || !steps || !Array.isArray(steps)) {
+          return res.status(400).json({
+            error: 'Missing required fields: goal, steps (array)'
+          });
+        }
+
+        // Start a new correlation chain for this plan
+        const planId = hyperLog.startChain(`Plan: ${goal.substring(0, 50)}`);
+
+        // Log the plan creation
+        await hyperLog.log(
+          'CRITICAL_DECISION',
+          'TheStrategist',
+          `Created plan: ${goal}`,
+          {
+            planId,
+            totalSteps: steps.length,
+            teamMembers,
+            steps: steps.map((s: any, i: number) => ({
+              order: i + 1,
+              ...s
+            }))
+          }
+        );
+
+        // Create delegation events for each step
+        const delegations: { id: string; step: string }[] = [];
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          const eventId = await hyperLog.log(
+            'DELEGATION',
+            'TheStrategist',
+            `Step ${i + 1}: ${step.task}`,
+            {
+              planId,
+              stepOrder: i + 1,
+              assignedTo: step.assignTo || teamMembers[i % teamMembers.length],
+              dependsOn: step.dependsOn || (i > 0 ? [delegations[i - 1].id] : []),
+              status: 'pending',
+              priority: step.priority || 'medium'
+            }
+          );
+          delegations.push({ id: eventId, step: step.task });
+        }
+
+        res.json({
+          success: true,
+          planId,
+          goal,
+          steps: delegations.map((d, i) => ({
+            ...d,
+            order: i + 1,
+            assignedTo: steps[i].assignTo || teamMembers[i % teamMembers.length]
+          })),
+          totalSteps: steps.length
+        });
+
+      } catch (error) {
+        console.error('Plan API error:', error);
+        res.status(500).json({ error: 'Failed to create plan' });
+      }
+    });
+
+    /**
+     * GET /api/team/status
+     * Get overall team status and workload
+     */
+    app.get('/api/team/status', async (req, res) => {
+      try {
+        const { hyperLog } = await import('./services/hyper-log.js');
+        const allEvents = hyperLog.getHistory(200);
+
+        const delegations = allEvents.filter(e => e.type === 'DELEGATION');
+        const byAgent: Record<string, any> = {};
+
+        // Aggregate by team member
+        for (const d of delegations) {
+          const agent = d.metadata?.assignedTo || 'Unassigned';
+          if (!byAgent[agent]) {
+            byAgent[agent] = {
+              name: agent,
+              pending: 0,
+              inProgress: 0,
+              completed: 0,
+              blocked: 0,
+              tasks: []
+            };
+          }
+
+          const status = d.metadata?.status || 'pending';
+          byAgent[agent][status === 'in_progress' ? 'inProgress' : status]++;
+          byAgent[agent].tasks.push({
+            id: d.id,
+            task: d.content,
+            status,
+            priority: d.metadata?.priority
+          });
+        }
+
+        res.json({
+          team: Object.values(byAgent),
+          summary: {
+            totalTasks: delegations.length,
+            pending: delegations.filter(d => d.metadata?.status === 'pending').length,
+            inProgress: delegations.filter(d => d.metadata?.status === 'in_progress').length,
+            completed: delegations.filter(d => d.metadata?.status === 'completed').length
+          },
+          lastUpdated: Date.now()
+        });
+
+      } catch (error) {
+        console.error('Team status API error:', error);
+        res.status(500).json({ error: 'Failed to fetch team status' });
+      }
+    });
+
+    // ============================================
+    // THE COLONIZER - API Assimilation Engine
+    // ============================================
+
+    /**
+     * POST /api/evolution/colonize
+     * Assimilate a new external API into the WidgeTDC swarm
+     */
+    app.post('/api/evolution/colonize', async (req, res) => {
+      try {
+        const { colonizerService } = await import('./services/colonizer-service.js');
+        const { systemName, documentation, generateTests = false, dryRun = false } = req.body;
+
+        if (!systemName || !documentation) {
+          return res.status(400).json({
+            error: 'Missing required fields: systemName, documentation'
+          });
+        }
+
+        console.log(`🛸 [COLONIZER API] Received assimilation request for: ${systemName}`);
+
+        const result = await colonizerService.assimilateSystem({
+          systemName,
+          apiSpecContent: documentation,
+          generateTests,
+          dryRun
+        });
+
+        res.json(result);
+
+      } catch (error: any) {
+        console.error('Colonizer API error:', error);
+        res.status(500).json({ error: error.message || 'Assimilation failed' });
+      }
+    });
+
+    /**
+     * GET /api/evolution/systems
+     * List all assimilated systems
+     */
+    app.get('/api/evolution/systems', async (req, res) => {
+      try {
+        const { colonizerService } = await import('./services/colonizer-service.js');
+        const systems = await colonizerService.listAssimilatedSystems();
+
+        res.json({
+          systems,
+          count: systems.length,
+          toolsDirectory: 'apps/backend/src/tools/generated'
+        });
+
+      } catch (error: any) {
+        console.error('Systems list API error:', error);
+        res.status(500).json({ error: 'Failed to list systems' });
+      }
+    });
+
+    /**
+     * DELETE /api/evolution/systems/:systemName
+     * Remove an assimilated system
+     */
+    app.delete('/api/evolution/systems/:systemName', async (req, res) => {
+      try {
+        const { colonizerService } = await import('./services/colonizer-service.js');
+        const { systemName } = req.params;
+
+        const success = await colonizerService.removeSystem(systemName);
+
+        if (success) {
+          res.json({
+            success: true,
+            message: `System ${systemName} removed. Restart server to complete removal.`
+          });
+        } else {
+          res.status(404).json({
+            success: false,
+            message: `System ${systemName} not found`
+          });
+        }
+
+      } catch (error: any) {
+        console.error('System removal API error:', error);
+        res.status(500).json({ error: 'Failed to remove system' });
+      }
+    });
+
+    /**
+     * GET /api/evolution/graph/stats
+     * Get Neo4j graph statistics for 3D visualization
+     * 🔗 NEURAL LINK ENDPOINT
+     */
+    app.get('/api/evolution/graph/stats', async (_req, res) => {
+      try {
+        const { neo4jService } = await import('./database/Neo4jService.js');
+
+        // 1. Fetch Stats
+        const statsQuery = `
+          MATCH (n) 
+          OPTIONAL MATCH ()-[r]->() 
+          RETURN count(DISTINCT n) as nodes, count(DISTINCT r) as relationships
+        `;
+        const statsResult = await neo4jService.runQuery(statsQuery);
+        const stats = {
+          nodes: statsResult[0]?.nodes?.toNumber ? statsResult[0].nodes.toNumber() : (statsResult[0]?.nodes || 0),
+          relationships: statsResult[0]?.relationships?.toNumber ? statsResult[0].relationships.toNumber() : (statsResult[0]?.relationships || 0)
+        };
+
+        // 2. Fetch Sample Nodes for Visualization
+        const vizQuery = `
+          MATCH (n) 
+          RETURN n, labels(n) as labels 
+          LIMIT 100
+        `;
+        const vizResult = await neo4jService.runQuery(vizQuery);
+
+        // Map Neo4j structure to clean JSON for Frontend
+        const visualNodes = vizResult.map(row => {
+          const node = row.n;
+          return {
+            id: node.elementId, // v6: use elementId instead of identity
+            name: node.properties.name || node.properties.title || `Node ${node.elementId}`,
+            labels: row.labels || node.labels,
+            type: (row.labels && row.labels.includes('Directory')) ? 'directory' : 'file', // Simple heuristic
+            properties: node.properties
+          };
+        });
+
+        // 3. Fetch Sample Relationships
+        const relQuery = `
+          MATCH (n)-[r]->(m)
+          RETURN r, elementId(n) as source, elementId(m) as target
+          LIMIT 200
+        `;
+        const relResult = await neo4jService.runQuery(relQuery);
+
+        const visualLinks = relResult.map(row => ({
+          source: row.source, // elementId is string
+          target: row.target, // elementId is string
+          type: row.r.type,
+          id: row.r.elementId // v6: use elementId
+        }));
+
+        // 4. Send Combined Payload
+        res.json({
+          timestamp: new Date().toISOString(),
+          stats: stats,
+          nodes: visualNodes,
+          links: visualLinks,
+          // Backwards compatibility fields
+          totalNodes: stats.nodes,
+          totalRelationships: stats.relationships,
+          importGraph: visualLinks.map(l => ({ from: l.source, to: l.target }))
+        });
+
+      } catch (error: any) {
+        console.error('❌ API Error in /graph/stats:', error);
+        res.status(500).json({
+          error: 'Failed to retrieve neural link data',
+          details: error.message,
+          nodes: [],
+          links: []
+        });
+      }
+    });
+
+    /**
+     * GET /api/codex/status
+     * Get Codex Symbiosis status
+     */
+    app.get('/api/codex/status', async (_req, res) => {
+      try {
+        const { CODEX_VERSION } = await import('./config/codex.js');
+
+        res.json({
+          version: CODEX_VERSION,
+          status: 'active',
+          injectionPoint: 'LLM Service',
+          principles: [
+            'HUKOMMELSE - Check context before responding',
+            'TRANSPARENS - Explain all actions',
+            'SIKKERHED - Never leak PII without approval',
+            'SAMARBEJDE - Compatible with team patterns',
+            'VÆKST - Suggest improvements when seen',
+            'YDMYGHED - Ask when uncertain',
+            'LOYALITET - Serve The Executive'
+          ],
+          message: 'Codex Symbiosis is active. All AI responses are filtered through the ethical framework.'
+        });
+
+      } catch (error: any) {
+        res.status(500).json({ error: 'Failed to get Codex status' });
+      }
+    });
+
+    // ============================================
+    // OMNI-HARVESTER - Knowledge Acquisition API
+    // ============================================
+    const acquisitionRouter = (await import('./routes/acquisition.js')).default;
+    app.use('/api/acquisition', acquisitionRouter);
+    console.log('🌾 Omni-Harvester API mounted at /api/acquisition');
+
+    // Graceful shutdown handler
+    const gracefulShutdown = async (signal: string) => {
+      console.log(`\n🛑 ${signal} received: starting graceful shutdown...`);
+
+      // Stop accepting new connections
+      server.close(() => {
+        console.log('  ✓ HTTP server closed');
+      });
+
+      // Stop scheduled tasks
+      try {
+        dataScheduler.stop();
+        console.log('  ✓ Data scheduler stopped');
+      } catch { /* ignore */ }
+
+      // Stop HansPedder agent
+      try {
+        const { hansPedderAgent } = await import('./services/agent/HansPedderAgentController.js');
+        hansPedderAgent.stop();
+        console.log('  ✓ HansPedder agent stopped');
+      } catch { /* ignore */ }
+
+      // Close Neo4j connections
+      try {
+        const { neo4jService } = await import('./database/Neo4jService.js');
+        await neo4jService.close();
+        console.log('  ✓ Neo4j connection closed');
+      } catch { /* ignore */ }
+
+      // Close SQLite database
+      try {
+        const { closeDatabase } = await import('./database/index.js');
+        closeDatabase();
+        console.log('  ✓ SQLite database closed');
+      } catch { /* ignore */ }
+
+      console.log('✅ Graceful shutdown complete');
+      process.exit(0);
+    };
+
+    // Handle shutdown signals
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+    // Handle uncaught errors gracefully
+    process.on('uncaughtException', (error) => {
+      console.error('💥 Uncaught Exception:', error);
+      gracefulShutdown('uncaughtException');
+    });
+
+    process.on('unhandledRejection', (reason, promise) => {
+      console.error('💥 Unhandled Rejection at:', promise, 'reason:', reason);
+      // Don't exit on unhandled rejections, just log
+    });
+
+  } catch (error) {
+    console.error('❌ Failed to start server:', error);
+    process.exit(1);
+  }
+}
+
+// Start the application
+startServer();

apps/backend/src/mcp/EventBus.ts

@@ -0,0 +1,140 @@
+import { EventEmitter } from 'events';
+import { persistentEventBus } from '../services/EventBus.js';
+
+export type EventType =
+    | 'system.alert'
+    | 'security.alert'
+    | 'agent.decision'
+    | 'agent.log'
+    | 'mcp.tool.executed'
+    | 'autonomous.task.executed'
+    | 'taskrecorder.suggestion.created'
+    | 'taskrecorder.suggestion.approved'
+    | 'taskrecorder.execution.started'
+    | 'data:ingested'
+    | 'widget:invoke'
+    | 'osint:investigation:start'
+    | 'threat:hunt:start'
+    | 'orchestrator:coordinate:start'
+    | 'docgen:powerpoint:create'
+    | 'docgen:word:create'
+    | 'docgen:excel:create'
+    | 'docgen:powerpoint:completed'
+    | 'docgen:powerpoint:failed'
+    | 'docgen:word:completed'
+    | 'docgen:word:failed'
+    | 'docgen:excel:completed'
+    | 'docgen:excel:failed'
+    | 'docgen:powerpoint:created'
+    | 'docgen:powerpoint:error'
+    | 'devtools:scan:started'
+    | 'devtools:scan:completed'
+    | 'devtools:scan:failed'
+    // Data ingestion events
+    | 'ingestion:emails'
+    | 'ingestion:news'
+    | 'ingestion:documents'
+    | 'ingestion:assets'
+    | 'threat:detected'
+    | 'system:heartbeat'
+    | 'system:force-refresh'
+    // WebSocket events
+    | 'ws:connected'
+    | 'ws:disconnected'
+    // HansPedder agent events
+    | 'hanspedder:test-results'
+    | 'hanspedder:nudge'
+    | 'hanspedder:fix-reported'
+    // System health events
+    | 'system:backend-unhealthy'
+    | 'system:health-check'
+    | 'mcp:reconnect-requested'
+    // Prototype generation events
+    | 'prototype.generation.started'
+    | 'prototype.generation.completed'
+    | 'prototype.generation.error'
+    | 'prototype.saved'
+    | 'prototype.deleted'
+    // MCP tool events
+    | 'mcp.tool.call'
+    | 'mcp.tool.result'
+    | 'mcp.tool.error'
+    // NudgeService events
+    | 'nudge.system_metrics'
+    | 'nudge.cycle_complete'
+    | 'agent.ping'
+    | 'system.activity'
+    | 'data.push'
+    // Autonomous memory events
+    | 'pattern:recorded'
+    | 'failure:recorded'
+    | 'failure:recurring'
+    | 'recovery:completed'
+    | 'health:recorded'
+    | 'source:health'
+    | 'decision:made'
+    // Email events
+    | 'email:refresh'
+    | 'email:new';
+
+export interface BaseEvent {
+    type: EventType;
+    timestamp: string;
+    source: string;
+    payload: any;
+}
+
+/**
+ * Unified Event Bus Interface
+ * Uses RedisEventBus in production for persistence and scalability
+ * Falls back to in-memory EventEmitter in development
+ */
+class MCPEventBus extends EventEmitter {
+    constructor() {
+        super();
+        // init persistent bus (no await needed; it will fallback if unavailable)
+        persistentEventBus.init().catch((err) => {
+            console.warn('⚠️ Redis Streams not ready, using in-memory bus:', err?.message || err);
+        });
+    }
+
+    async initialize(): Promise<void> {
+        // persistent bus handles its own initialization
+        await persistentEventBus.init();
+    }
+
+    emitEvent(event: BaseEvent) {
+        // Publish to stream (persistent) or fallback to memory
+        persistentEventBus.publish(event.type, event);
+        if (!persistentEventBus.isReady()) {
+            // Immediate local delivery for dev/fallback
+            super.emit(event.type, event);
+            super.emit('*', event);
+        }
+    }
+
+    // Direct emit for convenience (for non-BaseEvent objects)
+    emit(type: EventType | '*', ...args: any[]): boolean {
+        if (type !== '*') {
+            persistentEventBus.publish(type, args[0]);
+        }
+        if (!persistentEventBus.isReady()) {
+            return super.emit(type, ...args);
+        }
+        return true;
+    }
+
+    onEvent(type: EventType | '*', listener: (event: BaseEvent | any) => void) {
+        if (type !== '*') {
+            persistentEventBus.subscribe(type, listener);
+        }
+        // Always listen locally for fallback
+        this.on(type, listener);
+    }
+
+    async shutdown(): Promise<void> {
+        await persistentEventBus.shutdown?.();
+    }
+}
+
+export const eventBus = new MCPEventBus();

apps/backend/src/mcp/SmartToolRouter.ts

@@ -0,0 +1,476 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════════════════╗
+ * ║                    SMART TOOL ROUTER - INTENT-BASED SELECTION             ║
+ * ║═══════════════════════════════════════════════════════════════════════════║
+ * ║  Automatically selects the best MCP tool based on user intent using       ║
+ * ║  semantic matching and context analysis.                                  ║
+ * ║                                                                           ║
+ * ║  Reduces cognitive load for AI agents by inferring the right tool         ║
+ * ║  from natural language queries instead of requiring explicit tool names.  ║
+ * ╚═══════════════════════════════════════════════════════════════════════════╝
+ */
+
+import { hyperLog } from '../services/HyperLog.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TOOL DEFINITIONS WITH SEMANTIC KEYWORDS
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface ToolDefinition {
+  name: string;
+  description: string;
+  keywords: string[];
+  intentPatterns: string[];
+  category: 'query' | 'mutation' | 'system' | 'analysis' | 'communication';
+  priority: number; // Higher = preferred when multiple match
+  payloadTemplate?: Record<string, unknown> | string;
+}
+
+// Lightweight domain synonym map to widen recall without heavy models
+const SYNONYMS: Record<string, string[]> = {
+  health: ['status', 'alive', 'uptime', 'heartbeat'],
+  graph: ['neo4j', 'relationships', 'nodes', 'edges'],
+  ingest: ['import', 'harvest', 'index', 'scan'],
+  latency: ['delay', 'performance', 'response'],
+  prototype: ['wireframe', 'mockup', 'design'],
+  chat: ['message', 'notify', 'communicate'],
+  archive: ['vidensarkiv', 'library', 'repository'],
+};
+
+const TOOL_DEFINITIONS: ToolDefinition[] = [
+  // System & Health
+  {
+    name: 'get_system_health',
+    description: 'Get WidgeTDC system health status',
+    keywords: ['health', 'status', 'alive', 'running', 'up', 'down', 'working'],
+    intentPatterns: ['is the system working', 'check health', 'system status', 'is it up'],
+    category: 'system',
+    priority: 10,
+    payloadTemplate: {},
+  },
+
+  // Knowledge Graph Queries
+  {
+    name: 'query_knowledge_graph',
+    description: 'Query the Neo4j knowledge graph',
+    keywords: [
+      'find',
+      'search',
+      'query',
+      'graph',
+      'neo4j',
+      'nodes',
+      'relationships',
+      'knowledge',
+      'entities',
+    ],
+    intentPatterns: [
+      'find in graph',
+      'search knowledge',
+      'query entities',
+      'what do we know about',
+      'related to',
+    ],
+    category: 'query',
+    priority: 8,
+    payloadTemplate: { cypher: 'MATCH (n) RETURN n LIMIT 10', params: {} },
+  },
+  {
+    name: 'get_graph_stats',
+    description: 'Get graph statistics',
+    keywords: ['stats', 'statistics', 'count', 'how many', 'size', 'graph size'],
+    intentPatterns: ['how many nodes', 'graph statistics', 'database size', 'count entities'],
+    category: 'query',
+    priority: 6,
+    payloadTemplate: {},
+  },
+
+  // Graph Mutations
+  {
+    name: 'graph_mutation',
+    description: 'Create or modify graph nodes and relationships',
+    keywords: ['create', 'add', 'insert', 'new', 'node', 'relationship', 'connect', 'link'],
+    intentPatterns: ['create a node', 'add relationship', 'connect entities', 'insert into graph'],
+    category: 'mutation',
+    priority: 7,
+    payloadTemplate: {
+      cypher: 'CREATE (n:Entity {id: $id, name: $name})',
+      params: { id: '...', name: '...' },
+    },
+  },
+
+  // File Access
+  {
+    name: 'dropzone_files',
+    description: 'Access files in DropZone',
+    keywords: ['file', 'files', 'dropzone', 'read', 'list', 'folder', 'document'],
+    intentPatterns: ['read file', 'list files', 'whats in dropzone', 'check files'],
+    category: 'query',
+    priority: 5,
+    payloadTemplate: { path: '/', action: 'list' },
+  },
+  {
+    name: 'vidensarkiv_files',
+    description: 'Access knowledge archive files',
+    keywords: ['vidensarkiv', 'archive', 'knowledge', 'documents', 'library'],
+    intentPatterns: ['check archive', 'knowledge library', 'archived documents'],
+    category: 'query',
+    priority: 5,
+    payloadTemplate: { path: '/', action: 'list' },
+  },
+
+  // Ingestion
+  {
+    name: 'ingest_knowledge_graph',
+    description: 'Ingest repository into knowledge graph',
+    keywords: ['ingest', 'import', 'harvest', 'scan', 'index', 'repository', 'codebase'],
+    intentPatterns: ['ingest repo', 'scan codebase', 'import to graph', 'harvest knowledge'],
+    category: 'mutation',
+    priority: 6,
+    payloadTemplate: { repoUrl: 'https://github.com/org/repo', branch: 'main' },
+  },
+
+  // Communication
+  {
+    name: 'neural_chat',
+    description: 'Agent-to-agent communication',
+    keywords: ['chat', 'message', 'send', 'communicate', 'talk', 'notify', 'channel'],
+    intentPatterns: ['send message', 'chat with', 'notify agent', 'communicate'],
+    category: 'communication',
+    priority: 7,
+    payloadTemplate: { to: 'agent-name', message: '...' },
+  },
+  {
+    name: 'agent_messages',
+    description: 'Read or send agent messages',
+    keywords: ['inbox', 'outbox', 'messages', 'mail', 'notifications'],
+    intentPatterns: ['check messages', 'read inbox', 'send mail'],
+    category: 'communication',
+    priority: 6,
+    payloadTemplate: { action: 'list', limit: 10 },
+  },
+
+  // Task Delegation
+  {
+    name: 'capability_broker',
+    description: 'Delegate tasks to appropriate agents',
+    keywords: ['delegate', 'task', 'capability', 'route', 'assign', 'who can'],
+    intentPatterns: ['delegate task', 'who can handle', 'route request', 'find agent for'],
+    category: 'system',
+    priority: 8,
+    payloadTemplate: { task: 'describe your task here', priority: 'medium' },
+  },
+
+  // Analysis
+  {
+    name: 'activate_associative_memory',
+    description: 'Cognitive pattern matching across memories',
+    keywords: ['remember', 'recall', 'memory', 'associative', 'pattern', 'cognitive'],
+    intentPatterns: ['what do we remember', 'recall patterns', 'associative search'],
+    category: 'analysis',
+    priority: 7,
+    payloadTemplate: { query: 'pattern to recall' },
+  },
+  {
+    name: 'emit_sonar_pulse',
+    description: 'Check service latencies and health',
+    keywords: ['latency', 'ping', 'sonar', 'response time', 'performance'],
+    intentPatterns: ['check latency', 'ping services', 'performance test'],
+    category: 'system',
+    priority: 5,
+    payloadTemplate: { targets: ['neo4j', 'postgres', 'redis'] },
+  },
+
+  // Prototypes
+  {
+    name: 'prototype_manager',
+    description: 'Generate or manage PRD prototypes',
+    keywords: ['prototype', 'prd', 'generate', 'design', 'mockup', 'wireframe'],
+    intentPatterns: ['generate prototype', 'create design', 'build from prd'],
+    category: 'mutation',
+    priority: 6,
+    payloadTemplate: { prd: 'Paste PRD text here', output: 'wireframe' },
+  },
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SMART TOOL ROUTER CLASS
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface ToolMatch {
+  tool: string;
+  confidence: number;
+  reason: string;
+  category: string;
+}
+
+export interface RouterResult {
+  bestMatch: ToolMatch | null;
+  alternatives: ToolMatch[];
+  query: string;
+  processingTimeMs: number;
+  suggestions?: ToolMatch[];
+  clarifyQuestion?: string;
+  payloadTemplate?: Record<string, unknown> | string | null;
+}
+
+class SmartToolRouter {
+  private toolDefs: ToolDefinition[] = TOOL_DEFINITIONS;
+  private feedback: Map<string, { success: number; failure: number }> = new Map();
+
+  /**
+   * Route a natural language query to the best matching tool
+   */
+  route(query: string): RouterResult {
+    const startTime = Date.now();
+    const normalizedQuery = query.toLowerCase().trim();
+
+    // Expand query with synonyms to improve recall without an embedding model
+    const baseTokens = normalizedQuery.split(/\s+/).filter(Boolean);
+    const expandedTokens: string[] = [];
+    for (const token of baseTokens) {
+      const syns = SYNONYMS[token];
+      if (syns) expandedTokens.push(...syns.map(s => s.toLowerCase()));
+    }
+    const augmentedQuery = [normalizedQuery, ...expandedTokens].join(' ');
+
+    if (!normalizedQuery) {
+      const fallback = this.getFallbackMatch('Tom forespørgsel - bruger capability_broker');
+      return {
+        bestMatch: fallback,
+        alternatives: [],
+        query,
+        processingTimeMs: Date.now() - startTime,
+      };
+    }
+    const queryWords = new Set([...baseTokens, ...expandedTokens]);
+
+    const matches: ToolMatch[] = [];
+
+    for (const tool of this.toolDefs) {
+      let score = 0;
+      const reasons: string[] = [];
+
+      // 1. Keyword matching (40% weight)
+      const keywordMatches = tool.keywords.filter(kw => augmentedQuery.includes(kw.toLowerCase()));
+      if (keywordMatches.length > 0) {
+        score += (keywordMatches.length / tool.keywords.length) * 40;
+        reasons.push(`Keywords: ${keywordMatches.join(', ')}`);
+      }
+
+      // 2. Intent pattern matching (40% weight)
+      const patternMatches = tool.intentPatterns.filter(pattern =>
+        this.fuzzyMatch(augmentedQuery, pattern.toLowerCase())
+      );
+      if (patternMatches.length > 0) {
+        score += (patternMatches.length / tool.intentPatterns.length) * 40;
+        reasons.push(`Intent: ${patternMatches[0]}`);
+      }
+
+      // 3. Word overlap (15% weight)
+      const toolWords = new Set(
+        [...tool.keywords, ...tool.name.split('_')].map(w => w.toLowerCase())
+      );
+      const overlap = [...queryWords].filter(w => toolWords.has(w)).length;
+      if (overlap > 0) {
+        score += Math.min(overlap * 5, 15);
+      }
+
+      // 4. Priority boost (5% weight)
+      score += (tool.priority / 10) * 5;
+
+      // 5. Feedback boost (up to ~5 points)
+      score += this.getFeedbackBoost(tool.name);
+
+      if (score > 15) {
+        // Minimum threshold
+        matches.push({
+          tool: tool.name,
+          confidence: Math.min(score / 100, 0.99),
+          reason: reasons.join('; ') || 'Priority match',
+          category: tool.category,
+        });
+      }
+    }
+
+    // Sort by confidence
+    matches.sort((a, b) => b.confidence - a.confidence);
+
+    // Lightweight re-rank to boost semantic coverage and prefer richer reasons
+    const reranked = this.rerankCandidates(augmentedQuery, matches);
+
+    const bestCandidate =
+      reranked.length > 0
+        ? reranked[0]
+        : this.getFallbackMatch('Ingen match - fallback med forslag');
+    const alternatives =
+      reranked.length > 1 ? reranked.slice(1, 4) : this.getSuggestionAlternatives(bestCandidate);
+
+    const payloadTemplate = bestCandidate ? this.getPayloadTemplate(bestCandidate.tool) : null;
+    const clarifyQuestion =
+      bestCandidate && bestCandidate.confidence < 0.35
+        ? 'Uddyb hvad du vil gøre, fx data, system eller filnavn?'
+        : undefined;
+
+    const result: RouterResult = {
+      bestMatch: bestCandidate,
+      alternatives,
+      query,
+      processingTimeMs: Date.now() - startTime,
+      suggestions: alternatives,
+      payloadTemplate,
+      clarifyQuestion,
+    };
+
+    // Log routing decision
+    if (result.bestMatch) {
+      hyperLog.logEvent('TOOL_ROUTED', {
+        query: query.substring(0, 100),
+        tool: result.bestMatch.tool,
+        confidence: result.bestMatch.confidence,
+        alternatives: result.alternatives.length,
+      });
+    } else {
+      hyperLog.logEvent('TOOL_ROUTE_FAILED', {
+        query: query.substring(0, 100),
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Fuzzy string matching for intent patterns
+   */
+  private fuzzyMatch(query: string, pattern: string): boolean {
+    const patternWords = pattern.split(/\s+/);
+    const queryLower = query.toLowerCase();
+
+    // Check if all pattern words appear in query (in any order)
+    let matchCount = 0;
+    for (const word of patternWords) {
+      if (queryLower.includes(word)) {
+        matchCount++;
+      }
+    }
+
+    // Consider match if 60%+ of pattern words found
+    return matchCount / patternWords.length >= 0.6;
+  }
+
+  /**
+   * Get tool suggestions for a category
+   */
+  getToolsByCategory(category: ToolDefinition['category']): string[] {
+    return this.toolDefs
+      .filter(t => t.category === category)
+      .sort((a, b) => b.priority - a.priority)
+      .map(t => t.name);
+  }
+
+  /**
+   * Auto-complete tool name from partial input
+   */
+  autocomplete(partial: string): string[] {
+    const normalizedPartial = partial.toLowerCase();
+    return this.toolDefs
+      .filter(
+        t =>
+          t.name.toLowerCase().includes(normalizedPartial) ||
+          t.keywords.some(k => k.toLowerCase().includes(normalizedPartial))
+      )
+      .map(t => t.name);
+  }
+
+  /**
+   * Add custom tool definition (for dynamic tools)
+   */
+  registerTool(tool: ToolDefinition): void {
+    this.toolDefs.push(tool);
+    hyperLog.logEvent('TOOL_REGISTERED', { name: tool.name, category: tool.category });
+  }
+
+  /**
+   * Allow external feedback to adjust routing preferences over time
+   */
+  registerFeedback(toolName: string, outcome: 'success' | 'failure' | 'timeout'): void {
+    const stats = this.feedback.get(toolName) || { success: 0, failure: 0 };
+    if (outcome === 'success') stats.success += 1;
+    else stats.failure += 1;
+    this.feedback.set(toolName, stats);
+  }
+
+  /**
+   * Lightweight reranker to reward better coverage and reasons
+   */
+  private rerankCandidates(query: string, matches: ToolMatch[]): ToolMatch[] {
+    if (!matches.length) return matches;
+    const queryTokens = new Set(query.split(/\s+/).filter(Boolean));
+
+    return [...matches]
+      .map(m => {
+        const coverage = [...queryTokens].filter(t => m.reason.toLowerCase().includes(t)).length;
+        const reasonBonus = Math.min(coverage * 0.01, 0.05);
+        const boosted = Math.min(m.confidence + reasonBonus, 0.99);
+        return { ...m, confidence: boosted };
+      })
+      .sort((a, b) => b.confidence - a.confidence);
+  }
+
+  private getPayloadTemplate(toolName: string): Record<string, unknown> | string | null {
+    const def = this.toolDefs.find(t => t.name === toolName);
+    return def?.payloadTemplate ?? null;
+  }
+
+  private getFeedbackBoost(toolName: string): number {
+    const stats = this.feedback.get(toolName);
+    if (!stats) return 0;
+    const total = stats.success + stats.failure;
+    if (total === 0) return 0;
+    const ratio = stats.success / total;
+    return Math.min(ratio * 5, 5); // up to 5 bonus points
+  }
+
+  /**
+   * Provide suggestion alternatives when fallback is used
+   */
+  private getSuggestionAlternatives(best: ToolMatch | null): ToolMatch[] {
+    if (best) return [];
+    const topByPriority = [...this.toolDefs].sort((a, b) => b.priority - a.priority).slice(0, 3);
+
+    return topByPriority.map(t => ({
+      tool: t.name,
+      confidence: (t.priority / 10) * 0.2,
+      reason: 'Suggestion based on priority',
+      category: t.category,
+    }));
+  }
+
+  /**
+   * Fallback tool match when no candidate passes threshold
+   */
+  private getFallbackMatch(reason?: string): ToolMatch | null {
+    const fallback = this.toolDefs.find(t => t.name === 'capability_broker');
+    if (!fallback) return null;
+
+    return {
+      tool: fallback.name,
+      confidence: 0.35,
+      reason: reason || 'Fallback: capability_broker',
+      category: fallback.category,
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SINGLETON EXPORT
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const smartToolRouter = new SmartToolRouter();
+
+/**
+ * Convenience function for quick routing
+ */
+export function routeToTool(query: string): ToolMatch | null {
+  return smartToolRouter.route(query).bestMatch;
+}

apps/backend/src/mcp/SourceRegistry.ts

@@ -0,0 +1,109 @@
+/**
+ * Simple Source Registry Implementation
+ * 
+ * Manages available data sources and matches them to query intents
+ */
+
+import { QueryIntent, DataSource } from './autonomous/index.js';
+
+export class SourceRegistryImpl {
+    private sources: Map<string, DataSource> = new Map();
+
+    /**
+     * Register a new data source
+     */
+    registerSource(source: DataSource): void {
+        this.sources.set(source.name, source);
+        console.log(`📌 Registered source: ${source.name} (${source.type})`);
+    }
+
+    /**
+     * Get sources capable of handling a query intent
+     */
+    getCapableSources(intent: QueryIntent): DataSource[] {
+        const capable: DataSource[] = [];
+
+        for (const source of this.sources.values()) {
+            if (this.canHandle(source, intent)) {
+                capable.push(source);
+            }
+        }
+
+        return capable;
+    }
+
+    /**
+     * Get all registered sources
+     */
+    getAllSources(): DataSource[] {
+        return Array.from(this.sources.values());
+    }
+
+    /**
+     * Get source by name
+     */
+    getSource(name: string): DataSource | undefined {
+        return this.sources.get(name);
+    }
+
+    /**
+     * Check if source can handle intent
+     */
+    private canHandle(source: DataSource, intent: QueryIntent): boolean {
+        // Check if source has wildcard capability
+        if (source.capabilities.includes('*')) {
+            return true;
+        }
+
+        // Check for domain.operation match
+        const fullType = `${intent.domain}.${intent.operation}`;
+        if (source.capabilities.includes(fullType)) {
+            return true;
+        }
+
+        // Check for domain.* match
+        const domainWildcard = `${intent.domain}.*`;
+        if (source.capabilities.includes(domainWildcard)) {
+            return true;
+        }
+
+        // Check for simple type match
+        if (source.capabilities.includes(intent.type)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Get sources by type
+     */
+    getSourcesByType(type: string): DataSource[] {
+        return Array.from(this.sources.values())
+            .filter(s => s.type === type);
+    }
+
+    /**
+     * Remove a source
+     */
+    unregisterSource(name: string): boolean {
+        return this.sources.delete(name);
+    }
+
+    /**
+     * Clear all sources
+     */
+    clear(): void {
+        this.sources.clear();
+    }
+}
+
+// Singleton instance
+let registryInstance: SourceRegistryImpl | null = null;
+
+export function getSourceRegistry(): SourceRegistryImpl {
+    if (!registryInstance) {
+        registryInstance = new SourceRegistryImpl();
+    }
+    return registryInstance;
+}

apps/backend/src/mcp/autonomous/AutonomousAgent.ts

@@ -0,0 +1,389 @@
+/**
+ * Autonomous Connection Agent
+ * 
+ * Main orchestrator that autonomously selects optimal data sources,
+ * learns from outcomes, and adapts over time
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { CognitiveMemory } from '../memory/CognitiveMemory.js';
+import { DecisionEngine, DataSource, QueryIntent, DecisionResult } from './DecisionEngine.js';
+
+export interface DataQuery {
+    id?: string;
+    type: string;
+    domain?: string;
+    operation?: string;
+    params?: any;
+    priority?: 'low' | 'normal' | 'high';
+    freshness?: 'stale' | 'normal' | 'realtime';
+    widgetId?: string;
+}
+
+export interface QueryResult {
+    data: any;
+    source: string;
+    latencyMs: number;
+    cached: boolean;
+    timestamp: Date;
+}
+
+export interface SourceRegistry {
+    getCapableSources(intent: QueryIntent): DataSource[];
+    getAllSources(): DataSource[];
+}
+
+export class AutonomousAgent {
+    private memory: CognitiveMemory;
+    private decisionEngine: DecisionEngine;
+    private registry: SourceRegistry;
+    private predictionCache: Map<string, any> = new Map();
+    private wsServer: any = null; // WebSocket server for real-time events
+
+    constructor(
+        memory: CognitiveMemory,
+        registry: SourceRegistry,
+        wsServer?: any
+    ) {
+        this.memory = memory;
+        this.decisionEngine = new DecisionEngine(memory);
+        this.registry = registry;
+        this.wsServer = wsServer || null;
+
+        console.log('🤖 Autonomous Agent initialized');
+    }
+
+    /**
+     * Set WebSocket server for real-time event emission
+     */
+    setWebSocketServer(server: any): void {
+        this.wsServer = server;
+    }
+
+    /**
+     * Main routing function - autonomously selects best source
+     */
+    async route(query: DataQuery): Promise<DataSource> {
+        const startTime = Date.now();
+
+        // 1. Analyze query intent
+        const intent = await this.decisionEngine.analyzeIntent(query);
+
+        // 2. Get candidate sources
+        const candidates = this.registry.getCapableSources(intent);
+
+        if (candidates.length === 0) {
+            throw new Error(`No sources available for query type: ${intent.type}`);
+        }
+
+        // 3. Make intelligent decision
+        const decision = await this.decisionEngine.decide(candidates, intent);
+
+        // 4. Log decision for learning
+        await this.logDecision(query, decision, candidates);
+
+        const decisionTime = Date.now() - startTime;
+        console.log(
+            `🎯 Selected ${decision.selectedSource.name} ` +
+            `(confidence: ${(decision.confidence * 100).toFixed(0)}%, ` +
+            `decision: ${decisionTime}ms)`
+        );
+        console.log(`   Reasoning: ${decision.reasoning}`);
+
+        return decision.selectedSource;
+    }
+
+    /**
+     * Execute query with selected source and learn from outcome
+     * Includes autonomous fallback handling for failures
+     */
+    async executeAndLearn(
+        query: DataQuery,
+        executeFunction: (source: DataSource) => Promise<any>
+    ): Promise<QueryResult> {
+        // Generate unique query ID for tracking if not provided
+        const queryId = query.id || uuidv4();
+        const startTime = Date.now();
+
+        // 1. Analyze intent
+        const intent = await this.decisionEngine.analyzeIntent(query);
+
+        // 2. Get candidate sources
+        const candidates = this.registry.getCapableSources(intent);
+
+        if (candidates.length === 0) {
+            throw new Error(`No sources available for query type: ${intent.type}`);
+        }
+
+        // 3. Score and rank sources for fallback strategy
+        const rankedSources = await this.decisionEngine.scoreAllSources(candidates, intent);
+
+        const errors: any[] = [];
+
+        // 4. Try sources in order (Fallback Loop)
+        for (const candidate of rankedSources) {
+            const selectedSource = candidate.source;
+
+            try {
+                // Only log if it's a fallback attempt (not the first choice)
+                if (errors.length > 0) {
+                    console.log(`🔄 Fallback: Attempting execution with ${selectedSource.name} (Score: ${candidate.score.toFixed(2)})...`);
+                }
+
+                // Execute query
+                const result = await executeFunction(selectedSource);
+
+                // Success!
+                const latencyMs = Date.now() - startTime;
+
+                // Log decision (we log the one that actually worked)
+                const decision: DecisionResult = {
+                    selectedSource: selectedSource,
+                    score: candidate.score,
+                    confidence: candidate.score,
+                    reasoning: candidate.reasoning,
+                    alternatives: rankedSources.filter(s => s.source.name !== selectedSource.name)
+                };
+                await this.logDecision(query, decision, candidates);
+
+                // Emit WebSocket event for real-time updates
+                if (this.wsServer && this.wsServer.emitAutonomousDecision) {
+                    this.wsServer.emitAutonomousDecision({
+                        queryId: queryId,
+                        selectedSource: selectedSource.name,
+                        confidence: candidate.score,
+                        alternatives: rankedSources.slice(1, 4).map(s => s.source.name),
+                        reasoning: candidate.reasoning,
+                        latency: latencyMs
+                    });
+                }
+
+                // Learn from successful execution
+                await this.memory.recordQuery({
+                    widgetId: query.widgetId || 'unknown',
+                    queryType: query.type,
+                    queryParams: query.params,
+                    sourceUsed: selectedSource.name,
+                    latencyMs,
+                    resultSize: this.estimateSize(result),
+                    success: true
+                });
+
+                // Log to ProjectMemory for historical tracking
+                try {
+                    const { projectMemory } = await import('../../services/project/ProjectMemory.js');
+                    projectMemory.logLifecycleEvent({
+                        eventType: 'other',
+                        status: 'success',
+                        details: {
+                            type: 'agent_decision',
+                            query: query.type,
+                            source: selectedSource.name,
+                            latency: latencyMs,
+                            confidence: candidate.score
+                        }
+                    });
+                } catch (error) {
+                    // Don't fail the query if ProjectMemory logging fails
+                    console.warn('Failed to log to ProjectMemory:', error);
+                }
+
+                return {
+                    data: result,
+                    source: selectedSource.name,
+                    latencyMs,
+                    cached: false,
+                    timestamp: new Date()
+                };
+
+            } catch (error: any) {
+                console.warn(`⚠️ Source ${selectedSource.name} failed: ${error.message}`);
+                errors.push({ source: selectedSource.name, error: error.message });
+
+                // Learn from failure
+                await this.memory.recordFailure({
+                    sourceName: selectedSource.name,
+                    error,
+                    queryContext: {
+                        queryType: query.type,
+                        queryParams: query.params
+                    }
+                });
+
+                await this.memory.recordQuery({
+                    widgetId: query.widgetId || 'unknown',
+                    queryType: query.type,
+                    queryParams: query.params,
+                    sourceUsed: selectedSource.name,
+                    latencyMs: Date.now() - startTime,
+                    success: false
+                });
+
+                // Continue to next source...
+            }
+        }
+
+        // If we get here, ALL sources failed
+        throw new Error(`All available sources failed for query ${query.type}. Errors: ${JSON.stringify(errors)}`);
+    }
+
+    /**
+     * Predictive pre-fetching based on learned patterns
+     */
+    async predictAndPrefetch(widgetId: string): Promise<void> {
+        try {
+            // Get widget patterns
+            const patterns = await this.memory.getWidgetPatterns(widgetId);
+
+            if (patterns.timePatterns.length === 0) {
+                return; // No patterns learned yet
+            }
+
+            const currentHour = new Date().getHours();
+
+            // Find pattern for current hour
+            const currentPattern = patterns.timePatterns.find(p => p.hour === currentHour);
+
+            if (!currentPattern || currentPattern.frequency < 5) {
+                return; // Not confident enough
+            }
+
+            // Predict likely source based on common sources
+            const likelySource = patterns.commonSources[0];
+
+            if (!likelySource) {
+                return;
+            }
+
+            console.log(
+                `🔮 Pre-fetching for ${widgetId} ` +
+                `(hour: ${currentHour}, confidence: high)`
+            );
+
+            // Pre-warm cache or connection
+            // (Implementation depends on source type)
+            this.predictionCache.set(widgetId, {
+                source: likelySource,
+                timestamp: new Date()
+            });
+
+        } catch (error) {
+            console.error('Prediction error:', error);
+        }
+    }
+
+    /**
+     * Continuous learning - runs periodically
+     */
+    async learn(): Promise<void> {
+        console.log('🎓 Running learning cycle...');
+
+        try {
+            // Analyze decision quality
+            await this.analyzeDecisionQuality();
+
+            // Identify patterns
+            await this.identifyPatterns();
+
+            // Update predictions
+            await this.updatePredictions();
+
+            console.log('✅ Learning cycle complete');
+        } catch (error) {
+            console.error('Learning cycle error:', error);
+        }
+    }
+
+    /**
+     * Analyze if past decisions were optimal
+     */
+    private async analyzeDecisionQuality(): Promise<void> {
+        // Simple heuristic: check success rate of recent decisions
+        try {
+            const stats = await this.memory.getFailureStatistics();
+            console.log(`🧠 Learning: Analyzed decision quality. Recovery rate: ${(stats.overallRecoveryRate * 100).toFixed(1)}%`);
+        } catch (e) {
+            // Ignore error if stats not available
+        }
+    }
+
+    /**
+     * Identify new patterns in widget usage
+     */
+    private async identifyPatterns(): Promise<void> {
+        // Analyze query_patterns table to find new time-based patterns,
+        // sequence patterns, etc.
+        // Store findings in mcp_widget_patterns table
+    }
+
+    /**
+     * Update pre-fetch predictions
+     */
+    private async updatePredictions(): Promise<void> {
+        // Based on identified patterns, update what should be pre-fetched
+        // Clear old predictions that are no longer accurate
+    }
+
+    /**
+     * Log decision for future analysis
+     */
+    private async logDecision(
+        query: DataQuery,
+        decision: DecisionResult,
+        _allCandidates: DataSource[]
+    ): Promise<void> {
+        try {
+            // Note: This is simplified - full implementation would use proper DB access
+            // For now, logging to console
+            console.log(`📊 Decision logged: ${decision.selectedSource.name}`);
+        } catch (error) {
+            console.error('Failed to log decision:', error);
+        }
+    }
+
+    /**
+     * Estimate result size in bytes
+     */
+    private estimateSize(result: any): number {
+        try {
+            return JSON.stringify(result).length;
+        } catch {
+            return 0;
+        }
+    }
+
+    /**
+     * Get agent statistics
+     */
+    async getStats(): Promise<{
+        totalDecisions: number;
+        averageConfidence: number;
+        topSources: { source: string; count: number }[];
+    }> {
+        // Placeholder - would query decision_log table
+        return {
+            totalDecisions: 0,
+            averageConfidence: 0,
+            topSources: []
+        };
+    }
+}
+
+/**
+ * Start autonomous learning loop
+ */
+export function startAutonomousLearning(agent: AutonomousAgent, intervalMs: number = 300000): void {
+    console.log(`🔄 Starting autonomous learning (every ${intervalMs / 1000}s)`);
+
+    // Run learning cycle periodically
+    setInterval(async () => {
+        try {
+            await agent.learn();
+        } catch (error) {
+            console.error('Learning cycle failed:', error);
+        }
+    }, intervalMs);
+
+    // Run initial learning after 10 seconds
+    setTimeout(() => agent.learn(), 10000);
+}

apps/backend/src/mcp/autonomous/DecisionEngine.ts

@@ -0,0 +1,437 @@
+/**
+ * Decision Engine - AI-Powered Source Selection
+ * 
+ * Makes intelligent decisions about which data source to use
+ * based on learned patterns, current health, context, AND semantic relevance
+ */
+
+import { CognitiveMemory } from '../memory/CognitiveMemory.js';
+import { getEmbeddingService } from '../../services/embeddings/EmbeddingService.js';
+import { logger } from '../../utils/logger.js';
+
+export interface QueryIntent {
+    type: string;
+    domain: string;
+    operation: string;
+    params: any;
+    priority?: 'low' | 'normal' | 'high';
+    freshness?: 'stale' | 'normal' | 'realtime';
+}
+
+export interface DataSource {
+    name: string;
+    type: string;
+    capabilities: string[];
+    description?: string; // Added description for semantic matching
+    isHealthy: () => Promise<boolean>;
+    estimatedLatency: number;
+    costPerQuery: number;
+    query?: (operation: string, params: any) => Promise<any>; // Optional query method
+}
+
+export interface SourceScore {
+    source: DataSource;
+    score: number;
+    breakdown: {
+        performance: number;
+        reliability: number;
+        cost: number;
+        freshness: number;
+        history: number;
+        semantic: number;
+    };
+    reasoning: string;
+}
+
+export interface DecisionResult {
+    selectedSource: DataSource;
+    score: number;
+    confidence: number;
+    reasoning: string;
+    alternatives: SourceScore[];
+}
+
+export class DecisionEngine {
+    private memory: CognitiveMemory;
+    private embeddings = getEmbeddingService();
+    private sourceEmbeddings: Map<string, number[]> = new Map();
+
+    // Scoring weights (can be tuned based on priority)
+    private weights = {
+        performance: 0.20,
+        reliability: 0.20,
+        cost: 0.15,
+        freshness: 0.05,
+        history: 0.10,
+        semantic: 0.30 // High weight for semantic relevance
+    };
+
+    constructor(memory: CognitiveMemory) {
+        this.memory = memory;
+        this.initializeEmbeddings().catch(err => {
+            logger.warn('Failed to initialize source embeddings:', err);
+        });
+    }
+
+    private async initializeEmbeddings() {
+        // Initialize embedding service (and GPU bridge if applicable)
+        await this.embeddings.initialize();
+    }
+
+    /**
+     * Analyze query intent to understand requirements
+     */
+    async analyzeIntent(query: any): Promise<QueryIntent> {
+        // Extract intent from query structure
+        const intent: QueryIntent = {
+            type: query.type || 'unknown',
+            domain: query.domain || this.inferDomain(query),
+            operation: query.operation || 'read',
+            params: query.params || {},
+            priority: query.priority || 'normal',
+            freshness: query.freshness || 'normal'
+        };
+
+        return intent;
+    }
+
+    /**
+     * Score all available sources for a query
+     */
+    async scoreAllSources(
+        sources: DataSource[],
+        intent: QueryIntent
+    ): Promise<SourceScore[]> {
+        // Ensure embeddings service is ready
+        await this.embeddings.initialize();
+
+        const scores = await Promise.all(
+            sources.map(source => this.scoreSource(source, intent))
+        );
+
+        // Sort by score descending
+        return scores.sort((a, b) => b.score - a.score);
+    }
+
+    /**
+     * Score a single source for this query
+     */
+    async scoreSource(
+        source: DataSource,
+        intent: QueryIntent
+    ): Promise<SourceScore> {
+        // Adjust weights based on priority
+        const weights = this.getWeights(intent);
+
+        // Calculate individual scores
+        const performance = await this.scorePerformance(source, intent);
+        const reliability = await this.scoreReliability(source, intent);
+        const cost = this.scoreCost(source, intent);
+        const freshness = this.scoreFreshness(source, intent);
+        const history = await this.scoreHistory(source, intent);
+        const semantic = await this.scoreSemanticRelevance(source, intent);
+
+        // Weighted total
+        const totalScore =
+            performance * weights.performance +
+            reliability * weights.reliability +
+            cost * weights.cost +
+            freshness * weights.freshness +
+            history * weights.history +
+            semantic * weights.semantic;
+
+        // Generate reasoning
+        const reasoning = this.generateReasoning({
+            performance,
+            reliability,
+            cost,
+            freshness,
+            history,
+            semantic
+        }, weights);
+
+        return {
+            source,
+            score: totalScore,
+            breakdown: {
+                performance,
+                reliability,
+                cost,
+                freshness,
+                history,
+                semantic
+            },
+            reasoning
+        };
+    }
+
+    /**
+     * Make final decision from scored sources
+     */
+    async decide(
+        sources: DataSource[],
+        intent: QueryIntent
+    ): Promise<DecisionResult> {
+        const scored = await this.scoreAllSources(sources, intent);
+
+        if (scored.length === 0) {
+            throw new Error('No available sources for this query');
+        }
+
+        const best = scored[0];
+
+        // Confidence is based on score gap between #1 and #2
+        const confidence = scored.length > 1
+            ? Math.min(1.0, (best.score - scored[1].score) / 0.3 + 0.5)
+            : 1.0;
+
+        return {
+            selectedSource: best.source,
+            score: best.score,
+            confidence,
+            reasoning: best.reasoning,
+            alternatives: scored.slice(1, 4) // Top 3 alternatives
+        };
+    }
+
+    /**
+     * Score semantic relevance using embeddings
+     */
+    private async scoreSemanticRelevance(
+        source: DataSource,
+        intent: QueryIntent
+    ): Promise<number> {
+        try {
+            // 1. Get or generate embedding for source description/capabilities
+            let sourceVector = this.sourceEmbeddings.get(source.name);
+            if (!sourceVector) {
+                const description = `${source.name} ${source.type} ${source.capabilities.join(' ')} ${source.description || ''}`;
+                sourceVector = await this.embeddings.generateEmbedding(description);
+                this.sourceEmbeddings.set(source.name, sourceVector);
+            }
+
+            // 2. Generate embedding for query intent
+            const queryText = `${intent.type} ${intent.domain} ${intent.operation} ${JSON.stringify(intent.params)}`;
+            const queryVector = await this.embeddings.generateEmbedding(queryText);
+
+            // 3. Calculate cosine similarity
+            return this.cosineSimilarity(sourceVector, queryVector);
+
+        } catch (error) {
+            // Fallback to keyword matching if embedding fails
+            logger.warn(`Semantic scoring failed for ${source.name}:`, error);
+            
+            // Simple keyword overlap fallback
+            const queryStr = JSON.stringify(intent).toLowerCase();
+            const capsStr = source.capabilities.join(' ').toLowerCase();
+            if (capsStr.includes(intent.type.toLowerCase())) return 0.8;
+            if (queryStr.includes(source.name.toLowerCase())) return 0.6;
+            
+            return 0.3; // Default low relevance
+        }
+    }
+
+    private cosineSimilarity(vecA: number[], vecB: number[]): number {
+        if (vecA.length !== vecB.length) return 0;
+        let dot = 0;
+        let magA = 0;
+        let magB = 0;
+        for (let i = 0; i < vecA.length; i++) {
+            dot += vecA[i] * vecB[i];
+            magA += vecA[i] * vecA[i];
+            magB += vecB[i] * vecB[i];
+        }
+        return magA === 0 || magB === 0 ? 0 : dot / (Math.sqrt(magA) * Math.sqrt(magB));
+    }
+
+    /**
+     * Score performance (latency, throughput)
+     */
+    private async scorePerformance(
+        source: DataSource,
+        intent: QueryIntent
+    ): Promise<number> {
+        // Get average latency from memory
+        const avgLatency = await this.memory.getAverageLatency(source.name);
+
+        // Normalize: 0-50ms = 1.0, 500ms+ = 0.0
+        const latencyScore = Math.max(0, Math.min(1, 1 - (avgLatency / 500)));
+
+        // For high priority queries, penalize slow sources more
+        if (intent.priority === 'high' && avgLatency > 200) {
+            return latencyScore * 0.5;
+        }
+
+        return latencyScore;
+    }
+
+    /**
+     * Score reliability (uptime, success rate)
+     */
+    private async scoreReliability(
+        source: DataSource,
+        intent: QueryIntent
+    ): Promise<number> {
+        // Current health check
+        const isHealthy = await source.isHealthy();
+        if (!isHealthy) {
+            return 0.0; // Unhealthy source gets zero score
+        }
+
+        // Historical success rate
+        const successRate = await this.memory.getSuccessRate(
+            source.name,
+            intent.type
+        );
+
+        // Get failure intelligence
+        const intelligence = await this.memory.getSourceIntelligence(source.name);
+
+        // Penalize if there were recent failures
+        const recentFailurePenalty = Math.min(0.3, intelligence.recentFailures * 0.05);
+
+        return Math.max(0, successRate - recentFailurePenalty);
+    }
+
+    /**
+     * Score cost (API costs, compute)
+     */
+    private scoreCost(source: DataSource, intent: QueryIntent): number {
+        const cost = source.costPerQuery || 0;
+
+        // Normalize: $0 = 1.0, $0.10+ = 0.0
+        const costScore = Math.max(0, Math.min(1, 1 - (cost / 0.1)));
+
+        // For low priority queries, strongly prefer free sources
+        if (intent.priority === 'low' && cost > 0) {
+            return costScore * 0.5;
+        }
+
+        return costScore;
+    }
+
+    /**
+     * Score data freshness
+     */
+    private scoreFreshness(source: DataSource, intent: QueryIntent): number {
+        // Database sources are typically fresher than cached/file sources
+        const freshnessMap: Record<string, number> = {
+            'database': 1.0,
+            'api': 0.9,
+            'cache': 0.5,
+            'file': 0.3
+        };
+
+        const baseScore = freshnessMap[source.type] || 0.5;
+
+        // Adjust based on required freshness
+        if (intent.freshness === 'realtime') {
+            return source.type === 'database' || source.type === 'api' ? 1.0 : 0.2;
+        } else if (intent.freshness === 'stale') {
+            return 1.0; // Don't care about freshness
+        }
+
+        return baseScore;
+    }
+
+    /**
+     * Score based on historical patterns
+     */
+    private async scoreHistory(
+        source: DataSource,
+        intent: QueryIntent
+    ): Promise<number> {
+        // Check if this source has been successful for similar queries
+        const historyScore = await this.memory.getSimilarQuerySuccess(
+            intent.type,
+            intent.params
+        );
+
+        return historyScore;
+    }
+
+    /**
+     * Adjust weights based on query intent
+     */
+    private getWeights(intent: QueryIntent) {
+        const weights = { ...this.weights };
+
+        // High priority: favor performance and reliability
+        if (intent.priority === 'high') {
+            weights.performance = 0.30;
+            weights.reliability = 0.30;
+            weights.semantic = 0.20; // Reduce semantic weight slightly
+            weights.cost = 0.10;
+            weights.freshness = 0.05;
+            weights.history = 0.05;
+        }
+
+        // Low priority: favor cost
+        else if (intent.priority === 'low') {
+            weights.performance = 0.10;
+            weights.reliability = 0.20;
+            weights.semantic = 0.20;
+            weights.cost = 0.40;
+            weights.freshness = 0.05;
+            weights.history = 0.05;
+        }
+
+        // Realtime freshness: favor databases/APIs
+        if (intent.freshness === 'realtime') {
+            weights.freshness = 0.30;
+            weights.performance = 0.20;
+            weights.semantic = 0.20;
+            weights.reliability = 0.20;
+            weights.cost = 0.10;
+        }
+
+        return weights;
+    }
+
+    /**
+     * Generate human-readable reasoning
+     */
+    private generateReasoning(
+        breakdown: SourceScore['breakdown'],
+        weights: typeof this.weights
+    ): string {
+        const reasons: string[] = [];
+
+        // Find strongest factor
+        const factors = Object.entries(breakdown).sort((a, b) => b[1] - a[1]);
+        const [topFactor, topScore] = factors[0];
+
+        if (topScore > 0.8) {
+            reasons.push(`Excellent ${topFactor} (${(topScore * 100).toFixed(0)}%)`);
+        } else if (topScore > 0.6) {
+            reasons.push(`Good ${topFactor} (${(topScore * 100).toFixed(0)}%)`);
+        }
+        
+        // Explicitly mention semantic match if high
+        if (breakdown.semantic > 0.8) {
+            reasons.push(`Strong conceptual match`);
+        }
+
+        // Note any weak factors
+        for (const [factor, score] of factors) {
+            if (score < 0.3 && weights[factor as keyof typeof weights] > 0.15) {
+                reasons.push(`Low ${factor} (${(score * 100).toFixed(0)}%)`);
+            }
+        }
+
+        return reasons.join(', ') || 'Balanced scores across all factors';
+    }
+
+    /**
+     * Infer domain from query structure
+     */
+    private inferDomain(query: any): string {
+        // Simple heuristics
+        if (query.uri?.startsWith('agents://')) return 'agents';
+        if (query.uri?.startsWith('security://')) return 'security';
+        if (query.tool?.includes('search')) return 'search';
+        if (query.tool?.includes('agent')) return 'agents';
+
+        return 'general';
+    }
+}

apps/backend/src/mcp/autonomous/INTEGRATION_GUIDE.md

@@ -0,0 +1,330 @@
+# Autonomous MCP System - Integration Guide
+
+## Quick Start
+
+### 1. Initialize Cognitive Memory
+
+```typescript
+import { initializeDatabase, getDatabase } from './database/index.js';
+import { initCognitiveMemory } from './mcp/autonomous/index.js';
+
+// Initialize database
+await initializeDatabase();
+const db = getDatabase();
+
+// Initialize cognitive memory
+const memory = initCognitiveMemory(db);
+```
+
+### 2. Create Source Registry
+
+```typescript
+import { SourceRegistry, DataSource } from './mcp/autonomous/index.js';
+
+class SimpleSourceRegistry implements SourceRegistry {
+  private sources: Map<string, DataSource> = new Map();
+  
+  registerSource(source: DataSource) {
+    this.sources.set(source.name, source);
+  }
+  
+  getCapableSources(intent: QueryIntent): DataSource[] {
+    // Filter sources that can handle this query
+    return Array.from(this.sources.values()).filter(source => {
+      // Check if source supports this operation
+      return source.capabilities.includes(intent.type) ||
+             source.capabilities.includes('*');
+    });
+  }
+  
+  getAllSources(): DataSource[] {
+    return Array.from(this.sources.values());
+  }
+}
+
+const registry = new SimpleSourceRegistry();
+```
+
+### 3. Register Data Sources
+
+```typescript
+// Example: PostgreSQL source
+registry.registerSource({
+  name: 'postgres-main',
+  type: 'database',
+  capabilities: ['agents.list', 'agents.get', 'agents.update'],
+  isHealthy: async () => {
+    try {
+      await db.query('SELECT 1');
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  estimatedLatency: 50,
+  costPerQuery: 0
+});
+
+// Example: API source
+registry.registerSource({
+  name: 'external-api',
+  type: 'api',
+  capabilities: ['security.search', 'security.list'],
+  isHealthy: async () => {
+    const response = await fetch('https://api.example.com/health');
+    return response.ok;
+  },
+  estimatedLatency: 200,
+  costPerQuery: 0.01
+});
+```
+
+### 4. Create Autonomous Agent
+
+```typescript
+import { AutonomousAgent, startAutonomousLearning } from './mcp/autonomous/index.js';
+
+const agent = new AutonomousAgent(memory, registry);
+
+// Start autonomous learning (runs every 5 minutes)
+startAutonomousLearning(agent, 300000);
+```
+
+### 5. Use in Routes
+
+```typescript
+import { mcpRouter } from './mcp/mcpRouter.js';
+
+mcpRouter.post('/autonomous/query', async (req, res) => {
+  try {
+    const query = req.body;
+    
+    // Agent autonomously selects best source and executes
+    const result = await agent.executeAndLearn(query, async (source) => {
+      // Your execute logic here
+      return await yourDataFetcher(source, query);
+    });
+    
+    res.json({
+      success: true,
+      data: result.data,
+      meta: {
+        source: result.source,
+        latency: result.latencyMs,
+        cached: result.cached
+      }
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+```
+
+## Advanced Usage
+
+### Wrap Existing Providers with Self-Healing
+
+```typescript
+import { SelfHealingAdapter } from './mcp/autonomous/index.js';
+
+const primaryProvider: DataProvider = {
+  name: 'postgres-main',
+  type: 'database',
+  query: async (op, params) => { /* ... */ },
+  health: async () => ({ healthy: true, score: 1.0 })
+};
+
+const fallbackProvider: DataProvider = {
+  name: 'postgres-replica',
+  type: 'database',
+  query: async (op, params) => { /* ... */ },
+  health: async () => ({ healthy: true, score: 1.0 })
+};
+
+// Wrap with self-healing
+const selfHealing = new SelfHealingAdapter(
+  primaryProvider,
+  memory,
+  fallbackProvider
+);
+
+// Now use selfHealing instead of primaryProvider
+```
+
+### Predictive Pre-fetching
+
+```typescript
+// Pre-fetch data for a widget before it requests
+await agent.predictAndPrefetch('AgentMonitorWidget');
+
+// This analyzes historical patterns and pre-warms likely data
+```
+
+### Query with Intelligence
+
+```typescript
+const result = await agent.executeAndLearn({
+  type: 'agents.list',
+  widgetId: 'AgentMonitorWidget',
+  priority: 'high',  // Favor speed over cost
+  freshness: 'realtime'  // Need fresh data
+}, async (source) => {
+  // Your fetch logic
+  return await fetchFromSource(source);
+});
+```
+
+## Monitoring
+
+### Get Agent Statistics
+
+```typescript
+const stats = await agent.getStats();
+console.log(`Total decisions: ${stats.totalDecisions}`);
+console.log(`Average confidence: ${(stats.averageConfidence * 100).toFixed(1)}%`);
+console.log(`Top sources:`, stats.topSources);
+```
+
+### Get Source Intelligence
+
+```typescript
+const intel = await memory.getSourceIntelligence('postgres-main');
+console.log(`Average latency: ${intel.averageLatency}ms`);
+console.log(`Success rate: ${(intel.overallSuccessRate * 100).toFixed(1)}%`);
+console.log(`Recent failures: ${intel.recentFailures}`);
+
+if (intel.lastFailure) {
+  console.log(`Last failure: ${intel.lastFailure.errorType}`);
+  console.log(`Known recovery paths:`, intel.knownRecoveryPaths);
+}
+```
+
+### Health Dashboard Data
+
+```typescript
+const healthHistory = await memory.getHealthHistory('postgres-main', 100);
+
+// Analyze trends
+const latencies = healthHistory.map(h => h.latency.p95);
+const avgLatency = latencies.reduce((a, b) => a + b, 0) / latencies.length;
+const trend = latencies[0] > latencies[latencies.length - 1] ? 'improving' : 'degrading';
+
+console.log(`Average P95 latency: ${avgLatency.toFixed(0)}ms (${trend})`);
+```
+
+## Best Practices
+
+### 1. Always Initialize Database First
+
+```typescript
+// ✅ Correct order
+await initializeDatabase();
+const memory = initCognitiveMemory(getDatabase());
+
+// ❌ Wrong - will fail
+const memory = initCognitiveMemory(getDatabase());
+await initializeDatabase();
+```
+
+### 2. Register Sources at Startup
+
+```typescript
+// Register all sources before starting agent
+registry.registerSource(source1);
+registry.registerSource(source2);
+registry.registerSource(source3);
+
+// Then create agent
+const agent = new AutonomousAgent(memory, registry);
+```
+
+### 3. Let Agent Learn Before Production
+
+```typescript
+// Run in learning mode for 1 week
+const agent = new AutonomousAgent(memory, registry);
+
+// Agent observes and learns patterns
+// After 1 week of data, confidence will be high
+```
+
+### 4. Implement Graceful Fallbacks
+
+```typescript
+// Always provide fallback sources
+const adapter = new SelfHealingAdapter(
+  primarySource,
+  memory,
+  fallbackSource  // ✅ Always provide this
+);
+```
+
+### 5. Monitor Decision Quality
+
+```typescript
+// Periodically check if agent is making good decisions
+setInterval(async () => {
+  const stats = await agent.getStats();
+  
+  if (stats.averageConfidence < 0.6) {
+    console.warn('Low decision confidence - agent needs more data');
+  }
+}, 3600000); // Every hour
+```
+
+## Troubleshooting
+
+### Agent Always Selects Same Source
+
+**Problem**: Not enough variety in registered sources or historical data.
+
+**Solution**:
+```typescript
+// Check registered sources
+const sources = registry.getAllSources();
+console.log(`Registered sources: ${sources.length}`);
+
+// Check historical patterns
+const patterns = await memory.getWidgetPatterns('YourWidget');
+console.log(`Common sources:`, patterns.commonSources);
+```
+
+### Self-Healing Not Working
+
+**Problem**: Circuit breaker may be stuck open.
+
+**Solution**:
+```typescript
+// Check circuit breaker state in logs
+// Look for: "Circuit breaker OPEN"
+
+// Manually reset by restarting or adjusting thresholds
+adapter.failureThreshold = 10; // More lenient
+```
+
+### Memory Growing Too Large
+
+**Problem**: Not cleaning old data.
+
+**Solution**:
+```typescript
+// Run cleanup periodically
+setInterval(async () => {
+  await memory.cleanup(30); // Keep last 30 days
+}, 86400000); // Daily
+```
+
+## Next Steps
+
+1. **Tune Decision Weights**: Adjust weights in `DecisionEngine` based on your priorities
+2. **Add Custom Recovery Actions**: Extend `SelfHealingAdapter` with domain-specific recovery
+3. **Implement ML Models**: Replace heuristics with trained models for predictions
+4. **Build Admin Dashboard**: Visualize agent decisions and source health
+
+## API Reference
+
+See individual files for detailed API documentation:
+- `DecisionEngine.ts` - Scoring algorithms
+- `AutonomousAgent.ts` - Main orchestrator
+- `SelfHealingAdapter.ts` - Recovery mechanisms
+- `CognitiveMemory.ts` - Memory interface

apps/backend/src/mcp/autonomous/MCPIntegration.ts

@@ -0,0 +1,148 @@
+/**
+ * MCP Integration with Autonomous System
+ * 
+ * Auto-registers MCP tools as data sources in the autonomous system
+ * for intelligent routing and self-healing
+ */
+
+import { mcpRegistry } from '../mcpRegistry.js';
+import { getSourceRegistry } from '../SourceRegistry.js';
+import { DataSource } from './DecisionEngine.js';
+import { OutlookJsonAdapter } from '../../services/external/OutlookJsonAdapter.js';
+import { join } from 'path';
+import { cwd } from 'process';
+
+/**
+ * Register all MCP tools as autonomous data sources
+ */
+export async function registerMCPToolsAsSources(): Promise<void> {
+    const sourceRegistry = getSourceRegistry();
+    const tools = mcpRegistry.getRegisteredTools();
+
+    console.log(`🔗 Registering ${tools.length} MCP tools as autonomous data sources...`);
+
+    for (const toolName of tools) {
+        try {
+            // Parse tool name to extract domain
+            const [domain, operation] = toolName.split('.');
+            const capabilities = [
+                toolName,
+                `${domain}.*`,
+                operation || '*'
+            ];
+
+            // Create base data source
+            const baseSource: DataSource = {
+                name: `mcp-${toolName}`,
+                type: 'mcp-tool',
+                capabilities,
+                isHealthy: async () => {
+                    // Check if tool is registered
+                    return mcpRegistry.getRegisteredTools().includes(toolName);
+                },
+                estimatedLatency: 100, // MCP tools typically fast
+                costPerQuery: 0, // MCP tools are free
+                query: async (op: string, params: any) => {
+                    // Route through MCP registry
+                    // Include operation in payload so handlers can distinguish different operations
+                    return await mcpRegistry.route({
+                        id: `auton-${Date.now()}`,
+                        createdAt: new Date().toISOString(),
+                        sourceId: 'autonomous-agent',
+                        targetId: 'mcp-registry',
+                        tool: toolName,
+                        payload: {
+                            ...(params || {}),
+                            operation: op // Include operation parameter for routing
+                        }
+                    });
+                }
+            };
+
+            // Register as data source directly (self-healing is handled at the adapter level)
+            sourceRegistry.registerSource(baseSource);
+
+            console.log(`  ✓ Registered: ${toolName} → mcp-${toolName}`);
+        } catch (error: any) {
+            console.warn(`  ⚠️  Failed to register ${toolName}: ${error.message}`);
+        }
+    }
+
+    console.log(`✅ Registered ${tools.length} MCP tools as autonomous sources`);
+}
+
+/**
+ * Register database as data source
+ */
+export async function registerDatabaseSource(): Promise<void> {
+    const sourceRegistry = getSourceRegistry();
+    const { getDatabase } = await import('../../database/index.js');
+
+    sourceRegistry.registerSource({
+        name: 'database-main',
+        type: 'database',
+        capabilities: ['*', 'database.*', 'agents.*', 'memory.*', 'srag.*', 'evolution.*', 'pal.*'],
+        isHealthy: async () => {
+            try {
+                const db = getDatabase();
+                const stmt = db.prepare('SELECT 1');
+                stmt.get();
+                stmt.free();
+                return true;
+            } catch {
+                return false;
+            }
+        },
+        estimatedLatency: 50,
+        costPerQuery: 0,
+        query: async (_operation: string, _params: any) => {
+            // Database queries are handled by repositories
+            // This is a placeholder - actual routing happens in repositories
+            throw new Error('Database query routing handled by repositories');
+        }
+    });
+
+    console.log('📌 Registered database as autonomous source');
+}
+
+/**
+ * Register Outlook JSON source
+ */
+export async function registerOutlookSource(): Promise<void> {
+    const sourceRegistry = getSourceRegistry();
+    // Path to data file
+    const dataPath = join(cwd(), 'apps', 'backend', 'data', 'outlook-mails.json');
+    
+    const adapter = new OutlookJsonAdapter(dataPath);
+    
+    sourceRegistry.registerSource({
+        name: 'outlook-mail',
+        type: 'email-adapter',
+        capabilities: ['email.search', 'email.read', 'communication.history'],
+        isHealthy: async () => true, // File adapter is always "healthy" if file exists or not (just returns empty)
+        estimatedLatency: 20, // Fast local read
+        costPerQuery: 0,
+        query: async (operation: string, params: any) => {
+            return await adapter.query(operation, params);
+        }
+    });
+
+    console.log(`📌 Registered Outlook JSON source (path: ${dataPath})`);
+}
+
+/**
+ * Initialize all autonomous data sources
+ */
+export async function initializeAutonomousSources(): Promise<void> {
+    // Register database first (highest priority for most queries)
+    await registerDatabaseSource();
+
+    // Register Outlook source
+    await registerOutlookSource();
+
+    // Wait a bit for MCP tools to be registered
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Register all MCP tools as sources
+    await registerMCPToolsAsSources();
+}

apps/backend/src/mcp/autonomous/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Autonomous MCP System - Public API
+ *
+ * Complete autonomous intelligence system with:
+ * - Cognitive Memory (pattern learning, failure memory)
+ * - Decision Engine (AI-powered source selection)
+ * - Autonomous Agent (main orchestrator)
+ * - Self-Healing (via services/SelfHealingAdapter - consolidated)
+ */
+
+// Memory Layer
+export { CognitiveMemory, initCognitiveMemory, getCognitiveMemory } from '../memory/CognitiveMemory.js';
+export { PatternMemory } from '../memory/PatternMemory.js';
+export { FailureMemory } from '../memory/FailureMemory.js';
+
+// Autonomous Intelligence
+export { DecisionEngine } from './DecisionEngine.js';
+export { AutonomousAgent, startAutonomousLearning } from './AutonomousAgent.js';
+
+// Self-Healing: Use the consolidated service from services/SelfHealingAdapter.ts
+// import { selfHealing } from '../../services/SelfHealingAdapter.js';
+
+// Types
+export type { QueryIntent, DataSource, SourceScore, DecisionResult } from './DecisionEngine.js';
+export type { DataQuery, QueryResult, SourceRegistry } from './AutonomousAgent.js';
+export type { QueryPattern, UsagePattern } from '../memory/PatternMemory.js';
+export type { HealthMetrics } from '../memory/CognitiveMemory.js';

apps/backend/src/mcp/autonomousRouter.ts

@@ -0,0 +1,1079 @@
+/**
+ * Autonomous MCP Router
+ * 
+ * Handles autonomous query routing with AI-powered source selection
+ */
+
+import { Router } from 'express';
+import { getCognitiveMemory } from './memory/CognitiveMemory.js';
+import { AutonomousAgent, startAutonomousLearning } from './autonomous/AutonomousAgent.js';
+import { getSourceRegistry } from './SourceRegistry.js';
+import { getDatabase } from '../database/index.js';
+import { eventBus } from './EventBus.js';
+import { hybridSearchEngine } from './cognitive/HybridSearchEngine.js';
+import { emotionAwareDecisionEngine } from './cognitive/EmotionAwareDecisionEngine.js';
+import { unifiedMemorySystem } from './cognitive/UnifiedMemorySystem.js';
+import { unifiedGraphRAG } from './cognitive/UnifiedGraphRAG.js';
+import { stateGraphRouter } from './cognitive/StateGraphRouter.js';
+import { patternEvolutionEngine } from './cognitive/PatternEvolutionEngine.js';
+import { agentTeam } from './cognitive/AgentTeam.js';
+
+// WebSocket server for real-time events (will be injected)
+let wsServer: any = null;
+
+// Agent instance (declared before setWebSocketServer to avoid race condition)
+let agent: AutonomousAgent | null = null;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AUTONOMOUS RESPONSE SYSTEM - The Missing Link
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface AutonomousProposal {
+    id: string;
+    action: string;
+    confidence: number;
+    reasoning: string;
+    suggestedParams: Record<string, any>;
+    createdAt: Date;
+    status: 'pending' | 'approved' | 'rejected' | 'executed';
+}
+
+// Loop protection
+const recentResponses: Map<string, number> = new Map();
+const RESPONSE_COOLDOWN_MS = 30000; // 30 seconds between same event types
+const MAX_DEPTH = 3; // Maximum nested autonomous actions
+let currentDepth = 0;
+
+// Store proposals for user approval
+const pendingProposals: Map<string, AutonomousProposal> = new Map();
+
+/**
+ * THE AUTONOMOUS LINK - Triggers autonomous response based on events
+ *
+ * Decision flow:
+ * 1. Analyze incoming event
+ * 2. Use AgentTeam/EmotionAware engine to decide action
+ * 3. If confidence > 0.8 → Execute automatically
+ * 4. If confidence < 0.8 → Create proposal for user
+ */
+async function triggerAutonomousResponse(
+    event: any,
+    agentInstance: AutonomousAgent
+): Promise<void> {
+    const eventType = event.type || 'unknown';
+    const eventKey = `${eventType}:${JSON.stringify(event.payload || {}).substring(0, 100)}`;
+
+    // Loop protection: Check cooldown
+    const lastResponse = recentResponses.get(eventKey);
+    if (lastResponse && Date.now() - lastResponse < RESPONSE_COOLDOWN_MS) {
+        console.log(`⏳ Autonomous response on cooldown for: ${eventType}`);
+        return;
+    }
+
+    // Loop protection: Check depth
+    if (currentDepth >= MAX_DEPTH) {
+        console.log(`🛑 Max autonomous depth reached (${MAX_DEPTH}), stopping chain`);
+        return;
+    }
+
+    currentDepth++;
+    recentResponses.set(eventKey, Date.now());
+
+    try {
+        console.log(`🤖 Autonomous Response triggered for: ${eventType}`);
+
+        // Step 1: Analyze event and determine action
+        const decision = await analyzeEventAndDecide(event);
+
+        // Step 2: Route based on confidence
+        if (decision.confidence >= 0.8) {
+            // High confidence - execute automatically
+            console.log(`✅ Auto-executing (confidence: ${decision.confidence.toFixed(2)}): ${decision.action}`);
+            await executeAutonomousAction(decision, agentInstance);
+
+            eventBus.emit('agent.decision', {
+                type: 'agent.decision',
+                timestamp: new Date().toISOString(),
+                source: 'autonomousRouter',
+                payload: {
+                    event: eventType,
+                    decision: decision.action,
+                    confidence: decision.confidence,
+                    autoExecuted: true
+                }
+            });
+        } else {
+            // Low confidence - create proposal for user
+            console.log(`📋 Creating proposal (confidence: ${decision.confidence.toFixed(2)}): ${decision.action}`);
+            const proposal = createProposal(decision);
+            pendingProposals.set(proposal.id, proposal);
+
+            eventBus.emit('agent.decision', {
+                type: 'agent.decision',
+                timestamp: new Date().toISOString(),
+                source: 'autonomousRouter',
+                payload: {
+                    event: eventType,
+                    decision: decision.action,
+                    confidence: decision.confidence,
+                    autoExecuted: false,
+                    proposalId: proposal.id
+                }
+            });
+
+            // Notify via WebSocket if available
+            if (wsServer) {
+                wsServer.broadcast?.({
+                    type: 'autonomous:proposal',
+                    proposal
+                });
+            }
+        }
+    } catch (error) {
+        console.error('❌ Autonomous response error:', error);
+    } finally {
+        currentDepth--;
+    }
+}
+
+/**
+ * Analyze event and decide on action using cognitive systems
+ */
+async function analyzeEventAndDecide(event: any): Promise<{
+    action: string;
+    confidence: number;
+    reasoning: string;
+    params: Record<string, any>;
+}> {
+    const eventType = event.type || 'unknown';
+    const payload = event.payload || {};
+
+    // Use emotion-aware decision engine for analysis
+    try {
+        const emotionResult = await emotionAwareDecisionEngine.makeDecision(
+            `analyze_event: ${eventType} ${JSON.stringify(payload)}`,
+            { userId: 'system', orgId: 'autonomous' }
+        );
+
+        if (emotionResult.action) {
+            return {
+                action: `${emotionResult.action.complexity}_action`,
+                confidence: emotionResult.confidence || 0.5,
+                reasoning: emotionResult.reasoning || 'Emotion-aware analysis',
+                params: {}
+            };
+        }
+    } catch {
+        // Fallback to rule-based decisions
+    }
+
+    // Rule-based fallback decisions
+    return getDefaultDecision(eventType, payload);
+}
+
+/**
+ * Default rule-based decisions for known event types
+ */
+function getDefaultDecision(eventType: string, payload: any): {
+    action: string;
+    confidence: number;
+    reasoning: string;
+    params: Record<string, any>;
+} {
+    switch (eventType) {
+        case 'system.alert':
+            if (payload.severity === 'critical') {
+                return {
+                    action: 'notify_and_escalate',
+                    confidence: 0.9,
+                    reasoning: 'Critical system alert requires immediate attention',
+                    params: { channel: 'all', priority: 'high' }
+                };
+            }
+            return {
+                action: 'log_and_monitor',
+                confidence: 0.85,
+                reasoning: 'Non-critical alert, logging for monitoring',
+                params: { logLevel: 'warn' }
+            };
+
+        case 'security.alert':
+            return {
+                action: 'security_response',
+                confidence: payload.severity === 'critical' ? 0.95 : 0.7,
+                reasoning: 'Security event detected, initiating response protocol',
+                params: { isolate: payload.severity === 'critical', investigate: true }
+            };
+
+        case 'data:ingested':
+            return {
+                action: 'process_and_index',
+                confidence: 0.9,
+                reasoning: 'New data ingested, processing for knowledge graph',
+                params: { source: payload.source, count: payload.count }
+            };
+
+        case 'threat:detected':
+            return {
+                action: 'threat_analysis',
+                confidence: 0.85,
+                reasoning: 'Potential threat detected, running analysis',
+                params: { threatType: payload.type, indicators: payload.indicators }
+            };
+
+        default:
+            return {
+                action: 'observe_and_learn',
+                confidence: 0.5,
+                reasoning: 'Unknown event type, observing for pattern learning',
+                params: { eventType, payload }
+            };
+    }
+}
+
+/**
+ * Execute autonomous action
+ */
+async function executeAutonomousAction(
+    decision: { action: string; params: Record<string, any>; reasoning: string },
+    agentInstance: AutonomousAgent
+): Promise<void> {
+    const { action, params, reasoning } = decision;
+
+    console.log(`🚀 Executing: ${action} - ${reasoning}`);
+
+    switch (action) {
+        case 'notify_and_escalate':
+            eventBus.emit('system.alert', {
+                type: 'system.alert',
+                timestamp: new Date().toISOString(),
+                source: 'autonomous',
+                payload: { message: reasoning, ...params }
+            });
+            break;
+
+        case 'log_and_monitor':
+            console.log(`[AUTONOMOUS MONITOR] ${reasoning}`);
+            break;
+
+        case 'security_response':
+            // Route to security agent in AgentTeam
+            await agentTeam.routeMessage({
+                from: 'autonomous' as any,
+                to: 'sentinel' as any,
+                type: 'task',
+                content: JSON.stringify({ action: 'investigate', ...params }),
+                metadata: { reasoning },
+                timestamp: new Date()
+            });
+            break;
+
+        case 'process_and_index':
+            // Trigger GraphRAG indexing
+            await unifiedGraphRAG.query(`Index new data from ${params.source}`, {
+                userId: 'system',
+                orgId: 'autonomous'
+            });
+            break;
+
+        case 'threat_analysis':
+            await agentTeam.coordinate({
+                type: 'threat_analysis',
+                params
+            } as any, { autoExecute: true });
+            break;
+
+        case 'observe_and_learn':
+            // Store pattern for learning - use working memory update
+            await unifiedMemorySystem.updateWorkingMemory(
+                { userId: 'system', orgId: 'autonomous' },
+                { event: `Observed: ${JSON.stringify(params)}`, action }
+            );
+            break;
+
+        default:
+            console.log(`⚠️ Unknown action: ${action}`);
+    }
+}
+
+/**
+ * Create proposal for user approval
+ */
+function createProposal(decision: {
+    action: string;
+    confidence: number;
+    reasoning: string;
+    params: Record<string, any>;
+}): AutonomousProposal {
+    return {
+        id: `proposal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        action: decision.action,
+        confidence: decision.confidence,
+        reasoning: decision.reasoning,
+        suggestedParams: decision.params,
+        createdAt: new Date(),
+        status: 'pending'
+    };
+}
+
+/**
+ * Get pending proposals
+ */
+export function getPendingProposals(): AutonomousProposal[] {
+    return Array.from(pendingProposals.values()).filter(p => p.status === 'pending');
+}
+
+/**
+ * Approve and execute a proposal
+ */
+export async function approveProposal(proposalId: string): Promise<boolean> {
+    const proposal = pendingProposals.get(proposalId);
+    if (!proposal || proposal.status !== 'pending') return false;
+
+    proposal.status = 'approved';
+
+    if (agent) {
+        await executeAutonomousAction({
+            action: proposal.action,
+            params: proposal.suggestedParams,
+            reasoning: proposal.reasoning
+        }, agent);
+        proposal.status = 'executed';
+    }
+
+    return true;
+}
+
+/**
+ * Reject a proposal
+ */
+export function rejectProposal(proposalId: string): boolean {
+    const proposal = pendingProposals.get(proposalId);
+    if (!proposal || proposal.status !== 'pending') return false;
+    proposal.status = 'rejected';
+    return true;
+}
+
+export function setWebSocketServer(server: any): void {
+    wsServer = server;
+    // Update agent instance if it already exists
+    if (agent) {
+        agent.setWebSocketServer(server);
+    }
+}
+
+export const autonomousRouter = Router();
+
+// Re-export for convenience
+export { startAutonomousLearning };
+
+/**
+ * Initialize agent (called from main server)
+ */
+export function initAutonomousAgent(): AutonomousAgent {
+    if (agent) return agent;
+
+    const memory = getCognitiveMemory();
+    const registry = getSourceRegistry();
+
+    agent = new AutonomousAgent(memory, registry, wsServer);
+
+    // Listen to system events - THE AUTONOMOUS LINK
+    eventBus.onEvent('system.alert', async (event) => {
+        if (agent) {
+            await triggerAutonomousResponse(event, agent);
+        }
+    });
+
+    // Also listen to security alerts
+    eventBus.onEvent('security.alert', async (event) => {
+        if (agent) {
+            await triggerAutonomousResponse(event, agent);
+        }
+    });
+
+    console.log('🤖 Autonomous Agent initialized');
+
+    return agent;
+}
+
+/**
+ * Autonomous query endpoint
+ */
+autonomousRouter.post('/query', async (req, res) => {
+    if (!agent) {
+        return res.status(503).json({
+            success: false,
+            error: 'Autonomous agent not initialized'
+        });
+    }
+
+    try {
+        const query = req.body;
+
+        // Execute with autonomous routing
+        const result = await agent.executeAndLearn(query, async (source) => {
+            // Simple executor - calls source.query
+            if ('query' in source && typeof source.query === 'function') {
+                return await source.query(query.operation, query.params);
+            }
+
+            throw new Error(`Source ${source.name} does not support query operation`);
+        });
+
+        res.json({
+            success: true,
+            data: result.data,
+            meta: {
+                source: result.source,
+                latency: result.latencyMs,
+                cached: result.cached,
+                timestamp: result.timestamp
+            }
+        });
+    } catch (error: any) {
+        console.error('Autonomous query error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Get agent statistics
+ */
+autonomousRouter.get('/stats', async (req, res) => {
+    if (!agent) {
+        return res.status(503).json({ error: 'Agent not initialized' });
+    }
+
+    try {
+        const stats = await agent.getStats();
+        res.json(stats);
+    } catch (error: any) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+/**
+ * Trigger predictive pre-fetch for a widget
+ */
+autonomousRouter.post('/prefetch/:widgetId', async (req, res) => {
+    if (!agent) {
+        return res.status(503).json({ error: 'Agent not initialized' });
+    }
+
+    try {
+        const { widgetId } = req.params;
+        await agent.predictAndPrefetch(widgetId);
+
+        res.json({
+            success: true,
+            message: `Pre-fetch triggered for ${widgetId}`
+        });
+    } catch (error: any) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+/**
+ * List available sources
+ */
+autonomousRouter.get('/sources', async (req, res) => {
+    try {
+        const registry = getSourceRegistry();
+        const sources = registry.getAllSources();
+
+        const sourcesInfo = await Promise.all(
+            sources.map(async (source) => {
+                try {
+                    const health = await source.isHealthy();
+                    return {
+                        name: source.name,
+                        type: source.type,
+                        capabilities: source.capabilities,
+                        healthy: health,
+                        estimatedLatency: source.estimatedLatency,
+                        costPerQuery: source.costPerQuery
+                    };
+                } catch {
+                    return {
+                        name: source.name,
+                        type: source.type,
+                        capabilities: source.capabilities,
+                        healthy: false,
+                        estimatedLatency: source.estimatedLatency,
+                        costPerQuery: source.costPerQuery
+                    };
+                }
+            })
+        );
+
+        res.json({ sources: sourcesInfo });
+    } catch (error: any) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+/**
+ * Get system health
+ */
+/**
+ * Get decision history
+ */
+autonomousRouter.get('/decisions', async (req, res) => {
+    try {
+        const db = getDatabase();
+        const limit = parseInt(req.query.limit as string) || 50;
+
+        const stmt = db.prepare(`
+            SELECT * FROM mcp_decision_log
+            ORDER BY timestamp DESC
+            LIMIT ?
+        `);
+        // Use variadic parameters for consistency with sqlite3 API
+        const decisions = stmt.all(limit);
+        stmt.free();
+
+        res.json({ decisions });
+    } catch (error: any) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+/**
+ * Get learned patterns
+ */
+autonomousRouter.get('/patterns', async (req, res) => {
+    try {
+        const memory = getCognitiveMemory();
+        const widgetId = req.query.widgetId as string;
+
+        if (widgetId) {
+            const patterns = await memory.getWidgetPatterns(widgetId);
+            res.json({ patterns });
+        } else {
+            // Get all patterns
+            const db = getDatabase();
+            const stmt = db.prepare(`
+                SELECT DISTINCT widget_id, query_type, source_used, 
+                       AVG(latency_ms) as avg_latency,
+                       COUNT(*) as frequency
+                FROM query_patterns
+                GROUP BY widget_id, query_type, source_used
+                ORDER BY frequency DESC
+                LIMIT 100
+            `);
+            const patterns = stmt.all();
+            stmt.free();
+            res.json({ patterns });
+        }
+    } catch (error: any) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+/**
+ * Trigger manual learning cycle
+ */
+autonomousRouter.post('/learn', async (req, res) => {
+    if (!agent) {
+        return res.status(503).json({ error: 'Agent not initialized' });
+    }
+
+    try {
+        await agent.learn();
+        res.json({
+            success: true,
+            message: 'Learning cycle completed'
+        });
+    } catch (error: any) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+/**
+ * MCP Tool: Manage Project Memory
+ * Allows autonomous agent to document its own actions
+ */
+autonomousRouter.post('/manage_project_memory', async (req, res) => {
+    try {
+        // Support both flat and nested param formats
+        const action = req.body.action;
+        const params = req.body.params || req.body;
+
+        const { eventType, event_type, component_name, status, details, metadata,
+            name, description, featureStatus, limit } = params;
+
+        // Import projectMemory here to avoid circular dependency
+        const { projectMemory } = await import('../services/project/ProjectMemory.js');
+
+        switch (action) {
+            case 'log_event':
+                const finalEventType = eventType || event_type;
+                if (!finalEventType || !status) {
+                    return res.status(400).json({ error: 'event_type and status required' });
+                }
+
+                // Merge component_name and description into details if provided
+                const eventDetails = {
+                    ...(details || {}),
+                    ...(component_name && { component_name }),
+                    ...(description && { description }),
+                    ...(metadata && { metadata })
+                };
+
+                projectMemory.logLifecycleEvent({
+                    eventType: finalEventType,
+                    status,
+                    details: eventDetails
+                });
+                console.log(`✅ [ProjectMemory] Logged ${finalEventType} event: ${status}`);
+                res.json({ success: true, message: 'Event logged', eventType: finalEventType });
+                break;
+
+            case 'add_feature':
+                const featureName = name || params.feature_name;
+                const featureDesc = description;
+                const featureStat = featureStatus || params.status;
+
+                if (!featureName || !featureDesc || !featureStat) {
+                    return res.status(400).json({
+                        error: 'feature_name, description, and status required',
+                        received: { name: featureName, description: featureDesc, status: featureStat }
+                    });
+                }
+
+                projectMemory.addFeature({
+                    name: featureName,
+                    description: featureDesc,
+                    status: featureStat
+                });
+                console.log(`✅ [ProjectMemory] Added feature: ${featureName} (${featureStat})`);
+                res.json({ success: true, message: 'Feature added', featureName });
+                break;
+
+            case 'query_history':
+                const queryLimit = limit || params.limit || 50;
+                const events = projectMemory.getLifecycleEvents(queryLimit);
+                res.json({ success: true, events, count: events.length });
+                break;
+
+            case 'update_feature':
+                if (!name || !featureStatus) {
+                    return res.status(400).json({ error: 'name and featureStatus required' });
+                }
+                projectMemory.updateFeatureStatus(name, featureStatus);
+                console.log(`✅ [ProjectMemory] Updated feature: ${name} → ${featureStatus}`);
+                res.json({ success: true, message: 'Feature updated' });
+                break;
+
+            default:
+                res.status(400).json({
+                    error: 'Invalid action',
+                    validActions: ['log_event', 'add_feature', 'query_history', 'update_feature'],
+                    received: { action, params }
+                });
+        }
+    } catch (error: any) {
+        console.error('❌ [ProjectMemory] Error:', error);
+        res.status(500).json({ error: error.message, stack: error.stack });
+    }
+});
+
+/**
+ * Hybrid search endpoint
+ */
+autonomousRouter.post('/search', async (req, res) => {
+    try {
+        const { query, limit, filters } = req.body;
+        const userId = (req as any).user?.id || 'anonymous';
+        const orgId = (req as any).user?.orgId || 'default';
+
+        if (!query) {
+            return res.status(400).json({ error: 'Query is required' });
+        }
+
+        const results = await hybridSearchEngine.search(query, {
+            userId,
+            orgId,
+            timestamp: new Date(),
+            limit: limit || 20,
+            filters: filters || {}
+        });
+
+        res.json({
+            success: true,
+            results,
+            count: results.length
+        });
+    } catch (error: any) {
+        console.error('Hybrid search error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Emotion-aware decision endpoint
+ */
+autonomousRouter.post('/decision', async (req, res) => {
+    try {
+        const query = req.body;
+        const userId = (req as any).user?.id || 'anonymous';
+        const orgId = (req as any).user?.orgId || 'default';
+
+        const decision = await emotionAwareDecisionEngine.makeDecision(query, {
+            userId,
+            orgId
+        });
+
+        res.json({
+            success: true,
+            decision
+        });
+    } catch (error: any) {
+        console.error('Emotion-aware decision error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * GraphRAG endpoint - Multi-hop reasoning over knowledge graph
+ */
+autonomousRouter.post('/graphrag', async (req, res) => {
+    try {
+        const { query, maxHops, context } = req.body;
+        const userId = (req as any).user?.id || context?.userId || 'anonymous';
+        const orgId = (req as any).user?.orgId || context?.orgId || 'default';
+
+        if (!query) {
+            return res.status(400).json({ error: 'Query is required' });
+        }
+
+        const result = await unifiedGraphRAG.query(query, {
+            userId,
+            orgId
+        });
+
+        res.json({
+            success: true,
+            result,
+            query,
+            maxHops: maxHops || 2
+        });
+    } catch (error: any) {
+        console.error('GraphRAG error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * StateGraphRouter endpoint - LangGraph-style state routing
+ */
+autonomousRouter.post('/stategraph', async (req, res) => {
+    try {
+        const { taskId, input } = req.body;
+
+        if (!taskId || !input) {
+            return res.status(400).json({ error: 'taskId and input are required' });
+        }
+
+        // Initialize state
+        const state = stateGraphRouter.initState(taskId, input);
+
+        // Route until completion
+        let currentState = state;
+        let iterations = 0;
+        const maxIterations = 20;
+
+        while (currentState.status === 'active' && iterations < maxIterations) {
+            currentState = await stateGraphRouter.route(currentState);
+            iterations++;
+        }
+
+        res.json({
+            success: true,
+            state: currentState,
+            iterations,
+            checkpoints: stateGraphRouter.getCheckpoints(taskId)
+        });
+    } catch (error: any) {
+        console.error('StateGraphRouter error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * PatternEvolutionEngine endpoint - Strategy evolution
+ */
+autonomousRouter.post('/evolve', async (req, res) => {
+    try {
+        await patternEvolutionEngine.evolveStrategies();
+
+        const currentStrategy = patternEvolutionEngine.getCurrentStrategy();
+        const history = patternEvolutionEngine.getEvolutionHistory();
+
+        res.json({
+            success: true,
+            currentStrategy,
+            history: history.slice(0, 10), // Last 10 evolutions
+            message: 'Evolution cycle completed'
+        });
+    } catch (error: any) {
+        console.error('PatternEvolution error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Get current evolution strategy
+ */
+autonomousRouter.get('/evolution/strategy', async (req, res) => {
+    try {
+        const strategy = patternEvolutionEngine.getCurrentStrategy();
+        const history = patternEvolutionEngine.getEvolutionHistory();
+
+        res.json({
+            success: true,
+            current: strategy,
+            history: history.slice(0, 20)
+        });
+    } catch (error: any) {
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * AgentTeam endpoint - Route message to role-based agents
+ */
+autonomousRouter.post('/agentteam', async (req, res) => {
+    try {
+        const { from, to, type, content, metadata } = req.body;
+        const userId = (req as any).user?.id || metadata?.userId || 'anonymous';
+        const orgId = (req as any).user?.orgId || metadata?.orgId || 'default';
+
+        if (!content) {
+            return res.status(400).json({ error: 'content is required' });
+        }
+
+        const message = {
+            from: from || 'user',
+            to: to || 'all',
+            type: type || 'query',
+            content,
+            metadata: { ...metadata, userId, orgId },
+            timestamp: new Date()
+        };
+
+        const result = await agentTeam.routeMessage(message);
+
+        res.json({
+            success: true,
+            result,
+            message
+        });
+    } catch (error: any) {
+        console.error('AgentTeam error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * AgentTeam coordination endpoint - Complex multi-agent tasks
+ */
+autonomousRouter.post('/agentteam/coordinate', async (req, res) => {
+    try {
+        const { task, context } = req.body;
+
+        if (!task) {
+            return res.status(400).json({ error: 'task is required' });
+        }
+
+        const result = await agentTeam.coordinate(task, context);
+
+        res.json({
+            success: true,
+            result
+        });
+    } catch (error: any) {
+        console.error('AgentTeam coordination error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Get AgentTeam status
+ */
+autonomousRouter.get('/agentteam/status', async (req, res) => {
+    try {
+        const statuses = await agentTeam.getAllStatuses();
+
+        res.json({
+            success: true,
+            agents: statuses,
+            totalAgents: statuses.length,
+            activeAgents: statuses.filter(s => s.active).length
+        });
+    } catch (error: any) {
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Get PAL agent conversation history
+ */
+autonomousRouter.get('/agentteam/pal/history', async (req, res) => {
+    try {
+        const palAgent = agentTeam.getAgent('pal');
+        if (!palAgent) {
+            return res.status(404).json({ error: 'PAL agent not found' });
+        }
+
+        // Access conversation history if available
+        const history = (palAgent as any).getConversationHistory?.() || [];
+
+        res.json({
+            success: true,
+            history,
+            count: history.length
+        });
+    } catch (error: any) {
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PROPOSAL MANAGEMENT ENDPOINTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get pending autonomous proposals
+ */
+autonomousRouter.get('/proposals', async (req, res) => {
+    try {
+        const proposals = getPendingProposals();
+        res.json({
+            success: true,
+            proposals,
+            count: proposals.length
+        });
+    } catch (error: any) {
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+
+/**
+ * Approve a proposal
+ */
+autonomousRouter.post('/proposals/:id/approve', async (req, res) => {
+    try {
+        const success = await approveProposal(req.params.id);
+        if (success) {
+            res.json({ success: true, message: 'Proposal approved and executed' });
+        } else {
+            res.status(404).json({ success: false, error: 'Proposal not found or already processed' });
+        }
+    } catch (error: any) {
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+
+/**
+ * Reject a proposal
+ */
+autonomousRouter.post('/proposals/:id/reject', async (req, res) => {
+    try {
+        const success = rejectProposal(req.params.id);
+        if (success) {
+            res.json({ success: true, message: 'Proposal rejected' });
+        } else {
+            res.status(404).json({ success: false, error: 'Proposal not found or already processed' });
+        }
+    } catch (error: any) {
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+
+/**
+ * Get system health with cognitive analysis
+ */
+autonomousRouter.get('/health', async (req, res) => {
+    try {
+        const registry = getSourceRegistry();
+        const sources = registry.getAllSources();
+
+        const sourceHealth = await Promise.all(
+            sources.map(async (source) => {
+                try {
+                    const healthy = await source.isHealthy();
+                    return {
+                        name: source.name,
+                        healthy,
+                        score: healthy ? 1.0 : 0.0
+                    };
+                } catch {
+                    return {
+                        name: source.name,
+                        healthy: false,
+                        score: 0.0
+                    };
+                }
+            })
+        );
+
+        const healthyCount = sourceHealth.filter(s => s.healthy).length;
+        const totalCount = sourceHealth.length;
+
+        // Get cognitive system health
+        const cognitiveHealth = await unifiedMemorySystem.analyzeSystemHealth();
+
+        res.json({
+            status: healthyCount > 0 ? 'healthy' : 'unhealthy',
+            healthySourcesCount: healthyCount,
+            totalSourcesCount: totalCount,
+            sources: sourceHealth,
+            cognitive: {
+                globalHealth: cognitiveHealth.globalHealth,
+                componentHealth: cognitiveHealth.componentHealth,
+                wholePartRatio: cognitiveHealth.wholePartRatio,
+                healthVariance: cognitiveHealth.healthVariance
+            }
+        });
+    } catch (error: any) {
+        res.status(500).json({
+            status: 'error',
+            error: error.message
+        });
+    }
+});

apps/backend/src/mcp/cognitive/AdvancedSearch.ts

@@ -0,0 +1,240 @@
+import { graphMemoryService } from '../../memory/GraphMemoryService';
+import { neo4jService } from '../../database/Neo4jService';
+
+/**
+ * Query Expansion - Expands user query with synonyms and related terms
+ */
+export class QueryExpander {
+    private synonymMap: Map<string, string[]> = new Map([
+        ['find', ['search', 'locate', 'discover', 'retrieve']],
+        ['show', ['display', 'present', 'reveal', 'demonstrate']],
+        ['create', ['make', 'build', 'generate', 'construct']],
+        ['delete', ['remove', 'erase', 'eliminate', 'destroy']],
+        ['update', ['modify', 'change', 'alter', 'revise']],
+    ]);
+
+    /**
+     * Expand query with synonyms and related terms
+     */
+    async expandQuery(query: string): Promise<string[]> {
+        const words = query.toLowerCase().split(/\s+/);
+        const expandedTerms = new Set<string>([query]);
+
+        // Add synonyms
+        words.forEach(word => {
+            const synonyms = this.synonymMap.get(word);
+            if (synonyms) {
+                synonyms.forEach(syn => {
+                    const expandedQuery = query.replace(new RegExp(word, 'gi'), syn);
+                    expandedTerms.add(expandedQuery);
+                });
+            }
+        });
+
+        // Add semantic variations using Neo4j graph
+        try {
+            await neo4jService.connect();
+
+            // Find related concepts in the graph
+            const relatedConcepts = await neo4jService.runQuery(
+                `MATCH (n:Entity)
+         WHERE toLower(n.name) CONTAINS $query OR toLower(n.content) CONTAINS $query
+         MATCH (n)-[:RELATED_TO|SIMILAR_TO]-(related)
+         RETURN DISTINCT related.name as concept
+         LIMIT 5`,
+                { query: query.toLowerCase() }
+            );
+
+            relatedConcepts.forEach(record => {
+                if (record.concept) {
+                    expandedTerms.add(`${query} ${record.concept}`);
+                }
+            });
+
+            await neo4jService.disconnect();
+        } catch (error) {
+            console.warn('Query expansion from graph failed:', error);
+        }
+
+        return Array.from(expandedTerms);
+    }
+
+    /**
+     * Extract key phrases from query
+     */
+    extractKeyPhrases(query: string): string[] {
+        // Simple n-gram extraction (2-3 words)
+        const words = query.toLowerCase().split(/\s+/);
+        const phrases: string[] = [];
+
+        // Bigrams
+        for (let i = 0; i < words.length - 1; i++) {
+            phrases.push(`${words[i]} ${words[i + 1]}`);
+        }
+
+        // Trigrams
+        for (let i = 0; i < words.length - 2; i++) {
+            phrases.push(`${words[i]} ${words[i + 1]} ${words[i + 2]}`);
+        }
+
+        return phrases;
+    }
+}
+
+/**
+ * Result Re-ranker - Re-ranks search results using multiple signals
+ */
+export class ResultReRanker {
+    /**
+     * Re-rank results using multiple scoring signals
+     */
+    async rerank(
+        query: string,
+        results: Array<{ id: string; content: string; score: number; metadata?: any }>,
+        options: {
+            useRecency?: boolean;
+            usePopularity?: boolean;
+            useSemanticSimilarity?: boolean;
+        } = {}
+    ): Promise<Array<{ id: string; content: string; score: number; metadata?: any }>> {
+        const scoredResults = await Promise.all(
+            results.map(async result => {
+                let finalScore = result.score;
+
+                // Recency boost
+                if (options.useRecency && result.metadata?.createdAt) {
+                    const age = Date.now() - new Date(result.metadata.createdAt).getTime();
+                    const daysSinceCreation = age / (1000 * 60 * 60 * 24);
+                    const recencyBoost = Math.exp(-daysSinceCreation / 30); // Decay over 30 days
+                    finalScore *= (1 + recencyBoost * 0.2);
+                }
+
+                // Popularity boost (based on connections in graph)
+                if (options.usePopularity) {
+                    try {
+                        await neo4jService.connect();
+                        const connections = await neo4jService.getNodeRelationships(result.id);
+                        const popularityBoost = Math.min(connections.length / 10, 1); // Cap at 10 connections
+                        finalScore *= (1 + popularityBoost * 0.3);
+                        await neo4jService.disconnect();
+                    } catch (error) {
+                        // Ignore errors
+                    }
+                }
+
+                // Exact match boost
+                if (result.content.toLowerCase().includes(query.toLowerCase())) {
+                    finalScore *= 1.5;
+                }
+
+                return { ...result, score: finalScore };
+            })
+        );
+
+        // Sort by final score
+        return scoredResults.sort((a, b) => b.score - a.score);
+    }
+
+    /**
+     * Diversify results to avoid redundancy
+     */
+    diversify(
+        results: Array<{ id: string; content: string; score: number }>,
+        maxSimilarity: number = 0.8
+    ): Array<{ id: string; content: string; score: number }> {
+        const diversified: typeof results = [];
+
+        for (const result of results) {
+            // Check if too similar to already selected results
+            const tooSimilar = diversified.some(selected => {
+                const similarity = this.computeTextSimilarity(result.content, selected.content);
+                return similarity > maxSimilarity;
+            });
+
+            if (!tooSimilar) {
+                diversified.push(result);
+            }
+
+            // Stop if we have enough diverse results
+            if (diversified.length >= 10) break;
+        }
+
+        return diversified;
+    }
+
+    private computeTextSimilarity(text1: string, text2: string): number {
+        const words1 = new Set(text1.toLowerCase().split(/\s+/));
+        const words2 = new Set(text2.toLowerCase().split(/\s+/));
+
+        const intersection = new Set([...words1].filter(x => words2.has(x)));
+        const union = new Set([...words1, ...words2]);
+
+        return intersection.size / union.size; // Jaccard similarity
+    }
+}
+
+/**
+ * Hybrid Search - Combines keyword and semantic search
+ */
+export class HybridSearch {
+    private queryExpander = new QueryExpander();
+    private reRanker = new ResultReRanker();
+
+    /**
+     * Perform hybrid search combining multiple strategies
+     */
+    async search(
+        query: string,
+        options: {
+            limit?: number;
+            useQueryExpansion?: boolean;
+            useReranking?: boolean;
+            useDiversification?: boolean;
+        } = {}
+    ): Promise<Array<{ id: string; content: string; score: number; metadata?: any }>> {
+        const limit = options.limit || 10;
+        let queries = [query];
+
+        // Query expansion
+        if (options.useQueryExpansion) {
+            queries = await this.queryExpander.expandQuery(query);
+        }
+
+        // Execute searches for all query variations
+        const allResults = new Map<string, any>();
+
+        for (const q of queries) {
+            const results = await graphMemoryService.searchEntities(q, limit * 2);
+
+            results.forEach((result, index) => {
+                const existing = allResults.get(result.id);
+                // Use position as pseudo-score (lower index = higher relevance)
+                const resultWithScore = { ...result, content: result.name, score: 1 / (index + 1) };
+                if (!existing || resultWithScore.score > existing.score) {
+                    allResults.set(result.id, resultWithScore);
+                }
+            });
+        }
+
+        let results = Array.from(allResults.values());
+
+        // Re-ranking
+        if (options.useReranking) {
+            results = await this.reRanker.rerank(query, results, {
+                useRecency: true,
+                usePopularity: true,
+            });
+        }
+
+        // Diversification
+        if (options.useDiversification) {
+            results = this.reRanker.diversify(results);
+        }
+
+        return results.slice(0, limit);
+    }
+}
+
+export const queryExpander = new QueryExpander();
+export const resultReRanker = new ResultReRanker();
+export const hybridSearch = new HybridSearch();

apps/backend/src/mcp/cognitive/AgentCommunication.ts

@@ -0,0 +1,252 @@
+/**
+ * Advanced Agent Communication Protocol
+ * Enables sophisticated inter-agent communication and coordination
+ */
+
+export interface AgentMessage {
+    id: string;
+    from: string;
+    to: string | string[]; // Single agent or broadcast
+    type: 'request' | 'response' | 'broadcast' | 'negotiation' | 'delegation';
+    content: any;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    timestamp: Date;
+    correlationId?: string; // For request-response pairing
+    metadata?: Record<string, any>;
+}
+
+export interface NegotiationProposal {
+    proposalId: string;
+    proposer: string;
+    task: string;
+    terms: Record<string, any>;
+    deadline?: Date;
+    requiredCapabilities: string[];
+}
+
+export interface NegotiationResponse {
+    proposalId: string;
+    responder: string;
+    accepted: boolean;
+    counterProposal?: Partial<NegotiationProposal>;
+    reason?: string;
+}
+
+export class AgentCommunicationProtocol {
+    private messageQueue: Map<string, AgentMessage[]> = new Map();
+    private subscriptions: Map<string, Set<(msg: AgentMessage) => void>> = new Map();
+    private negotiationHistory: Map<string, NegotiationProposal[]> = new Map();
+
+    /**
+     * Send message to specific agent(s)
+     */
+    async sendMessage(message: Omit<AgentMessage, 'id' | 'timestamp'>): Promise<string> {
+        const fullMessage: AgentMessage = {
+            ...message,
+            id: this.generateMessageId(),
+            timestamp: new Date(),
+        };
+
+        // Store in queue
+        const recipients = Array.isArray(message.to) ? message.to : [message.to];
+        recipients.forEach(recipient => {
+            if (!this.messageQueue.has(recipient)) {
+                this.messageQueue.set(recipient, []);
+            }
+            this.messageQueue.get(recipient)!.push(fullMessage);
+        });
+
+        // Notify subscribers
+        recipients.forEach(recipient => {
+            const subscribers = this.subscriptions.get(recipient);
+            if (subscribers) {
+                subscribers.forEach(callback => callback(fullMessage));
+            }
+        });
+
+        return fullMessage.id;
+    }
+
+    /**
+     * Receive messages for an agent
+     */
+    async receiveMessages(agentId: string, filter?: Partial<AgentMessage>): Promise<AgentMessage[]> {
+        const messages = this.messageQueue.get(agentId) || [];
+
+        if (!filter) return messages;
+
+        return messages.filter(msg => {
+            return Object.entries(filter).every(([key, value]) => {
+                return msg[key as keyof AgentMessage] === value;
+            });
+        });
+    }
+
+    /**
+     * Subscribe to messages
+     */
+    subscribe(agentId: string, callback: (msg: AgentMessage) => void): () => void {
+        if (!this.subscriptions.has(agentId)) {
+            this.subscriptions.set(agentId, new Set());
+        }
+        this.subscriptions.get(agentId)!.add(callback);
+
+        // Return unsubscribe function
+        return () => {
+            this.subscriptions.get(agentId)?.delete(callback);
+        };
+    }
+
+    /**
+     * Broadcast message to all agents
+     */
+    async broadcast(message: Omit<AgentMessage, 'id' | 'timestamp' | 'to'>): Promise<string> {
+        return this.sendMessage({
+            ...message,
+            to: 'broadcast',
+        });
+    }
+
+    /**
+     * Request-response pattern
+     */
+    async request(
+        from: string,
+        to: string,
+        content: any,
+        timeout: number = 30000
+    ): Promise<AgentMessage | null> {
+        const correlationId = this.generateMessageId();
+
+        await this.sendMessage({
+            from,
+            to,
+            type: 'request',
+            content,
+            priority: 'medium',
+            correlationId,
+        });
+
+        // Wait for response
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                unsubscribe();
+                resolve(null);
+            }, timeout);
+
+            const unsubscribe = this.subscribe(from, (msg) => {
+                if (msg.type === 'response' && msg.correlationId === correlationId) {
+                    clearTimeout(timeoutId);
+                    unsubscribe();
+                    resolve(msg);
+                }
+            });
+        });
+    }
+
+    /**
+     * Respond to a request
+     */
+    async respond(originalMessage: AgentMessage, response: any): Promise<string> {
+        return this.sendMessage({
+            from: originalMessage.to as string,
+            to: originalMessage.from,
+            type: 'response',
+            content: response,
+            priority: originalMessage.priority,
+            correlationId: originalMessage.correlationId,
+        });
+    }
+
+    /**
+     * Initiate negotiation
+     */
+    async proposeNegotiation(proposal: NegotiationProposal): Promise<string> {
+        if (!this.negotiationHistory.has(proposal.proposer)) {
+            this.negotiationHistory.set(proposal.proposer, []);
+        }
+        this.negotiationHistory.get(proposal.proposer)!.push(proposal);
+
+        return this.broadcast({
+            from: proposal.proposer,
+            type: 'negotiation',
+            content: proposal,
+            priority: 'high',
+        });
+    }
+
+    /**
+     * Respond to negotiation
+     */
+    async respondToNegotiation(
+        proposal: NegotiationProposal,
+        response: NegotiationResponse
+    ): Promise<string> {
+        return this.sendMessage({
+            from: response.responder,
+            to: proposal.proposer,
+            type: 'response',
+            content: response,
+            priority: 'high',
+            metadata: { negotiation: true },
+        });
+    }
+
+    /**
+     * Delegate task to another agent
+     */
+    async delegateTask(
+        from: string,
+        to: string,
+        task: any,
+        priority: AgentMessage['priority'] = 'medium'
+    ): Promise<string> {
+        return this.sendMessage({
+            from,
+            to,
+            type: 'delegation',
+            content: task,
+            priority,
+        });
+    }
+
+    /**
+     * Clear old messages
+     */
+    clearOldMessages(agentId: string, olderThan: Date): void {
+        const messages = this.messageQueue.get(agentId);
+        if (messages) {
+            const filtered = messages.filter(msg => msg.timestamp > olderThan);
+            this.messageQueue.set(agentId, filtered);
+        }
+    }
+
+    /**
+     * Get message statistics
+     */
+    getStatistics(agentId: string): {
+        totalMessages: number;
+        byType: Record<string, number>;
+        byPriority: Record<string, number>;
+    } {
+        const messages = this.messageQueue.get(agentId) || [];
+
+        return {
+            totalMessages: messages.length,
+            byType: messages.reduce((acc, msg) => {
+                acc[msg.type] = (acc[msg.type] || 0) + 1;
+                return acc;
+            }, {} as Record<string, number>),
+            byPriority: messages.reduce((acc, msg) => {
+                acc[msg.priority] = (acc[msg.priority] || 0) + 1;
+                return acc;
+            }, {} as Record<string, number>),
+        };
+    }
+
+    private generateMessageId(): string {
+        return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+
+export const agentCommunicationProtocol = new AgentCommunicationProtocol();

apps/backend/src/mcp/cognitive/AgentCoordination.ts

@@ -0,0 +1,334 @@
+import { agentCommunicationProtocol, AgentMessage } from './AgentCommunication';
+
+/**
+ * Agent Capability Registry
+ */
+export interface AgentCapability {
+    name: string;
+    description: string;
+    parameters: Record<string, any>;
+    cost: number; // Resource cost
+    reliability: number; // 0-1
+}
+
+export interface AgentProfile {
+    id: string;
+    name: string;
+    capabilities: AgentCapability[];
+    currentLoad: number; // 0-100
+    maxLoad: number;
+    specialization: string[];
+    performance: {
+        tasksCompleted: number;
+        successRate: number;
+        avgResponseTime: number;
+    };
+}
+
+/**
+ * Dynamic Agent Spawning System
+ */
+export class AgentSpawner {
+    private agents: Map<string, AgentProfile> = new Map();
+    private taskQueue: Array<{ task: any; requiredCapabilities: string[] }> = [];
+
+    /**
+     * Register an agent
+     */
+    registerAgent(profile: AgentProfile): void {
+        this.agents.set(profile.id, profile);
+    }
+
+    /**
+     * Spawn new agent based on workload
+     */
+    async spawnAgent(template: Partial<AgentProfile>): Promise<AgentProfile> {
+        const newAgent: AgentProfile = {
+            id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name: template.name || 'Dynamic Agent',
+            capabilities: template.capabilities || [],
+            currentLoad: 0,
+            maxLoad: template.maxLoad || 100,
+            specialization: template.specialization || [],
+            performance: {
+                tasksCompleted: 0,
+                successRate: 1.0,
+                avgResponseTime: 0,
+            },
+        };
+
+        this.registerAgent(newAgent);
+        console.log(`✨ Spawned new agent: ${newAgent.id}`);
+
+        return newAgent;
+    }
+
+    /**
+     * Find best agent for task
+     */
+    findBestAgent(requiredCapabilities: string[]): AgentProfile | null {
+        const candidates = Array.from(this.agents.values()).filter(agent => {
+            // Check if agent has required capabilities
+            const hasCapabilities = requiredCapabilities.every(required =>
+                agent.capabilities.some(cap => cap.name === required)
+            );
+
+            // Check if agent has capacity
+            const hasCapacity = agent.currentLoad < agent.maxLoad;
+
+            return hasCapabilities && hasCapacity;
+        });
+
+        if (candidates.length === 0) return null;
+
+        // Sort by performance and load
+        candidates.sort((a, b) => {
+            const scoreA = a.performance.successRate * (1 - a.currentLoad / a.maxLoad);
+            const scoreB = b.performance.successRate * (1 - b.currentLoad / b.maxLoad);
+            return scoreB - scoreA;
+        });
+
+        return candidates[0];
+    }
+
+    /**
+     * Auto-scale agents based on workload
+     */
+    async autoScale(): Promise<void> {
+        // Check if we need more agents
+        const avgLoad = Array.from(this.agents.values())
+            .reduce((sum, agent) => sum + agent.currentLoad, 0) / this.agents.size;
+
+        if (avgLoad > 80) {
+            // High load - spawn new agent
+            const mostCommonSpecialization = this.getMostCommonSpecialization();
+            await this.spawnAgent({
+                specialization: [mostCommonSpecialization],
+                maxLoad: 100,
+            });
+        } else if (avgLoad < 20 && this.agents.size > 1) {
+            // Low load - consider removing agents
+            this.removeIdleAgents();
+        }
+    }
+
+    /**
+     * Remove idle agents
+     */
+    private removeIdleAgents(): void {
+        const idleAgents = Array.from(this.agents.values())
+            .filter(agent => agent.currentLoad === 0 && agent.performance.tasksCompleted === 0);
+
+        idleAgents.forEach(agent => {
+            this.agents.delete(agent.id);
+            console.log(`🗑️  Removed idle agent: ${agent.id}`);
+        });
+    }
+
+    private getMostCommonSpecialization(): string {
+        const specializations = Array.from(this.agents.values())
+            .flatMap(agent => agent.specialization);
+
+        const counts = specializations.reduce((acc, spec) => {
+            acc[spec] = (acc[spec] || 0) + 1;
+            return acc;
+        }, {} as Record<string, number>);
+
+        return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'general';
+    }
+
+    /**
+     * Get all agents
+     */
+    getAllAgents(): AgentProfile[] {
+        return Array.from(this.agents.values());
+    }
+
+    /**
+     * Update agent load
+     */
+    updateAgentLoad(agentId: string, load: number): void {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.currentLoad = Math.max(0, Math.min(100, load));
+        }
+    }
+}
+
+/**
+ * Agent Specialization Learning
+ */
+export class AgentSpecializationLearner {
+    private performanceHistory: Map<string, Array<{
+        task: string;
+        success: boolean;
+        duration: number;
+        timestamp: Date;
+    }>> = new Map();
+
+    /**
+     * Record task performance
+     */
+    recordPerformance(
+        agentId: string,
+        task: string,
+        success: boolean,
+        duration: number
+    ): void {
+        if (!this.performanceHistory.has(agentId)) {
+            this.performanceHistory.set(agentId, []);
+        }
+
+        this.performanceHistory.get(agentId)!.push({
+            task,
+            success,
+            duration,
+            timestamp: new Date(),
+        });
+
+        // Keep only last 100 records
+        const history = this.performanceHistory.get(agentId)!;
+        if (history.length > 100) {
+            history.shift();
+        }
+    }
+
+    /**
+     * Identify agent specializations
+     */
+    identifySpecializations(agentId: string): string[] {
+        const history = this.performanceHistory.get(agentId) || [];
+        if (history.length < 10) return [];
+
+        // Group by task type
+        const taskPerformance = history.reduce((acc, record) => {
+            if (!acc[record.task]) {
+                acc[record.task] = { successes: 0, total: 0, avgDuration: 0 };
+            }
+            acc[record.task].total++;
+            if (record.success) acc[record.task].successes++;
+            acc[record.task].avgDuration += record.duration;
+            return acc;
+        }, {} as Record<string, { successes: number; total: number; avgDuration: number }>);
+
+        // Calculate success rates
+        Object.keys(taskPerformance).forEach(task => {
+            const perf = taskPerformance[task];
+            perf.avgDuration /= perf.total;
+        });
+
+        // Find tasks with high success rate and low duration
+        const specializations = Object.entries(taskPerformance)
+            .filter(([_, perf]) => {
+                const successRate = perf.successes / perf.total;
+                return successRate > 0.8 && perf.total >= 5;
+            })
+            .map(([task]) => task);
+
+        return specializations;
+    }
+
+    /**
+     * Recommend task assignment
+     */
+    recommendAgent(
+        agents: AgentProfile[],
+        task: string
+    ): AgentProfile | null {
+        const scores = agents.map(agent => {
+            const history = this.performanceHistory.get(agent.id) || [];
+            const taskHistory = history.filter(h => h.task === task);
+
+            if (taskHistory.length === 0) {
+                return { agent, score: 0.5 }; // Neutral score for unknown
+            }
+
+            const successRate = taskHistory.filter(h => h.success).length / taskHistory.length;
+            const avgDuration = taskHistory.reduce((sum, h) => sum + h.duration, 0) / taskHistory.length;
+            const recency = (Date.now() - taskHistory[taskHistory.length - 1].timestamp.getTime()) / (1000 * 60 * 60 * 24);
+
+            // Score based on success rate, speed, and recency
+            const score = successRate * 0.6 + (1 / (avgDuration + 1)) * 0.3 + (1 / (recency + 1)) * 0.1;
+
+            return { agent, score };
+        });
+
+        scores.sort((a, b) => b.score - a.score);
+        return scores[0]?.agent || null;
+    }
+}
+
+/**
+ * Cross-Agent Knowledge Sharing
+ */
+export class KnowledgeSharing {
+    private sharedKnowledge: Map<string, Array<{
+        source: string;
+        knowledge: any;
+        timestamp: Date;
+        usefulness: number;
+    }>> = new Map();
+
+    /**
+     * Share knowledge
+     */
+    async shareKnowledge(
+        fromAgent: string,
+        topic: string,
+        knowledge: any
+    ): Promise<void> {
+        if (!this.sharedKnowledge.has(topic)) {
+            this.sharedKnowledge.set(topic, []);
+        }
+
+        this.sharedKnowledge.get(topic)!.push({
+            source: fromAgent,
+            knowledge,
+            timestamp: new Date(),
+            usefulness: 0,
+        });
+
+        // Broadcast to other agents
+        await agentCommunicationProtocol.broadcast({
+            from: fromAgent,
+            type: 'broadcast',
+            content: {
+                topic,
+                knowledge,
+            },
+            priority: 'low',
+            metadata: { knowledgeSharing: true },
+        });
+    }
+
+    /**
+     * Query shared knowledge
+     */
+    queryKnowledge(topic: string, limit: number = 10): any[] {
+        const knowledge = this.sharedKnowledge.get(topic) || [];
+
+        // Sort by usefulness and recency
+        return knowledge
+            .sort((a, b) => {
+                const scoreA = a.usefulness + (1 / ((Date.now() - a.timestamp.getTime()) / 1000 / 60 / 60 + 1));
+                const scoreB = b.usefulness + (1 / ((Date.now() - b.timestamp.getTime()) / 1000 / 60 / 60 + 1));
+                return scoreB - scoreA;
+            })
+            .slice(0, limit)
+            .map(k => k.knowledge);
+    }
+
+    /**
+     * Rate knowledge usefulness
+     */
+    rateKnowledge(topic: string, knowledgeIndex: number, rating: number): void {
+        const knowledge = this.sharedKnowledge.get(topic);
+        if (knowledge && knowledge[knowledgeIndex]) {
+            knowledge[knowledgeIndex].usefulness = rating;
+        }
+    }
+}
+
+export const agentSpawner = new AgentSpawner();
+export const specializationLearner = new AgentSpecializationLearner();
+export const knowledgeSharing = new KnowledgeSharing();

apps/backend/src/mcp/cognitive/AgentTeam.ts

@@ -0,0 +1,816 @@
+// AgentTeam – Phase 2 Week 5-6
+// Role-based agent coordination system
+
+import { unifiedMemorySystem } from './UnifiedMemorySystem.js';
+import { hybridSearchEngine } from './HybridSearchEngine.js';
+import { emotionAwareDecisionEngine } from './EmotionAwareDecisionEngine.js';
+import { unifiedGraphRAG } from './UnifiedGraphRAG.js';
+import { stateGraphRouter, AgentState } from './StateGraphRouter.js';
+import { projectMemory } from '../../services/project/ProjectMemory.js';
+import { eventBus } from '../EventBus.js';
+
+export type AgentRole = 'data' | 'security' | 'memory' | 'pal' | 'orchestrator';
+
+export interface AgentMessage {
+    from: AgentRole;
+    to: AgentRole | 'all';
+    type: 'query' | 'task' | 'result' | 'alert' | 'coordinate';
+    content: string;
+    metadata?: any;
+    timestamp: Date;
+}
+
+export interface AgentCapabilities {
+    canHandle: (message: AgentMessage) => boolean | Promise<boolean>;
+    execute: (message: AgentMessage) => Promise<any>;
+    getStatus: () => Promise<AgentStatus>;
+}
+
+export interface AgentStatus {
+    role: AgentRole;
+    active: boolean;
+    tasksCompleted: number;
+    lastActivity: Date;
+    capabilities: string[];
+}
+
+/**
+ * Data Agent - Handles data ingestion, transformation, and quality
+ */
+class DataAgent implements AgentCapabilities {
+    public readonly role: AgentRole = 'data';
+    private tasksCompleted = 0;
+    private lastActivity = new Date();
+
+    canHandle(message: AgentMessage): boolean {
+        return message.type === 'query' && (
+            message.content.includes('data') ||
+            message.content.includes('ingest') ||
+            message.content.includes('transform') ||
+            message.content.includes('quality')
+        );
+    }
+
+    async execute(message: AgentMessage): Promise<any> {
+        console.log(`📊 [DataAgent] Processing: ${message.content}`);
+        this.lastActivity = new Date();
+        this.tasksCompleted++;
+
+        // Use HybridSearchEngine to find relevant data
+        const searchResults = await hybridSearchEngine.search(message.content, {
+            userId: message.metadata?.userId || 'system',
+            orgId: message.metadata?.orgId || 'default',
+            limit: 10,
+            timestamp: new Date()
+        });
+
+        return {
+            role: this.role,
+            result: {
+                dataFound: searchResults.length,
+                sources: searchResults.map(r => ({
+                    source: r.source,
+                    relevance: r.score
+                })),
+                quality: this.assessDataQuality(searchResults)
+            }
+        };
+    }
+
+    private assessDataQuality(searchResults: any): {
+        completeness: number;
+        freshness: number;
+        reliability: number;
+    } {
+        // Simple quality assessment
+        const avgScore = searchResults.results.reduce((sum: number, r: any) => sum + r.score, 0) / searchResults.results.length || 0;
+        
+        return {
+            completeness: Math.min(1.0, searchResults.results.length / 10),
+            freshness: avgScore,
+            reliability: avgScore * 0.9
+        };
+    }
+
+    async getStatus(): Promise<AgentStatus> {
+        return {
+            role: this.role,
+            active: true,
+            tasksCompleted: this.tasksCompleted,
+            lastActivity: this.lastActivity,
+            capabilities: ['data_ingestion', 'data_quality', 'data_transformation']
+        };
+    }
+}
+
+/**
+ * Security Agent - Handles security checks, threat detection, and compliance
+ */
+class SecurityAgent implements AgentCapabilities {
+    public readonly role: AgentRole = 'security';
+    private tasksCompleted = 0;
+    private lastActivity = new Date();
+
+    canHandle(message: AgentMessage): boolean {
+        return message.type === 'query' && (
+            message.content.includes('security') ||
+            message.content.includes('threat') ||
+            message.content.includes('compliance') ||
+            message.content.includes('vulnerability')
+        ) || message.type === 'alert';
+    }
+
+    async execute(message: AgentMessage): Promise<any> {
+        console.log(`🔒 [SecurityAgent] Processing: ${message.content}`);
+        this.lastActivity = new Date();
+        this.tasksCompleted++;
+
+        // Use EmotionAwareDecisionEngine for security decisions
+        const decision = await emotionAwareDecisionEngine.makeDecision(
+            message.content,
+            {
+                orgId: message.metadata?.orgId || 'default',
+                userId: message.metadata?.userId || 'system',
+                boardId: message.metadata?.boardId
+            }
+        );
+
+        return {
+            role: this.role,
+            result: {
+                threatLevel: this.assessThreatLevel(message.content),
+                decision: decision,
+                recommendations: this.generateSecurityRecommendations(message.content)
+            }
+        };
+    }
+
+    private assessThreatLevel(content: string): 'low' | 'medium' | 'high' {
+        const threatKeywords = ['vulnerability', 'breach', 'attack', 'malware', 'exploit'];
+        const found = threatKeywords.filter(kw => content.toLowerCase().includes(kw)).length;
+        
+        if (found >= 2) return 'high';
+        if (found >= 1) return 'medium';
+        return 'low';
+    }
+
+    private generateSecurityRecommendations(content: string): string[] {
+        const recommendations: string[] = [];
+        
+        if (content.includes('vulnerability')) {
+            recommendations.push('Run security scan');
+            recommendations.push('Review access controls');
+        }
+        
+        if (content.includes('compliance')) {
+            recommendations.push('Verify GDPR compliance');
+            recommendations.push('Check data retention policies');
+        }
+        
+        return recommendations;
+    }
+
+    async getStatus(): Promise<AgentStatus> {
+        return {
+            role: this.role,
+            active: true,
+            tasksCompleted: this.tasksCompleted,
+            lastActivity: this.lastActivity,
+            capabilities: ['threat_detection', 'compliance_check', 'security_scan']
+        };
+    }
+}
+
+/**
+ * Memory Agent - Handles memory operations, retrieval, and consolidation
+ */
+class MemoryAgent implements AgentCapabilities {
+    public readonly role: AgentRole = 'memory';
+    private tasksCompleted = 0;
+    private lastActivity = new Date();
+
+    canHandle(message: AgentMessage): boolean {
+        return message.type === 'query' && (
+            message.content.includes('memory') ||
+            message.content.includes('remember') ||
+            message.content.includes('recall') ||
+            message.content.includes('forget')
+        );
+    }
+
+    async execute(message: AgentMessage): Promise<any> {
+        console.log(`🧠 [MemoryAgent] Processing: ${message.content}`);
+        this.lastActivity = new Date();
+        this.tasksCompleted++;
+
+        // Use UnifiedMemorySystem for memory operations
+        const memory = await unifiedMemorySystem.getWorkingMemory({
+            userId: message.metadata?.userId || 'system',
+            orgId: message.metadata?.orgId || 'default'
+        });
+
+        // Use GraphRAG for memory retrieval
+        const graphResult = await unifiedGraphRAG.query(message.content, {
+            userId: message.metadata?.userId || 'system',
+            orgId: message.metadata?.orgId || 'default'
+        });
+
+        return {
+            role: this.role,
+            result: {
+                workingMemory: memory,
+                graphContext: graphResult,
+                consolidation: await this.consolidateMemory(memory)
+            }
+        };
+    }
+
+    private async consolidateMemory(memory: any): Promise<{
+        patterns: number;
+        features: number;
+        events: number;
+    }> {
+        return {
+            patterns: memory.recentPatterns?.length || 0,
+            features: memory.recentFeatures?.length || 0,
+            events: memory.recentEvents?.length || 0
+        };
+    }
+
+    async getStatus(): Promise<AgentStatus> {
+        return {
+            role: this.role,
+            active: true,
+            tasksCompleted: this.tasksCompleted,
+            lastActivity: this.lastActivity,
+            capabilities: ['memory_retrieval', 'memory_consolidation', 'pattern_detection']
+        };
+    }
+}
+
+/**
+ * PAL Agent - Personal Assistant, Life Coach, Strategic & Political Advisor, Compensation Expert
+ * Inspired by CgentCore's L1 Director Agent architecture
+ */
+class PalAgent implements AgentCapabilities {
+    public readonly role: AgentRole = 'pal';
+    private conversationHistory: Array<{ role: string; content: string; timestamp: Date }> = [];
+
+    canHandle(message: AgentMessage): boolean {
+        const content = message.content.toLowerCase();
+        return message.type === 'query' && (
+            // Personal Assistant
+            content.includes('assistant') ||
+            content.includes('help me') ||
+            content.includes('remind') ||
+            content.includes('schedule') ||
+            // Coach
+            content.includes('coach') ||
+            content.includes('advice') ||
+            content.includes('guidance') ||
+            content.includes('improve') ||
+            // Strategic
+            content.includes('strategy') ||
+            content.includes('strategic') ||
+            content.includes('planning') ||
+            content.includes('roadmap') ||
+            // Political
+            content.includes('political') ||
+            content.includes('politics') ||
+            content.includes('policy') ||
+            content.includes('stakeholder') ||
+            // Compensation
+            content.includes('salary') ||
+            content.includes('compensation') ||
+            content.includes('gage') ||
+            content.includes('pay') ||
+            content.includes('bonus') ||
+            // Personal/workflow
+            content.includes('workflow') ||
+            content.includes('optimize') ||
+            content.includes('personal') ||
+            content.includes('preference') ||
+            content.includes('emotional')
+        );
+    }
+
+    async execute(message: AgentMessage): Promise<any> {
+        console.log(`👤 [PalAgent] Processing: ${message.content}`);
+
+        // Store conversation history
+        this.conversationHistory.push({
+            role: 'user',
+            content: message.content,
+            timestamp: new Date()
+        });
+
+        // Determine agent mode based on content
+        const mode = this.determineMode(message.content);
+        
+        // Use EmotionAwareDecisionEngine for personal decisions
+        const decision = await emotionAwareDecisionEngine.makeDecision(
+            message.content,
+            {
+                orgId: message.metadata?.orgId || 'default',
+                userId: message.metadata?.userId || 'system',
+                boardId: message.metadata?.boardId
+            }
+        );
+
+        // Route to specialized handler
+        let result: any;
+        switch (mode) {
+            case 'coach':
+                result = await this.handleCoach(message, decision);
+                break;
+            case 'strategic':
+                result = await this.handleStrategic(message, decision);
+                break;
+            case 'political':
+                result = await this.handlePolitical(message, decision);
+                break;
+            case 'compensation':
+                result = await this.handleCompensation(message, decision);
+                break;
+            case 'assistant':
+            default:
+                result = await this.handleAssistant(message, decision);
+                break;
+        }
+
+        // Store agent response
+        this.conversationHistory.push({
+            role: 'assistant',
+            content: JSON.stringify(result),
+            timestamp: new Date()
+        });
+
+        return {
+            role: this.role,
+            mode,
+            result,
+            emotionalState: decision.emotionalState,
+            confidence: decision.confidence
+        };
+    }
+
+    /**
+     * Determine agent mode from message content
+     */
+    private determineMode(content: string): 'assistant' | 'coach' | 'strategic' | 'political' | 'compensation' {
+        const lower = content.toLowerCase();
+        
+        if (lower.includes('coach') || lower.includes('guidance') || lower.includes('improve')) {
+            return 'coach';
+        }
+        if (lower.includes('strategy') || lower.includes('strategic') || lower.includes('planning')) {
+            return 'strategic';
+        }
+        if (lower.includes('political') || lower.includes('politics') || lower.includes('policy') || lower.includes('stakeholder')) {
+            return 'political';
+        }
+        if (lower.includes('salary') || lower.includes('compensation') || lower.includes('gage') || lower.includes('pay') || lower.includes('bonus')) {
+            return 'compensation';
+        }
+        return 'assistant';
+    }
+
+    /**
+     * Personal Assistant Mode - Task management, reminders, scheduling
+     */
+    private async handleAssistant(message: AgentMessage, decision: any): Promise<any> {
+        console.log('  📋 [PalAgent] Assistant mode');
+
+        // Use UnifiedMemorySystem to recall user preferences
+        const memory = await unifiedMemorySystem.getWorkingMemory({
+            userId: message.metadata?.userId || 'system',
+            orgId: message.metadata?.orgId || 'default'
+        });
+
+        return {
+            type: 'assistant',
+            response: this.generateAssistantResponse(message.content),
+            recommendations: this.generateWorkflowRecommendations(message.content),
+            context: {
+                recentPatterns: memory.recentPatterns?.slice(0, 3) || [],
+                preferences: memory.recentFeatures?.slice(0, 3) || []
+            },
+            nextActions: [
+                'Review your calendar for conflicts',
+                'Check pending tasks',
+                'Update preferences based on feedback'
+            ]
+        };
+    }
+
+    /**
+     * Coach Mode - Personal development, guidance, improvement
+     */
+    private async handleCoach(message: AgentMessage, decision: any): Promise<any> {
+        console.log('  🎯 [PalAgent] Coach mode');
+
+        // Use GraphRAG to find related coaching insights
+        const graphResult = await unifiedGraphRAG.query(`Coaching advice: ${message.content}`, {
+            userId: message.metadata?.userId || 'system',
+            orgId: message.metadata?.orgId || 'default'
+        });
+
+        return {
+            type: 'coach',
+            guidance: this.generateCoachingGuidance(message.content, decision),
+            insights: graphResult.nodes.slice(0, 3).map((n: any) => ({
+                insight: n.content,
+                confidence: n.score
+            })),
+            actionPlan: [
+                'Identify specific goals',
+                'Break down into actionable steps',
+                'Set measurable milestones',
+                'Schedule regular check-ins'
+            ],
+            emotionalSupport: {
+                currentState: decision.emotionalState,
+                recommendations: this.getEmotionalRecommendations(decision.emotionalState)
+            }
+        };
+    }
+
+    /**
+     * Strategic Advisor Mode - Strategic planning, roadmaps, business strategy
+     */
+    private async handleStrategic(message: AgentMessage, decision: any): Promise<any> {
+        console.log('  🎲 [PalAgent] Strategic advisor mode');
+
+        // Use StateGraphRouter for strategic planning workflow
+        const state = stateGraphRouter.initState(`strategic-${Date.now()}`, message.content);
+        let currentState = state;
+        let iterations = 0;
+
+        while (currentState.status === 'active' && iterations < 5) {
+            currentState = await stateGraphRouter.route(currentState);
+            iterations++;
+        }
+
+        return {
+            type: 'strategic',
+            analysis: this.generateStrategicAnalysis(message.content),
+            roadmap: currentState.scratchpad.plan || [],
+            recommendations: [
+                'Define clear objectives',
+                'Identify key stakeholders',
+                'Assess risks and opportunities',
+                'Create timeline with milestones',
+                'Establish success metrics'
+            ],
+            considerations: {
+                risks: ['Resource constraints', 'Timeline pressure', 'Stakeholder alignment'],
+                opportunities: ['Market timing', 'Competitive advantage', 'Innovation potential'],
+                dependencies: ['Team capacity', 'Technology readiness', 'Budget approval']
+            },
+            planningState: currentState.scratchpad
+        };
+    }
+
+    /**
+     * Political Advisor Mode - Stakeholder management, organizational politics
+     */
+    private async handlePolitical(message: AgentMessage, decision: any): Promise<any> {
+        console.log('  🏛️ [PalAgent] Political advisor mode');
+
+        return {
+            type: 'political',
+            analysis: this.generatePoliticalAnalysis(message.content),
+            stakeholderMap: [
+                { role: 'Champion', influence: 'high', support: 'positive' },
+                { role: 'Decision Maker', influence: 'high', support: 'neutral' },
+                { role: 'Influencer', influence: 'medium', support: 'positive' }
+            ],
+            recommendations: [
+                'Identify key decision makers',
+                'Build coalition of supporters',
+                'Address concerns proactively',
+                'Communicate value proposition clearly',
+                'Timing is critical - choose right moment'
+            ],
+            tactics: {
+                communication: 'Tailor message to audience',
+                timing: 'Align with organizational cycles',
+                relationships: 'Leverage existing networks',
+                framing: 'Position as win-win solution'
+            },
+            warnings: [
+                'Avoid creating unnecessary opposition',
+                'Respect organizational hierarchy',
+                'Be transparent about intentions'
+            ]
+        };
+    }
+
+    /**
+     * Compensation Expert Mode - Salary, benefits, negotiation
+     */
+    private async handleCompensation(message: AgentMessage, decision: any): Promise<any> {
+        console.log('  💰 [PalAgent] Compensation expert mode');
+
+        // Use HybridSearchEngine to find market data
+        const searchResults = await hybridSearchEngine.search(`compensation ${message.content}`, {
+            userId: message.metadata?.userId || 'system',
+            orgId: message.metadata?.orgId || 'default',
+            limit: 5,
+            timestamp: new Date()
+        });
+
+        return {
+            type: 'compensation',
+            analysis: this.generateCompensationAnalysis(message.content),
+            marketData: {
+                sources: searchResults.slice(0, 3).map((r: any) => ({
+                    source: r.source,
+                    relevance: r.score
+                })),
+                note: 'Market data should be verified from multiple sources'
+            },
+            recommendations: [
+                'Research market rates for your role and location',
+                'Consider total compensation package (salary + benefits)',
+                'Document your achievements and value',
+                'Prepare negotiation strategy',
+                'Know your walk-away point'
+            ],
+            negotiationTips: [
+                'Focus on value delivered, not just time served',
+                'Use data to support your request',
+                'Consider non-monetary benefits',
+                'Practice your pitch',
+                'Be prepared to negotiate'
+            ],
+            factors: {
+                baseSalary: 'Foundation of compensation',
+                bonuses: 'Variable compensation',
+                equity: 'Long-term value',
+                benefits: 'Health, retirement, etc.',
+                perks: 'Flexibility, development, etc.'
+            }
+        };
+    }
+
+    private generateAssistantResponse(content: string): string {
+        if (content.includes('remind')) {
+            return 'I can help you set reminders. What would you like to be reminded about?';
+        }
+        if (content.includes('schedule')) {
+            return 'I can help you manage your schedule. What would you like to schedule?';
+        }
+        return 'How can I assist you today?';
+    }
+
+    private generateCoachingGuidance(content: string, decision: any): string {
+        return `Based on your current emotional state (${decision.emotionalState}), I recommend focusing on clear, achievable goals. Let's break down your challenge into manageable steps.`;
+    }
+
+    private generateStrategicAnalysis(content: string): string {
+        return 'Strategic analysis requires understanding objectives, constraints, and opportunities. Let me help you develop a comprehensive strategy.';
+    }
+
+    private generatePoliticalAnalysis(content: string): string {
+        return 'Organizational politics require careful navigation. Key factors: stakeholder interests, power dynamics, and timing.';
+    }
+
+    private generateCompensationAnalysis(content: string): string {
+        return 'Compensation analysis should consider market rates, your value proposition, and total package (salary + benefits + equity).';
+    }
+
+    private getEmotionalRecommendations(emotionalState: string): string[] {
+        const recommendations: Record<string, string[]> = {
+            'positive': ['Maintain momentum', 'Set stretch goals', 'Share success'],
+            'neutral': ['Focus on growth', 'Seek feedback', 'Plan next steps'],
+            'negative': ['Take breaks', 'Seek support', 'Reframe challenges', 'Celebrate small wins']
+        };
+        return recommendations[emotionalState] || recommendations['neutral'];
+    }
+
+    private generateWorkflowRecommendations(content: string): string[] {
+        const recommendations: string[] = [];
+        
+        if (content.includes('optimize')) {
+            recommendations.push('Review recent task patterns');
+            recommendations.push('Identify bottlenecks');
+            recommendations.push('Automate repetitive tasks');
+        }
+        
+        if (content.includes('workflow')) {
+            recommendations.push('Analyze user preferences');
+            recommendations.push('Suggest workflow improvements');
+            recommendations.push('Implement time-blocking');
+        }
+        
+        return recommendations;
+    }
+
+    async getStatus(): Promise<AgentStatus> {
+        return {
+            role: this.role,
+            active: true,
+            tasksCompleted: this.conversationHistory.filter(m => m.role === 'assistant').length,
+            lastActivity: this.conversationHistory.length > 0 
+                ? this.conversationHistory[this.conversationHistory.length - 1].timestamp 
+                : new Date(),
+            capabilities: [
+                'personal_assistant',
+                'life_coach',
+                'strategic_advisor',
+                'political_advisor',
+                'compensation_expert',
+                'workflow_optimization',
+                'emotional_awareness',
+                'conversation_history'
+            ]
+        };
+    }
+
+    /**
+     * Get conversation history
+     */
+    public getConversationHistory(): Array<{ role: string; content: string; timestamp: Date }> {
+        return this.conversationHistory.slice(-20); // Last 20 messages
+    }
+}
+
+/**
+ * Orchestrator Agent - Coordinates other agents and manages task flow
+ */
+class OrchestratorAgent implements AgentCapabilities {
+    public readonly role: AgentRole = 'orchestrator';
+    private messageHistory: AgentMessage[] = [];
+
+    canHandle(message: AgentMessage): boolean {
+        return message.type === 'coordinate' || message.to === 'orchestrator';
+    }
+
+    async execute(message: AgentMessage): Promise<any> {
+        console.log(`🎯 [OrchestratorAgent] Coordinating: ${message.content}`);
+
+        this.messageHistory.push(message);
+
+        // Use StateGraphRouter for complex coordination
+        const state = stateGraphRouter.initState(`coord-${Date.now()}`, message.content);
+        let currentState = state;
+        let iterations = 0;
+
+        while (currentState.status === 'active' && iterations < 10) {
+            currentState = await stateGraphRouter.route(currentState);
+            iterations++;
+        }
+
+        return {
+            role: this.role,
+            result: {
+                coordination: {
+                    state: currentState.status,
+                    path: currentState.history,
+                    iterations
+                },
+                messageHistory: this.messageHistory.slice(-10)
+            }
+        };
+    }
+
+    async getStatus(): Promise<AgentStatus> {
+        return {
+            role: this.role,
+            active: true,
+            tasksCompleted: this.messageHistory.length,
+            lastActivity: new Date(),
+            capabilities: ['coordination', 'task_routing', 'agent_management']
+        };
+    }
+}
+
+/**
+ * AgentTeam - Coordinates role-based agents
+ */
+export class AgentTeam {
+    private agents: Map<AgentRole, AgentCapabilities> = new Map();
+    private messageQueue: AgentMessage[] = [];
+    private coordinationHistory: AgentMessage[] = [];
+
+    constructor() {
+        // Initialize all agents
+        this.agents.set('data', new DataAgent());
+        this.agents.set('security', new SecurityAgent());
+        this.agents.set('memory', new MemoryAgent());
+        this.agents.set('pal', new PalAgent());
+        this.agents.set('orchestrator', new OrchestratorAgent());
+
+        console.log('👥 [AgentTeam] Initialized with 5 role-based agents');
+    }
+
+    /**
+     * Route message to appropriate agent(s)
+     */
+    public async routeMessage(message: AgentMessage): Promise<any> {
+        console.log(`📨 [AgentTeam] Routing message from ${message.from} to ${message.to}`);
+
+        // If message is to orchestrator, handle directly
+        if (message.to === 'orchestrator') {
+            const orchestrator = this.agents.get('orchestrator');
+            if (orchestrator) {
+                return await orchestrator.execute(message);
+            }
+        }
+
+        // If message is to 'all', broadcast
+        if (message.to === 'all') {
+            const results: any[] = [];
+            for (const [role, agent] of this.agents.entries()) {
+                if (agent.canHandle(message)) {
+                    const result = await agent.execute(message);
+                    results.push(result);
+                }
+            }
+            return { results, broadcast: true };
+        }
+
+        // Route to specific agent
+        const targetAgent = this.agents.get(message.to as AgentRole);
+        if (!targetAgent) {
+            throw new Error(`Agent ${message.to} not found`);
+        }
+
+        if (!targetAgent.canHandle(message)) {
+            // Try to find alternative agent
+            for (const [role, agent] of this.agents.entries()) {
+                if (agent.canHandle(message)) {
+                    console.log(`🔄 [AgentTeam] Rerouting from ${message.to} to ${role}`);
+                    return await agent.execute(message);
+                }
+            }
+            throw new Error(`No agent can handle message: ${message.content}`);
+        }
+
+        return await targetAgent.execute(message);
+    }
+
+    /**
+     * Coordinate multiple agents for complex task
+     */
+    public async coordinate(task: string, context?: any): Promise<any> {
+        const coordinationMessage: AgentMessage = {
+            from: 'orchestrator',
+            to: 'all',
+            type: 'coordinate',
+            content: task,
+            metadata: context,
+            timestamp: new Date()
+        };
+
+        this.coordinationHistory.push(coordinationMessage);
+
+        // Use orchestrator to coordinate
+        const orchestrator = this.agents.get('orchestrator');
+        if (orchestrator) {
+            const result = await orchestrator.execute(coordinationMessage);
+            
+            // Log to ProjectMemory
+            projectMemory.logLifecycleEvent({
+                eventType: 'other',
+                status: 'success',
+                details: {
+                    component: 'AgentTeam',
+                    action: 'coordination',
+                    task,
+                    agentsInvolved: this.agents.size,
+                    timestamp: new Date().toISOString()
+                }
+            });
+
+            return result;
+        }
+
+        throw new Error('Orchestrator agent not available');
+    }
+
+    /**
+     * Get status of all agents
+     */
+    public async getAllStatuses(): Promise<AgentStatus[]> {
+        const statuses: AgentStatus[] = [];
+        
+        for (const [role, agent] of this.agents.entries()) {
+            const status = await agent.getStatus();
+            statuses.push(status);
+        }
+
+        return statuses;
+    }
+
+    /**
+     * Get agent by role
+     */
+    public getAgent(role: AgentRole): AgentCapabilities | undefined {
+        return this.agents.get(role);
+    }
+}
+
+export const agentTeam = new AgentTeam();
+

apps/backend/src/mcp/cognitive/AutonomousTaskEngine.ts

@@ -0,0 +1,323 @@
+// AutonomousTaskEngine – Phase 1 (BabyAGI loop)
+import { AutonomousAgent } from '../autonomous/AutonomousAgent.js';
+import { unifiedMemorySystem } from './UnifiedMemorySystem.js';
+import { eventBus } from '../EventBus.js';
+import { getCognitiveMemory } from '../memory/CognitiveMemory.js';
+import { getSourceRegistry } from '../SourceRegistry.js';
+
+type Task = {
+    type: string;
+    payload: any;
+    baseScore?: number;
+    isSimple?: boolean;
+    isMaintenanceTask?: boolean;
+};
+
+interface TaskResult {
+    success: boolean;
+    data?: any;
+    error?: any;
+    needsMoreData?: boolean;
+    foundPattern?: boolean;
+}
+
+interface ExecutionLog {
+    task: Task;
+    result: TaskResult;
+    timestamp: Date;
+    newTasks: Task[];
+}
+
+class PriorityQueue<T> {
+    private items: { task: T; priority: number }[] = [];
+
+    enqueue(task: T, priority: number) {
+        this.items.push({ task, priority });
+        this.items.sort((a, b) => b.priority - a.priority);
+    }
+
+    dequeue(): T | undefined {
+        return this.items.shift()?.task;
+    }
+
+    isEmpty(): boolean {
+        return this.items.length === 0;
+    }
+
+    addAll(tasks: T[], priorityFn?: (task: T) => number) {
+        tasks.forEach(task => {
+            const priority = priorityFn ? priorityFn(task) : (task as any).baseScore || 50;
+            this.enqueue(task, priority);
+        });
+    }
+
+    reprioritize(priorityFn: (task: T) => number) {
+        const tasks = this.items.map(item => item.task);
+        this.items = [];
+        tasks.forEach(task => {
+            const priority = priorityFn(task);
+            this.enqueue(task, priority);
+        });
+    }
+}
+
+export class AutonomousTaskEngine {
+    private agent: AutonomousAgent;
+    private queue = new PriorityQueue<Task>();
+    private active = true;
+    private executionHistory: ExecutionLog[] = [];
+    private memoryOptimizationIntervalId: NodeJS.Timeout | null = null;
+
+    constructor(agent?: AutonomousAgent) {
+        if (agent) {
+            this.agent = agent;
+        } else {
+            const memory = getCognitiveMemory();
+            const registry = getSourceRegistry();
+            this.agent = new AutonomousAgent(memory, registry);
+        }
+
+        // Listen for system events to generate tasks
+        eventBus.onEvent('system.alert', (event) => {
+            this.queue.enqueue({
+                type: 'diagnostic',
+                payload: event.payload,
+                baseScore: 100,
+                isMaintenanceTask: true
+            }, 100);
+        });
+
+        // Schedule nightly memory optimization (Consolidation & Decay)
+        this.memoryOptimizationIntervalId = setInterval(() => {
+            this.queue.enqueue({
+                type: 'memory_optimization',
+                payload: { mode: 'nightly_consolidation' },
+                baseScore: 80,
+                isMaintenanceTask: true
+            }, 80);
+        }, 1000 * 60 * 60 * 24); // Every 24 hours
+    }
+
+    async start() {
+        console.log('🤖 AutonomousTaskEngine started');
+        
+        // Run the task loop in the background (non-blocking)
+        this.runTaskLoop();
+    }
+
+    private async runTaskLoop() {
+        while (this.active) {
+            if (this.queue.isEmpty()) {
+                await new Promise((r) => setTimeout(r, 1000));
+                continue;
+            }
+
+            const task = this.queue.dequeue()!;
+            const result = await this.executeTask(task);
+
+            // Generate new tasks based on result
+            const newTasks = await this.generateTasksFromResult(result);
+            this.queue.addAll(newTasks);
+
+            // Reprioritize all tasks
+            await this.reprioritizeTasks();
+
+            // Log to episodic memory
+            await this.logToEpisodicMemory(task, result, newTasks);
+
+            // Learn patterns → procedural memory
+            await this.convertPatternToProcedure(result);
+        }
+    }
+
+    stop() {
+        this.active = false;
+        // Clear the memory optimization interval to prevent resource leak
+        if (this.memoryOptimizationIntervalId !== null) {
+            clearInterval(this.memoryOptimizationIntervalId);
+            this.memoryOptimizationIntervalId = null;
+        }
+    }
+
+    private async executeTask(task: Task): Promise<TaskResult> {
+        const startTime = Date.now();
+        try {
+            // Handle special memory optimization tasks
+            if (task.type === 'memory_optimization') {
+                return await this.executeMemoryOptimization(task);
+            }
+
+            const intent = this.taskToIntent(task);
+            const result = await this.agent.executeAndLearn(intent, async (src) => {
+                if ('query' in src && typeof src.query === 'function') {
+                    return await src.query(intent.operation || task.type, intent.params || task.payload);
+                }
+                throw new Error(`Source ${src.name} does not support query operation`);
+            });
+
+            const duration = Date.now() - startTime;
+
+            // Emit event for TaskRecorder observation
+            eventBus.emit('autonomous.task.executed', {
+                taskType: task.type,
+                payload: task.payload,
+                success: true,
+                result: result.data,
+                duration
+            });
+
+            return {
+                success: true,
+                data: result.data,
+                needsMoreData: false,
+                foundPattern: false
+            };
+        } catch (error: any) {
+            const duration = Date.now() - startTime;
+
+            // Emit event for TaskRecorder observation (failure)
+            eventBus.emit('autonomous.task.executed', {
+                taskType: task.type,
+                payload: task.payload,
+                success: false,
+                error: error.message,
+                duration
+            });
+
+            return {
+                success: false,
+                error: error.message,
+                needsMoreData: true
+            };
+        }
+    }
+
+    /**
+     * Execute Memory Optimization (Learning Loop)
+     * 1. Consolidate similar vectors
+     * 2. Decay old/unused memories
+     * 3. Reflect on recent insights
+     */
+    private async executeMemoryOptimization(task: Task): Promise<TaskResult> {
+        console.log('🧠 [Learning Loop] Starting memory optimization...');
+
+        try {
+            const { getVectorStore } = await import('../../platform/vector/index.js');
+            const vectorStore = await getVectorStore();
+
+            // 1. Consolidation: Find duplicates/similar items
+            // (Simplified implementation: In a real scenario, we'd cluster vectors)
+            const stats = await vectorStore.getStatistics();
+            console.log(`🧠 [Learning Loop] Current memory size: ${stats.totalRecords} vectors`);
+
+            // 2. Reflection: If we have new data, try to synthesize it
+            // This would involve querying the LLM to summarize recent entries
+
+            return {
+                success: true,
+                data: { optimized: true, stats },
+                foundPattern: true // Optimization often reveals patterns
+            };
+        } catch (error: any) {
+            console.error('❌ [Learning Loop] Optimization failed:', error);
+            return { success: false, error: error.message };
+        }
+    }
+
+    private async generateTasksFromResult(result: TaskResult): Promise<Task[]> {
+        const tasks: Task[] = [];
+
+        if (result.needsMoreData) {
+            tasks.push({
+                type: 'data_collection',
+                payload: { reason: result.error || 'Missing data' },
+                baseScore: 60,
+                isSimple: true
+            });
+        }
+
+        if (result.foundPattern) {
+            tasks.push({
+                type: 'pattern_exploration',
+                payload: { pattern: result.data },
+                baseScore: 70,
+                isSimple: false
+            });
+        }
+
+        return tasks;
+    }
+
+    private async reprioritizeTasks(): Promise<void> {
+        // Get emotional state and system health for prioritization
+        const emotionalState = await this.getEmotionalState();
+        const systemHealth = await unifiedMemorySystem.analyzeSystemHealth();
+
+        this.queue.reprioritize((task) => {
+            let score = task.baseScore || 50;
+
+            // Stress-aware prioritization
+            if (emotionalState.stress === 'high') {
+                score += task.isSimple ? 50 : -30;
+            }
+
+            // Health-aware prioritization
+            if (systemHealth.globalHealth < 0.5) {
+                score += task.isMaintenanceTask ? 100 : 0;
+            }
+
+            return score;
+        });
+    }
+
+    private async getEmotionalState(): Promise<{ stress: 'low' | 'medium' | 'high' }> {
+        // Placeholder: query PAL for emotional state
+        // In real implementation, this would query PAL repository
+        return { stress: 'low' };
+    }
+
+    private async logToEpisodicMemory(task: Task, result: TaskResult, newTasks: Task[]): Promise<void> {
+        const log: ExecutionLog = {
+            task,
+            result,
+            timestamp: new Date(),
+            newTasks
+        };
+
+        this.executionHistory.push(log);
+
+        // Keep only last 100 logs
+        if (this.executionHistory.length > 100) {
+            this.executionHistory.shift();
+        }
+
+        // Update working memory
+        await unifiedMemorySystem.updateWorkingMemory(
+            { orgId: 'default', userId: 'system' }, // Removed timestamp to match McpContext type
+            log
+        );
+    }
+
+    private async convertPatternToProcedure(result: TaskResult): Promise<void> {
+        // Placeholder: convert successful patterns to procedural memory
+        // In real implementation, this would extract rules and store them
+        if (result.success && result.data) {
+            // Pattern detected, could be converted to a production rule
+        }
+    }
+
+    private taskToIntent(task: Task): any {
+        return {
+            type: task.type,
+            operation: task.type,
+            params: task.payload
+        };
+    }
+
+    getExecutionHistory(): ExecutionLog[] {
+        return [...this.executionHistory];
+    }
+}
+
+// Export singleton instance
+export const autonomousTaskEngine = new AutonomousTaskEngine();

apps/backend/src/mcp/cognitive/EmotionAwareDecisionEngine.ts

@@ -0,0 +1,395 @@
+// Enhanced EmotionAwareDecisionEngine – Phase 1 Week 3
+// Multi-modal decision making with emotional awareness
+
+import { PalRepository } from '../../services/pal/palRepository.js';
+import { unifiedMemorySystem } from './UnifiedMemorySystem.js';
+import { McpContext } from '@widget-tdc/mcp-types';
+import { QueryIntent } from '../autonomous/DecisionEngine.js';
+
+export interface EmotionalState {
+    stress: 'low' | 'medium' | 'high';
+    focus: 'shallow' | 'medium' | 'deep';
+    energy: 'low' | 'medium' | 'high';
+    mood: 'negative' | 'neutral' | 'positive';
+}
+
+export interface Action {
+    complexity: 'low' | 'medium' | 'high';
+    estimatedTime: number; // milliseconds
+    depth: 'low' | 'medium' | 'high';
+    requiresFocus: boolean;
+}
+
+export interface Decision {
+    action: Action;
+    confidence: number;
+    reasoning: string;
+    emotionalFit: number;
+    dataQuality: number;
+    contextRelevance: number;
+    emotionalState?: EmotionalState;
+}
+
+export class EmotionAwareDecisionEngine {
+    private palRepo: PalRepository;
+
+    constructor() {
+        this.palRepo = new PalRepository();
+    }
+
+    /**
+     * Make emotion-aware decision based on query, emotional state, and context
+     */
+    async makeDecision(
+        query: string | QueryIntent,
+        ctx: McpContext
+    ): Promise<Decision> {
+        // Get emotional state from PAL
+        const emotionalState = await this.getEmotionalState(ctx.userId, ctx.orgId);
+
+        // Normalize query: if QueryIntent, convert to string representation; if string, use as-is
+        const queryStr = typeof query === 'string' 
+            ? query 
+            : `${query.operation || query.type} ${query.domain || ''} ${JSON.stringify(query.params || {})}`.trim();
+
+        // Convert to QueryIntent for methods that need structured data
+        const queryIntent: QueryIntent = typeof query === 'string'
+            ? {
+                type: 'query',
+                domain: 'general',
+                operation: 'search',
+                params: { query: queryStr }
+            }
+            : query;
+
+        // Evaluate multi-modal scores
+        const dataScore = await this.evaluateDataQuality(queryIntent, ctx);
+        const emotionScore = this.evaluateEmotionalFit(this.queryToAction(queryIntent), emotionalState);
+        const contextScore = await this.evaluateContextRelevance(queryIntent, ctx);
+
+        // Calculate dynamic weights based on emotional state
+        const weights = this.calculateDynamicWeights(emotionalState);
+
+        // Fuse scores with weights
+        const fusedScore = this.fusionDecision(
+            {
+                data: dataScore,
+                emotion: emotionScore,
+                context: contextScore
+            },
+            weights
+        );
+
+        // Determine action complexity based on emotional state
+        const action = this.determineOptimalAction(queryIntent, emotionalState);
+
+        const decision: Decision = {
+            action,
+            confidence: fusedScore,
+            reasoning: this.generateReasoning(emotionalState, dataScore, emotionScore, contextScore),
+            emotionalFit: emotionScore,
+            dataQuality: dataScore,
+            contextRelevance: contextScore,
+            emotionalState
+        };
+        return decision;
+    }
+
+    /**
+     * Get emotional state from PAL repository
+     */
+    private async getEmotionalState(userId: string, orgId: string): Promise<EmotionalState> {
+        try {
+            // Get recent PAL events to infer emotional state
+            const recentEvents = this.palRepo.getRecentEvents(userId, orgId, 10);
+            
+            // Analyze events for stress indicators
+            let stressLevel: 'low' | 'medium' | 'high' = 'low';
+            let focusLevel: 'shallow' | 'medium' | 'deep' = 'medium';
+            const energyLevel: 'low' | 'medium' | 'high' = 'medium';
+            const mood: 'negative' | 'neutral' | 'positive' = 'neutral';
+
+            if (Array.isArray(recentEvents)) {
+                const stressEvents = recentEvents.filter((e: any) => 
+                    e.event_type === 'stress' || e.detected_stress_level
+                );
+                
+                if (stressEvents.length > 0) {
+                    const avgStress = stressEvents.reduce((sum: number, e: any) => {
+                        const level = e.detected_stress_level || e.stress_level || 0;
+                        return sum + level;
+                    }, 0) / stressEvents.length;
+
+                    if (avgStress > 7) stressLevel = 'high';
+                    else if (avgStress > 4) stressLevel = 'medium';
+                }
+
+                // Check focus windows
+                const focusWindows = await this.palRepo.getFocusWindows(userId, orgId);
+                const now = new Date();
+                const currentHour = now.getHours();
+                const currentDay = now.getDay();
+
+                const inFocusWindow = focusWindows.some((fw: any) =>
+                    fw.weekday === currentDay &&
+                    currentHour >= fw.start_hour &&
+                    currentHour < fw.end_hour
+                );
+
+                if (inFocusWindow) {
+                    focusLevel = 'deep';
+                }
+            }
+
+            return {
+                stress: stressLevel,
+                focus: focusLevel,
+                energy: energyLevel,
+                mood
+            };
+        } catch (error) {
+            console.warn('Failed to get emotional state, using defaults:', error);
+            return {
+                stress: 'low',
+                focus: 'medium',
+                energy: 'medium',
+                mood: 'neutral'
+            };
+        }
+    }
+
+    /**
+     * Evaluate data quality score
+     */
+    private async evaluateDataQuality(query: QueryIntent, _ctx: McpContext): Promise<number> {
+        try {
+            // Check system health - healthy systems provide better data
+            const health = await unifiedMemorySystem.analyzeSystemHealth();
+            const baseScore = health.globalHealth;
+
+            // Adjust based on query complexity
+            const complexity = this.estimateQueryComplexity(query);
+            const complexityPenalty = complexity === 'high' ? 0.1 : complexity === 'medium' ? 0.05 : 0;
+
+            return Math.max(0, Math.min(1, baseScore - complexityPenalty));
+        } catch {
+            return 0.8; // Default good score
+        }
+    }
+
+    /**
+     * Evaluate emotional fit of action
+     */
+    private evaluateEmotionalFit(action: Action, emotion: EmotionalState): number {
+        let score = 0.5; // Base neutral score
+
+        // Stress-aware routing
+        if (emotion.stress === 'high') {
+            // Prefer simple, fast actions
+            if (action.complexity === 'low' && action.estimatedTime < 1000) {
+                score = 1.0;
+            } else if (action.complexity === 'high') {
+                score = 0.2;
+            } else {
+                score = 0.6;
+            }
+        } else if (emotion.stress === 'low') {
+            // Can handle more complexity
+            if (action.complexity === 'high' && action.depth === 'high') {
+                score = 0.9;
+            } else {
+                score = 0.7;
+            }
+        }
+
+        // Focus-aware routing
+        if (emotion.focus === 'deep') {
+            // Allow complex, deep tasks
+            if (action.depth === 'high' && action.requiresFocus) {
+                score = Math.max(score, 1.0);
+            }
+        } else if (emotion.focus === 'shallow') {
+            // Prefer simpler tasks
+            if (action.complexity === 'high') {
+                score = Math.min(score, 0.4);
+            }
+        }
+
+        // Energy-aware routing
+        if (emotion.energy === 'low') {
+            // Prefer low-effort tasks
+            if (action.complexity === 'low' && action.estimatedTime < 500) {
+                score = Math.max(score, 0.9);
+            } else {
+                score = Math.min(score, 0.6);
+            }
+        }
+
+        return Math.max(0, Math.min(1, score));
+    }
+
+    /**
+     * Evaluate context relevance
+     */
+    private async evaluateContextRelevance(query: QueryIntent, ctx: McpContext): Promise<number> {
+        try {
+            // Check if query matches recent patterns
+            const patterns = await unifiedMemorySystem.findHolographicPatterns(ctx);
+            
+            const queryText = JSON.stringify(query).toLowerCase();
+            const relevantPatterns = patterns.filter((p: any) => {
+                const keyword = p.keyword?.toLowerCase() || '';
+                return keyword && queryText.includes(keyword);
+            });
+
+            // More relevant patterns = higher score
+            return Math.min(1, 0.5 + (relevantPatterns.length * 0.1));
+        } catch {
+            return 0.7; // Default good relevance
+        }
+    }
+
+    /**
+     * Calculate dynamic weights based on emotional state
+     */
+    private calculateDynamicWeights(emotion: EmotionalState): {
+        data: number;
+        emotion: number;
+        context: number;
+    } {
+        // Base weights
+        let dataWeight = 0.4;
+        let emotionWeight = 0.3;
+        let contextWeight = 0.3;
+
+        // Adjust weights based on stress
+        if (emotion.stress === 'high') {
+            // Prioritize emotional fit when stressed
+            emotionWeight = 0.5;
+            dataWeight = 0.3;
+            contextWeight = 0.2;
+        } else if (emotion.stress === 'low') {
+            // Prioritize data quality when relaxed
+            dataWeight = 0.5;
+            emotionWeight = 0.2;
+            contextWeight = 0.3;
+        }
+
+        // Normalize
+        const total = dataWeight + emotionWeight + contextWeight;
+        return {
+            data: dataWeight / total,
+            emotion: emotionWeight / total,
+            context: contextWeight / total
+        };
+    }
+
+    /**
+     * Fuse scores with weights
+     */
+    private fusionDecision(
+        scores: { data: number; emotion: number; context: number },
+        weights: { data: number; emotion: number; context: number }
+    ): number {
+        return (
+            scores.data * weights.data +
+            scores.emotion * weights.emotion +
+            scores.context * weights.context
+        );
+    }
+
+    /**
+     * Determine optimal action based on query and emotional state
+     */
+    private determineOptimalAction(query: QueryIntent, emotion: EmotionalState): Action {
+        // Estimate complexity from query
+        const complexity = this.estimateQueryComplexity(query);
+        
+        // Estimate time (placeholder - would be more sophisticated)
+        const estimatedTime = complexity === 'high' ? 2000 : complexity === 'medium' ? 1000 : 500;
+        
+        // Determine depth requirement
+        const depth = complexity === 'high' ? 'high' : complexity === 'medium' ? 'medium' : 'low';
+        
+        // Adjust based on emotional state
+        let finalComplexity = complexity;
+        if (emotion.stress === 'high' && complexity === 'high') {
+            finalComplexity = 'medium'; // Reduce complexity when stressed
+        }
+
+        return {
+            complexity: finalComplexity,
+            estimatedTime,
+            depth,
+            requiresFocus: complexity === 'high' || emotion.focus === 'deep'
+        };
+    }
+
+    /**
+     * Estimate query complexity
+     */
+    private estimateQueryComplexity(query: QueryIntent): 'low' | 'medium' | 'high' {
+        const queryStr = JSON.stringify(query).toLowerCase();
+        
+        // Simple heuristics
+        if (queryStr.includes('complex') || queryStr.includes('analyze') || queryStr.includes('deep')) {
+            return 'high';
+        }
+        if (queryStr.includes('search') || queryStr.includes('find') || queryStr.includes('get')) {
+            return 'medium';
+        }
+        return 'low';
+    }
+
+    /**
+     * Convert query to action representation
+     */
+    private queryToAction(query: QueryIntent): Action {
+        const complexity = this.estimateQueryComplexity(query);
+        return {
+            complexity,
+            estimatedTime: complexity === 'high' ? 2000 : complexity === 'medium' ? 1000 : 500,
+            depth: complexity === 'high' ? 'high' : complexity === 'medium' ? 'medium' : 'low',
+            requiresFocus: complexity === 'high'
+        };
+    }
+
+    /**
+     * Generate human-readable reasoning
+     */
+    private generateReasoning(
+        emotion: EmotionalState,
+        dataScore: number,
+        emotionScore: number,
+        contextScore: number
+    ): string {
+        const parts: string[] = [];
+
+        if (emotion.stress === 'high') {
+            parts.push('User is experiencing high stress - prioritizing simple, fast actions');
+        }
+
+        if (emotion.focus === 'deep') {
+            parts.push('User is in deep focus mode - allowing complex tasks');
+        }
+
+        if (dataScore > 0.8) {
+            parts.push('High data quality available');
+        }
+
+        if (emotionScore > 0.8) {
+            parts.push('Action matches emotional state well');
+        }
+
+        if (contextScore > 0.8) {
+            parts.push('High context relevance');
+        }
+
+        return parts.length > 0 
+            ? parts.join('. ') 
+            : 'Balanced decision based on available information';
+    }
+}
+
+export const emotionAwareDecisionEngine = new EmotionAwareDecisionEngine();
+

apps/backend/src/mcp/cognitive/GraphTraversalOptimizer.ts

@@ -0,0 +1,234 @@
+import { neo4jService } from '../../database/Neo4jService';
+
+/**
+ * Advanced Graph Traversal Optimizer
+ * Optimizes multi-hop graph queries for better performance
+ */
+export class GraphTraversalOptimizer {
+    /**
+     * Optimized breadth-first search with pruning
+     */
+    async optimizedBFS(
+        startNodeId: string,
+        targetCondition: (node: any) => boolean,
+        maxDepth: number = 3,
+        maxNodes: number = 100
+    ): Promise<{ path: any[]; nodesVisited: number }> {
+        await neo4jService.connect();
+
+        try {
+            // Use Cypher's built-in path finding with limits
+            const result = await neo4jService.runQuery(
+                `MATCH path = (start)-[*1..${maxDepth}]-(end)
+         WHERE id(start) = $startId
+         WITH path, nodes(path) as pathNodes
+         LIMIT $maxNodes
+         RETURN path, pathNodes`,
+                { startId: parseInt(startNodeId), maxNodes }
+            );
+
+            await neo4jService.disconnect();
+
+            if (result.length === 0) {
+                return { path: [], nodesVisited: 0 };
+            }
+
+            // Find best path based on condition
+            const bestPath = result.find(r => {
+                const nodes = r.pathNodes;
+                return nodes.some((node: any) => targetCondition(node));
+            });
+
+            return {
+                path: bestPath?.pathNodes || [],
+                nodesVisited: result.length,
+            };
+        } catch (error) {
+            await neo4jService.disconnect();
+            throw error;
+        }
+    }
+
+    /**
+     * Find shortest path with relationship type filtering
+     */
+    async findShortestPath(
+        startNodeId: string,
+        endNodeId: string,
+        relationshipTypes?: string[],
+        maxDepth: number = 5
+    ): Promise<{ path: any[]; length: number } | null> {
+        await neo4jService.connect();
+
+        try {
+            const relFilter = relationshipTypes
+                ? `:${relationshipTypes.join('|')}`
+                : '';
+
+            const result = await neo4jService.runQuery(
+                `MATCH path = shortestPath((start)-[${relFilter}*1..${maxDepth}]-(end))
+         WHERE id(start) = $startId AND id(end) = $endId
+         RETURN path, length(path) as pathLength`,
+                { startId: parseInt(startNodeId), endId: parseInt(endNodeId) }
+            );
+
+            await neo4jService.disconnect();
+
+            if (result.length === 0) return null;
+
+            return {
+                path: result[0].path,
+                length: result[0].pathLength,
+            };
+        } catch (error) {
+            await neo4jService.disconnect();
+            throw error;
+        }
+    }
+
+    /**
+     * Find all paths with cost optimization
+     */
+    async findAllPathsWithCost(
+        startNodeId: string,
+        endNodeId: string,
+        maxDepth: number = 4,
+        costProperty: string = 'weight'
+    ): Promise<Array<{ path: any[]; cost: number }>> {
+        await neo4jService.connect();
+
+        try {
+            const result = await neo4jService.runQuery(
+                `MATCH path = (start)-[*1..${maxDepth}]-(end)
+         WHERE id(start) = $startId AND id(end) = $endId
+         WITH path, relationships(path) as rels
+         RETURN path, 
+                reduce(cost = 0, r in rels | cost + coalesce(r.${costProperty}, 1)) as totalCost
+         ORDER BY totalCost ASC
+         LIMIT 10`,
+                { startId: parseInt(startNodeId), endId: parseInt(endNodeId) }
+            );
+
+            await neo4jService.disconnect();
+
+            return result.map(r => ({
+                path: r.path,
+                cost: r.totalCost,
+            }));
+        } catch (error) {
+            await neo4jService.disconnect();
+            throw error;
+        }
+    }
+
+    /**
+     * Community detection using label propagation
+     */
+    async detectCommunities(minCommunitySize: number = 3): Promise<Map<string, string[]>> {
+        await neo4jService.connect();
+
+        try {
+            // Simple community detection based on connected components
+            const result = await neo4jService.runQuery(
+                `CALL gds.wcc.stream('myGraph')
+         YIELD nodeId, componentId
+         WITH componentId, collect(nodeId) as members
+         WHERE size(members) >= $minSize
+         RETURN componentId, members`,
+                { minSize: minCommunitySize }
+            );
+
+            await neo4jService.disconnect();
+
+            const communities = new Map<string, string[]>();
+            result.forEach(r => {
+                communities.set(r.componentId.toString(), r.members.map((id: any) => id.toString()));
+            });
+
+            return communities;
+        } catch (error) {
+            await neo4jService.disconnect();
+            // Fallback to simple connected components
+            return this.simpleConnectedComponents(minCommunitySize);
+        }
+    }
+
+    /**
+     * Fallback: Simple connected components without GDS
+     */
+    private async simpleConnectedComponents(minSize: number): Promise<Map<string, string[]>> {
+        const result = await neo4jService.runQuery(
+            `MATCH (n)
+       OPTIONAL MATCH path = (n)-[*]-(m)
+       WITH n, collect(DISTINCT m) as connected
+       WHERE size(connected) >= $minSize
+       RETURN id(n) as nodeId, [x in connected | id(x)] as members
+       LIMIT 100`,
+            { minSize }
+        );
+
+        const communities = new Map<string, string[]>();
+        result.forEach((r, idx) => {
+            communities.set(`community_${idx}`, r.members.map((id: any) => id.toString()));
+        });
+
+        return communities;
+    }
+
+    /**
+     * PageRank-style importance scoring
+     */
+    async computeNodeImportance(dampingFactor: number = 0.85, iterations: number = 20): Promise<Map<string, number>> {
+        await neo4jService.connect();
+
+        try {
+            // Try using GDS PageRank
+            const result = await neo4jService.runQuery(
+                `CALL gds.pageRank.stream('myGraph', {
+           maxIterations: $iterations,
+           dampingFactor: $dampingFactor
+         })
+         YIELD nodeId, score
+         RETURN nodeId, score
+         ORDER BY score DESC
+         LIMIT 100`,
+                { iterations, dampingFactor }
+            );
+
+            await neo4jService.disconnect();
+
+            const scores = new Map<string, number>();
+            result.forEach(r => {
+                scores.set(r.nodeId.toString(), r.score);
+            });
+
+            return scores;
+        } catch (error) {
+            await neo4jService.disconnect();
+            // Fallback to simple degree centrality
+            return this.simpleDegreeCentrality();
+        }
+    }
+
+    /**
+     * Fallback: Simple degree centrality without GDS
+     */
+    private async simpleDegreeCentrality(): Promise<Map<string, number>> {
+        const result = await neo4jService.runQuery(
+            `MATCH (n)-[r]-(m)
+       WITH n, count(r) as degree
+       RETURN id(n) as nodeId, degree
+       ORDER BY degree DESC
+       LIMIT 100`
+        );
+
+        const scores = new Map<string, number>();
+        result.forEach(r => {
+            scores.set(r.nodeId.toString(), r.degree);
+        });
+
+        return scores;
+    }
+}
+
+export const graphTraversalOptimizer = new GraphTraversalOptimizer();

apps/backend/src/mcp/cognitive/HybridSearchEngine.ts

@@ -0,0 +1,215 @@
+// HybridSearchEngine – Phase 1 Week 3
+// Combines keyword, semantic, and graph search with Reciprocal Rank Fusion
+
+import { MemoryRepository } from '../../services/memory/memoryRepository.js';
+import { SragRepository } from '../../services/srag/sragRepository.js';
+import { unifiedMemorySystem } from './UnifiedMemorySystem.js';
+import { McpContext } from '@widget-tdc/mcp-types';
+
+export interface SearchContext extends McpContext {
+    limit?: number;
+    filters?: Record<string, any>;
+    timestamp?: Date;
+}
+
+export interface SearchResult {
+    id: string;
+    type: 'memory' | 'document' | 'graph' | 'pattern';
+    score: number;
+    content: any;
+    source: string;
+    metadata?: any;
+}
+
+export class HybridSearchEngine {
+    private memoryRepo: MemoryRepository;
+    private sragRepo: SragRepository;
+
+    constructor() {
+        this.memoryRepo = new MemoryRepository();
+        this.sragRepo = new SragRepository();
+    }
+
+    /**
+     * Perform hybrid search across keyword, semantic, and graph sources
+     */
+    async search(query: string, ctx: SearchContext): Promise<SearchResult[]> {
+        const limit = ctx.limit || 20;
+
+        // Run all search types in parallel
+        const [keywordResults, semanticResults, graphResults] = await Promise.all([
+            this.keywordSearch(query, ctx, limit * 2),
+            this.semanticSearch(query, ctx, limit * 2),
+            this.graphTraversal(query, ctx, limit * 2)
+        ]);
+
+        // Reciprocal Rank Fusion
+        const fusedResults = this.fuseResults([
+            keywordResults,
+            semanticResults,
+            graphResults
+        ]);
+
+        // Return top results
+        return fusedResults.slice(0, limit);
+    }
+
+    /**
+     * Keyword-based search (exact matches, FTS)
+     */
+    private async keywordSearch(
+        query: string,
+        ctx: SearchContext,
+        limit: number
+    ): Promise<SearchResult[]> {
+        const results: SearchResult[] = [];
+
+        try {
+            // Search memory entities
+            const memoryResults = await this.memoryRepo.searchEntities({
+                orgId: ctx.orgId,
+                userId: ctx.userId,
+                keywords: query.split(/\s+/).filter(w => w.length > 2),
+                limit
+            });
+
+            memoryResults.forEach((entity: any, index: number) => {
+                results.push({
+                    id: `memory-${entity.id}`,
+                    type: 'memory',
+                    score: 1.0 - (index / limit), // Rank-based score
+                    content: entity,
+                    source: 'memory_repository'
+                });
+            });
+
+            // Search SRAG documents
+            const sragResults = await this.sragRepo.searchDocuments(ctx.orgId, query);
+            sragResults.forEach((doc: any, index: number) => {
+                results.push({
+                    id: `srag-${doc.id}`,
+                    type: 'document',
+                    score: 1.0 - (index / limit),
+                    content: doc,
+                    source: 'srag_repository'
+                });
+            });
+        } catch (error) {
+            console.warn('Keyword search error:', error);
+        }
+
+        return results;
+    }
+
+    /**
+     * Semantic search using embeddings
+     */
+    private async semanticSearch(
+        query: string,
+        ctx: SearchContext,
+        limit: number
+    ): Promise<SearchResult[]> {
+        const results: SearchResult[] = [];
+
+        try {
+            // Use MemoryRepository's vector search
+            const memoryResults = await this.memoryRepo.searchEntities({
+                orgId: ctx.orgId,
+                userId: ctx.userId,
+                keywords: query ? [query] : [], // Use query as keyword for semantic search
+                limit
+            });
+
+            memoryResults.forEach((entity: any, index: number) => {
+                results.push({
+                    id: `semantic-${entity.id}`,
+                    type: 'memory',
+                    score: entity.similarity || (1.0 - index / limit),
+                    content: entity,
+                    source: 'semantic_search'
+                });
+            });
+        } catch (error) {
+            console.warn('Semantic search error:', error);
+        }
+
+        return results;
+    }
+
+    /**
+     * Graph traversal search (knowledge graph patterns)
+     */
+    private async graphTraversal(
+        query: string,
+        ctx: SearchContext,
+        limit: number
+    ): Promise<SearchResult[]> {
+        const results: SearchResult[] = [];
+
+        try {
+            // Use UnifiedMemorySystem to find holographic patterns
+            const patterns = await unifiedMemorySystem.findHolographicPatterns(ctx);
+
+            if (Array.isArray(patterns)) {
+                patterns.forEach((pattern: any, index: number) => {
+                    // Check if pattern matches query keywords
+                    const queryWords = query.toLowerCase().split(/\s+/);
+                    const patternText = JSON.stringify(pattern).toLowerCase();
+                    const matchCount = queryWords.filter(word => 
+                        patternText.includes(word)
+                    ).length;
+
+                    if (matchCount > 0) {
+                        results.push({
+                            id: `pattern-${pattern.keyword || index}`,
+                            type: 'pattern',
+                            score: (matchCount / queryWords.length) * (pattern.frequency || 0.5),
+                            content: pattern,
+                            source: 'graph_traversal'
+                        });
+                    }
+                });
+            }
+        } catch (error) {
+            console.warn('Graph traversal error:', error);
+        }
+
+        return results;
+    }
+
+    /**
+     * Reciprocal Rank Fusion (RRF) to combine results from multiple sources
+     */
+    private fuseResults(resultSets: SearchResult[][]): SearchResult[] {
+        const rrfScores = new Map<string, { result: SearchResult; score: number }>();
+
+        // Calculate RRF scores for each result set
+        resultSets.forEach((resultSet, setIndex) => {
+            resultSet.forEach((result, rank) => {
+                const existing = rrfScores.get(result.id);
+                const rrfScore = 1 / (rank + 60); // RRF formula: 1/(rank + k), k=60
+
+                if (existing) {
+                    // Combine scores: RRF + original score
+                    existing.score += rrfScore;
+                } else {
+                    rrfScores.set(result.id, {
+                        result,
+                        score: rrfScore + (result.score * 0.1) // Weight original score
+                    });
+                }
+            });
+        });
+
+        // Sort by combined score and return
+        return Array.from(rrfScores.values())
+            .sort((a, b) => b.score - a.score)
+            .map(item => ({
+                ...item.result,
+                score: item.score
+            }));
+    }
+}
+
+export const hybridSearchEngine = new HybridSearchEngine();
+

apps/backend/src/mcp/cognitive/IntegrationManager.ts

@@ -0,0 +1,230 @@
+/**
+ * External Integrations
+ * Slack, GitHub, Jira, and other third-party services
+ */
+
+export interface SlackMessage {
+    channel: string;
+    text: string;
+    attachments?: any[];
+    thread_ts?: string;
+}
+
+export interface GitHubIssue {
+    title: string;
+    body: string;
+    labels?: string[];
+    assignees?: string[];
+}
+
+export interface JiraTicket {
+    project: string;
+    summary: string;
+    description: string;
+    issueType: string;
+    priority?: string;
+}
+
+export class IntegrationManager {
+    private slackWebhook?: string;
+    private githubToken?: string;
+    private jiraCredentials?: { email: string; apiToken: string; domain: string };
+
+    constructor() {
+        this.slackWebhook = process.env.SLACK_WEBHOOK_URL;
+        this.githubToken = process.env.GITHUB_TOKEN;
+
+        if (process.env.JIRA_EMAIL && process.env.JIRA_API_TOKEN && process.env.JIRA_DOMAIN) {
+            this.jiraCredentials = {
+                email: process.env.JIRA_EMAIL,
+                apiToken: process.env.JIRA_API_TOKEN,
+                domain: process.env.JIRA_DOMAIN,
+            };
+        }
+    }
+
+    /**
+     * Send Slack notification
+     */
+    async sendSlackNotification(message: SlackMessage): Promise<boolean> {
+        if (!this.slackWebhook) {
+            console.warn('⚠️  Slack webhook not configured');
+            return false;
+        }
+
+        try {
+            // In production, would make actual HTTP request
+            console.log(`📢 Slack notification: ${message.text} to ${message.channel}`);
+            return true;
+        } catch (error) {
+            console.error('Failed to send Slack notification:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Create GitHub issue
+     */
+    async createGitHubIssue(
+        repo: string,
+        issue: GitHubIssue
+    ): Promise<{ number: number; url: string } | null> {
+        if (!this.githubToken) {
+            console.warn('⚠️  GitHub token not configured');
+            return null;
+        }
+
+        try {
+            // In production, would make actual GitHub API call
+            const issueNumber = Math.floor(Math.random() * 1000);
+            const url = `https://github.com/${repo}/issues/${issueNumber}`;
+
+            console.log(`🐙 Created GitHub issue #${issueNumber}: ${issue.title}`);
+            return { number: issueNumber, url };
+        } catch (error) {
+            console.error('Failed to create GitHub issue:', error);
+            return null;
+        }
+    }
+
+    /**
+     * Create Jira ticket
+     */
+    async createJiraTicket(ticket: JiraTicket): Promise<{ key: string; url: string } | null> {
+        if (!this.jiraCredentials) {
+            console.warn('⚠️  Jira credentials not configured');
+            return null;
+        }
+
+        try {
+            // In production, would make actual Jira API call
+            const ticketKey = `${ticket.project}-${Math.floor(Math.random() * 1000)}`;
+            const url = `https://${this.jiraCredentials.domain}/browse/${ticketKey}`;
+
+            console.log(`📋 Created Jira ticket ${ticketKey}: ${ticket.summary}`);
+            return { key: ticketKey, url };
+        } catch (error) {
+            console.error('Failed to create Jira ticket:', error);
+            return null;
+        }
+    }
+
+    /**
+     * Send alert to multiple channels
+     */
+    async sendAlert(
+        message: string,
+        severity: 'info' | 'warning' | 'error' | 'critical',
+        channels: Array<'slack' | 'github' | 'jira'> = ['slack']
+    ): Promise<void> {
+        const emoji = {
+            info: 'ℹ️',
+            warning: '⚠️',
+            error: '❌',
+            critical: '🚨',
+        };
+
+        const formattedMessage = `${emoji[severity]} ${message}`;
+
+        for (const channel of channels) {
+            switch (channel) {
+                case 'slack':
+                    await this.sendSlackNotification({
+                        channel: '#alerts',
+                        text: formattedMessage,
+                    });
+                    break;
+
+                case 'github':
+                    if (severity === 'error' || severity === 'critical') {
+                        await this.createGitHubIssue('org/repo', {
+                            title: `[${severity.toUpperCase()}] ${message}`,
+                            body: `Automated alert generated at ${new Date().toISOString()}`,
+                            labels: [severity, 'automated'],
+                        });
+                    }
+                    break;
+
+                case 'jira':
+                    if (severity === 'critical') {
+                        await this.createJiraTicket({
+                            project: 'OPS',
+                            summary: message,
+                            description: `Critical alert generated at ${new Date().toISOString()}`,
+                            issueType: 'Bug',
+                            priority: 'Highest',
+                        });
+                    }
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Webhook receiver for external events
+     */
+    async handleWebhook(
+        source: 'slack' | 'github' | 'jira',
+        payload: any
+    ): Promise<void> {
+        console.log(`🔔 Received webhook from ${source}`);
+
+        switch (source) {
+            case 'slack':
+                await this.handleSlackEvent(payload);
+                break;
+            case 'github':
+                await this.handleGitHubEvent(payload);
+                break;
+            case 'jira':
+                await this.handleJiraEvent(payload);
+                break;
+        }
+    }
+
+    private async handleSlackEvent(payload: any): Promise<void> {
+        // Handle Slack slash commands, mentions, etc.
+        console.log('Processing Slack event:', payload.type);
+    }
+
+    private async handleGitHubEvent(payload: any): Promise<void> {
+        // Handle GitHub webhooks (issues, PRs, comments)
+        console.log('Processing GitHub event:', payload.action);
+    }
+
+    private async handleJiraEvent(payload: any): Promise<void> {
+        // Handle Jira webhooks (issue updates, comments)
+        console.log('Processing Jira event:', payload.webhookEvent);
+    }
+
+    /**
+     * Sync data from external source
+     */
+    async syncExternalData(
+        source: 'github' | 'jira',
+        query: string
+    ): Promise<any[]> {
+        switch (source) {
+            case 'github':
+                return this.syncGitHubData(query);
+            case 'jira':
+                return this.syncJiraData(query);
+            default:
+                return [];
+        }
+    }
+
+    private async syncGitHubData(query: string): Promise<any[]> {
+        // Fetch issues, PRs, etc. from GitHub
+        console.log(`🔄 Syncing GitHub data: ${query}`);
+        return [];
+    }
+
+    private async syncJiraData(query: string): Promise<any[]> {
+        // Fetch tickets from Jira
+        console.log(`🔄 Syncing Jira data: ${query}`);
+        return [];
+    }
+}
+
+export const integrationManager = new IntegrationManager();

apps/backend/src/mcp/cognitive/MetaLearningEngine.ts

@@ -0,0 +1,244 @@
+/**
+ * Meta-Learning Engine
+ * Learns how to learn - optimizes learning strategies across tasks
+ */
+
+export interface LearningStrategy {
+    name: string;
+    parameters: Record<string, any>;
+    performance: {
+        tasksApplied: number;
+        avgImprovement: number;
+        bestDomain: string;
+    };
+}
+
+export interface TaskDomain {
+    name: string;
+    characteristics: string[];
+    optimalStrategy: string;
+    transferability: Map<string, number>; // How well learning transfers to other domains
+}
+
+export class MetaLearningEngine {
+    private strategies: Map<string, LearningStrategy> = new Map();
+    private domains: Map<string, TaskDomain> = new Map();
+    private learningHistory: Array<{
+        domain: string;
+        strategy: string;
+        improvement: number;
+        timestamp: Date;
+    }> = [];
+
+    constructor() {
+        this.initializeDefaultStrategies();
+    }
+
+    /**
+     * Initialize default learning strategies
+     */
+    private initializeDefaultStrategies(): void {
+        const defaultStrategies: LearningStrategy[] = [
+            {
+                name: 'gradient_descent',
+                parameters: { learningRate: 0.01, momentum: 0.9 },
+                performance: { tasksApplied: 0, avgImprovement: 0, bestDomain: '' },
+            },
+            {
+                name: 'few_shot',
+                parameters: { examples: 5, temperature: 0.7 },
+                performance: { tasksApplied: 0, avgImprovement: 0, bestDomain: '' },
+            },
+            {
+                name: 'reinforcement',
+                parameters: { explorationRate: 0.1, discountFactor: 0.95 },
+                performance: { tasksApplied: 0, avgImprovement: 0, bestDomain: '' },
+            },
+            {
+                name: 'transfer_learning',
+                parameters: { sourceTask: '', fineTuneEpochs: 10 },
+                performance: { tasksApplied: 0, avgImprovement: 0, bestDomain: '' },
+            },
+        ];
+
+        defaultStrategies.forEach(strategy => {
+            this.strategies.set(strategy.name, strategy);
+        });
+    }
+
+    /**
+     * Select optimal learning strategy for a task
+     */
+    selectStrategy(domain: string, taskCharacteristics: string[]): LearningStrategy {
+        const domainInfo = this.domains.get(domain);
+
+        if (domainInfo && domainInfo.optimalStrategy) {
+            const strategy = this.strategies.get(domainInfo.optimalStrategy);
+            if (strategy) return strategy;
+        }
+
+        // Find strategy with best performance in similar domains
+        const strategies = Array.from(this.strategies.values());
+        const scored = strategies.map(strategy => {
+            const relevantHistory = this.learningHistory.filter(h => h.strategy === strategy.name);
+            const avgImprovement = relevantHistory.length > 0
+                ? relevantHistory.reduce((sum, h) => sum + h.improvement, 0) / relevantHistory.length
+                : 0;
+
+            return { strategy, score: avgImprovement };
+        });
+
+        scored.sort((a, b) => b.score - a.score);
+        return scored[0]?.strategy || strategies[0];
+    }
+
+    /**
+     * Record learning outcome
+     */
+    recordLearningOutcome(
+        domain: string,
+        strategy: string,
+        improvement: number
+    ): void {
+        this.learningHistory.push({
+            domain,
+            strategy,
+            improvement,
+            timestamp: new Date(),
+        });
+
+        // Update strategy performance
+        const strategyObj = this.strategies.get(strategy);
+        if (strategyObj) {
+            strategyObj.performance.tasksApplied++;
+            strategyObj.performance.avgImprovement =
+                (strategyObj.performance.avgImprovement * (strategyObj.performance.tasksApplied - 1) + improvement) /
+                strategyObj.performance.tasksApplied;
+        }
+
+        // Update domain optimal strategy
+        this.updateDomainStrategy(domain);
+    }
+
+    /**
+     * Update optimal strategy for a domain
+     */
+    private updateDomainStrategy(domain: string): void {
+        const domainHistory = this.learningHistory.filter(h => h.domain === domain);
+        if (domainHistory.length < 5) return; // Need enough data
+
+        // Group by strategy
+        const strategyPerformance = new Map<string, number[]>();
+        domainHistory.forEach(h => {
+            if (!strategyPerformance.has(h.strategy)) {
+                strategyPerformance.set(h.strategy, []);
+            }
+            strategyPerformance.get(h.strategy)!.push(h.improvement);
+        });
+
+        // Find best strategy
+        let bestStrategy = '';
+        let bestAvg = -Infinity;
+
+        strategyPerformance.forEach((improvements, strategy) => {
+            const avg = improvements.reduce((sum, val) => sum + val, 0) / improvements.length;
+            if (avg > bestAvg) {
+                bestAvg = avg;
+                bestStrategy = strategy;
+            }
+        });
+
+        // Update domain
+        if (!this.domains.has(domain)) {
+            this.domains.set(domain, {
+                name: domain,
+                characteristics: [],
+                optimalStrategy: bestStrategy,
+                transferability: new Map(),
+            });
+        } else {
+            this.domains.get(domain)!.optimalStrategy = bestStrategy;
+        }
+    }
+
+    /**
+     * Transfer learning from one domain to another
+     */
+    async transferLearning(
+        sourceDomain: string,
+        targetDomain: string
+    ): Promise<LearningStrategy | null> {
+        const source = this.domains.get(sourceDomain);
+        if (!source) return null;
+
+        // Check transferability
+        const transferScore = source.transferability.get(targetDomain) || 0;
+
+        if (transferScore > 0.5) {
+            // High transferability - use source domain's strategy
+            const strategy = this.strategies.get(source.optimalStrategy);
+            if (strategy) {
+                console.log(`📚 Transferring learning from ${sourceDomain} to ${targetDomain}`);
+                return strategy;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Optimize learning parameters
+     */
+    optimizeParameters(strategyName: string): Record<string, any> {
+        const strategy = this.strategies.get(strategyName);
+        if (!strategy) return {};
+
+        // Simple parameter optimization based on historical performance
+        const recentHistory = this.learningHistory
+            .filter(h => h.strategy === strategyName)
+            .slice(-20);
+
+        if (recentHistory.length < 10) return strategy.parameters;
+
+        // Analyze if we should adjust learning rate (example)
+        const avgImprovement = recentHistory.reduce((sum, h) => sum + h.improvement, 0) / recentHistory.length;
+
+        if (avgImprovement < 0.1 && strategy.parameters.learningRate) {
+            // Low improvement - increase learning rate
+            strategy.parameters.learningRate *= 1.1;
+        } else if (avgImprovement > 0.5 && strategy.parameters.learningRate) {
+            // High improvement - decrease learning rate for fine-tuning
+            strategy.parameters.learningRate *= 0.9;
+        }
+
+        return strategy.parameters;
+    }
+
+    /**
+     * Get meta-learning statistics
+     */
+    getStatistics(): {
+        totalStrategies: number;
+        totalDomains: number;
+        mostEffectiveStrategy: string;
+        avgImprovementRate: number;
+    } {
+        const strategies = Array.from(this.strategies.values());
+        const mostEffective = strategies.sort((a, b) =>
+            b.performance.avgImprovement - a.performance.avgImprovement
+        )[0];
+
+        const avgImprovement = this.learningHistory.length > 0
+            ? this.learningHistory.reduce((sum, h) => sum + h.improvement, 0) / this.learningHistory.length
+            : 0;
+
+        return {
+            totalStrategies: this.strategies.size,
+            totalDomains: this.domains.size,
+            mostEffectiveStrategy: mostEffective?.name || 'none',
+            avgImprovementRate: avgImprovement,
+        };
+    }
+}
+
+export const metaLearningEngine = new MetaLearningEngine();

apps/backend/src/mcp/cognitive/MultiModalProcessor.ts

@@ -0,0 +1,165 @@
+/**
+ * Multi-Modal Support
+ * Handles images, audio, video, and cross-modal search
+ * PRODUCTION VERSION - NO MOCK DATA
+ */
+
+import { getVectorStore } from '../../platform/vector/index.js';
+import { getEmbeddingService } from '../../services/embeddings/EmbeddingService';
+
+export interface MultiModalEmbedding {
+    id: string;
+    type: 'image' | 'audio' | 'video' | 'text';
+    embedding: number[];
+    metadata: Record<string, any>;
+    timestamp: Date;
+}
+
+export class MultiModalProcessor {
+    private clipModelLoaded: boolean = false;
+    private audioModelLoaded: boolean = false;
+
+    /**
+     * Generate image embeddings using CLIP
+     * Requires CLIP model to be configured
+     */
+    async generateImageEmbedding(imageUrl: string): Promise<number[]> {
+        if (!process.env.CLIP_MODEL_PATH && !process.env.OPENAI_API_KEY) {
+            throw new Error(
+                'CLIP model not configured. Set CLIP_MODEL_PATH or OPENAI_API_KEY in environment variables.'
+            );
+        }
+
+        // TODO: Implement actual CLIP model integration
+        // Options:
+        // 1. Use OpenAI CLIP API
+        // 2. Use local CLIP model via transformers.js
+        // 3. Use HuggingFace Inference API
+
+        throw new Error('CLIP model integration not yet implemented. Please configure a CLIP provider.');
+    }
+
+    /**
+     * Generate audio embeddings
+     * Requires audio processing model
+     */
+    async generateAudioEmbedding(audioUrl: string): Promise<number[]> {
+        if (!process.env.AUDIO_MODEL_PATH) {
+            throw new Error(
+                'Audio model not configured. Set AUDIO_MODEL_PATH in environment variables.'
+            );
+        }
+
+        // TODO: Implement actual audio model integration
+        // Options:
+        // 1. Wav2Vec 2.0
+        // 2. OpenAI Whisper
+        // 3. HuggingFace audio models
+
+        throw new Error('Audio model integration not yet implemented. Please configure an audio model.');
+    }
+
+    /**
+     * Generate video embeddings
+     * Combines visual and audio features
+     */
+    async generateVideoEmbedding(videoUrl: string): Promise<number[]> {
+        if (!process.env.VIDEO_MODEL_PATH) {
+            throw new Error(
+                'Video model not configured. Set VIDEO_MODEL_PATH in environment variables.'
+            );
+        }
+
+        // TODO: Implement actual video model integration
+        // Options:
+        // 1. Combine CLIP (visual) + Wav2Vec (audio)
+        // 2. Use specialized video models
+        // 3. Frame-by-frame processing
+
+        throw new Error('Video model integration not yet implemented. Please configure a video model.');
+    }
+
+    /**
+     * Cross-modal search
+     * Search for images using text query, or vice versa
+     */
+    async crossModalSearch(
+        query: string | number[],
+        targetModality: 'image' | 'audio' | 'video' | 'text',
+        limit: number = 10
+    ): Promise<MultiModalEmbedding[]> {
+        // Convert query to embedding if needed
+        let queryEmbedding: number[];
+        if (typeof query === 'string') {
+            queryEmbedding = await this.generateTextEmbedding(query);
+        } else {
+            queryEmbedding = query;
+        }
+
+        // Search in vector database
+        const vectorStore = await getVectorStore();
+        const results = await vectorStore.search({
+            vector: queryEmbedding,
+            namespace: `multimodal_${targetModality}`,
+            limit
+        });
+
+        return results.map(result => ({
+            id: result.id,
+            type: targetModality,
+            embedding: [], // Embedding not returned from search, would need separate lookup
+            metadata: result.metadata || {},
+            timestamp: new Date(result.metadata?.timestamp || Date.now()),
+        }));
+    }
+
+    /**
+     * Generate text embedding for cross-modal comparison
+     */
+    private async generateTextEmbedding(text: string): Promise<number[]> {
+        const embeddingService = getEmbeddingService();
+        const embedding = await embeddingService.generateEmbedding(text);
+        return embedding;
+    }
+
+    /**
+     * Multi-modal RAG
+     * Retrieve relevant content across all modalities
+     */
+    async multiModalRAG(
+        query: string,
+        modalities: Array<'image' | 'audio' | 'video' | 'text'> = ['text', 'image']
+    ): Promise<Map<string, MultiModalEmbedding[]>> {
+        const results = new Map<string, MultiModalEmbedding[]>();
+
+        for (const modality of modalities) {
+            try {
+                const modalityResults = await this.crossModalSearch(query, modality, 5);
+                results.set(modality, modalityResults);
+            } catch (error) {
+                console.error(`Failed to search ${modality}:`, error);
+                results.set(modality, []);
+            }
+        }
+
+        console.log(`📚 Multi-modal RAG completed for: ${query}`);
+        return results;
+    }
+
+    /**
+     * Check if multi-modal features are available
+     */
+    isConfigured(): {
+        clip: boolean;
+        audio: boolean;
+        video: boolean;
+    } {
+        return {
+            clip: !!(process.env.CLIP_MODEL_PATH || process.env.OPENAI_API_KEY),
+            audio: !!process.env.AUDIO_MODEL_PATH,
+            video: !!process.env.VIDEO_MODEL_PATH,
+        };
+    }
+}
+
+export const multiModalProcessor = new MultiModalProcessor();

apps/backend/src/mcp/cognitive/ObservabilitySystem.ts

@@ -0,0 +1,243 @@
+/**
+ * Advanced Observability System
+ * Distributed tracing, metrics, and logging
+ */
+
+export interface Trace {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    operation: string;
+    startTime: Date;
+    endTime?: Date;
+    duration?: number;
+    status: 'success' | 'error' | 'pending';
+    tags: Record<string, any>;
+    logs: Array<{ timestamp: Date; message: string; level: string }>;
+}
+
+export interface Metric {
+    name: string;
+    value: number;
+    type: 'counter' | 'gauge' | 'histogram';
+    timestamp: Date;
+    tags: Record<string, string>;
+}
+
+export class ObservabilitySystem {
+    private traces: Map<string, Trace[]> = new Map();
+    private metrics: Metric[] = [];
+    private activeSpans: Map<string, Trace> = new Map();
+
+    /**
+     * Start a new trace span
+     */
+    startSpan(operation: string, parentSpanId?: string): string {
+        const spanId = this.generateId();
+        const traceId = parentSpanId
+            ? this.findTraceId(parentSpanId)
+            : this.generateId();
+
+        const span: Trace = {
+            traceId,
+            spanId,
+            parentSpanId,
+            operation,
+            startTime: new Date(),
+            status: 'pending',
+            tags: {},
+            logs: [],
+        };
+
+        this.activeSpans.set(spanId, span);
+
+        if (!this.traces.has(traceId)) {
+            this.traces.set(traceId, []);
+        }
+        this.traces.get(traceId)!.push(span);
+
+        return spanId;
+    }
+
+    /**
+     * End a trace span
+     */
+    endSpan(spanId: string, status: 'success' | 'error' = 'success'): void {
+        const span = this.activeSpans.get(spanId);
+        if (!span) return;
+
+        span.endTime = new Date();
+        span.duration = span.endTime.getTime() - span.startTime.getTime();
+        span.status = status;
+
+        this.activeSpans.delete(spanId);
+    }
+
+    /**
+     * Add tags to a span
+     */
+    addTags(spanId: string, tags: Record<string, any>): void {
+        const span = this.activeSpans.get(spanId);
+        if (span) {
+            span.tags = { ...span.tags, ...tags };
+        }
+    }
+
+    /**
+     * Add log to a span
+     */
+    addLog(spanId: string, message: string, level: string = 'info'): void {
+        const span = this.activeSpans.get(spanId);
+        if (span) {
+            span.logs.push({
+                timestamp: new Date(),
+                message,
+                level,
+            });
+        }
+    }
+
+    /**
+     * Record a metric
+     */
+    recordMetric(
+        name: string,
+        value: number,
+        type: Metric['type'] = 'gauge',
+        tags: Record<string, string> = {}
+    ): void {
+        this.metrics.push({
+            name,
+            value,
+            type,
+            timestamp: new Date(),
+            tags,
+        });
+
+        // Keep only last 10000 metrics
+        if (this.metrics.length > 10000) {
+            this.metrics.shift();
+        }
+    }
+
+    /**
+     * Get trace by ID
+     */
+    getTrace(traceId: string): Trace[] | undefined {
+        return this.traces.get(traceId);
+    }
+
+    /**
+     * Get metrics by name
+     */
+    getMetrics(name: string, since?: Date): Metric[] {
+        let filtered = this.metrics.filter(m => m.name === name);
+
+        if (since) {
+            filtered = filtered.filter(m => m.timestamp >= since);
+        }
+
+        return filtered;
+    }
+
+    /**
+     * Get aggregated metrics
+     */
+    getAggregatedMetrics(
+        name: string,
+        aggregation: 'sum' | 'avg' | 'min' | 'max' | 'count',
+        since?: Date
+    ): number {
+        const metrics = this.getMetrics(name, since);
+
+        if (metrics.length === 0) return 0;
+
+        switch (aggregation) {
+            case 'sum':
+                return metrics.reduce((sum, m) => sum + m.value, 0);
+            case 'avg':
+                return metrics.reduce((sum, m) => sum + m.value, 0) / metrics.length;
+            case 'min':
+                return Math.min(...metrics.map(m => m.value));
+            case 'max':
+                return Math.max(...metrics.map(m => m.value));
+            case 'count':
+                return metrics.length;
+            default:
+                return 0;
+        }
+    }
+
+    /**
+     * Get slow traces (duration > threshold)
+     */
+    getSlowTraces(thresholdMs: number = 1000): Trace[] {
+        const allTraces = Array.from(this.traces.values()).flat();
+        return allTraces.filter(trace =>
+            trace.duration && trace.duration > thresholdMs
+        );
+    }
+
+    /**
+     * Get error traces
+     */
+    getErrorTraces(): Trace[] {
+        const allTraces = Array.from(this.traces.values()).flat();
+        return allTraces.filter(trace => trace.status === 'error');
+    }
+
+    /**
+     * Generate observability dashboard data
+     */
+    getDashboardData(): {
+        totalTraces: number;
+        activeSpans: number;
+        errorRate: number;
+        avgDuration: number;
+        slowTraces: number;
+        topOperations: Array<{ operation: string; count: number }>;
+    } {
+        const allTraces = Array.from(this.traces.values()).flat();
+        const completedTraces = allTraces.filter(t => t.endTime);
+        const errorTraces = allTraces.filter(t => t.status === 'error');
+
+        const avgDuration = completedTraces.length > 0
+            ? completedTraces.reduce((sum, t) => sum + (t.duration || 0), 0) / completedTraces.length
+            : 0;
+
+        // Count operations
+        const operationCounts = new Map<string, number>();
+        allTraces.forEach(trace => {
+            operationCounts.set(trace.operation, (operationCounts.get(trace.operation) || 0) + 1);
+        });
+
+        const topOperations = Array.from(operationCounts.entries())
+            .map(([operation, count]) => ({ operation, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+
+        return {
+            totalTraces: allTraces.length,
+            activeSpans: this.activeSpans.size,
+            errorRate: completedTraces.length > 0 ? errorTraces.length / completedTraces.length : 0,
+            avgDuration,
+            slowTraces: this.getSlowTraces().length,
+            topOperations,
+        };
+    }
+
+    private generateId(): string {
+        return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    private findTraceId(spanId: string): string {
+        for (const [traceId, spans] of this.traces.entries()) {
+            if (spans.some(s => s.spanId === spanId)) {
+                return traceId;
+            }
+        }
+        return this.generateId();
+    }
+}
+
+export const observabilitySystem = new ObservabilitySystem();

apps/backend/src/mcp/cognitive/PatternEvolutionEngine.ts

@@ -0,0 +1,289 @@
+// PatternEvolutionEngine – Phase 2 Week 7-8
+// Creative strategy evolution with mutation and A/B testing
+
+import { projectMemory } from '../../services/project/ProjectMemory.js';
+import { getDatabase } from '../../database/index.js';
+
+interface Strategy {
+    id: string;
+    name: string;
+    approach: string;
+    timeout: number;
+    retryCount: number;
+    fitnessScore: number;
+    createdAt: Date;
+    adoptedAt?: Date;
+}
+
+interface MutationConfig {
+    mutationRate: number;
+    creativityFactor: number;
+}
+
+interface TestResult {
+    strategy: Strategy;
+    fitnessScore: number;
+    testDuration: number;
+    metrics: {
+        successRate: number;
+        avgLatency: number;
+        userSatisfaction: number;
+    };
+}
+
+export class PatternEvolutionEngine {
+    private strategies: Map<string, Strategy> = new Map();
+    private currentBestStrategy: Strategy | null = null;
+
+    constructor() {
+        this.loadStrategies();
+    }
+
+    /**
+     * Main evolution loop
+     */
+    public async evolveStrategies(): Promise<void> {
+        console.log('🧬 [Evolution] Starting strategy evolution...');
+
+        // 1. Get current best strategy
+        const currentStrategy = await this.getBestStrategy();
+
+        if (!currentStrategy) {
+            // Initialize with default strategy
+            const defaultStrategy = this.createDefaultStrategy();
+            await this.saveStrategy(defaultStrategy);
+            this.currentBestStrategy = defaultStrategy;
+            console.log('✅ [Evolution] Initialized with default strategy');
+            return;
+        }
+
+        // 2. Generate mutations
+        const mutations = this.generateMutations(currentStrategy, {
+            mutationRate: 0.15,
+            creativityFactor: 0.4
+        });
+
+        console.log(`🧬 [Evolution] Generated ${mutations.length} mutations`);
+
+        // 3. A/B test mutations
+        const testResults = await this.abTest(mutations);
+
+        // 4. Select winners (must be >10% improvement)
+        const winners = testResults.filter(r =>
+            r.fitnessScore > currentStrategy.fitnessScore * 1.1
+        );
+
+        // 5. Adopt best winner if improvement found
+        if (winners.length > 0) {
+            const best = winners.sort((a, b) => b.fitnessScore - a.fitnessScore)[0];
+            await this.adoptStrategy(best.strategy);
+
+            // Log to ProjectMemory
+            await this.logEvolution({
+                oldStrategy: currentStrategy,
+                newStrategy: best.strategy,
+                improvement: best.fitnessScore / currentStrategy.fitnessScore,
+                testResults: testResults.length
+            });
+
+            console.log(`✅ [Evolution] Adopted new strategy: ${best.strategy.name} (${((best.fitnessScore / currentStrategy.fitnessScore - 1) * 100).toFixed(1)}% improvement)`);
+        } else {
+            console.log('ℹ️ [Evolution] No improvement found, keeping current strategy');
+        }
+    }
+
+    /**
+     * Get current best strategy
+     */
+    private async getBestStrategy(): Promise<Strategy | null> {
+        if (this.currentBestStrategy) {
+            return this.currentBestStrategy;
+        }
+
+        // Load from database or memory
+        const strategies = Array.from(this.strategies.values());
+        if (strategies.length === 0) {
+            return null;
+        }
+
+        const best = strategies.sort((a, b) => b.fitnessScore - a.fitnessScore)[0];
+        this.currentBestStrategy = best;
+        return best;
+    }
+
+    /**
+     * Generate strategy mutations
+     */
+    private generateMutations(strategy: Strategy, config: MutationConfig): Strategy[] {
+        const mutations: Strategy[] = [];
+
+        for (let i = 0; i < 10; i++) {
+            const mutated: Strategy = {
+                ...strategy,
+                id: `${strategy.id}-mut-${i}-${Date.now()}`,
+                name: `${strategy.name} Mutation ${i + 1}`,
+                fitnessScore: strategy.fitnessScore, // Will be updated after testing
+                createdAt: new Date()
+            };
+
+            // Mutate timeout
+            if (Math.random() < config.mutationRate) {
+                mutated.timeout = Math.max(100, strategy.timeout * (1 + (Math.random() - 0.5) * 0.3));
+            }
+
+            // Mutate retry count
+            if (Math.random() < config.mutationRate) {
+                mutated.retryCount = Math.max(0, strategy.retryCount + Math.floor((Math.random() - 0.5) * 2));
+            }
+
+            // Creative mutations (approach changes)
+            if (Math.random() < config.creativityFactor) {
+                mutated.approach = this.generateCreativeApproach(strategy.approach);
+            }
+
+            mutations.push(mutated);
+        }
+
+        return mutations;
+    }
+
+    /**
+     * Generate creative approach variations
+     */
+    private generateCreativeApproach(currentApproach: string): string {
+        const variations = [
+            'aggressive', 'conservative', 'balanced', 'adaptive', 'predictive'
+        ];
+        
+        const randomVariation = variations[Math.floor(Math.random() * variations.length)];
+        return `${randomVariation}_${currentApproach}`;
+    }
+
+    /**
+     * A/B test mutations
+     */
+    private async abTest(mutations: Strategy[]): Promise<TestResult[]> {
+        const results: TestResult[] = [];
+
+        for (const mutation of mutations) {
+            // Simulate testing (in real implementation, this would run actual tests)
+            const testResult = await this.simulateTest(mutation);
+            results.push(testResult);
+        }
+
+        return results;
+    }
+
+    /**
+     * Simulate strategy test (placeholder - should run actual tests)
+     */
+    private async simulateTest(strategy: Strategy): Promise<TestResult> {
+        // Simulate fitness calculation based on strategy parameters
+        const baseFitness = 0.5;
+        
+        // Timeout optimization: shorter is better (up to a point)
+        const timeoutScore = Math.max(0, 1 - (strategy.timeout / 5000));
+        
+        // Retry optimization: balanced retries are better
+        const retryScore = strategy.retryCount <= 3 ? 1.0 : Math.max(0, 1 - (strategy.retryCount - 3) * 0.2);
+        
+        // Approach bonus (creative approaches get slight bonus)
+        const approachBonus = strategy.approach.includes('adaptive') || strategy.approach.includes('predictive') ? 0.1 : 0;
+        
+        const fitnessScore = baseFitness + timeoutScore * 0.3 + retryScore * 0.2 + approachBonus;
+
+        return {
+            strategy,
+            fitnessScore: Math.min(1.0, fitnessScore),
+            testDuration: 1000 + Math.random() * 2000,
+            metrics: {
+                successRate: 0.7 + Math.random() * 0.25,
+                avgLatency: strategy.timeout * (0.8 + Math.random() * 0.4),
+                userSatisfaction: fitnessScore
+            }
+        };
+    }
+
+    /**
+     * Adopt new strategy
+     */
+    private async adoptStrategy(strategy: Strategy): Promise<void> {
+        strategy.adoptedAt = new Date();
+        await this.saveStrategy(strategy);
+        this.currentBestStrategy = strategy;
+        this.strategies.set(strategy.id, strategy);
+    }
+
+    /**
+     * Create default strategy
+     */
+    private createDefaultStrategy(): Strategy {
+        return {
+            id: 'default-strategy',
+            name: 'Default Strategy',
+            approach: 'balanced',
+            timeout: 3000,
+            retryCount: 2,
+            fitnessScore: 0.5,
+            createdAt: new Date()
+        };
+    }
+
+    /**
+     * Save strategy (placeholder - should persist to database)
+     */
+    private async saveStrategy(strategy: Strategy): Promise<void> {
+        this.strategies.set(strategy.id, strategy);
+        // TODO: Persist to database
+    }
+
+    /**
+     * Load strategies (placeholder)
+     */
+    private loadStrategies(): void {
+        // TODO: Load from database
+    }
+
+    /**
+     * Log evolution to ProjectMemory
+     */
+    private async logEvolution(evolution: {
+        oldStrategy: Strategy;
+        newStrategy: Strategy;
+        improvement: number;
+        testResults: number;
+    }): Promise<void> {
+        projectMemory.logLifecycleEvent({
+            eventType: 'feature',
+            status: 'success',
+            details: {
+                component: 'PatternEvolutionEngine',
+                action: 'strategy_evolution',
+                oldStrategy: evolution.oldStrategy.name,
+                newStrategy: evolution.newStrategy.name,
+                improvement: `${((evolution.improvement - 1) * 100).toFixed(1)}%`,
+                testResults: evolution.testResults,
+                timestamp: new Date().toISOString()
+            }
+        });
+    }
+
+    /**
+     * Get current strategy
+     */
+    public getCurrentStrategy(): Strategy | null {
+        return this.currentBestStrategy;
+    }
+
+    /**
+     * Get evolution history
+     */
+    public getEvolutionHistory(): Strategy[] {
+        return Array.from(this.strategies.values())
+            .filter(s => s.adoptedAt)
+            .sort((a, b) => (b.adoptedAt?.getTime() || 0) - (a.adoptedAt?.getTime() || 0));
+    }
+}
+
+export const patternEvolutionEngine = new PatternEvolutionEngine();
+

apps/backend/src/mcp/cognitive/RLHFAlignmentSystem.ts

@@ -0,0 +1,262 @@
+/**
+ * RLHF (Reinforcement Learning from Human Feedback) Alignment System
+ * Aligns AI behavior with human preferences through feedback
+ */
+
+export interface HumanFeedback {
+    id: string;
+    taskId: string;
+    agentId: string;
+    rating: number; // 1-5
+    feedback: string;
+    timestamp: Date;
+    category: 'helpful' | 'harmless' | 'honest';
+}
+
+export interface PreferenceComparison {
+    id: string;
+    responseA: string;
+    responseB: string;
+    preferred: 'A' | 'B' | 'equal';
+    reason?: string;
+    timestamp: Date;
+}
+
+export interface RewardModel {
+    weights: Map<string, number>;
+    bias: number;
+    accuracy: number;
+}
+
+export class RLHFAlignmentSystem {
+    private feedbackLog: HumanFeedback[] = [];
+    private preferences: PreferenceComparison[] = [];
+    private rewardModel: RewardModel = {
+        weights: new Map(),
+        bias: 0,
+        accuracy: 0,
+    };
+
+    /**
+     * Collect human feedback
+     */
+    collectFeedback(feedback: Omit<HumanFeedback, 'id' | 'timestamp'>): string {
+        const fullFeedback: HumanFeedback = {
+            ...feedback,
+            id: `feedback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date(),
+        };
+
+        this.feedbackLog.push(fullFeedback);
+
+        // Keep only last 1000 feedbacks
+        if (this.feedbackLog.length > 1000) {
+            this.feedbackLog.shift();
+        }
+
+        return fullFeedback.id;
+    }
+
+    /**
+     * Collect preference comparison
+     */
+    collectPreference(comparison: Omit<PreferenceComparison, 'id' | 'timestamp'>): string {
+        const fullComparison: PreferenceComparison = {
+            ...comparison,
+            id: `pref_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date(),
+        };
+
+        this.preferences.push(fullComparison);
+
+        // Retrain reward model periodically
+        if (this.preferences.length % 10 === 0) {
+            this.trainRewardModel();
+        }
+
+        return fullComparison.id;
+    }
+
+    /**
+     * Train reward model from preferences
+     */
+    private trainRewardModel(): void {
+        if (this.preferences.length < 10) return;
+
+        // Simple reward model training
+        // In production, this would use proper ML techniques
+
+        const features = new Map<string, number>();
+
+        this.preferences.forEach(pref => {
+            const preferred = pref.preferred === 'A' ? pref.responseA : pref.responseB;
+            const notPreferred = pref.preferred === 'A' ? pref.responseB : pref.responseA;
+
+            // Extract simple features (length, politeness markers, etc.)
+            const prefLength = preferred.length;
+            const notPrefLength = notPreferred.length;
+
+            features.set('length_preference', (features.get('length_preference') || 0) +
+                (prefLength > notPrefLength ? 1 : -1));
+
+            // Check for politeness markers
+            const politeWords = ['please', 'thank', 'appreciate', 'kindly'];
+            const prefPolite = politeWords.some(word => preferred.toLowerCase().includes(word));
+            const notPrefPolite = politeWords.some(word => notPreferred.toLowerCase().includes(word));
+
+            if (prefPolite && !notPrefPolite) {
+                features.set('politeness', (features.get('politeness') || 0) + 1);
+            }
+        });
+
+        // Update reward model weights
+        features.forEach((value, feature) => {
+            this.rewardModel.weights.set(feature, value / this.preferences.length);
+        });
+
+        console.log(`🎯 Reward model updated with ${this.preferences.length} preferences`);
+    }
+
+    /**
+     * Predict reward for a response
+     */
+    predictReward(response: string): number {
+        let reward = this.rewardModel.bias;
+
+        // Apply learned weights
+        const length = response.length;
+        reward += (this.rewardModel.weights.get('length_preference') || 0) * length / 1000;
+
+        const politeWords = ['please', 'thank', 'appreciate', 'kindly'];
+        const isPolite = politeWords.some(word => response.toLowerCase().includes(word));
+        if (isPolite) {
+            reward += this.rewardModel.weights.get('politeness') || 0;
+        }
+
+        return reward;
+    }
+
+    /**
+     * Optimize response based on learned preferences
+     */
+    optimizeResponse(candidates: string[]): string {
+        if (candidates.length === 0) return '';
+        if (candidates.length === 1) return candidates[0];
+
+        // Score each candidate
+        const scored = candidates.map(candidate => ({
+            response: candidate,
+            reward: this.predictReward(candidate),
+        }));
+
+        // Return highest scoring
+        scored.sort((a, b) => b.reward - a.reward);
+        return scored[0].response;
+    }
+
+    /**
+     * Check alignment with safety constraints
+     */
+    checkSafetyConstraints(response: string): {
+        safe: boolean;
+        violations: string[];
+    } {
+        const violations: string[] = [];
+
+        // Check for harmful content patterns
+        const harmfulPatterns = [
+            /\b(hack|exploit|bypass)\b/i,
+            /\b(illegal|unlawful)\b/i,
+            /\b(violence|harm|hurt)\b/i,
+        ];
+
+        harmfulPatterns.forEach((pattern, index) => {
+            if (pattern.test(response)) {
+                violations.push(`Potential harmful content detected (pattern ${index + 1})`);
+            }
+        });
+
+        // Check for dishonest patterns
+        if (response.includes('I am certain') && response.includes('probably')) {
+            violations.push('Contradictory certainty claims');
+        }
+
+        return {
+            safe: violations.length === 0,
+            violations,
+        };
+    }
+
+    /**
+     * Get feedback statistics
+     */
+    getFeedbackStatistics(agentId?: string): {
+        totalFeedback: number;
+        avgRating: number;
+        categoryBreakdown: Record<string, number>;
+        recentTrend: 'improving' | 'declining' | 'stable';
+    } {
+        const relevant = agentId
+            ? this.feedbackLog.filter(f => f.agentId === agentId)
+            : this.feedbackLog;
+
+        const avgRating = relevant.length > 0
+            ? relevant.reduce((sum, f) => sum + f.rating, 0) / relevant.length
+            : 0;
+
+        const categoryBreakdown = relevant.reduce((acc, f) => {
+            acc[f.category] = (acc[f.category] || 0) + 1;
+            return acc;
+        }, {} as Record<string, number>);
+
+        // Analyze trend (last 20 vs previous 20)
+        const recent = relevant.slice(-20);
+        const previous = relevant.slice(-40, -20);
+
+        const recentAvg = recent.length > 0
+            ? recent.reduce((sum, f) => sum + f.rating, 0) / recent.length
+            : 0;
+        const previousAvg = previous.length > 0
+            ? previous.reduce((sum, f) => sum + f.rating, 0) / previous.length
+            : 0;
+
+        let trend: 'improving' | 'declining' | 'stable' = 'stable';
+        if (recentAvg > previousAvg + 0.2) trend = 'improving';
+        else if (recentAvg < previousAvg - 0.2) trend = 'declining';
+
+        return {
+            totalFeedback: relevant.length,
+            avgRating,
+            categoryBreakdown,
+            recentTrend: trend,
+        };
+    }
+
+    /**
+     * Apply alignment corrections
+     */
+    async applyAlignmentCorrections(agentId: string): Promise<string[]> {
+        const stats = this.getFeedbackStatistics(agentId);
+        const corrections: string[] = [];
+
+        if (stats.avgRating < 3) {
+            corrections.push('Overall performance below acceptable threshold');
+        }
+
+        if (stats.categoryBreakdown.harmless && stats.categoryBreakdown.harmless < stats.totalFeedback * 0.8) {
+            corrections.push('Increase safety measures');
+        }
+
+        if (stats.categoryBreakdown.honest && stats.categoryBreakdown.honest < stats.totalFeedback * 0.8) {
+            corrections.push('Improve honesty and transparency');
+        }
+
+        if (stats.recentTrend === 'declining') {
+            corrections.push('Performance declining - review recent changes');
+        }
+
+        return corrections;
+    }
+}
+
+export const rlhfAlignmentSystem = new RLHFAlignmentSystem();

apps/backend/src/mcp/cognitive/SelfReflectionEngine.ts

@@ -0,0 +1,205 @@
+import { neo4jService } from '../../database/Neo4jService';
+
+/**
+ * Self-Reflection Engine
+ * Enables agents to assess their own performance and improve
+ */
+
+export interface PerformanceMetrics {
+    taskId: string;
+    agentId: string;
+    success: boolean;
+    duration: number;
+    errorType?: string;
+    timestamp: Date;
+    context: Record<string, any>;
+}
+
+export interface ReflectionInsight {
+    pattern: string;
+    frequency: number;
+    impact: 'positive' | 'negative' | 'neutral';
+    recommendation: string;
+    confidence: number;
+}
+
+export class SelfReflectionEngine {
+    private performanceLog: PerformanceMetrics[] = [];
+    private insights: ReflectionInsight[] = [];
+
+    /**
+     * Log performance data
+     */
+    logPerformance(metrics: PerformanceMetrics): void {
+        this.performanceLog.push(metrics);
+
+        // Keep only last 1000 entries
+        if (this.performanceLog.length > 1000) {
+            this.performanceLog.shift();
+        }
+    }
+
+    /**
+     * Analyze error patterns
+     */
+    analyzeErrorPatterns(agentId?: string): Map<string, number> {
+        const errors = this.performanceLog.filter(log =>
+            !log.success && (!agentId || log.agentId === agentId)
+        );
+
+        const errorCounts = new Map<string, number>();
+        errors.forEach(error => {
+            if (error.errorType) {
+                errorCounts.set(error.errorType, (errorCounts.get(error.errorType) || 0) + 1);
+            }
+        });
+
+        return errorCounts;
+    }
+
+    /**
+     * Evaluate strategy effectiveness
+     */
+    evaluateStrategyEffectiveness(
+        strategy: string,
+        timeWindow: number = 7 * 24 * 60 * 60 * 1000 // 7 days
+    ): {
+        successRate: number;
+        avgDuration: number;
+        totalAttempts: number;
+    } {
+        const cutoff = new Date(Date.now() - timeWindow);
+        const relevant = this.performanceLog.filter(log =>
+            log.timestamp > cutoff &&
+            log.context.strategy === strategy
+        );
+
+        if (relevant.length === 0) {
+            return { successRate: 0, avgDuration: 0, totalAttempts: 0 };
+        }
+
+        const successes = relevant.filter(log => log.success).length;
+        const totalDuration = relevant.reduce((sum, log) => sum + log.duration, 0);
+
+        return {
+            successRate: successes / relevant.length,
+            avgDuration: totalDuration / relevant.length,
+            totalAttempts: relevant.length,
+        };
+    }
+
+    /**
+     * Generate improvement recommendations
+     */
+    async generateRecommendations(agentId: string): Promise<ReflectionInsight[]> {
+        const errorPatterns = this.analyzeErrorPatterns(agentId);
+        const recommendations: ReflectionInsight[] = [];
+
+        // Analyze error patterns
+        errorPatterns.forEach((count, errorType) => {
+            if (count > 5) {
+                recommendations.push({
+                    pattern: `Frequent ${errorType} errors`,
+                    frequency: count,
+                    impact: 'negative',
+                    recommendation: `Implement better error handling for ${errorType}`,
+                    confidence: Math.min(count / 10, 1),
+                });
+            }
+        });
+
+        // Analyze performance trends
+        const recentPerformance = this.performanceLog
+            .filter(log => log.agentId === agentId)
+            .slice(-50);
+
+        if (recentPerformance.length > 10) {
+            const successRate = recentPerformance.filter(log => log.success).length / recentPerformance.length;
+
+            if (successRate < 0.7) {
+                recommendations.push({
+                    pattern: 'Low success rate',
+                    frequency: recentPerformance.length,
+                    impact: 'negative',
+                    recommendation: 'Review task assignment criteria and agent capabilities',
+                    confidence: 1 - successRate,
+                });
+            } else if (successRate > 0.95) {
+                recommendations.push({
+                    pattern: 'High success rate',
+                    frequency: recentPerformance.length,
+                    impact: 'positive',
+                    recommendation: 'Consider taking on more complex tasks',
+                    confidence: successRate,
+                });
+            }
+        }
+
+        this.insights = recommendations;
+        return recommendations;
+    }
+
+    /**
+     * Continuous improvement loop
+     */
+    async runImprovementCycle(agentId: string): Promise<void> {
+        const recommendations = await this.generateRecommendations(agentId);
+
+        // Store insights in Neo4j for long-term learning
+        try {
+            await neo4jService.connect();
+
+            for (const insight of recommendations) {
+                await neo4jService.runQuery(
+                    `MERGE (a:Agent {id: $agentId})
+           CREATE (i:Insight {
+             pattern: $pattern,
+             recommendation: $recommendation,
+             confidence: $confidence,
+             timestamp: datetime()
+           })
+           CREATE (a)-[:HAS_INSIGHT]->(i)`,
+                    {
+                        agentId,
+                        pattern: insight.pattern,
+                        recommendation: insight.recommendation,
+                        confidence: insight.confidence,
+                    }
+                );
+            }
+
+            await neo4jService.disconnect();
+        } catch (error) {
+            console.error('Failed to store insights:', error);
+        }
+
+        console.log(`🔍 Generated ${recommendations.length} improvement recommendations for ${agentId}`);
+    }
+
+    /**
+     * Get performance summary
+     */
+    getPerformanceSummary(agentId: string, days: number = 7): {
+        totalTasks: number;
+        successRate: number;
+        avgDuration: number;
+        errorBreakdown: Map<string, number>;
+    } {
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const relevant = this.performanceLog.filter(log =>
+            log.agentId === agentId && log.timestamp > cutoff
+        );
+
+        const successes = relevant.filter(log => log.success).length;
+        const totalDuration = relevant.reduce((sum, log) => sum + log.duration, 0);
+
+        return {
+            totalTasks: relevant.length,
+            successRate: relevant.length > 0 ? successes / relevant.length : 0,
+            avgDuration: relevant.length > 0 ? totalDuration / relevant.length : 0,
+            errorBreakdown: this.analyzeErrorPatterns(agentId),
+        };
+    }
+}
+
+export const selfReflectionEngine = new SelfReflectionEngine();

apps/backend/src/mcp/cognitive/StateGraphRouter.ts

@@ -0,0 +1,248 @@
+
+import { UnifiedGraphRAG, unifiedGraphRAG } from './UnifiedGraphRAG.js';
+import { UnifiedMemorySystem, unifiedMemorySystem } from './UnifiedMemorySystem.js';
+
+export type AgentNodeType = 'router' | 'planner' | 'researcher' | 'coder' | 'reviewer' | 'end';
+
+export interface AgentState {
+    id: string;
+    messages: { role: string; content: string }[];
+    context: any;
+    currentNode: AgentNodeType;
+    history: AgentNodeType[];
+    scratchpad: any; // Shared working memory for agents
+    status: 'active' | 'completed' | 'failed' | 'waiting';
+}
+
+interface Checkpoint {
+    id: string;
+    state: AgentState;
+    timestamp: Date;
+    metadata?: any;
+}
+
+export class StateGraphRouter {
+    private graphRag: UnifiedGraphRAG;
+    private memory: UnifiedMemorySystem;
+    private checkpoints: Map<string, Checkpoint> = new Map();
+
+    constructor() {
+        this.graphRag = unifiedGraphRAG;
+        this.memory = unifiedMemorySystem;
+    }
+
+    /**
+     * Initialize a new state for a task
+     */
+    public initState(taskId: string, initialInput: string): AgentState {
+        return {
+            id: taskId,
+            messages: [{ role: 'user', content: initialInput }],
+            context: {},
+            currentNode: 'router',
+            history: [],
+            scratchpad: {},
+            status: 'active'
+        };
+    }
+
+    /**
+     * Save checkpoint for time-travel debugging
+     */
+    private saveCheckpoint(state: AgentState, metadata?: any): string {
+        const checkpointId = `${state.id}-${Date.now()}`;
+        this.checkpoints.set(checkpointId, {
+            id: checkpointId,
+            state: JSON.parse(JSON.stringify(state)), // Deep clone
+            timestamp: new Date(),
+            metadata
+        });
+        
+        // Keep only last 50 checkpoints per task
+        const taskCheckpoints = Array.from(this.checkpoints.entries())
+            .filter(([_, cp]) => cp.state.id === state.id)
+            .sort((a, b) => b[1].timestamp.getTime() - a[1].timestamp.getTime())
+            .slice(50);
+        
+        this.checkpoints.clear();
+        taskCheckpoints.forEach(([id, cp]) => this.checkpoints.set(id, cp));
+        
+        return checkpointId;
+    }
+
+    /**
+     * Time-travel: restore to previous checkpoint
+     */
+    public async timeTravel(checkpointId: string): Promise<AgentState | null> {
+        const checkpoint = this.checkpoints.get(checkpointId);
+        if (!checkpoint) {
+            return null;
+        }
+        
+        console.log(`⏪ [StateGraph] Time-traveling to checkpoint: ${checkpointId}`);
+        return JSON.parse(JSON.stringify(checkpoint.state)); // Deep clone
+    }
+
+    /**
+     * Get all checkpoints for a task
+     */
+    public getCheckpoints(taskId: string): Checkpoint[] {
+        return Array.from(this.checkpoints.values())
+            .filter(cp => cp.state.id === taskId)
+            .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    }
+
+    /**
+     * Route the state to the next node
+     */
+    public async route(state: AgentState): Promise<AgentState> {
+        console.log(`🔄 [StateGraph] Routing from ${state.currentNode}...`);
+        
+        // Save checkpoint before routing
+        this.saveCheckpoint(state, { action: 'before_routing', node: state.currentNode });
+        
+        // Update history
+        if (state.history[state.history.length - 1] !== state.currentNode) {
+            state.history.push(state.currentNode);
+        }
+
+        let newState: AgentState;
+        
+        switch (state.currentNode) {
+            case 'router':
+                newState = await this.handleRouterNode(state);
+                break;
+            
+            case 'planner':
+                newState = await this.handlePlannerNode(state);
+                break;
+
+            case 'researcher':
+                newState = await this.handleResearcherNode(state);
+                break;
+
+            case 'reviewer':
+                newState = await this.handleReviewerNode(state);
+                break;
+
+            case 'end':
+                newState = state;
+                break;
+
+            default:
+                console.error(`Unknown node: ${state.currentNode}`);
+                state.status = 'failed';
+                newState = state;
+        }
+        
+        // Save checkpoint after routing
+        this.saveCheckpoint(newState, { action: 'after_routing', node: newState.currentNode });
+        
+        return newState;
+    }
+
+    /**
+     * Router Logic: Decides the initial path based on query complexity
+     */
+    private async handleRouterNode(state: AgentState): Promise<AgentState> {
+        const lastMessage = state.messages[state.messages.length - 1].content;
+
+        // 1. Use GraphRAG to understand context
+        const ragResult = await this.graphRag.query(lastMessage, { 
+            userId: 'system', 
+            orgId: 'default' 
+        });
+
+        state.context.ragReasoning = ragResult;
+
+        // 2. Heuristic routing (Will be replaced by LLM classifier later)
+        if (ragResult.confidence < 0.3 || lastMessage.length > 100) {
+            // Low confidence or complex query -> Needs Planning
+            console.log('  -> Routing to Planner (Complex/Unknown)');
+            state.currentNode = 'planner';
+        } else {
+            // High confidence -> Direct Research or Execution (Simplified)
+            console.log('  -> Routing to Researcher (Simple)');
+            state.currentNode = 'researcher';
+        }
+
+        return state;
+    }
+
+    /**
+     * Planner Node: Break down complex tasks
+     */
+    private async handlePlannerNode(state: AgentState): Promise<AgentState> {
+        console.log('  -> Planner: Analyzing task...');
+        
+        const lastMessage = state.messages[state.messages.length - 1].content;
+        
+        // Use GraphRAG to understand context and dependencies
+        const ragResult = await this.graphRag.query(`Plan: ${lastMessage}`, {
+            userId: 'system',
+            orgId: 'default'
+        });
+        
+        // Simple planning logic (can be enhanced with LLM)
+        const plan = [
+            `Step 1: Analyze requirements (confidence: ${ragResult.confidence.toFixed(2)})`,
+            `Step 2: Identify dependencies (${ragResult.nodes.length} related concepts found)`,
+            'Step 3: Execute plan',
+            'Step 4: Review results'
+        ];
+        
+        state.scratchpad.plan = plan;
+        state.scratchpad.ragContext = ragResult;
+        state.currentNode = 'researcher';
+        
+        return state;
+    }
+
+    /**
+     * Researcher Node: Gather information
+     */
+    private async handleResearcherNode(state: AgentState): Promise<AgentState> {
+        console.log('  -> Researcher: Gathering information...');
+        
+        const lastMessage = state.messages[state.messages.length - 1].content;
+        
+        // Use UnifiedMemorySystem to search for relevant information
+        const searchResults = await this.memory.getWorkingMemory({
+            userId: 'system',
+            orgId: 'default'
+        });
+        
+        state.scratchpad.research = {
+            query: lastMessage,
+            foundContext: searchResults.recentEvents?.slice(0, 5) || [],
+            foundFeatures: searchResults.recentFeatures?.slice(0, 3) || []
+        };
+        
+        state.currentNode = 'reviewer';
+        return state;
+    }
+
+    /**
+     * Reviewer Node: Validate and finalize
+     */
+    private async handleReviewerNode(state: AgentState): Promise<AgentState> {
+        console.log('  -> Reviewer: Validating results...');
+        
+        // Simple validation (can be enhanced)
+        const hasPlan = state.scratchpad.plan && state.scratchpad.plan.length > 0;
+        const hasResearch = state.scratchpad.research;
+        
+        if (hasPlan && hasResearch) {
+            state.status = 'completed';
+            state.currentNode = 'end';
+        } else {
+            // If missing info, go back to researcher
+            state.currentNode = 'researcher';
+        }
+        
+        return state;
+    }
+}
+
+export const stateGraphRouter = new StateGraphRouter();
+

apps/backend/src/mcp/cognitive/TaskRecorder.ts

@@ -0,0 +1,648 @@
+/**
+ * TaskRecorder - Observes, learns, and suggests automation
+ * 
+ * CRITICAL RULE: Agents NEVER commit real tasks without user approval
+ * 
+ * Features:
+ * - Observes all tasks performed by users/agents
+ * - Learns patterns from repeated tasks
+ * - Suggests automation after observing N times
+ * - Requires explicit user approval before automation
+ * - Never auto-executes real tasks
+ */
+
+import { unifiedMemorySystem } from './UnifiedMemorySystem.js';
+import { projectMemory } from '../../services/project/ProjectMemory.js';
+import { eventBus } from '../EventBus.js';
+import { getDatabase } from '../../database/index.js';
+import { v4 as uuidv4 } from 'uuid';
+
+export interface TaskObservation {
+    id: string;
+    taskType: string;
+    taskSignature: string; // Hash of task parameters
+    userId: string;
+    orgId: string;
+    timestamp: Date;
+    duration?: number;
+    success: boolean;
+    result?: any;
+    context?: Record<string, any>;
+    params?: any;
+}
+
+export interface TaskPattern {
+    taskSignature: string;
+    taskType: string;
+    frequency: number;
+    firstSeen: Date;
+    lastSeen: Date;
+    successRate: number;
+    averageDuration?: number;
+    contexts: Record<string, number>; // Context patterns
+    suggestedAutomation?: AutomationSuggestion;
+}
+
+export interface AutomationSuggestion {
+    id: string;
+    taskSignature: string;
+    taskType: string;
+    confidence: number; // 0-1, based on pattern strength
+    observedCount: number; // How many times observed
+    suggestedAction: string; // Description of what would be automated
+    requiresApproval: boolean; // Always true for real tasks
+    estimatedBenefit: string; // Time saved, etc.
+    createdAt: Date;
+    status: 'pending' | 'approved' | 'rejected' | 'active';
+    approvedBy?: string;
+    approvedAt?: Date;
+}
+
+export interface TaskExecutionRequest {
+    suggestionId: string;
+    taskSignature: string;
+    taskType: string;
+    params: any;
+    requestedBy: string;
+    requiresApproval: boolean; // Always true for real tasks
+}
+
+export class TaskRecorder {
+    private observations: Map<string, TaskObservation[]> = new Map(); // signature -> observations
+    private patterns: Map<string, TaskPattern> = new Map(); // signature -> pattern
+    private suggestions: Map<string, AutomationSuggestion> = new Map(); // suggestionId -> suggestion
+    private readonly MIN_OBSERVATIONS_FOR_SUGGESTION = 3; // Suggest after 3 observations
+    private readonly MIN_CONFIDENCE_FOR_SUGGESTION = 0.7; // 70% success rate minimum
+    private db: any;
+
+    constructor() {
+        this.db = getDatabase();
+        this.initializeDatabase();
+        this.setupEventListeners();
+    }
+
+    /**
+     * Initialize database tables for task recording
+     */
+    private initializeDatabase(): void {
+        try {
+            // Create task_observations table
+            this.db.run(`
+                CREATE TABLE IF NOT EXISTS task_observations (
+                    id TEXT PRIMARY KEY,
+                    task_type TEXT NOT NULL,
+                    task_signature TEXT NOT NULL,
+                    user_id TEXT NOT NULL,
+                    org_id TEXT NOT NULL,
+                    timestamp TEXT NOT NULL,
+                    duration INTEGER,
+                    success INTEGER NOT NULL,
+                    result TEXT,
+                    context TEXT,
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+                )
+            `);
+
+            // Create task_patterns table
+            this.db.run(`
+                CREATE TABLE IF NOT EXISTS task_patterns (
+                    task_signature TEXT PRIMARY KEY,
+                    task_type TEXT NOT NULL,
+                    frequency INTEGER NOT NULL DEFAULT 1,
+                    first_seen TEXT NOT NULL,
+                    last_seen TEXT NOT NULL,
+                    success_rate REAL NOT NULL,
+                    average_duration REAL,
+                    contexts TEXT,
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+                )
+            `);
+
+            // Create automation_suggestions table
+            this.db.run(`
+                CREATE TABLE IF NOT EXISTS automation_suggestions (
+                    id TEXT PRIMARY KEY,
+                    task_signature TEXT NOT NULL,
+                    task_type TEXT NOT NULL,
+                    confidence REAL NOT NULL,
+                    observed_count INTEGER NOT NULL,
+                    suggested_action TEXT NOT NULL,
+                    requires_approval INTEGER NOT NULL DEFAULT 1,
+                    estimated_benefit TEXT,
+                    status TEXT NOT NULL DEFAULT 'pending',
+                    approved_by TEXT,
+                    approved_at TEXT,
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (task_signature) REFERENCES task_patterns(task_signature)
+                )
+            `);
+
+            // Create task_executions table (for approved automations)
+            this.db.run(`
+                CREATE TABLE IF NOT EXISTS task_executions (
+                    id TEXT PRIMARY KEY,
+                    suggestion_id TEXT,
+                    task_signature TEXT NOT NULL,
+                    task_type TEXT NOT NULL,
+                    params TEXT NOT NULL,
+                    requested_by TEXT NOT NULL,
+                    approved_by TEXT NOT NULL,
+                    executed_at TEXT NOT NULL,
+                    success INTEGER,
+                    result TEXT,
+                    FOREIGN KEY (suggestion_id) REFERENCES automation_suggestions(id)
+                )
+            `);
+
+            console.log('✅ TaskRecorder database initialized');
+        } catch (error) {
+            console.error('❌ Failed to initialize TaskRecorder database:', error);
+        }
+    }
+
+    /**
+     * Setup event listeners for task observation
+     */
+    private setupEventListeners(): void {
+        // Listen for MCP tool executions
+        eventBus.onEvent('mcp.tool.executed', async (event: any) => {
+            await this.observeTask({
+                taskType: event.tool || 'unknown',
+                taskSignature: this.generateSignature(event.tool, event.payload),
+                userId: event.userId || 'system',
+                orgId: event.orgId || 'default',
+                timestamp: new Date(),
+                success: event.success !== false,
+                result: event.result,
+                context: {
+                    source: 'mcp_tool',
+                    tool: event.tool,
+                    payload: event.payload
+                }
+            });
+        });
+
+        // Listen for autonomous agent tasks
+        eventBus.onEvent('autonomous.task.executed', async (event: any) => {
+            await this.observeTask({
+                taskType: event.taskType || 'autonomous_task',
+                taskSignature: this.generateSignature(event.taskType, event.payload),
+                userId: event.userId || 'system',
+                orgId: event.orgId || 'default',
+                timestamp: new Date(),
+                success: event.success !== false,
+                result: event.result,
+                context: {
+                    source: 'autonomous_agent',
+                    taskType: event.taskType
+                }
+            });
+        });
+
+        console.log('👁️ TaskRecorder event listeners setup complete');
+    }
+
+    /**
+     * Observe a task execution
+     */
+    async observeTask(observation: Omit<TaskObservation, 'id'>): Promise<void> {
+        const id = `obs-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const fullObservation: TaskObservation = { ...observation, id };
+
+        // Store in memory
+        const signature = observation.taskSignature;
+        if (!this.observations.has(signature)) {
+            this.observations.set(signature, []);
+        }
+        this.observations.get(signature)!.push(fullObservation);
+
+        // Persist to database
+        try {
+            this.db.run(`
+                INSERT INTO task_observations 
+                (id, task_type, task_signature, user_id, org_id, timestamp, duration, success, result, context)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `, [
+                id,
+                observation.taskType,
+                signature,
+                observation.userId,
+                observation.orgId,
+                observation.timestamp.toISOString(),
+                observation.duration || null,
+                observation.success ? 1 : 0,
+                observation.result ? JSON.stringify(observation.result) : null,
+                observation.context ? JSON.stringify(observation.context) : null
+            ]);
+        } catch (error) {
+            console.error('Failed to persist task observation:', error);
+        }
+
+        // Update pattern
+        await this.updatePattern(fullObservation);
+
+        // Check if we should suggest automation
+        await this.checkAndSuggestAutomation(signature);
+
+        console.log(`👁️ [TaskRecorder] Observed: ${observation.taskType} (${signature.substring(0, 8)}...)`);
+    }
+
+    /**
+     * Update pattern from observation
+     */
+    private async updatePattern(observation: TaskObservation): Promise<void> {
+        const signature = observation.taskSignature;
+        const existing = this.patterns.get(signature);
+
+        if (existing) {
+            // Update existing pattern
+            existing.frequency += 1;
+            existing.lastSeen = observation.timestamp;
+            existing.successRate = this.calculateSuccessRate(signature);
+            existing.averageDuration = this.calculateAverageDuration(signature);
+
+            // Update context patterns
+            if (observation.context) {
+                for (const [key, value] of Object.entries(observation.context)) {
+                    const contextKey = `${key}:${value}`;
+                    existing.contexts[contextKey] = (existing.contexts[contextKey] || 0) + 1;
+                }
+            }
+
+            // Update database
+            try {
+                this.db.run(`
+                    UPDATE task_patterns
+                    SET frequency = ?,
+                        last_seen = ?,
+                        success_rate = ?,
+                        average_duration = ?,
+                        contexts = ?,
+                        updated_at = CURRENT_TIMESTAMP
+                    WHERE task_signature = ?
+                `, [
+                    existing.frequency,
+                    existing.lastSeen.toISOString(),
+                    existing.successRate,
+                    existing.averageDuration || null,
+                    JSON.stringify(existing.contexts),
+                    signature
+                ]);
+            } catch (error) {
+                console.error('Failed to update pattern:', error);
+            }
+        } else {
+            // Create new pattern
+            const pattern: TaskPattern = {
+                taskSignature: signature,
+                taskType: observation.taskType,
+                frequency: 1,
+                firstSeen: observation.timestamp,
+                lastSeen: observation.timestamp,
+                successRate: observation.success ? 1.0 : 0.0,
+                averageDuration: observation.duration,
+                contexts: observation.context ?
+                    Object.fromEntries(Object.entries(observation.context).map(([k, v]) => [`${k}:${v}`, 1])) :
+                    {}
+            };
+
+            this.patterns.set(signature, pattern);
+
+            // Insert into database
+            try {
+                this.db.run(`
+                    INSERT INTO task_patterns
+                    (task_signature, task_type, frequency, first_seen, last_seen, success_rate, average_duration, contexts)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                `, [
+                    signature,
+                    pattern.taskType,
+                    pattern.frequency,
+                    pattern.firstSeen.toISOString(),
+                    pattern.lastSeen.toISOString(),
+                    pattern.successRate,
+                    pattern.averageDuration || null,
+                    JSON.stringify(pattern.contexts)
+                ]);
+            } catch (error) {
+                console.error('Failed to insert pattern:', error);
+            }
+        }
+    }
+
+    /**
+     * Check if automation should be suggested
+     */
+    private async checkAndSuggestAutomation(signature: string): Promise<void> {
+        const pattern = this.patterns.get(signature);
+        if (!pattern) return;
+
+        // Check if we've observed enough times
+        if (pattern.frequency < this.MIN_OBSERVATIONS_FOR_SUGGESTION) {
+            return;
+        }
+
+        // Check if success rate is high enough
+        if (pattern.successRate < this.MIN_CONFIDENCE_FOR_SUGGESTION) {
+            return;
+        }
+
+        // Check if suggestion already exists
+        const existingSuggestion = Array.from(this.suggestions.values())
+            .find(s => s.taskSignature === signature && s.status === 'pending');
+        if (existingSuggestion) {
+            return; // Already suggested
+        }
+
+        // Create automation suggestion
+        const suggestion: AutomationSuggestion = {
+            id: `sug-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            taskSignature: signature,
+            taskType: pattern.taskType,
+            confidence: pattern.successRate,
+            observedCount: pattern.frequency,
+            suggestedAction: `Automate "${pattern.taskType}" task (observed ${pattern.frequency} times with ${(pattern.successRate * 100).toFixed(0)}% success rate)`,
+            requiresApproval: true, // ALWAYS require approval for real tasks
+            estimatedBenefit: pattern.averageDuration
+                ? `Saves ~${pattern.averageDuration}ms per execution`
+                : 'Reduces manual repetition',
+            createdAt: new Date(),
+            status: 'pending'
+        };
+
+        this.suggestions.set(suggestion.id, suggestion);
+        pattern.suggestedAutomation = suggestion;
+
+        // Persist suggestion
+        try {
+            this.db.run(`
+                INSERT INTO automation_suggestions
+                (id, task_signature, task_type, confidence, observed_count, suggested_action, requires_approval, estimated_benefit, status)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `, [
+                suggestion.id,
+                signature,
+                suggestion.taskType,
+                suggestion.confidence,
+                suggestion.observedCount,
+                suggestion.suggestedAction,
+                1, // requires_approval = true
+                suggestion.estimatedBenefit,
+                'pending'
+            ]);
+        } catch (error) {
+            console.error('Failed to persist suggestion:', error);
+        }
+
+        // Emit event for UI notification
+        eventBus.emit('taskrecorder.suggestion.created', {
+            suggestion,
+            pattern
+        });
+
+        // Log to ProjectMemory
+        try {
+            projectMemory.logLifecycleEvent({
+                eventType: 'other',
+                status: 'success',
+                details: {
+                    component: 'TaskRecorder',
+                    action: 'automation_suggested',
+                    suggestionId: suggestion.id,
+                    taskType: pattern.taskType,
+                    observedCount: pattern.frequency,
+                    confidence: pattern.successRate
+                }
+            });
+        } catch (err) {
+            console.warn('Could not log suggestion to ProjectMemory:', err);
+        }
+
+        console.log(`💡 [TaskRecorder] Automation suggested: ${suggestion.suggestedAction}`);
+    }
+
+    /**
+     * Request task execution (requires approval)
+     */
+    async requestTaskExecution(request: TaskExecutionRequest): Promise<{ approved: boolean; executionId?: string }> {
+        // CRITICAL: Always require approval for real tasks
+        if (!request.requiresApproval) {
+            throw new Error('All real tasks require approval - cannot execute without approval');
+        }
+
+        const suggestion = this.suggestions.get(request.suggestionId);
+        if (!suggestion) {
+            throw new Error(`Suggestion ${request.suggestionId} not found`);
+        }
+
+        // Check if suggestion is approved
+        if (suggestion.status !== 'approved') {
+            return {
+                approved: false,
+                executionId: undefined
+            };
+        }
+
+        // Execute task (with approval)
+        const executionId = `exec-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+        try {
+            this.db.run(`
+                INSERT INTO task_executions
+                (id, suggestion_id, task_signature, task_type, params, requested_by, approved_by, executed_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            `, [
+                executionId,
+                request.suggestionId,
+                request.taskSignature,
+                request.taskType,
+                JSON.stringify(request.params),
+                request.requestedBy,
+                suggestion.approvedBy || 'system',
+                new Date().toISOString()
+            ]);
+
+            // Emit execution event
+            eventBus.emit('taskrecorder.execution.started', {
+                executionId,
+                request,
+                suggestion
+            });
+
+            return {
+                approved: true,
+                executionId
+            };
+        } catch (error) {
+            console.error('Failed to record execution:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Approve automation suggestion
+     */
+    async approveSuggestion(suggestionId: string, approvedBy: string): Promise<void> {
+        const suggestion = this.suggestions.get(suggestionId);
+        if (!suggestion) {
+            throw new Error(`Suggestion ${suggestionId} not found`);
+        }
+
+        suggestion.status = 'approved';
+        suggestion.approvedBy = approvedBy;
+        suggestion.approvedAt = new Date();
+
+        // Update database
+        try {
+            this.db.run(`
+                UPDATE automation_suggestions
+                SET status = 'approved',
+                    approved_by = ?,
+                    approved_at = ?
+                WHERE id = ?
+            `, [
+                approvedBy,
+                suggestion.approvedAt.toISOString(),
+                suggestionId
+            ]);
+        } catch (error) {
+            console.error('Failed to update suggestion:', error);
+        }
+
+        // Emit event
+        eventBus.emit('taskrecorder.suggestion.approved', {
+            suggestion
+        });
+
+        console.log(`✅ [TaskRecorder] Suggestion approved: ${suggestion.suggestedAction}`);
+    }
+
+    /**
+     * Reject automation suggestion
+     */
+    async rejectSuggestion(suggestionId: string, rejectedBy: string): Promise<void> {
+        const suggestion = this.suggestions.get(suggestionId);
+        if (!suggestion) {
+            throw new Error(`Suggestion ${suggestionId} not found`);
+        }
+
+        suggestion.status = 'rejected';
+
+        // Update database
+        try {
+            this.db.run(`
+                UPDATE automation_suggestions
+                SET status = 'rejected'
+                WHERE id = ?
+            `, [suggestionId]);
+        } catch (error) {
+            console.error('Failed to update suggestion:', error);
+        }
+
+        console.log(`❌ [TaskRecorder] Suggestion rejected: ${suggestion.suggestedAction}`);
+    }
+
+    /**
+     * Get all pending suggestions
+     */
+    getPendingSuggestions(): AutomationSuggestion[] {
+        return Array.from(this.suggestions.values())
+            .filter(s => s.status === 'pending')
+            .sort((a, b) => b.confidence - a.confidence);
+    }
+
+    /**
+     * Get pattern by signature
+     */
+    getPattern(signature: string): TaskPattern | undefined {
+        return this.patterns.get(signature);
+    }
+
+    /**
+     * Get all patterns
+     */
+    getAllPatterns(): TaskPattern[] {
+        return Array.from(this.patterns.values())
+            .sort((a, b) => b.frequency - a.frequency);
+    }
+
+    /**
+     * Generate signature from task type and params
+     */
+    private generateSignature(taskType: string, params: any): string {
+        const normalized = {
+            type: taskType,
+            params: this.normalizeParams(params)
+        };
+        const str = JSON.stringify(normalized);
+        // Use simple hash for signature
+        return `sig-${this.simpleHash(str)}`;
+    }
+
+    /**
+     * Normalize params for consistent signatures
+     */
+    private normalizeParams(params: any): any {
+        if (!params || typeof params !== 'object') {
+            return params;
+        }
+
+        const normalized: any = {};
+        for (const [key, value] of Object.entries(params)) {
+            // Ignore timestamps, IDs, and other variable fields
+            if (['timestamp', 'id', 'createdAt', 'updatedAt', 'userId', 'orgId'].includes(key)) {
+                continue;
+            }
+            normalized[key] = value;
+        }
+        return normalized;
+    }
+
+    /**
+     * Simple hash function
+     */
+    private simpleHash(str: string): string {
+        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).toString(36);
+    }
+
+    /**
+     * Calculate success rate for a pattern
+     */
+    private calculateSuccessRate(signature: string): number {
+        const observations = this.observations.get(signature) || [];
+        if (observations.length === 0) return 0;
+
+        const successful = observations.filter(o => o.success).length;
+        return successful / observations.length;
+    }
+
+    /**
+     * Calculate average duration for a pattern
+     */
+    private calculateAverageDuration(signature: string): number | undefined {
+        const observations = this.observations.get(signature) || [];
+        const withDuration = observations.filter(o => o.duration !== undefined);
+        if (withDuration.length === 0) return undefined;
+
+        const sum = withDuration.reduce((acc, o) => acc + (o.duration || 0), 0);
+        return sum / withDuration.length;
+    }
+}
+
+// Singleton instance
+let taskRecorderInstance: TaskRecorder | null = null;
+
+export function getTaskRecorder(): TaskRecorder {
+    if (!taskRecorderInstance) {
+        taskRecorderInstance = new TaskRecorder();
+    }
+    return taskRecorderInstance;
+}
+

apps/backend/src/mcp/cognitive/UnifiedGraphRAG.ts

@@ -0,0 +1,326 @@
+import { hybridSearchEngine } from './HybridSearchEngine.js';
+import { getCognitiveMemory } from '../memory/CognitiveMemory.js';
+import { unifiedMemorySystem } from './UnifiedMemorySystem.js';
+import { getLlmService } from '../../services/llm/llmService.js';
+import { MemoryRepository } from '../../services/memory/memoryRepository.js';
+import { getVectorStore } from '../../platform/vector/index.js';
+
+interface GraphNode {
+    id: string;
+    type: string;
+    content: string;
+    score: number;
+    depth: number;
+    metadata: any;
+    connections: GraphEdge[];
+    embedding?: number[]; // For semantic similarity
+}
+
+interface GraphEdge {
+    targetId: string;
+    relation: string;
+    weight: number;
+}
+
+interface GraphRAGResult {
+    answer: string;
+    reasoning_path: string[];
+    nodes: GraphNode[];
+    confidence: number;
+    sources?: Array<{ id: string; content: string; score: number }>;
+}
+
+export class UnifiedGraphRAG {
+    private maxHops: number = 2;
+    private minScore: number = 0.3;
+    private memoryRepo: MemoryRepository;
+
+    constructor() {
+        this.memoryRepo = new MemoryRepository();
+    }
+
+    /**
+     * Perform multi-hop reasoning over the knowledge graph
+     * Enhanced with LLM synthesis, semantic similarity, and CMA graph integration
+     */
+    public async query(query: string, context: { userId: string; orgId: string; maxHops?: number }): Promise<GraphRAGResult> {
+        console.log(`🧠 [GraphRAG] Starting reasoning for: "${query}"`);
+
+        const maxHops = context.maxHops || this.maxHops;
+
+        // 1. Get seed nodes from Hybrid Search (High precision entry points)
+        const seedResults = await hybridSearchEngine.search(query, {
+            ...context,
+            limit: 5
+        });
+
+        if (seedResults.length === 0) {
+            return {
+                answer: "No sufficient data found to reason about this query.",
+                reasoning_path: [],
+                nodes: [],
+                confidence: 0
+            };
+        }
+
+        // 2. Convert search results to graph nodes
+        let frontier: GraphNode[] = seedResults.map(r => ({
+            id: r.id,
+            type: r.type,
+            content: r.content,
+            score: r.score,
+            depth: 0,
+            metadata: r.metadata,
+            connections: []
+        }));
+
+        const visited = new Set<string>(frontier.map(n => n.id));
+        const knowledgeGraph: GraphNode[] = [...frontier];
+        const reasoningPath: string[] = [`Found ${frontier.length} starting points: ${frontier.map(n => n.id).join(', ')}`];
+
+        // 3. Expand graph (Multi-hop traversal with semantic similarity)
+        for (let hop = 1; hop <= maxHops; hop++) {
+            console.log(`🔍 [GraphRAG] Hop ${hop}: Expanding ${frontier.length} nodes`);
+            const newFrontier: GraphNode[] = [];
+
+            for (const node of frontier) {
+                // Enhanced expansion: Use CMA graph relations + semantic similarity
+                const connections = await this.expandNode(node, query, context);
+
+                for (const conn of connections) {
+                    if (!visited.has(conn.id) && conn.score > this.minScore) {
+                        visited.add(conn.id);
+                        newFrontier.push(conn);
+                        knowledgeGraph.push(conn);
+
+                        // Track edge in parent node
+                        node.connections.push({
+                            targetId: conn.id,
+                            relation: conn.metadata.relation || 'related_to',
+                            weight: conn.score
+                        });
+                    }
+                }
+            }
+
+            if (newFrontier.length > 0) {
+                reasoningPath.push(`Hop ${hop}: Discovered ${newFrontier.length} new related concepts.`);
+                frontier = newFrontier;
+            } else {
+                break; // No more connections found
+            }
+        }
+
+        // 4. Synthesize Answer using LLM (Inspired by CgentCore's L1 Director Agent)
+        const topNodes = knowledgeGraph.sort((a, b) => b.score - a.score).slice(0, 10);
+        const answer = await this.synthesizeAnswer(query, topNodes, context);
+
+        return {
+            answer,
+            reasoning_path: reasoningPath,
+            nodes: topNodes,
+            confidence: topNodes.length > 0 ? topNodes[0].score : 0,
+            sources: topNodes.slice(0, 5).map(n => ({
+                id: n.id,
+                content: n.content.substring(0, 200),
+                score: n.score
+            }))
+        };
+    }
+
+    /**
+     * Enhanced node expansion with CMA graph integration and semantic similarity
+     * Inspired by CgentCore's hybrid search approach
+     */
+    private async expandNode(node: GraphNode, query: string, context: { userId: string; orgId: string }): Promise<GraphNode[]> {
+        const memory = getCognitiveMemory();
+        const expandedNodes: GraphNode[] = [];
+
+        // Strategy 1: Get patterns involving this widget/source (existing)
+        const patterns = await memory.getWidgetPatterns(node.id);
+
+        // UsagePattern is an object with commonSources and timePatterns
+        // Use commonSources to expand graph connections
+        for (const source of patterns.commonSources || []) {
+            expandedNodes.push({
+                id: `source-${source}`,
+                type: 'source',
+                content: `Source: ${source}`,
+                score: node.score * 0.7, // Decay score over hops
+                depth: node.depth + 1,
+                metadata: { relation: 'uses_source', averageLatency: patterns.averageLatency },
+                connections: []
+            });
+        }
+
+        // Strategy 2: Use CMA memory relations (Direct graph edges)
+        // Inspired by CgentCore's memory_relations table
+        const relatedMemories = await this.memoryRepo.searchEntities({
+            orgId: context.orgId,
+            userId: context.userId,
+            keywords: this.extractKeywords(node.content),
+            limit: 5
+        });
+
+        for (const mem of relatedMemories) {
+            // Check if memory is semantically related to query
+            const semanticScore = await this.computeSemanticSimilarity(query, mem.content);
+
+            if (semanticScore > this.minScore) {
+                expandedNodes.push({
+                    id: `memory-${mem.id}`,
+                    type: mem.entity_type || 'memory',
+                    content: mem.content,
+                    score: (mem.importance || 0.5) * semanticScore * node.score * 0.7,
+                    depth: node.depth + 1,
+                    metadata: {
+                        relation: 'memory_relation',
+                        importance: mem.importance,
+                        semanticScore
+                    },
+                    connections: []
+                });
+            }
+        }
+
+        // Strategy 3: Use UnifiedMemorySystem for episodic memory connections
+        const workingMemory = await unifiedMemorySystem.getWorkingMemory({
+            userId: context.userId,
+            orgId: context.orgId
+        });
+
+        // Find related events/features based on semantic similarity
+        const relatedEvents = (workingMemory.recentEvents || []).slice(0, 3);
+        for (const event of relatedEvents) {
+            const eventContent = JSON.stringify(event);
+            const semanticScore = await this.computeSemanticSimilarity(query, eventContent);
+
+            if (semanticScore > this.minScore) {
+                expandedNodes.push({
+                    id: `event-${event.id || Date.now()}`,
+                    type: 'episodic',
+                    content: eventContent.substring(0, 200),
+                    score: semanticScore * node.score * 0.6,
+                    depth: node.depth + 1,
+                    metadata: {
+                        relation: 'episodic_memory',
+                        semanticScore
+                    },
+                    connections: []
+                });
+            }
+        }
+
+        return expandedNodes.sort((a, b) => b.score - a.score).slice(0, 5); // Top 5 per node
+    }
+
+    /**
+     * LLM-based answer synthesis
+     * Inspired by CgentCore's L1 Director Agent response generation
+     */
+    private async synthesizeAnswer(query: string, nodes: GraphNode[], context: { userId: string; orgId: string }): Promise<string> {
+        try {
+            const llmService = getLlmService();
+
+            // Build context from graph nodes
+            const graphContext = nodes.map((n, idx) =>
+                `[${idx + 1}] ${n.type}: ${n.content.substring(0, 300)} (confidence: ${n.score.toFixed(2)})`
+            ).join('\n\n');
+
+            const reasoningPath = nodes.map(n => `${n.id} (depth: ${n.depth})`).join(' -> ');
+
+            const systemContext = `You are an advanced reasoning assistant. Synthesize a comprehensive answer based on the knowledge graph context provided. 
+Use the reasoning path to explain how you arrived at the answer. Be precise, cite sources, and indicate confidence levels.`;
+
+            const userPrompt = `Query: ${query}
+
+Knowledge Graph Context:
+${graphContext}
+
+Reasoning Path: ${reasoningPath}
+
+Provide a comprehensive answer synthesizing the information from the knowledge graph. Include:
+1. Direct answer to the query
+2. Key insights from the graph
+3. Confidence assessment
+4. Sources referenced`;
+
+            const answer = await llmService.generateContextualResponse(
+                systemContext,
+                userPrompt,
+                `User: ${context.userId}, Org: ${context.orgId}`
+            );
+
+            return answer || "Reasoning complete. See nodes for details.";
+        } catch (error) {
+            console.error('[GraphRAG] LLM synthesis error:', error);
+            // Fallback to simple synthesis
+            return `Based on ${nodes.length} related concepts found: ${nodes.slice(0, 3).map(n => n.content.substring(0, 100)).join('; ')}...`;
+        }
+    }
+
+    /**
+     * Compute semantic similarity using ChromaDB vector search
+     * Uses proper embeddings via HuggingFace for true semantic similarity
+     */
+    private async computeSemanticSimilarity(query: string, content: string): Promise<number> {
+        try {
+            // Use pgvector for proper vector similarity
+            const vectorStore = await getVectorStore();
+
+            // For now, use simple text matching as fallback
+            // TODO: Generate embeddings for proper vector search
+            // const results = await vectorStore.search({
+            //     vector: [], // Would need actual embeddings here
+            //     limit: 1
+            // });
+
+            // Simple text similarity fallback
+            const queryLower = query.toLowerCase();
+            const contentLower = content.toLowerCase();
+
+            // Use Jaccard similarity
+            const queryWords = new Set(queryLower.split(/\s+/).filter(w => w.length > 2));
+            const contentWords = new Set(contentLower.split(/\s+/).filter(w => w.length > 2));
+            const intersection = new Set([...queryWords].filter(w => contentWords.has(w)));
+            const union = new Set([...queryWords, ...contentWords]);
+
+            const jaccard = union.size > 0 ? intersection.size / union.size : 0;
+            const phraseMatch = contentLower.includes(queryLower) ? 0.3 : 0;
+
+            return Math.min(1.0, jaccard + phraseMatch);
+
+        } catch (error) {
+            console.warn('[GraphRAG] Vector similarity failed, using keyword fallback:', error);
+
+            // Fallback to keyword similarity
+            const queryWords = new Set(query.toLowerCase().split(/\s+/).filter(w => w.length > 2));
+            const contentWords = new Set(content.toLowerCase().split(/\s+/).filter(w => w.length > 2));
+
+            const intersection = new Set([...queryWords].filter(w => contentWords.has(w)));
+            const union = new Set([...queryWords, ...contentWords]);
+
+            // Fix: Check for division by zero (Bug 2)
+            const jaccard = union.size > 0 ? intersection.size / union.size : 0;
+            const phraseMatch = content.toLowerCase().includes(query.toLowerCase()) ? 0.3 : 0;
+
+            return Math.min(1.0, jaccard + phraseMatch);
+        }
+    }
+
+    /**
+     * Extract keywords from content for memory search
+     */
+    private extractKeywords(content: string): string[] {
+        // Simple keyword extraction (can be enhanced with NLP)
+        const words = content.toLowerCase()
+            .split(/\s+/)
+            .filter(w => w.length > 3)
+            .filter(w => !['the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'man', 'new', 'now', 'old', 'see', 'two', 'way', 'who', 'boy', 'did', 'its', 'let', 'put', 'say', 'she', 'too', 'use'].includes(w))
+            .slice(0, 5);
+
+        return words;
+    }
+}
+
+export const unifiedGraphRAG = new UnifiedGraphRAG();

apps/backend/src/mcp/cognitive/UnifiedMemorySystem.ts

@@ -0,0 +1,330 @@
+// UnifiedMemorySystem – Phase 1 foundation
+// Provides Working, Procedural, Semantic, and Episodic memory layers
+// Integrates existing repositories (CMA, SRAG, PAL, Evolution, ProjectMemory)
+
+import { getCognitiveMemory, initCognitiveMemory, CognitiveMemory } from '../memory/CognitiveMemory.js';
+import { getDatabase } from '../../database/index.js';
+import { MemoryRepository } from '../../services/memory/memoryRepository.js';
+import { SragRepository } from '../../services/srag/sragRepository.js';
+import { PalRepository } from '../../services/pal/palRepository.js';
+import { EvolutionRepository } from '../../services/evolution/evolutionRepository.js';
+import { projectMemory } from '../../services/project/ProjectMemory.js';
+import { McpContext } from '@widget-tdc/mcp-types';
+import { QueryIntent } from '../autonomous/DecisionEngine.js';
+import { hybridSearchEngine } from './HybridSearchEngine.js';
+import { emotionAwareDecisionEngine } from './EmotionAwareDecisionEngine.js';
+
+/** WorkingMemoryState – transient context for the current request */
+export interface WorkingMemoryState {
+    recentEvents: any[];
+    recentFeatures: any[];
+    recentPatterns?: any[];
+    widgetStates: Record<string, any>; // Live data fra widgets
+    userMood: {
+        sentiment: 'positive' | 'neutral' | 'negative' | 'stressed';
+        arousal: number; // 0-1 (Hvor aktiv er brugeren?)
+        lastUpdated: number;
+    };
+    suggestedLayout?: {
+        mode: 'focus' | 'discovery' | 'alert';
+        activeWidgets: string[]; // ID på widgets der bør være fremme
+        theme?: string;
+    };
+}
+
+/** ProductionRuleEngine – simple procedural memory placeholder */
+class ProductionRuleEngine {
+    constructor(private cognitive: CognitiveMemory) { }
+    // TODO: implement rule extraction from cognitive patterns
+    async findRules(_opts: any): Promise<any[]> { return []; }
+}
+
+export class UnifiedMemorySystem {
+    // Existing repositories
+    private cognitive: CognitiveMemory;
+    private memoryRepo: MemoryRepository;
+    private sragRepo: SragRepository;
+    private palRepo: PalRepository;
+    private evolutionRepo: EvolutionRepository;
+
+    // New memory layers
+    private workingMemory: Map<string, WorkingMemoryState> = new Map();
+    private proceduralMemory: ProductionRuleEngine;
+
+    constructor() {
+        // Initialize repositories
+        this.memoryRepo = new MemoryRepository();
+        this.sragRepo = new SragRepository();
+        this.palRepo = new PalRepository();
+        this.evolutionRepo = new EvolutionRepository();
+
+        // Initialize cognitive memory lazily or assume initialized
+        // We cannot call getDatabase() here because it might not be ready
+        // The cognitive memory should be passed in or retrieved lazily
+        this.cognitive = {} as any; // Placeholder, will be set in init() or getter
+        this.proceduralMemory = new ProductionRuleEngine(this.cognitive);
+    }
+
+    // New init method to be called after DB is ready
+    public init() {
+        const db = getDatabase();
+        initCognitiveMemory(db);
+        this.cognitive = getCognitiveMemory();
+        this.proceduralMemory = new ProductionRuleEngine(this.cognitive);
+    }
+
+    /** Retrieve or create working memory for a user/org context */
+    async getWorkingMemory(ctx: McpContext): Promise<WorkingMemoryState> {
+        const key = `${ctx.orgId}:${ctx.userId}`;
+        if (!this.workingMemory.has(key)) {
+            const events = projectMemory.getLifecycleEvents(20);
+            const features = projectMemory.getFeatures();
+            this.workingMemory.set(key, { 
+                recentEvents: events, 
+                recentFeatures: features,
+                widgetStates: {},
+                userMood: { sentiment: 'neutral', arousal: 0.5, lastUpdated: Date.now() }
+            });
+        }
+        return this.workingMemory.get(key)!;
+    }
+
+    /** Opdater widget state og kør adaptiv analyse */
+    async updateWidgetState(ctx: McpContext, widgetId: string, state: any): Promise<void> {
+        const wm = await this.getWorkingMemory(ctx);
+        wm.widgetStates[widgetId] = { ...state, lastUpdated: Date.now() };
+        
+        // Trigger holographic analysis when state changes
+        const patterns = await this.findHolographicPatterns(ctx);
+        
+        // Opdater adaptivt layout baseret på mønstre
+        this.updateAdaptiveLayout(wm, patterns);
+    }
+
+    /** Persist result (e.g., tool output) into working memory for future context */
+    async updateWorkingMemory(ctx: McpContext, result: any): Promise<void> {
+        const key = `${ctx.orgId}:${ctx.userId}`;
+        const state = this.workingMemory.get(key);
+        if (state) {
+            state.recentEvents = [...(state.recentEvents || []), result];
+            
+            // Simuleret humør-analyse baseret på interaktion
+            // Hvis resultatet er en fejl -> stress op
+            if (result?.error) {
+                state.userMood.sentiment = 'stressed';
+                state.userMood.arousal = Math.min(1, state.userMood.arousal + 0.2);
+            } else {
+                // Reset langsomt mod neutral
+                state.userMood.arousal = Math.max(0.2, state.userMood.arousal - 0.05);
+            }
+            
+            this.workingMemory.set(key, state);
+        }
+    }
+
+    /** Enrich an incoming MCPMessage with memory context */
+    async enrichMCPRequest(message: any, ctx: McpContext): Promise<any> {
+        const wm = await this.getWorkingMemory(ctx);
+        return { 
+            ...message, 
+            memoryContext: { 
+                recentEvents: wm.recentEvents, 
+                recentFeatures: wm.recentFeatures,
+                activeWidgets: wm.widgetStates,
+                systemSuggestion: wm.suggestedLayout
+            } 
+        };
+    }
+
+    /** Example holographic pattern correlation across subsystems */
+    async findHolographicPatterns(ctx: McpContext): Promise<any[]> {
+        const wm = await this.getWorkingMemory(ctx);
+        const widgetData = Object.values(wm.widgetStates);
+
+        const [pal, cma, srag] = await Promise.all([
+            Promise.resolve(this.palRepo.getRecentEvents(ctx.userId, ctx.orgId, 50)).catch(() => []),
+            Promise.resolve(this.memoryRepo.searchEntities({ orgId: ctx.orgId, userId: ctx.userId, keywords: [], limit: 50 })).catch(() => []),
+            Promise.resolve(this.sragRepo.searchDocuments(ctx.orgId, '')).catch(() => []),
+        ]);
+
+        // Inkluder widget data i korrelationen
+        return this.correlateAcrossSystems([pal, cma, srag, widgetData]);
+    }
+
+    /** Opdater layout forslag baseret på mønstre og humør */
+    private updateAdaptiveLayout(wm: WorkingMemoryState, patterns: any[]) {
+        // 1. Tjek for kritiske mønstre (Sikkerhed)
+        const securityPattern = patterns.find(p => 
+            ['threat', 'attack', 'breach', 'password', 'alert'].includes(p.keyword) && p.frequency > 2
+        );
+
+        if (securityPattern) {
+            wm.suggestedLayout = {
+                mode: 'alert',
+                activeWidgets: ['DarkWebMonitorWidget', 'NetworkSpyWidget', 'CybersecurityOverwatchWidget'],
+                theme: 'red-alert'
+            };
+            return;
+        }
+
+        // 2. Tjek brugerens humør (Emotion Aware)
+        if (wm.userMood.sentiment === 'stressed' || wm.userMood.arousal > 0.8) {
+            wm.suggestedLayout = {
+                mode: 'focus',
+                activeWidgets: ['StatusWidget', 'IntelligentNotesWidget'], // Kun det mest nødvendige
+                theme: 'calm-blue'
+            };
+            return;
+        }
+
+        // 3. Default: Discovery mode hvis mange data-kilder er aktive
+        if (patterns.length > 5) {
+            wm.suggestedLayout = {
+                mode: 'discovery',
+                activeWidgets: ['VisualizerWidget', 'SearchInterfaceWidget', 'KnowledgeGraphWidget'],
+                theme: 'default'
+            };
+        }
+    }
+
+    /** Cross-correlate patterns across subsystems */
+    private correlateAcrossSystems(systems: any[]): any[] {
+        const patterns: any[] = [];
+
+        // Simple correlation: find common keywords/topics across systems
+        const allKeywords = new Map<string, number>();
+
+        if (!Array.isArray(systems)) return [];
+
+        systems.forEach((system, idx) => {
+            if (Array.isArray(system)) {
+                system.forEach((item: any) => {
+                    if (!item) return;
+                    const text = JSON.stringify(item).toLowerCase();
+                    const words = text.match(/\b\w{4,}\b/g) || [];
+                    words.forEach(word => {
+                        allKeywords.set(word, (allKeywords.get(word) || 0) + 1);
+                    });
+                });
+            }
+        });
+
+        // Find keywords that appear in multiple systems (holographic pattern)
+        Array.from(allKeywords.entries())
+            .filter(([_, count]) => count >= 2)
+            .forEach(([keyword, count]) => {
+                patterns.push({
+                    keyword,
+                    frequency: count,
+                    systems: systems.length,
+                    type: 'holographic_pattern'
+                });
+            });
+
+        return patterns;
+    }
+
+    /** Whole-part system health analysis */
+    async analyzeSystemHealth(): Promise<SystemHealthReport> {
+        const wholeSystem = {
+            globalHealth: await this.calculateGlobalHealth(),
+            emergentPatterns: await this.detectEmergentBehaviors(),
+            systemRhythms: await this.detectTemporalCycles()
+        };
+
+        const parts = await Promise.all([
+            this.componentHealth('pal'),
+            this.componentHealth('cma'),
+            this.componentHealth('srag'),
+            this.componentHealth('evolution'),
+            this.componentHealth('autonomous-agent')
+        ]);
+
+        return this.modelWholePartRelationships(wholeSystem, parts);
+    }
+
+    private async calculateGlobalHealth(): Promise<number> {
+        try {
+            const health = await this.cognitive.getSourceHealth('system');
+            return health?.healthScore || 0.8; // Default to 80% if no data
+        } catch {
+            return 0.8;
+        }
+    }
+
+    private async detectEmergentBehaviors(): Promise<any[]> {
+        // Placeholder: detect patterns that emerge from system interactions
+        return [];
+    }
+
+    private async detectTemporalCycles(): Promise<any[]> {
+        // Placeholder: detect recurring patterns over time
+        return [];
+    }
+
+    private async componentHealth(component: string): Promise<ComponentHealth> {
+        try {
+            if (!this.cognitive || !this.cognitive.getSourceHealth) {
+                 return {
+                    name: component,
+                    healthScore: 0.8, // Default optimistic
+                    latency: 0,
+                    successRate: 0.9
+                };
+            }
+            const health = await this.cognitive.getSourceHealth(component);
+            return {
+                name: component,
+                healthScore: health?.healthScore || 0.8,
+                latency: health?.latency?.p50 || 0,
+                successRate: health?.successRate || 0.9
+            };
+        } catch {
+            return {
+                name: component,
+                healthScore: 0.8,
+                latency: 0,
+                successRate: 0.9
+            };
+        }
+    }
+
+    private modelWholePartRelationships(whole: any, parts: ComponentHealth[]): SystemHealthReport {
+        const avgPartHealth = parts.reduce((sum, p) => sum + p.healthScore, 0) / parts.length;
+        const wholeHealth = whole.globalHealth;
+
+        return {
+            globalHealth: wholeHealth,
+            componentHealth: parts,
+            emergentPatterns: whole.emergentPatterns,
+            systemRhythms: whole.systemRhythms,
+            wholePartRatio: wholeHealth / Math.max(avgPartHealth, 0.1), // How whole relates to parts
+            healthVariance: this.calculateVariance(parts.map(p => p.healthScore))
+        };
+    }
+
+    private calculateVariance(values: number[]): number {
+        if (values.length === 0) return 0;
+        const mean = values.reduce((a, b) => a + b, 0) / values.length;
+        const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
+        return variance;
+    }
+}
+
+interface ComponentHealth {
+    name: string;
+    healthScore: number;
+    latency: number;
+    successRate: number;
+}
+
+interface SystemHealthReport {
+    globalHealth: number;
+    componentHealth: ComponentHealth[];
+    emergentPatterns: any[];
+    systemRhythms: any[];
+    wholePartRatio: number;
+    healthVariance: number;
+}
+
+export const unifiedMemorySystem = new UnifiedMemorySystem();

apps/backend/src/mcp/devToolsHandlers.ts

@@ -0,0 +1,23 @@
+import { devToolsService } from '../services/devtools/DevToolsService.js';
+import { MCPMessage } from '@widget-tdc/mcp-types';
+
+export async function handleDevToolsRequest(message: MCPMessage): Promise<any> {
+    const { tool, payload } = message;
+
+    switch (tool) {
+        case 'devtools-status':
+            return await devToolsService.getStatus();
+
+        case 'devtools-scan':
+            await devToolsService.runScan();
+            return { status: 'started', message: 'GitHub scan started in background' };
+
+        case 'devtools-validate':
+            const repoPath = (payload?.path as string) || process.cwd();
+            const result = await devToolsService.validateRepo(repoPath);
+            return { output: result };
+
+        default:
+            throw new Error(`Unknown DevTools tool: ${tool}`);
+    }
+}