agentic-qe 3.6.6 → 3.6.7

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();
@@ -6100,7 +6184,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 +6305,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 +6321,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 +6331,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 +6455,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);
@@ -9720,6 +9812,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 +9926,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 +9949,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 +10005,7 @@ var init_attention_wrapper = __esm({
           throughput: seqLen * seqLen / ((endTime - startTime) / 1e3),
           peakMemoryMB: endMemory
         });
+        this.maybePersistToKv();
         return output;
       }
       /**
@@ -10062,6 +10172,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 +11013,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 +18456,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 +18503,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 +18599,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 +18796,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 +18819,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 +18834,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 +19100,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);
         }
@@ -30866,6 +30978,7 @@ var HybridMemoryBackend = class {
   unifiedMemory = null;
   config;
   cleanupInterval;
+  cleanupCount = 0;
   initialized = false;
   constructor(config) {
     this.config = {
@@ -31082,6 +31195,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);
       }
@@ -43320,11 +43458,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 +43481,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 +43534,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 +44817,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 +44833,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 +44862,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 +44891,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 +45316,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 +47690,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 +47707,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 +47715,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 +47737,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 +47813,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 +48243,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 +83184,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 +83418,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 +83479,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 +83490,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 +83882,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 +86981,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 +89615,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)
     );
   }
   // ==========================================================================
@@ -119135,8 +119410,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
    */
@@ -125120,7 +125421,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 +125433,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 +125465,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 +125667,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 +125724,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) {
@@ -135671,6 +136058,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 +136072,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 +136088,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 +136511,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 +145963,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 +152326,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);