Deploy from GitHub Actions 2025-12-15_17-15-49

apps/backend/package.json

@@ -10,6 +10,7 @@
     "build:tsc": "tsc",
     "start": "node dist/index.js",
     "test": "vitest run",
+    "lint": "eslint .",
     "neural-bridge": "tsx src/mcp/servers/NeuralBridgeServer.ts",
     "neural-bridge:build": "tsc && node dist/mcp/servers/NeuralBridgeServer.js",
     "ingest-drive": "tsx src/scripts/ingest-drive.ts"
@@ -69,7 +70,6 @@
     "zod": "^3.25.76"
   },
   "devDependencies": {
-    "esbuild": "^0.24.2",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/imap": "^0.8.40",
@@ -84,7 +84,11 @@
     "@types/uuid": "^9.0.7",
     "@types/ws": "^8.5.10",
     "@types/xml2js": "^0.4.14",
+    "@typescript-eslint/eslint-plugin": "^7.16.0",
+    "@typescript-eslint/parser": "^7.16.0",
+    "esbuild": "^0.24.2",
+    "eslint": "^8.57.0",
     "tsx": "^4.20.6",
     "typescript": "~5.8.2"
   }
-}
+}

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

@@ -3,7 +3,9 @@
 // Integrates existing repositories (CMA, SRAG, PAL, Evolution, ProjectMemory)
 
 import { getCognitiveMemory, initCognitiveMemory, CognitiveMemory } from '../memory/CognitiveMemory.js';
-import { getDatabase } from '../../database/index.js';
+import { getDatabase, getSqlJsDatabase } from '../../database/index.js';
+import { getDatabaseAdapter } from '../../platform/db/PrismaDatabaseAdapter.js';
+import { PostgresStorageAdapter } from '../memory/StorageAdapter.js';
 import { MemoryRepository } from '../../services/memory/memoryRepository.js';
 import { SragRepository } from '../../services/srag/sragRepository.js';
 import { PalRepository } from '../../services/pal/palRepository.js';
@@ -67,8 +69,15 @@ export class UnifiedMemorySystem {
 
     // New init method to be called after DB is ready
     public init() {
-        const db = getDatabase();
-        initCognitiveMemory(db);
+        const dbAdapter = getDatabaseAdapter();
+        if (dbAdapter.isAvailable()) {
+            initCognitiveMemory(new PostgresStorageAdapter(dbAdapter));
+        } else {
+            const db = getSqlJsDatabase();
+            // Note: getSqlJsDatabase returns the raw sql.js instance needed for .exec()
+            // If it returns null, CognitiveMemory handles it (memory-only mode)
+            initCognitiveMemory(db);
+        }
         this.cognitive = getCognitiveMemory();
         this.proceduralMemory = new ProductionRuleEngine(this.cognitive);
     }
@@ -79,8 +88,8 @@ export class UnifiedMemorySystem {
         if (!this.workingMemory.has(key)) {
             const events = projectMemory.getLifecycleEvents(20);
             const features = projectMemory.getFeatures();
-            this.workingMemory.set(key, { 
-                recentEvents: events, 
+            this.workingMemory.set(key, {
+                recentEvents: events,
                 recentFeatures: features,
                 widgetStates: {},
                 userMood: { sentiment: 'neutral', arousal: 0.5, lastUpdated: Date.now() }
@@ -93,10 +102,10 @@ export class UnifiedMemorySystem {
     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);
     }
@@ -107,7 +116,7 @@ export class UnifiedMemorySystem {
         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) {
@@ -117,7 +126,7 @@ export class UnifiedMemorySystem {
                 // Reset langsomt mod neutral
                 state.userMood.arousal = Math.max(0.2, state.userMood.arousal - 0.05);
             }
-            
+
             this.workingMemory.set(key, state);
         }
     }
@@ -125,14 +134,14 @@ export class UnifiedMemorySystem {
     /** 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, 
+        return {
+            ...message,
+            memoryContext: {
+                recentEvents: wm.recentEvents,
                 recentFeatures: wm.recentFeatures,
                 activeWidgets: wm.widgetStates,
                 systemSuggestion: wm.suggestedLayout
-            } 
+            }
         };
     }
 
@@ -154,7 +163,7 @@ export class UnifiedMemorySystem {
     /** 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 => 
+        const securityPattern = patterns.find(p =>
             ['threat', 'attack', 'breach', 'password', 'alert'].includes(p.keyword) && p.frequency > 2
         );
 
@@ -265,7 +274,7 @@ export class UnifiedMemorySystem {
     private async componentHealth(component: string): Promise<ComponentHealth> {
         try {
             if (!this.cognitive || !this.cognitive.getSourceHealth) {
-                 return {
+                return {
                     name: component,
                     healthScore: 0.8, // Default optimistic
                     latency: 0,

apps/backend/src/mcp/memory/CognitiveMemory.ts

@@ -15,10 +15,11 @@
  * ╚══════════════════════════════════════════════════════════════════════════════╝
  */
 
+import type { StorageAdapter } from './StorageAdapter.js';
+import { SqlJsStorageAdapter } from './StorageAdapter.js';
 import type { Database } from 'sql.js';
 import { PatternMemory, UsagePattern, PatternStatistics } from './PatternMemory.js';
 import { FailureMemory, Failure, RecoveryPath, FailureStatistics, SourceHealthSummary } from './FailureMemory.js';
-import { queryAll, execute, queryOne } from './SqlJsCompat.js';
 import { logger } from '../../utils/logger.js';
 import { eventBus, type EventType } from '../EventBus.js';
 
@@ -63,7 +64,7 @@ export interface CognitiveStats {
     failures: FailureStatistics;
     healthRecords: number;
     initialized: boolean;
-    persistenceMode: 'sqlite' | 'memory';
+    persistenceMode: 'sqlite' | 'postgres' | 'memory';
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -74,19 +75,28 @@ export class CognitiveMemory {
     public readonly patternMemory: PatternMemory;
     public readonly failureMemory: FailureMemory;
 
-    private db: Database | null = null;
+    private storage: StorageAdapter | null = null;
     private healthHistory: Map<string, HealthMetrics[]> = new Map();
     private readonly MAX_HEALTH_RECORDS = 1000;
     private initialized: boolean = false;
-    private persistenceMode: 'sqlite' | 'memory' = 'memory';
+    private persistenceMode: 'sqlite' | 'postgres' | 'memory' = 'memory';
+
+    constructor(storageOrDb?: StorageAdapter | Database) {
+        if (storageOrDb) {
+            if ('exec' in storageOrDb || 'run' in storageOrDb) {
+                // It's a Database
+                this.storage = new SqlJsStorageAdapter(storageOrDb as Database);
+            } else {
+                // It's a StorageAdapter
+                this.storage = storageOrDb as StorageAdapter;
+            }
+            this.persistenceMode = this.storage.mode;
+        }
 
-    constructor(database?: Database) {
-        this.patternMemory = new PatternMemory(database);
-        this.failureMemory = new FailureMemory(database);
+        this.patternMemory = new PatternMemory(this.storage || undefined);
+        this.failureMemory = new FailureMemory(this.storage || undefined);
 
-        if (database) {
-            this.db = database;
-            this.persistenceMode = 'sqlite';
+        if (this.storage) {
             this.initializeHealthTable();
         }
 
@@ -98,11 +108,14 @@ export class CognitiveMemory {
     /**
      * Initialize health metrics table for persistence
      */
-    private initializeHealthTable(): void {
-        if (!this.db) return;
+    private async initializeHealthTable(): Promise<void> {
+        if (!this.storage) return;
 
         try {
-            this.db.exec(`
+            const isPostgres = this.storage.mode === 'postgres';
+            const timestampType = isPostgres ? 'TIMESTAMP WITH TIME ZONE' : 'DATETIME';
+
+            await this.storage.execute(`
                 CREATE TABLE IF NOT EXISTS mcp_source_health (
                     id TEXT PRIMARY KEY,
                     source_name TEXT NOT NULL,
@@ -113,11 +126,11 @@ export class CognitiveMemory {
                     success_rate REAL NOT NULL,
                     request_count INTEGER NOT NULL,
                     error_count INTEGER NOT NULL,
-                    timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+                    timestamp ${timestampType} NOT NULL DEFAULT CURRENT_TIMESTAMP
                 )
             `);
 
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_source_health_source 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_source_health_source 
                 ON mcp_source_health(source_name, timestamp DESC)`);
 
             logger.debug('📊 Health metrics table initialized');
@@ -303,10 +316,10 @@ export class CognitiveMemory {
         }
 
         // Persist to database
-        if (this.db) {
+        if (this.storage) {
             try {
                 const id = `${sourceName}-${Date.now()}`;
-                execute(this.db, `
+                await this.storage.execute(`
                     INSERT INTO mcp_source_health 
                     (id, source_name, health_score, latency_p50, latency_p95, latency_p99,
                      success_rate, request_count, error_count, timestamp)
@@ -340,9 +353,9 @@ export class CognitiveMemory {
         limit: number = 100
     ): Promise<HealthMetrics[]> {
         // Try database first
-        if (this.db) {
+        if (this.storage) {
             try {
-                const rows = queryAll<{
+                const rows = await this.storage.queryAll<{
                     source_name: string;
                     health_score: number;
                     latency_p50: number;
@@ -352,7 +365,7 @@ export class CognitiveMemory {
                     request_count: number;
                     error_count: number;
                     timestamp: string;
-                }>(this.db, `
+                }>(`
                     SELECT * FROM mcp_source_health 
                     WHERE source_name = ?
                     ORDER BY timestamp DESC
@@ -513,7 +526,7 @@ export class CognitiveMemory {
      * Clean old data (maintenance)
      */
     async cleanup(retentionDays: number = 30): Promise<void> {
-        if (!this.db) {
+        if (!this.storage) {
             logger.debug('🧹 Cognitive memory cleanup (in-memory - automatic via limits)');
             return;
         }
@@ -522,12 +535,10 @@ export class CognitiveMemory {
             const cutoffDate = new Date();
             cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
 
-            const stmt = this.db.prepare(`
+            await this.storage.execute(`
                 DELETE FROM mcp_source_health 
                 WHERE timestamp < ?
-            `);
-            stmt.run([cutoffDate.toISOString()]);
-            stmt.free();
+            `, [cutoffDate.toISOString()]);
 
             logger.info(`🧹 Cleaned health records older than ${retentionDays} days`);
         } catch (error) {
@@ -542,12 +553,12 @@ export class CognitiveMemory {
 
 let instance: CognitiveMemory | null = null;
 
-export function initCognitiveMemory(database?: Database): CognitiveMemory {
+export function initCognitiveMemory(storageOrDb?: StorageAdapter | Database): CognitiveMemory {
     if (!instance) {
-        instance = new CognitiveMemory(database);
-    } else if (database && !instance['db']) {
-        // Upgrade to database-backed if provided later
-        instance = new CognitiveMemory(database);
+        instance = new CognitiveMemory(storageOrDb);
+    } else if (storageOrDb && !instance['storage']) {
+        // Upgrade to persistent storage if provided later
+        instance = new CognitiveMemory(storageOrDb);
     }
     return instance;
 }

apps/backend/src/mcp/memory/FailureMemory.ts

@@ -14,10 +14,9 @@
  */
 
 import { v4 as uuidv4 } from 'uuid';
-import type { Database } from 'sql.js';
+import type { StorageAdapter } from './StorageAdapter.js';
 import { logger } from '../../utils/logger.js';
 import { eventBus, type EventType } from '../EventBus.js';
-import { queryAll, queryOne, queryScalar, execute, batchInsert } from './SqlJsCompat.js';
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // INTERFACES
@@ -73,7 +72,7 @@ export interface SourceHealthSummary {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 export class FailureMemory {
-    private db: Database | null = null;
+    private storage: StorageAdapter | null = null;
     private initialized: boolean = false;
     private writeQueue: Failure[] = [];
     private flushInterval: ReturnType<typeof setInterval> | null = null;
@@ -84,30 +83,33 @@ export class FailureMemory {
     private readonly FLUSH_INTERVAL_MS = 3000; // Faster flush for failures
     private readonly MAX_DB_FAILURES = 50000;
 
-    constructor(database?: Database) {
-        if (database) {
-            this.db = database;
+    constructor(storage?: StorageAdapter) {
+        if (storage) {
+            this.storage = storage;
             this.initialize();
         }
     }
 
     /**
-     * Initialize with database connection
+     * Initialize with storage adapter
      */
-    public setDatabase(database: Database): void {
-        this.db = database;
+    public setStorage(storage: StorageAdapter): void {
+        this.storage = storage;
         this.initialize();
     }
 
     /**
      * Initialize the service
      */
-    private initialize(): void {
-        if (this.initialized || !this.db) return;
+    private async initialize(): Promise<void> {
+        if (this.initialized || !this.storage) return;
 
         try {
+            const isPostgres = this.storage.mode === 'postgres';
+            const timestampType = isPostgres ? 'TIMESTAMP WITH TIME ZONE' : 'DATETIME';
+
             // Ensure table exists - use exec for DDL statements (more compatible)
-            this.db.exec(`
+            await this.storage.execute(`
                 CREATE TABLE IF NOT EXISTS mcp_failure_memory (
                     id TEXT PRIMARY KEY,
                     source_name TEXT NOT NULL,
@@ -118,26 +120,26 @@ export class FailureMemory {
                     recovery_action TEXT,
                     recovery_success BOOLEAN,
                     recovery_time_ms INTEGER,
-                    occurred_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+                    occurred_at ${timestampType} NOT NULL DEFAULT CURRENT_TIMESTAMP
                 )
             `);
 
             // Create indexes
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_failure_memory_source 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_failure_memory_source 
                 ON mcp_failure_memory(source_name, occurred_at DESC)`);
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_failure_memory_error 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_failure_memory_error 
                 ON mcp_failure_memory(error_type, occurred_at DESC)`);
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_failure_memory_recovery 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_failure_memory_recovery 
                 ON mcp_failure_memory(recovery_action, recovery_success)`);
 
             // Load recent failures into cache
-            this.loadCacheFromDb();
+            await this.loadCacheFromDb();
 
             // Start background flush
             this.flushInterval = setInterval(() => this.flushWriteQueue(), this.FLUSH_INTERVAL_MS);
 
             this.initialized = true;
-            logger.info('🛡️ FailureMemory initialized with SQLite persistence');
+            logger.info(`🛡️ FailureMemory initialized with ${this.storage.mode} persistence`);
         } catch (error) {
             logger.error('❌ FailureMemory initialization failed:', error);
             this.initialized = true;
@@ -147,11 +149,11 @@ export class FailureMemory {
     /**
      * Load recent failures from database into cache
      */
-    private loadCacheFromDb(): void {
-        if (!this.db) return;
+    private async loadCacheFromDb(): Promise<void> {
+        if (!this.storage) return;
 
         try {
-            const rows = queryAll(this.db, `
+            const rows = await this.storage.queryAll(`
                 SELECT * FROM mcp_failure_memory 
                 ORDER BY occurred_at DESC 
                 LIMIT ?
@@ -263,9 +265,10 @@ export class FailureMemory {
         }
 
         // Update database
-        if (this.db) {
+        // Update database
+        if (this.storage) {
             try {
-                execute(this.db, `
+                await this.storage.execute(`
                     UPDATE mcp_failure_memory 
                     SET recovery_action = ?, recovery_success = ?, recovery_time_ms = ?
                     WHERE id = ?
@@ -286,8 +289,8 @@ export class FailureMemory {
     /**
      * Flush write queue to database
      */
-    private flushWriteQueue(): void {
-        if (!this.db || this.writeQueue.length === 0) return;
+    private async flushWriteQueue(): Promise<void> {
+        if (!this.storage || this.writeQueue.length === 0) return;
 
         const failures = [...this.writeQueue];
         this.writeQueue = [];
@@ -306,16 +309,16 @@ export class FailureMemory {
                 JSON.stringify(f.errorContext),
                 JSON.stringify(f.queryContext),
                 f.recoveryAction || null,
-                f.recoverySuccess != null ? (f.recoverySuccess ? 1 : 0) : null,
+                f.recoverySuccess != null ? f.recoverySuccess : null, // Use boolean directly
                 f.recoveryTimeMs || null,
                 f.occurredAt.toISOString()
             ]);
 
-            batchInsert(this.db, 'mcp_failure_memory', columns, rows);
+            await this.storage.batchInsert('mcp_failure_memory', columns, rows);
 
             // Cleanup old failures periodically
             if (Math.random() < 0.02) { // 2% chance per flush
-                this.cleanupOldFailures();
+                this.cleanupOldFailures(); // Background
             }
 
         } catch (error) {
@@ -327,14 +330,14 @@ export class FailureMemory {
     /**
      * Cleanup old failures
      */
-    private cleanupOldFailures(): void {
-        if (!this.db) return;
+    private async cleanupOldFailures(): Promise<void> {
+        if (!this.storage) return;
 
         try {
             const ninetyDaysAgo = new Date();
             ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);
 
-            execute(this.db, `
+            await this.storage.execute(`
                 DELETE FROM mcp_failure_memory 
                 WHERE occurred_at < ?
                 AND id NOT IN (
@@ -357,9 +360,9 @@ export class FailureMemory {
         sourceName: string,
         limit: number = 50
     ): Promise<Failure[]> {
-        if (this.db) {
+        if (this.storage) {
             try {
-                const rows = queryAll(this.db, `
+                const rows = await this.storage.queryAll(`
                     SELECT * FROM mcp_failure_memory 
                     WHERE source_name = ?
                     ORDER BY occurred_at DESC
@@ -387,15 +390,15 @@ export class FailureMemory {
         sourceName: string,
         errorType: string
     ): Promise<RecoveryPath[]> {
-        if (this.db) {
+        if (this.storage) {
             try {
-                const rows = queryAll<{
+                const rows = await this.storage.queryAll<{
                     recovery_action: string;
                     total: number;
                     successes: number;
                     avg_time: number;
                     last_success: string | null;
-                }>(this.db, `
+                }>(`
                     SELECT 
                         recovery_action,
                         COUNT(*) as total,
@@ -487,9 +490,9 @@ export class FailureMemory {
         const cutoff = new Date();
         cutoff.setMinutes(cutoff.getMinutes() - withinMinutes);
 
-        if (this.db) {
+        if (this.storage) {
             try {
-                const count = queryScalar<number>(this.db, `
+                const count = await this.storage.queryScalar<number>(`
                     SELECT COUNT(*) 
                     FROM mcp_failure_memory 
                     WHERE source_name = ? AND error_type = ? AND occurred_at > ?
@@ -519,9 +522,9 @@ export class FailureMemory {
 
         let failures: Failure[] = [];
 
-        if (this.db) {
+        if (this.storage) {
             try {
-                const rows = queryAll(this.db, `
+                const rows = await this.storage.queryAll(`
                     SELECT * FROM mcp_failure_memory 
                     WHERE source_name = ? AND occurred_at > ?
                     ORDER BY occurred_at DESC
@@ -599,36 +602,36 @@ export class FailureMemory {
         const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
         const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
 
-        if (this.db) {
+        if (this.storage) {
             try {
-                const total = queryScalar<number>(this.db, 'SELECT COUNT(*) FROM mcp_failure_memory') || 0;
-                const uniqueErrors = queryScalar<number>(this.db, 'SELECT COUNT(DISTINCT error_type) FROM mcp_failure_memory') || 0;
-                const uniqueSources = queryScalar<number>(this.db, 'SELECT COUNT(DISTINCT source_name) FROM mcp_failure_memory') || 0;
+                const total = await this.storage.queryScalar<number>('SELECT COUNT(*) FROM mcp_failure_memory') || 0;
+                const uniqueErrors = await this.storage.queryScalar<number>('SELECT COUNT(DISTINCT error_type) FROM mcp_failure_memory') || 0;
+                const uniqueSources = await this.storage.queryScalar<number>('SELECT COUNT(DISTINCT source_name) FROM mcp_failure_memory') || 0;
 
-                const recoveryRate = queryScalar<number>(this.db, `
+                const recoveryRate = await this.storage.queryScalar<number>(`
                     SELECT AVG(CAST(recovery_success AS FLOAT)) 
                     FROM mcp_failure_memory 
                     WHERE recovery_action IS NOT NULL
                 `) || 0;
 
-                const avgRecoveryTime = queryScalar<number>(this.db, `
+                const avgRecoveryTime = await this.storage.queryScalar<number>(`
                     SELECT AVG(recovery_time_ms) 
                     FROM mcp_failure_memory 
                     WHERE recovery_success = 1
                 `) || 0;
 
-                const last24h = queryScalar<number>(this.db,
+                const last24h = await this.storage.queryScalar<number>(
                     'SELECT COUNT(*) FROM mcp_failure_memory WHERE occurred_at > ?',
                     [oneDayAgo.toISOString()]
                 ) || 0;
 
-                const last7d = queryScalar<number>(this.db,
+                const last7d = await this.storage.queryScalar<number>(
                     'SELECT COUNT(*) FROM mcp_failure_memory WHERE occurred_at > ?',
                     [sevenDaysAgo.toISOString()]
                 ) || 0;
 
                 // Top error types
-                const topErrorRows = queryAll<{ error_type: string; count: number; recovery_rate: number }>(this.db, `
+                const topErrorRows = await this.storage.queryAll<{ error_type: string; count: number; recovery_rate: number }>(`
                     SELECT 
                         error_type, 
                         COUNT(*) as count,
@@ -645,7 +648,7 @@ export class FailureMemory {
                 }));
 
                 // Top failing sources
-                const topSourceRows = queryAll<{ source_name: string; count: number }>(this.db, `
+                const topSourceRows = await this.storage.queryAll<{ source_name: string; count: number }>(`
                     SELECT source_name, COUNT(*) as count
                     FROM mcp_failure_memory
                     GROUP BY source_name
@@ -658,12 +661,12 @@ export class FailureMemory {
                 }));
 
                 // Recent recoveries
-                const recentRecoveryRows = queryAll<{
+                const recentRecoveryRows = await this.storage.queryAll<{
                     recovery_action: string;
                     recovery_success: number;
                     recovery_time_ms: number;
                     occurred_at: string;
-                }>(this.db, `
+                }>(`
                     SELECT recovery_action, recovery_success, recovery_time_ms, occurred_at
                     FROM mcp_failure_memory
                     WHERE recovery_action IS NOT NULL
@@ -713,7 +716,7 @@ export class FailureMemory {
      * Force flush all pending writes
      */
     async flush(): Promise<void> {
-        this.flushWriteQueue();
+        await this.flushWriteQueue();
     }
 
     /**

apps/backend/src/mcp/memory/PatternMemory.ts

@@ -15,10 +15,9 @@
 
 import { v4 as uuidv4 } from 'uuid';
 import crypto from 'crypto';
-import type { Database } from 'sql.js';
+import type { StorageAdapter } from './StorageAdapter.js';
 import { logger } from '../../utils/logger.js';
 import { eventBus, type EventType } from '../EventBus.js';
-import { queryAll, queryOne, queryScalar, execute, batchInsert } from './SqlJsCompat.js';
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // INTERFACES
@@ -76,7 +75,7 @@ export interface PatternStatistics {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 export class PatternMemory {
-    private db: Database | null = null;
+    private storage: StorageAdapter | null = null;
     private initialized: boolean = false;
     private writeQueue: QueryPattern[] = [];
     private flushInterval: ReturnType<typeof setInterval> | null = null;
@@ -87,30 +86,34 @@ export class PatternMemory {
     private readonly FLUSH_INTERVAL_MS = 5000; // Batch writes every 5 seconds
     private readonly MAX_DB_PATTERNS = 100000;
 
-    constructor(database?: Database) {
-        if (database) {
-            this.db = database;
+    constructor(storage?: StorageAdapter) {
+        if (storage) {
+            this.storage = storage;
             this.initialize();
         }
     }
 
     /**
-     * Initialize with database connection
+     * Initialize with storage adapter
      */
-    public setDatabase(database: Database): void {
-        this.db = database;
+    public setStorage(storage: StorageAdapter): void {
+        this.storage = storage;
         this.initialize();
     }
 
     /**
      * Initialize the service
      */
-    private initialize(): void {
-        if (this.initialized || !this.db) return;
+    private async initialize(): Promise<void> {
+        if (this.initialized || !this.storage) return;
 
         try {
-            // Ensure table exists - use exec for DDL statements (more compatible)
-            this.db.exec(`
+            // Postgres uses different syntax for some things, but basic CREATE TABLE is mostly compatible
+            // except for DATETIME DEFAULT CURRENT_TIMESTAMP vs TIMESTAMP WITH TIME ZONE
+            const isPostgres = this.storage.mode === 'postgres';
+            const timestampType = isPostgres ? 'TIMESTAMP WITH TIME ZONE' : 'DATETIME';
+
+            await this.storage.execute(`
                 CREATE TABLE IF NOT EXISTS mcp_query_patterns (
                     id TEXT PRIMARY KEY,
                     widget_id TEXT NOT NULL,
@@ -121,26 +124,26 @@ export class PatternMemory {
                     result_size INTEGER,
                     success BOOLEAN NOT NULL,
                     user_context TEXT,
-                    timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+                    timestamp ${timestampType} NOT NULL DEFAULT CURRENT_TIMESTAMP
                 )
             `);
 
             // Create indexes for fast queries
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_query_patterns_widget 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_query_patterns_widget 
                 ON mcp_query_patterns(widget_id, timestamp DESC)`);
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_query_patterns_signature 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_query_patterns_signature 
                 ON mcp_query_patterns(query_signature)`);
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_query_patterns_source 
+            await this.storage.execute(`CREATE INDEX IF NOT EXISTS idx_query_patterns_source 
                 ON mcp_query_patterns(source_used, timestamp DESC)`);
 
             // Load recent patterns into cache
-            this.loadCacheFromDb();
+            await this.loadCacheFromDb();
 
             // Start background flush
             this.flushInterval = setInterval(() => this.flushWriteQueue(), this.FLUSH_INTERVAL_MS);
 
             this.initialized = true;
-            logger.info('🧠 PatternMemory initialized with SQLite persistence');
+            logger.info(`🧠 PatternMemory initialized with ${this.storage.mode} storage`);
         } catch (error) {
             logger.error('❌ PatternMemory initialization failed:', error);
             // Fall back to in-memory only
@@ -151,11 +154,12 @@ export class PatternMemory {
     /**
      * Load recent patterns from database into cache
      */
-    private loadCacheFromDb(): void {
-        if (!this.db) return;
+
+    private async loadCacheFromDb(): Promise<void> {
+        if (!this.storage) return;
 
         try {
-            const rows = queryAll(this.db, `
+            const rows = await this.storage.queryAll(`
                 SELECT * FROM mcp_query_patterns 
                 ORDER BY timestamp DESC 
                 LIMIT ?
@@ -245,8 +249,8 @@ export class PatternMemory {
     /**
      * Flush write queue to database (batched writes)
      */
-    private flushWriteQueue(): void {
-        if (!this.db || this.writeQueue.length === 0) return;
+    private async flushWriteQueue(): Promise<void> {
+        if (!this.storage || this.writeQueue.length === 0) return;
 
         const patterns = [...this.writeQueue];
         this.writeQueue = [];
@@ -264,17 +268,17 @@ export class PatternMemory {
                 p.querySignature,
                 p.sourceUsed,
                 p.latencyMs,
-                p.resultSize || null,
-                p.success ? 1 : 0,
+                p.resultSize ?? null,
+                p.success, // Use boolean directly for Postgres compatibility
                 p.userContext ? JSON.stringify(p.userContext) : null,
                 p.timestamp.toISOString()
             ]);
 
-            batchInsert(this.db, 'mcp_query_patterns', columns, rows);
+            await this.storage.batchInsert('mcp_query_patterns', columns, rows);
 
             // Cleanup old patterns periodically
             if (Math.random() < 0.01) { // 1% chance per flush
-                this.cleanupOldPatterns();
+                this.cleanupOldPatterns(); // No await to keep it background
             }
 
         } catch (error) {
@@ -287,14 +291,17 @@ export class PatternMemory {
     /**
      * Cleanup old patterns to prevent database bloat
      */
-    private cleanupOldPatterns(): void {
-        if (!this.db) return;
+    private async cleanupOldPatterns(): Promise<void> {
+        if (!this.storage) return;
 
         try {
             const thirtyDaysAgo = new Date();
             thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
 
-            execute(this.db, `
+            // Need to fix this query for Postgres compatibility if nested subquery limit issues arise
+            // But standard SQL roughly supports DELETE...
+            // Postgres supports DELETE FROM ... WHERE id NOT IN (...)
+            await this.storage.execute(`
                 DELETE FROM mcp_query_patterns 
                 WHERE timestamp < ?
                 AND id NOT IN (
@@ -332,10 +339,10 @@ export class PatternMemory {
         }
 
         // Query database for more
-        if (this.db) {
+        if (this.storage) {
             try {
                 const remaining = limit - results.length;
-                const rows = queryAll(this.db, `
+                const rows = await this.storage.queryAll(`
                     SELECT * FROM mcp_query_patterns 
                     WHERE query_signature = ?
                     AND id NOT IN (${results.map(() => '?').join(',') || '\'\''})
@@ -367,9 +374,9 @@ export class PatternMemory {
         let patterns: QueryPattern[] = [];
 
         // Try database first
-        if (this.db) {
+        if (this.storage) {
             try {
-                const rows = queryAll(this.db, `
+                const rows = await this.storage.queryAll(`
                     SELECT * FROM mcp_query_patterns 
                     WHERE widget_id = ? AND timestamp > ?
                     ORDER BY timestamp DESC
@@ -435,12 +442,12 @@ export class PatternMemory {
      * Get average latency for a source
      */
     async getAverageLatency(sourceName: string): Promise<number> {
-        if (this.db) {
+        if (this.storage) {
             try {
                 const oneDayAgo = new Date();
                 oneDayAgo.setDate(oneDayAgo.getDate() - 1);
 
-                const result = queryOne<{ avg_latency: number }>(this.db, `
+                const result = await this.storage.queryOne<{ avg_latency: number }>(`
                     SELECT AVG(latency_ms) as avg_latency 
                     FROM mcp_query_patterns 
                     WHERE source_used = ? AND success = 1 AND timestamp > ?
@@ -471,12 +478,12 @@ export class PatternMemory {
      * Get success rate for a source and query type
      */
     async getSuccessRate(sourceName: string, queryType: string): Promise<number> {
-        if (this.db) {
+        if (this.storage) {
             try {
                 const sevenDaysAgo = new Date();
                 sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
 
-                const result = queryOne<{ total: number; successes: number }>(this.db, `
+                const result = await this.storage.queryOne<{ total: number; successes: number }>(`
                     SELECT 
                         COUNT(*) as total,
                         SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successes
@@ -515,37 +522,37 @@ export class PatternMemory {
         const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
         const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
 
-        if (this.db) {
+        if (this.storage) {
             try {
                 // Total patterns
-                const total = queryScalar<number>(this.db, 'SELECT COUNT(*) FROM mcp_query_patterns') || 0;
+                const total = await this.storage.queryScalar<number>('SELECT COUNT(*) FROM mcp_query_patterns') || 0;
 
                 // Unique widgets
-                const uniqueWidgets = queryScalar<number>(this.db, 'SELECT COUNT(DISTINCT widget_id) FROM mcp_query_patterns') || 0;
+                const uniqueWidgets = await this.storage.queryScalar<number>('SELECT COUNT(DISTINCT widget_id) FROM mcp_query_patterns') || 0;
 
                 // Unique sources
-                const uniqueSources = queryScalar<number>(this.db, 'SELECT COUNT(DISTINCT source_used) FROM mcp_query_patterns') || 0;
+                const uniqueSources = await this.storage.queryScalar<number>('SELECT COUNT(DISTINCT source_used) FROM mcp_query_patterns') || 0;
 
                 // Average latency
-                const avgLatency = queryScalar<number>(this.db, 'SELECT AVG(latency_ms) FROM mcp_query_patterns WHERE success = 1') || 0;
+                const avgLatency = await this.storage.queryScalar<number>('SELECT AVG(latency_ms) FROM mcp_query_patterns WHERE success = 1') || 0;
 
                 // Success rate
-                const successRate = queryScalar<number>(this.db, 'SELECT AVG(CAST(success AS FLOAT)) FROM mcp_query_patterns') || 0;
+                const successRate = await this.storage.queryScalar<number>('SELECT AVG(CAST(success AS FLOAT)) FROM mcp_query_patterns') || 0;
 
                 // Queries last 24h
-                const last24h = queryScalar<number>(this.db,
+                const last24h = await this.storage.queryScalar<number>(
                     'SELECT COUNT(*) FROM mcp_query_patterns WHERE timestamp > ?',
                     [oneDayAgo.toISOString()]
                 ) || 0;
 
                 // Queries last 7d
-                const last7d = queryScalar<number>(this.db,
+                const last7d = await this.storage.queryScalar<number>(
                     'SELECT COUNT(*) FROM mcp_query_patterns WHERE timestamp > ?',
                     [sevenDaysAgo.toISOString()]
                 ) || 0;
 
                 // Top sources
-                const topSourcesRows = queryAll<{ source_used: string; count: number; avg_latency: number }>(this.db, `
+                const topSourcesRows = await this.storage.queryAll<{ source_used: string; count: number; avg_latency: number }>(`
                     SELECT source_used, COUNT(*) as count, AVG(latency_ms) as avg_latency
                     FROM mcp_query_patterns
                     GROUP BY source_used
@@ -559,7 +566,7 @@ export class PatternMemory {
                 }));
 
                 // Top widgets
-                const topWidgetsRows = queryAll<{ widget_id: string; count: number }>(this.db, `
+                const topWidgetsRows = await this.storage.queryAll<{ widget_id: string; count: number }>(`
                     SELECT widget_id, COUNT(*) as count
                     FROM mcp_query_patterns
                     GROUP BY widget_id
@@ -575,6 +582,7 @@ export class PatternMemory {
                     totalPatterns: total,
                     uniqueWidgets,
                     uniqueSources,
+
                     avgLatencyMs: avgLatency,
                     successRate,
                     queriesLast24h: last24h,

apps/backend/src/mcp/memory/StorageAdapter.ts

@@ -0,0 +1,107 @@
+
+import type { Database } from 'sql.js';
+import { logger } from '../../utils/logger.js';
+import { queryAll, queryOne, execute, batchInsert, queryScalar } from './SqlJsCompat.js';
+import { DatabaseAdapter } from '../../platform/db/PrismaDatabaseAdapter.js';
+
+export interface StorageAdapter {
+    queryAll<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    queryOne<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    queryScalar<T = any>(sql: string, params?: any[]): Promise<T | null>;
+    execute(sql: string, params?: any[]): Promise<number>;
+    batchInsert(tableName: string, columns: string[], rows: any[][]): Promise<number>;
+    isAvailable(): boolean;
+    mode: 'sqlite' | 'postgres';
+}
+
+export class SqlJsStorageAdapter implements StorageAdapter {
+    constructor(private db: Database | null) { }
+
+    mode: 'sqlite' | 'postgres' = 'sqlite';
+
+    isAvailable(): boolean {
+        return !!this.db;
+    }
+
+    async queryAll<T = any>(sql: string, params: any[] = []): Promise<T[]> {
+        if (!this.db) return [];
+        // SqlJsCompat functions are synchronous for sql.js, but we wrap in Promise for common interface
+        return Promise.resolve(queryAll<T>(this.db, sql, params));
+    }
+
+    async queryOne<T = any>(sql: string, params: any[] = []): Promise<T | null> {
+        if (!this.db) return null;
+        return Promise.resolve(queryOne<T>(this.db, sql, params));
+    }
+
+    async queryScalar<T = any>(sql: string, params: any[] = []): Promise<T | null> {
+        if (!this.db) return null;
+        return Promise.resolve(queryScalar<T>(this.db, sql, params));
+    }
+
+    async execute(sql: string, params: any[] = []): Promise<number> {
+        if (!this.db) return 0;
+        return Promise.resolve(execute(this.db, sql, params));
+    }
+
+    async batchInsert(tableName: string, columns: string[], rows: any[][]): Promise<number> {
+        if (!this.db) return 0;
+        return Promise.resolve(batchInsert(this.db, tableName, columns, rows));
+    }
+}
+
+export class PostgresStorageAdapter implements StorageAdapter {
+    constructor(private prisma: DatabaseAdapter) { }
+
+    mode: 'sqlite' | 'postgres' = 'postgres';
+
+    isAvailable(): boolean {
+        return this.prisma.isAvailable();
+    }
+
+    async queryAll<T = any>(sql: string, params: any[] = []): Promise<T[]> {
+        // Postgres uses $1, $2, etc. instead of ?
+        const { sql: pgSql, params: pgParams } = this.convertSql(sql, params);
+        return await this.prisma.query(pgSql, pgParams);
+    }
+
+    async queryOne<T = any>(sql: string, params: any[] = []): Promise<T | null> {
+        const rows = await this.queryAll<T>(sql, params);
+        return rows.length > 0 ? rows[0] : null;
+    }
+
+    async queryScalar<T = any>(sql: string, params: any[] = []): Promise<T | null> {
+        const rows = await this.queryAll(sql, params);
+        if (rows.length === 0) return null;
+        const firstValue = Object.values(rows[0])[0];
+        return firstValue as T;
+    }
+
+    async execute(sql: string, params: any[] = []): Promise<number> {
+        const { sql: pgSql, params: pgParams } = this.convertSql(sql, params);
+        return await this.prisma.execute(pgSql, pgParams);
+    }
+
+    async batchInsert(tableName: string, columns: string[], rows: any[][]): Promise<number> {
+        if (rows.length === 0) return 0;
+
+        // Construct standard VALUES clause but with $1, $2...
+        // This is tricky with variable params.
+        // A simple loop implementation for now
+        let count = 0;
+        for (const row of rows) {
+            const placeholders = row.map((_, i) => `$${i + 1}`).join(', ');
+            const sql = `INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`;
+            await this.prisma.query(sql, row);
+            count++;
+        }
+        return count;
+    }
+
+    private convertSql(sql: string, params: any[]): { sql: string, params: any[] } {
+        // Convert ? to $1, $2, etc.
+        let paramIndex = 1;
+        const pgSql = sql.replace(/\?/g, () => `$${paramIndex++}`);
+        return { sql: pgSql, params };
+    }
+}

apps/backend/src/platform/db/PrismaDatabaseAdapter.ts

@@ -24,6 +24,7 @@ export interface DatabaseAdapter {
     initialize(): Promise<void>;
     disconnect(): Promise<void>;
     query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<number>;
     transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
     isAvailable(): boolean;
 }
@@ -56,6 +57,10 @@ class StubDatabaseAdapter implements DatabaseAdapter {
         throw new Error(`PostgreSQL not available: ${this.reason}. Use SQLite for local operations.`);
     }
 
+    async execute(_sql: string, _params?: any[]): Promise<number> {
+        throw new Error(`PostgreSQL not available: ${this.reason}. Use SQLite for local operations.`);
+    }
+
     isAvailable(): boolean {
         return false;
     }
@@ -131,6 +136,13 @@ class PrismaDatabaseAdapterImpl implements DatabaseAdapter {
         return this.prisma.$queryRawUnsafe(sql, ...(params || []));
     }
 
+    async execute(sql: string, params?: any[]): Promise<number> {
+        if (!this.prisma || !this.isInitialized) {
+            throw new Error('PostgreSQL not connected. Use SQLite for local operations.');
+        }
+        return this.prisma.$executeRawUnsafe(sql, ...(params || []));
+    }
+
     async transaction<T>(fn: (tx: any) => Promise<T>): Promise<T> {
         if (!this.prisma || !this.isInitialized) {
             throw new Error('PostgreSQL not connected. Use SQLite for local operations.');

apps/backend/src/services/NeuralChat/NeuralCortex.ts

@@ -67,7 +67,7 @@ export interface DiscoveredPattern {
 
 class NeuralCortex {
     private static instance: NeuralCortex;
-    
+
     public static getInstance(): NeuralCortex {
         if (!NeuralCortex.instance) {
             NeuralCortex.instance = new NeuralCortex();
@@ -86,7 +86,7 @@ class NeuralCortex {
     }> {
         const entities = this.extractEntities(message.body);
         const concepts = this.extractConcepts(message.body);
-        
+
         // 1. Create message node in GRAPH (Neo4j)
         await neo4jAdapter.runQuery(`
             CREATE (m:Message {
@@ -158,23 +158,23 @@ class NeuralCortex {
      */
     private extractEntities(text: string): string[] {
         const entities: string[] = [];
-        
+
         // @mentions
         const mentions = text.match(/@(\w+)/g);
         if (mentions) entities.push(...mentions.map(m => m.slice(1)));
-        
+
         // File paths
         const files = text.match(/[\w-]+\.(ts|js|tsx|jsx|json|md|py|yaml|yml|sql)/gi);
         if (files) entities.push(...files);
-        
+
         // Component/Class names (PascalCase)
         const components = text.match(/\b[A-Z][a-zA-Z]+(?:Widget|Service|Controller|Adapter|Component|Provider|Handler)\b/g);
         if (components) entities.push(...components);
-        
+
         // URLs
         const urls = text.match(/https?:\/\/[^\s]+/g);
         if (urls) entities.push(...urls);
-        
+
         return [...new Set(entities)];
     }
 
@@ -184,19 +184,19 @@ class NeuralCortex {
     private extractConcepts(text: string): string[] {
         const concepts: string[] = [];
         const textLower = text.toLowerCase();
-        
+
         // Technologies
-        const techs = ['neo4j', 'react', 'typescript', 'docker', 'kubernetes', 'api', 'websocket', 'mcp', 'graphql', 'rest', 'postgresql', 'redis', 'vector', 'rag'];
+        const techs = ['neo4j', 'react', 'typescript', 'docker', 'kubernetes', 'api', 'websocket', 'mcp', 'graphql', 'rest', 'postgresql', 'redis', 'vector', 'pgvector', 'rag'];
         techs.forEach(t => { if (textLower.includes(t)) concepts.push(t); });
-        
+
         // Actions
         const actions = ['deploy', 'review', 'test', 'refactor', 'implement', 'fix', 'create', 'delete', 'update', 'analyze', 'research', 'architect'];
         actions.forEach(a => { if (textLower.includes(a)) concepts.push(a); });
-        
+
         // Domains
         const domains = ['security', 'performance', 'architecture', 'authentication', 'authorization', 'database', 'frontend', 'backend', 'infrastructure', 'ai', 'agents'];
         domains.forEach(d => { if (textLower.includes(d)) concepts.push(d); });
-        
+
         return [...new Set(concepts)];
     }
 
@@ -211,7 +211,7 @@ class NeuralCortex {
                 MERGE (m)-[:MENTIONS]->(e)
                 RETURN e.name as linked
             `, { messageId, entity });
-            
+
             return result[0]?.linked || null;
         } catch {
             return null;
@@ -241,27 +241,27 @@ class NeuralCortex {
      */
     async query(input: CortexQuery): Promise<CortexResult[]> {
         const results: CortexResult[] = [];
-        
+
         switch (input.type) {
             case 'search':
                 return await this.hybridSearch(input.query, input.context);
-            
+
             case 'pattern':
                 return await this.findPatterns(input.query, input.context);
-            
+
             case 'insight':
                 return await this.generateInsights(input.query, input.context);
-            
+
             case 'history':
                 return await this.getDecisionHistory(input.query, input.context);
-            
+
             case 'chat':
             default:
                 // 1. Search Chat History (Vector + Keyword)
                 const chatResults = await this.searchMessages(input.query);
                 // 2. Search Knowledge Graph (Keyword/Hybrid)
                 const graphResults = await this.hybridSearch(input.query, input.context);
-                
+
                 return [...chatResults, ...graphResults].sort((a, b) => b.relevance - a.relevance);
         }
     }
@@ -313,7 +313,7 @@ class NeuralCortex {
 
                 for (const r of graphResults) {
                     if (!existingIds.has(r.m.properties.id)) {
-                         results.push({
+                        results.push({
                             type: 'message' as const,
                             data: {
                                 id: r.m.properties.id,
@@ -380,13 +380,13 @@ class NeuralCortex {
                 LIMIT 20
             `, { query, nodeTypes });
 
-             // Merge results (simple dedup by name)
-             const existingNames = new Set(results.map(r => r.data.name));
-             
-             for (const r of graphResults) {
-                 const name = r.n.properties.name || r.n.properties.id;
-                 if (!existingNames.has(name)) {
-                     results.push({
+            // Merge results (simple dedup by name)
+            const existingNames = new Set(results.map(r => r.data.name));
+
+            for (const r of graphResults) {
+                const name = r.n.properties.name || r.n.properties.id;
+                if (!existingNames.has(name)) {
+                    results.push({
                         type: 'node' as const,
                         data: {
                             name: name,
@@ -397,8 +397,8 @@ class NeuralCortex {
                         source: 'knowledge_graph',
                         connections: r.connections.filter((c: any) => c.target)
                     });
-                 }
-             }
+                }
+            }
 
             return results;
         } catch {
@@ -567,7 +567,7 @@ class NeuralCortex {
             return [];
         }
     }
-    
+
     /**
      * Calculate relevance score (0-1) for a result
      */
@@ -575,12 +575,12 @@ class NeuralCortex {
         if (!text) return 0;
         const queryTerms = query.toLowerCase().split(' ');
         const textLower = text.toLowerCase();
-        
+
         let matches = 0;
         for (const term of queryTerms) {
             if (textLower.includes(term)) matches++;
         }
-        
+
         return matches / queryTerms.length;
     }
 
@@ -589,7 +589,7 @@ class NeuralCortex {
      */
     private async getDecisionHistory(query: string, context?: CortexQuery['context']): Promise<CortexResult[]> {
         try {
-             const history = await neo4jAdapter.runQuery(`
+            const history = await neo4jAdapter.runQuery(`
                 MATCH (m:Message)
                 WHERE any(word IN ['decision', 'approved', 'rejected', 'selected', 'chose'] 
                          WHERE toLower(m.body) CONTAINS word)
@@ -599,17 +599,17 @@ class NeuralCortex {
                 LIMIT 20
              `, { query });
 
-             return history.map((h: any) => ({
-                 type: 'message',
-                 data: {
-                     id: h.m.properties.id,
-                     body: h.m.properties.body,
-                     agent: h.agent,
-                     timestamp: h.m.properties.timestamp
-                 },
-                 relevance: 1,
-                 source: 'history'
-             }));
+            return history.map((h: any) => ({
+                type: 'message',
+                data: {
+                    id: h.m.properties.id,
+                    body: h.m.properties.body,
+                    agent: h.agent,
+                    timestamp: h.m.properties.timestamp
+                },
+                relevance: 1,
+                source: 'history'
+            }));
         } catch {
             return [];
         }

apps/backend/src/services/SelfHealingAdapter.ts

@@ -12,7 +12,7 @@ interface HealingResult {
   latency: number;
 }
 
-class SelfHealingAdapter {
+export class SelfHealingAdapter {
   private static instance: SelfHealingAdapter;
   private retryLimits: Map<ErrorSignature, number> = new Map();
   private circuitBreakers: Map<string, boolean> = new Map(); // True = OPEN (Broken)
@@ -29,6 +29,25 @@ class SelfHealingAdapter {
     return SelfHealingAdapter.instance;
   }
 
+  // Wrapper compatibility for CortexController
+  public async handleError(error: any, source: string): Promise<void> {
+    await this.heal(error instanceof Error ? error : new Error(String(error)), source, {});
+  }
+
+  public async runStartupValidation(_fullCheck: boolean = false): Promise<{ success: boolean; services: any[] }> {
+    // Basic validation implementation
+    return {
+      success: true,
+      services: this.getSystemStatus().services
+    };
+  }
+
+  public async learnFromError(error: any, context: any, _solution?: any): Promise<void> {
+    // Integration with Knowledge Graph to learn from failures
+    console.log(`🧠 [LAZARUS] Analyzing failure pattern: ${error instanceof Error ? error.message : String(error)} in ${JSON.stringify(context)}`);
+    // Logic to store into FailureMemory would go here
+  }
+
   /**
    * 🛡️ THE OMEGA SHIELD: Main entry point for all system errors.
    * Wraps any operation in a Lazarus Loop.
@@ -158,7 +177,7 @@ class SelfHealingAdapter {
    * Used by KnowledgeCompiler.
    */
   public getPredictiveAlerts(): any[] {
-    // In a real implementation, this would analyze error frequencies from metricsService.
+    // In a real implementations, this would analyze error frequencies from metricsService.
     // For now, we return basic alerts if circuit breakers are open.
     const alerts: any[] = [];
     this.circuitBreakers.forEach((isOpen, name) => {

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

@@ -3,10 +3,14 @@ import path from 'path';
 import { EmbeddingProvider } from './EmbeddingService.js';
 import { logger } from '../../utils/logger.js';
 
-// ESM/CJS compatible __dirname
-const __dirname = typeof import.meta !== 'undefined' && import.meta.url 
-  ? path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1'))
-  : __dirname || process.cwd();
+import { fileURLToPath } from 'url';
+
+// ESM/CJS compatible directory logic
+const currentDir = typeof import.meta !== 'undefined' && import.meta.url
+  ? path.dirname(fileURLToPath(import.meta.url))
+  : process.cwd(); // Fallback for CJS if specific __dirname is tricky, usually path.dirname(__filename) but __filename is also issue. 
+// Better: assume ESM for this modern app or just use process.cwd() relative path if needed but finding built script is safer.
+
 
 export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
   name = 'local-gpu';
@@ -16,14 +20,14 @@ export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
   private isReady: boolean = false;
   private pendingRequests: Map<number, { resolve: (val: any) => void; reject: (err: any) => void }> = new Map();
   private requestCounter: number = 0;
-  private cleanup: () => void = () => {}; // Dynamic cleanup callback
+  private cleanup: () => void = () => { }; // Dynamic cleanup callback
 
   async initialize(): Promise<void> {
     if (this.isReady) return;
 
     return new Promise((resolve, reject) => {
       try {
-        const scriptPath = path.join(__dirname, 'gpu_bridge.py');
+        const scriptPath = path.join(currentDir, 'gpu_bridge.py');
         logger.info(`🔌 Starting GPU Bridge: python3 ${scriptPath}`);
 
         this.process = spawn('python3', [scriptPath]);
@@ -33,10 +37,10 @@ export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
           const lines = data.toString().split('\n');
           for (const line of lines) {
             if (!line.trim()) continue;
-            
+
             try {
               const response = JSON.parse(line);
-              
+
               // Initial Ready Signal
               if (response.status === 'ready') {
                 logger.info(`🚀 GPU Bridge Ready on device: ${response.device}`);
@@ -49,10 +53,10 @@ export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
               // For a more robust solution with concurrency, we'd need Request IDs
               // But for this implementation, we assume one request at a time via the Service lock
               // or we rely on the strictly ordered stdio.
-              
+
               // NOTE: This simplified implementation assumes sequential processing (awaiting each call)
               // which matches the current usage in EmbeddingService.
-              
+
             } catch (e) {
               logger.error(`GPU Bridge parse error: ${e} [Line: ${line}]`);
             }
@@ -76,11 +80,11 @@ export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
 
         // Timeout backup
         setTimeout(() => {
-            if (!this.isReady) {
-                // If it takes too long, we might just be downloading the model (can take time)
-                // So we don't reject immediately, but warn.
-                logger.warn('⏳ GPU Bridge taking longer than expected (model download?)...');
-            }
+          if (!this.isReady) {
+            // If it takes too long, we might just be downloading the model (can take time)
+            // So we don't reject immediately, but warn.
+            logger.warn('⏳ GPU Bridge taking longer than expected (model download?)...');
+          }
         }, 10000);
 
       } catch (error) {
@@ -95,43 +99,43 @@ export class LocalGPUEmbeddingsProvider implements EmbeddingProvider {
   // We just need to ensure we don't interleave writes before reads are done.
   private async execute<T>(payload: any): Promise<T> {
     if (!this.process || !this.isReady) {
-       await this.initialize();
+      await this.initialize();
     }
 
     return new Promise((resolve, reject) => {
-        // Simple one-off listener for the next line of output
-        // This assumes strictly sequential execution provided by the await in the caller
-        const listener = (data: Buffer) => {
-            const lines = data.toString().split('\n').filter(l => l.trim());
-            for (const line of lines) {
-                try {
-                    const response = JSON.parse(line);
-                    // Ignore status messages if they appear late
-                    if (response.status) continue; 
-                    
-                    if (response.error) {
-                        this.cleanup();
-                        reject(new Error(response.error));
-                    } else {
-                        this.cleanup();
-                        resolve(response);
-                    }
-                    return; // Handled
-                } catch (e) {
-                   // partial line? wait for next chunk
-                }
+      // Simple one-off listener for the next line of output
+      // This assumes strictly sequential execution provided by the await in the caller
+      const listener = (data: Buffer) => {
+        const lines = data.toString().split('\n').filter(l => l.trim());
+        for (const line of lines) {
+          try {
+            const response = JSON.parse(line);
+            // Ignore status messages if they appear late
+            if (response.status) continue;
+
+            if (response.error) {
+              this.cleanup();
+              reject(new Error(response.error));
+            } else {
+              this.cleanup();
+              resolve(response);
             }
-        };
-
-        const cleanup = () => {
-            this.process?.stdout?.off('data', listener);
-            this.cleanup = () => {}; // prevent double call
-        };
-        // Store cleanup on this scope so the listener callback can call it
-        (this as any).cleanup = cleanup; 
-
-        this.process!.stdout!.on('data', listener);
-        this.process!.stdin!.write(JSON.stringify(payload) + '\n');
+            return; // Handled
+          } catch (e) {
+            // partial line? wait for next chunk
+          }
+        }
+      };
+
+      const cleanup = () => {
+        this.process?.stdout?.off('data', listener);
+        this.cleanup = () => { }; // prevent double call
+      };
+      // Store cleanup on this scope so the listener callback can call it
+      (this as any).cleanup = cleanup;
+
+      this.process!.stdout!.on('data', listener);
+      this.process!.stdin!.write(JSON.stringify(payload) + '\n');
     });
   }
 

apps/backend/src/tests/autonomous.integration.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
 import { initializeDatabase, getDatabase, getSqlJsDatabase } from '../database/index.js';
+import { SqlJsStorageAdapter } from '../mcp/memory/StorageAdapter.js';
 
 // Mock Embeddings to avoid ONNX/Float32Array issues in tests
 vi.mock('../platform/embeddings/TransformersEmbeddings', () => ({
@@ -85,7 +86,7 @@ describe('PatternMemory - Enterprise Persistence', () => {
 
     beforeEach(async () => {
         const { PatternMemory } = await import('../mcp/memory/PatternMemory.js');
-        patternMemory = new PatternMemory(db);
+        patternMemory = new PatternMemory(new SqlJsStorageAdapter(db));
     });
 
     it('should record query patterns', async () => {
@@ -212,7 +213,7 @@ describe('FailureMemory - Self-Healing Intelligence', () => {
 
     beforeEach(async () => {
         const { FailureMemory } = await import('../mcp/memory/FailureMemory.js');
-        failureMemory = new FailureMemory(db);
+        failureMemory = new FailureMemory(new SqlJsStorageAdapter(db));
     });
 
     it('should record failures with context', async () => {

package-lock.json

@@ -115,11 +115,48 @@
         "@types/uuid": "^9.0.7",
         "@types/ws": "^8.5.10",
         "@types/xml2js": "^0.4.14",
+        "@typescript-eslint/eslint-plugin": "^7.16.0",
+        "@typescript-eslint/parser": "^7.16.0",
         "esbuild": "^0.24.2",
+        "eslint": "^8.57.0",
         "tsx": "^4.20.6",
         "typescript": "~5.8.2"
       }
     },
+    "apps/backend/node_modules/@eslint/eslintrc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz",
+      "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^9.6.0",
+        "globals": "^13.19.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.0",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "apps/backend/node_modules/@eslint/js": {
+      "version": "8.57.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.0.tgz",
+      "integrity": "sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
     "apps/backend/node_modules/@napi-rs/canvas": {
       "version": "0.1.84",
       "license": "MIT",
@@ -151,6 +188,473 @@
         "undici-types": "~6.21.0"
       }
     },
+    "apps/backend/node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-7.16.0.tgz",
+      "integrity": "sha512-py1miT6iQpJcs1BiJjm54AMzeuMPBSPuKPlnT8HlfudbcS5rYeX5jajpLf3mrdRh9dA/Ec2FVUY0ifeVNDIhZw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.10.0",
+        "@typescript-eslint/scope-manager": "7.16.0",
+        "@typescript-eslint/type-utils": "7.16.0",
+        "@typescript-eslint/utils": "7.16.0",
+        "@typescript-eslint/visitor-keys": "7.16.0",
+        "graphemer": "^1.4.0",
+        "ignore": "^5.3.1",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^1.3.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^7.0.0",
+        "eslint": "^8.56.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/eslint-plugin/node_modules/ts-api-utils": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz",
+      "integrity": "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.2.0"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/parser": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-7.16.0.tgz",
+      "integrity": "sha512-ar9E+k7CU8rWi2e5ErzQiC93KKEFAXA2Kky0scAlPcxYblLt8+XZuHUZwlyfXILyQa95P6lQg+eZgh/dDs3+Vw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "7.16.0",
+        "@typescript-eslint/types": "7.16.0",
+        "@typescript-eslint/typescript-estree": "7.16.0",
+        "@typescript-eslint/visitor-keys": "7.16.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.56.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/scope-manager": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-7.16.0.tgz",
+      "integrity": "sha512-8gVv3kW6n01Q6TrI1cmTZ9YMFi3ucDT7i7aI5lEikk2ebk1AEjrwX8MDTdaX5D7fPXMBLvnsaa0IFTAu+jcfOw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "7.16.0",
+        "@typescript-eslint/visitor-keys": "7.16.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/type-utils": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-7.16.0.tgz",
+      "integrity": "sha512-j0fuUswUjDHfqV/UdW6mLtOQQseORqfdmoBNDFOqs9rvNVR2e+cmu6zJu/Ku4SDuqiJko6YnhwcL8x45r8Oqxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/typescript-estree": "7.16.0",
+        "@typescript-eslint/utils": "7.16.0",
+        "debug": "^4.3.4",
+        "ts-api-utils": "^1.3.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.56.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/type-utils/node_modules/ts-api-utils": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz",
+      "integrity": "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.2.0"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-7.16.0.tgz",
+      "integrity": "sha512-fecuH15Y+TzlUutvUl9Cc2XJxqdLr7+93SQIbcZfd4XRGGKoxyljK27b+kxKamjRkU7FYC6RrbSCg0ALcZn/xw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/typescript-estree": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-7.16.0.tgz",
+      "integrity": "sha512-a5NTvk51ZndFuOLCh5OaJBELYc2O3Zqxfl3Js78VFE1zE46J2AaVuW+rEbVkQznjkmlzWsUI15BG5tQMixzZLw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@typescript-eslint/types": "7.16.0",
+        "@typescript-eslint/visitor-keys": "7.16.0",
+        "debug": "^4.3.4",
+        "globby": "^11.1.0",
+        "is-glob": "^4.0.3",
+        "minimatch": "^9.0.4",
+        "semver": "^7.6.0",
+        "ts-api-utils": "^1.3.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/typescript-estree/node_modules/ts-api-utils": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz",
+      "integrity": "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.2.0"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/utils": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-7.16.0.tgz",
+      "integrity": "sha512-PqP4kP3hb4r7Jav+NiRCntlVzhxBNWq6ZQ+zQwII1y/G/1gdIPeYDCKr2+dH6049yJQsWZiHU6RlwvIFBXXGNA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.4.0",
+        "@typescript-eslint/scope-manager": "7.16.0",
+        "@typescript-eslint/types": "7.16.0",
+        "@typescript-eslint/typescript-estree": "7.16.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.56.0"
+      }
+    },
+    "apps/backend/node_modules/@typescript-eslint/visitor-keys": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-7.16.0.tgz",
+      "integrity": "sha512-rMo01uPy9C7XxG7AFsxa8zLnWXTF8N3PYclekWSrurvhwiw1eW88mrKiAYe6s53AUY57nTRz8dJsuuXdkAhzCg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "7.16.0",
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "apps/backend/node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "apps/backend/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "apps/backend/node_modules/doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "esutils": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "apps/backend/node_modules/eslint": {
+      "version": "8.57.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.0.tgz",
+      "integrity": "sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==",
+      "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.2.0",
+        "@eslint-community/regexpp": "^4.6.1",
+        "@eslint/eslintrc": "^2.1.4",
+        "@eslint/js": "8.57.0",
+        "@humanwhocodes/config-array": "^0.11.14",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@nodelib/fs.walk": "^1.2.8",
+        "@ungap/structured-clone": "^1.2.0",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.2",
+        "debug": "^4.3.2",
+        "doctrine": "^3.0.0",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^7.2.2",
+        "eslint-visitor-keys": "^3.4.3",
+        "espree": "^9.6.1",
+        "esquery": "^1.4.2",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^6.0.1",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "globals": "^13.19.0",
+        "graphemer": "^1.4.0",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "is-path-inside": "^3.0.3",
+        "js-yaml": "^4.1.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "levn": "^0.4.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3",
+        "strip-ansi": "^6.0.1",
+        "text-table": "^0.2.0"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "apps/backend/node_modules/eslint-scope": {
+      "version": "7.2.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
+      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "apps/backend/node_modules/espree": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
+      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.9.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^3.4.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "apps/backend/node_modules/file-entry-cache": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
+      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^3.0.4"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "apps/backend/node_modules/flat-cache": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
+      "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.3",
+        "rimraf": "^3.0.2"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "apps/backend/node_modules/globals": {
+      "version": "13.24.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
+      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^0.20.2"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "apps/backend/node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "apps/backend/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "apps/backend/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "apps/backend/node_modules/pdfjs-dist": {
       "version": "5.4.449",
       "license": "Apache-2.0",
@@ -161,6 +665,36 @@
         "@napi-rs/canvas": "^0.1.81"
       }
     },
+    "apps/backend/node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "apps/backend/node_modules/type-fest": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "apps/backend/packages/domain-types": {
       "name": "@widget-tdc/domain-types",
       "version": "1.0.0",
@@ -3325,6 +3859,46 @@
         "node": ">=18.18.0"
       }
     },
+    "node_modules/@humanwhocodes/config-array": {
+      "version": "0.11.14",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.14.tgz",
+      "integrity": "sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==",
+      "deprecated": "Use @eslint/config-array instead",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanwhocodes/object-schema": "^2.0.2",
+        "debug": "^4.3.1",
+        "minimatch": "^3.0.5"
+      },
+      "engines": {
+        "node": ">=10.10.0"
+      }
+    },
+    "node_modules/@humanwhocodes/config-array/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@humanwhocodes/config-array/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/@humanwhocodes/module-importer": {
       "version": "1.0.1",
       "dev": true,
@@ -3337,6 +3911,14 @@
         "url": "https://github.com/sponsors/nzakas"
       }
     },
+    "node_modules/@humanwhocodes/object-schema": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz",
+      "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==",
+      "deprecated": "Use @eslint/object-schema instead",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
     "node_modules/@humanwhocodes/retry": {
       "version": "0.4.3",
       "dev": true,
@@ -7500,6 +8082,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/array-union": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
+      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/array.prototype.findlast": {
       "version": "1.2.5",
       "dev": true,
@@ -9638,6 +10230,19 @@
         "node": ">=0.3.1"
       }
     },
+    "node_modules/dir-glob": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
+      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-type": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/dlv": {
       "version": "1.1.3",
       "license": "MIT"
@@ -11885,6 +12490,37 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/globby": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
+      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "array-union": "^2.1.0",
+        "dir-glob": "^3.0.1",
+        "fast-glob": "^3.2.9",
+        "ignore": "^5.2.0",
+        "merge2": "^1.4.1",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/globby/node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/gopd": {
       "version": "1.2.0",
       "license": "MIT",
@@ -12655,6 +13291,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-plain-obj": {
       "version": "4.1.0",
       "license": "MIT",
@@ -17154,6 +17800,16 @@
         "node": ">=18"
       }
     },
+    "node_modules/slash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/smart-buffer": {
       "version": "4.2.0",
       "license": "MIT",
@@ -17999,6 +18655,13 @@
       "version": "1.0.0",
       "license": "MIT"
     },
+    "node_modules/text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/thenify": {
       "version": "3.3.1",
       "license": "MIT",