agentic-qe 3.7.14 → 3.7.16

package/dist/cli/bundle.js

@@ -11,10 +11,10 @@ var __require = /* @__PURE__ */ ((x67) => typeof require !== "undefined" ? requi
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x67 + '" is not supported');
 });
-var __glob = (map) => (path36) => {
-  var fn = map[path36];
+var __glob = (map) => (path37) => {
+  var fn = map[path37];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path36);
+  throw new Error("Module not found in bundle: " + path37);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -1876,7 +1876,19 @@ var init_hnsw_adapter = __esm({
         this.backend.add(id, vector, metadata);
       }
       search(query, k68) {
-        return this.backend.search(query, k68);
+        const start = performance.now();
+        const results = this.backend.search(query, k68);
+        const elapsed = performance.now() - start;
+        if (elapsed > 50) {
+          console.warn(`[HNSW] search took ${elapsed.toFixed(1)}ms (k=${k68}, results=${results.length})`);
+        }
+        this._lastSearchLatencyMs = elapsed;
+        return results;
+      }
+      /** Last search latency in ms, for instrumentation */
+      _lastSearchLatencyMs = 0;
+      get lastSearchLatencyMs() {
+        return this._lastSearchLatencyMs;
       }
       remove(id) {
         return this.backend.remove(id);
@@ -2549,7 +2561,7 @@ var init_unified_memory_schemas = __esm({
   "src/kernel/unified-memory-schemas.ts"() {
     "use strict";
     init_add_hypergraph_tables();
-    SCHEMA_VERSION = 8;
+    SCHEMA_VERSION = 9;
     SCHEMA_VERSION_TABLE = `
   CREATE TABLE IF NOT EXISTS schema_version (
     id INTEGER PRIMARY KEY CHECK (id = 1),
@@ -2855,6 +2867,31 @@ var init_unified_memory_schemas = __esm({
     FOREIGN KEY (execution_id) REFERENCES execution_results(id)
   );
 
+  -- FTS5 full-text search index for hybrid vector/text search
+  CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(
+    name, description, pattern_type, qe_domain,
+    content='qe_patterns',
+    content_rowid='rowid'
+  );
+
+  -- FTS5 triggers to keep index in sync
+  CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_insert AFTER INSERT ON qe_patterns BEGIN
+    INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+    VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_delete AFTER DELETE ON qe_patterns BEGIN
+    INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
+    VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_update AFTER UPDATE ON qe_patterns BEGIN
+    INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
+    VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
+    INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+    VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
+  END;
+
   -- QE Patterns indexes
   CREATE INDEX IF NOT EXISTS idx_qe_patterns_domain ON qe_patterns(qe_domain);
   CREATE INDEX IF NOT EXISTS idx_qe_patterns_type ON qe_patterns(pattern_type);
@@ -3048,10 +3085,12 @@ var init_unified_memory_schemas = __esm({
     quality_score REAL NOT NULL,
     duration_ms REAL NOT NULL,
     error TEXT,
+    model_tier 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);
+  CREATE INDEX IF NOT EXISTS idx_routing_outcomes_tier ON routing_outcomes(model_tier);
 
   -- Coverage sessions (ADR-023: Coverage Learning)
   CREATE TABLE IF NOT EXISTS coverage_sessions (
@@ -4045,6 +4084,7 @@ __export(unified_memory_exports, {
   validateTableName: () => validateTableName
 });
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 function clearProjectRootCache() {
   _cachedProjectRoot = null;
@@ -4201,6 +4241,7 @@ var init_unified_memory = __esm({
           _UnifiedMemoryManager.instance = null;
         }
         _UnifiedMemoryManager.instancePromise = null;
+        clearProjectRootCache();
       }
       async initialize() {
         if (this.initialized) return;
@@ -4212,6 +4253,17 @@ var init_unified_memory = __esm({
       async _doInitialize() {
         if (this.initialized) return;
         try {
+          const envRoot = process.env.AQE_PROJECT_ROOT;
+          if (envRoot) {
+            const resolvedPath = path.resolve(this.config.dbPath);
+            const resolvedRoot = path.resolve(envRoot);
+            if (!resolvedPath.startsWith(resolvedRoot) && !resolvedPath.startsWith(os.tmpdir()) && resolvedPath.includes(".agentic-qe")) {
+              console.error(
+                `[UnifiedMemory] WARNING: DB path "${this.config.dbPath}" points to a production .agentic-qe/ while AQE_PROJECT_ROOT="${envRoot}". Redirecting to test-safe path.`
+              );
+              this.config.dbPath = path.join(envRoot, ".agentic-qe", "memory.db");
+            }
+          }
           const dir = path.dirname(this.config.dbPath);
           if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
@@ -4385,6 +4437,36 @@ var init_unified_memory = __esm({
             if (currentVersion < 6) this.db.exec(HYPERGRAPH_SCHEMA);
             if (currentVersion < 7) this.db.exec(SONA_PATTERNS_SCHEMA);
             if (currentVersion < 8) this.db.exec(FEEDBACK_SCHEMA);
+            if (currentVersion < 9) {
+              this.db.exec(`
+            CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(
+              name, description, pattern_type, qe_domain,
+              content='qe_patterns',
+              content_rowid='rowid'
+            );
+
+            CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_insert AFTER INSERT ON qe_patterns BEGIN
+              INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+              VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
+            END;
+
+            CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_delete AFTER DELETE ON qe_patterns BEGIN
+              INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
+              VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
+            END;
+
+            CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_update AFTER UPDATE ON qe_patterns BEGIN
+              INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
+              VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
+              INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+              VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
+            END;
+          `);
+              this.db.exec(`
+            INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+            SELECT rowid, name, description, pattern_type, qe_domain FROM qe_patterns;
+          `);
+            }
             this.db.prepare(`
           INSERT OR REPLACE INTO schema_version (id, version, migrated_at)
           VALUES (1, ?, datetime('now'))
@@ -7327,7 +7409,7 @@ function calculateQualityScore(pattern) {
   return pattern.confidence * 0.3 + usageScore * 0.2 + pattern.successRate * 0.5;
 }
 function shouldPromotePattern(pattern, coherenceEnergy, coherenceThreshold = 0.4) {
-  const meetsUsageCriteria = pattern.tier === "short-term" && pattern.successfulUses >= 3;
+  const meetsUsageCriteria = pattern.tier === "short-term" && pattern.successfulUses >= PROMOTION_THRESHOLD;
   const meetsQualityCriteria = pattern.successRate >= 0.7 && pattern.confidence >= 0.6;
   const meetsCoherenceCriteria = coherenceEnergy === void 0 || coherenceEnergy < coherenceThreshold;
   let blockReason;
@@ -7389,7 +7471,7 @@ function applyPatternTemplate(template, variables) {
   }
   return content;
 }
-var QE_DOMAINS, QE_DOMAIN_LIST;
+var QE_DOMAINS, PROMOTION_THRESHOLD, QE_DOMAIN_LIST;
 var init_qe_patterns = __esm({
   "src/learning/qe-patterns.ts"() {
     "use strict";
@@ -7411,6 +7493,7 @@ var init_qe_patterns = __esm({
       "chaos-resilience": /chaos|resilience|fault|inject|blast|recover|latency|failure|stress|load/i,
       "learning-optimization": /learn|pattern|optim|neural|embedding|vector|memory|adapt|train/i
     };
+    PROMOTION_THRESHOLD = 3;
     QE_DOMAIN_LIST = Object.keys(QE_DOMAINS);
   }
 });
@@ -11024,7 +11107,7 @@ var init_gnn_wrapper = __esm({
        * Save index to file
        * Note: @ruvector/gnn uses JSON serialization for layers
        */
-      async saveIndex(namespace, path36) {
+      async saveIndex(namespace, path37) {
         const index = this.indexes.get(namespace);
         if (!index) {
           throw new Error(`Namespace ${namespace} not initialized`);
@@ -11034,15 +11117,15 @@ var init_gnn_wrapper = __esm({
           vector: Array.from(emb.vector),
           metadata: emb.metadata
         }));
-        const fs31 = await import("fs/promises");
-        await fs31.writeFile(path36, JSON.stringify(data, null, 2));
+        const fs32 = await import("fs/promises");
+        await fs32.writeFile(path37, JSON.stringify(data, null, 2));
       }
       /**
        * Load index from file
        */
-      async loadIndex(namespace, path36) {
-        const fs31 = await import("fs/promises");
-        const content = await fs31.readFile(path36, "utf-8");
+      async loadIndex(namespace, path37) {
+        const fs32 = await import("fs/promises");
+        const content = await fs32.readFile(path37, "utf-8");
         const data = safeJsonParse(content);
         this.initializeIndex(namespace);
         for (const item of data) {
@@ -12544,7 +12627,7 @@ var init_path_traversal_validator = __esm({
       /**
        * Validate a file path against traversal attacks
        */
-      validate(path36, options = {}) {
+      validate(path37, options = {}) {
         const {
           basePath = "",
           allowAbsolute = false,
@@ -12553,7 +12636,7 @@ var init_path_traversal_validator = __esm({
           maxDepth = 10,
           maxLength = 4096
         } = options;
-        if (path36.length > maxLength) {
+        if (path37.length > maxLength) {
           return {
             valid: false,
             error: `Path exceeds maximum length of ${maxLength}`,
@@ -12561,7 +12644,7 @@ var init_path_traversal_validator = __esm({
           };
         }
         for (const pattern of PATH_TRAVERSAL_PATTERNS) {
-          if (pattern.test(path36)) {
+          if (pattern.test(path37)) {
             return {
               valid: false,
               error: "Path traversal attempt detected",
@@ -12569,7 +12652,7 @@ var init_path_traversal_validator = __esm({
             };
           }
         }
-        if (!allowAbsolute && (path36.startsWith("/") || /^[A-Z]:/i.test(path36))) {
+        if (!allowAbsolute && (path37.startsWith("/") || /^[A-Z]:/i.test(path37))) {
           return {
             valid: false,
             error: "Absolute paths are not allowed",
@@ -12577,7 +12660,7 @@ var init_path_traversal_validator = __esm({
           };
         }
         for (const pattern of DANGEROUS_PATH_COMPONENTS) {
-          if (pattern.test(path36)) {
+          if (pattern.test(path37)) {
             return {
               valid: false,
               error: "Access to system paths is not allowed",
@@ -12585,7 +12668,7 @@ var init_path_traversal_validator = __esm({
             };
           }
         }
-        const normalizedPath = this.normalizePath(path36);
+        const normalizedPath = this.normalizePath(path37);
         if (normalizedPath.includes("..")) {
           return {
             valid: false,
@@ -12648,8 +12731,8 @@ var init_path_traversal_validator = __esm({
       /**
        * Normalize a path by resolving . and .. components
        */
-      normalizePath(path36) {
-        let normalized = path36.replace(/\\/g, "/");
+      normalizePath(path37) {
+        let normalized = path37.replace(/\\/g, "/");
         normalized = normalized.replace(/\/+/g, "/");
         const parts = normalized.split("/");
         const result = [];
@@ -12690,13 +12773,13 @@ var init_path_traversal_validator = __esm({
       /**
        * Get file extension from path
        */
-      getExtension(path36) {
-        const match = path36.match(/\.([^./\\]+)$/);
+      getExtension(path37) {
+        const match = path37.match(/\.([^./\\]+)$/);
         return match ? match[1] : null;
       }
     };
     defaultValidator2 = new PathTraversalValidator();
-    validatePath = (path36, options) => defaultValidator2.validate(path36, options);
+    validatePath = (path37, options) => defaultValidator2.validate(path37, options);
   }
 });
 
@@ -13797,23 +13880,23 @@ var init_knowledge_graph = __esm({
           if (!incremental) {
             await this.clear();
           }
-          for (const path36 of paths) {
+          for (const path37 of paths) {
             try {
               if (languages && languages.length > 0) {
-                const ext = this.getFileExtension(path36);
+                const ext = this.getFileExtension(path37);
                 if (!this.matchesLanguage(ext, languages)) {
                   continue;
                 }
               }
-              if (!includeTests && this.isTestFile(path36)) {
+              if (!includeTests && this.isTestFile(path37)) {
                 continue;
               }
-              const result = await this.indexFile(path36);
+              const result = await this.indexFile(path37);
               nodesCreated += result.nodes;
               edgesCreated += result.edges;
             } catch (fileError) {
               errors.push({
-                file: path36,
+                file: path37,
                 error: toErrorMessage(fileError)
               });
             }
@@ -14527,16 +14610,16 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
           }
         });
       }
-      async traverseDependencies(file, direction, depth, visited, nodes, edges, path36, cycles) {
+      async traverseDependencies(file, direction, depth, visited, nodes, edges, path37, cycles) {
         if (depth <= 0 || visited.has(file)) {
-          const cycleStart = path36.indexOf(file);
+          const cycleStart = path37.indexOf(file);
           if (cycleStart >= 0) {
-            cycles.push([...path36.slice(cycleStart), file]);
+            cycles.push([...path37.slice(cycleStart), file]);
           }
           return;
         }
         visited.add(file);
-        path36.push(file);
+        path37.push(file);
         const nodeId = this.pathToNodeId(file);
         const fileEdges = await this.getEdges(nodeId, direction);
         const inDegree = fileEdges.filter((e20) => e20.target === nodeId).length;
@@ -14566,12 +14649,12 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
               visited,
               nodes,
               edges,
-              path36,
+              path37,
               cycles
             );
           }
         }
-        path36.pop();
+        path37.pop();
       }
       calculateDependencyMetrics(nodes, edges) {
         const totalNodes = nodes.length;
@@ -14656,23 +14739,23 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
         const magnitude2 = Math.sqrt(embedding.reduce((sum, v65) => sum + v65 * v65, 0)) || 1;
         return embedding.map((v65) => v65 / magnitude2);
       }
-      pathToNodeId(path36) {
-        return path36.replace(/[/\\]/g, ":").replace(/\./g, "_");
+      pathToNodeId(path37) {
+        return path37.replace(/[/\\]/g, ":").replace(/\./g, "_");
       }
       nodeIdToPath(nodeId) {
-        const path36 = nodeId.replace(/:/g, "/").replace(/_(?=[^_]*$)/, ".");
-        return path36.includes("/") ? path36 : null;
+        const path37 = nodeId.replace(/:/g, "/").replace(/_(?=[^_]*$)/, ".");
+        return path37.includes("/") ? path37 : null;
       }
-      getFileName(path36) {
-        return path36.split(/[/\\]/).pop() || path36;
+      getFileName(path37) {
+        return path37.split(/[/\\]/).pop() || path37;
       }
-      getFileExtension(path36) {
-        const name = this.getFileName(path36);
+      getFileExtension(path37) {
+        const name = this.getFileName(path37);
         const parts = name.split(".");
         return parts.length > 1 ? parts.pop() : "";
       }
-      getFileType(path36) {
-        const ext = this.getFileExtension(path36);
+      getFileType(path37) {
+        const ext = this.getFileExtension(path37);
         const typeMap = {
           ts: "typescript",
           tsx: "typescript-react",
@@ -14701,7 +14784,7 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
           return exts.includes(ext);
         });
       }
-      isTestFile(path36) {
+      isTestFile(path37) {
         const testPatterns = [
           /\.test\.[tj]sx?$/,
           /\.spec\.[tj]sx?$/,
@@ -14710,7 +14793,7 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
           /.*_test\.py$/,
           /.*_test\.go$/
         ];
-        return testPatterns.some((pattern) => pattern.test(path36));
+        return testPatterns.some((pattern) => pattern.test(path37));
       }
       /**
        * Dispose of all resources and clear caches.
@@ -15049,7 +15132,7 @@ var init_impact_analyzer = __esm({
       // ============================================================================
       // Private Helper Methods
       // ============================================================================
-      isTestFile(path36) {
+      isTestFile(path37) {
         const testPatterns = [
           /\.test\.[tj]sx?$/,
           /\.spec\.[tj]sx?$/,
@@ -15058,15 +15141,15 @@ var init_impact_analyzer = __esm({
           /.*_test\.py$/,
           /.*_test\.go$/
         ];
-        return testPatterns.some((pattern) => pattern.test(path36));
+        return testPatterns.some((pattern) => pattern.test(path37));
       }
-      isCriticalPath(path36) {
+      isCriticalPath(path37) {
         const criticalPatterns = this.config.criticalPaths.map(
           (p74) => p74.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
         );
-        return criticalPatterns.some((pattern) => new RegExp(pattern).test(path36));
+        return criticalPatterns.some((pattern) => new RegExp(pattern).test(path37));
       }
-      isEntryPoint(path36) {
+      isEntryPoint(path37) {
         const entryPatterns = [
           /\/index\.[tj]sx?$/,
           /\/main\.[tj]sx?$/,
@@ -15076,14 +15159,14 @@ var init_impact_analyzer = __esm({
           /\/__init__\.py$/,
           /\/main\.go$/
         ];
-        return entryPatterns.some((pattern) => pattern.test(path36));
+        return entryPatterns.some((pattern) => pattern.test(path37));
       }
-      getBaseName(path36) {
-        const fileName = this.getFileName(path36);
+      getBaseName(path37) {
+        const fileName = this.getFileName(path37);
         return fileName.replace(/\.[^.]+$/, "");
       }
-      getFileName(path36) {
-        return path36.split(/[/\\]/).pop() || path36;
+      getFileName(path37) {
+        return path37.split(/[/\\]/).pop() || path37;
       }
       deduplicateImpact(impact) {
         const seen = /* @__PURE__ */ new Map();
@@ -18591,7 +18674,7 @@ var init_pattern_store = __esm({
         efSearch: 100,
         maxElements: 5e4
       },
-      promotionThreshold: 3,
+      promotionThreshold: PROMOTION_THRESHOLD,
       minConfidence: 0.3,
       maxPatternsPerDomain: 5e3,
       autoCleanup: true,
@@ -18624,6 +18707,7 @@ var init_pattern_store = __esm({
       cleanupTimer;
       // Optional SQLite persistence delegate for delete/promote
       sqliteStore = null;
+      loadingPromise = null;
       // In-memory caches for fast access
       patternCache = /* @__PURE__ */ new Map();
       domainIndex = /* @__PURE__ */ new Map();
@@ -18640,12 +18724,22 @@ var init_pattern_store = __esm({
         searchLatencies: []
       };
       /**
-       * Set SQLite persistence delegate for delete/promote operations.
-       * When set, PatternStore will forward these operations to SQLite
-       * in addition to updating the in-memory cache.
+       * Set SQLite persistence delegate and load patterns into memory.
+       *
+       * When set, PatternStore will:
+       * 1. Load existing patterns from SQLite into the in-memory cache
+       * 2. Forward create/delete/promote operations to SQLite for persistence
+       * 3. Persist embeddings alongside patterns on store()
        */
       setSqliteStore(store) {
         this.sqliteStore = store;
+        if (this.initialized) {
+          this.loadingPromise = this.loadPatterns().catch(
+            (e20) => console.warn("[PatternStore] Failed to load patterns after setSqliteStore:", e20)
+          ).finally(() => {
+            this.loadingPromise = null;
+          });
+        }
       }
       /**
        * Initialize the pattern store
@@ -18716,6 +18810,40 @@ var init_pattern_store = __esm({
           );
           await Promise.race([initPromise3, timeoutPromise]);
           this.hnswAvailable = this.hnswIndex.isNativeAvailable();
+          if (this.sqliteStore) {
+            try {
+              const embeddings = this.sqliteStore.getAllEmbeddings();
+              const maxBootstrap = this.config.hnsw.maxElements;
+              let loaded = 0;
+              for (const { patternId, embedding } of embeddings) {
+                if (loaded >= maxBootstrap) break;
+                if (!embedding || embedding.length !== this.config.embeddingDimension) continue;
+                const pattern = this.patternCache.get(patternId);
+                if (!pattern) continue;
+                try {
+                  await this.hnswIndex.insert(patternId, embedding, {
+                    filePath: pattern.patternType,
+                    lineCoverage: pattern.confidence * 100,
+                    branchCoverage: pattern.qualityScore * 100,
+                    functionCoverage: 0,
+                    statementCoverage: 0,
+                    uncoveredLineCount: 0,
+                    uncoveredBranchCount: 0,
+                    riskScore: 1 - pattern.confidence,
+                    lastUpdated: Date.now(),
+                    totalLines: 0
+                  });
+                  loaded++;
+                } catch {
+                }
+              }
+              if (loaded > 0) {
+                console.log(`[PatternStore] Loaded ${loaded} embeddings from SQLite into HNSW`);
+              }
+            } catch (error) {
+              console.warn("[PatternStore] Failed to load SQLite embeddings into HNSW:", toErrorMessage(error));
+            }
+          }
           console.log(
             `[PatternStore] HNSW lazy-initialized (native: ${this.hnswAvailable})`
           );
@@ -18729,9 +18857,32 @@ var init_pattern_store = __esm({
         }
       }
       /**
-       * Load existing patterns from memory with timeout protection
+       * Load existing patterns from SQLite into in-memory cache.
+       *
+       * Previously this was a no-op after Issue #258 removed kv_store duplication,
+       * but that left 15,634 SQLite patterns invisible to search on every restart.
+       * Now properly loads from SQLitePatternStore when wired.
        */
       async loadPatterns() {
+        if (!this.sqliteStore) {
+          return;
+        }
+        try {
+          const patterns = this.sqliteStore.getPatterns({ limit: 5e4 });
+          for (const pattern of patterns) {
+            this.indexPattern(pattern);
+          }
+          if (patterns.length > 0) {
+            console.log(
+              `[PatternStore] Loaded ${patterns.length} patterns from SQLite into memory cache`
+            );
+          }
+        } catch (error) {
+          console.warn(
+            "[PatternStore] Failed to load patterns from SQLite:",
+            toErrorMessage(error)
+          );
+        }
       }
       /**
        * Index a pattern in local caches
@@ -18746,7 +18897,11 @@ var init_pattern_store = __esm({
           this.typeIndex.set(pattern.patternType, /* @__PURE__ */ new Set());
         }
         this.typeIndex.get(pattern.patternType).add(pattern.id);
-        this.tierIndex.get(pattern.tier).add(pattern.id);
+        const tier = pattern.tier === "long-term" ? "long-term" : "short-term";
+        if (pattern.tier !== tier) {
+          pattern.tier = tier;
+        }
+        this.tierIndex.get(tier).add(pattern.id);
       }
       /**
        * Remove pattern from local indices
@@ -18764,6 +18919,9 @@ var init_pattern_store = __esm({
         if (!this.initialized) {
           await this.initialize();
         }
+        if (this.loadingPromise) {
+          await this.loadingPromise;
+        }
         const validation = validateQEPattern(pattern);
         if (!validation.valid) {
           return err(new Error(`Invalid pattern: ${validation.errors.join(", ")}`));
@@ -18780,6 +18938,13 @@ var init_pattern_store = __esm({
           await this.cleanupDomain(pattern.qeDomain);
         }
         this.indexPattern(pattern);
+        if (this.sqliteStore) {
+          try {
+            this.sqliteStore.storePattern(pattern, pattern.embedding);
+          } catch (error) {
+            console.warn(`[PatternStore] SQLite persist failed for ${pattern.id}:`, toErrorMessage(error));
+          }
+        }
         if (pattern.embedding) {
           const hnsw = await this.ensureHNSW();
           if (hnsw) {
@@ -18875,6 +19040,9 @@ var init_pattern_store = __esm({
         if (!this.initialized) {
           await this.initialize();
         }
+        if (this.loadingPromise) {
+          await this.loadingPromise;
+        }
         return this.patternCache.get(id) ?? null;
       }
       /**
@@ -18884,6 +19052,9 @@ var init_pattern_store = __esm({
         if (!this.initialized) {
           await this.initialize();
         }
+        if (this.loadingPromise) {
+          await this.loadingPromise;
+        }
         const startTime = performance.now();
         const limit = options.limit || 10;
         const results = [];
@@ -18909,13 +19080,60 @@ var init_pattern_store = __esm({
               }
             }
           }
+          if (typeof query === "string" && query.trim() && this.sqliteStore) {
+            try {
+              const ftsResults = this.sqliteStore.searchFTS(query, limit * 2);
+              if (ftsResults.length > 0) {
+                const ftsScoreMap = new Map(ftsResults.map((r54) => [r54.id, r54.ftsScore]));
+                const existingIds = new Set(results.map((r54) => r54.pattern.id));
+                for (const result of results) {
+                  const ftsScore = ftsScoreMap.get(result.pattern.id);
+                  if (ftsScore !== void 0) {
+                    result.score = 0.75 * result.score + 0.25 * ftsScore;
+                  }
+                }
+                for (const ftsResult of ftsResults) {
+                  if (existingIds.has(ftsResult.id)) continue;
+                  const pattern = await this.get(ftsResult.id);
+                  if (pattern && this.matchesFilters(pattern, options)) {
+                    const reuseInfo = this.calculateReuseInfo(pattern, ftsResult.ftsScore);
+                    results.push({
+                      pattern,
+                      score: 0.5 * ftsResult.ftsScore,
+                      // FTS-only: exact keyword match is valuable
+                      matchType: "exact",
+                      similarity: ftsResult.ftsScore,
+                      canReuse: reuseInfo.canReuse,
+                      estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
+                      reuseConfidence: reuseInfo.reuseConfidence
+                    });
+                  }
+                }
+              }
+            } catch {
+            }
+          }
           if (typeof query === "string" || results.length < limit) {
             const textResults = await this.searchByText(
               typeof query === "string" ? query : "",
               options,
               limit - results.length
             );
-            results.push(...textResults);
+            const existingIds = new Set(results.map((r54) => r54.pattern.id));
+            for (const tr3 of textResults) {
+              if (!existingIds.has(tr3.pattern.id)) {
+                results.push(tr3);
+              }
+            }
+          }
+          const TEMPORAL_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1e3;
+          const now = Date.now();
+          for (const result of results) {
+            const lastUsed = result.pattern.lastUsedAt?.getTime() ?? result.pattern.createdAt.getTime();
+            const ageMs = now - lastUsed;
+            const decayFactor = Math.pow(0.5, ageMs / TEMPORAL_HALF_LIFE_MS);
+            const effectiveDecay = result.pattern.usageCount > 0 ? decayFactor : 0.5;
+            result.score = result.score * (0.7 + 0.3 * effectiveDecay);
           }
           results.sort((a37, b68) => b68.score - a37.score);
           const finalResults = results.slice(0, limit);
@@ -19067,6 +19285,13 @@ var init_pattern_store = __esm({
           qualityScore,
           lastUsedAt: now
         };
+        if (this.sqliteStore) {
+          try {
+            this.sqliteStore.recordUsage(id, success);
+          } catch (error) {
+            console.warn(`[PatternStore] SQLite recordUsage failed for ${id}:`, toErrorMessage(error));
+          }
+        }
         const promotionCheck = shouldPromotePattern(updated);
         const shouldPromote = promotionCheck.meetsUsageCriteria && promotionCheck.meetsQualityCriteria && promotionCheck.meetsCoherenceCriteria;
         if (shouldPromote && updated.tier === "short-term") {
@@ -19192,7 +19417,8 @@ var init_pattern_store = __esm({
             continue;
           }
           if (pattern.tier === "short-term") {
-            const ageMs = Date.now() - pattern.createdAt.getTime();
+            const createdTime = pattern.createdAt instanceof Date ? pattern.createdAt.getTime() : new Date(pattern.createdAt).getTime();
+            const ageMs = Date.now() - createdTime;
             const isOld = ageMs > 7 * 24 * 60 * 60 * 1e3;
             const isLowQuality = pattern.qualityScore < 0.2;
             const isUnused = pattern.usageCount === 0 && ageMs > 24 * 60 * 60 * 1e3;
@@ -19830,9 +20056,9 @@ var init_opencode_installer = __esm({
           // NPM package location
           join32(__dirname3, "../../assets/opencode")
         ];
-        for (const path36 of possiblePaths) {
-          if (existsSync28(path36)) {
-            return path36;
+        for (const path37 of possiblePaths) {
+          if (existsSync28(path37)) {
+            return path37;
           }
         }
         return join32(process.cwd(), ".opencode");
@@ -22312,47 +22538,47 @@ function saveIdMap(rvfPath, strToNum, nextLabel) {
   };
   writeFileSync31(idMapPath(rvfPath), JSON.stringify(data), "utf-8");
 }
-function createRvfStore(path36, dimensions) {
+function createRvfStore(path37, dimensions) {
   const native = getNative();
   if (!native) {
     throw new Error(
       "@ruvector/rvf-node is not available \u2014 install the package or check platform compatibility"
     );
   }
-  const db = native.RvfDatabase.create(path36, { dimension: dimensions });
+  const db = native.RvfDatabase.create(path37, { dimension: dimensions });
   const dim = db.dimension();
   return new RvfNativeAdapterImpl(
     db,
-    path36,
+    path37,
     dim,
     /* @__PURE__ */ new Map(),
     /* @__PURE__ */ new Map(),
     1
   );
 }
-function openRvfStore(path36) {
+function openRvfStore(path37) {
   const native = getNative();
   if (!native) {
     throw new Error(
       "@ruvector/rvf-node is not available \u2014 install the package or check platform compatibility"
     );
   }
-  const db = native.RvfDatabase.open(path36);
+  const db = native.RvfDatabase.open(path37);
   const dim = db.dimension();
-  const { strToNum, numToStr, nextLabel } = loadIdMap(path36);
-  return new RvfNativeAdapterImpl(db, path36, dim, strToNum, numToStr, nextLabel);
+  const { strToNum, numToStr, nextLabel } = loadIdMap(path37);
+  return new RvfNativeAdapterImpl(db, path37, dim, strToNum, numToStr, nextLabel);
 }
-function openRvfStoreReadonly(path36) {
+function openRvfStoreReadonly(path37) {
   const native = getNative();
   if (!native) {
     throw new Error(
       "@ruvector/rvf-node is not available \u2014 install the package or check platform compatibility"
     );
   }
-  const db = native.RvfDatabase.openReadonly(path36);
+  const db = native.RvfDatabase.openReadonly(path37);
   const dim = db.dimension();
-  const { strToNum, numToStr, nextLabel } = loadIdMap(path36);
-  return new RvfNativeAdapterImpl(db, path36, dim, strToNum, numToStr, nextLabel);
+  const { strToNum, numToStr, nextLabel } = loadIdMap(path37);
+  return new RvfNativeAdapterImpl(db, path37, dim, strToNum, numToStr, nextLabel);
 }
 function isRvfNativeAvailable() {
   return getNative() !== null;
@@ -23473,15 +23699,15 @@ var init_vitest_executor = __esm({
       }
       async getCoverageFromReport() {
         try {
-          const fs31 = await import("fs/promises");
-          const path36 = await import("path");
+          const fs32 = await import("fs/promises");
+          const path37 = await import("path");
           const coverageDir = this.config.coverageDir || "coverage";
-          const coverageFile = path36.join(
+          const coverageFile = path37.join(
             this.config.cwd || process.cwd(),
             coverageDir,
             "coverage-summary.json"
           );
-          const content = await fs31.readFile(coverageFile, "utf-8");
+          const content = await fs32.readFile(coverageFile, "utf-8");
           const coverage = safeJsonParse(content);
           return (coverage.total?.lines?.pct ?? 0) / 100;
         } catch {
@@ -23533,14 +23759,14 @@ var init_test_selector = __esm({
       {
         sourcePattern: /^src\/(.+)\.ts$/,
         toTestPaths: (match, _sourceFile) => {
-          const path36 = match[1];
+          const path37 = match[1];
           return [
-            `tests/unit/${path36}.test.ts`,
-            `tests/unit/${path36}.spec.ts`,
-            `tests/${path36}.test.ts`,
-            `tests/${path36}.spec.ts`,
-            `src/${path36}.test.ts`,
-            `src/${path36}.spec.ts`
+            `tests/unit/${path37}.test.ts`,
+            `tests/unit/${path37}.spec.ts`,
+            `tests/${path37}.test.ts`,
+            `tests/${path37}.spec.ts`,
+            `src/${path37}.test.ts`,
+            `src/${path37}.spec.ts`
           ];
         }
       },
@@ -23548,11 +23774,11 @@ var init_test_selector = __esm({
       {
         sourcePattern: /^src\/(.+)\/index\.ts$/,
         toTestPaths: (match, _sourceFile) => {
-          const path36 = match[1];
+          const path37 = match[1];
           return [
-            `tests/unit/${path36}.test.ts`,
-            `tests/unit/${path36}/index.test.ts`,
-            `tests/unit/${path36}.spec.ts`
+            `tests/unit/${path37}.test.ts`,
+            `tests/unit/${path37}/index.test.ts`,
+            `tests/unit/${path37}.spec.ts`
           ];
         }
       },
@@ -23624,8 +23850,8 @@ var init_test_selector = __esm({
        * Get tests for a specific list of changed files
        */
       async selectTestsForFiles(files) {
-        const changedFiles = files.map((path36) => ({
-          path: path36,
+        const changedFiles = files.map((path37) => ({
+          path: path37,
           changeType: "modified"
         }));
         const { selectedTests, mappings, runAllTests, runAllReason } = await this.mapChangesToTests(changedFiles);
@@ -23651,7 +23877,7 @@ var init_test_selector = __esm({
         const changedFiles = [];
         for (const line of lines) {
           const [status, ...pathParts] = line.split("	");
-          const path36 = pathParts.join("	");
+          const path37 = pathParts.join("	");
           let changeType;
           let previousPath;
           switch (status[0]) {
@@ -23666,13 +23892,13 @@ var init_test_selector = __esm({
               break;
             case "R":
               changeType = "renamed";
-              previousPath = path36;
+              previousPath = path37;
               break;
             default:
               changeType = "modified";
           }
           changedFiles.push({
-            path: changeType === "renamed" ? pathParts[1] || path36 : path36,
+            path: changeType === "renamed" ? pathParts[1] || path37 : path37,
             changeType,
             previousPath
           });
@@ -23749,8 +23975,8 @@ var init_test_selector = __esm({
       /**
        * Check if a file is a config file that should trigger full test run
        */
-      isConfigFile(path36) {
-        return /^(vitest\.config|jest\.config|tsconfig|package\.json)/.test(path36);
+      isConfigFile(path37) {
+        return /^(vitest\.config|jest\.config|tsconfig|package\.json)/.test(path37);
       }
       async findTestsHeuristically(sourcePath) {
         const baseName = basename7(sourcePath, ".ts").replace(/\.(tsx?|jsx?)$/, "");
@@ -23765,12 +23991,12 @@ var init_test_selector = __esm({
         return this.filterExistingFiles(candidates);
       }
       async filterExistingFiles(files) {
-        const fs31 = await import("fs/promises");
+        const fs32 = await import("fs/promises");
         const existing = [];
         for (const file of files) {
           try {
             const fullPath = resolve11(this.cwd, file);
-            await fs31.access(fullPath);
+            await fs32.access(fullPath);
             existing.push(file);
           } catch (error) {
             console.debug("[TestSelector] File access check failed:", error instanceof Error ? error.message : error);
@@ -23810,8 +24036,8 @@ function createFlakyTracker(config) {
 async function loadFlakyTracker(historyPath, config) {
   const tracker = createFlakyTracker({ ...config, historyPath });
   try {
-    const fs31 = await import("fs/promises");
-    const content = await fs31.readFile(historyPath, "utf-8");
+    const fs32 = await import("fs/promises");
+    const content = await fs32.readFile(historyPath, "utf-8");
     const records = safeJsonParse(content);
     tracker.importHistory(records);
   } catch (error) {
@@ -23820,9 +24046,9 @@ async function loadFlakyTracker(historyPath, config) {
   return tracker;
 }
 async function saveFlakyTracker(tracker, historyPath) {
-  const fs31 = await import("fs/promises");
+  const fs32 = await import("fs/promises");
   const history = tracker.exportHistory();
-  await fs31.writeFile(historyPath, JSON.stringify(history, null, 2));
+  await fs32.writeFile(historyPath, JSON.stringify(history, null, 2));
 }
 var DEFAULT_CONFIG62, FlakyTestTracker;
 var init_flaky_tracker = __esm({
@@ -24131,16 +24357,16 @@ var init_github_actions = __esm({
        */
       async writeOutput(results) {
         const output = this.generateOutput(results);
-        const fs31 = await import("fs/promises");
+        const fs32 = await import("fs/promises");
         for (const annotation of output.annotations) {
           this.writeAnnotation(annotation);
         }
         if (output.summary && process.env.GITHUB_STEP_SUMMARY) {
-          await fs31.appendFile(process.env.GITHUB_STEP_SUMMARY, output.summary);
+          await fs32.appendFile(process.env.GITHUB_STEP_SUMMARY, output.summary);
         }
         if (process.env.GITHUB_OUTPUT) {
           const outputLines = Object.entries(output.outputs).map(([key, value]) => `${key}=${value}`).join("\n");
-          await fs31.appendFile(process.env.GITHUB_OUTPUT, outputLines + "\n");
+          await fs32.appendFile(process.env.GITHUB_OUTPUT, outputLines + "\n");
         }
       }
       // --------------------------------------------------------------------------
@@ -24372,6 +24598,7 @@ var init_pipeline = __esm({
         const startTime = Date.now();
         let selectedTests = [];
         let ranAllTests = this.config.runAllTests ?? false;
+        const selectionStart = performance.now();
         if (!ranAllTests) {
           const selectionResult = await this.selector.selectAffectedTests();
           if (selectionResult.runAllTests) {
@@ -24385,19 +24612,26 @@ var init_pipeline = __esm({
             console.log(`[TestSchedulingPipeline] Selected ${selectedTests.length} affected tests`);
           }
         }
+        const selectionMs = performance.now() - selectionStart;
+        const executionStart = performance.now();
         let phaseResults;
         if (ranAllTests) {
           phaseResults = await this.scheduler.run();
         } else {
           phaseResults = await this.runWithSelectedTests(selectedTests);
         }
+        const executionMs = performance.now() - executionStart;
+        const analysisStart = performance.now();
         const flakyAnalysis = this.flakyTracker.analyze();
         if (this.config.flakyHistoryPath) {
           await saveFlakyTracker(this.flakyTracker, this.config.flakyHistoryPath);
         }
+        const analysisMs = performance.now() - analysisStart;
+        const reportingStart = performance.now();
         if (this.ciEnvironment.isCI) {
           await this.reporter.writeOutput(phaseResults);
         }
+        const reportingMs = performance.now() - reportingStart;
         const totalDurationMs = Date.now() - startTime;
         return {
           phaseResults,
@@ -24405,7 +24639,8 @@ var init_pipeline = __esm({
           ranAllTests,
           flakyAnalysis,
           ciEnvironment: this.ciEnvironment,
-          totalDurationMs
+          totalDurationMs,
+          stepLatencies: { selectionMs, executionMs, analysisMs, reportingMs }
         };
       }
       /**
@@ -26188,6 +26423,24 @@ var init_visual_security = __esm({
 });
 
 // src/learning/sqlite-persistence.ts
+function hashEmbedding(text, dimension = 384) {
+  const embedding = new Array(dimension).fill(0);
+  const normalized = text.toLowerCase().trim();
+  for (let pass = 0; pass < 3; pass++) {
+    for (let i58 = 0; i58 < normalized.length; i58++) {
+      const charCode = normalized.charCodeAt(i58);
+      const idx = charCode * (i58 + 1) * (pass + 1) % dimension;
+      embedding[idx] += Math.sin(charCode * (pass + 1)) / (i58 + 1);
+    }
+  }
+  const magnitude2 = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+  if (magnitude2 > 0) {
+    for (let i58 = 0; i58 < dimension; i58++) {
+      embedding[i58] /= magnitude2;
+    }
+  }
+  return embedding;
+}
 function createSQLitePatternStore(config = {}) {
   return new SQLitePatternStore(config);
 }
@@ -26200,6 +26453,7 @@ var init_sqlite_persistence = __esm({
     init_safe_json();
     init_error_utils();
     init_unified_memory();
+    init_real_embeddings();
     DEFAULT_SQLITE_CONFIG = {
       // LEGACY: Ignored when useUnified=true (the default). All data goes to memory.db
       dbPath: ".agentic-qe/memory.db",
@@ -26233,11 +26487,11 @@ var init_sqlite_persistence = __esm({
             this.db = this.unifiedMemory.getDatabase();
             console.log(`[SQLitePatternStore] Using unified storage: ${this.unifiedMemory.getDbPath()}`);
           } else {
-            const path36 = await import("path");
-            const fs31 = await import("fs");
-            const dir = path36.dirname(this.config.dbPath);
-            if (!fs31.existsSync(dir)) {
-              fs31.mkdirSync(dir, { recursive: true });
+            const path37 = await import("path");
+            const fs32 = await import("fs");
+            const dir = path37.dirname(this.config.dbPath);
+            if (!fs32.existsSync(dir)) {
+              fs32.mkdirSync(dir, { recursive: true });
             }
             this.db = openDatabase(this.config.dbPath);
             this.db.pragma(`mmap_size = ${this.config.mmapSize}`);
@@ -26332,6 +26586,31 @@ var init_sqlite_persistence = __esm({
       CREATE UNIQUE INDEX IF NOT EXISTS idx_patterns_unique_name_domain_type
         ON qe_patterns(name, qe_domain, pattern_type);
 
+      -- FTS5 full-text search index for hybrid vector/text search
+      CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(
+        name, description, pattern_type, qe_domain,
+        content='qe_patterns',
+        content_rowid='rowid'
+      );
+
+      -- FTS5 triggers to keep index in sync
+      CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_insert AFTER INSERT ON qe_patterns BEGIN
+        INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+        VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_delete AFTER DELETE ON qe_patterns BEGIN
+        INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
+        VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_update AFTER UPDATE ON qe_patterns BEGIN
+        INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
+        VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
+        INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
+        VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
+      END;
+
       -- Indexes for performance
       CREATE INDEX IF NOT EXISTS idx_patterns_domain ON qe_patterns(qe_domain);
       CREATE INDEX IF NOT EXISTS idx_patterns_type ON qe_patterns(pattern_type);
@@ -26394,10 +26673,22 @@ var init_sqlite_persistence = __esm({
       prepareStatements() {
         if (!this.db) throw new Error("Database not initialized");
         this.prepared.set("insertPattern", this.db.prepare(`
-      INSERT OR REPLACE INTO qe_patterns (
+      INSERT INTO qe_patterns (
         id, pattern_type, qe_domain, domain, name, description,
         confidence, tier, template_json, context_json
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        confidence = excluded.confidence,
+        tier = excluded.tier,
+        template_json = excluded.template_json,
+        context_json = excluded.context_json,
+        updated_at = datetime('now')
+      ON CONFLICT(name, qe_domain, pattern_type) DO UPDATE SET
+        confidence = excluded.confidence,
+        tier = excluded.tier,
+        template_json = excluded.template_json,
+        context_json = excluded.context_json,
+        updated_at = datetime('now')
     `));
         this.prepared.set("insertEmbedding", this.db.prepare(`
       INSERT OR REPLACE INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model)
@@ -26506,6 +26797,69 @@ var init_sqlite_persistence = __esm({
         }
         return rows.map((row) => this.rowToPattern(row));
       }
+      /**
+       * FTS5 full-text search for patterns.
+       * Returns pattern IDs with BM25 relevance scores.
+       */
+      searchFTS(query, limit = 20) {
+        if (!this.db) throw new Error("Database not initialized");
+        if (!query.trim()) return [];
+        const sanitized = '"' + query.replace(/"/g, '""') + '"';
+        const start = performance.now();
+        try {
+          const rows = this.db.prepare(`
+        SELECT p.id, rank AS fts_score
+        FROM qe_patterns_fts fts
+        JOIN qe_patterns p ON p.rowid = fts.rowid
+        WHERE qe_patterns_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `).all(sanitized, limit);
+          const elapsed = performance.now() - start;
+          if (elapsed > 50) {
+            console.warn(`[FTS5] searchFTS took ${elapsed.toFixed(1)}ms (results=${rows.length})`);
+          }
+          this._lastFtsLatencyMs = elapsed;
+          const maxAbsScore = Math.max(...rows.map((r54) => Math.abs(r54.fts_score)), 1);
+          return rows.map((r54) => ({
+            id: r54.id,
+            ftsScore: Math.abs(r54.fts_score) / maxAbsScore
+          }));
+        } catch {
+          return [];
+        }
+      }
+      /** Last FTS5 search latency in ms, for instrumentation */
+      _lastFtsLatencyMs = 0;
+      get lastFtsLatencyMs() {
+        return this._lastFtsLatencyMs;
+      }
+      /**
+       * Ghost pattern check: find patterns in SQLite that have no embeddings.
+       * Used by aqe_health to detect data integrity issues.
+       */
+      getGhostPatternCount() {
+        if (!this.db) throw new Error("Database not initialized");
+        const total = this.db.prepare(
+          `SELECT COUNT(*) as c FROM qe_patterns WHERE id NOT LIKE 'bench-%'`
+        ).get().c;
+        const ghostCount = this.db.prepare(`
+      SELECT COUNT(*) as c FROM qe_patterns p
+      WHERE p.id NOT LIKE 'bench-%'
+        AND p.id NOT IN (SELECT pattern_id FROM qe_pattern_embeddings)
+    `).get().c;
+        const sampleGhosts = this.db.prepare(`
+      SELECT p.id FROM qe_patterns p
+      WHERE p.id NOT LIKE 'bench-%'
+        AND p.id NOT IN (SELECT pattern_id FROM qe_pattern_embeddings)
+      LIMIT 10
+    `).all();
+        return {
+          total,
+          withoutEmbeddings: ghostCount,
+          sampleGhostIds: sampleGhosts.map((g67) => g67.id)
+        };
+      }
       /**
        * Get all embeddings for HNSW indexing
        */
@@ -26838,6 +27192,95 @@ var init_sqlite_persistence = __esm({
           };
         }
       }
+      /**
+       * Backfill embeddings for patterns that don't have them.
+       * Uses real all-MiniLM-L6-v2 transformer embeddings via @xenova/transformers.
+       * Falls back to hash-based embeddings if ONNX is unavailable.
+       * Skips bench/test patterns (id LIKE 'bench-%').
+       *
+       * @param batchSize - Patterns per inference batch (default: 32, matches model batch size)
+       * @returns Stats about the backfill operation
+       */
+      async backfillEmbeddings(batchSize = 32) {
+        if (!this.db) throw new Error("Database not initialized");
+        const dimension = getEmbeddingDimension();
+        const patternsWithout = this.db.prepare(`
+      SELECT p.id, p.name, p.description, p.pattern_type, p.qe_domain
+      FROM qe_patterns p
+      WHERE p.id NOT IN (SELECT pattern_id FROM qe_pattern_embeddings)
+        AND p.id NOT LIKE 'bench-%'
+      ORDER BY p.quality_score DESC
+    `).all();
+        const alreadyHad = this.db.prepare(`
+      SELECT COUNT(*) as c FROM qe_pattern_embeddings
+    `).get();
+        if (patternsWithout.length === 0) {
+          console.log(`[SQLitePatternStore] Backfill: all patterns already have embeddings (${alreadyHad.c} total)`);
+          return { processed: 0, skipped: 0, errors: 0, alreadyHad: alreadyHad.c, method: "transformer" };
+        }
+        console.log(`[SQLitePatternStore] Backfill: ${patternsWithout.length} patterns need embeddings (${alreadyHad.c} already have)`);
+        const insertEmbedding = this.prepared.get("insertEmbedding");
+        if (!insertEmbedding) {
+          throw new Error("Prepared statements not ready");
+        }
+        let processed = 0;
+        let skipped = 0;
+        let errors = 0;
+        let method = "transformer";
+        for (let i58 = 0; i58 < patternsWithout.length; i58 += batchSize) {
+          const batch = patternsWithout.slice(i58, i58 + batchSize);
+          const textsWithIds = [];
+          for (const pattern of batch) {
+            const text = [
+              pattern.name,
+              pattern.description,
+              pattern.pattern_type,
+              pattern.qe_domain
+            ].filter(Boolean).join(" ");
+            if (!text.trim()) {
+              skipped++;
+              continue;
+            }
+            textsWithIds.push({ id: pattern.id, text });
+          }
+          if (textsWithIds.length === 0) continue;
+          let embeddings;
+          try {
+            embeddings = await computeBatchEmbeddings(textsWithIds.map((t50) => t50.text));
+          } catch (e20) {
+            console.warn(`[SQLitePatternStore] Transformer unavailable, falling back to hash embeddings: ${toErrorMessage(e20)}`);
+            method = "hash-fallback";
+            embeddings = textsWithIds.map((t50) => hashEmbedding(t50.text, dimension));
+          }
+          const embeddingTag = method === "transformer" ? "transformer-backfill" : "hash-backfill";
+          const insertBatch = this.db.transaction(() => {
+            for (let j52 = 0; j52 < textsWithIds.length; j52++) {
+              try {
+                const embedding = embeddings[j52];
+                if (!embedding || embedding.length !== dimension) {
+                  errors++;
+                  continue;
+                }
+                const buffer = Buffer.from(new Float32Array(embedding).buffer);
+                insertEmbedding.run(textsWithIds[j52].id, buffer, dimension, embeddingTag);
+                processed++;
+              } catch (e20) {
+                errors++;
+                if (errors <= 3) {
+                  console.warn(`[SQLitePatternStore] Backfill error for ${textsWithIds[j52].id}:`, toErrorMessage(e20));
+                }
+              }
+            }
+          });
+          insertBatch();
+          const progress = Math.min(i58 + batchSize, patternsWithout.length);
+          if (progress % 100 === 0 || progress >= patternsWithout.length) {
+            console.log(`[SQLitePatternStore] Backfill progress: ${progress}/${patternsWithout.length}`);
+          }
+        }
+        console.log(`[SQLitePatternStore] Backfill complete (${method}): ${processed} processed, ${skipped} skipped, ${errors} errors`);
+        return { processed, skipped, errors, alreadyHad: alreadyHad.c, method };
+      }
       /**
        * Close the database
        */
@@ -29398,7 +29841,7 @@ var init_shared_rvf_dual_writer = __esm({
 
 // src/workflows/browser/workflow-loader.ts
 import { readFile as readFile9, readdir as readdir4 } from "fs/promises";
-import { join as join65, basename as basename10 } from "path";
+import { join as join66, basename as basename10 } from "path";
 import { parse as parseYaml2 } from "yaml";
 function interpolateVariables(template, variables) {
   return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
@@ -29432,7 +29875,7 @@ var init_workflow_loader = __esm({
       templatesDir;
       cache = /* @__PURE__ */ new Map();
       constructor(templatesDir) {
-        this.templatesDir = templatesDir || join65(__dirname, "templates");
+        this.templatesDir = templatesDir || join66(__dirname, "templates");
       }
       /**
        * Load a workflow template by name
@@ -29442,7 +29885,7 @@ var init_workflow_loader = __esm({
           return this.cache.get(templateName);
         }
         try {
-          const templatePath = join65(this.templatesDir, `${templateName}.yaml`);
+          const templatePath = join66(this.templatesDir, `${templateName}.yaml`);
           const content = await readFile9(templatePath, "utf-8");
           const workflow = parseYaml2(content);
           const validation = await this.validate(workflow);
@@ -29583,7 +30026,7 @@ ${validation.errors.join("\n")}`
        */
       async getMetadata(templateName) {
         try {
-          const templatePath = join65(this.templatesDir, `${templateName}.yaml`);
+          const templatePath = join66(this.templatesDir, `${templateName}.yaml`);
           const content = await readFile9(templatePath, "utf-8");
           const workflow = parseYaml2(content);
           return {
@@ -29828,7 +30271,7 @@ var init_browser_workflow = __esm({
 
 // src/cli/index.ts
 init_error_utils();
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 import chalk33 from "chalk";
 
 // src/kernel/kernel.ts
@@ -44014,6 +44457,103 @@ var TestQualityGate = class {
   }
 };
 
+// src/learning/opd-remediation.ts
+function generateRemediationHints(pattern, executionHistory, config) {
+  const hints = [];
+  const maxHints = config?.maxHintsPerPattern ?? 3;
+  const totalCount = executionHistory.length;
+  if (totalCount === 0) return hints;
+  const failCount = executionHistory.filter((e20) => !e20.success).length;
+  const failRate = failCount / totalCount;
+  if (failRate > 0.2 && failRate < 0.8 && totalCount >= 3) {
+    hints.push({
+      patternId: pattern.id,
+      observation: `Pattern "${pattern.name}" fails ${(failRate * 100).toFixed(0)}% of the time (${failCount}/${totalCount} executions)`,
+      diagnosis: "Intermittent failures suggest timing dependencies, external service flakiness, or non-deterministic behavior",
+      suggestion: "Add retry logic, mock external dependencies, or add explicit waits for async operations",
+      confidence: Math.min(0.9, 0.5 + totalCount * 0.05),
+      category: "flaky"
+    });
+  }
+  if (failRate >= 0.8 && totalCount >= 2) {
+    hints.push({
+      patternId: pattern.id,
+      observation: `Pattern "${pattern.name}" fails ${(failRate * 100).toFixed(0)}% of executions \u2014 effectively broken`,
+      diagnosis: "Consistent failures indicate the pattern logic is incorrect or the target code changed",
+      suggestion: "Review the pattern against current code. Consider quarantining and creating a replacement pattern.",
+      confidence: 0.85,
+      category: "false-positive"
+    });
+  }
+  if (totalCount >= 5) {
+    const recentFails = executionHistory.slice(-3).filter((e20) => !e20.success).length;
+    const earlySuccesses = executionHistory.slice(0, Math.max(1, totalCount - 3)).filter((e20) => e20.success).length;
+    if (recentFails >= 2 && earlySuccesses >= 2) {
+      hints.push({
+        patternId: pattern.id,
+        observation: `Pattern "${pattern.name}" worked previously but now fails consistently`,
+        diagnosis: "Recent code changes likely broke compatibility with this pattern",
+        suggestion: "Update pattern to match current code structure. Check git log for recent changes to affected files.",
+        confidence: 0.8,
+        category: "outdated"
+      });
+    }
+  }
+  if (pattern.description && pattern.description.length < 20 && failRate > 0.3) {
+    hints.push({
+      patternId: pattern.id,
+      observation: `Pattern "${pattern.name}" has a vague description and high failure rate`,
+      diagnosis: "Pattern may be too broadly scoped \u2014 matching contexts where it does not apply",
+      suggestion: "Narrow the pattern scope by adding specific tags, domain constraints, or more detailed matching criteria",
+      confidence: 0.6,
+      category: "wrong-scope"
+    });
+  }
+  const feedbackMessages = executionHistory.filter((e20) => !e20.success && e20.feedback).map((e20) => e20.feedback).slice(-3);
+  if (feedbackMessages.length > 0) {
+    const commonWords = findCommonKeywords(feedbackMessages);
+    if (commonWords.length > 0) {
+      hints.push({
+        patternId: pattern.id,
+        observation: `Failure feedback contains recurring themes: ${commonWords.join(", ")}`,
+        diagnosis: `Common failure keywords suggest a systematic issue: ${commonWords.slice(0, 3).join(", ")}`,
+        suggestion: `Address the recurring "${commonWords[0]}" issue in the pattern logic or preconditions`,
+        confidence: 0.65,
+        category: "missing-context"
+      });
+    }
+  }
+  return hints.slice(0, maxHints);
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "was",
+  "in",
+  "to",
+  "for",
+  "of",
+  "and",
+  "or",
+  "not",
+  "with",
+  "test",
+  "error"
+]);
+function findCommonKeywords(feedbacks) {
+  const wordCounts = /* @__PURE__ */ new Map();
+  for (const feedback of feedbacks) {
+    const words = feedback.toLowerCase().split(/\W+/).filter((w54) => w54.length > 2 && !STOP_WORDS.has(w54));
+    const uniqueWords = new Set(words);
+    for (const word of uniqueWords) {
+      wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);
+    }
+  }
+  return Array.from(wordCounts.entries()).filter(([, count]) => count >= 2).sort((a37, b68) => b68[1] - a37[1]).map(([word]) => word).slice(0, 5);
+}
+
 // src/domains/test-generation/pattern-injection/edge-case-injector.ts
 var DEFAULT_INJECTION_CONFIG = {
   topN: 3,
@@ -44179,6 +44719,7 @@ var EdgeCaseInjector = class {
   }
   /**
    * Format selected patterns into a prompt context string.
+   * Appends OPD remediation hints for patterns with low success rates.
    */
   formatPromptContext(patterns) {
     const lines = ["## Historical Edge Cases (from patterns that caught real bugs):"];
@@ -44188,8 +44729,36 @@ var EdgeCaseInjector = class {
       const desc = p74.description || p74.name;
       lines.push(`${i58 + 1}. [${tag}] ${desc}`);
     }
+    const weakPatterns = patterns.filter((p74) => p74.successRate < 0.5);
+    const allHints = [];
+    for (const wp of weakPatterns) {
+      const hints = generateRemediationHints(
+        { id: wp.key, name: wp.name, description: wp.description, successRate: wp.successRate, usageCount: wp.usageCount, confidence: wp.confidence, tags: wp.tags },
+        this.buildSyntheticHistory(wp)
+      );
+      allHints.push(...hints);
+    }
+    if (allHints.length > 0) {
+      lines.push("");
+      lines.push("## Remediation Notes (patterns with known issues):");
+      for (const hint of allHints.slice(0, 3)) {
+        lines.push(`- [${hint.category}] ${hint.suggestion}`);
+      }
+    }
     return lines.join("\n");
   }
+  /**
+   * Build a synthetic execution history from pattern metadata.
+   * Used to feed into OPD remediation when full history is unavailable.
+   */
+  buildSyntheticHistory(pattern) {
+    const total = Math.max(pattern.usageCount, 1);
+    const successes = Math.round(total * pattern.successRate);
+    const history = [];
+    for (let i58 = 0; i58 < successes; i58++) history.push({ success: true });
+    for (let i58 = 0; i58 < total - successes; i58++) history.push({ success: false });
+    return history;
+  }
   /**
    * Infer a short tag from pattern name when no tags are available.
    */
@@ -44331,7 +44900,7 @@ function resolveRequest(request) {
 import { execSync } from "child_process";
 import * as fs3 from "fs";
 import * as path3 from "path";
-import * as os from "os";
+import * as os2 from "os";
 var COMPILE_COMMANDS = {
   typescript: { check: "npx tsc --noEmit --strict", fileExt: ".ts" },
   java: { check: "javac -d /dev/null", fileExt: ".java" },
@@ -44352,7 +44921,7 @@ var CompilationValidator = class {
         suggestions: [`No compilation check available for ${language} -- syntax validation skipped`]
       };
     }
-    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "aqe-compile-"));
+    const tmpDir = fs3.mkdtempSync(path3.join(os2.tmpdir(), "aqe-compile-"));
     const tmpFile = path3.join(tmpDir, `test_validation${config.fileExt}`);
     try {
       fs3.writeFileSync(tmpFile, code, "utf-8");
@@ -46858,7 +47427,9 @@ var QE_HOOK_EVENTS = {
   // Pattern learning
   PatternLearned: "qe:pattern-learned",
   PatternApplied: "qe:pattern-applied",
-  PatternPromoted: "qe:pattern-promoted"
+  PatternPromoted: "qe:pattern-promoted",
+  // Session lifecycle
+  PreCompaction: "qe:pre-compaction"
 };
 function createQEHookHandlers(reasoningBank) {
   return {
@@ -47242,6 +47813,32 @@ Factors: ${riskFactors.join("\n- ")}`,
         success: true,
         data: { patternId, newTier }
       };
+    },
+    // ========================================================================
+    // Session Lifecycle Hooks
+    // ========================================================================
+    [QE_HOOK_EVENTS.PreCompaction]: async (ctx) => {
+      const stats = { experiencesFlushed: 0, patternsPromoted: 0 };
+      if (ctx.data?.experienceCaptureService) {
+        const service = ctx.data.experienceCaptureService;
+        const pendingCount = service.getPendingCount?.() ?? 0;
+        if (pendingCount > 0) {
+          const flushed = await service.flushPending?.();
+          stats.experiencesFlushed = flushed ?? pendingCount;
+        }
+      }
+      if (ctx.data?.patternLifecycleManager) {
+        const manager = ctx.data.patternLifecycleManager;
+        const promotionResult = manager.runPromotionSweep?.();
+        if (promotionResult) {
+          stats.patternsPromoted = promotionResult.promoted ?? 0;
+        }
+      }
+      console.log("[QEHooks] Pre-compaction flush:", stats);
+      return {
+        success: true,
+        data: stats
+      };
     }
   };
 }
@@ -50624,12 +51221,12 @@ var DeterministicGatewayIntegration = class {
   /**
    * Validate a single value against its schema
    */
-  validateValue(value, schema, path36) {
+  validateValue(value, schema, path37) {
     const errors = [];
     if (schema.required && (value === void 0 || value === null)) {
       errors.push({
-        path: path36,
-        message: `${path36} is required`,
+        path: path37,
+        message: `${path37} is required`,
         expected: schema.type,
         received: "undefined"
       });
@@ -50641,8 +51238,8 @@ var DeterministicGatewayIntegration = class {
     const actualType = Array.isArray(value) ? "array" : typeof value;
     if (actualType !== schema.type) {
       errors.push({
-        path: path36,
-        message: `${path36} must be of type ${schema.type}`,
+        path: path37,
+        message: `${path37} must be of type ${schema.type}`,
         expected: schema.type,
         received: actualType
       });
@@ -50651,16 +51248,16 @@ var DeterministicGatewayIntegration = class {
     if (schema.type === "string" && typeof value === "string") {
       if (schema.minLength !== void 0 && value.length < schema.minLength) {
         errors.push({
-          path: path36,
-          message: `${path36} must be at least ${schema.minLength} characters`,
+          path: path37,
+          message: `${path37} must be at least ${schema.minLength} characters`,
           expected: `minLength: ${schema.minLength}`,
           received: `length: ${value.length}`
         });
       }
       if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
         errors.push({
-          path: path36,
-          message: `${path36} must be at most ${schema.maxLength} characters`,
+          path: path37,
+          message: `${path37} must be at most ${schema.maxLength} characters`,
           expected: `maxLength: ${schema.maxLength}`,
           received: `length: ${value.length}`
         });
@@ -50668,8 +51265,8 @@ var DeterministicGatewayIntegration = class {
       const patternRegex = schema.pattern ? createSafeRegex(schema.pattern) : null;
       if (patternRegex && !patternRegex.test(value)) {
         errors.push({
-          path: path36,
-          message: `${path36} must match pattern ${schema.pattern}`,
+          path: path37,
+          message: `${path37} must match pattern ${schema.pattern}`,
           expected: `pattern: ${schema.pattern}`,
           received: value
         });
@@ -50678,16 +51275,16 @@ var DeterministicGatewayIntegration = class {
     if (schema.type === "number" && typeof value === "number") {
       if (schema.min !== void 0 && value < schema.min) {
         errors.push({
-          path: path36,
-          message: `${path36} must be at least ${schema.min}`,
+          path: path37,
+          message: `${path37} must be at least ${schema.min}`,
           expected: `min: ${schema.min}`,
           received: `${value}`
         });
       }
       if (schema.max !== void 0 && value > schema.max) {
         errors.push({
-          path: path36,
-          message: `${path36} must be at most ${schema.max}`,
+          path: path37,
+          message: `${path37} must be at most ${schema.max}`,
           expected: `max: ${schema.max}`,
           received: `${value}`
         });
@@ -50695,22 +51292,22 @@ var DeterministicGatewayIntegration = class {
     }
     if (schema.enum && !schema.enum.includes(value)) {
       errors.push({
-        path: path36,
-        message: `${path36} must be one of: ${schema.enum.join(", ")}`,
+        path: path37,
+        message: `${path37} must be one of: ${schema.enum.join(", ")}`,
         expected: `enum: [${schema.enum.join(", ")}]`,
         received: String(value)
       });
     }
     if (schema.type === "array" && Array.isArray(value) && schema.items) {
       value.forEach((item, index) => {
-        const itemErrors = this.validateValue(item, schema.items, `${path36}[${index}]`);
+        const itemErrors = this.validateValue(item, schema.items, `${path37}[${index}]`);
         errors.push(...itemErrors);
       });
     }
     if (schema.type === "object" && typeof value === "object" && schema.properties) {
       const objValue = value;
       for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        const propErrors = this.validateValue(objValue[propName], propSchema, `${path36}.${propName}`);
+        const propErrors = this.validateValue(objValue[propName], propSchema, `${path37}.${propName}`);
         errors.push(...propErrors);
       }
     }
@@ -60486,8 +61083,8 @@ var TestGenerationCoordinator = class extends BaseDomainCoordinator {
         );
         console.log("[TestGenerationCoordinator] QEFlashAttention initialized for test-similarity");
       } catch (error) {
-        console.error("[TestGenerationCoordinator] Failed to initialize QEFlashAttention:", error);
-        throw new Error(`QEFlashAttention initialization failed: ${toErrorMessage(error)}`);
+        console.warn("[TestGenerationCoordinator] QEFlashAttention unavailable (optional native module), continuing without it:", toErrorMessage(error));
+        this.flashAttention = null;
       }
     }
     if (this.config.enableDecisionTransformer) {
@@ -60498,8 +61095,8 @@ var TestGenerationCoordinator = class extends BaseDomainCoordinator {
         });
         console.log("[TestGenerationCoordinator] DecisionTransformer created for test case selection");
       } catch (error) {
-        console.error("[TestGenerationCoordinator] Failed to create DecisionTransformer:", error);
-        throw new Error(`DecisionTransformer creation failed: ${toErrorMessage(error)}`);
+        console.warn("[TestGenerationCoordinator] DecisionTransformer unavailable (optional native module), continuing without it:", toErrorMessage(error));
+        this.decisionTransformer = null;
       }
     }
     this.subscribeToEvents();
@@ -64961,11 +65558,11 @@ var AgentBrowserCommandExecutor = class {
   /**
    * Take screenshot
    */
-  screenshot(path36, fullPage) {
+  screenshot(path37, fullPage) {
     const args = [];
-    if (path36) args.push(path36);
+    if (path37) args.push(path37);
     if (fullPage) args.push("--full");
-    if (!path36) args.push("--json");
+    if (!path37) args.push("--json");
     return this.execute("screenshot", args);
   }
   // ========================================================================
@@ -65043,14 +65640,14 @@ var AgentBrowserCommandExecutor = class {
   /**
    * Save browser state (cookies, storage)
    */
-  saveState(path36) {
-    return this.execute("state", ["save", path36]);
+  saveState(path37) {
+    return this.execute("state", ["save", path37]);
   }
   /**
    * Load browser state
    */
-  loadState(path36) {
-    return this.execute("state", ["load", path36]);
+  loadState(path37) {
+    return this.execute("state", ["load", path37]);
   }
   // ========================================================================
   // Trace recording
@@ -66327,9 +66924,9 @@ var AgentBrowserClient = class {
   /**
    * Save browser state (cookies, storage, etc.)
    */
-  async saveState(path36) {
+  async saveState(path37) {
     try {
-      const result = this.executor.saveState(path36);
+      const result = this.executor.saveState(path37);
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Save state failed", "SAVE_STATE_FAILED", "agent-browser"));
       }
@@ -66348,9 +66945,9 @@ var AgentBrowserClient = class {
   /**
    * Load previously saved browser state
    */
-  async loadState(path36) {
+  async loadState(path37) {
     try {
-      const result = this.executor.loadState(path36);
+      const result = this.executor.loadState(path37);
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Load state failed", "LOAD_STATE_FAILED", "agent-browser"));
       }
@@ -73290,16 +73887,16 @@ var CoverageEmbedder = class {
     const idealRegions = Math.ceil(coverage.uncoveredLines.length / 5);
     return regions > 0 ? Math.min(1, idealRegions / regions) : 0;
   }
-  extractPathFeatures(path36) {
-    const parts = path36.split("/").filter(Boolean);
-    const extension = path36.split(".").pop() || "";
+  extractPathFeatures(path37) {
+    const parts = path37.split("/").filter(Boolean);
+    const extension = path37.split(".").pop() || "";
     const fileName = parts[parts.length - 1] || "";
     return {
       depth: parts.length,
       extension,
-      hashNormalized: this.hashString(path36) / 1e6,
-      isTest: /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(path36) || parts.includes("tests") || parts.includes("__tests__"),
-      isConfig: /\.(config|rc)\.(ts|js|json|yaml|yml)$/.test(path36),
+      hashNormalized: this.hashString(path37) / 1e6,
+      isTest: /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(path37) || parts.includes("tests") || parts.includes("__tests__"),
+      isConfig: /\.(config|rc)\.(ts|js|json|yaml|yml)$/.test(path37),
       isIndex: fileName.startsWith("index."),
       inSrc: parts.includes("src"),
       inLib: parts.includes("lib"),
@@ -73646,12 +74243,12 @@ var GhostCoverageAnalyzerService = class _GhostCoverageAnalyzerService {
   ratio(n61, d74) {
     return d74 > 0 ? n61 / d74 : 0;
   }
-  gapId(path36, cat) {
-    const h66 = `${path36}:${cat}`.split("").reduce((a37, c70) => (a37 << 5) - a37 + c70.charCodeAt(0) | 0, 0);
+  gapId(path37, cat) {
+    const h66 = `${path37}:${cat}`.split("").reduce((a37, c70) => (a37 << 5) - a37 + c70.charCodeAt(0) | 0, 0);
     return `phantom-${Math.abs(h66).toString(16)}`;
   }
-  gapDescription(path36, cat, dist) {
-    const n61 = path36.split("/").pop() || path36;
+  gapDescription(path37, cat, dist) {
+    const n61 = path37.split("/").pop() || path37;
     const s70 = dist > 0.7 ? "significant" : dist > 0.4 ? "moderate" : "minor";
     const m74 = {
       "missing-error-handler": `${n61}: ${s70} missing error handler tests. Cover error paths and failure recovery.`,
@@ -76085,7 +76682,7 @@ function getCodeMetricsAnalyzer() {
 }
 
 // src/shared/metrics/system-metrics.ts
-import * as os2 from "os";
+import * as os3 from "os";
 var SystemMetricsCollector = class {
   lastCpuUsage = null;
   lastCpuTime = 0;
@@ -76117,8 +76714,8 @@ var SystemMetricsCollector = class {
    * Collect CPU metrics
    */
   collectCpuMetrics() {
-    const cpus2 = os2.cpus();
-    const loadAverage = os2.loadavg();
+    const cpus2 = os3.cpus();
+    const loadAverage = os3.loadavg();
     let totalIdle = 0;
     let totalTick = 0;
     for (const cpu of cpus2) {
@@ -76138,8 +76735,8 @@ var SystemMetricsCollector = class {
    * Collect memory metrics
    */
   collectMemoryMetrics() {
-    const total = os2.totalmem();
-    const free = os2.freemem();
+    const total = os3.totalmem();
+    const free = os3.freemem();
     const used = total - free;
     const usage = used / total * 100;
     return {
@@ -76162,7 +76759,7 @@ var SystemMetricsCollector = class {
     const cpuPercent = totalCpuUs / elapsedUs * 100;
     this.lastCpuUsage = cpuUsage;
     this.lastCpuTime = now;
-    const totalMem = os2.totalmem();
+    const totalMem = os3.totalmem();
     const memPercent = memUsage.rss / totalMem * 100;
     return {
       cpuUsage: Math.min(100, Math.round(cpuPercent * 100) / 100),
@@ -76718,10 +77315,10 @@ ${codeContext.slice(0, 2e3)}
     const coverage = await this.memory.get(key);
     return coverage ?? null;
   }
-  hashFilePath(path36) {
+  hashFilePath(path37) {
     let hash = 0;
-    for (let i58 = 0; i58 < path36.length; i58++) {
-      hash = (hash << 5) - hash + path36.charCodeAt(i58);
+    for (let i58 = 0; i58 < path37.length; i58++) {
+      hash = (hash << 5) - hash + path37.charCodeAt(i58);
       hash = hash & hash;
     }
     return hash.toString(16);
@@ -90935,10 +91532,10 @@ function countTestsByFilePattern(projectPath, config) {
             fileTests = countTestsInGoFile(fullPath);
           }
           total += fileTests;
-          const path36 = fullPath.toLowerCase();
-          if (path36.includes("e2e") || path36.includes("end-to-end")) {
+          const path37 = fullPath.toLowerCase();
+          if (path37.includes("e2e") || path37.includes("end-to-end")) {
             e2e += fileTests;
-          } else if (path36.includes("integration")) {
+          } else if (path37.includes("integration")) {
             integration += fileTests;
           } else {
             unit += fileTests;
@@ -91768,7 +92365,7 @@ var HypergraphEngine = class {
     ];
     const effectiveMaxDepth = Math.min(maxDepth, this.config.maxTraversalDepth);
     while (queue.length > 0) {
-      const { nodeId, depth, path: path36 } = queue.shift();
+      const { nodeId, depth, path: path37 } = queue.shift();
       if (!visitedNodes.has(nodeId)) {
         const node = await this.getNode(nodeId);
         if (node) {
@@ -91777,7 +92374,7 @@ var HypergraphEngine = class {
       }
       maxDepthReached = Math.max(maxDepthReached, depth);
       if (depth >= effectiveMaxDepth) {
-        paths.push(path36);
+        paths.push(path37);
         continue;
       }
       const edgeCriteria = { sourceId: nodeId };
@@ -91786,15 +92383,15 @@ var HypergraphEngine = class {
       }
       const edges = await this.findEdges(edgeCriteria);
       if (edges.length === 0) {
-        paths.push(path36);
+        paths.push(path37);
         continue;
       }
       for (const edge of edges) {
         if (!visitedEdges.has(edge.id)) {
           visitedEdges.set(edge.id, edge);
           const newPath = {
-            nodes: [...path36.nodes, edge.targetId],
-            edges: [...path36.edges, edge.id]
+            nodes: [...path37.nodes, edge.targetId],
+            edges: [...path37.edges, edge.id]
           };
           queue.push({
             nodeId: edge.targetId,
@@ -92175,11 +92772,11 @@ async function createHypergraphEngine(config) {
 init_wrappers();
 async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
   try {
-    for (const path36 of paths) {
+    for (const path37 of paths) {
       try {
-        const result = await fileReader.readFile(path36);
+        const result = await fileReader.readFile(path37);
         if (result.success && result.value) {
-          const embedding = await generateCodeEmbedding(path36, result.value);
+          const embedding = await generateCodeEmbedding(path37, result.value);
           const embeddingObj = {
             vector: embedding,
             dimension: 384,
@@ -92187,12 +92784,12 @@ async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
             text: result.value.slice(0, 1e3),
             timestamp: Date.now(),
             quantization: "none",
-            metadata: { path: path36 }
+            metadata: { path: path37 }
           };
           gnnIndex.addEmbedding(embeddingObj);
         }
       } catch (error) {
-        console.error(`Failed to index ${path36}:`, error);
+        console.error(`Failed to index ${path37}:`, error);
       }
     }
     console.log(`[GNN] Indexed ${paths.length} code embeddings`);
@@ -92200,9 +92797,9 @@ async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
     console.error("Failed to index code embeddings:", error);
   }
 }
-async function generateCodeEmbedding(path36, content) {
+async function generateCodeEmbedding(path37, content) {
   const features = [];
-  const ext = path36.split(".").pop();
+  const ext = path37.split(".").pop();
   const typeHash = hashCode(ext || "");
   features.push(typeHash % 1e3 / 1e3);
   features.push(Math.min(1, content.length / 1e4));
@@ -92623,14 +93220,14 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
   async initializeHypergraph() {
     try {
       const { openDatabase: openDatabase2 } = await Promise.resolve().then(() => (init_safe_db(), safe_db_exports));
-      const fs31 = await import("fs");
-      const path36 = await import("path");
+      const fs32 = await import("fs");
+      const path37 = await import("path");
       const { findProjectRoot: findProjectRoot2 } = await Promise.resolve().then(() => (init_unified_memory(), unified_memory_exports));
       const projectRoot = findProjectRoot2();
-      const dbPath = this.config.hypergraphDbPath || path36.join(projectRoot, ".agentic-qe", "hypergraph.db");
-      const dir = path36.dirname(dbPath);
-      if (!fs31.existsSync(dir)) {
-        fs31.mkdirSync(dir, { recursive: true });
+      const dbPath = this.config.hypergraphDbPath || path37.join(projectRoot, ".agentic-qe", "hypergraph.db");
+      const dir = path37.dirname(dbPath);
+      if (!fs32.existsSync(dir)) {
+        fs32.mkdirSync(dir, { recursive: true });
       }
       this.hypergraphDb = openDatabase2(dbPath);
       this.hypergraph = await createHypergraphEngine({
@@ -93158,11 +93755,11 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
   // ============================================================================
   async indexForSemanticSearch(paths) {
     const filesToIndex = paths.slice(0, 100);
-    for (const path36 of filesToIndex) {
+    for (const path37 of filesToIndex) {
       try {
-        const result = await this.fileReader.readFile(path36);
+        const result = await this.fileReader.readFile(path37);
         if (result.success && result.value) {
-          await this.semanticAnalyzer.indexCode(path36, result.value);
+          await this.semanticAnalyzer.indexCode(path37, result.value);
         }
       } catch {
       }
@@ -93370,8 +93967,8 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
       for (const marker of markers) {
         try {
           const markerPath = `${currentPath}/${marker}`;
-          const fs31 = __require("fs");
-          if (fs31.existsSync(markerPath)) {
+          const fs32 = __require("fs");
+          if (fs32.existsSync(markerPath)) {
             return currentPath;
           }
         } catch {
@@ -93877,8 +94474,8 @@ var FilePath = class _FilePath {
   equals(other) {
     return this._value === other._value;
   }
-  static create(path36) {
-    return new _FilePath(path36);
+  static create(path37) {
+    return new _FilePath(path37);
   }
 };
 var RiskScore = class _RiskScore {
@@ -94616,8 +95213,8 @@ var SASTScanner = class {
     let content;
     let lines;
     try {
-      const fs31 = await import("fs/promises");
-      content = await fs31.readFile(filePath, "utf-8");
+      const fs32 = await import("fs/promises");
+      content = await fs32.readFile(filePath, "utf-8");
       lines = content.split("\n");
     } catch {
       return { vulnerabilities: [], linesScanned: 0 };
@@ -95307,10 +95904,10 @@ async function extractAndCrawlLinks(html, baseUrl, currentCrawled, maxDepth, vul
     }
   }
   const linksToCrawl = Array.from(discoveredLinks).slice(0, Math.min(10, maxCrawl - crawledUrls));
-  for (const path36 of linksToCrawl) {
+  for (const path37 of linksToCrawl) {
     if (crawledUrls >= maxCrawl) break;
     try {
-      const crawlUrl = new URL(path36, baseUrl.origin).toString();
+      const crawlUrl = new URL(path37, baseUrl.origin).toString();
       const crawlResponse = await fetch(crawlUrl, {
         method: "GET",
         headers: { "User-Agent": "AgenticQE-DAST-Scanner/3.0" },
@@ -95319,11 +95916,11 @@ async function extractAndCrawlLinks(html, baseUrl, currentCrawled, maxDepth, vul
       });
       crawledUrls++;
       if (crawlResponse.ok) {
-        if (path36.includes("password") || path36.includes("token") || path36.includes("api_key")) {
+        if (path37.includes("password") || path37.includes("token") || path37.includes("api_key")) {
           vulnerabilities.push({
             id: v4_default(),
             title: "Sensitive Data in URL Path",
-            description: `URL path may contain sensitive parameter names: ${path36}`,
+            description: `URL path may contain sensitive parameter names: ${path37}`,
             severity: "medium",
             category: "sensitive-data",
             location: { file: crawlUrl },
@@ -96832,8 +97429,8 @@ var DependencyScanner = class {
    */
   async scanPackageJson(packageJsonPath) {
     try {
-      const fs31 = await import("fs/promises");
-      const content = await fs31.readFile(packageJsonPath, "utf-8");
+      const fs32 = await import("fs/promises");
+      const content = await fs32.readFile(packageJsonPath, "utf-8");
       const packageJson = safeJsonParse(content);
       const allDependencies = {
         ...packageJson.dependencies || {},
@@ -101149,17 +101746,17 @@ Provide:
       warnings.push("No consumers defined for contract");
     }
   }
-  validateServiceInfo(info, path36, errors) {
+  validateServiceInfo(info, path37, errors) {
     if (!info.name || info.name.trim() === "") {
       errors.push({
-        path: `${path36}.name`,
+        path: `${path37}.name`,
         message: "Service name is required",
         code: "REQUIRED_FIELD"
       });
     }
     if (!info.version || info.version.trim() === "") {
       errors.push({
-        path: `${path36}.version`,
+        path: `${path37}.version`,
         message: "Service version is required",
         code: "REQUIRED_FIELD"
       });
@@ -101805,13 +102402,13 @@ Provide:
   /**
    * Validate nested field selections
    */
-  validateGraphQLSelections(selections, typeName, schemaInfo, path36, errors) {
+  validateGraphQLSelections(selections, typeName, schemaInfo, path37, errors) {
     const typeDef = schemaInfo.types[typeName];
     if (!typeDef) {
       if (["String", "Int", "Float", "Boolean", "ID"].includes(typeName)) {
         if (selections.length > 0) {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "selection",
             message: `Cannot select fields on scalar type '${typeName}'`,
             params: { type: typeName }
@@ -101824,7 +102421,7 @@ Provide:
       const fieldDef = typeDef.fields[selection.name];
       if (!fieldDef) {
         errors.push({
-          path: `${path36}.${selection.name}`,
+          path: `${path37}.${selection.name}`,
           keyword: "field",
           message: `Field '${selection.name}' does not exist on type '${typeName}'`,
           params: { field: selection.name, type: typeName }
@@ -101835,7 +102432,7 @@ Provide:
           selection.selections,
           nestedType,
           schemaInfo,
-          `${path36}.${selection.name}`,
+          `${path37}.${selection.name}`,
           errors
         );
       }
@@ -101844,14 +102441,14 @@ Provide:
   /**
    * Validate variable type matches expected GraphQL type
    */
-  validateGraphQLVariableType(value, expectedType, path36, errors) {
+  validateGraphQLVariableType(value, expectedType, path37, errors) {
     const baseType = this.unwrapGraphQLType(expectedType);
     const isNonNull = expectedType.endsWith("!");
     const isList = expectedType.includes("[");
     if (value === null || value === void 0) {
       if (isNonNull) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "type",
           message: `Variable cannot be null (expected ${expectedType})`,
           params: { expectedType }
@@ -101862,7 +102459,7 @@ Provide:
     if (isList) {
       if (!Array.isArray(value)) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "type",
           message: `Expected array for type ${expectedType}`,
           params: { expectedType, actualType: typeof value }
@@ -101875,7 +102472,7 @@ Provide:
       case "ID":
         if (typeof value !== "string") {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "type",
             message: `Expected string for type ${baseType}`,
             params: { expectedType: baseType, actualType: typeof value }
@@ -101885,7 +102482,7 @@ Provide:
       case "Int":
         if (typeof value !== "number" || !Number.isInteger(value)) {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "type",
             message: `Expected integer for type Int`,
             params: { expectedType: "Int", actualType: typeof value }
@@ -101895,7 +102492,7 @@ Provide:
       case "Float":
         if (typeof value !== "number") {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "type",
             message: `Expected number for type Float`,
             params: { expectedType: "Float", actualType: typeof value }
@@ -101905,7 +102502,7 @@ Provide:
       case "Boolean":
         if (typeof value !== "boolean") {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "type",
             message: `Expected boolean for type Boolean`,
             params: { expectedType: "Boolean", actualType: typeof value }
@@ -101916,7 +102513,7 @@ Provide:
       default:
         if (typeof value !== "object") {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "type",
             message: `Expected object for type ${baseType}`,
             params: { expectedType: baseType, actualType: typeof value }
@@ -101924,10 +102521,10 @@ Provide:
         }
     }
   }
-  basicTypeValidation(data, schema, path36, errors, depth = 0) {
+  basicTypeValidation(data, schema, path37, errors, depth = 0) {
     if (depth > this.config.maxSchemaDepth) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxDepth",
         message: "Maximum schema depth exceeded",
         params: { maxDepth: this.config.maxSchemaDepth }
@@ -101944,7 +102541,7 @@ Provide:
       for (const prop of required) {
         if (!(prop in dataObj)) {
           errors.push({
-            path: path36 ? `${path36}.${prop}` : prop,
+            path: path37 ? `${path37}.${prop}` : prop,
             keyword: "required",
             message: `Required property '${prop}' is missing`,
             params: { missingProperty: prop }
@@ -101956,7 +102553,7 @@ Provide:
           this.basicTypeValidation(
             dataObj[prop],
             propSchema,
-            path36 ? `${path36}.${prop}` : prop,
+            path37 ? `${path37}.${prop}` : prop,
             errors,
             depth + 1
           );
@@ -101965,26 +102562,26 @@ Provide:
     } else if (type === "array" && actualType === "array") {
       const items = schema.items;
       const dataArr = data;
-      this.validateArrayConstraints(dataArr, schema, path36, errors);
+      this.validateArrayConstraints(dataArr, schema, path37, errors);
       if (items) {
         for (let i58 = 0; i58 < dataArr.length; i58++) {
           this.basicTypeValidation(
             dataArr[i58],
             items,
-            `${path36}[${i58}]`,
+            `${path37}[${i58}]`,
             errors,
             depth + 1
           );
         }
       }
     } else if (type === "string" && actualType === "string") {
-      this.validateStringConstraints(data, schema, path36, errors);
+      this.validateStringConstraints(data, schema, path37, errors);
     } else if ((type === "number" || type === "integer") && (actualType === "number" || actualType === "integer")) {
-      this.validateNumberConstraints(data, schema, path36, errors);
+      this.validateNumberConstraints(data, schema, path37, errors);
     } else if (type !== actualType) {
       if (!(type === "number" && actualType === "integer")) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "type",
           message: `Expected type '${type}' but got '${actualType}'`,
           params: { expectedType: type, actualType }
@@ -101995,7 +102592,7 @@ Provide:
       const enumValues = schema.enum;
       if (!enumValues.some((v65) => JSON.stringify(v65) === JSON.stringify(data))) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "enum",
           message: `Value must be one of: ${enumValues.map((v65) => JSON.stringify(v65)).join(", ")}`,
           params: { allowedValues: enumValues }
@@ -102003,13 +102600,13 @@ Provide:
       }
     }
   }
-  validateStringConstraints(data, schema, path36, errors) {
+  validateStringConstraints(data, schema, path37, errors) {
     const minLength = schema.minLength;
     const maxLength = schema.maxLength;
     const pattern = schema.pattern;
     if (minLength !== void 0 && data.length < minLength) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "minLength",
         message: `String must be at least ${minLength} characters`,
         params: { limit: minLength, actual: data.length }
@@ -102017,7 +102614,7 @@ Provide:
     }
     if (maxLength !== void 0 && data.length > maxLength) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxLength",
         message: `String must be at most ${maxLength} characters`,
         params: { limit: maxLength, actual: data.length }
@@ -102027,7 +102624,7 @@ Provide:
       const regex = createSafeRegex(pattern);
       if (regex && !regex.test(data)) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "pattern",
           message: `String must match pattern: ${pattern}`,
           params: { pattern }
@@ -102035,7 +102632,7 @@ Provide:
       }
     }
   }
-  validateNumberConstraints(data, schema, path36, errors) {
+  validateNumberConstraints(data, schema, path37, errors) {
     const minimum = schema.minimum;
     const maximum = schema.maximum;
     const exclusiveMinimum = schema.exclusiveMinimum;
@@ -102043,7 +102640,7 @@ Provide:
     const multipleOf = schema.multipleOf;
     if (minimum !== void 0 && data < minimum) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "minimum",
         message: `Number must be >= ${minimum}`,
         params: { limit: minimum, actual: data }
@@ -102051,7 +102648,7 @@ Provide:
     }
     if (maximum !== void 0 && data > maximum) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maximum",
         message: `Number must be <= ${maximum}`,
         params: { limit: maximum, actual: data }
@@ -102059,7 +102656,7 @@ Provide:
     }
     if (exclusiveMinimum !== void 0 && data <= exclusiveMinimum) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "exclusiveMinimum",
         message: `Number must be > ${exclusiveMinimum}`,
         params: { limit: exclusiveMinimum, actual: data }
@@ -102067,7 +102664,7 @@ Provide:
     }
     if (exclusiveMaximum !== void 0 && data >= exclusiveMaximum) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "exclusiveMaximum",
         message: `Number must be < ${exclusiveMaximum}`,
         params: { limit: exclusiveMaximum, actual: data }
@@ -102075,20 +102672,20 @@ Provide:
     }
     if (multipleOf !== void 0 && data % multipleOf !== 0) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "multipleOf",
         message: `Number must be a multiple of ${multipleOf}`,
         params: { multipleOf, actual: data }
       });
     }
   }
-  validateArrayConstraints(data, schema, path36, errors) {
+  validateArrayConstraints(data, schema, path37, errors) {
     const minItems = schema.minItems;
     const maxItems = schema.maxItems;
     const uniqueItems = schema.uniqueItems;
     if (minItems !== void 0 && data.length < minItems) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "minItems",
         message: `Array must have at least ${minItems} items`,
         params: { limit: minItems, actual: data.length }
@@ -102096,7 +102693,7 @@ Provide:
     }
     if (maxItems !== void 0 && data.length > maxItems) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxItems",
         message: `Array must have at most ${maxItems} items`,
         params: { limit: maxItems, actual: data.length }
@@ -102108,7 +102705,7 @@ Provide:
         const serialized = JSON.stringify(data[i58]);
         if (seen.has(serialized)) {
           errors.push({
-            path: `${path36}[${i58}]`,
+            path: `${path37}[${i58}]`,
             keyword: "uniqueItems",
             message: "Array items must be unique",
             params: { duplicateIndex: i58 }
@@ -102604,11 +103201,11 @@ var ApiCompatibilityService = class {
     } catch {
     }
   }
-  scanObjectForDeprecations(obj, path36, deprecations, version2, context2) {
+  scanObjectForDeprecations(obj, path37, deprecations, version2, context2) {
     if (!obj || typeof obj !== "object") return;
     const record = obj;
     if (record.deprecated === true) {
-      const location = context2 ? `${context2} -> ${path36}` : path36;
+      const location = context2 ? `${context2} -> ${path37}` : path37;
       deprecations.push({
         location,
         reason: typeof record.description === "string" ? record.description : "Field marked as deprecated",
@@ -102617,7 +103214,7 @@ var ApiCompatibilityService = class {
       });
     }
     if (record["x-deprecated"] === true) {
-      const location = context2 ? `${context2} -> ${path36}` : path36;
+      const location = context2 ? `${context2} -> ${path37}` : path37;
       deprecations.push({
         location,
         reason: typeof record["x-deprecated-message"] === "string" ? record["x-deprecated-message"] : "Element marked as deprecated via x-deprecated",
@@ -102629,7 +103226,7 @@ var ApiCompatibilityService = class {
       for (const [propName, propValue] of Object.entries(props)) {
         this.scanObjectForDeprecations(
           propValue,
-          `${path36}.${propName}`,
+          `${path37}.${propName}`,
           deprecations,
           version2,
           context2
@@ -102639,7 +103236,7 @@ var ApiCompatibilityService = class {
     if (record.items && typeof record.items === "object") {
       this.scanObjectForDeprecations(
         record.items,
-        `${path36}[]`,
+        `${path37}[]`,
         deprecations,
         version2,
         context2
@@ -103388,13 +103985,13 @@ var ContractTestingCoordinator = class extends BaseDomainCoordinator {
     }
     return contracts;
   }
-  async loadContractFromPath(path36) {
-    const content = await this.loadFileContent(path36);
+  async loadContractFromPath(path37) {
+    const content = await this.loadFileContent(path37);
     if (!content) {
       return null;
     }
     try {
-      const filePath = path36.value.toLowerCase();
+      const filePath = path37.value.toLowerCase();
       if (filePath.endsWith(".json")) {
         const parsed = safeJsonParse(content);
         if (parsed.openapi || parsed.swagger) {
@@ -103402,22 +103999,22 @@ var ContractTestingCoordinator = class extends BaseDomainCoordinator {
         }
         return parsed;
       } else if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-        console.warn("YAML contract files not yet supported:", path36.value);
+        console.warn("YAML contract files not yet supported:", path37.value);
         return null;
       }
       return safeJsonParse(content);
     } catch (error) {
       console.error(
-        `Failed to parse contract from ${path36.value}:`,
+        `Failed to parse contract from ${path37.value}:`,
         toErrorMessage(error)
       );
       return null;
     }
   }
-  async loadFileContent(path36) {
-    const result = await this.fileReader.readFile(path36.value);
+  async loadFileContent(path37) {
+    const result = await this.fileReader.readFile(path37.value);
     if (!result.success) {
-      console.error(`Failed to read file ${path36.value}:`, result.error);
+      console.error(`Failed to read file ${path37.value}:`, result.error);
       return null;
     }
     return result.value;
@@ -103428,13 +104025,13 @@ var ContractTestingCoordinator = class extends BaseDomainCoordinator {
     const paths = spec.paths || {};
     const endpoints = [];
     const schemas = [];
-    for (const [path36, methods] of Object.entries(paths)) {
+    for (const [path37, methods] of Object.entries(paths)) {
       const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
       for (const method of httpMethods) {
         const operation = methods[method.toLowerCase()];
         if (operation) {
           endpoints.push({
-            path: path36,
+            path: path37,
             method,
             requestSchema: this.extractRequestSchema(operation),
             responseSchema: this.extractResponseSchema(operation),
@@ -104163,10 +104760,10 @@ var SchemaValidatorService = class {
   // ============================================================================
   // Private Validation Methods
   // ============================================================================
-  validateValue(value, schema, path36, errors, depth) {
+  validateValue(value, schema, path37, errors, depth) {
     if (depth > this.config.maxRecursionDepth) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxDepth",
         message: "Maximum recursion depth exceeded",
         params: { maxDepth: this.config.maxRecursionDepth }
@@ -104179,7 +104776,7 @@ var SchemaValidatorService = class {
       }
       if (this.config.strictMode) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "type",
           message: "Value cannot be null",
           params: {}
@@ -104189,15 +104786,15 @@ var SchemaValidatorService = class {
     }
     const schemaType = schema.type;
     if (schema.oneOf) {
-      this.validateOneOf(value, schema.oneOf, path36, errors, depth);
+      this.validateOneOf(value, schema.oneOf, path37, errors, depth);
       return;
     }
     if (schema.anyOf) {
-      this.validateAnyOf(value, schema.anyOf, path36, errors, depth);
+      this.validateAnyOf(value, schema.anyOf, path37, errors, depth);
       return;
     }
     if (schema.allOf) {
-      this.validateAllOf(value, schema.allOf, path36, errors, depth);
+      this.validateAllOf(value, schema.allOf, path37, errors, depth);
       return;
     }
     if (schemaType) {
@@ -104205,7 +104802,7 @@ var SchemaValidatorService = class {
       const actualType = this.getJsonType(value);
       if (!types.some((t50) => this.typesMatch(actualType, t50))) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "type",
           message: `Expected type '${types.join(" | ")}' but got '${actualType}'`,
           params: { expectedType: types, actualType }
@@ -104214,19 +104811,19 @@ var SchemaValidatorService = class {
       }
     }
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-      this.validateObject(value, schema, path36, errors, depth);
+      this.validateObject(value, schema, path37, errors, depth);
     } else if (Array.isArray(value)) {
-      this.validateArray(value, schema, path36, errors, depth);
+      this.validateArray(value, schema, path37, errors, depth);
     } else if (typeof value === "string") {
-      this.validateString(value, schema, path36, errors);
+      this.validateString(value, schema, path37, errors);
     } else if (typeof value === "number") {
-      this.validateNumber(value, schema, path36, errors);
+      this.validateNumber(value, schema, path37, errors);
     }
     if (schema.enum) {
       const enumValues = schema.enum;
       if (!enumValues.includes(value)) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "enum",
           message: `Value must be one of: ${enumValues.map((v65) => JSON.stringify(v65)).join(", ")}`,
           params: { allowedValues: enumValues }
@@ -104236,7 +104833,7 @@ var SchemaValidatorService = class {
     if ("const" in schema) {
       if (value !== schema.const) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "const",
           message: `Value must be ${JSON.stringify(schema.const)}`,
           params: { expected: schema.const }
@@ -104244,14 +104841,14 @@ var SchemaValidatorService = class {
       }
     }
   }
-  validateObject(value, schema, path36, errors, depth) {
+  validateObject(value, schema, path37, errors, depth) {
     const properties = schema.properties || {};
     const required = schema.required || [];
     const additionalProperties = schema.additionalProperties;
     for (const prop of required) {
       if (!(prop in value)) {
         errors.push({
-          path: path36 ? `${path36}.${prop}` : prop,
+          path: path37 ? `${path37}.${prop}` : prop,
           keyword: "required",
           message: `Required property '${prop}' is missing`,
           params: { missingProperty: prop }
@@ -104259,7 +104856,7 @@ var SchemaValidatorService = class {
       }
     }
     for (const [prop, propValue] of Object.entries(value)) {
-      const propPath = path36 ? `${path36}.${prop}` : prop;
+      const propPath = path37 ? `${path37}.${prop}` : prop;
       if (prop in properties) {
         this.validateValue(propValue, properties[prop], propPath, errors, depth + 1);
       } else if (this.config.strictMode && additionalProperties === false) {
@@ -104282,7 +104879,7 @@ var SchemaValidatorService = class {
     const propCount = Object.keys(value).length;
     if (typeof schema.minProperties === "number" && propCount < schema.minProperties) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "minProperties",
         message: `Object must have at least ${schema.minProperties} properties`,
         params: { limit: schema.minProperties, actual: propCount }
@@ -104290,23 +104887,23 @@ var SchemaValidatorService = class {
     }
     if (typeof schema.maxProperties === "number" && propCount > schema.maxProperties) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxProperties",
         message: `Object must have at most ${schema.maxProperties} properties`,
         params: { limit: schema.maxProperties, actual: propCount }
       });
     }
   }
-  validateArray(value, schema, path36, errors, depth) {
+  validateArray(value, schema, path37, errors, depth) {
     const items = schema.items;
     if (items) {
       for (let i58 = 0; i58 < value.length; i58++) {
-        this.validateValue(value[i58], items, `${path36}[${i58}]`, errors, depth + 1);
+        this.validateValue(value[i58], items, `${path37}[${i58}]`, errors, depth + 1);
       }
     }
     if (typeof schema.minItems === "number" && value.length < schema.minItems) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "minItems",
         message: `Array must have at least ${schema.minItems} items`,
         params: { limit: schema.minItems, actual: value.length }
@@ -104314,7 +104911,7 @@ var SchemaValidatorService = class {
     }
     if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxItems",
         message: `Array must have at most ${schema.maxItems} items`,
         params: { limit: schema.maxItems, actual: value.length }
@@ -104326,7 +104923,7 @@ var SchemaValidatorService = class {
         const serialized = JSON.stringify(value[i58]);
         if (seen.has(serialized)) {
           errors.push({
-            path: `${path36}[${i58}]`,
+            path: `${path37}[${i58}]`,
             keyword: "uniqueItems",
             message: "Array items must be unique",
             params: { duplicateIndex: i58 }
@@ -104336,10 +104933,10 @@ var SchemaValidatorService = class {
       }
     }
   }
-  validateString(value, schema, path36, errors) {
+  validateString(value, schema, path37, errors) {
     if (typeof schema.minLength === "number" && value.length < schema.minLength) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "minLength",
         message: `String must be at least ${schema.minLength} characters`,
         params: { limit: schema.minLength, actual: value.length }
@@ -104347,7 +104944,7 @@ var SchemaValidatorService = class {
     }
     if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "maxLength",
         message: `String must be at most ${schema.maxLength} characters`,
         params: { limit: schema.maxLength, actual: value.length }
@@ -104357,7 +104954,7 @@ var SchemaValidatorService = class {
       const regex = createSafeRegex(schema.pattern);
       if (regex && !regex.test(value)) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "pattern",
           message: `String must match pattern '${schema.pattern}'`,
           params: { pattern: schema.pattern }
@@ -104365,15 +104962,15 @@ var SchemaValidatorService = class {
       }
     }
     if (typeof schema.format === "string") {
-      this.validateFormat(value, schema.format, path36, errors);
+      this.validateFormat(value, schema.format, path37, errors);
     }
   }
-  validateNumber(value, schema, path36, errors) {
+  validateNumber(value, schema, path37, errors) {
     if (typeof schema.minimum === "number") {
       if (schema.exclusiveMinimum === true) {
         if (value <= schema.minimum) {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "exclusiveMinimum",
             message: `Number must be greater than ${schema.minimum}`,
             params: { limit: schema.minimum, actual: value }
@@ -104381,7 +104978,7 @@ var SchemaValidatorService = class {
         }
       } else if (value < schema.minimum) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "minimum",
           message: `Number must be at least ${schema.minimum}`,
           params: { limit: schema.minimum, actual: value }
@@ -104392,7 +104989,7 @@ var SchemaValidatorService = class {
       if (schema.exclusiveMaximum === true) {
         if (value >= schema.maximum) {
           errors.push({
-            path: path36,
+            path: path37,
             keyword: "exclusiveMaximum",
             message: `Number must be less than ${schema.maximum}`,
             params: { limit: schema.maximum, actual: value }
@@ -104400,7 +104997,7 @@ var SchemaValidatorService = class {
         }
       } else if (value > schema.maximum) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "maximum",
           message: `Number must be at most ${schema.maximum}`,
           params: { limit: schema.maximum, actual: value }
@@ -104411,7 +105008,7 @@ var SchemaValidatorService = class {
       const remainder = value % schema.multipleOf;
       if (Math.abs(remainder) > 1e-10) {
         errors.push({
-          path: path36,
+          path: path37,
           keyword: "multipleOf",
           message: `Number must be a multiple of ${schema.multipleOf}`,
           params: { multipleOf: schema.multipleOf, actual: value }
@@ -104419,7 +105016,7 @@ var SchemaValidatorService = class {
       }
     }
   }
-  validateFormat(value, format, path36, errors) {
+  validateFormat(value, format, path37, errors) {
     let isValid = true;
     switch (format) {
       case "email":
@@ -104456,46 +105053,46 @@ var SchemaValidatorService = class {
     }
     if (!isValid) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "format",
         message: `String must be a valid ${format}`,
         params: { format }
       });
     }
   }
-  validateOneOf(value, schemas, path36, errors, depth) {
+  validateOneOf(value, schemas, path37, errors, depth) {
     const validCount = schemas.reduce((count, schema) => {
       const subErrors = [];
-      this.validateValue(value, schema, path36, subErrors, depth + 1);
+      this.validateValue(value, schema, path37, subErrors, depth + 1);
       return count + (subErrors.length === 0 ? 1 : 0);
     }, 0);
     if (validCount !== 1) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "oneOf",
         message: `Value must match exactly one schema (matched ${validCount})`,
         params: { matched: validCount }
       });
     }
   }
-  validateAnyOf(value, schemas, path36, errors, depth) {
+  validateAnyOf(value, schemas, path37, errors, depth) {
     const hasValid = schemas.some((schema) => {
       const subErrors = [];
-      this.validateValue(value, schema, path36, subErrors, depth + 1);
+      this.validateValue(value, schema, path37, subErrors, depth + 1);
       return subErrors.length === 0;
     });
     if (!hasValid) {
       errors.push({
-        path: path36,
+        path: path37,
         keyword: "anyOf",
         message: "Value must match at least one schema",
         params: {}
       });
     }
   }
-  validateAllOf(value, schemas, path36, errors, depth) {
+  validateAllOf(value, schemas, path37, errors, depth) {
     for (const schema of schemas) {
-      this.validateValue(value, schema, path36, errors, depth + 1);
+      this.validateValue(value, schema, path37, errors, depth + 1);
     }
   }
   getJsonType(value) {
@@ -104528,20 +105125,20 @@ var SchemaValidatorService = class {
       });
     }
   }
-  compareSchemaObjects(oldSchema, newSchema, path36, additions, removals, modifications) {
+  compareSchemaObjects(oldSchema, newSchema, path37, additions, removals, modifications) {
     const oldProps = oldSchema.properties || {};
     const newProps = newSchema.properties || {};
     const oldRequired = new Set(oldSchema.required || []);
     const newRequired = new Set(newSchema.required || []);
     for (const prop of Object.keys(oldProps)) {
       if (!(prop in newProps)) {
-        const propPath = path36 ? `${path36}.${prop}` : prop;
+        const propPath = path37 ? `${path37}.${prop}` : prop;
         removals.push(propPath);
       }
     }
     for (const prop of Object.keys(newProps)) {
       if (!(prop in oldProps)) {
-        const propPath = path36 ? `${path36}.${prop}` : prop;
+        const propPath = path37 ? `${path37}.${prop}` : prop;
         additions.push(propPath);
         if (newRequired.has(prop)) {
           modifications.push({
@@ -104555,7 +105152,7 @@ var SchemaValidatorService = class {
     }
     if (oldSchema.type !== newSchema.type) {
       modifications.push({
-        path: path36 || "root",
+        path: path37 || "root",
         oldType: String(oldSchema.type || "any"),
         newType: String(newSchema.type || "any"),
         isBreaking: true
@@ -104564,7 +105161,7 @@ var SchemaValidatorService = class {
     const newRequiredArray = Array.from(newRequired);
     for (const prop of newRequiredArray) {
       if (!oldRequired.has(prop) && prop in oldProps) {
-        const propPath = path36 ? `${path36}.${prop}` : prop;
+        const propPath = path37 ? `${path37}.${prop}` : prop;
         modifications.push({
           path: propPath,
           oldType: "optional",
@@ -105440,7 +106037,7 @@ var VisualTesterService = class {
       const timestamp = /* @__PURE__ */ new Date();
       const urlHash = this.hashUrl(url);
       const viewportKey = `${viewport.width}x${viewport.height}`;
-      const path36 = FilePath.create(
+      const path37 = FilePath.create(
         `${this.config.baselineDirectory}/${urlHash}_${viewportKey}_${screenshotId}.png`
       );
       const loadTime = this.estimateLoadTime(url, viewport);
@@ -105456,7 +106053,7 @@ var VisualTesterService = class {
         url,
         viewport,
         timestamp,
-        path: path36,
+        path: path37,
         metadata
       };
       await this.storeScreenshotMetadata(screenshot);
@@ -105473,7 +106070,7 @@ var VisualTesterService = class {
       const viewport = options?.viewport || this.config.defaultViewport;
       const screenshotId = v4_default();
       const timestamp = /* @__PURE__ */ new Date();
-      const path36 = FilePath.create(
+      const path37 = FilePath.create(
         `${this.config.baselineDirectory}/${screenshotId}.png`
       );
       const metadata = {
@@ -105488,7 +106085,7 @@ var VisualTesterService = class {
         url,
         viewport,
         timestamp,
-        path: path36,
+        path: path37,
         metadata
       };
       await this.storeScreenshotMetadata(screenshot);
@@ -109700,12 +110297,12 @@ var VisualAccessibilityCoordinator = class extends BaseDomainCoordinator {
    */
   extractPathFeatures(url) {
     const features = [];
-    const path36 = new URL(url).pathname;
+    const path37 = new URL(url).pathname;
     const commonPaths = ["dashboard", "checkout", "login", "profile", "settings", "api", "admin", "search"];
     for (const cp of commonPaths) {
-      features.push(path36.includes(cp) ? 1 : 0);
+      features.push(path37.includes(cp) ? 1 : 0);
     }
-    const depth = path36.split("/").filter(Boolean).length;
+    const depth = path37.split("/").filter(Boolean).length;
     features.push(depth / 10);
     features.push(url.includes("?") ? 1 : 0);
     features.push(url.startsWith("https://") ? 1 : 0);
@@ -113304,12 +113901,12 @@ var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
     }
     return experiments;
   }
-  generateCriticalPathExperiment(path36, _architecture) {
-    const pathName = path36.join("-");
+  generateCriticalPathExperiment(path37, _architecture) {
+    const pathName = path37.join("-");
     return {
       id: v4_default(),
       name: `critical-path-${pathName}`,
-      description: `Test critical path: ${path36.join(" -> ")}`,
+      description: `Test critical path: ${path37.join(" -> ")}`,
       hypothesis: {
         statement: "System should handle partial path failure gracefully",
         metrics: [
@@ -113322,7 +113919,7 @@ var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
       },
       steadyState: {
         description: "All services in path are healthy",
-        probes: path36.map((service) => ({
+        probes: path37.map((service) => ({
           name: `${service}-health`,
           type: "http",
           target: `http://${service}/health`,
@@ -113330,7 +113927,7 @@ var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
           timeout: 5e3
         }))
       },
-      faults: path36.slice(0, -1).map((service) => ({
+      faults: path37.slice(0, -1).map((service) => ({
         id: v4_default(),
         type: "latency",
         target: {
@@ -120174,8 +120771,8 @@ var WorkflowOrchestrator = class {
       }
     }
   }
-  getValueByPath(obj, path36) {
-    const parts = path36.split(".");
+  getValueByPath(obj, path37) {
+    const parts = path37.split(".");
     let current = obj;
     for (const part of parts) {
       if (current === null || current === void 0) return void 0;
@@ -120184,8 +120781,8 @@ var WorkflowOrchestrator = class {
     }
     return current;
   }
-  setValueByPath(obj, path36, value) {
-    const parts = path36.split(".");
+  setValueByPath(obj, path37, value) {
+    const parts = path37.split(".");
     const dangerousKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
     for (const part of parts) {
       if (dangerousKeys.has(part)) throw new Error(`Invalid path: contains dangerous prototype key`);
@@ -120332,15 +120929,15 @@ var WorkflowOrchestrator = class {
   detectCircularDependencies(steps) {
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const visit = (stepId, path36) => {
-      if (recursionStack.has(stepId)) return [...path36, stepId].join(" -> ");
+    const visit = (stepId, path37) => {
+      if (recursionStack.has(stepId)) return [...path37, stepId].join(" -> ");
       if (visited.has(stepId)) return null;
       visited.add(stepId);
       recursionStack.add(stepId);
       const step = steps.find((s70) => s70.id === stepId);
       if (step?.dependsOn) {
         for (const dep of step.dependsOn) {
-          const result = visit(dep, [...path36, stepId]);
+          const result = visit(dep, [...path37, stepId]);
           if (result) return result;
         }
       }
@@ -129311,8 +129908,8 @@ var CrossPhaseHookExecutor = class {
     try {
       const parts = condition.split(/\s*(>|<|>=|<=|==|!=)\s*/);
       if (parts.length !== 3) return false;
-      const [path36, op, value] = parts;
-      const actual = this.getValueFromPath(context2, path36);
+      const [path37, op, value] = parts;
+      const actual = this.getValueFromPath(context2, path37);
       const expected = isNaN(Number(value)) ? value : Number(value);
       const actualNum = typeof actual === "number" ? actual : Number(actual);
       const expectedNum = typeof expected === "number" ? expected : Number(expected);
@@ -129336,8 +129933,8 @@ var CrossPhaseHookExecutor = class {
       return false;
     }
   }
-  getValueFromPath(obj, path36) {
-    return path36.split(".").reduce((curr, key) => {
+  getValueFromPath(obj, path37) {
+    return path37.split(".").reduce((curr, key) => {
       if (curr && typeof curr === "object" && key in curr) {
         return curr[key];
       }
@@ -129346,8 +129943,8 @@ var CrossPhaseHookExecutor = class {
   }
   extractFromContext(extract, context2) {
     const result = {};
-    for (const [key, path36] of Object.entries(extract)) {
-      result[key] = this.getValueFromPath(context2, path36);
+    for (const [key, path37] of Object.entries(extract)) {
+      result[key] = this.getValueFromPath(context2, path37);
     }
     return result;
   }
@@ -132189,6 +132786,9 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
     if (config) {
       this.costConfig = { ...DEFAULT_COST_CONFIG, ...config };
     }
+    this.initializeDb().catch(() => {
+    });
+    this.startAutoSave();
   }
   /**
    * Set cost configuration for token pricing.
@@ -132244,6 +132844,7 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
       this.totalTokensSaved += tokensSaved;
     }
     this.isDirty = true;
+    this.maybePersistToKv();
   }
   /**
    * Record pattern reuse for a task (tokens saved by skipping LLM call).
@@ -132516,8 +133117,8 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
    * Save metrics to persistent storage
    */
   async save() {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
+    const fs32 = await import("fs");
+    const path37 = await import("path");
     const data = {
       version: "1.0.0",
       sessionId: this.sessionId,
@@ -132531,26 +133132,26 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
       },
       lastSavedAt: Date.now()
     };
-    const filePath = path36.resolve(this.persistenceConfig.filePath);
-    const dirPath = path36.dirname(filePath);
-    if (!fs31.existsSync(dirPath)) {
-      fs31.mkdirSync(dirPath, { recursive: true });
+    const filePath = path37.resolve(this.persistenceConfig.filePath);
+    const dirPath = path37.dirname(filePath);
+    if (!fs32.existsSync(dirPath)) {
+      fs32.mkdirSync(dirPath, { recursive: true });
     }
-    fs31.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    fs32.writeFileSync(filePath, JSON.stringify(data, null, 2));
     this.isDirty = false;
   }
   /**
    * Load metrics from persistent storage
    */
   async load() {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
-    const filePath = path36.resolve(this.persistenceConfig.filePath);
-    if (!fs31.existsSync(filePath)) {
+    const fs32 = await import("fs");
+    const path37 = await import("path");
+    const filePath = path37.resolve(this.persistenceConfig.filePath);
+    if (!fs32.existsSync(filePath)) {
       return false;
     }
     try {
-      const content = fs31.readFileSync(filePath, "utf-8");
+      const content = fs32.readFileSync(filePath, "utf-8");
       const data = safeJsonParse(content);
       if (!data.version || !data.version.startsWith("1.")) {
         console.warn("[TokenMetricsCollector] Incompatible data version, skipping load");
@@ -133718,9 +134319,9 @@ function validatePipeline(pipeline11) {
 function detectCircularDependencies(stages) {
   const visited = /* @__PURE__ */ new Set();
   const recursionStack = /* @__PURE__ */ new Set();
-  const visit = (stageName, path36) => {
+  const visit = (stageName, path37) => {
     if (recursionStack.has(stageName)) {
-      return [...path36, stageName].join(" -> ");
+      return [...path37, stageName].join(" -> ");
     }
     if (visited.has(stageName)) {
       return null;
@@ -133730,7 +134331,7 @@ function detectCircularDependencies(stages) {
     const stage = stages.find((s70) => s70.name === stageName);
     if (stage?.depends_on) {
       for (const dep of stage.depends_on) {
-        const result = visit(dep, [...path36, stageName]);
+        const result = visit(dep, [...path37, stageName]);
         if (result) return result;
       }
     }
@@ -133850,7 +134451,7 @@ init_safe_json();
 import { randomUUID as randomUUID17 } from "crypto";
 import * as fs18 from "fs";
 import * as path19 from "path";
-import * as os3 from "os";
+import * as os4 from "os";
 init_safe_json();
 init_error_utils();
 var DEFAULT_CONFIG_DIR = ".aqe";
@@ -133877,7 +134478,7 @@ var PersistentScheduler = class {
    * Prevents writing to arbitrary filesystem locations
    */
   validateSchedulesPath(schedulesPath) {
-    const homeDir = os3.homedir();
+    const homeDir = os4.homedir();
     const resolvedPath = path19.resolve(schedulesPath);
     const resolvedHome = path19.resolve(homeDir);
     if (resolvedPath.startsWith(resolvedHome + path19.sep) || resolvedPath === resolvedHome) {
@@ -133888,7 +134489,7 @@ var PersistentScheduler = class {
     if (resolvedPath.startsWith(resolvedCwd + path19.sep) || resolvedPath === resolvedCwd) {
       return;
     }
-    const tmpDir = os3.tmpdir();
+    const tmpDir = os4.tmpdir();
     const resolvedTmp = path19.resolve(tmpDir);
     if (resolvedPath.startsWith(resolvedTmp + path19.sep) || resolvedPath === resolvedTmp) {
       return;
@@ -133901,7 +134502,7 @@ var PersistentScheduler = class {
    * Get the default path for schedules.json
    */
   getDefaultSchedulesPath() {
-    const homeDir = os3.homedir();
+    const homeDir = os4.homedir();
     return path19.join(homeDir, DEFAULT_CONFIG_DIR, SCHEDULES_FILE);
   }
   /**
@@ -134351,7 +134952,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.7.14" : "3.0.0";
+  return true ? "3.7.16" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -137135,9 +137736,9 @@ var N8nInstaller = class {
       // NPM package location
       join24(__dirname2, "../../assets/agents/n8n")
     ];
-    for (const path36 of possiblePaths) {
-      if (existsSync20(path36)) {
-        return path36;
+    for (const path37 of possiblePaths) {
+      if (existsSync20(path37)) {
+        return path37;
       }
     }
     return join24(process.cwd(), ".claude/agents/n8n");
@@ -137151,9 +137752,9 @@ var N8nInstaller = class {
       join24(process.cwd(), ".claude/skills"),
       join24(__dirname2, "../../assets/skills")
     ];
-    for (const path36 of possiblePaths) {
-      if (existsSync20(path36)) {
-        return path36;
+    for (const path37 of possiblePaths) {
+      if (existsSync20(path37)) {
+        return path37;
       }
     }
     return join24(process.cwd(), ".claude/skills");
@@ -142556,6 +143157,7 @@ function createProtocolHandler(cleanupAndExit2, ensureInitialized2) {
 }
 
 // src/cli/handlers/brain-handler.ts
+init_unified_memory();
 import path20 from "path";
 import chalk9 from "chalk";
 
@@ -143594,10 +144196,10 @@ function resolveFormat(format) {
   }
   return isRvfAvailable() ? "rvf" : "jsonl";
 }
-function detectImportFormat(path36, format) {
+function detectImportFormat(path37, format) {
   if (format === "rvf") return "rvf";
   if (format === "jsonl") return "jsonl";
-  if (path36.endsWith(".rvf")) return "rvf";
+  if (path37.endsWith(".rvf")) return "rvf";
   return "jsonl";
 }
 
@@ -143823,7 +144425,7 @@ Examples:
   }
 };
 function defaultDbPath() {
-  return path20.join(process.cwd(), ".agentic-qe", "memory.db");
+  return path20.join(findProjectRoot(), ".agentic-qe", "memory.db");
 }
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -143936,8 +144538,8 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
           console.log(chalk10.red("Test generation domain not available"));
           return;
         }
-        const path36 = await import("path");
-        const targetPath = path36.resolve(target || ".");
+        const path37 = await import("path");
+        const targetPath = path37.resolve(target || ".");
         const sourceFiles = walkSourceFiles(targetPath, { includeTests: false });
         if (sourceFiles.length === 0) {
           console.log(chalk10.yellow("No source files found"));
@@ -143973,14 +144575,14 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
             console.log(chalk10.cyan("  Tests:"));
             for (const test of generated.tests.slice(0, 10)) {
               console.log(`    ${chalk10.white(test.name)}`);
-              console.log(chalk10.gray(`      Source: ${path36.basename(test.sourceFile)}`));
+              console.log(chalk10.gray(`      Source: ${path37.basename(test.sourceFile)}`));
               console.log(chalk10.gray(`      Assertions: ${test.assertions}`));
               if (test.testCode) {
                 console.log(chalk10.gray(`      Test File: ${test.testFile}`));
-                const fs31 = await import("fs");
-                const testDir = path36.dirname(test.testFile);
-                fs31.mkdirSync(testDir, { recursive: true });
-                fs31.writeFileSync(test.testFile, test.testCode, "utf-8");
+                const fs32 = await import("fs");
+                const testDir = path37.dirname(test.testFile);
+                fs32.mkdirSync(testDir, { recursive: true });
+                fs32.writeFileSync(test.testFile, test.testCode, "utf-8");
                 console.log(chalk10.green(`      Written to: ${test.testFile}`));
               }
             }
@@ -144005,8 +144607,8 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
           console.log(chalk10.red("Test execution domain not available"));
           return;
         }
-        const path36 = await import("path");
-        const targetPath = path36.resolve(target || ".");
+        const path37 = await import("path");
+        const targetPath = path37.resolve(target || ".");
         const testFiles = walkSourceFiles(targetPath, { testsOnly: true });
         if (testFiles.length === 0) {
           console.log(chalk10.yellow("No test files found"));
@@ -144362,8 +144964,8 @@ var WizardFormat = class {
   /**
    * Format a path relative to cwd
    */
-  static relativePath(path36, cwd) {
-    return relative7(cwd, path36) || ".";
+  static relativePath(path37, cwd) {
+    return relative7(cwd, path37) || ".";
   }
   /**
    * Format a boolean as Yes/No
@@ -145179,8 +145781,8 @@ function createCoverageCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk14.red("Coverage analysis domain not available"));
         return;
       }
-      const path36 = await import("path");
-      const targetPath = path36.resolve(analyzeTarget);
+      const path37 = await import("path");
+      const targetPath = path37.resolve(analyzeTarget);
       const sourceFiles = walkSourceFiles(targetPath, { includeTests: false });
       if (sourceFiles.length === 0) {
         console.log(chalk14.yellow("No source files found"));
@@ -145502,8 +146104,8 @@ function createSecurityCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk16.red("Security domain not available"));
         return;
       }
-      const path36 = await import("path");
-      const targetPath = path36.resolve(options.target);
+      const path37 = await import("path");
+      const targetPath = path37.resolve(options.target);
       const files = walkSourceFiles(targetPath, { includeTests: true });
       if (files.length === 0) {
         console.log(chalk16.yellow("No files found to scan"));
@@ -145616,13 +146218,13 @@ function createCodeCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk17.red("Code intelligence domain not available"));
         return;
       }
-      const path36 = await import("path");
+      const path37 = await import("path");
       const format = options.format || "text";
       if (action === "index") {
         console.log(chalk17.blue(`
  Indexing codebase at ${target || "."}...
 `));
-        const targetPath = path36.resolve(target || ".");
+        const targetPath = path37.resolve(target || ".");
         const paths = walkSourceFiles(targetPath, {
           includeTests: options.includeTests || false
         });
@@ -145691,7 +146293,7 @@ function createCodeCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk17.blue(`
  Analyzing impact for ${target || "recent changes"}...
 `));
-        const targetPath = path36.resolve(target || ".");
+        const targetPath = path37.resolve(target || ".");
         const changedFiles = walkSourceFiles(targetPath, { maxDepth: 2 }).slice(0, 10);
         const result = await codeAPI.analyzeImpact({
           changedFiles,
@@ -145741,7 +146343,7 @@ function createCodeCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk17.blue(`
  Mapping dependencies for ${target || "."}...
 `));
-        const targetPath = path36.resolve(target || ".");
+        const targetPath = path37.resolve(target || ".");
         const files = walkSourceFiles(targetPath, { maxDepth: 2 }).slice(0, 50);
         const result = await codeAPI.mapDependencies({
           files,
@@ -145897,32 +146499,32 @@ var v3Agents = [
 function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
   const migrateCmd = new Command6("migrate").description("V2-to-V3 migration tools with agent compatibility (ADR-048)");
   migrateCmd.command("run").description("Run full migration from v2 to v3").option("--dry-run", "Preview migration without making changes").option("--backup", "Create backup before migration (recommended)", true).option("--skip-memory", "Skip memory database migration").option("--skip-patterns", "Skip pattern migration").option("--skip-config", "Skip configuration migration").option("--skip-agents", "Skip agent name migration").option("--target <component>", "Migrate specific component (agents, skills, config, memory)").option("--force", "Force migration even if v3 already exists").action(async (options) => {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
+    const fs32 = await import("fs");
+    const path37 = await import("path");
     console.log(chalk18.blue("\n V2 to V3 Migration (ADR-048)\n"));
     const cwd = process.cwd();
-    const v2Dir = path36.join(cwd, ".agentic-qe");
-    const v3Dir = path36.join(cwd, ".aqe");
-    const claudeAgentDir = path36.join(cwd, ".claude", "agents");
+    const v2Dir = path37.join(cwd, ".agentic-qe");
+    const v3Dir = path37.join(cwd, ".aqe");
+    const claudeAgentDir = path37.join(cwd, ".claude", "agents");
     console.log(chalk18.white("1. Detecting v2 installation..."));
-    const hasV2Dir = fs31.existsSync(v2Dir);
-    const hasClaudeAgents = fs31.existsSync(claudeAgentDir);
+    const hasV2Dir = fs32.existsSync(v2Dir);
+    const hasClaudeAgents = fs32.existsSync(claudeAgentDir);
     if (!hasV2Dir && !hasClaudeAgents) {
       console.log(chalk18.yellow("   ! No v2 installation found"));
       console.log(chalk18.gray("   This might be a fresh project. Use `aqe init` instead."));
       await cleanupAndExit2(0);
     }
     const v2Files = {
-      memoryDb: path36.join(v2Dir, "memory.db"),
-      config: path36.join(v2Dir, "config.json"),
-      patterns: path36.join(v2Dir, "patterns")
+      memoryDb: path37.join(v2Dir, "memory.db"),
+      config: path37.join(v2Dir, "config.json"),
+      patterns: path37.join(v2Dir, "patterns")
     };
-    const hasMemory = hasV2Dir && fs31.existsSync(v2Files.memoryDb);
-    const hasConfig = hasV2Dir && fs31.existsSync(v2Files.config);
-    const hasPatterns = hasV2Dir && fs31.existsSync(v2Files.patterns);
+    const hasMemory = hasV2Dir && fs32.existsSync(v2Files.memoryDb);
+    const hasConfig = hasV2Dir && fs32.existsSync(v2Files.config);
+    const hasPatterns = hasV2Dir && fs32.existsSync(v2Files.patterns);
     const agentsToMigrate = [];
     if (hasClaudeAgents) {
-      const files = fs31.readdirSync(claudeAgentDir);
+      const files = fs32.readdirSync(claudeAgentDir);
       for (const file of files) {
         if (file.endsWith(".md") && file.startsWith("qe-")) {
           const agentName = file.replace(".md", "");
@@ -145939,7 +146541,7 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     console.log(chalk18.gray(`     Agents to migrate: ${agentsToMigrate.length}
 `));
     console.log(chalk18.white("2. Checking v3 status..."));
-    if (fs31.existsSync(v3Dir) && !options.force) {
+    if (fs32.existsSync(v3Dir) && !options.force) {
       console.log(chalk18.yellow("   ! v3 directory already exists at .aqe/"));
       console.log(chalk18.gray("   Use --force to overwrite existing v3 installation."));
       await cleanupAndExit2(1);
@@ -145948,14 +146550,14 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if (options.dryRun) {
       console.log(chalk18.blue(" Dry Run - Migration Plan:\n"));
       if (!options.skipMemory && hasMemory) {
-        const stats = fs31.statSync(v2Files.memoryDb);
+        const stats = fs32.statSync(v2Files.memoryDb);
         console.log(chalk18.gray(`  - Migrate memory.db (${(stats.size / 1024).toFixed(1)} KB)`));
       }
       if (!options.skipConfig && hasConfig) {
         console.log(chalk18.gray("  - Convert config.json to v3 format"));
       }
       if (!options.skipPatterns && hasPatterns) {
-        const patternFiles = fs31.readdirSync(v2Files.patterns);
+        const patternFiles = fs32.readdirSync(v2Files.patterns);
         console.log(chalk18.gray(`  - Migrate ${patternFiles.length} pattern files`));
       }
       if (!options.skipAgents && agentsToMigrate.length > 0) {
@@ -145970,22 +146572,22 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     }
     if (options.backup) {
       console.log(chalk18.white("3. Creating backup..."));
-      const backupDir = path36.join(cwd, ".aqe-backup", `backup-${Date.now()}`);
+      const backupDir = path37.join(cwd, ".aqe-backup", `backup-${Date.now()}`);
       try {
-        fs31.mkdirSync(backupDir, { recursive: true });
+        fs32.mkdirSync(backupDir, { recursive: true });
         const copyDir = (src, dest) => {
-          if (!fs31.existsSync(src)) return;
-          if (fs31.statSync(src).isDirectory()) {
-            fs31.mkdirSync(dest, { recursive: true });
-            for (const file of fs31.readdirSync(src)) {
-              copyDir(path36.join(src, file), path36.join(dest, file));
+          if (!fs32.existsSync(src)) return;
+          if (fs32.statSync(src).isDirectory()) {
+            fs32.mkdirSync(dest, { recursive: true });
+            for (const file of fs32.readdirSync(src)) {
+              copyDir(path37.join(src, file), path37.join(dest, file));
             }
           } else {
-            fs31.copyFileSync(src, dest);
+            fs32.copyFileSync(src, dest);
           }
         };
-        if (hasV2Dir) copyDir(v2Dir, path36.join(backupDir, ".agentic-qe"));
-        if (hasClaudeAgents) copyDir(claudeAgentDir, path36.join(backupDir, ".claude", "agents"));
+        if (hasV2Dir) copyDir(v2Dir, path37.join(backupDir, ".agentic-qe"));
+        if (hasClaudeAgents) copyDir(claudeAgentDir, path37.join(backupDir, ".claude", "agents"));
         console.log(chalk18.green(`   * Backup created at .aqe-backup/
 `));
       } catch (err3) {
@@ -145998,11 +146600,11 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if (!options.target || options.target === "config" || options.target === "memory") {
       console.log(chalk18.white("4. Creating v3 directory structure..."));
       try {
-        fs31.mkdirSync(v3Dir, { recursive: true });
-        fs31.mkdirSync(path36.join(v3Dir, "agentdb"), { recursive: true });
-        fs31.mkdirSync(path36.join(v3Dir, "reasoning-bank"), { recursive: true });
-        fs31.mkdirSync(path36.join(v3Dir, "cache"), { recursive: true });
-        fs31.mkdirSync(path36.join(v3Dir, "logs"), { recursive: true });
+        fs32.mkdirSync(v3Dir, { recursive: true });
+        fs32.mkdirSync(path37.join(v3Dir, "agentdb"), { recursive: true });
+        fs32.mkdirSync(path37.join(v3Dir, "reasoning-bank"), { recursive: true });
+        fs32.mkdirSync(path37.join(v3Dir, "cache"), { recursive: true });
+        fs32.mkdirSync(path37.join(v3Dir, "logs"), { recursive: true });
         console.log(chalk18.green("   * Directory structure created\n"));
       } catch (err3) {
         console.log(chalk18.red(`   x Failed: ${err3}
@@ -146013,17 +146615,17 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "memory") && !options.skipMemory && hasMemory) {
       console.log(chalk18.white("5. Migrating memory database..."));
       try {
-        const destDb = path36.join(v3Dir, "agentdb", "memory.db");
-        fs31.copyFileSync(v2Files.memoryDb, destDb);
-        const indexFile = path36.join(v3Dir, "agentdb", "index.json");
-        fs31.writeFileSync(indexFile, JSON.stringify({
+        const destDb = path37.join(v3Dir, "agentdb", "memory.db");
+        fs32.copyFileSync(v2Files.memoryDb, destDb);
+        const indexFile = path37.join(v3Dir, "agentdb", "index.json");
+        fs32.writeFileSync(indexFile, JSON.stringify({
           version: "3.0.0",
           migratedFrom: "v2",
           migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
           hnswEnabled: true,
           vectorDimensions: 384
         }, null, 2));
-        const stats = fs31.statSync(v2Files.memoryDb);
+        const stats = fs32.statSync(v2Files.memoryDb);
         console.log(chalk18.green(`   * Memory database migrated (${(stats.size / 1024).toFixed(1)} KB)
 `));
       } catch (err3) {
@@ -146040,7 +146642,7 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "config") && !options.skipConfig && hasConfig) {
       console.log(chalk18.white("6. Migrating configuration..."));
       try {
-        const v2ConfigRaw = fs31.readFileSync(v2Files.config, "utf-8");
+        const v2ConfigRaw = fs32.readFileSync(v2Files.config, "utf-8");
         const v2Config = parseJsonFile(v2ConfigRaw, v2Files.config);
         const v3Config = {
           version: "3.0.0",
@@ -146076,8 +146678,8 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
             migrationDate: (/* @__PURE__ */ new Date()).toISOString()
           }
         };
-        const destConfig = path36.join(v3Dir, "config.json");
-        fs31.writeFileSync(destConfig, JSON.stringify(v3Config, null, 2));
+        const destConfig = path37.join(v3Dir, "config.json");
+        fs32.writeFileSync(destConfig, JSON.stringify(v3Config, null, 2));
         console.log(chalk18.green("   * Configuration migrated\n"));
       } catch (err3) {
         console.log(chalk18.red(`   x Config migration failed: ${err3}
@@ -146093,18 +146695,18 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "memory") && !options.skipPatterns && hasPatterns) {
       console.log(chalk18.white("7. Migrating patterns to ReasoningBank..."));
       try {
-        const patternFiles = fs31.readdirSync(v2Files.patterns);
+        const patternFiles = fs32.readdirSync(v2Files.patterns);
         let migratedCount = 0;
         for (const file of patternFiles) {
-          const srcPath = path36.join(v2Files.patterns, file);
-          const destPath = path36.join(v3Dir, "reasoning-bank", file);
-          if (fs31.statSync(srcPath).isFile()) {
-            fs31.copyFileSync(srcPath, destPath);
+          const srcPath = path37.join(v2Files.patterns, file);
+          const destPath = path37.join(v3Dir, "reasoning-bank", file);
+          if (fs32.statSync(srcPath).isFile()) {
+            fs32.copyFileSync(srcPath, destPath);
             migratedCount++;
           }
         }
-        const indexPath = path36.join(v3Dir, "reasoning-bank", "index.json");
-        fs31.writeFileSync(indexPath, JSON.stringify({
+        const indexPath = path37.join(v3Dir, "reasoning-bank", "index.json");
+        fs32.writeFileSync(indexPath, JSON.stringify({
           version: "3.0.0",
           migratedFrom: "v2",
           migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -146125,17 +146727,17 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "agents") && !options.skipAgents && agentsToMigrate.length > 0) {
       console.log(chalk18.white("8. Migrating agent names (ADR-048)..."));
       let migratedAgents = 0;
-      const deprecatedDir = path36.join(claudeAgentDir, "deprecated");
-      if (!fs31.existsSync(deprecatedDir)) {
-        fs31.mkdirSync(deprecatedDir, { recursive: true });
+      const deprecatedDir = path37.join(claudeAgentDir, "deprecated");
+      if (!fs32.existsSync(deprecatedDir)) {
+        fs32.mkdirSync(deprecatedDir, { recursive: true });
       }
       for (const v2Name of agentsToMigrate) {
         const v3Name = resolveAgentName(v2Name);
-        const v2FilePath = path36.join(claudeAgentDir, `${v2Name}.md`);
-        const v3FilePath = path36.join(claudeAgentDir, `${v3Name}.md`);
-        const deprecatedPath = path36.join(deprecatedDir, `${v2Name}.md.v2`);
+        const v2FilePath = path37.join(claudeAgentDir, `${v2Name}.md`);
+        const v3FilePath = path37.join(claudeAgentDir, `${v3Name}.md`);
+        const deprecatedPath = path37.join(deprecatedDir, `${v2Name}.md.v2`);
         try {
-          const content = fs31.readFileSync(v2FilePath, "utf-8");
+          const content = fs32.readFileSync(v2FilePath, "utf-8");
           const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
           if (!frontmatterMatch) {
             console.log(chalk18.yellow(`   ! ${v2Name}: No frontmatter found, skipping`));
@@ -146163,8 +146765,8 @@ v2_compat:
           const newContent = `---
 ${newFrontmatter}
 ---${body}`;
-          fs31.writeFileSync(v3FilePath, newContent, "utf-8");
-          fs31.renameSync(v2FilePath, deprecatedPath);
+          fs32.writeFileSync(v3FilePath, newContent, "utf-8");
+          fs32.renameSync(v2FilePath, deprecatedPath);
           console.log(chalk18.gray(`   ${v2Name} -> ${v3Name}`));
           migratedAgents++;
         } catch (err3) {
@@ -146185,10 +146787,10 @@ ${newFrontmatter}
     }
     console.log(chalk18.white("9. Validating migration..."));
     const validationResults = {
-      v3DirExists: fs31.existsSync(v3Dir),
-      configExists: fs31.existsSync(path36.join(v3Dir, "config.json")),
-      agentdbExists: fs31.existsSync(path36.join(v3Dir, "agentdb")),
-      reasoningBankExists: fs31.existsSync(path36.join(v3Dir, "reasoning-bank"))
+      v3DirExists: fs32.existsSync(v3Dir),
+      configExists: fs32.existsSync(path37.join(v3Dir, "config.json")),
+      agentdbExists: fs32.existsSync(path37.join(v3Dir, "agentdb")),
+      reasoningBankExists: fs32.existsSync(path37.join(v3Dir, "reasoning-bank"))
     };
     const allValid = Object.values(validationResults).every((v65) => v65);
     if (allValid) {
@@ -146208,18 +146810,18 @@ ${newFrontmatter}
     await cleanupAndExit2(0);
   });
   migrateCmd.command("status").description("Check migration status of current project").option("--json", "Output as JSON").action(async (options) => {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
+    const fs32 = await import("fs");
+    const path37 = await import("path");
     const cwd = process.cwd();
-    const v2Dir = path36.join(cwd, ".agentic-qe");
-    const v3Dir = path36.join(cwd, ".aqe");
-    const claudeAgentDir = path36.join(cwd, ".claude", "agents");
-    const isV2Project = fs31.existsSync(v2Dir);
-    const isV3Project = fs31.existsSync(v3Dir);
+    const v2Dir = path37.join(cwd, ".agentic-qe");
+    const v3Dir = path37.join(cwd, ".aqe");
+    const claudeAgentDir = path37.join(cwd, ".claude", "agents");
+    const isV2Project = fs32.existsSync(v2Dir);
+    const isV3Project = fs32.existsSync(v3Dir);
     const agentsToMigrate = [];
     const agentsMigrated = [];
-    if (fs31.existsSync(claudeAgentDir)) {
-      const files = fs31.readdirSync(claudeAgentDir);
+    if (fs32.existsSync(claudeAgentDir)) {
+      const files = fs32.readdirSync(claudeAgentDir);
       for (const file of files) {
         if (file.endsWith(".md") && file.startsWith("qe-")) {
           const agentName = file.replace(".md", "");
@@ -146268,15 +146870,15 @@ ${newFrontmatter}
     await cleanupAndExit2(0);
   });
   migrateCmd.command("verify").description("Verify migration integrity").option("--fix", "Attempt to fix issues automatically").action(async (options) => {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
+    const fs32 = await import("fs");
+    const path37 = await import("path");
     console.log(chalk18.bold("\n Verifying Migration...\n"));
     const cwd = process.cwd();
-    const v3Dir = path36.join(cwd, ".aqe");
-    const claudeAgentDir = path36.join(cwd, ".claude", "agents");
+    const v3Dir = path37.join(cwd, ".aqe");
+    const claudeAgentDir = path37.join(cwd, ".claude", "agents");
     const deprecatedInUse = [];
-    if (fs31.existsSync(claudeAgentDir)) {
-      const files = fs31.readdirSync(claudeAgentDir);
+    if (fs32.existsSync(claudeAgentDir)) {
+      const files = fs32.readdirSync(claudeAgentDir);
       for (const file of files) {
         if (file.endsWith(".md") && file.startsWith("qe-")) {
           const agentName = file.replace(".md", "");
@@ -146289,8 +146891,8 @@ ${newFrontmatter}
     const checks = [
       {
         name: "V3 Directory",
-        passed: fs31.existsSync(v3Dir),
-        message: fs31.existsSync(v3Dir) ? "Exists" : "Missing .aqe/"
+        passed: fs32.existsSync(v3Dir),
+        message: fs32.existsSync(v3Dir) ? "Exists" : "Missing .aqe/"
       },
       {
         name: "Agent Compatibility",
@@ -146299,7 +146901,7 @@ ${newFrontmatter}
       },
       {
         name: "Config Format",
-        passed: fs31.existsSync(path36.join(v3Dir, "config.json")),
+        passed: fs32.existsSync(path37.join(v3Dir, "config.json")),
         message: "Valid v3 config"
       }
     ];
@@ -146324,15 +146926,15 @@ ${newFrontmatter}
     await cleanupAndExit2(0);
   });
   migrateCmd.command("rollback").description("Rollback to previous version from backup").option("--backup-id <id>", "Specific backup to restore").option("--force", "Skip confirmation").action(async (options) => {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
+    const fs32 = await import("fs");
+    const path37 = await import("path");
     const cwd = process.cwd();
-    const backupRoot = path36.join(cwd, ".aqe-backup");
-    if (!fs31.existsSync(backupRoot)) {
+    const backupRoot = path37.join(cwd, ".aqe-backup");
+    if (!fs32.existsSync(backupRoot)) {
       console.log(chalk18.yellow("\n! No backups found.\n"));
       return;
     }
-    const backups = fs31.readdirSync(backupRoot).filter((f74) => f74.startsWith("backup-")).sort().reverse();
+    const backups = fs32.readdirSync(backupRoot).filter((f74) => f74.startsWith("backup-")).sort().reverse();
     if (backups.length === 0) {
       console.log(chalk18.yellow("\n! No backups found.\n"));
       return;
@@ -146344,8 +146946,8 @@ ${newFrontmatter}
       console.log(`  ${chalk18.cyan(backup)} - ${date.toLocaleString()}`);
     }
     const targetBackup = options.backupId || backups[0];
-    const backupPath = path36.join(backupRoot, targetBackup);
-    if (!fs31.existsSync(backupPath)) {
+    const backupPath = path37.join(backupRoot, targetBackup);
+    if (!fs32.existsSync(backupPath)) {
       console.log(chalk18.red(`
  Backup not found: ${targetBackup}
 `));
@@ -146360,21 +146962,21 @@ ${newFrontmatter}
     console.log(chalk18.bold(`
  Rolling back to ${targetBackup}...
 `));
-    const v2Backup = path36.join(backupPath, ".agentic-qe");
-    const agentsBackup = path36.join(backupPath, ".claude", "agents");
-    if (fs31.existsSync(v2Backup)) {
-      const v2Dir = path36.join(cwd, ".agentic-qe");
-      fs31.cpSync(v2Backup, v2Dir, { recursive: true });
+    const v2Backup = path37.join(backupPath, ".agentic-qe");
+    const agentsBackup = path37.join(backupPath, ".claude", "agents");
+    if (fs32.existsSync(v2Backup)) {
+      const v2Dir = path37.join(cwd, ".agentic-qe");
+      fs32.cpSync(v2Backup, v2Dir, { recursive: true });
       console.log(chalk18.dim("  Restored .agentic-qe/"));
     }
-    if (fs31.existsSync(agentsBackup)) {
-      const agentsDir = path36.join(cwd, ".claude", "agents");
-      fs31.cpSync(agentsBackup, agentsDir, { recursive: true });
+    if (fs32.existsSync(agentsBackup)) {
+      const agentsDir = path37.join(cwd, ".claude", "agents");
+      fs32.cpSync(agentsBackup, agentsDir, { recursive: true });
       console.log(chalk18.dim("  Restored .claude/agents/"));
     }
-    const v3Dir = path36.join(cwd, ".aqe");
-    if (fs31.existsSync(v3Dir)) {
-      fs31.rmSync(v3Dir, { recursive: true, force: true });
+    const v3Dir = path37.join(cwd, ".aqe");
+    if (fs32.existsSync(v3Dir)) {
+      fs32.rmSync(v3Dir, { recursive: true, force: true });
       console.log(chalk18.dim("  Removed .aqe/"));
     }
     console.log(chalk18.green("\n Rollback complete!\n"));
@@ -147932,8 +148534,8 @@ function createCompletionsCommand(cleanupAndExit2) {
     console.log(generateCompletion("powershell"));
   });
   completionsCmd.command("install").description("Auto-install completions for current shell").option("-s, --shell <shell>", "Target shell (bash|zsh|fish|powershell)").action(async (options) => {
-    const fs31 = await import("fs");
-    const path36 = await import("path");
+    const fs32 = await import("fs");
+    const path37 = await import("path");
     const shellInfo = options.shell ? { name: options.shell, configFile: null, detected: false } : detectShell();
     if (shellInfo.name === "unknown") {
       console.log(chalk19.red("Could not detect shell. Please specify with --shell option.\n"));
@@ -147947,11 +148549,11 @@ Installing completions for ${shellInfo.name}...
     const script = generateCompletion(shellInfo.name);
     if (shellInfo.name === "fish") {
       const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-      const fishCompletionsDir = path36.join(homeDir, ".config", "fish", "completions");
+      const fishCompletionsDir = path37.join(homeDir, ".config", "fish", "completions");
       try {
-        fs31.mkdirSync(fishCompletionsDir, { recursive: true });
-        const completionFile = path36.join(fishCompletionsDir, "aqe.fish");
-        fs31.writeFileSync(completionFile, script);
+        fs32.mkdirSync(fishCompletionsDir, { recursive: true });
+        const completionFile = path37.join(fishCompletionsDir, "aqe.fish");
+        fs32.writeFileSync(completionFile, script);
         console.log(chalk19.green(`Completions installed to: ${completionFile}`));
         console.log(chalk19.gray("\nRestart your shell or run: source ~/.config/fish/completions/aqe.fish\n"));
       } catch (err3) {
@@ -156391,6 +156993,7 @@ async function syncIncrementalToCloud(since, config) {
 init_esm_node();
 import * as fs29 from "fs";
 import * as path29 from "path";
+init_unified_memory();
 init_error_utils();
 init_logging();
 var logger21 = LoggerFactory.create("pull-agent");
@@ -156612,7 +157215,7 @@ var PullSyncAgent = class {
     if (this.config.targetDb) {
       return path29.resolve(this.config.targetDb);
     }
-    return path29.resolve(process.cwd(), ".agentic-qe/memory.db");
+    return path29.resolve(findProjectRoot(), ".agentic-qe/memory.db");
   }
   backupLocalDb() {
     if (this.config.dryRun) return;
@@ -158150,11 +158753,11 @@ function createCategoryEngineWrapper(rawEngine) {
     add_morphism(source, target, name) {
       morphisms.push({ source, target, name });
     },
-    verify_composition(path36) {
-      if (path36.length < 2) return true;
-      for (let i58 = 0; i58 < path36.length - 1; i58++) {
-        const source = path36[i58];
-        const target = path36[i58 + 1];
+    verify_composition(path37) {
+      if (path37.length < 2) return true;
+      for (let i58 = 0; i58 < path37.length - 1; i58++) {
+        const source = path37[i58];
+        const target = path37[i58 + 1];
         const hasMorphism = morphisms.some((m74) => m74.source === source && m74.target === target);
         if (!hasMorphism) return false;
       }
@@ -158269,14 +158872,14 @@ var CategoryAdapter = class {
    * @param path - Array of type names representing a composition path
    * @returns True if the composition is valid
    */
-  verifyComposition(path36) {
+  verifyComposition(path37) {
     this.ensureInitialized();
-    if (path36.length < 2) {
+    if (path37.length < 2) {
       return true;
     }
-    const isValid = this.engine.verify_composition(path36);
+    const isValid = this.engine.verify_composition(path37);
     this.logger.debug("Verified composition", {
-      path: path36,
+      path: path37,
       isValid
     });
     return isValid;
@@ -158315,8 +158918,8 @@ var CategoryAdapter = class {
     for (const element of pipeline11.elements) {
       this.addMorphism(element.inputType, element.outputType, element.name);
     }
-    const path36 = this.buildCompositionPath(pipeline11);
-    const compositionValid = this.verifyComposition(path36);
+    const path37 = this.buildCompositionPath(pipeline11);
+    const compositionValid = this.verifyComposition(path37);
     const mismatches = this.checkTypeConsistency();
     const warnings = this.generateWarnings(pipeline11, compositionValid, mismatches);
     const durationMs = Date.now() - startTime;
@@ -158340,17 +158943,17 @@ var CategoryAdapter = class {
    * Build a composition path from a pipeline
    */
   buildCompositionPath(pipeline11) {
-    const path36 = [pipeline11.inputType];
+    const path37 = [pipeline11.inputType];
     for (const element of pipeline11.elements) {
-      if (element.inputType !== path36[path36.length - 1]) {
-        path36.push(element.inputType);
+      if (element.inputType !== path37[path37.length - 1]) {
+        path37.push(element.inputType);
       }
-      path36.push(element.outputType);
+      path37.push(element.outputType);
     }
-    if (path36[path36.length - 1] !== pipeline11.outputType) {
-      path36.push(pipeline11.outputType);
+    if (path37[path37.length - 1] !== pipeline11.outputType) {
+      path37.push(pipeline11.outputType);
     }
-    return path36;
+    return path37;
   }
   /**
    * Infer a schema from a type name
@@ -159988,8 +160591,8 @@ var WasmLoader = class {
         })(),
         join63(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
       ].filter((p74) => p74 !== null);
-      for (const path36 of wasmPaths) {
-        if (existsSync64(path36)) {
+      for (const path37 of wasmPaths) {
+        if (existsSync64(path37)) {
           return true;
         }
       }
@@ -160251,9 +160854,9 @@ var WasmLoader = class {
       join63(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
     ].filter((p74) => p74 !== null);
     let wasmPath = null;
-    for (const path36 of wasmPaths) {
-      if (existsSync64(path36)) {
-        wasmPath = path36;
+    for (const path37 of wasmPaths) {
+      if (existsSync64(path37)) {
+        wasmPath = path37;
         break;
       }
     }
@@ -163398,6 +164001,134 @@ function capitalize(s70) {
   return s70.charAt(0).toUpperCase() + s70.slice(1);
 }
 
+// src/cli/commands/prove.ts
+import { Command as Command20 } from "commander";
+import * as crypto6 from "crypto";
+import * as fs31 from "fs";
+import * as path36 from "path";
+function hashAttestation(data) {
+  const serialized = JSON.stringify(data, null, 0);
+  return crypto6.createHash("sha256").update(serialized).digest("hex");
+}
+async function collectMetrics(projectRoot) {
+  const metrics = {
+    testCount: 0,
+    passRate: 0,
+    coveragePercent: 0,
+    vulnerabilities: 0,
+    qualityScore: 0,
+    patternsUsed: 0
+  };
+  try {
+    const junitPath = path36.join(projectRoot, "junit.xml");
+    if (fs31.existsSync(junitPath)) {
+      const content = fs31.readFileSync(junitPath, "utf-8");
+      const testsMatch = content.match(/tests="(\d+)"/);
+      const failsMatch = content.match(/failures="(\d+)"/);
+      if (testsMatch) {
+        metrics.testCount = parseInt(testsMatch[1], 10);
+        const failures = failsMatch ? parseInt(failsMatch[1], 10) : 0;
+        metrics.passRate = metrics.testCount > 0 ? (metrics.testCount - failures) / metrics.testCount * 100 : 0;
+      }
+    }
+  } catch {
+  }
+  try {
+    const coveragePath = path36.join(projectRoot, "coverage", "coverage-summary.json");
+    if (fs31.existsSync(coveragePath)) {
+      const coverage = JSON.parse(fs31.readFileSync(coveragePath, "utf-8"));
+      metrics.coveragePercent = coverage?.total?.lines?.pct ?? 0;
+    }
+  } catch {
+  }
+  try {
+    const dbPath = path36.join(projectRoot, ".agentic-qe", "memory.db");
+    if (fs31.existsSync(dbPath)) {
+      metrics.patternsUsed = 1;
+    }
+  } catch {
+  }
+  metrics.qualityScore = Math.round(
+    metrics.passRate * 0.4 + metrics.coveragePercent * 0.3 + (metrics.vulnerabilities === 0 ? 100 : Math.max(0, 100 - metrics.vulnerabilities * 10)) * 0.3
+  );
+  return metrics;
+}
+function buildAttestation(projectRoot, metrics) {
+  const data = {
+    version: "1.0.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot,
+    attestation: {
+      testsExecuted: metrics.testCount > 0,
+      coverageChecked: metrics.coveragePercent > 0,
+      securityScanned: metrics.vulnerabilities === 0,
+      qualityGatePassed: metrics.qualityScore >= 70
+    },
+    metrics,
+    generatedBy: "agentic-qe prove"
+  };
+  const hash = hashAttestation(data);
+  return { ...data, hash };
+}
+function formatMarkdown(att) {
+  return [
+    "# Proof of Quality",
+    "",
+    `**Generated:** ${att.timestamp}`,
+    `**Project:** ${att.projectRoot}`,
+    `**Hash:** \`${att.hash}\``,
+    "",
+    "## Attestation",
+    "",
+    "| Check | Status |",
+    "|-------|--------|",
+    `| Tests Executed | ${att.attestation.testsExecuted ? "PASS" : "FAIL"} |`,
+    `| Coverage Checked | ${att.attestation.coverageChecked ? "PASS" : "FAIL"} |`,
+    `| Security Scanned | ${att.attestation.securityScanned ? "PASS" : "FAIL"} |`,
+    `| Quality Gate | ${att.attestation.qualityGatePassed ? "PASSED" : "FAILED"} |`,
+    "",
+    "## Metrics",
+    "",
+    "| Metric | Value |",
+    "|--------|-------|",
+    `| Tests | ${att.metrics.testCount} |`,
+    `| Pass Rate | ${att.metrics.passRate.toFixed(1)}% |`,
+    `| Coverage | ${att.metrics.coveragePercent.toFixed(1)}% |`,
+    `| Vulnerabilities | ${att.metrics.vulnerabilities} |`,
+    `| Quality Score | ${att.metrics.qualityScore}/100 |`,
+    "",
+    "---",
+    `*${att.generatedBy}*`
+  ].join("\n");
+}
+async function handleProve(options) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const metrics = await collectMetrics(projectRoot);
+  const attestation = buildAttestation(projectRoot, metrics);
+  const content = options.format === "markdown" ? formatMarkdown(attestation) : JSON.stringify(attestation, null, 2);
+  if (options.output) {
+    fs31.writeFileSync(options.output, content);
+    console.log(`Quality attestation written to ${options.output}`);
+  } else {
+    console.log(content);
+  }
+  return attestation;
+}
+function createProveCommand(_context, cleanupAndExit2, _ensureInitialized) {
+  return new Command20("prove").description("Generate a verifiable Proof-of-Quality attestation").option("-F, --format <format>", "Output format (json|markdown)", "json").option("-o, --output <path>", "Write attestation to file").action(async (options) => {
+    try {
+      await handleProve({
+        format: options.format,
+        output: options.output
+      });
+      await cleanupAndExit2(0);
+    } catch (error) {
+      console.error("Failed to generate proof-of-quality:", error);
+      await cleanupAndExit2(1);
+    }
+  });
+}
+
 // src/cli/index.ts
 var INTERNAL_LOG_PREFIXES = [
   "[UnifiedMemory]",
@@ -163523,10 +164254,10 @@ async function ensureInitializedStrict() {
   if (context.initialized && context.kernel && context.queen) {
     return true;
   }
-  const fs31 = await import("fs");
-  const path36 = await import("path");
-  const configDir = path36.resolve(".agentic-qe");
-  if (!fs31.existsSync(configDir)) {
+  const fs32 = await import("fs");
+  const path37 = await import("path");
+  const configDir = path37.resolve(".agentic-qe");
+  if (!fs32.existsSync(configDir)) {
     console.error(chalk33.red("\nError: AQE system not initialized in this directory."));
     console.log(chalk33.yellow("Run `aqe init` first to set up this project.\n"));
     return false;
@@ -163581,15 +164312,15 @@ async function cleanupAndExit(code = 0) {
   }
   process.exit(code);
 }
-var program = new Command20();
-var VERSION = true ? "3.7.14" : "0.0.0-dev";
+var program = new Command21();
+var VERSION = true ? "3.7.16" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry2 = createCommandRegistry(context, cleanupAndExit, ensureInitialized, ensureInitializedStrict);
 registry2.registerAll(program);
 var workflowCmd = program.command("workflow").description("Manage QE workflows and pipelines (ADR-041)");
 workflowCmd.command("run <file>").description("Execute a QE pipeline from YAML file").option("-w, --watch", "Watch execution progress").option("-v, --verbose", "Show detailed output").option("--params <json>", "Additional parameters as JSON", "{}").action(async (file, options) => {
   if (!await ensureInitialized()) return;
-  const fs31 = await import("fs");
+  const fs32 = await import("fs");
   const pathModule = await import("path");
   const filePath = pathModule.resolve(file);
   try {
@@ -163829,14 +164560,14 @@ workflowCmd.command("list").description("List workflows").option("-s, --schedule
   }
 });
 workflowCmd.command("validate <file>").description("Validate a pipeline YAML file").option("-v, --verbose", "Show detailed validation results").action(async (file, options) => {
-  const fs31 = await import("fs");
+  const fs32 = await import("fs");
   const pathModule = await import("path");
   const filePath = pathModule.resolve(file);
   try {
     console.log(chalk33.blue(`
 Validating pipeline: ${file}
 `));
-    if (!fs31.existsSync(filePath)) {
+    if (!fs32.existsSync(filePath)) {
       console.log(chalk33.red(`File not found: ${filePath}`));
       await cleanupAndExit(1);
     }
@@ -164029,16 +164760,16 @@ workflowCmd.command("browser-load [template]").description("Load and validate a
       params.workflowYaml = options.yaml;
     } else if (template) {
       if (template.endsWith(".yaml") || template.endsWith(".yml")) {
-        const fs31 = await import("fs");
+        const fs32 = await import("fs");
         const pathModule = await import("path");
         const filePath = pathModule.resolve(template);
-        if (!fs31.existsSync(filePath)) {
+        if (!fs32.existsSync(filePath)) {
           console.log(chalk33.red(`
 File not found: ${filePath}
 `));
           await cleanupAndExit(1);
         }
-        params.workflowYaml = fs31.readFileSync(filePath, "utf-8");
+        params.workflowYaml = fs32.readFileSync(filePath, "utf-8");
       } else {
         params.templateName = template;
       }
@@ -164121,6 +164852,7 @@ program.addCommand(createHooksCommand());
 program.addCommand(createLearningCommand());
 program.addCommand(createMcpCommand());
 program.addCommand(createPlatformCommand());
+program.addCommand(createProveCommand(context, cleanupAndExit, ensureInitialized));
 process.on("SIGINT", async () => {
   console.log(chalk33.yellow("\n\nShutting down..."));
   console.log(chalk33.green("Shutdown complete\n"));