agentic-qe 3.6.6 → 3.6.8

package/v3/dist/cli/bundle.js

@@ -595,6 +595,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
@@ -1539,12 +1543,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"))) {
@@ -1609,7 +1617,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";
@@ -1629,7 +1637,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),
@@ -2100,6 +2108,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 = [];
@@ -2439,6 +2522,7 @@ var init_unified_memory = __esm({
       db = null;
       config;
       initialized = false;
+      vectorsLoaded = false;
       initPromise = null;
       preparedStatements = /* @__PURE__ */ new Map();
       vectorIndex = new InMemoryHNSWIndex();
@@ -2447,6 +2531,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).
@@ -2516,7 +2604,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();
@@ -2637,6 +2725,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'))
@@ -2650,6 +2741,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(
@@ -2659,6 +2751,7 @@ var init_unified_memory = __esm({
           const embedding = this.bufferToFloatArray(row.embedding, row.dimensions);
           this.vectorIndex.add(row.id, embedding);
         }
+        this.vectorsLoaded = true;
         console.log(`[UnifiedMemory] Loaded ${rows.length} vectors into HNSW index`);
       }
       // ============================================================================
@@ -2782,6 +2875,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);
@@ -3416,6 +3512,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/shared/embeddings/types.ts
 var EMBEDDING_CONFIG;
 var init_types2 = __esm({
@@ -6624,206 +6925,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, {
@@ -6940,6 +7041,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,
@@ -7053,11 +7155,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];
@@ -7068,10 +7178,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
@@ -7116,6 +7234,7 @@ var init_attention_wrapper = __esm({
           throughput: seqLen * seqLen / ((endTime - startTime) / 1e3),
           peakMemoryMB: endMemory
         });
+        this.maybePersistToKv();
         return output;
       }
       /**
@@ -7282,6 +7401,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
       // ========================================================================
       /**
@@ -8092,8 +8254,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++;
       }
@@ -9018,13 +9178,13 @@ var init_path_traversal_validator = __esm({
        */
       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
@@ -10009,13 +10169,6 @@ var init_knowledge_graph = __esm({
       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
@@ -10250,26 +10403,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;
       }
@@ -10319,9 +10464,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);
@@ -10333,12 +10475,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) {
@@ -10729,11 +10867,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 text = `${entity.type} ${entity.name} ${entity.visibility}${entity.isAsync ? " async" : ""}`;
@@ -13812,31 +13946,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
@@ -13884,10 +13993,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();
@@ -13984,15 +14089,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
@@ -14189,10 +14286,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);
@@ -14216,10 +14309,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`
@@ -14235,8 +14324,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);
@@ -15790,7 +15877,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);
         }
@@ -17588,6 +17683,7 @@ var HybridMemoryBackend = class {
   unifiedMemory = null;
   config;
   cleanupInterval;
+  cleanupCount = 0;
   initialized = false;
   constructor(config) {
     this.config = {
@@ -17804,6 +17900,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);
       }
@@ -18015,6 +18136,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";
 
@@ -29479,11 +29601,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
    *
@@ -29494,8 +29624,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
    */
@@ -29507,6 +29677,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
@@ -30786,6 +30961,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;
@@ -30801,11 +30977,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,
@@ -30823,6 +31006,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");
   }
@@ -30844,6 +31035,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"}`);
   }
   /**
@@ -31268,6 +31460,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
   // ============================================================================
   /**
@@ -33612,6 +33834,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,
@@ -33628,7 +33851,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;
@@ -33636,6 +33859,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
    *
@@ -33651,6 +33881,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();
     }
@@ -33719,6 +33957,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;
   }
@@ -34148,6 +34387,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
   // ============================================================================
   /**
@@ -70941,9 +71219,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 fs21 = await import("fs");
       const path23 = await import("path");
+      const { findProjectRoot: findProjectRoot2 } = await Promise.resolve().then(() => (init_unified_memory(), unified_memory_exports));
+      const projectRoot = findProjectRoot2();
+      const dbPath = this.config.hypergraphDbPath || path23.join(projectRoot, ".agentic-qe", "hypergraph.db");
       const dir = path23.dirname(dbPath);
       if (!fs21.existsSync(dir)) {
         fs21.mkdirSync(dir, { recursive: true });
@@ -73574,17 +73854,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)
     );
   }
   // ==========================================================================
@@ -101917,6 +102202,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"
@@ -103369,8 +103661,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
    */
@@ -103922,7 +104240,10 @@ var QueenMinCutBridge = class {
     }
     this.eventSubscriptions = [];
     if (this.config.persistData) {
-      await this.saveSnapshot();
+      try {
+        await this.saveSnapshot();
+      } catch {
+      }
     }
     this.initialized = false;
   }
@@ -109347,7 +109668,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 = [];
@@ -109358,6 +109680,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.
    *
@@ -109383,6 +109712,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
@@ -109580,6 +109914,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.
    */
@@ -109620,12 +109971,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) {
@@ -112275,6 +112682,7 @@ var EarlyExitTokenOptimizer = class {
 init_pattern_store();
 
 // src/learning/token-tracker.ts
+init_unified_memory();
 import { randomUUID as randomUUID6 } from "crypto";
 var DEFAULT_COST_CONFIG = {
   costPerInputToken: 3e-3 / 1e3,
@@ -112288,7 +112696,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();
@@ -112304,6 +112712,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()}-${randomUUID6().substring(0, 8)}`;
     this.sessionStartTime = Date.now();
@@ -112718,6 +113135,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() {
@@ -114421,7 +114920,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.6.6" : "3.0.0";
+  return true ? "3.6.8" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -118935,9 +119434,22 @@ var HooksPhase = class extends BasePhase {
    * Uses `npx agentic-qe` for portability - works without global installation.
    * All hooks use --json output for structured data and fail silently with continueOnError.
    */
-  generateHooksConfig(config) {
+  generateHooksConfig(_config) {
     return {
       PreToolUse: [
+        // File guardian — MUST be first to block before learning hooks run
+        {
+          matcher: "^(Write|Edit|MultiEdit)$",
+          hooks: [
+            {
+              type: "command",
+              command: 'npx agentic-qe hooks guard --file "$TOOL_INPUT_file_path" --json',
+              timeout: 3e3,
+              continueOnError: true
+            }
+          ]
+        },
+        // Learning: pre-edit context
         {
           matcher: "^(Write|Edit|MultiEdit)$",
           hooks: [
@@ -118949,17 +119461,19 @@ var HooksPhase = class extends BasePhase {
             }
           ]
         },
+        // Command bouncer — blocks dangerous commands
         {
           matcher: "^Bash$",
           hooks: [
             {
               type: "command",
               command: 'npx agentic-qe hooks pre-command --command "$TOOL_INPUT_command" --json',
-              timeout: 5e3,
+              timeout: 3e3,
               continueOnError: true
             }
           ]
         },
+        // Task routing
         {
           matcher: "^Task$",
           hooks: [
@@ -118978,7 +119492,7 @@ var HooksPhase = class extends BasePhase {
           hooks: [
             {
               type: "command",
-              command: 'npx agentic-qe hooks post-edit --file "$TOOL_INPUT_file_path" --success "$TOOL_SUCCESS" --json',
+              command: 'npx agentic-qe hooks post-edit --file "$TOOL_INPUT_file_path" --success --json',
               timeout: 5e3,
               continueOnError: true
             }
@@ -118989,7 +119503,7 @@ var HooksPhase = class extends BasePhase {
           hooks: [
             {
               type: "command",
-              command: 'npx agentic-qe hooks post-command --command "$TOOL_INPUT_command" --success "$TOOL_SUCCESS" --json',
+              command: 'npx agentic-qe hooks post-command --command "$TOOL_INPUT_command" --success --json',
               timeout: 5e3,
               continueOnError: true
             }
@@ -119000,7 +119514,7 @@ var HooksPhase = class extends BasePhase {
           hooks: [
             {
               type: "command",
-              command: 'npx agentic-qe hooks post-task --task-id "$TOOL_RESULT_agent_id" --success "$TOOL_SUCCESS" --json',
+              command: 'npx agentic-qe hooks post-task --task-id "$TOOL_RESULT_agent_id" --success --json',
               timeout: 5e3,
               continueOnError: true
             }
@@ -137839,13 +138353,19 @@ Examples:
       });
       const result = results[0] || { success: true, guidance: [], routing: null };
       if (options.json) {
+        const guidanceLines = result.guidance || [];
+        const agentHint = result.routing?.recommendedAgent ? `Recommended agent: ${result.routing.recommendedAgent} (${(result.routing.confidence * 100).toFixed(0)}% confidence).` : "";
+        const contextStr = [
+          agentHint,
+          ...guidanceLines.map((g67) => g67)
+        ].filter(Boolean).join(" ");
         printJson({
-          success: result.success,
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: contextStr || void 0
+          },
           file: options.file,
           operation: options.operation,
-          guidance: result.guidance || [],
-          recommendedAgent: result.routing?.recommendedAgent,
-          confidence: result.routing?.confidence,
           patterns: result.routing?.patterns?.length || 0
         });
       } else {
@@ -138161,18 +138681,32 @@ Registered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`)
         dreamState.totalDreamsThisSession = 0;
       }
       await memoryBackend2.set(DREAM_STATE_KEY, dreamState);
+      const contextParts = [];
+      contextParts.push(`AQE Learning: ${stats.totalPatterns} patterns loaded`);
+      const domainEntries = Object.entries(stats.byDomain).filter(([, count]) => count > 0).sort(([, a37], [, b68]) => b68 - a37).slice(0, 5);
+      if (domainEntries.length > 0) {
+        contextParts.push(`Top domains: ${domainEntries.map(([d74, c70]) => `${d74}(${c70})`).join(", ")}`);
+      }
+      if (stats.patternSuccessRate > 0) {
+        contextParts.push(`Pattern success rate: ${(stats.patternSuccessRate * 100).toFixed(0)}%`);
+      }
+      if (stats.routingRequests > 0) {
+        contextParts.push(`Routing confidence: ${(stats.avgRoutingConfidence * 100).toFixed(0)}% across ${stats.routingRequests} requests`);
+      }
+      const additionalContext = contextParts.join(". ") + ".";
       if (options.json) {
         printJson({
-          success: true,
+          hookSpecificOutput: {
+            hookEventName: "SessionStart",
+            additionalContext
+          },
           sessionId,
           initialized: true,
           patternsLoaded: stats.totalPatterns,
           dreamScheduler: {
             enabled: true,
             lastDreamTime: dreamState.lastDreamTime,
-            pendingExperiences: dreamState.experienceCount,
-            intervalMs: DREAM_INTERVAL_MS,
-            experienceThreshold: DREAM_EXPERIENCE_THRESHOLD
+            pendingExperiences: dreamState.experienceCount
           }
         });
       } else {
@@ -138199,8 +138733,9 @@ Registered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`)
         }
       }
       if (options.json) {
+        const summary = stats ? `Session complete: ${stats.totalPatterns} patterns, ${stats.routingRequests} routings, ${(stats.patternSuccessRate * 100).toFixed(0)}% success rate` : "Session complete";
         printJson({
-          success: true,
+          continue: true,
           sessionId,
           stateSaved: options.saveState || false,
           metricsExported: options.exportMetrics || false,
@@ -138324,34 +138859,119 @@ Registered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`)
       process.exit(0);
     }
   });
-  hooks.command("pre-command").description("Get context before executing a Bash command").option("-c, --command <cmd>", "Command to be executed").option("--json", "Output as JSON").action(async (options) => {
-    try {
-      const command = options.command || "";
-      const warnings = [];
-      if (command.includes("rm -rf /") || command.includes("rm -rf ~")) {
-        warnings.push("Dangerous recursive delete detected");
-      }
-      if (command.includes("> /dev/sd") || command.includes("dd if=")) {
-        warnings.push("Direct disk write detected");
-      }
-      if (command.includes(".agentic-qe") && command.includes("rm")) {
-        warnings.push("Deleting AQE data files");
+  hooks.command("guard").description("File guardian - block edits to protected files").requiredOption("-f, --file <path>", "File path to check").option("--json", "Output as JSON (required for hook API)").action(async (options) => {
+    try {
+      const filePath = options.file || "";
+      const normalizedPath = filePath.replace(/\\/g, "/");
+      const protectedPatterns = [
+        { pattern: /^\.env($|\.)/, reason: "Environment file contains secrets" },
+        { pattern: /\.env\.[a-zA-Z]+$/, reason: "Environment file contains secrets" },
+        { pattern: /\.lock$/, reason: "Lock files are auto-generated" },
+        { pattern: /(^|\/)node_modules\//, reason: "node_modules is managed by package manager" },
+        { pattern: /(^|\/)\.agentic-qe\/memory\.db/, reason: "AQE memory database must not be directly edited" },
+        { pattern: /(^|\/)\.agentic-qe\/memory\.db-wal$/, reason: "AQE WAL file must not be directly edited" },
+        { pattern: /(^|\/)\.agentic-qe\/memory\.db-shm$/, reason: "AQE shared memory file must not be directly edited" }
+      ];
+      const match = protectedPatterns.find((p74) => p74.pattern.test(normalizedPath));
+      if (match) {
+        if (options.json) {
+          printJson({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "deny",
+              permissionDecisionReason: `Protected file: ${match.reason} (${filePath})`
+            }
+          });
+        } else {
+          printError(`Blocked: ${match.reason} (${filePath})`);
+        }
+      } else {
+        if (options.json) {
+          printJson({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "allow"
+            }
+          });
+        } else {
+          printSuccess(`Allowed: ${filePath}`);
+        }
       }
+      process.exit(0);
+    } catch (error) {
       if (options.json) {
         printJson({
-          success: true,
-          command: command.substring(0, 100),
-          warnings,
-          safe: warnings.length === 0
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "allow"
+          }
         });
-      } else if (warnings.length > 0) {
-        console.log(chalk27.yellow("\n\u26A0\uFE0F  Command Warnings:"));
-        warnings.forEach((w54) => console.log(chalk27.yellow(`  - ${w54}`)));
+      }
+      process.exit(0);
+    }
+  });
+  hooks.command("pre-command").description("Get context before executing a Bash command").option("-c, --command <cmd>", "Command to be executed").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const command = options.command || "";
+      const dangerousPatterns = [
+        { pattern: /rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+)?-[a-zA-Z]*r[a-zA-Z]*\s+\/(?!\w)/, reason: "Recursive delete of root filesystem" },
+        { pattern: /rm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+)?-[a-zA-Z]*f[a-zA-Z]*\s+\/(?!\w)/, reason: "Recursive delete of root filesystem" },
+        { pattern: /rm\s+-rf\s+~/, reason: "Recursive delete of home directory" },
+        { pattern: /DROP\s+(TABLE|DATABASE|SCHEMA)/i, reason: "Destructive SQL operation" },
+        { pattern: /git\s+push\s+.*--force(?!-)/, reason: "Force push can overwrite remote history" },
+        { pattern: /git\s+reset\s+--hard/, reason: "Hard reset discards uncommitted changes" },
+        { pattern: />\s*\/dev\/sd[a-z]/, reason: "Direct write to block device" },
+        { pattern: /dd\s+if=.*of=\/dev\/sd/, reason: "Direct disk write via dd" },
+        { pattern: /chmod\s+777\s/, reason: "World-writable permissions are a security risk" },
+        { pattern: /:\(\)\s*\{\s*:\|\s*:&\s*\}\s*;?\s*:/, reason: "Fork bomb detected" },
+        { pattern: /mkfs\./, reason: "Filesystem format operation" },
+        { pattern: />\s*\/dev\/null\s*2>&1\s*&\s*disown/, reason: "Stealth background process" }
+      ];
+      const warningPatterns = [
+        { pattern: /\.agentic-qe.*rm/, reason: "Deleting AQE data files" },
+        { pattern: /rm\s+-rf\s/, reason: "Recursive force delete" },
+        { pattern: /git\s+clean\s+-[a-zA-Z]*f/, reason: "Force cleaning untracked files" }
+      ];
+      const dangerMatch = dangerousPatterns.find((p74) => p74.pattern.test(command));
+      const warnings = warningPatterns.filter((p74) => p74.pattern.test(command)).map((p74) => p74.reason);
+      if (dangerMatch) {
+        if (options.json) {
+          printJson({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "deny",
+              permissionDecisionReason: `Dangerous command blocked: ${dangerMatch.reason}`
+            }
+          });
+        } else {
+          printError(`Blocked: ${dangerMatch.reason}`);
+        }
+      } else {
+        if (options.json) {
+          const result = {
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "allow"
+            }
+          };
+          if (warnings.length > 0) {
+            result.hookSpecificOutput.additionalContext = `Warnings: ${warnings.join("; ")}`;
+          }
+          printJson(result);
+        } else if (warnings.length > 0) {
+          console.log(chalk27.yellow("\n\u26A0\uFE0F  Command Warnings:"));
+          warnings.forEach((w54) => console.log(chalk27.yellow(`  - ${w54}`)));
+        }
       }
       process.exit(0);
     } catch (error) {
       if (options.json) {
-        printJson({ success: false, error: error instanceof Error ? error.message : "unknown" });
+        printJson({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "allow"
+          }
+        });
       }
       process.exit(0);
     }
@@ -140349,7 +140969,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command18();
-var VERSION = true ? "3.6.6" : "0.0.0-dev";
+var VERSION = true ? "3.6.8" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry = createCommandRegistry(context, cleanupAndExit, ensureInitialized);
 registry.registerAll(program);