agentic-qe 3.6.6 → 3.6.8

package/v3/dist/mcp/bundle.js

@@ -4179,6 +4179,10 @@ var init_sql_safety = __esm({
       "mincut_observations",
       // SONA tables
       "sona_patterns",
+      // Feedback loop tables
+      "test_outcomes",
+      "routing_outcomes",
+      "coverage_sessions",
       // Sync tables
       "patterns",
       // Hypergraph tables
@@ -5123,12 +5127,16 @@ function findProjectRoot(startDir = process.cwd()) {
   let dir = startDir;
   const root = path.parse(dir).root;
   let checkDir = dir;
+  let topmostAqeDir = null;
   while (checkDir !== root) {
     if (fs.existsSync(path.join(checkDir, ".agentic-qe"))) {
-      return checkDir;
+      topmostAqeDir = checkDir;
     }
     checkDir = path.dirname(checkDir);
   }
+  if (topmostAqeDir) {
+    return topmostAqeDir;
+  }
   checkDir = dir;
   while (checkDir !== root) {
     if (fs.existsSync(path.join(checkDir, ".git"))) {
@@ -5193,7 +5201,7 @@ function registerExitHandlers() {
     process.exit(0);
   });
 }
-var DEFAULT_UNIFIED_MEMORY_CONFIG, SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, BinaryHeap, InMemoryHNSWIndex, UnifiedMemoryManager, exitHandlersRegistered;
+var DEFAULT_UNIFIED_MEMORY_CONFIG, SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, FEEDBACK_SCHEMA, BinaryHeap, InMemoryHNSWIndex, UnifiedMemoryManager, exitHandlersRegistered;
 var init_unified_memory = __esm({
   "src/kernel/unified-memory.ts"() {
     "use strict";
@@ -5213,7 +5221,7 @@ var init_unified_memory = __esm({
       busyTimeout: MEMORY_CONSTANTS.BUSY_TIMEOUT_MS,
       vectorDimensions: MEMORY_CONSTANTS.DEFAULT_VECTOR_DIMENSIONS
     };
-    SCHEMA_VERSION = 7;
+    SCHEMA_VERSION = 8;
     SCHEMA_VERSION_TABLE = `
   CREATE TABLE IF NOT EXISTS schema_version (
     id INTEGER PRIMARY KEY CHECK (id = 1),
@@ -5684,6 +5692,81 @@ var init_unified_memory = __esm({
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_domain ON sona_patterns(domain);
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_confidence ON sona_patterns(confidence DESC);
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_updated ON sona_patterns(updated_at DESC);
+`;
+    FEEDBACK_SCHEMA = `
+  -- Test outcomes (ADR-023: Quality Feedback Loop)
+  CREATE TABLE IF NOT EXISTS test_outcomes (
+    id TEXT PRIMARY KEY,
+    test_id TEXT NOT NULL,
+    test_name TEXT NOT NULL,
+    generated_by TEXT NOT NULL,
+    pattern_id TEXT,
+    framework TEXT NOT NULL,
+    language TEXT NOT NULL,
+    domain TEXT NOT NULL,
+    passed INTEGER NOT NULL,
+    error_message TEXT,
+    coverage_lines REAL DEFAULT 0,
+    coverage_branches REAL DEFAULT 0,
+    coverage_functions REAL DEFAULT 0,
+    mutation_score REAL,
+    execution_time_ms REAL NOT NULL,
+    flaky INTEGER DEFAULT 0,
+    flakiness_score REAL,
+    maintainability_score REAL NOT NULL,
+    complexity REAL,
+    lines_of_code INTEGER,
+    assertion_count INTEGER,
+    file_path TEXT,
+    source_file_path TEXT,
+    metadata_json TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_test_outcomes_pattern ON test_outcomes(pattern_id);
+  CREATE INDEX IF NOT EXISTS idx_test_outcomes_agent ON test_outcomes(generated_by);
+  CREATE INDEX IF NOT EXISTS idx_test_outcomes_domain ON test_outcomes(domain);
+  CREATE INDEX IF NOT EXISTS idx_test_outcomes_created ON test_outcomes(created_at);
+
+  -- Routing outcomes (ADR-022: Adaptive QE Agent Routing)
+  CREATE TABLE IF NOT EXISTS routing_outcomes (
+    id TEXT PRIMARY KEY,
+    task_json TEXT NOT NULL,
+    decision_json TEXT NOT NULL,
+    used_agent TEXT NOT NULL,
+    followed_recommendation INTEGER NOT NULL,
+    success INTEGER NOT NULL,
+    quality_score REAL NOT NULL,
+    duration_ms REAL NOT NULL,
+    error TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_routing_outcomes_agent ON routing_outcomes(used_agent);
+  CREATE INDEX IF NOT EXISTS idx_routing_outcomes_created ON routing_outcomes(created_at);
+
+  -- Coverage sessions (ADR-023: Coverage Learning)
+  CREATE TABLE IF NOT EXISTS coverage_sessions (
+    id TEXT PRIMARY KEY,
+    target_path TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    technique TEXT NOT NULL,
+    before_lines REAL DEFAULT 0,
+    before_branches REAL DEFAULT 0,
+    before_functions REAL DEFAULT 0,
+    after_lines REAL DEFAULT 0,
+    after_branches REAL DEFAULT 0,
+    after_functions REAL DEFAULT 0,
+    tests_generated INTEGER DEFAULT 0,
+    tests_passed INTEGER DEFAULT 0,
+    gaps_json TEXT,
+    duration_ms REAL NOT NULL,
+    started_at TEXT NOT NULL,
+    completed_at TEXT NOT NULL,
+    context_json TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_coverage_sessions_technique ON coverage_sessions(technique);
+  CREATE INDEX IF NOT EXISTS idx_coverage_sessions_agent ON coverage_sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_coverage_sessions_created ON coverage_sessions(created_at);
 `;
     BinaryHeap = class {
       data = [];
@@ -6023,6 +6106,7 @@ var init_unified_memory = __esm({
       db = null;
       config;
       initialized = false;
+      vectorsLoaded = false;
       initPromise = null;
       preparedStatements = /* @__PURE__ */ new Map();
       vectorIndex = new InMemoryHNSWIndex();
@@ -6031,6 +6115,10 @@ var init_unified_memory = __esm({
       constructor(config) {
         const resolvedDefaults = getResolvedDefaultConfig();
         this.config = { ...resolvedDefaults, ...config };
+        if (!path.isAbsolute(this.config.dbPath)) {
+          const projectRoot = findProjectRoot();
+          this.config.dbPath = path.join(projectRoot, this.config.dbPath);
+        }
       }
       /**
        * Get or create the singleton instance (synchronous).
@@ -6100,7 +6188,7 @@ var init_unified_memory = __esm({
           this.db.pragma(`busy_timeout = ${this.config.busyTimeout}`);
           this.db.pragma("foreign_keys = ON");
           await this.runMigrations();
-          await this.loadVectorIndex();
+          this.vectorsLoaded = false;
           this.initialized = true;
           console.log(`[UnifiedMemory] Initialized: ${this.config.dbPath}`);
           this.warnIfDuplicateDatabases();
@@ -6221,6 +6309,9 @@ var init_unified_memory = __esm({
             if (currentVersion < 7) {
               this.db.exec(SONA_PATTERNS_SCHEMA);
             }
+            if (currentVersion < 8) {
+              this.db.exec(FEEDBACK_SCHEMA);
+            }
             this.db.prepare(`
           INSERT OR REPLACE INTO schema_version (id, version, migrated_at)
           VALUES (1, ?, datetime('now'))
@@ -6234,6 +6325,7 @@ var init_unified_memory = __esm({
        * Load all vectors from SQLite into HNSW index
        */
       async loadVectorIndex() {
+        if (this.vectorsLoaded) return;
         if (!this.db) throw new Error("Database not initialized");
         this.vectorIndex.clear();
         const rows = this.db.prepare(
@@ -6243,6 +6335,7 @@ var init_unified_memory = __esm({
           const embedding = this.bufferToFloatArray(row2.embedding, row2.dimensions);
           this.vectorIndex.add(row2.id, embedding);
         }
+        this.vectorsLoaded = true;
         console.log(`[UnifiedMemory] Loaded ${rows.length} vectors into HNSW index`);
       }
       // ============================================================================
@@ -6366,6 +6459,9 @@ var init_unified_memory = __esm({
        */
       async vectorSearch(query, k68 = 10, namespace) {
         this.ensureInitialized();
+        if (!this.vectorsLoaded) {
+          await this.loadVectorIndex();
+        }
         const results = this.vectorIndex.search(query, k68 * 2);
         if (results.length === 0) return [];
         const ids = results.map((r54) => r54.id);
@@ -6988,6 +7084,211 @@ var init_real_embeddings = __esm({
   }
 });
 
+// src/kernel/unified-persistence.ts
+function getUnifiedPersistence(config) {
+  return UnifiedPersistenceManager.getInstance(config);
+}
+async function initializeUnifiedPersistence(config) {
+  const manager = getUnifiedPersistence(config);
+  await manager.initialize();
+  return manager;
+}
+function registerExitHandlers2() {
+  if (exitHandlersRegistered2) return;
+  exitHandlersRegistered2 = true;
+  const cleanup = () => {
+    try {
+      const instance3 = UnifiedPersistenceManager["instance"];
+      if (instance3) {
+        instance3.close();
+      }
+    } catch (error) {
+      console.debug("[UnifiedPersistence] Cleanup error:", error instanceof Error ? error.message : error);
+    }
+  };
+  process.on("beforeExit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+var DEFAULT_UNIFIED_CONFIG, UnifiedPersistenceManager, exitHandlersRegistered2;
+var init_unified_persistence = __esm({
+  "src/kernel/unified-persistence.ts"() {
+    "use strict";
+    init_unified_memory();
+    DEFAULT_UNIFIED_CONFIG = {
+      dbPath: DEFAULT_UNIFIED_MEMORY_CONFIG.dbPath,
+      // '.agentic-qe/memory.db'
+      walMode: true,
+      mmapSize: 64 * 1024 * 1024,
+      // 64MB
+      cacheSize: -32e3,
+      // 32MB
+      busyTimeout: 5e3
+    };
+    UnifiedPersistenceManager = class _UnifiedPersistenceManager {
+      static instance = null;
+      static instancePromise = null;
+      unifiedMemory = null;
+      config;
+      initialized = false;
+      initPromise = null;
+      constructor(config) {
+        this.config = { ...DEFAULT_UNIFIED_CONFIG, ...config };
+      }
+      /**
+       * Get or create the singleton instance (synchronous).
+       * Thread-safe: JS is single-threaded for synchronous code.
+       */
+      static getInstance(config) {
+        if (_UnifiedPersistenceManager.instance) {
+          return _UnifiedPersistenceManager.instance;
+        }
+        _UnifiedPersistenceManager.instance = new _UnifiedPersistenceManager(config);
+        return _UnifiedPersistenceManager.instance;
+      }
+      /**
+       * Get or create the singleton instance with async initialization.
+       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
+       */
+      static async getInstanceAsync(config) {
+        if (_UnifiedPersistenceManager.instance?.initialized) {
+          return _UnifiedPersistenceManager.instance;
+        }
+        if (!_UnifiedPersistenceManager.instancePromise) {
+          _UnifiedPersistenceManager.instancePromise = (async () => {
+            const instance3 = _UnifiedPersistenceManager.getInstance(config);
+            await instance3.initialize();
+            return instance3;
+          })();
+        }
+        return _UnifiedPersistenceManager.instancePromise;
+      }
+      /**
+       * Reset the singleton (for testing)
+       */
+      static resetInstance() {
+        if (_UnifiedPersistenceManager.instance) {
+          _UnifiedPersistenceManager.instance.close();
+          _UnifiedPersistenceManager.instance = null;
+        }
+        _UnifiedPersistenceManager.instancePromise = null;
+        resetUnifiedMemory();
+      }
+      /**
+       * Initialize the database and create all schemas.
+       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
+       */
+      async initialize() {
+        if (this.initialized) return;
+        if (!this.initPromise) {
+          this.initPromise = this._doInitialize();
+        }
+        return this.initPromise;
+      }
+      /**
+       * Internal initialization implementation
+       */
+      async _doInitialize() {
+        if (this.initialized) return;
+        try {
+          const memoryConfig = {
+            dbPath: this.config.dbPath,
+            walMode: this.config.walMode,
+            busyTimeout: this.config.busyTimeout,
+            mmapSize: this.config.mmapSize,
+            cacheSize: this.config.cacheSize
+          };
+          this.unifiedMemory = getUnifiedMemory(memoryConfig);
+          await this.unifiedMemory.initialize();
+          this.initialized = true;
+          console.log(`[UnifiedPersistence] Initialized via UnifiedMemoryManager: ${this.config.dbPath}`);
+        } catch (error) {
+          this.initPromise = null;
+          throw new Error(
+            `Failed to initialize UnifiedPersistenceManager: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Get the raw database connection for advanced operations
+       */
+      getDatabase() {
+        if (!this.unifiedMemory || !this.initialized) {
+          throw new Error("UnifiedPersistenceManager not initialized");
+        }
+        return this.unifiedMemory.getDatabase();
+      }
+      /**
+       * Check if initialized
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the database path
+       */
+      getDbPath() {
+        return this.config.dbPath;
+      }
+      /**
+       * Prepare and cache a statement
+       */
+      prepare(name, sql) {
+        if (!this.unifiedMemory) throw new Error("Database not initialized");
+        return this.unifiedMemory.prepare(name, sql);
+      }
+      /**
+       * Execute a transaction
+       */
+      transaction(fn) {
+        if (!this.unifiedMemory) throw new Error("Database not initialized");
+        return this.unifiedMemory.transaction(fn);
+      }
+      /**
+       * Get database statistics
+       */
+      getStats() {
+        if (!this.unifiedMemory) throw new Error("Database not initialized");
+        const memStats = this.unifiedMemory.getStats();
+        return {
+          tables: memStats.tables,
+          fileSize: memStats.fileSize,
+          walSize: memStats.walSize
+        };
+      }
+      /**
+       * Vacuum the database to reclaim space
+       */
+      vacuum() {
+        const db = this.getDatabase();
+        db.exec("VACUUM");
+      }
+      /**
+       * Checkpoint WAL to main database
+       */
+      checkpoint() {
+        const db = this.getDatabase();
+        db.pragma("wal_checkpoint(TRUNCATE)");
+      }
+      /**
+       * Close the database connection
+       */
+      close() {
+        this.initialized = false;
+        console.log("[UnifiedPersistence] Facade closed");
+      }
+    };
+    exitHandlersRegistered2 = false;
+    registerExitHandlers2();
+  }
+});
+
 // src/coordination/consensus/model-provider.ts
 function buildVerificationPrompt(finding, options = {}) {
   const {
@@ -9416,206 +9717,6 @@ var init_sona_wrapper = __esm({
   }
 });
 
-// src/kernel/unified-persistence.ts
-function getUnifiedPersistence(config) {
-  return UnifiedPersistenceManager.getInstance(config);
-}
-function registerExitHandlers2() {
-  if (exitHandlersRegistered2) return;
-  exitHandlersRegistered2 = true;
-  const cleanup = () => {
-    try {
-      const instance3 = UnifiedPersistenceManager["instance"];
-      if (instance3) {
-        instance3.close();
-      }
-    } catch (error) {
-      console.debug("[UnifiedPersistence] Cleanup error:", error instanceof Error ? error.message : error);
-    }
-  };
-  process.on("beforeExit", cleanup);
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    cleanup();
-    process.exit(0);
-  });
-}
-var DEFAULT_UNIFIED_CONFIG, UnifiedPersistenceManager, exitHandlersRegistered2;
-var init_unified_persistence = __esm({
-  "src/kernel/unified-persistence.ts"() {
-    "use strict";
-    init_unified_memory();
-    DEFAULT_UNIFIED_CONFIG = {
-      dbPath: DEFAULT_UNIFIED_MEMORY_CONFIG.dbPath,
-      // '.agentic-qe/memory.db'
-      walMode: true,
-      mmapSize: 64 * 1024 * 1024,
-      // 64MB
-      cacheSize: -32e3,
-      // 32MB
-      busyTimeout: 5e3
-    };
-    UnifiedPersistenceManager = class _UnifiedPersistenceManager {
-      static instance = null;
-      static instancePromise = null;
-      unifiedMemory = null;
-      config;
-      initialized = false;
-      initPromise = null;
-      constructor(config) {
-        this.config = { ...DEFAULT_UNIFIED_CONFIG, ...config };
-      }
-      /**
-       * Get or create the singleton instance (synchronous).
-       * Thread-safe: JS is single-threaded for synchronous code.
-       */
-      static getInstance(config) {
-        if (_UnifiedPersistenceManager.instance) {
-          return _UnifiedPersistenceManager.instance;
-        }
-        _UnifiedPersistenceManager.instance = new _UnifiedPersistenceManager(config);
-        return _UnifiedPersistenceManager.instance;
-      }
-      /**
-       * Get or create the singleton instance with async initialization.
-       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
-       */
-      static async getInstanceAsync(config) {
-        if (_UnifiedPersistenceManager.instance?.initialized) {
-          return _UnifiedPersistenceManager.instance;
-        }
-        if (!_UnifiedPersistenceManager.instancePromise) {
-          _UnifiedPersistenceManager.instancePromise = (async () => {
-            const instance3 = _UnifiedPersistenceManager.getInstance(config);
-            await instance3.initialize();
-            return instance3;
-          })();
-        }
-        return _UnifiedPersistenceManager.instancePromise;
-      }
-      /**
-       * Reset the singleton (for testing)
-       */
-      static resetInstance() {
-        if (_UnifiedPersistenceManager.instance) {
-          _UnifiedPersistenceManager.instance.close();
-          _UnifiedPersistenceManager.instance = null;
-        }
-        _UnifiedPersistenceManager.instancePromise = null;
-        resetUnifiedMemory();
-      }
-      /**
-       * Initialize the database and create all schemas.
-       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
-       */
-      async initialize() {
-        if (this.initialized) return;
-        if (!this.initPromise) {
-          this.initPromise = this._doInitialize();
-        }
-        return this.initPromise;
-      }
-      /**
-       * Internal initialization implementation
-       */
-      async _doInitialize() {
-        if (this.initialized) return;
-        try {
-          const memoryConfig = {
-            dbPath: this.config.dbPath,
-            walMode: this.config.walMode,
-            busyTimeout: this.config.busyTimeout,
-            mmapSize: this.config.mmapSize,
-            cacheSize: this.config.cacheSize
-          };
-          this.unifiedMemory = getUnifiedMemory(memoryConfig);
-          await this.unifiedMemory.initialize();
-          this.initialized = true;
-          console.log(`[UnifiedPersistence] Initialized via UnifiedMemoryManager: ${this.config.dbPath}`);
-        } catch (error) {
-          this.initPromise = null;
-          throw new Error(
-            `Failed to initialize UnifiedPersistenceManager: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      /**
-       * Get the raw database connection for advanced operations
-       */
-      getDatabase() {
-        if (!this.unifiedMemory || !this.initialized) {
-          throw new Error("UnifiedPersistenceManager not initialized");
-        }
-        return this.unifiedMemory.getDatabase();
-      }
-      /**
-       * Check if initialized
-       */
-      isInitialized() {
-        return this.initialized;
-      }
-      /**
-       * Get the database path
-       */
-      getDbPath() {
-        return this.config.dbPath;
-      }
-      /**
-       * Prepare and cache a statement
-       */
-      prepare(name, sql) {
-        if (!this.unifiedMemory) throw new Error("Database not initialized");
-        return this.unifiedMemory.prepare(name, sql);
-      }
-      /**
-       * Execute a transaction
-       */
-      transaction(fn) {
-        if (!this.unifiedMemory) throw new Error("Database not initialized");
-        return this.unifiedMemory.transaction(fn);
-      }
-      /**
-       * Get database statistics
-       */
-      getStats() {
-        if (!this.unifiedMemory) throw new Error("Database not initialized");
-        const memStats = this.unifiedMemory.getStats();
-        return {
-          tables: memStats.tables,
-          fileSize: memStats.fileSize,
-          walSize: memStats.walSize
-        };
-      }
-      /**
-       * Vacuum the database to reclaim space
-       */
-      vacuum() {
-        const db = this.getDatabase();
-        db.exec("VACUUM");
-      }
-      /**
-       * Checkpoint WAL to main database
-       */
-      checkpoint() {
-        const db = this.getDatabase();
-        db.pragma("wal_checkpoint(TRUNCATE)");
-      }
-      /**
-       * Close the database connection
-       */
-      close() {
-        this.initialized = false;
-        console.log("[UnifiedPersistence] Facade closed");
-      }
-    };
-    exitHandlersRegistered2 = false;
-    registerExitHandlers2();
-  }
-});
-
 // native-require:@ruvector/attention
 var attention_exports = {};
 __export(attention_exports, {
@@ -9720,6 +9821,7 @@ var init_attention_wrapper = __esm({
   "src/integrations/ruvector/attention-wrapper.ts"() {
     "use strict";
     init_attention();
+    init_unified_memory();
     QE_FLASH_ATTENTION_CONFIG = {
       "test-similarity": {
         dim: 384,
@@ -9833,11 +9935,19 @@ var init_attention_wrapper = __esm({
         }
       }
     };
-    QEFlashAttention = class {
+    QEFlashAttention = class _QEFlashAttention {
       attention;
       config;
       workload;
       metrics = [];
+      // kv_store persistence
+      db = null;
+      persistCount = 0;
+      static KV_NAMESPACE = "attention-metrics";
+      static KV_TTL = 3600;
+      // 1 hour
+      static PERSIST_INTERVAL = 10;
+      // every 10 operations
       constructor(workload, customConfig) {
         this.workload = workload;
         const baseConfig = QE_FLASH_ATTENTION_CONFIG[workload];
@@ -9848,10 +9958,18 @@ var init_attention_wrapper = __esm({
         this.attention = AttentionFactory.create(this.config);
       }
       /**
-       * Initialize Flash Attention
+       * Initialize Flash Attention and kv_store persistence
        * Note: @ruvector/attention doesn't require async initialization
        */
       async initialize() {
+        try {
+          this.db = getUnifiedMemory();
+          if (!this.db.isInitialized()) await this.db.initialize();
+          await this.loadFromKv();
+        } catch (error) {
+          console.warn("[QEFlashAttention] DB init failed, using memory-only:", error instanceof Error ? error.message : String(error));
+          this.db = null;
+        }
       }
       /**
        * Compute Flash Attention using @ruvector/attention
@@ -9896,6 +10014,7 @@ var init_attention_wrapper = __esm({
           throughput: seqLen * seqLen / ((endTime - startTime) / 1e3),
           peakMemoryMB: endMemory
         });
+        this.maybePersistToKv();
         return output;
       }
       /**
@@ -10062,6 +10181,49 @@ var init_attention_wrapper = __esm({
         this.metrics = [];
       }
       // ========================================================================
+      // kv_store Persistence
+      // ========================================================================
+      /**
+       * Persist metrics snapshot to kv_store
+       */
+      async persistToKv() {
+        if (!this.db) return;
+        const kvKey = `attention-metrics-${this.workload}`;
+        const snapshot = {
+          workload: this.workload,
+          metrics: this.metrics.slice(-50),
+          savedAt: Date.now()
+        };
+        await this.db.kvSet(
+          kvKey,
+          snapshot,
+          _QEFlashAttention.KV_NAMESPACE,
+          _QEFlashAttention.KV_TTL
+        );
+      }
+      /**
+       * Load metrics snapshot from kv_store
+       */
+      async loadFromKv() {
+        if (!this.db) return;
+        const kvKey = `attention-metrics-${this.workload}`;
+        const snapshot = await this.db.kvGet(kvKey, _QEFlashAttention.KV_NAMESPACE);
+        if (snapshot?.metrics?.length) {
+          this.metrics = snapshot.metrics;
+        }
+      }
+      /**
+       * Track operations and persist periodically
+       */
+      maybePersistToKv() {
+        this.persistCount++;
+        if (this.persistCount >= _QEFlashAttention.PERSIST_INTERVAL) {
+          this.persistCount = 0;
+          this.persistToKv().catch(() => {
+          });
+        }
+      }
+      // ========================================================================
       // Private Helper Methods
       // ========================================================================
       /**
@@ -10860,8 +11022,6 @@ var init_hnsw_index = __esm({
         const embedding = this.vectorToEmbedding(vector, key, metadata);
         this.ruvectorIndex.addEmbedding(embedding, label);
         this.vectorStore.set(key, vector);
-        const fullKey = this.buildKey(key);
-        await this.memory.storeVector(fullKey, vector, metadata);
         this.stats.insertOperations++;
         this.stats.vectorCount++;
       }
@@ -18305,31 +18465,6 @@ var init_pattern_store = __esm({
        * Load existing patterns from memory with timeout protection
        */
       async loadPatterns() {
-        try {
-          const timeoutMs = 5e3;
-          const searchPromise = this.memory.search(`${this.config.namespace}:pattern:*`, 1e4);
-          const timeoutPromise = new Promise(
-            (_56, reject) => setTimeout(() => reject(new Error("Pattern load timeout")), timeoutMs)
-          );
-          const keys = await Promise.race([searchPromise, timeoutPromise]);
-          const BATCH_SIZE = 50;
-          for (let i58 = 0; i58 < keys.length; i58 += BATCH_SIZE) {
-            const batch = keys.slice(i58, i58 + BATCH_SIZE);
-            const patterns = await Promise.all(
-              batch.map((key) => this.memory.get(key).catch(() => null))
-            );
-            for (const pattern of patterns) {
-              if (pattern) {
-                this.indexPattern(pattern);
-              }
-            }
-          }
-          if (this.patternCache.size > 0) {
-            console.log(`[PatternStore] Loaded ${this.patternCache.size} patterns`);
-          }
-        } catch (error) {
-          console.log(`[PatternStore] Starting fresh (no existing patterns loaded): ${error instanceof Error ? error.message : "unknown error"}`);
-        }
       }
       /**
        * Index a pattern in local caches
@@ -18377,10 +18512,6 @@ var init_pattern_store = __esm({
         if (domainCount >= this.config.maxPatternsPerDomain) {
           await this.cleanupDomain(pattern.qeDomain);
         }
-        const key = `${this.config.namespace}:pattern:${pattern.id}`;
-        await this.memory.set(key, pattern, {
-          persist: true
-        });
         this.indexPattern(pattern);
         if (pattern.embedding) {
           const hnsw = await this.ensureHNSW();
@@ -18477,15 +18608,7 @@ var init_pattern_store = __esm({
         if (!this.initialized) {
           await this.initialize();
         }
-        const cached = this.patternCache.get(id);
-        if (cached) return cached;
-        const key = `${this.config.namespace}:pattern:${id}`;
-        const pattern = await this.memory.get(key);
-        if (pattern) {
-          this.indexPattern(pattern);
-          return pattern;
-        }
-        return null;
+        return this.patternCache.get(id) ?? null;
       }
       /**
        * Search for patterns
@@ -18682,10 +18805,6 @@ var init_pattern_store = __esm({
         if (shouldPromote && updated.tier === "short-term") {
           await this.promote(id);
         } else {
-          const key = `${this.config.namespace}:pattern:${id}`;
-          await this.memory.set(key, updated, {
-            persist: true
-          });
           this.patternCache.set(id, updated);
         }
         return ok(void 0);
@@ -18709,10 +18828,6 @@ var init_pattern_store = __esm({
         };
         this.tierIndex.get("short-term")?.delete(id);
         this.tierIndex.get("long-term")?.add(id);
-        const key = `${this.config.namespace}:pattern:${id}`;
-        await this.memory.set(key, promoted, {
-          persist: true
-        });
         this.patternCache.set(id, promoted);
         console.log(
           `[PatternStore] Promoted pattern ${id} (${pattern.name}) to long-term storage`
@@ -18728,8 +18843,6 @@ var init_pattern_store = __esm({
           return err(new Error(`Pattern not found: ${id}`));
         }
         this.unindexPattern(pattern);
-        const key = `${this.config.namespace}:pattern:${id}`;
-        await this.memory.delete(key);
         if (this.hnswIndex !== null) {
           try {
             await this.hnswIndex.delete(id);
@@ -18996,7 +19109,15 @@ var init_qe_reasoning_bank = __esm({
         await this.loadPretrainedPatterns();
         this.initialized = true;
         try {
-          await this.seedCrossDomainPatterns();
+          const SEED_FLAG_KEY = "reasoning-bank:cross-domain-seeded";
+          const alreadySeeded = await this.memory.get(SEED_FLAG_KEY);
+          if (!alreadySeeded) {
+            await this.memory.set(SEED_FLAG_KEY, true);
+            await this.seedCrossDomainPatterns();
+          } else {
+            const stats = await this.patternStore.getStats();
+            console.log(`[QEReasoningBank] Cross-domain transfer already complete (${stats.totalPatterns} patterns)`);
+          }
         } catch (error) {
           console.warn("[QEReasoningBank] Cross-domain seeding failed (non-fatal):", error);
         }
@@ -27914,13 +28035,13 @@ var PathTraversalValidator = class {
    */
   joinPathsAbsolute(...paths) {
     if (paths.length === 0) return "";
-    const isAbsolute5 = paths[0].startsWith("/");
+    const isAbsolute6 = paths[0].startsWith("/");
     const result = paths.map((p74) => {
       while (p74.startsWith("/")) p74 = p74.slice(1);
       while (p74.endsWith("/")) p74 = p74.slice(0, -1);
       return p74;
     }).filter(Boolean).join("/");
-    return isAbsolute5 ? `/${result}` : result;
+    return isAbsolute6 ? `/${result}` : result;
   }
   /**
    * Get file extension from path
@@ -30866,6 +30987,7 @@ var HybridMemoryBackend = class {
   unifiedMemory = null;
   config;
   cleanupInterval;
+  cleanupCount = 0;
   initialized = false;
   constructor(config) {
     this.config = {
@@ -31082,6 +31204,31 @@ var HybridMemoryBackend = class {
     if (this.unifiedMemory?.isInitialized()) {
       try {
         await this.unifiedMemory.kvCleanupExpired();
+        const db = this.unifiedMemory.getDatabase();
+        try {
+          const expired = db.prepare("DELETE FROM kv_store WHERE expires_at IS NOT NULL AND expires_at < ?").run(Date.now());
+          if (expired.changes > 0) {
+            console.log(`[HybridBackend] Expired ${expired.changes} kv_store entries`);
+          }
+        } catch (e20) {
+        }
+        this.cleanupCount++;
+        if (this.cleanupCount % 10 === 0) {
+          try {
+            const kvCount = db.prepare("SELECT COUNT(*) as cnt FROM kv_store").get();
+            if (kvCount.cnt > 5e3) {
+              const deleted = db.prepare(`
+                DELETE FROM kv_store WHERE rowid NOT IN (
+                  SELECT rowid FROM kv_store ORDER BY rowid DESC LIMIT 5000
+                )
+              `).run();
+              if (deleted.changes > 0) {
+                console.log(`[HybridBackend] kv_store retention: pruned ${deleted.changes} rows (kept 5000)`);
+              }
+            }
+          } catch (e20) {
+          }
+        }
       } catch (error) {
         console.warn("[HybridBackend] Cleanup failed:", error);
       }
@@ -31293,6 +31440,7 @@ var SemanticAntiDriftMiddleware = class {
 // src/kernel/kernel.ts
 init_constants();
 init_unified_memory();
+init_unified_persistence();
 import * as path12 from "path";
 import * as fs11 from "fs";
 
@@ -43320,11 +43468,19 @@ var isConstitutionalEnforcerEnabled = () => governanceFlags.isGateEnabled("const
 var isStrictMode = () => governanceFlags.getFlags().global.strictMode;
 
 // src/governance/continue-gate-integration.ts
-var ContinueGateIntegration = class {
+init_unified_memory();
+var ContinueGateIntegration = class _ContinueGateIntegration {
   actionHistory = /* @__PURE__ */ new Map();
   throttledAgents = /* @__PURE__ */ new Map();
   guidanceContinueGate = null;
   initialized = false;
+  db = null;
+  persistCount = 0;
+  static KV_NAMESPACE = "continue-gate-actions";
+  static KV_KEY = "snapshot";
+  static PERSIST_INTERVAL = 20;
+  static KV_TTL = 3600;
+  // 1 hour
   /**
    * Initialize the ContinueGate integration
    *
@@ -43335,8 +43491,48 @@ var ContinueGateIntegration = class {
    */
   async initialize() {
     if (this.initialized) return;
+    try {
+      this.db = getUnifiedMemory();
+      if (!this.db.isInitialized()) await this.db.initialize();
+      await this.loadFromKv();
+    } catch (error) {
+      console.warn("[ContinueGateIntegration] DB init failed, using memory-only:", error instanceof Error ? error.message : String(error));
+      this.db = null;
+    }
     this.initialized = true;
   }
+  async loadFromKv() {
+    if (!this.db) return;
+    const data = await this.db.kvGet(_ContinueGateIntegration.KV_KEY, _ContinueGateIntegration.KV_NAMESPACE);
+    if (data) {
+      for (const [agentId, actions] of data.actionHistory) {
+        this.actionHistory.set(agentId, actions);
+      }
+      const now = Date.now();
+      for (const [agentId, until] of data.throttledAgents) {
+        if (until > now) this.throttledAgents.set(agentId, until);
+      }
+      console.log("[ContinueGateIntegration] Loaded state from DB");
+    }
+  }
+  async persistSnapshot() {
+    if (!this.db) return;
+    try {
+      await this.db.kvSet(
+        _ContinueGateIntegration.KV_KEY,
+        {
+          actionHistory: Array.from(this.actionHistory.entries()).map(
+            ([agentId, actions]) => [agentId, actions.slice(-50)]
+          ),
+          throttledAgents: Array.from(this.throttledAgents.entries())
+        },
+        _ContinueGateIntegration.KV_NAMESPACE,
+        _ContinueGateIntegration.KV_TTL
+      );
+    } catch (error) {
+      console.warn("[ContinueGateIntegration] Persist failed:", error instanceof Error ? error.message : String(error));
+    }
+  }
   /**
    * Record an agent action for loop detection
    */
@@ -43348,6 +43544,11 @@ var ContinueGateIntegration = class {
       history.shift();
     }
     this.actionHistory.set(action.agentId, history);
+    this.persistCount++;
+    if (this.persistCount % _ContinueGateIntegration.PERSIST_INTERVAL === 0) {
+      this.persistSnapshot().catch(() => {
+      });
+    }
   }
   /**
    * Evaluate whether an agent should continue
@@ -44626,6 +44827,7 @@ var DeterministicGatewayIntegration = class {
 var deterministicGatewayIntegration = new DeterministicGatewayIntegration();
 
 // src/governance/evolution-pipeline-integration.ts
+init_unified_memory();
 function isEvolutionPipelineEnabled() {
   const flags = governanceFlags.getFlags();
   if (!flags.global.enableAllGates) return false;
@@ -44641,11 +44843,18 @@ function getEvolutionFlags() {
     learningRate: 0.1
   };
 }
-var EvolutionPipelineIntegration = class {
+var EvolutionPipelineIntegration = class _EvolutionPipelineIntegration {
   rules = /* @__PURE__ */ new Map();
   variantTests = /* @__PURE__ */ new Map();
   taskOutcomes = /* @__PURE__ */ new Map();
   initialized = false;
+  // KV persistence
+  db = null;
+  persistCount = 0;
+  static NAMESPACE = "rule-evolution";
+  static TTL_SECONDS = 604800;
+  // 7 days
+  static PERSIST_INTERVAL = 10;
   // Statistics
   stats = {
     autoPromotions: 0,
@@ -44663,6 +44872,14 @@ var EvolutionPipelineIntegration = class {
    */
   async initialize() {
     if (this.initialized) return;
+    try {
+      this.db = getUnifiedMemory();
+      if (!this.db.isInitialized()) await this.db.initialize();
+      await this.loadFromKv();
+    } catch (error) {
+      console.warn("[EvolutionPipeline] DB init failed, using memory-only:", error instanceof Error ? error.message : String(error));
+      this.db = null;
+    }
     this.initialized = true;
     this.logEvent("initialize", "Evolution Pipeline initialized");
   }
@@ -44684,6 +44901,7 @@ var EvolutionPipelineIntegration = class {
     record.applications.push(application);
     this.pruneApplicationHistory(record);
     this.checkAutoPromotionDemotion(ruleId);
+    this.persistSnapshot();
     this.logEvent("rule_application", `Rule ${ruleId} applied: ${success ? "success" : "failure"}`);
   }
   /**
@@ -45108,6 +45326,36 @@ var EvolutionPipelineIntegration = class {
     this.rules.delete(ruleId);
   }
   // ============================================================================
+  // KV Persistence
+  // ============================================================================
+  /**
+   * Load rules snapshot from KV store
+   */
+  async loadFromKv() {
+    if (!this.db) return;
+    const data = await this.db.kvGet("snapshot", _EvolutionPipelineIntegration.NAMESPACE);
+    if (data) {
+      for (const [key, record] of Object.entries(data)) {
+        this.rules.set(key, record);
+      }
+    }
+  }
+  /**
+   * Persist rules snapshot to KV store on interval
+   */
+  persistSnapshot() {
+    if (!this.db) return;
+    this.persistCount++;
+    if (this.persistCount % _EvolutionPipelineIntegration.PERSIST_INTERVAL !== 0) return;
+    try {
+      const snapshot = Object.fromEntries(this.rules);
+      this.db.kvSet("snapshot", snapshot, _EvolutionPipelineIntegration.NAMESPACE, _EvolutionPipelineIntegration.TTL_SECONDS).catch(() => {
+      });
+    } catch (error) {
+      console.warn("[EvolutionPipeline] Persist failed:", error instanceof Error ? error.message : String(error));
+    }
+  }
+  // ============================================================================
   // Private Helpers
   // ============================================================================
   /**
@@ -47452,6 +47700,7 @@ var ProofEnvelopeIntegration = class {
 var proofEnvelopeIntegration = new ProofEnvelopeIntegration();
 
 // src/governance/compliance-reporter.ts
+init_unified_memory();
 var DEFAULT_COMPLIANCE_REPORTER_FLAGS = {
   enabled: true,
   autoRecordViolations: true,
@@ -47468,7 +47717,7 @@ var SEVERITY_WEIGHTS = {
 var DEFAULT_SCORE = 100;
 var SCORE_DECAY_RATE = 0.5;
 var TREND_THRESHOLD = 5;
-var ComplianceReporter = class {
+var ComplianceReporter = class _ComplianceReporter {
   violations = /* @__PURE__ */ new Map();
   alertThresholds = /* @__PURE__ */ new Map();
   proofIntegration;
@@ -47476,6 +47725,13 @@ var ComplianceReporter = class {
   initialized = false;
   scoreHistory = [];
   alertListeners = /* @__PURE__ */ new Set();
+  // KV persistence
+  db = null;
+  persistCount = 0;
+  static NAMESPACE = "compliance-audit";
+  static TTL_SECONDS = 2592e3;
+  // 30 days
+  static PERSIST_INTERVAL = 10;
   /**
    * Create a new ComplianceReporter instance
    *
@@ -47491,6 +47747,14 @@ var ComplianceReporter = class {
    */
   async initialize() {
     if (this.initialized) return;
+    try {
+      this.db = getUnifiedMemory();
+      if (!this.db.isInitialized()) await this.db.initialize();
+      await this.loadFromKv();
+    } catch (error) {
+      console.warn("[ComplianceReporter] DB init failed, using memory-only:", error instanceof Error ? error.message : String(error));
+      this.db = null;
+    }
     if (!this.proofIntegration.isInitialized()) {
       await this.proofIntegration.initialize();
     }
@@ -47559,6 +47823,7 @@ var ComplianceReporter = class {
     if (this.flags.alertOnCritical && violation.severity === "critical") {
       this.triggerAlert(violation.gate, "Critical violation detected", "critical");
     }
+    this.persistSnapshot();
     this.cleanupOldViolations();
     return id;
   }
@@ -47988,6 +48253,45 @@ var ComplianceReporter = class {
     this.initialized = false;
   }
   // ============================================================================
+  // KV Persistence
+  // ============================================================================
+  /**
+   * Load violations and score history from KV store
+   */
+  async loadFromKv() {
+    if (!this.db) return;
+    const data = await this.db.kvGet("snapshot", _ComplianceReporter.NAMESPACE);
+    if (data) {
+      if (data.violations) {
+        for (const [key, violation] of Object.entries(data.violations)) {
+          this.violations.set(key, violation);
+        }
+      }
+      if (data.scoreHistory) {
+        this.scoreHistory = data.scoreHistory;
+      }
+    }
+  }
+  /**
+   * Persist violations and score history to KV store on interval
+   */
+  persistSnapshot() {
+    if (!this.db) return;
+    this.persistCount++;
+    if (this.persistCount % _ComplianceReporter.PERSIST_INTERVAL !== 0) return;
+    try {
+      const violationEntries = Array.from(this.violations.entries()).slice(-500);
+      const snapshot = {
+        violations: Object.fromEntries(violationEntries),
+        scoreHistory: this.scoreHistory.slice(-100)
+      };
+      this.db.kvSet("snapshot", snapshot, _ComplianceReporter.NAMESPACE, _ComplianceReporter.TTL_SECONDS).catch(() => {
+      });
+    } catch (error) {
+      console.warn("[ComplianceReporter] Persist failed:", error instanceof Error ? error.message : String(error));
+    }
+  }
+  // ============================================================================
   // Private Methods
   // ============================================================================
   /**
@@ -82890,13 +83194,6 @@ var KnowledgeGraphService = class {
   async clear() {
     this.nodeCache.clear();
     this.edgeIndex.clear();
-    const nodePattern = `${this.config.namespace}:node:*`;
-    const edgePattern = `${this.config.namespace}:edge:*`;
-    const nodeKeys = await this.memory.search(nodePattern, this.config.maxNodes);
-    const edgeKeys = await this.memory.search(edgePattern, this.config.maxNodes * 10);
-    for (const key of [...nodeKeys, ...edgeKeys]) {
-      await this.memory.delete(key);
-    }
   }
   // ============================================================================
   // ADR-051: LLM Enhancement Methods
@@ -83131,26 +83428,18 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
       await this.createEdge(sourceId, targetId, rel.type);
       edgesCreated++;
     }
-    if (relationships.designPatterns.length > 0) {
-      await this.memory.set(
-        `${this.config.namespace}:patterns:${fileNodeId}`,
-        relationships.designPatterns,
-        { namespace: this.config.namespace }
-      );
-    }
-    if (relationships.architecturalBoundaries.length > 0) {
-      await this.memory.set(
-        `${this.config.namespace}:boundaries:${fileNodeId}`,
-        relationships.architecturalBoundaries,
-        { namespace: this.config.namespace }
-      );
-    }
-    if (relationships.dependencyImpacts.length > 0) {
-      await this.memory.set(
-        `${this.config.namespace}:impacts:${fileNodeId}`,
-        relationships.dependencyImpacts,
-        { namespace: this.config.namespace }
-      );
+    const node = this.nodeCache.get(fileNodeId);
+    if (node) {
+      if (relationships.designPatterns.length > 0) {
+        node.properties.designPatterns = relationships.designPatterns;
+      }
+      if (relationships.architecturalBoundaries.length > 0) {
+        node.properties.architecturalBoundaries = relationships.architecturalBoundaries;
+      }
+      if (relationships.dependencyImpacts.length > 0) {
+        node.properties.dependencyImpacts = relationships.dependencyImpacts;
+      }
+      this.nodeCache.set(fileNodeId, node);
     }
     return edgesCreated;
   }
@@ -83200,9 +83489,6 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
       target: targetId,
       type
     };
-    await this.memory.set(`${this.config.namespace}:edge:${edgeId}`, edge, {
-      namespace: this.config.namespace
-    });
     const sourceEdges = this.edgeIndex.get(sourceId) || [];
     sourceEdges.push(edge);
     this.edgeIndex.set(sourceId, sourceEdges);
@@ -83214,12 +83500,8 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
       if (firstKey) {
         this.nodeCache.delete(firstKey);
         this.edgeIndex.delete(firstKey);
-        await this.memory.delete(`${this.config.namespace}:node:${firstKey}`);
       }
     }
-    await this.memory.set(`${this.config.namespace}:node:${node.id}`, node, {
-      namespace: this.config.namespace
-    });
     this.nodeCache.set(node.id, node);
   }
   async extractEntities(filePath) {
@@ -83610,11 +83892,7 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
       return true;
     });
   }
-  async storeIndexMetadata(metadata) {
-    await this.memory.set(`${this.config.namespace}:metadata:index`, metadata, {
-      namespace: this.config.namespace,
-      persist: true
-    });
+  async storeIndexMetadata(_metadata) {
   }
   async generateEmbedding(entity) {
     const text2 = `${entity.type} ${entity.name} ${entity.visibility}${entity.isAsync ? " async" : ""}`;
@@ -86713,9 +86991,11 @@ var CodeIntelligenceCoordinator = class {
   async initializeHypergraph() {
     try {
       const Database = (await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports))).default;
-      const dbPath = this.config.hypergraphDbPath || ".agentic-qe/hypergraph.db";
       const fs19 = await import("fs");
       const path21 = await import("path");
+      const { findProjectRoot: findProjectRoot2 } = await Promise.resolve().then(() => (init_unified_memory(), unified_memory_exports));
+      const projectRoot = findProjectRoot2();
+      const dbPath = this.config.hypergraphDbPath || path21.join(projectRoot, ".agentic-qe", "hypergraph.db");
       const dir = path21.dirname(dbPath);
       if (!fs19.existsSync(dir)) {
         fs19.mkdirSync(dir, { recursive: true });
@@ -89345,17 +89625,22 @@ var SASTScanner = class {
    * Store scan results in memory
    */
   async storeScanResults(scanId, scanType, vulnerabilities, summary) {
+    const scanSummary = {
+      scanId,
+      scanType,
+      summary,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      vulnerabilityCount: vulnerabilities.length,
+      // Keep only critical/high vulnerabilities in stored result
+      criticalVulnerabilities: vulnerabilities.filter(
+        (v62) => v62.severity === "critical" || v62.severity === "high"
+      )
+    };
     await this.memory.set(
       `security:scan:${scanId}`,
-      {
-        scanId,
-        scanType,
-        vulnerabilities,
-        summary,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      { namespace: "security-compliance", ttl: 86400 * 7 }
-      // 7 days
+      scanSummary,
+      { namespace: "security-compliance", ttl: 86400 * 2 }
+      // 2 days (reduced from 7)
     );
   }
   // ==========================================================================
@@ -117683,6 +117968,13 @@ var QEKernelImpl = class {
     if (this._initialized) {
       return;
     }
+    if (this._config.memoryBackend === "memory") {
+      const tmpDbPath = path12.join(
+        __require("os").tmpdir(),
+        `aqe-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+      );
+      await initializeUnifiedPersistence({ dbPath: tmpDbPath });
+    }
     await this._memory.initialize();
     const antiDriftMiddleware = new SemanticAntiDriftMiddleware({
       agentId: "qe-kernel"
@@ -119135,8 +119427,34 @@ var MinCutPersistence = class {
       JSON.stringify(snapshot.vertices),
       JSON.stringify(snapshot.edges)
     );
+    await this.enforceRetention();
     return id;
   }
+  /**
+   * Enforce retention limits on snapshots and history to prevent DB bloat (Issue #258)
+   */
+  async enforceRetention(maxSnapshots = 200) {
+    const db = this.memory.getDatabase();
+    if (!db) return 0;
+    const countRow = db.prepare("SELECT COUNT(*) as count FROM mincut_snapshots").get();
+    if (!countRow || countRow.count <= maxSnapshots) return 0;
+    const deleteCount = countRow.count - maxSnapshots;
+    db.prepare(`
+      DELETE FROM mincut_snapshots WHERE id IN (
+        SELECT id FROM mincut_snapshots ORDER BY created_at ASC LIMIT ?
+      )
+    `).run(deleteCount);
+    const historyCount = db.prepare("SELECT COUNT(*) as count FROM mincut_history").get();
+    if (historyCount.count > 500) {
+      const historyDelete = historyCount.count - 500;
+      db.prepare(`
+        DELETE FROM mincut_history WHERE id IN (
+          SELECT id FROM mincut_history ORDER BY created_at ASC LIMIT ?
+        )
+      `).run(historyDelete);
+    }
+    return deleteCount;
+  }
   /**
    * Get a snapshot by ID
    */
@@ -119688,7 +120006,10 @@ var QueenMinCutBridge = class {
     }
     this.eventSubscriptions = [];
     if (this.config.persistData) {
-      await this.saveSnapshot();
+      try {
+        await this.saveSnapshot();
+      } catch {
+      }
     }
     this.initialized = false;
   }
@@ -125120,7 +125441,8 @@ var DEFAULT_DYNAMIC_SCALING_CONFIG = {
 
 // src/coordination/dynamic-scaling/dynamic-scaler.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-var DynamicScaler = class {
+init_unified_memory();
+var DynamicScaler = class _DynamicScaler {
   config;
   policy;
   metricsHistory = [];
@@ -125131,6 +125453,13 @@ var DynamicScaler = class {
   totalDecisions = 0;
   currentAgents;
   lastDecision;
+  // KV store persistence (Tier 2)
+  db = null;
+  persistCount = 0;
+  static KV_NAMESPACE = "scaling-metrics";
+  static KV_KEY = "dynamic-scaler-snapshot";
+  static PERSIST_INTERVAL = 10;
+  static KV_TTL = 7200;
   /**
    * Create a new DynamicScaler.
    *
@@ -125156,6 +125485,11 @@ var DynamicScaler = class {
     if (this.metricsHistory.length > this.config.metricsHistorySize) {
       this.metricsHistory.shift();
     }
+    this.persistCount++;
+    if (this.persistCount % _DynamicScaler.PERSIST_INTERVAL === 0) {
+      this.persistSnapshot().catch(() => {
+      });
+    }
   }
   // --------------------------------------------------------------------------
   // Evaluation
@@ -125353,6 +125687,23 @@ var DynamicScaler = class {
   // --------------------------------------------------------------------------
   // Lifecycle
   // --------------------------------------------------------------------------
+  /**
+   * Initialize persistence layer and load last snapshot from KV store.
+   * Safe to call multiple times; will not throw on DB failure.
+   */
+  async initialize() {
+    try {
+      this.db = getUnifiedMemory();
+      if (!this.db.isInitialized()) await this.db.initialize();
+      await this.loadFromKv();
+    } catch (error) {
+      console.warn(
+        "[DynamicScaler] DB init failed, using memory-only:",
+        error instanceof Error ? error.message : String(error)
+      );
+      this.db = null;
+    }
+  }
   /**
    * Release internal buffers. The scaler should not be used after disposal.
    */
@@ -125393,12 +125744,68 @@ var DynamicScaler = class {
   }
   /**
    * Record a scaling event, evicting the oldest when the history cap is hit.
+   * Triggers periodic persistence to KV store.
    */
   recordEvent(event) {
     this.events.push(event);
     if (this.events.length > this.config.decisionHistorySize) {
       this.events.shift();
     }
+    this.persistCount++;
+    if (this.persistCount % _DynamicScaler.PERSIST_INTERVAL === 0) {
+      this.persistSnapshot().catch(() => {
+      });
+    }
+  }
+  /**
+   * Load last persisted snapshot from KV store into in-memory state.
+   */
+  async loadFromKv() {
+    if (!this.db) return;
+    try {
+      const snapshot = await this.db.kvGet(_DynamicScaler.KV_KEY, _DynamicScaler.KV_NAMESPACE);
+      if (snapshot) {
+        if (Array.isArray(snapshot.metricsHistory)) {
+          for (const m74 of snapshot.metricsHistory) {
+            this.metricsHistory.push(m74);
+          }
+        }
+        if (Array.isArray(snapshot.events)) {
+          for (const e20 of snapshot.events) {
+            this.events.push(e20);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(
+        "[DynamicScaler] Failed to load KV snapshot:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Persist a trimmed snapshot of metricsHistory and events to KV store.
+   * Keeps only the last 50 entries of each to limit storage size.
+   */
+  async persistSnapshot() {
+    if (!this.db) return;
+    try {
+      const snapshot = {
+        metricsHistory: this.metricsHistory.slice(-50),
+        events: this.events.slice(-50)
+      };
+      await this.db.kvSet(
+        _DynamicScaler.KV_KEY,
+        snapshot,
+        _DynamicScaler.KV_NAMESPACE,
+        _DynamicScaler.KV_TTL
+      );
+    } catch (error) {
+      console.warn(
+        "[DynamicScaler] Failed to persist KV snapshot:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
   }
 };
 function createDynamicScaler(initialAgents, config) {
@@ -130038,34 +130445,55 @@ var ExperienceReplay = class {
     console.log("[ExperienceReplay] Initialized");
   }
   /**
-   * Ensure required schema exists
+   * Ensure required schema exists.
+   * Uses captured_experiences as the canonical table (written by experience-capture-middleware).
+   * Adds ExperienceReplay-specific columns if missing.
    */
   ensureSchema() {
     if (!this.db) throw new Error("Database not initialized");
     this.db.exec(`
-      CREATE TABLE IF NOT EXISTS experiences (
+      CREATE TABLE IF NOT EXISTS captured_experiences (
         id TEXT PRIMARY KEY,
-        trajectory_id TEXT NOT NULL,
         task TEXT NOT NULL,
-        domain TEXT NOT NULL,
-        strategy TEXT NOT NULL,
-        key_actions TEXT NOT NULL,
-        quality_score REAL NOT NULL DEFAULT 0.5,
+        agent TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT '',
+        success INTEGER NOT NULL DEFAULT 0,
+        quality REAL NOT NULL DEFAULT 0.5,
+        duration_ms INTEGER NOT NULL DEFAULT 0,
+        model_tier INTEGER,
+        routing_json TEXT,
+        steps_json TEXT,
+        result_json TEXT,
+        error TEXT,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        completed_at TEXT NOT NULL DEFAULT (datetime('now')),
+        source TEXT DEFAULT 'middleware',
         application_count INTEGER DEFAULT 0,
-        success_rate REAL DEFAULT 1.0,
         avg_token_savings REAL DEFAULT 0,
         embedding BLOB,
         embedding_dimension INTEGER,
-        original_metrics TEXT,
         tags TEXT,
-        created_at TEXT DEFAULT (datetime('now')),
-        last_applied_at TEXT,
-        FOREIGN KEY (trajectory_id) REFERENCES qe_trajectories(id) ON DELETE SET NULL
+        last_applied_at TEXT
       );
-      CREATE INDEX IF NOT EXISTS idx_experiences_domain ON experiences(domain);
-      CREATE INDEX IF NOT EXISTS idx_experiences_quality ON experiences(quality_score DESC);
-      CREATE INDEX IF NOT EXISTS idx_experiences_task ON experiences(task);
+      CREATE INDEX IF NOT EXISTS idx_captured_exp_domain ON captured_experiences(domain);
+      CREATE INDEX IF NOT EXISTS idx_captured_exp_quality ON captured_experiences(quality DESC);
+      CREATE INDEX IF NOT EXISTS idx_captured_exp_task ON captured_experiences(task);
     `);
+    const columns = this.db.prepare("PRAGMA table_info(captured_experiences)").all();
+    const colNames = new Set(columns.map((c70) => c70.name));
+    const additions = [
+      ["application_count", "INTEGER DEFAULT 0"],
+      ["avg_token_savings", "REAL DEFAULT 0"],
+      ["embedding", "BLOB"],
+      ["embedding_dimension", "INTEGER"],
+      ["tags", "TEXT"],
+      ["last_applied_at", "TEXT"]
+    ];
+    for (const [col, def] of additions) {
+      if (!colNames.has(col)) {
+        this.db.exec(`ALTER TABLE captured_experiences ADD COLUMN ${col} ${def}`);
+      }
+    }
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS experience_applications (
         id TEXT PRIMARY KEY,
@@ -130075,38 +130503,37 @@ var ExperienceReplay = class {
         tokens_saved INTEGER DEFAULT 0,
         feedback TEXT,
         applied_at TEXT DEFAULT (datetime('now')),
-        FOREIGN KEY (experience_id) REFERENCES experiences(id) ON DELETE CASCADE
+        FOREIGN KEY (experience_id) REFERENCES captured_experiences(id) ON DELETE CASCADE
       );
       CREATE INDEX IF NOT EXISTS idx_exp_apps_experience ON experience_applications(experience_id);
     `);
   }
   /**
-   * Prepare commonly used statements
+   * Prepare commonly used statements against captured_experiences table
    */
   prepareStatements() {
     if (!this.db) throw new Error("Database not initialized");
     this.prepared.set("insertExperience", this.db.prepare(`
-      INSERT INTO experiences (
-        id, trajectory_id, task, domain, strategy, key_actions, quality_score,
-        embedding, embedding_dimension, original_metrics, tags
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO captured_experiences (
+        id, task, agent, domain, success, quality, duration_ms,
+        steps_json, routing_json, embedding, embedding_dimension, tags, source
+      ) VALUES (?, ?, ?, ?, 1, ?, 0, ?, ?, ?, ?, ?, 'experience-replay')
     `));
     this.prepared.set("getExperience", this.db.prepare(`
-      SELECT * FROM experiences WHERE id = ?
+      SELECT * FROM captured_experiences WHERE id = ?
     `));
     this.prepared.set("getExperiencesByDomain", this.db.prepare(`
-      SELECT * FROM experiences WHERE domain = ? ORDER BY quality_score DESC LIMIT ?
+      SELECT * FROM captured_experiences WHERE domain = ? ORDER BY quality DESC LIMIT ?
     `));
     this.prepared.set("getAllExperiences", this.db.prepare(`
-      SELECT * FROM experiences ORDER BY quality_score DESC LIMIT ?
+      SELECT * FROM captured_experiences ORDER BY quality DESC LIMIT ?
     `));
     this.prepared.set("getAllEmbeddings", this.db.prepare(`
-      SELECT id, embedding, embedding_dimension FROM experiences WHERE embedding IS NOT NULL
+      SELECT id, embedding, embedding_dimension FROM captured_experiences WHERE embedding IS NOT NULL
     `));
     this.prepared.set("updateApplication", this.db.prepare(`
-      UPDATE experiences SET
+      UPDATE captured_experiences SET
         application_count = application_count + 1,
-        success_rate = (success_rate * application_count + ?) / (application_count + 1),
         avg_token_savings = (avg_token_savings * application_count + ?) / (application_count + 1),
         last_applied_at = datetime('now')
       WHERE id = ?
@@ -130116,13 +130543,13 @@ var ExperienceReplay = class {
       VALUES (?, ?, ?, ?, ?, ?)
     `));
     this.prepared.set("deleteExperience", this.db.prepare(`
-      DELETE FROM experiences WHERE id = ?
+      DELETE FROM captured_experiences WHERE id = ?
     `));
     this.prepared.set("getLowQualityExperiences", this.db.prepare(`
-      SELECT id FROM experiences WHERE quality_score < ? AND application_count < 3
+      SELECT id FROM captured_experiences WHERE quality < ? AND application_count < 3
     `));
     this.prepared.set("countByDomain", this.db.prepare(`
-      SELECT domain, COUNT(*) as count FROM experiences GROUP BY domain
+      SELECT domain, COUNT(*) as count FROM captured_experiences GROUP BY domain
     `));
   }
   /**
@@ -130198,15 +130625,17 @@ var ExperienceReplay = class {
       const embeddingBuffer = embedding ? this.floatArrayToBuffer(embedding) : null;
       insertStmt.run(
         id,
-        trajectory.id,
         trajectory.task,
-        domain,
         strategy,
-        JSON.stringify(keyActions),
+        // agent column stores strategy
+        domain,
         trajectory.metrics.efficiencyScore,
+        JSON.stringify(keyActions),
+        // steps_json stores key actions
+        JSON.stringify(trajectory.metrics),
+        // routing_json stores original metrics
         embeddingBuffer,
         embedding?.length ?? null,
-        JSON.stringify(trajectory.metrics),
         JSON.stringify(tags)
       );
     }
@@ -130338,7 +130767,7 @@ var ExperienceReplay = class {
     this.ensureInitialized();
     const updateStmt = this.prepared.get("updateApplication");
     if (updateStmt) {
-      updateStmt.run(success ? 1 : 0, tokensSaved, experienceId);
+      updateStmt.run(tokensSaved, experienceId);
     }
     const insertStmt = this.prepared.get("insertApplication");
     if (insertStmt) {
@@ -130445,19 +130874,21 @@ var ExperienceReplay = class {
     if (!row2) return null;
     return {
       id: row2.id,
-      trajectoryId: row2.trajectory_id,
+      trajectoryId: row2.id,
+      // captured_experiences doesn't have trajectory_id
       task: row2.task,
       domain: row2.domain,
-      strategy: row2.strategy,
-      keyActions: JSON.parse(row2.key_actions || "[]"),
-      qualityScore: row2.quality_score,
-      applicationCount: row2.application_count,
-      successRate: row2.success_rate,
-      avgTokenSavings: row2.avg_token_savings,
+      strategy: row2.agent,
+      // agent column stores strategy/agent name
+      keyActions: JSON.parse(row2.steps_json || "[]"),
+      qualityScore: row2.quality,
+      applicationCount: row2.application_count ?? 0,
+      successRate: row2.success ? 1 : 0,
+      avgTokenSavings: row2.avg_token_savings ?? 0,
       embedding: row2.embedding && row2.embedding_dimension ? this.bufferToFloatArray(row2.embedding, row2.embedding_dimension) : void 0,
-      createdAt: new Date(row2.created_at),
+      createdAt: new Date(row2.started_at),
       lastAppliedAt: row2.last_applied_at ? new Date(row2.last_applied_at) : void 0,
-      originalMetrics: JSON.parse(row2.original_metrics || "{}"),
+      originalMetrics: JSON.parse(row2.routing_json || "{}"),
       tags: JSON.parse(row2.tags || "[]")
     };
   }
@@ -135671,6 +136102,7 @@ var EarlyExitTokenOptimizer = class {
 init_pattern_store();
 
 // src/learning/token-tracker.ts
+init_unified_memory();
 import { randomUUID as randomUUID7 } from "crypto";
 var DEFAULT_COST_CONFIG = {
   costPerInputToken: 3e-3 / 1e3,
@@ -135684,7 +136116,7 @@ var DEFAULT_PERSISTENCE_CONFIG2 = {
   // Auto-save every minute
   maxMetricsInMemory: 1e4
 };
-var TokenMetricsCollectorImpl = class {
+var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
   taskMetrics = [];
   agentMetrics = /* @__PURE__ */ new Map();
   domainMetrics = /* @__PURE__ */ new Map();
@@ -135700,6 +136132,15 @@ var TokenMetricsCollectorImpl = class {
   persistenceConfig = DEFAULT_PERSISTENCE_CONFIG2;
   autoSaveTimer = null;
   isDirty = false;
+  // kv_store persistence
+  db = null;
+  kvPersistCount = 0;
+  static KV_NAMESPACE = "token-usage-metrics";
+  static KV_KEY = "token-tracker-snapshot";
+  static KV_TTL = 604800;
+  // 7 days
+  static KV_PERSIST_INTERVAL = 10;
+  // every 10 operations
   constructor() {
     this.sessionId = `session-${Date.now()}-${randomUUID7().substring(0, 8)}`;
     this.sessionStartTime = Date.now();
@@ -136114,6 +136555,88 @@ var TokenMetricsCollectorImpl = class {
     return this.isDirty;
   }
   // ============================================================================
+  // kv_store Persistence
+  // ============================================================================
+  /**
+   * Initialize kv_store persistence and restore snapshot if available.
+   * This supplements the existing file-based persistence.
+   */
+  async initializeDb() {
+    try {
+      this.db = getUnifiedMemory();
+      if (!this.db.isInitialized()) await this.db.initialize();
+      await this.loadFromKv();
+    } catch (error) {
+      console.warn("[TokenMetricsCollector] DB init failed, using memory-only:", error instanceof Error ? error.message : String(error));
+      this.db = null;
+    }
+  }
+  /**
+   * Persist current state snapshot to kv_store
+   */
+  async persistToKv() {
+    if (!this.db) return;
+    const snapshot = {
+      version: "1.0.0",
+      sessionId: this.sessionId,
+      sessionStartTime: this.sessionStartTime,
+      taskMetrics: this.taskMetrics.slice(-this.persistenceConfig.maxMetricsInMemory),
+      optimizationStats: {
+        cacheHits: this.cacheHits,
+        earlyExits: this.earlyExits,
+        totalTokensSaved: this.totalTokensSaved,
+        totalPatternsReused: this.totalPatternsReused
+      },
+      lastSavedAt: Date.now()
+    };
+    await this.db.kvSet(
+      _TokenMetricsCollectorImpl.KV_KEY,
+      snapshot,
+      _TokenMetricsCollectorImpl.KV_NAMESPACE,
+      _TokenMetricsCollectorImpl.KV_TTL
+    );
+  }
+  /**
+   * Load state snapshot from kv_store
+   */
+  async loadFromKv() {
+    if (!this.db) return false;
+    const snapshot = await this.db.kvGet(
+      _TokenMetricsCollectorImpl.KV_KEY,
+      _TokenMetricsCollectorImpl.KV_NAMESPACE
+    );
+    if (!snapshot) return false;
+    if (!snapshot.version || !snapshot.version.startsWith("1.")) {
+      console.warn("[TokenMetricsCollector] Incompatible kv_store data version, skipping load");
+      return false;
+    }
+    const historicalMetrics = snapshot.taskMetrics || [];
+    this.taskMetrics = [...historicalMetrics, ...this.taskMetrics];
+    this.cacheHits += snapshot.optimizationStats?.cacheHits || 0;
+    this.earlyExits += snapshot.optimizationStats?.earlyExits || 0;
+    this.totalTokensSaved += snapshot.optimizationStats?.totalTokensSaved || 0;
+    this.totalPatternsReused += snapshot.optimizationStats?.totalPatternsReused || 0;
+    for (const metric of historicalMetrics) {
+      this.updateAgentMetrics(metric.agentId, metric.usage, metric.patternReused, metric.tokensSaved || 0);
+      this.updateDomainMetrics(metric.domain, metric.usage);
+    }
+    if (this.taskMetrics.length > this.persistenceConfig.maxMetricsInMemory) {
+      this.taskMetrics = this.taskMetrics.slice(-this.persistenceConfig.maxMetricsInMemory);
+    }
+    return true;
+  }
+  /**
+   * Track state changes and persist to kv_store periodically
+   */
+  maybePersistToKv() {
+    this.kvPersistCount++;
+    if (this.kvPersistCount >= _TokenMetricsCollectorImpl.KV_PERSIST_INTERVAL) {
+      this.kvPersistCount = 0;
+      this.persistToKv().catch(() => {
+      });
+    }
+  }
+  // ============================================================================
   // Private Helper Methods
   // ============================================================================
   ensureInitialized() {
@@ -145484,6 +146007,9 @@ var GOAPStatusTool = class extends MCPToolBase {
   }
 };
 
+// src/coordination/mincut/time-crystal.ts
+init_unified_memory();
+
 // src/mcp/tools/mincut/index.ts
 var MINCUT_TOOL_NAMES = {
   HEALTH: "qe/mincut/health",
@@ -151844,24 +152370,49 @@ async function doInitialize() {
     await memoryManager.initialize();
     const db = memoryManager.getDatabase();
     if (db) {
+      let needsCreate = false;
+      const tableExists = db.prepare(
+        "SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name='captured_experiences'"
+      ).get().cnt > 0;
+      if (tableExists) {
+        const columns = db.prepare("PRAGMA table_info(captured_experiences)").all();
+        const colNames = new Set(columns.map((c70) => c70.name));
+        if (!colNames.has("success") || !colNames.has("task")) {
+          db.exec("ALTER TABLE captured_experiences RENAME TO captured_experiences_v2_backup");
+          needsCreate = true;
+        } else {
+          if (!colNames.has("domain")) {
+            db.exec("ALTER TABLE captured_experiences ADD COLUMN domain TEXT NOT NULL DEFAULT ''");
+          }
+          if (!colNames.has("source")) {
+            db.exec("ALTER TABLE captured_experiences ADD COLUMN source TEXT DEFAULT 'middleware'");
+          }
+        }
+      } else {
+        needsCreate = true;
+      }
+      if (needsCreate) {
+        db.exec(`
+          CREATE TABLE IF NOT EXISTS captured_experiences (
+            id TEXT PRIMARY KEY,
+            task TEXT NOT NULL,
+            agent TEXT NOT NULL,
+            domain TEXT NOT NULL DEFAULT '',
+            success INTEGER NOT NULL DEFAULT 0,
+            quality REAL NOT NULL DEFAULT 0.5,
+            duration_ms INTEGER NOT NULL DEFAULT 0,
+            model_tier INTEGER,
+            routing_json TEXT,
+            steps_json TEXT,
+            result_json TEXT,
+            error TEXT,
+            started_at TEXT NOT NULL DEFAULT (datetime('now')),
+            completed_at TEXT NOT NULL DEFAULT (datetime('now')),
+            source TEXT DEFAULT 'middleware'
+          );
+        `);
+      }
       db.exec(`
-        CREATE TABLE IF NOT EXISTS captured_experiences (
-          id TEXT PRIMARY KEY,
-          task TEXT NOT NULL,
-          agent TEXT NOT NULL,
-          domain TEXT NOT NULL,
-          success INTEGER NOT NULL DEFAULT 0,
-          quality REAL NOT NULL DEFAULT 0.5,
-          duration_ms INTEGER NOT NULL DEFAULT 0,
-          model_tier INTEGER,
-          routing_json TEXT,
-          steps_json TEXT,
-          result_json TEXT,
-          error TEXT,
-          started_at TEXT NOT NULL,
-          completed_at TEXT NOT NULL DEFAULT (datetime('now')),
-          source TEXT DEFAULT 'middleware'
-        );
         CREATE INDEX IF NOT EXISTS idx_captured_exp_domain ON captured_experiences(domain);
         CREATE INDEX IF NOT EXISTS idx_captured_exp_success ON captured_experiences(success);
         CREATE INDEX IF NOT EXISTS idx_captured_exp_agent ON captured_experiences(agent);
@@ -160536,6 +161087,25 @@ async function main() {
       }
     } catch (infraError) {
       originalStderrWrite(`[MCP] WARNING: Infra-healing init failed: ${infraError}
+`);
+    }
+    originalStderrWrite("[MCP] Auto-initializing fleet...\n");
+    try {
+      const fleetResult = await handleFleetInit({
+        topology: "hierarchical",
+        maxAgents: 15,
+        memoryBackend: "hybrid",
+        lazyLoading: true
+      });
+      if (fleetResult.success) {
+        originalStderrWrite(`[MCP] Fleet ready: ${fleetResult.data?.fleetId}
+`);
+      } else {
+        originalStderrWrite(`[MCP] WARNING: Fleet auto-init failed: ${fleetResult.error}
+`);
+      }
+    } catch (fleetError) {
+      originalStderrWrite(`[MCP] WARNING: Fleet auto-init error: ${fleetError}
 `);
     }
     originalStderrWrite("[MCP] Starting server...\n");