agentic-qe 3.6.3 → 3.6.5

package/v3/dist/mcp/bundle.js

@@ -39,6 +39,110 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "node_modules/secure-json-parse/index.js"(exports, module) {
+    "use strict";
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse(text2, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text2)) {
+        text2 = text2.toString();
+      }
+      if (text2 && text2.charCodeAt(0) === 65279) {
+        text2 = text2.slice(1);
+      }
+      const obj = JSON.parse(text2, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text2) === false && suspectConstructorRx.test(text2) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text2) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text2) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse2(text2, reviver, options) {
+      const { stackTraceLimit } = Error;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text2, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse(text2, reviver) {
+      const { stackTraceLimit } = Error;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text2, reviver, { safe: true });
+      } catch {
+        return void 0;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module.exports = parse2;
+    module.exports.default = parse2;
+    module.exports.parse = parse2;
+    module.exports.safeParse = safeParse;
+    module.exports.scan = filter;
+  }
+});
+
 // node_modules/uuid/dist/esm-node/rng.js
 import crypto2 from "crypto";
 function rng() {
@@ -4501,7 +4605,7 @@ var init_constants = __esm({
        * Default vector embedding dimensions for HNSW index.
        * 384 dimensions matches common sentence transformers.
        */
-      DEFAULT_VECTOR_DIMENSIONS: 384,
+      DEFAULT_VECTOR_DIMENSIONS: 768,
       /**
        * Default search result limit for KV store queries.
        * Prevents unbounded result sets.
@@ -4674,6 +4778,64 @@ ${HYPERGRAPH_INDEXES_SCHEMA}
   }
 });
 
+// src/shared/sql-safety.ts
+function validateTableName(tableName) {
+  if (!ALLOWED_TABLE_NAMES.has(tableName)) {
+    throw new Error(`Invalid table name: "${tableName}" is not in the allowlist`);
+  }
+  return tableName;
+}
+var ALLOWED_TABLE_NAMES;
+var init_sql_safety = __esm({
+  "src/shared/sql-safety.ts"() {
+    "use strict";
+    ALLOWED_TABLE_NAMES = /* @__PURE__ */ new Set([
+      // Core kernel tables
+      "schema_version",
+      "kv_store",
+      "vectors",
+      "rl_q_values",
+      // GOAP tables
+      "goap_goals",
+      "goap_actions",
+      "goap_plans",
+      "goap_execution_steps",
+      "goap_plan_signatures",
+      // Concept/dream tables
+      "concept_nodes",
+      "concept_edges",
+      "dream_cycles",
+      "dream_insights",
+      // QE pattern tables
+      "qe_patterns",
+      "qe_pattern_embeddings",
+      "qe_pattern_usage",
+      "qe_trajectories",
+      // Execution tables
+      "embeddings",
+      "execution_results",
+      "executed_steps",
+      // MinCut tables
+      "mincut_snapshots",
+      "mincut_history",
+      "mincut_weak_vertices",
+      "mincut_alerts",
+      "mincut_healing_actions",
+      "mincut_observations",
+      // SONA tables
+      "sona_patterns",
+      // Sync tables
+      "patterns",
+      // Hypergraph tables
+      "hypergraph_vertices",
+      "hypergraph_hyperedges",
+      "hypergraph_edge_vertices",
+      "hypergraph_vertex_properties",
+      "hypergraph_edge_properties"
+    ]);
+  }
+});
+
 // src/memory/crdt/lww-register.ts
 function createLWWRegister(nodeId, initialValue, initialTimestamp) {
   let state2 = {
@@ -5584,6 +5746,19 @@ var init_crdt = __esm({
 });
 
 // src/kernel/unified-memory.ts
+var unified_memory_exports = {};
+__export(unified_memory_exports, {
+  ALLOWED_TABLE_NAMES: () => ALLOWED_TABLE_NAMES,
+  DEFAULT_UNIFIED_MEMORY_CONFIG: () => DEFAULT_UNIFIED_MEMORY_CONFIG,
+  UnifiedMemoryManager: () => UnifiedMemoryManager,
+  findProjectRoot: () => findProjectRoot,
+  getDefaultDbPath: () => getDefaultDbPath,
+  getResolvedDefaultConfig: () => getResolvedDefaultConfig,
+  getUnifiedMemory: () => getUnifiedMemory,
+  initializeUnifiedMemory: () => initializeUnifiedMemory,
+  resetUnifiedMemory: () => resetUnifiedMemory,
+  validateTableName: () => validateTableName
+});
 import Database from "better-sqlite3";
 import * as fs from "fs";
 import * as path from "path";
@@ -5633,6 +5808,11 @@ function getResolvedDefaultConfig() {
 function getUnifiedMemory(config) {
   return UnifiedMemoryManager.getInstance(config);
 }
+async function initializeUnifiedMemory(config) {
+  const manager = getUnifiedMemory(config);
+  await manager.initialize();
+  return manager;
+}
 function resetUnifiedMemory() {
   UnifiedMemoryManager.resetInstance();
 }
@@ -5659,13 +5839,15 @@ function registerExitHandlers() {
     process.exit(0);
   });
 }
-var DEFAULT_UNIFIED_MEMORY_CONFIG, SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, InMemoryHNSWIndex, UnifiedMemoryManager, exitHandlersRegistered;
+var DEFAULT_UNIFIED_MEMORY_CONFIG, SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, BinaryHeap, InMemoryHNSWIndex, UnifiedMemoryManager, exitHandlersRegistered;
 var init_unified_memory = __esm({
   "src/kernel/unified-memory.ts"() {
     "use strict";
     init_vector_math();
     init_add_hypergraph_tables();
     init_constants();
+    init_sql_safety();
+    init_sql_safety();
     init_crdt();
     DEFAULT_UNIFIED_MEMORY_CONFIG = {
       dbPath: ".agentic-qe/memory.db",
@@ -6149,6 +6331,64 @@ var init_unified_memory = __esm({
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_confidence ON sona_patterns(confidence DESC);
   CREATE INDEX IF NOT EXISTS idx_sona_patterns_updated ON sona_patterns(updated_at DESC);
 `;
+    BinaryHeap = class {
+      data = [];
+      compareFn;
+      constructor(compareFn) {
+        this.compareFn = compareFn;
+      }
+      push(item) {
+        this.data.push(item);
+        this.bubbleUp(this.data.length - 1);
+      }
+      pop() {
+        if (this.data.length === 0) return void 0;
+        const top = this.data[0];
+        const last = this.data.pop();
+        if (this.data.length > 0) {
+          this.data[0] = last;
+          this.sinkDown(0);
+        }
+        return top;
+      }
+      peek() {
+        return this.data[0];
+      }
+      size() {
+        return this.data.length;
+      }
+      bubbleUp(i58) {
+        while (i58 > 0) {
+          const parent = i58 - 1 >> 1;
+          if (this.compareFn(this.data[i58], this.data[parent]) < 0) {
+            [this.data[i58], this.data[parent]] = [this.data[parent], this.data[i58]];
+            i58 = parent;
+          } else {
+            break;
+          }
+        }
+      }
+      sinkDown(i58) {
+        const n61 = this.data.length;
+        while (true) {
+          let smallest = i58;
+          const left = 2 * i58 + 1;
+          const right = 2 * i58 + 2;
+          if (left < n61 && this.compareFn(this.data[left], this.data[smallest]) < 0) {
+            smallest = left;
+          }
+          if (right < n61 && this.compareFn(this.data[right], this.data[smallest]) < 0) {
+            smallest = right;
+          }
+          if (smallest !== i58) {
+            [this.data[i58], this.data[smallest]] = [this.data[smallest], this.data[i58]];
+            i58 = smallest;
+          } else {
+            break;
+          }
+        }
+      }
+    };
     InMemoryHNSWIndex = class {
       nodes = /* @__PURE__ */ new Map();
       M = HNSW_CONSTANTS.M_CONNECTIONS;
@@ -6206,17 +6446,28 @@ var init_unified_memory = __esm({
       /**
        * Beam search at a single layer: starting from an entry point, explore
        * up to `ef` candidates and return the `ef` closest found.
-       * Uses a candidate set (max-heap behavior via sorted array) and a result
-       * set. Returns results sorted by descending similarity.
+       * Uses a max-heap for candidates and a min-heap for results to achieve
+       * O(log n) insertion instead of O(n) Array.splice.
+       * Returns results sorted by descending similarity.
        */
       searchLayerBeam(query, entryIds, level, ef) {
         const visited = new Set(entryIds);
-        const candidates = entryIds.filter((id) => this.nodes.has(id)).map((id) => ({ id, score: this.similarity(query, id) }));
-        candidates.sort((a37, b68) => b68.score - a37.score);
-        const results = [...candidates];
-        while (candidates.length > 0) {
-          const closest = candidates.shift();
-          if (results.length >= ef && closest.score < results[results.length - 1].score) {
+        const initial = entryIds.filter((id) => this.nodes.has(id)).map((id) => ({ id, score: this.similarity(query, id) }));
+        const candidateHeap = new BinaryHeap(
+          (a37, b68) => b68.score - a37.score
+          // max-heap: highest score first
+        );
+        const resultHeap = new BinaryHeap(
+          (a37, b68) => a37.score - b68.score
+          // min-heap: lowest score first
+        );
+        for (const entry of initial) {
+          candidateHeap.push(entry);
+          resultHeap.push(entry);
+        }
+        while (candidateHeap.size() > 0) {
+          const closest = candidateHeap.pop();
+          if (resultHeap.size() >= ef && closest.score < resultHeap.peek().score) {
             break;
           }
           const node = this.nodes.get(closest.id);
@@ -6227,33 +6478,22 @@ var init_unified_memory = __esm({
             visited.add(neighborId);
             if (!this.nodes.has(neighborId)) continue;
             const score = this.similarity(query, neighborId);
-            const worstResult = results.length >= ef ? results[results.length - 1].score : -Infinity;
-            if (results.length < ef || score > worstResult) {
-              const candidateEntry = { id: neighborId, score };
-              let inserted = false;
-              for (let i58 = 0; i58 < candidates.length; i58++) {
-                if (score > candidates[i58].score) {
-                  candidates.splice(i58, 0, candidateEntry);
-                  inserted = true;
-                  break;
-                }
-              }
-              if (!inserted) candidates.push(candidateEntry);
-              inserted = false;
-              for (let i58 = 0; i58 < results.length; i58++) {
-                if (score > results[i58].score) {
-                  results.splice(i58, 0, candidateEntry);
-                  inserted = true;
-                  break;
-                }
-              }
-              if (!inserted) results.push(candidateEntry);
-              if (results.length > ef) {
-                results.pop();
+            const worstResult = resultHeap.size() >= ef ? resultHeap.peek().score : -Infinity;
+            if (resultHeap.size() < ef || score > worstResult) {
+              const entry = { id: neighborId, score };
+              candidateHeap.push(entry);
+              resultHeap.push(entry);
+              if (resultHeap.size() > ef) {
+                resultHeap.pop();
               }
             }
           }
         }
+        const results = [];
+        while (resultHeap.size() > 0) {
+          results.push(resultHeap.pop());
+        }
+        results.reverse();
         return results;
       }
       /**
@@ -6547,7 +6787,8 @@ var init_unified_memory = __esm({
       columnExists(tableName, columnName) {
         if (!this.db) return false;
         try {
-          const info = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+          const safeName = validateTableName(tableName);
+          const info = this.db.prepare(`PRAGMA table_info(${safeName})`).all();
           return info.some((col) => col.name === columnName);
         } catch {
           return false;
@@ -6585,7 +6826,7 @@ var init_unified_memory = __esm({
           ).get(table);
           if (tableExists && !this.columnExists(table, requiredColumn)) {
             console.log(`[UnifiedMemory] Upgrading v2 table: ${table} (missing ${requiredColumn})`);
-            this.db.exec(`DROP TABLE IF EXISTS ${table}`);
+            this.db.exec(`DROP TABLE IF EXISTS ${validateTableName(table)}`);
           }
         }
       }
@@ -6766,17 +7007,23 @@ var init_unified_memory = __esm({
         return result.changes > 0;
       }
       /**
-       * Search for similar vectors
+       * Search for similar vectors.
+       * Uses batch SQL query instead of N+1 individual queries for metadata enrichment.
        */
       async vectorSearch(query, k68 = 10, namespace) {
         this.ensureInitialized();
         const results = this.vectorIndex.search(query, k68 * 2);
+        if (results.length === 0) return [];
+        const ids = results.map((r54) => r54.id);
+        const placeholders = ids.map(() => "?").join(",");
+        const rows = this.db.prepare(
+          `SELECT id, namespace, metadata FROM vectors WHERE id IN (${placeholders})`
+        ).all(...ids);
+        const metadataMap = new Map(rows.map((row2) => [row2.id, row2]));
         if (namespace) {
           const filteredResults = [];
           for (const result of results) {
-            const row2 = this.db.prepare(
-              "SELECT namespace, metadata FROM vectors WHERE id = ?"
-            ).get(result.id);
+            const row2 = metadataMap.get(result.id);
             if (row2 && row2.namespace === namespace) {
               filteredResults.push({
                 id: result.id,
@@ -6789,9 +7036,7 @@ var init_unified_memory = __esm({
           return filteredResults;
         }
         return results.slice(0, k68).map((result) => {
-          const row2 = this.db.prepare(
-            "SELECT metadata FROM vectors WHERE id = ?"
-          ).get(result.id);
+          const row2 = metadataMap.get(result.id);
           return {
             id: result.id,
             score: result.score,
@@ -11727,15 +11972,19 @@ var init_concept_graph = __esm({
       // Pattern Import
       // ==========================================================================
       /**
-       * Load patterns into the concept graph as nodes
-       * @returns Number of patterns loaded
+       * Load patterns into the concept graph as nodes with edge discovery.
+       * Idempotent — skips patterns whose pattern_id already has a node.
+       * After loading, discovers co_occurrence and similarity edges.
+       * @returns Number of new patterns loaded
        */
       async loadFromPatterns(patterns) {
         this.ensureInitialized();
         let loaded = 0;
         for (const pattern of patterns) {
           try {
-            await this.addNode({
+            const existing = await this.findNodeByPatternId(pattern.id);
+            if (existing) continue;
+            const patternNodeId = await this.addNode({
               conceptType: "pattern",
               content: `${pattern.name}: ${pattern.description}`,
               patternId: pattern.id,
@@ -11747,13 +11996,17 @@ var init_concept_graph = __esm({
               }
             });
             loaded++;
-            const domainNode = await this.findDomainNode(pattern.domain);
+            let domainNode = await this.findDomainNode(pattern.domain);
             if (!domainNode) {
-              await this.addNode({
+              const domainNodeId = await this.addNode({
                 conceptType: "domain",
                 content: pattern.domain,
                 metadata: { patternCount: 1 }
               });
+              domainNode = await this.getNode(domainNodeId);
+            }
+            if (domainNode) {
+              await this.addEdge(patternNodeId, domainNode.id, "co_occurrence", 0.8);
             }
           } catch (error) {
             if (this.config.debug) {
@@ -11761,11 +12014,51 @@ var init_concept_graph = __esm({
             }
           }
         }
-        if (this.config.debug) {
-          console.log(`[ConceptGraph] Loaded ${loaded} patterns`);
+        if (loaded > 0) {
+          const edgesCreated = await this.discoverSameDomainEdges();
+          if (this.config.debug) {
+            console.log(`[ConceptGraph] Discovered ${edgesCreated} same-domain edges`);
+          }
         }
+        console.log(`[ConceptGraph] Loaded ${loaded} new patterns (${patterns.length - loaded} already existed)`);
         return loaded;
       }
+      /**
+       * Discover similarity edges between pattern nodes in the same domain.
+       * Uses metadata.domain to group patterns, then creates bidirectional
+       * similarity edges between siblings. Idempotent (addEdge strengthens
+       * existing edges rather than duplicating).
+       * @returns Number of new edges created
+       */
+      async discoverSameDomainEdges() {
+        this.ensureInitialized();
+        if (!this.db) return 0;
+        const patternNodes = this.db.prepare(
+          "SELECT * FROM concept_nodes WHERE concept_type = 'pattern'"
+        ).all();
+        const domainGroups = /* @__PURE__ */ new Map();
+        for (const node of patternNodes) {
+          const metadata = node.metadata ? JSON.parse(node.metadata) : {};
+          const domain = metadata.domain || "unknown";
+          if (!domainGroups.has(domain)) {
+            domainGroups.set(domain, []);
+          }
+          domainGroups.get(domain).push(node);
+        }
+        let edgesCreated = 0;
+        for (const [, nodes] of domainGroups) {
+          for (let i58 = 0; i58 < nodes.length; i58++) {
+            for (let j52 = i58 + 1; j52 < nodes.length; j52++) {
+              const existingEdge = await this.getEdgeBetween(nodes[i58].id, nodes[j52].id);
+              if (!existingEdge) {
+                await this.addEdge(nodes[i58].id, nodes[j52].id, "similarity", 0.6);
+                edgesCreated++;
+              }
+            }
+          }
+        }
+        return edgesCreated;
+      }
       // ==========================================================================
       // Statistics
       // ==========================================================================
@@ -11845,6 +12138,15 @@ var init_concept_graph = __esm({
         if (!row2) return null;
         return this.rowToNode(row2);
       }
+      async findNodeByPatternId(patternId) {
+        if (!this.db) return null;
+        const stmt = this.db.prepare(
+          "SELECT * FROM concept_nodes WHERE pattern_id = ? LIMIT 1"
+        );
+        const row2 = stmt.get(patternId);
+        if (!row2) return null;
+        return this.rowToNode(row2);
+      }
       rowToNode(row2) {
         let embedding;
         if (row2.embedding) {
@@ -11885,6 +12187,46 @@ var init_concept_graph = __esm({
 });
 
 // src/learning/dream/spreading-activation.ts
+function quickselect(arr, k68) {
+  if (k68 < 0 || k68 >= arr.length) return arr[0] ?? 0;
+  let left = 0;
+  let right = arr.length - 1;
+  while (left < right) {
+    const mid = left + right >> 1;
+    if (arr[mid] < arr[left]) {
+      const t51 = arr[left];
+      arr[left] = arr[mid];
+      arr[mid] = t51;
+    }
+    if (arr[right] < arr[left]) {
+      const t51 = arr[left];
+      arr[left] = arr[right];
+      arr[right] = t51;
+    }
+    if (arr[mid] < arr[right]) {
+      const t51 = arr[mid];
+      arr[mid] = arr[right];
+      arr[right] = t51;
+    }
+    const pivot = arr[right];
+    let i58 = left;
+    for (let j52 = left; j52 < right; j52++) {
+      if (arr[j52] <= pivot) {
+        const t51 = arr[i58];
+        arr[i58] = arr[j52];
+        arr[j52] = t51;
+        i58++;
+      }
+    }
+    const t50 = arr[i58];
+    arr[i58] = arr[right];
+    arr[right] = t50;
+    if (i58 === k68) return arr[i58];
+    if (i58 < k68) left = i58 + 1;
+    else right = i58 - 1;
+  }
+  return arr[left];
+}
 var MAX_ACTIVATION_HISTORY_ENTRIES, MAX_COACTIVATION_ENTRIES, HISTORY_TRIM_TARGET_RATIO, DEFAULT_ACTIVATION_CONFIG, SpreadingActivation;
 var init_spreading_activation = __esm({
   "src/learning/dream/spreading-activation.ts"() {
@@ -12070,10 +12412,14 @@ var init_spreading_activation = __esm({
        */
       async findNovelAssociations(minActivation) {
         const threshold = minActivation ?? this.config.threshold;
-        const activeNodes = this.graph.getActiveNodes(threshold);
+        let activeNodes = this.graph.getActiveNodes(threshold);
         if (activeNodes.length < 2) {
           return [];
         }
+        const MAX_ACTIVE_NODES = 200;
+        if (activeNodes.length > MAX_ACTIVE_NODES) {
+          activeNodes = activeNodes.sort((a37, b68) => b68.activationLevel - a37.activationLevel).slice(0, MAX_ACTIVE_NODES);
+        }
         const associations = [];
         for (let i58 = 0; i58 < activeNodes.length; i58++) {
           for (let j52 = i58 + 1; j52 < activeNodes.length; j52++) {
@@ -12155,9 +12501,17 @@ var init_spreading_activation = __esm({
         }
         const targetSize = Math.floor(MAX_COACTIVATION_ENTRIES * HISTORY_TRIM_TARGET_RATIO);
         const entriesToRemove = this.coActivationCounts.size - targetSize;
-        const sortedEntries = Array.from(this.coActivationCounts.entries()).sort((a37, b68) => a37[1] - b68[1]);
-        for (let i58 = 0; i58 < entriesToRemove && i58 < sortedEntries.length; i58++) {
-          this.coActivationCounts.delete(sortedEntries[i58][0]);
+        const values = Array.from(this.coActivationCounts.values());
+        const threshold = quickselect(values, entriesToRemove - 1);
+        const toDelete = [];
+        for (const [key, count] of this.coActivationCounts) {
+          if (toDelete.length >= entriesToRemove) break;
+          if (count <= threshold) {
+            toDelete.push(key);
+          }
+        }
+        for (const key of toDelete) {
+          this.coActivationCounts.delete(key);
         }
       }
       /**
@@ -13018,6 +13372,7 @@ var init_dream_engine = __esm({
             await this.persistence.initialize();
           }
           this.db = this.persistence.getDatabase();
+          this.migrateSchema();
           this.graph = new ConceptGraph();
           await this.graph.initialize();
           this.initialized = true;
@@ -13028,6 +13383,49 @@ var init_dream_engine = __esm({
           );
         }
       }
+      /**
+       * Migrate legacy schema if needed.
+       * Handles the 'duration' → 'duration_ms' column rename in dream_cycles.
+       */
+      migrateSchema() {
+        if (!this.db) return;
+        try {
+          const cycleCols = this.db.prepare("PRAGMA table_info(dream_cycles)").all();
+          const hasDurationMs = cycleCols.some((c70) => c70.name === "duration_ms");
+          const hasDuration = cycleCols.some((c70) => c70.name === "duration");
+          if (!hasDurationMs && hasDuration) {
+            this.db.exec("ALTER TABLE dream_cycles RENAME COLUMN duration TO duration_ms");
+          }
+          const insightCols = this.db.prepare("PRAGMA table_info(dream_insights)").all();
+          const colNames = new Set(insightCols.map((c70) => c70.name));
+          const hasInsightType = colNames.has("insight_type");
+          const hasSourceConcepts = colNames.has("source_concepts");
+          if (!hasInsightType || !hasSourceConcepts) {
+            this.db.exec("DROP TABLE IF EXISTS dream_insights");
+            this.db.exec(`
+          CREATE TABLE IF NOT EXISTS dream_insights (
+            id TEXT PRIMARY KEY,
+            cycle_id TEXT NOT NULL,
+            insight_type TEXT NOT NULL,
+            source_concepts TEXT NOT NULL,
+            description TEXT NOT NULL,
+            novelty_score REAL DEFAULT 0.5,
+            confidence_score REAL DEFAULT 0.5,
+            actionable INTEGER DEFAULT 0,
+            applied INTEGER DEFAULT 0,
+            suggested_action TEXT,
+            pattern_id TEXT,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (cycle_id) REFERENCES dream_cycles(id) ON DELETE CASCADE
+          )
+        `);
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_insight_cycle ON dream_insights(cycle_id)");
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_insight_type ON dream_insights(insight_type)");
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_insight_novelty ON dream_insights(novelty_score DESC)");
+          }
+        } catch {
+        }
+      }
       // ==========================================================================
       // Main Dream Cycle
       // ==========================================================================
@@ -13240,8 +13638,8 @@ var init_dream_engine = __esm({
         const stmt = this.db.prepare(`
       INSERT INTO dream_cycles
       (id, start_time, end_time, duration_ms, concepts_processed, associations_found,
-       insights_generated, status, error)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       insights_generated, status, error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         stmt.run(
           cycle.id,
@@ -13252,7 +13650,8 @@ var init_dream_engine = __esm({
           cycle.associationsFound,
           cycle.insightsGenerated,
           cycle.status,
-          cycle.error ?? null
+          cycle.error ?? null,
+          cycle.startTime.toISOString()
         );
       }
       async updateCycle(cycle) {
@@ -15444,11 +15843,11 @@ var init_adapter = __esm({
             startTime
           );
         }
-        const cachedResult = this.cache.get(code, type);
-        if (cachedResult) {
+        const cachedResult2 = this.cache.get(code, type);
+        if (cachedResult2) {
           this.cacheHits++;
           this.logger.debug("Cache hit for transform", { type });
-          return { ...cachedResult, durationMs: Date.now() - startTime };
+          return { ...cachedResult2, durationMs: Date.now() - startTime };
         }
         this.cacheMisses++;
         let result;
@@ -18348,13 +18747,16 @@ var init_pattern_store = __esm({
             (_56, reject) => setTimeout(() => reject(new Error("Pattern load timeout")), timeoutMs)
           );
           const keys = await Promise.race([searchPromise, timeoutPromise]);
-          for (const key of keys) {
-            try {
-              const pattern = await this.memory.get(key);
+          const BATCH_SIZE = 50;
+          for (let i58 = 0; i58 < keys.length; i58 += BATCH_SIZE) {
+            const batch = keys.slice(i58, i58 + BATCH_SIZE);
+            const patterns = await Promise.all(
+              batch.map((key) => this.memory.get(key).catch(() => null))
+            );
+            for (const pattern of patterns) {
               if (pattern) {
                 this.indexPattern(pattern);
               }
-            } catch {
             }
           }
           console.log(`[PatternStore] Loaded ${this.patternCache.size} patterns`);
@@ -18441,11 +18843,12 @@ var init_pattern_store = __esm({
        */
       async create(options) {
         const now = /* @__PURE__ */ new Date();
+        const resolvedDomain = options.qeDomain || this.detectDomainFromType(options.patternType);
         const pattern = {
           id: v4_default(),
           patternType: options.patternType,
-          qeDomain: this.detectDomainFromType(options.patternType),
-          domain: mapQEDomainToAQE(this.detectDomainFromType(options.patternType)),
+          qeDomain: resolvedDomain,
+          domain: mapQEDomainToAQE(resolvedDomain),
           name: options.name,
           description: options.description,
           confidence: options.confidence ?? 0.5,
@@ -19025,6 +19428,11 @@ var init_qe_reasoning_bank = __esm({
         await this.patternStore.initialize();
         await this.loadPretrainedPatterns();
         this.initialized = true;
+        try {
+          await this.seedCrossDomainPatterns();
+        } catch (error) {
+          console.warn("[QEReasoningBank] Cross-domain seeding failed (non-fatal):", error);
+        }
         console.log("[QEReasoningBank] Initialized");
       }
       /**
@@ -19149,6 +19557,602 @@ Check for:
             context: {
               tags: ["flaky", "timing", "async", "stability"]
             }
+          },
+          // ================================================================
+          // quality-assessment domain seeds
+          // ================================================================
+          {
+            patternType: "assertion-pattern",
+            qeDomain: "quality-assessment",
+            name: "Quality Gate Checklist",
+            description: "Evaluate deployment readiness against quality gate criteria",
+            template: {
+              type: "prompt",
+              content: `Quality gate evaluation for {{targetModule}}:
+
+1. Test coverage >= {{coverageThreshold}}%
+2. No critical/high severity bugs open
+3. All P1 tests passing
+4. Performance benchmarks within SLA (p95 < {{latencyThresholdMs}}ms)
+5. Security scan clean (no critical CVEs)
+6. Code review approved
+
+Fail the gate if ANY criterion is unmet. Report which criteria passed/failed.`,
+              variables: [
+                { name: "targetModule", type: "string", required: true, description: "Module or service to evaluate" },
+                { name: "coverageThreshold", type: "number", required: false, defaultValue: 80, description: "Minimum coverage %" },
+                { name: "latencyThresholdMs", type: "number", required: false, defaultValue: 500, description: "P95 latency limit in ms" }
+              ]
+            },
+            context: {
+              tags: ["quality-gate", "deployment", "readiness", "sla"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "assertion-pattern",
+            qeDomain: "quality-assessment",
+            name: "Metric Threshold Validator",
+            description: "Validate quality metrics against configurable thresholds",
+            template: {
+              type: "code",
+              content: `function validateMetrics(metrics: Record<string, number>, thresholds: Record<string, { min?: number; max?: number }>) {
+  const violations: string[] = [];
+  for (const [metric, value] of Object.entries(metrics)) {
+    const threshold = thresholds[metric];
+    if (!threshold) continue;
+    if (threshold.min !== undefined && value < threshold.min) {
+      violations.push(\`\${metric}: \${value} < min \${threshold.min}\`);
+    }
+    if (threshold.max !== undefined && value > threshold.max) {
+      violations.push(\`\${metric}: \${value} > max \${threshold.max}\`);
+    }
+  }
+  return { pass: violations.length === 0, violations };
+}`,
+              variables: []
+            },
+            context: {
+              tags: ["metrics", "threshold", "validation", "scoring"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // defect-intelligence domain seeds
+          // ================================================================
+          {
+            patternType: "error-handling",
+            qeDomain: "defect-intelligence",
+            name: "Root Cause Analysis Workflow",
+            description: "Systematic root cause analysis for test failures and production incidents",
+            template: {
+              type: "prompt",
+              content: `Root cause analysis for: {{incidentDescription}}
+
+1. **Reproduce**: Confirm the failure is deterministic
+2. **Isolate**: Narrow down to the smallest failing component
+3. **Timeline**: When did it last pass? What changed since?
+4. **Categorize**: Is it a code bug, config issue, data issue, or environment?
+5. **Five Whys**: Ask why at least 5 times to reach the root cause
+6. **Fix**: Propose fix with test to prevent regression
+7. **Verify**: Run the fix and confirm the original failure is resolved`,
+              variables: [
+                { name: "incidentDescription", type: "string", required: true, description: "Description of the failure or incident" }
+              ]
+            },
+            context: {
+              tags: ["root-cause", "rca", "debugging", "incident"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "error-handling",
+            qeDomain: "defect-intelligence",
+            name: "Regression Risk Scorer",
+            description: "Score change risk for regression based on code complexity and history",
+            template: {
+              type: "prompt",
+              content: `Regression risk assessment for {{changePath}}:
+
+Risk factors (score each 0-3):
+- Lines changed: {{linesChanged}} \u2192 complexity risk
+- Files affected: {{filesAffected}} \u2192 blast radius
+- Previous bugs in area: historical defect density
+- Test coverage of changed code: gap risk
+- Dependency depth: cascade risk
+
+Total risk = sum / 15 \u2192 Low (<0.3), Medium (0.3-0.6), High (>0.6)`,
+              variables: [
+                { name: "changePath", type: "string", required: true, description: "File or module changed" },
+                { name: "linesChanged", type: "number", required: true, description: "Number of lines changed" },
+                { name: "filesAffected", type: "number", required: true, description: "Number of files affected" }
+              ]
+            },
+            context: {
+              tags: ["regression", "risk", "prediction", "change-analysis"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // requirements-validation domain seeds
+          // ================================================================
+          {
+            patternType: "test-template",
+            qeDomain: "requirements-validation",
+            name: "Gherkin BDD Scenario",
+            description: "Behavior-driven development scenario in Given/When/Then format",
+            template: {
+              type: "code",
+              content: `Feature: {{featureName}}
+
+  Scenario: {{scenarioDescription}}
+    Given {{precondition}}
+    When {{action}}
+    Then {{expectedOutcome}}
+
+  Scenario: {{scenarioDescription}} - error case
+    Given {{precondition}}
+    When {{errorAction}}
+    Then {{errorOutcome}}`,
+              variables: [
+                { name: "featureName", type: "string", required: true, description: "Feature under test" },
+                { name: "scenarioDescription", type: "string", required: true, description: "What the scenario validates" },
+                { name: "precondition", type: "string", required: true, description: "Given precondition" },
+                { name: "action", type: "string", required: true, description: "When action" },
+                { name: "expectedOutcome", type: "string", required: true, description: "Then expected result" },
+                { name: "errorAction", type: "string", required: true, description: "When error action" },
+                { name: "errorOutcome", type: "string", required: true, description: "Then error result" }
+              ]
+            },
+            context: {
+              tags: ["bdd", "gherkin", "requirements", "acceptance"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "test-template",
+            qeDomain: "requirements-validation",
+            name: "Acceptance Criteria Testability Check",
+            description: "Evaluate whether acceptance criteria are testable and complete",
+            template: {
+              type: "prompt",
+              content: `Testability assessment for: {{requirementId}} - {{requirementTitle}}
+
+Acceptance criteria:
+{{acceptanceCriteria}}
+
+Evaluate each criterion:
+1. **Observable**: Can we verify the outcome without internal knowledge?
+2. **Measurable**: Is there a quantifiable threshold or clear pass/fail?
+3. **Atomic**: Does each criterion test exactly one thing?
+4. **Achievable**: Can this be tested with available tools?
+5. **Complete**: Are edge cases and error paths covered?
+
+Flag any untestable or ambiguous criteria with suggested rewrites.`,
+              variables: [
+                { name: "requirementId", type: "string", required: true, description: "Requirement identifier" },
+                { name: "requirementTitle", type: "string", required: true, description: "Requirement title" },
+                { name: "acceptanceCriteria", type: "string", required: true, description: "The acceptance criteria text" }
+              ]
+            },
+            context: {
+              tags: ["requirements", "testability", "acceptance-criteria", "validation"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // code-intelligence domain seeds
+          // ================================================================
+          {
+            patternType: "refactor-safe",
+            name: "Safe Refactoring Checklist",
+            description: "Ensure refactoring preserves behavior with systematic safety checks",
+            template: {
+              type: "prompt",
+              content: `Safe refactoring checklist for {{targetPath}}:
+
+Before refactoring:
+1. Run existing tests \u2014 capture baseline results
+2. Check coverage of code being refactored
+3. Identify all callers and dependents via references
+
+During refactoring:
+4. Make one semantic change at a time
+5. Keep public API signatures stable (or update all callers)
+6. Preserve error handling contracts
+
+After refactoring:
+7. Run full test suite \u2014 compare to baseline
+8. Check for any new uncovered paths
+9. Verify no unused imports or dead code introduced`,
+              variables: [
+                { name: "targetPath", type: "string", required: true, description: "Path to refactor" }
+              ]
+            },
+            context: {
+              tags: ["refactor", "safety", "code-change", "impact"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "refactor-safe",
+            name: "Dependency Impact Analysis",
+            description: "Analyze the blast radius of a code change through the dependency graph",
+            template: {
+              type: "prompt",
+              content: `Impact analysis for changes in {{changedFile}}:
+
+1. Direct dependents: files that import/require {{changedFile}}
+2. Transitive dependents: files that depend on direct dependents
+3. Test coverage: which tests exercise the changed code?
+4. Integration points: does this affect API contracts or events?
+5. Risk tier: Critical (auth/payments) > High (business logic) > Medium (utils)
+
+Output: sorted list of affected files with risk scores.`,
+              variables: [
+                { name: "changedFile", type: "string", required: true, description: "File being changed" }
+              ]
+            },
+            context: {
+              tags: ["impact", "dependency", "blast-radius", "analysis"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // security-compliance domain seeds
+          // ================================================================
+          {
+            patternType: "assertion-pattern",
+            qeDomain: "security-compliance",
+            name: "OWASP Top 10 Security Audit",
+            description: "Check code against OWASP Top 10 vulnerability categories",
+            template: {
+              type: "prompt",
+              content: `Security audit for {{targetPath}} against OWASP Top 10:
+
+1. **A01 Broken Access Control**: Check authorization on every endpoint
+2. **A02 Cryptographic Failures**: No plaintext secrets, proper hashing
+3. **A03 Injection**: Parameterized queries, input sanitization
+4. **A04 Insecure Design**: Threat modeling, least privilege
+5. **A05 Security Misconfiguration**: Default creds, verbose errors
+6. **A06 Vulnerable Components**: Check dependencies for CVEs
+7. **A07 Auth Failures**: Brute force protection, session management
+8. **A08 Data Integrity Failures**: Verify signatures, safe deserialization
+9. **A09 Logging Failures**: Audit trail, no sensitive data in logs
+10. **A10 SSRF**: Validate/allowlist outbound URLs
+
+Flag findings as Critical/High/Medium/Low with remediation guidance.`,
+              variables: [
+                { name: "targetPath", type: "string", required: true, description: "Code path to audit" }
+              ]
+            },
+            context: {
+              tags: ["owasp", "security", "audit", "vulnerability"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "assertion-pattern",
+            qeDomain: "security-compliance",
+            name: "Input Sanitization Pattern",
+            description: "Validate and sanitize inputs at system boundaries to prevent injection",
+            template: {
+              type: "code",
+              content: `// Input validation at system boundary
+function validateInput(input: unknown, schema: {
+  type: 'string' | 'number' | 'boolean';
+  maxLength?: number;
+  pattern?: RegExp;
+  allowedValues?: unknown[];
+}): { valid: boolean; sanitized: unknown; errors: string[] } {
+  const errors: string[] = [];
+  if (typeof input !== schema.type) {
+    errors.push(\`Expected \${schema.type}, got \${typeof input}\`);
+    return { valid: false, sanitized: null, errors };
+  }
+  if (schema.type === 'string') {
+    let str = input as string;
+    if (schema.maxLength && str.length > schema.maxLength) {
+      str = str.slice(0, schema.maxLength);
+      errors.push('Input truncated to max length');
+    }
+    if (schema.pattern && !schema.pattern.test(str)) {
+      errors.push('Input does not match expected pattern');
+      return { valid: false, sanitized: null, errors };
+    }
+    return { valid: errors.length === 0, sanitized: str, errors };
+  }
+  return { valid: true, sanitized: input, errors };
+}`,
+              variables: []
+            },
+            context: {
+              tags: ["security", "validation", "sanitization", "injection-prevention"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // contract-testing domain seeds
+          // ================================================================
+          {
+            patternType: "api-contract",
+            name: "OpenAPI Contract Validator",
+            description: "Validate API responses against OpenAPI/Swagger schema",
+            template: {
+              type: "code",
+              content: `describe('{{apiEndpoint}} contract', () => {
+  it('should match the OpenAPI schema for {{operationId}}', async () => {
+    const response = await request(app).{{httpMethod}}('{{apiEndpoint}}');
+    expect(response.status).toBe({{expectedStatus}});
+    expect(response.body).toMatchSchema(openApiSpec.paths['{{apiEndpoint}}'].{{httpMethod}}.responses['{{expectedStatus}}'].content['application/json'].schema);
+  });
+
+  it('should return proper error for invalid input', async () => {
+    const response = await request(app).{{httpMethod}}('{{apiEndpoint}}').send({{invalidPayload}});
+    expect(response.status).toBe(400);
+    expect(response.body).toHaveProperty('errors');
+  });
+});`,
+              variables: [
+                { name: "apiEndpoint", type: "string", required: true, description: "API endpoint path" },
+                { name: "operationId", type: "string", required: true, description: "OpenAPI operation ID" },
+                { name: "httpMethod", type: "string", required: true, description: "HTTP method (get/post/put/delete)" },
+                { name: "expectedStatus", type: "number", required: true, description: "Expected HTTP status code" },
+                { name: "invalidPayload", type: "object", required: true, description: "Invalid request body for error case" }
+              ]
+            },
+            context: {
+              tags: ["api", "contract", "openapi", "schema-validation"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "api-contract",
+            name: "Consumer-Driven Contract Test",
+            description: "Pact-style consumer-driven contract testing between services",
+            template: {
+              type: "code",
+              content: `// Consumer side contract
+const pact = new Pact({
+  consumer: '{{consumerName}}',
+  provider: '{{providerName}}',
+});
+
+describe('{{consumerName}} -> {{providerName}} contract', () => {
+  beforeAll(() => pact.setup());
+  afterAll(() => pact.finalize());
+
+  it('should receive {{expectedResource}}', async () => {
+    await pact.addInteraction({
+      state: '{{providerState}}',
+      uponReceiving: '{{interactionDescription}}',
+      withRequest: { method: '{{httpMethod}}', path: '{{requestPath}}' },
+      willRespondWith: {
+        status: 200,
+        body: like({{expectedShape}}),
+      },
+    });
+
+    const result = await client.{{clientMethod}}();
+    expect(result).toBeDefined();
+  });
+});`,
+              variables: [
+                { name: "consumerName", type: "string", required: true, description: "Consumer service name" },
+                { name: "providerName", type: "string", required: true, description: "Provider service name" },
+                { name: "expectedResource", type: "string", required: true, description: "Resource being consumed" },
+                { name: "providerState", type: "string", required: true, description: "Provider state precondition" },
+                { name: "interactionDescription", type: "string", required: true, description: "Interaction description" },
+                { name: "httpMethod", type: "string", required: true, description: "HTTP method" },
+                { name: "requestPath", type: "string", required: true, description: "Request path" },
+                { name: "expectedShape", type: "object", required: true, description: "Expected response shape" },
+                { name: "clientMethod", type: "string", required: true, description: "Client method to call" }
+              ]
+            },
+            context: {
+              tags: ["contract", "pact", "consumer-driven", "microservice"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // visual-accessibility domain seeds
+          // ================================================================
+          {
+            patternType: "a11y-check",
+            name: "WCAG Contrast and ARIA Check",
+            description: "Validate WCAG 2.2 color contrast ratios and ARIA attribute correctness",
+            template: {
+              type: "prompt",
+              content: `Accessibility audit for {{componentName}}:
+
+WCAG 2.2 AA Compliance:
+1. **Color Contrast**: Text contrast ratio >= 4.5:1 (normal), >= 3:1 (large)
+2. **ARIA Roles**: All interactive elements have correct role attributes
+3. **ARIA Labels**: Forms and buttons have aria-label or aria-labelledby
+4. **Focus Management**: Tab order is logical, focus visible on all interactive elements
+5. **Screen Reader**: Content is meaningful when linearized
+6. **Keyboard**: All functionality accessible via keyboard alone
+
+Test with: axe-core, pa11y, or lighthouse --accessibility`,
+              variables: [
+                { name: "componentName", type: "string", required: true, description: "UI component to audit" }
+              ]
+            },
+            context: {
+              tags: ["wcag", "accessibility", "aria", "contrast", "a11y"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "visual-baseline",
+            name: "Visual Regression Baseline",
+            description: "Capture and compare screenshots for visual regression detection",
+            template: {
+              type: "code",
+              content: `describe('{{pageName}} visual regression', () => {
+  it('should match baseline screenshot', async () => {
+    await page.goto('{{pageUrl}}');
+    await page.waitForLoadState('networkidle');
+
+    const screenshot = await page.screenshot({ fullPage: {{fullPage}} });
+    expect(screenshot).toMatchSnapshot('{{pageName}}-baseline.png', {
+      maxDiffPixelRatio: {{maxDiffRatio}},
+    });
+  });
+
+  it('should match baseline at mobile viewport', async () => {
+    await page.setViewportSize({ width: 375, height: 812 });
+    await page.goto('{{pageUrl}}');
+    const screenshot = await page.screenshot({ fullPage: {{fullPage}} });
+    expect(screenshot).toMatchSnapshot('{{pageName}}-mobile-baseline.png', {
+      maxDiffPixelRatio: {{maxDiffRatio}},
+    });
+  });
+});`,
+              variables: [
+                { name: "pageName", type: "string", required: true, description: "Page name for snapshot naming" },
+                { name: "pageUrl", type: "string", required: true, description: "Page URL to capture" },
+                { name: "fullPage", type: "boolean", required: false, defaultValue: true, description: "Capture full page" },
+                { name: "maxDiffRatio", type: "number", required: false, defaultValue: 0.01, description: "Max pixel diff ratio" }
+              ]
+            },
+            context: {
+              tags: ["visual", "screenshot", "regression", "baseline", "playwright"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // chaos-resilience domain seeds
+          // ================================================================
+          {
+            patternType: "perf-benchmark",
+            name: "Load Test Scenario",
+            description: "k6-style load test with ramp-up stages and SLA assertions",
+            template: {
+              type: "code",
+              content: `import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+export const options = {
+  stages: [
+    { duration: '{{rampUpDuration}}', target: {{peakUsers}} },
+    { duration: '{{steadyDuration}}', target: {{peakUsers}} },
+    { duration: '{{rampDownDuration}}', target: 0 },
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<{{p95ThresholdMs}}'],
+    http_req_failed: ['rate<{{errorRateThreshold}}'],
+  },
+};
+
+export default function () {
+  const res = http.get('{{targetUrl}}');
+  check(res, {
+    'status is 200': (r) => r.status === 200,
+    'response time < {{p95ThresholdMs}}ms': (r) => r.timings.duration < {{p95ThresholdMs}},
+  });
+  sleep(1);
+}`,
+              variables: [
+                { name: "targetUrl", type: "string", required: true, description: "Target URL to load test" },
+                { name: "peakUsers", type: "number", required: true, description: "Peak concurrent users" },
+                { name: "rampUpDuration", type: "string", required: false, defaultValue: "2m", description: "Ramp-up duration" },
+                { name: "steadyDuration", type: "string", required: false, defaultValue: "5m", description: "Steady state duration" },
+                { name: "rampDownDuration", type: "string", required: false, defaultValue: "1m", description: "Ramp-down duration" },
+                { name: "p95ThresholdMs", type: "number", required: false, defaultValue: 500, description: "P95 latency threshold in ms" },
+                { name: "errorRateThreshold", type: "number", required: false, defaultValue: 0.01, description: "Max error rate (0-1)" }
+              ]
+            },
+            context: {
+              tags: ["load-test", "k6", "performance", "sla"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "perf-benchmark",
+            name: "Circuit Breaker Resilience Test",
+            description: "Test circuit breaker behavior under fault injection",
+            template: {
+              type: "prompt",
+              content: `Resilience test for {{serviceName}} circuit breaker:
+
+1. **Closed state**: Verify normal requests pass through
+2. **Fault injection**: Inject {{faultType}} faults at {{faultRate}}% rate
+3. **Trip threshold**: Verify breaker opens after {{failureThreshold}} consecutive failures
+4. **Open state**: Verify requests fail fast (no upstream calls)
+5. **Half-open probe**: After {{cooldownMs}}ms, verify single probe request
+6. **Recovery**: On probe success, verify breaker closes and traffic resumes
+7. **Metrics**: Verify circuit state changes are logged and observable`,
+              variables: [
+                { name: "serviceName", type: "string", required: true, description: "Service with circuit breaker" },
+                { name: "faultType", type: "string", required: false, defaultValue: "latency", description: "Type of fault (latency/error/timeout)" },
+                { name: "faultRate", type: "number", required: false, defaultValue: 50, description: "Fault injection rate %" },
+                { name: "failureThreshold", type: "number", required: false, defaultValue: 5, description: "Failures to trip breaker" },
+                { name: "cooldownMs", type: "number", required: false, defaultValue: 3e4, description: "Cooldown before half-open" }
+              ]
+            },
+            context: {
+              tags: ["chaos", "circuit-breaker", "resilience", "fault-injection"]
+            },
+            confidence: 0.6
+          },
+          // ================================================================
+          // learning-optimization domain seeds
+          // ================================================================
+          {
+            patternType: "coverage-strategy",
+            qeDomain: "learning-optimization",
+            name: "Cross-Domain Pattern Transfer",
+            description: "Strategy for transferring useful patterns from one QE domain to related domains",
+            template: {
+              type: "prompt",
+              content: `Pattern transfer from {{sourceDomain}} to {{targetDomain}}:
+
+1. Identify generalizable patterns in source domain (success rate > 70%)
+2. Check domain compatibility (related domains get 80% relevance, unrelated 50%)
+3. Adapt pattern context: replace domain-specific terms with target equivalents
+4. Set transferred pattern confidence to source * compatibility factor
+5. Store in target domain with provenance metadata
+6. Track transfer outcomes to learn which transfers are valuable`,
+              variables: [
+                { name: "sourceDomain", type: "string", required: true, description: "Source QE domain" },
+                { name: "targetDomain", type: "string", required: true, description: "Target QE domain" }
+              ]
+            },
+            context: {
+              tags: ["transfer", "cross-domain", "learning", "pattern-reuse"]
+            },
+            confidence: 0.6
+          },
+          {
+            patternType: "coverage-strategy",
+            qeDomain: "learning-optimization",
+            name: "Pattern Quality Promotion Pipeline",
+            description: "Pipeline for promoting short-term patterns to long-term based on success evidence",
+            template: {
+              type: "prompt",
+              content: `Pattern promotion evaluation for {{patternName}}:
+
+Criteria (all must pass):
+1. Usage count >= 3 successful applications
+2. Success rate >= 70%
+3. Confidence score >= 0.6
+4. Coherence check: no contradiction with existing long-term patterns
+5. Age: pattern has existed for at least 24 hours (not rushed)
+
+On promotion:
+- Move from short-term to long-term tier
+- Boost confidence by 10%
+- Enable for cross-domain transfer to related domains
+- Mark as reusable for token savings optimization`,
+              variables: [
+                { name: "patternName", type: "string", required: true, description: "Pattern to evaluate for promotion" }
+              ]
+            },
+            context: {
+              tags: ["promotion", "learning", "quality", "pipeline"]
+            },
+            confidence: 0.6
           }
         ];
         for (const options of foundationalPatterns) {
@@ -19160,6 +20164,92 @@ Check for:
         }
         console.log(`[QEReasoningBank] Loaded ${foundationalPatterns.length} foundational patterns`);
       }
+      /**
+       * Seed cross-domain patterns by transferring generalizable patterns
+       * from populated domains to their related domains.
+       *
+       * Uses the domain compatibility matrix to determine which domains
+       * are related and applies a relevance decay to transferred patterns.
+       */
+      async seedCrossDomainPatterns() {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        const stats = await this.patternStore.getStats();
+        let transferred = 0;
+        let skipped = 0;
+        const relatedDomains = {
+          "test-generation": ["test-execution", "coverage-analysis", "requirements-validation"],
+          "test-execution": ["test-generation", "coverage-analysis", "quality-assessment"],
+          "coverage-analysis": ["test-generation", "test-execution", "quality-assessment"],
+          "quality-assessment": ["test-execution", "coverage-analysis", "defect-intelligence"],
+          "defect-intelligence": ["quality-assessment", "code-intelligence"],
+          "requirements-validation": ["test-generation", "quality-assessment"],
+          "code-intelligence": ["defect-intelligence", "security-compliance"],
+          "security-compliance": ["code-intelligence", "quality-assessment"],
+          "contract-testing": ["test-generation", "test-execution"],
+          "visual-accessibility": ["quality-assessment"],
+          "chaos-resilience": ["test-execution", "quality-assessment"],
+          "learning-optimization": ["test-generation", "test-execution", "coverage-analysis", "quality-assessment", "defect-intelligence"]
+        };
+        for (const [sourceDomainStr, targetDomains] of Object.entries(relatedDomains)) {
+          const sourceDomain = sourceDomainStr;
+          const sourceCount = stats.byDomain[sourceDomain] || 0;
+          if (sourceCount === 0) continue;
+          const sourceResult = await this.searchPatterns("", {
+            domain: sourceDomain,
+            limit: 50
+          });
+          if (!sourceResult.success) continue;
+          for (const targetDomain of targetDomains) {
+            const targetCount = stats.byDomain[targetDomain] || 0;
+            if (targetCount >= sourceCount) {
+              skipped++;
+              continue;
+            }
+            for (const { pattern: sourcePattern } of sourceResult.value) {
+              const existingCheck = await this.searchPatterns(sourcePattern.name, {
+                domain: targetDomain,
+                limit: 1
+              });
+              if (existingCheck.success && existingCheck.value.length > 0) {
+                const bestMatch = existingCheck.value[0];
+                if (bestMatch.score > 0.8) {
+                  skipped++;
+                  continue;
+                }
+              }
+              const transferredConfidence = Math.max(0.3, (sourcePattern.confidence || 0.5) * 0.8);
+              const transferResult = await this.storePattern({
+                patternType: sourcePattern.patternType,
+                qeDomain: targetDomain,
+                name: `${sourcePattern.name} (from ${sourceDomain})`,
+                description: `${sourcePattern.description} [Transferred from ${sourceDomain} domain]`,
+                template: sourcePattern.template,
+                context: {
+                  ...sourcePattern.context,
+                  relatedDomains: [sourceDomain, targetDomain],
+                  tags: [
+                    ...sourcePattern.context.tags,
+                    "cross-domain-transfer",
+                    `source:${sourceDomain}`
+                  ]
+                },
+                confidence: transferredConfidence
+              });
+              if (transferResult.success) {
+                transferred++;
+              } else {
+                skipped++;
+              }
+            }
+          }
+        }
+        console.log(
+          `[QEReasoningBank] Cross-domain transfer complete: ${transferred} transferred, ${skipped} skipped`
+        );
+        return { transferred, skipped };
+      }
       /**
        * Store a new pattern
        */
@@ -19227,6 +20317,20 @@ Check for:
           outcome.patternId,
           outcome.success
         );
+        try {
+          const { getUnifiedMemory: getUnifiedMemory2 } = await Promise.resolve().then(() => (init_unified_memory(), unified_memory_exports));
+          const db = getUnifiedMemory2().getDatabase();
+          db.prepare(`
+        INSERT INTO qe_pattern_usage (pattern_id, success, metrics_json, feedback)
+        VALUES (?, ?, ?, ?)
+      `).run(
+            outcome.patternId,
+            outcome.success ? 1 : 0,
+            outcome.metrics ? JSON.stringify(outcome.metrics) : null,
+            outcome.feedback || null
+          );
+        } catch {
+        }
         if (result.success) {
           this.stats.learningOutcomes++;
           if (outcome.success) {
@@ -19555,11 +20659,96 @@ Check for:
   }
 });
 
+// src/adapters/claude-flow/detect.ts
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { join as join17 } from "node:path";
+import { execSync as execSync6 } from "node:child_process";
+function detectClaudeFlow(projectRoot) {
+  if (cachedResult && Date.now() - cacheTimestamp < CACHE_TTL_MS2) {
+    return cachedResult;
+  }
+  const result = doDetection(projectRoot);
+  cachedResult = result;
+  cacheTimestamp = Date.now();
+  return result;
+}
+function doDetection(projectRoot) {
+  const mcpResult = checkMCPConfig(projectRoot);
+  if (mcpResult) return mcpResult;
+  const pkgResult = checkPackageJson(projectRoot);
+  if (pkgResult) return pkgResult;
+  const binaryResult = checkLocalBinary(projectRoot);
+  if (binaryResult) return binaryResult;
+  return { available: false };
+}
+function checkMCPConfig(projectRoot) {
+  const mcpJsonPath = join17(projectRoot, ".claude", "mcp.json");
+  if (existsSync12(mcpJsonPath)) {
+    try {
+      const config = JSON.parse(readFileSync10(mcpJsonPath, "utf-8"));
+      if (config.mcpServers?.["claude-flow"]) {
+        return { available: true, method: "mcp-config" };
+      }
+    } catch {
+    }
+  }
+  const settingsPath = join17(projectRoot, ".claude", "settings.json");
+  if (existsSync12(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync10(settingsPath, "utf-8"));
+      const servers = settings.mcpServers || settings.mcp?.servers || {};
+      if (servers["claude-flow"] || servers["@anthropic/claude-flow"]) {
+        return { available: true, method: "mcp-config" };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function checkPackageJson(projectRoot) {
+  const packageJsonPath = join17(projectRoot, "package.json");
+  if (!existsSync12(packageJsonPath)) return null;
+  try {
+    const pkg2 = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+    const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
+    if (deps["@claude-flow/cli"] || deps["claude-flow"]) {
+      return { available: true, method: "npm-dependency" };
+    }
+  } catch {
+  }
+  return null;
+}
+function checkLocalBinary(projectRoot) {
+  try {
+    const result = execSync6("npx --no-install @claude-flow/cli --version", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd: projectRoot,
+      stdio: ["pipe", "pipe", "pipe"]
+      // suppress stderr noise
+    });
+    const version = result.trim().match(/\d+\.\d+\.\d+[\w.-]*/)?.[0];
+    return { available: true, method: "npx-cached", version };
+  } catch {
+  }
+  return null;
+}
+var cachedResult, cacheTimestamp, CACHE_TTL_MS2;
+var init_detect = __esm({
+  "src/adapters/claude-flow/detect.ts"() {
+    "use strict";
+    cachedResult = null;
+    cacheTimestamp = 0;
+    CACHE_TTL_MS2 = 6e4;
+  }
+});
+
 // src/adapters/claude-flow/trajectory-bridge.ts
 var TrajectoryBridge;
 var init_trajectory_bridge = __esm({
   "src/adapters/claude-flow/trajectory-bridge.ts"() {
     "use strict";
+    init_detect();
     TrajectoryBridge = class {
       constructor(options) {
         this.options = options;
@@ -19573,20 +20762,10 @@ var init_trajectory_bridge = __esm({
         this.claudeFlowAvailable = await this.checkClaudeFlow();
       }
       /**
-       * Check if Claude Flow is available
+       * Check if Claude Flow is available (no npm auto-install)
        */
       async checkClaudeFlow() {
-        try {
-          const { execSync: execSync6 } = await import("child_process");
-          execSync6("npx @claude-flow/cli@latest hooks metrics --period 1h", {
-            encoding: "utf-8",
-            timeout: 5e3,
-            cwd: this.options.projectRoot
-          });
-          return true;
-        } catch {
-          return false;
-        }
+        return detectClaudeFlow(this.options.projectRoot).available;
       }
       /**
        * Start a new trajectory
@@ -19595,10 +20774,10 @@ var init_trajectory_bridge = __esm({
         const id = `trajectory-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
+            const { execSync: execSync7 } = await import("child_process");
             const agentArg = agent ? `--agent ${this.escapeArg(agent)}` : "";
-            const result = execSync6(
-              `npx @claude-flow/cli@latest hooks intelligence trajectory-start --task ${this.escapeArg(task)} ${agentArg}`,
+            const result = execSync7(
+              `npx --no-install @claude-flow/cli hooks intelligence trajectory-start --task ${this.escapeArg(task)} ${agentArg}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             const match = result.match(/trajectoryId[:\s]+["']?([^"'\s,}]+)/i);
@@ -19624,11 +20803,11 @@ var init_trajectory_bridge = __esm({
       async recordStep(trajectoryId, action, result, quality) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
+            const { execSync: execSync7 } = await import("child_process");
             const resultArg = result ? `--result ${this.escapeArg(result)}` : "";
             const qualityArg = quality !== void 0 ? `--quality ${quality}` : "";
-            execSync6(
-              `npx @claude-flow/cli@latest hooks intelligence trajectory-step --trajectory-id ${this.escapeArg(trajectoryId)} --action ${this.escapeArg(action)} ${resultArg} ${qualityArg}`,
+            execSync7(
+              `npx --no-install @claude-flow/cli hooks intelligence trajectory-step --trajectory-id ${this.escapeArg(trajectoryId)} --action ${this.escapeArg(action)} ${resultArg} ${qualityArg}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             return;
@@ -19653,10 +20832,10 @@ var init_trajectory_bridge = __esm({
       async endTrajectory(trajectoryId, success, feedback) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
+            const { execSync: execSync7 } = await import("child_process");
             const feedbackArg = feedback ? `--feedback ${this.escapeArg(feedback)}` : "";
-            execSync6(
-              `npx @claude-flow/cli@latest hooks intelligence trajectory-end --trajectory-id ${this.escapeArg(trajectoryId)} --success ${success} ${feedbackArg}`,
+            execSync7(
+              `npx --no-install @claude-flow/cli hooks intelligence trajectory-end --trajectory-id ${this.escapeArg(trajectoryId)} --success ${success} ${feedbackArg}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
           } catch {
@@ -19689,14 +20868,14 @@ var init_trajectory_bridge = __esm({
        */
       async persistTrajectory(trajectory) {
         try {
-          const { join: join25 } = await import("path");
-          const { existsSync: existsSync17, mkdirSync: mkdirSync6 } = await import("fs");
+          const { join: join26 } = await import("path");
+          const { existsSync: existsSync18, mkdirSync: mkdirSync6 } = await import("fs");
           const { createRequire: createRequire4 } = await import("module");
           const require3 = createRequire4(import.meta.url);
           const Database6 = require3("better-sqlite3");
-          const dbPath = join25(this.options.projectRoot, ".agentic-qe", "trajectories.db");
-          const dir = join25(this.options.projectRoot, ".agentic-qe");
-          if (!existsSync17(dir)) {
+          const dbPath = join26(this.options.projectRoot, ".agentic-qe", "trajectories.db");
+          const dir = join26(this.options.projectRoot, ".agentic-qe");
+          if (!existsSync18(dir)) {
             mkdirSync6(dir, { recursive: true });
           }
           const db = new Database6(dbPath);
@@ -19750,6 +20929,7 @@ var COMPLEXITY_INDICATORS, ModelRouterBridge;
 var init_model_router_bridge = __esm({
   "src/adapters/claude-flow/model-router-bridge.ts"() {
     "use strict";
+    init_detect();
     COMPLEXITY_INDICATORS = {
       low: [
         /simple/i,
@@ -19790,20 +20970,10 @@ var init_model_router_bridge = __esm({
         this.claudeFlowAvailable = await this.checkClaudeFlow();
       }
       /**
-       * Check if Claude Flow is available
+       * Check if Claude Flow is available (no npm auto-install)
        */
       async checkClaudeFlow() {
-        try {
-          const { execSync: execSync6 } = await import("child_process");
-          execSync6("npx @claude-flow/cli@latest hooks model-stats", {
-            encoding: "utf-8",
-            timeout: 5e3,
-            cwd: this.options.projectRoot
-          });
-          return true;
-        } catch {
-          return false;
-        }
+        return detectClaudeFlow(this.options.projectRoot).available;
       }
       /**
        * Route task to optimal model
@@ -19811,9 +20981,9 @@ var init_model_router_bridge = __esm({
       async routeTask(task) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
-            const result = execSync6(
-              `npx @claude-flow/cli@latest hooks model-route --task ${this.escapeArg(task)}`,
+            const { execSync: execSync7 } = await import("child_process");
+            const result = execSync7(
+              `npx --no-install @claude-flow/cli hooks model-route --task ${this.escapeArg(task)}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             const modelMatch = result.match(/model[:\s]+["']?(haiku|sonnet|opus)/i);
@@ -19842,9 +21012,9 @@ var init_model_router_bridge = __esm({
         }
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
-            execSync6(
-              `npx @claude-flow/cli@latest hooks model-outcome --task ${this.escapeArg(outcome.task)} --model ${outcome.model} --outcome ${outcome.outcome}`,
+            const { execSync: execSync7 } = await import("child_process");
+            execSync7(
+              `npx --no-install @claude-flow/cli hooks model-outcome --task ${this.escapeArg(outcome.task)} --model ${outcome.model} --outcome ${outcome.outcome}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
           } catch (error) {
@@ -19941,6 +21111,7 @@ var PretrainBridge;
 var init_pretrain_bridge = __esm({
   "src/adapters/claude-flow/pretrain-bridge.ts"() {
     "use strict";
+    init_detect();
     PretrainBridge = class {
       constructor(options) {
         this.options = options;
@@ -19954,20 +21125,10 @@ var init_pretrain_bridge = __esm({
         this.claudeFlowAvailable = await this.checkClaudeFlow();
       }
       /**
-       * Check if Claude Flow is available
+       * Check if Claude Flow is available (no npm auto-install)
        */
       async checkClaudeFlow() {
-        try {
-          const { execSync: execSync6 } = await import("child_process");
-          execSync6("npx @claude-flow/cli@latest hooks pretrain --help", {
-            encoding: "utf-8",
-            timeout: 5e3,
-            cwd: this.options.projectRoot
-          });
-          return true;
-        } catch {
-          return false;
-        }
+        return detectClaudeFlow(this.options.projectRoot).available;
       }
       /**
        * Run pretrain analysis
@@ -19981,9 +21142,9 @@ var init_pretrain_bridge = __esm({
         }
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
-            const result = execSync6(
-              `npx @claude-flow/cli@latest hooks pretrain --path ${this.escapeArg(targetPath)} --depth ${depth}`,
+            const { execSync: execSync7 } = await import("child_process");
+            const result = execSync7(
+              `npx --no-install @claude-flow/cli hooks pretrain --path ${this.escapeArg(targetPath)} --depth ${depth}`,
               { encoding: "utf-8", timeout: 12e4, cwd: this.options.projectRoot }
             );
             try {
@@ -20016,9 +21177,9 @@ var init_pretrain_bridge = __esm({
       async generateAgentConfigs(format = "yaml") {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
-            const result = execSync6(
-              `npx @claude-flow/cli@latest hooks build-agents --format ${format}`,
+            const { execSync: execSync7 } = await import("child_process");
+            const result = execSync7(
+              `npx --no-install @claude-flow/cli hooks build-agents --format ${format}`,
               { encoding: "utf-8", timeout: 6e4, cwd: this.options.projectRoot }
             );
             try {
@@ -20039,9 +21200,9 @@ var init_pretrain_bridge = __esm({
       async transferPatterns(sourcePath, minConfidence = 0.7) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
-            const result = execSync6(
-              `npx @claude-flow/cli@latest hooks transfer --source-path ${this.escapeArg(sourcePath)} --min-confidence ${minConfidence}`,
+            const { execSync: execSync7 } = await import("child_process");
+            const result = execSync7(
+              `npx --no-install @claude-flow/cli hooks transfer --source-path ${this.escapeArg(sourcePath)} --min-confidence ${minConfidence}`,
               { encoding: "utf-8", timeout: 6e4, cwd: this.options.projectRoot }
             );
             const transferredMatch = result.match(/transferred[:\s]+(\d+)/i);
@@ -20077,8 +21238,8 @@ var init_pretrain_bridge = __esm({
       async localAnalyze(targetPath, depth) {
         try {
           const glob = await import("fast-glob");
-          const { existsSync: existsSync17, readFileSync: readFileSync14 } = await import("fs");
-          const { join: join25 } = await import("path");
+          const { existsSync: existsSync18, readFileSync: readFileSync15 } = await import("fs");
+          const { join: join26 } = await import("path");
           const patterns = depth === "shallow" ? ["*.ts", "*.js", "*.json"] : depth === "medium" ? ["**/*.ts", "**/*.js", "**/*.json", "**/*.py"] : ["**/*"];
           const ignore = ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
           const files = await glob.default(patterns, {
@@ -20095,10 +21256,10 @@ var init_pretrain_bridge = __esm({
             if (file.endsWith(".go")) languages.add("go");
             if (file.endsWith(".rs")) languages.add("rust");
           }
-          const packageJsonPath = join25(targetPath, "package.json");
-          if (existsSync17(packageJsonPath)) {
+          const packageJsonPath = join26(targetPath, "package.json");
+          if (existsSync18(packageJsonPath)) {
             try {
-              const pkg2 = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
+              const pkg2 = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
               const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
               if (deps.react) frameworks.add("react");
               if (deps.vue) frameworks.add("vue");
@@ -20180,6 +21341,7 @@ var init_claude_flow = __esm({
     init_trajectory_bridge();
     init_model_router_bridge();
     init_pretrain_bridge();
+    init_detect();
     init_trajectory_bridge();
     init_model_router_bridge();
     init_pretrain_bridge();
@@ -23595,8 +24757,8 @@ var init_coherence_service = __esm({
 // src/integrations/coherence/wasm-loader.ts
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname4, join as join17 } from "node:path";
-import { readFileSync as readFileSync10, existsSync as existsSync12 } from "node:fs";
+import { dirname as dirname4, join as join18 } from "node:path";
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "node:fs";
 var FALLBACK_RETRY_DELAYS_MS, WasmLoader, wasmLoader;
 var init_wasm_loader = __esm({
   "src/integrations/coherence/wasm-loader.ts"() {
@@ -23859,15 +25021,15 @@ var init_wasm_loader = __esm({
             (() => {
               try {
                 const modulePath = require3.resolve("prime-radiant-advanced-wasm");
-                return join17(dirname4(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
+                return join18(dirname4(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
               } catch {
                 return null;
               }
             })(),
-            join17(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
+            join18(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
           ].filter((p74) => p74 !== null);
           for (const path21 of wasmPaths) {
-            if (existsSync12(path21)) {
+            if (existsSync13(path21)) {
               return true;
             }
           }
@@ -24118,19 +25280,19 @@ var init_wasm_loader = __esm({
           (() => {
             try {
               const modulePath = require3.resolve("prime-radiant-advanced-wasm");
-              return join17(dirname4(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
+              return join18(dirname4(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
             } catch {
               return null;
             }
           })(),
           // Direct node_modules path from current file
-          join17(dirname4(fileURLToPath2(import.meta.url)), "../../../../node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm"),
+          join18(dirname4(fileURLToPath2(import.meta.url)), "../../../../node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm"),
           // Workspace root
-          join17(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
+          join18(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
         ].filter((p74) => p74 !== null);
         let wasmPath = null;
         for (const path21 of wasmPaths) {
-          if (existsSync12(path21)) {
+          if (existsSync13(path21)) {
             wasmPath = path21;
             break;
           }
@@ -24142,7 +25304,7 @@ ${wasmPaths.join("\n")}
 Ensure prime-radiant-advanced-wasm is installed.`
           );
         }
-        const wasmBytes = readFileSync10(wasmPath);
+        const wasmBytes = readFileSync11(wasmPath);
         if (wasmModule2.initSync && typeof wasmModule2.initSync === "function") {
           wasmModule2.initSync({ module: wasmBytes });
         } else {
@@ -24918,8 +26080,8 @@ var init_aqe_learning_engine = __esm({
       async localAnalyze(targetPath, depth) {
         try {
           const glob = await import("fast-glob");
-          const { existsSync: existsSync17, readFileSync: readFileSync14 } = await import("fs");
-          const { join: join25 } = await import("path");
+          const { existsSync: existsSync18, readFileSync: readFileSync15 } = await import("fs");
+          const { join: join26 } = await import("path");
           const patterns = depth === "shallow" ? ["*.ts", "*.js", "*.json"] : depth === "medium" ? ["**/*.ts", "**/*.js", "**/*.json", "**/*.py"] : ["**/*"];
           const ignore = ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
           const files = await glob.default(patterns, {
@@ -24936,10 +26098,10 @@ var init_aqe_learning_engine = __esm({
             if (file.endsWith(".go")) languages.add("go");
             if (file.endsWith(".rs")) languages.add("rust");
           }
-          const packageJsonPath = join25(targetPath, "package.json");
-          if (existsSync17(packageJsonPath)) {
+          const packageJsonPath = join26(targetPath, "package.json");
+          if (existsSync18(packageJsonPath)) {
             try {
-              const pkg2 = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
+              const pkg2 = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
               const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
               if (deps.react) frameworks.add("react");
               if (deps.vue) frameworks.add("vue");
@@ -25025,6 +26187,17 @@ var init_aqe_learning_engine = __esm({
 
 // src/mcp/transport/stdio.ts
 import * as readline from "readline";
+
+// src/cli/helpers/safe-json.ts
+var import_secure_json_parse = __toESM(require_secure_json_parse(), 1);
+function safeJsonParse(json) {
+  return import_secure_json_parse.default.parse(json, void 0, {
+    protoAction: "remove",
+    constructorAction: "remove"
+  });
+}
+
+// src/mcp/transport/stdio.ts
 var JSON_RPC_ERRORS = {
   PARSE_ERROR: -32700,
   INVALID_REQUEST: -32600,
@@ -25145,7 +26318,7 @@ var StdioTransport = class {
     }
     let message;
     try {
-      message = JSON.parse(line);
+      message = safeJsonParse(line);
     } catch {
       this.metrics.errors++;
       await this.sendError(null, JSON_RPC_ERRORS.PARSE_ERROR, "Parse error");
@@ -25259,6 +26432,8 @@ var DEFAULT_CONFIG = {
 var ConnectionManager = class {
   config;
   connections = /* @__PURE__ */ new Map();
+  threadIndex = /* @__PURE__ */ new Map();
+  // threadId → connection IDs
   closedConnections = [];
   // Keep closed connections for metrics
   keepAliveTimers = /* @__PURE__ */ new Map();
@@ -25297,6 +26472,12 @@ var ConnectionManager = class {
       }
     };
     this.connections.set(id, connection);
+    let threadConns = this.threadIndex.get(threadId);
+    if (!threadConns) {
+      threadConns = /* @__PURE__ */ new Set();
+      this.threadIndex.set(threadId, threadConns);
+    }
+    threadConns.add(id);
     this.startKeepAlive(id);
     this.startTimeout(id);
     return connection;
@@ -25311,11 +26492,11 @@ var ConnectionManager = class {
    * Get connection by thread ID
    */
   getConnectionByThreadId(threadId) {
-    const connections = Array.from(this.connections.values());
-    for (const connection of connections) {
-      if (connection.threadId === threadId) {
-        return connection;
-      }
+    const connIds = this.threadIndex.get(threadId);
+    if (!connIds) return void 0;
+    for (const id of connIds) {
+      const conn = this.connections.get(id);
+      if (conn) return conn;
     }
     return void 0;
   }
@@ -25385,17 +26566,24 @@ var ConnectionManager = class {
     while (this.closedConnections.length > 1e3) {
       this.closedConnections.shift();
     }
+    const threadConns = this.threadIndex.get(connection.threadId);
+    if (threadConns) {
+      threadConns.delete(id);
+      if (threadConns.size === 0) {
+        this.threadIndex.delete(connection.threadId);
+      }
+    }
     this.connections.delete(id);
   }
   /**
    * Close all connections for a thread
    */
   closeThreadConnections(threadId, reason) {
-    const connections = Array.from(this.connections.values());
-    for (const connection of connections) {
-      if (connection.threadId === threadId) {
-        this.closeConnection(connection.id, reason);
-      }
+    const connIds = this.threadIndex.get(threadId);
+    if (!connIds) return;
+    const ids = Array.from(connIds);
+    for (const id of ids) {
+      this.closeConnection(id, reason);
     }
   }
   /**
@@ -25768,7 +26956,7 @@ var SSETransport = class {
             reject(new Error("Empty request body"));
             return;
           }
-          const parsed = JSON.parse(body);
+          const parsed = safeJsonParse(body);
           resolve9(parsed);
         } catch (error) {
           reject(new Error("Invalid JSON in request body"));
@@ -26538,7 +27726,7 @@ var WebSocketTransport = class extends EventEmitter2 {
     }
     try {
       const messageStr = data.toString();
-      const message = JSON.parse(messageStr);
+      const message = safeJsonParse(messageStr);
       if (!connectionId.startsWith("pending_")) {
         this.connectionManager.recordMessageReceived(connectionId, Buffer.byteLength(messageStr));
       }
@@ -27291,6 +28479,7 @@ var RegexSafetyValidator = class {
   }
 };
 var defaultValidator2 = new RegexSafetyValidator();
+var createSafeRegex = (pattern, flags, maxLength) => defaultValidator2.createSafeRegex(pattern, flags, maxLength);
 
 // src/mcp/security/validators/crypto-validator.ts
 import { createHash, timingSafeEqual, randomBytes } from "crypto";
@@ -43662,7 +44851,8 @@ var DeterministicGatewayIntegration = class {
           received: `length: ${value.length}`
         });
       }
-      if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+      const patternRegex = schema.pattern ? createSafeRegex(schema.pattern) : null;
+      if (patternRegex && !patternRegex.test(value)) {
         errors.push({
           path: path21,
           message: `${path21} must match pattern ${schema.pattern}`,
@@ -95970,17 +97160,14 @@ Provide:
       });
     }
     if (pattern) {
-      try {
-        const regex = new RegExp(pattern);
-        if (!regex.test(data)) {
-          errors.push({
-            path: path21,
-            keyword: "pattern",
-            message: `String must match pattern: ${pattern}`,
-            params: { pattern }
-          });
-        }
-      } catch {
+      const regex = createSafeRegex(pattern);
+      if (regex && !regex.test(data)) {
+        errors.push({
+          path: path21,
+          keyword: "pattern",
+          message: `String must match pattern: ${pattern}`,
+          params: { pattern }
+        });
       }
     }
   }
@@ -98461,8 +99648,8 @@ var SchemaValidatorService = class {
       });
     }
     if (typeof schema.pattern === "string") {
-      const regex = new RegExp(schema.pattern);
-      if (!regex.test(value)) {
+      const regex = createSafeRegex(schema.pattern);
+      if (regex && !regex.test(value)) {
         errors.push({
           path: path21,
           keyword: "pattern",
@@ -117649,7 +118836,10 @@ var MinCutCalculator = class {
       variance += (degree - meanDegree) ** 2;
     }
     const stdDev2 = Math.sqrt(variance / vertices.length);
-    const minDegree = Math.min(...degrees.values());
+    let minDegree = Infinity;
+    for (const d74 of degrees.values()) {
+      if (d74 < minDegree) minDegree = d74;
+    }
     const effectiveThreshold = threshold ?? meanDegree - stdDev2;
     for (const vertex of vertices) {
       const weightedDegree = degrees.get(vertex.id);
@@ -117716,23 +118906,71 @@ var MinCutCalculator = class {
   }
   /**
    * Analyze graph for potential partitioning points
+   *
+   * Uses Tarjan's algorithm to find articulation points in O(V+E) time.
+   * Previous implementation cloned the entire graph per vertex — O(V*(V+E)).
    */
   findPartitioningPoints(graph) {
+    if (graph.isEmpty() || graph.vertexCount < 2) {
+      return [];
+    }
+    const articulationPoints = this.findArticulationPoints(graph);
     const result = [];
     for (const vertex of graph.getVertices()) {
       const localMinCut = this.getLocalMinCut(graph, vertex.id);
-      const graphCopy = graph.clone();
-      graphCopy.removeVertex(vertex.id);
-      const wouldDisconnect = !graphCopy.isConnected() && graph.vertexCount > 2;
       result.push({
         vertexId: vertex.id,
         localMinCut,
-        wouldDisconnect
+        wouldDisconnect: articulationPoints.has(vertex.id) && graph.vertexCount > 2
       });
     }
     result.sort((a37, b68) => a37.localMinCut - b68.localMinCut);
     return result;
   }
+  /**
+   * Tarjan's algorithm for finding articulation points in O(V+E)
+   */
+  findArticulationPoints(graph) {
+    const disc = /* @__PURE__ */ new Map();
+    const low = /* @__PURE__ */ new Map();
+    const parent = /* @__PURE__ */ new Map();
+    const ap = /* @__PURE__ */ new Set();
+    let timer = 0;
+    const vertices = graph.getVertexIds();
+    for (const v62 of vertices) {
+      disc.set(v62, -1);
+      low.set(v62, -1);
+      parent.set(v62, null);
+    }
+    const dfs = (u73) => {
+      let children6 = 0;
+      disc.set(u73, timer);
+      low.set(u73, timer);
+      timer++;
+      for (const neighborId of graph.neighborIds(u73)) {
+        if (disc.get(neighborId) === -1) {
+          children6++;
+          parent.set(neighborId, u73);
+          dfs(neighborId);
+          low.set(u73, Math.min(low.get(u73), low.get(neighborId)));
+          if (parent.get(u73) === null && children6 > 1) {
+            ap.add(u73);
+          }
+          if (parent.get(u73) !== null && low.get(neighborId) >= disc.get(u73)) {
+            ap.add(u73);
+          }
+        } else if (neighborId !== parent.get(u73)) {
+          low.set(u73, Math.min(low.get(u73), disc.get(neighborId)));
+        }
+      }
+    };
+    for (const v62 of vertices) {
+      if (disc.get(v62) === -1) {
+        dfs(v62);
+      }
+    }
+    return ap;
+  }
   /**
    * Suggest optimal edge additions to improve min-cut
    */
@@ -133104,7 +134342,12 @@ function getTaskExecutor() {
 }
 function resetTaskExecutor() {
   taskExecutor = null;
-  cachedLearningEngine = null;
+  if (cachedLearningEngine) {
+    const engine = cachedLearningEngine;
+    cachedLearningEngine = null;
+    engine.dispose().catch(() => {
+    });
+  }
 }
 async function getLearningEngine() {
   if (cachedLearningEngine) {
@@ -133187,6 +134430,24 @@ async function routeDomainTask(taskDescription, domain, codeContext) {
     return null;
   }
 }
+async function recordPatternUsageAsync(patternHints, success, domain, durationMs) {
+  if (!patternHints || patternHints.length === 0) return;
+  if (!cachedLearningEngine) return;
+  try {
+    for (const hint of patternHints) {
+      if (!hint.patternId) continue;
+      await cachedLearningEngine.recordOutcome({
+        patternId: hint.patternId,
+        success,
+        metrics: {
+          executionTimeMs: durationMs
+        },
+        feedback: `Domain handler ${domain} execution ${success ? "succeeded" : "failed"}`
+      });
+    }
+  } catch {
+  }
+}
 function createDomainHandler(config) {
   const {
     domain,
@@ -133207,10 +134468,11 @@ function createDomainHandler(config) {
       };
     }
     const { queen } = getFleetState();
+    let routingResult = null;
     try {
       const taskDescription = buildTaskDescription(params);
       const codeContext = includeCodeContext?.(params);
-      const routingResult = await routeDomainTask(taskDescription, domain, codeContext);
+      routingResult = await routeDomainTask(taskDescription, domain, codeContext);
       const payload = mapToPayload(params, routingResult);
       const timeout = calculateTimeout?.(params) ?? defaultTimeout;
       const submitResult = await queen.submitTask({
@@ -133249,12 +134511,24 @@ function createDomainHandler(config) {
         result.savedFiles,
         params
       );
+      recordPatternUsageAsync(
+        routingResult?.patternHints,
+        true,
+        domain,
+        result.duration
+      );
       return {
         success: true,
         data: mappedResult
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
+      recordPatternUsageAsync(
+        routingResult?.patternHints,
+        false,
+        domain,
+        0
+      );
       return {
         success: false,
         error: `Failed to ${taskType.replace(/-/g, " ")}: ${errorMessage}`
@@ -137779,8 +139053,8 @@ function generateRecommendations2(results) {
 }
 
 // src/domains/requirements-validation/services/quality-criteria/quality-criteria-service.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { join as join21 } from "path";
 
 // src/domains/requirements-validation/services/quality-criteria/types.ts
 var HTSM_CATEGORIES = [
@@ -137821,14 +139095,14 @@ var QualityCriteriaService = class {
   findTemplatePath() {
     const possiblePaths = [
       // Relative to v3 package
-      join20(process.cwd(), ".claude/helpers/v3/quality-criteria/quality-criteria-reference-template.html"),
+      join21(process.cwd(), ".claude/helpers/v3/quality-criteria/quality-criteria-reference-template.html"),
       // In node_modules
-      join20(process.cwd(), "node_modules/@agentic-qe/v3/assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html"),
+      join21(process.cwd(), "node_modules/@agentic-qe/v3/assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html"),
       // Development path
-      join20(__dirname, "../../../../../assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html")
+      join21(__dirname, "../../../../../assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html")
     ];
     for (const path21 of possiblePaths) {
-      if (existsSync14(path21)) {
+      if (existsSync15(path21)) {
         return path21;
       }
     }
@@ -137845,8 +139119,8 @@ var QualityCriteriaService = class {
    */
   analyze(input) {
     let epicContent = input.epicContent || "";
-    if (input.epicPath && existsSync14(input.epicPath)) {
-      epicContent = readFileSync11(input.epicPath, "utf-8");
+    if (input.epicPath && existsSync15(input.epicPath)) {
+      epicContent = readFileSync12(input.epicPath, "utf-8");
     }
     if (!epicContent && !input.epicPath) {
       throw new Error("Either epicPath or epicContent is required for analysis");
@@ -138012,8 +139286,8 @@ Analyze the requirements above and return the complete QualityCriteriaAnalysis.`
    * Generate HTML output
    */
   generateHTML(analysis) {
-    if (!this.templateCache && existsSync14(this.config.templatePath)) {
-      this.templateCache = readFileSync11(this.config.templatePath, "utf-8");
+    if (!this.templateCache && existsSync15(this.config.templatePath)) {
+      this.templateCache = readFileSync12(this.config.templatePath, "utf-8");
     }
     if (!this.templateCache) {
       return this.generateFallbackHTML(analysis);
@@ -138124,7 +139398,7 @@ function createQualityCriteriaService(config) {
 init_types();
 
 // src/mcp/tools/requirements-validation/quality-criteria.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
 var QualityCriteriaTool = class extends MCPToolBase {
   config = {
     name: "qe/requirements/quality-criteria",
@@ -138223,8 +139497,8 @@ var QualityCriteriaTool = class extends MCPToolBase {
         message: "Preparing agent invocation for semantic HTSM analysis"
       });
       let content = epicContent || "";
-      if (epicPath && existsSync15(epicPath)) {
-        content = readFileSync12(epicPath, "utf-8");
+      if (epicPath && existsSync16(epicPath)) {
+        content = readFileSync13(epicPath, "utf-8");
       }
       if (!content && !epicPath) {
         return {
@@ -139317,7 +140591,7 @@ var ContractValidateTool = class extends MCPToolBase {
     const endpoints = [];
     if (format === "openapi") {
       try {
-        const parsed = JSON.parse(content);
+        const parsed = safeJsonParse(content);
         const components = parsed.components;
         const schemasDef = components?.schemas || {};
         for (const [name, schemaContent] of Object.entries(schemasDef)) {
@@ -139355,7 +140629,7 @@ var ContractValidateTool = class extends MCPToolBase {
       });
     } else if (format === "pact") {
       try {
-        const parsed = JSON.parse(content);
+        const parsed = safeJsonParse(content);
         const interactions = parsed.interactions || [];
         for (const interaction of interactions) {
           const request = interaction.request;
@@ -145338,6 +146612,85 @@ import Database4 from "better-sqlite3";
 
 // src/learning/qe-unified-memory.ts
 init_hnsw_index();
+var QE_DOMAIN_HNSW_CONFIGS = {
+  "test-suites": {
+    dimensions: EMBEDDING_CONFIG.DIMENSIONS,
+    M: 8,
+    // Low connectivity for fast lookup
+    efConstruction: 100,
+    efSearch: 50,
+    metric: "cosine",
+    namespace: "test-suites-hnsw",
+    maxElements: 1e5
+  },
+  coverage: {
+    dimensions: EMBEDDING_CONFIG.DIMENSIONS,
+    M: 16,
+    // Balanced for gap detection
+    efConstruction: 200,
+    efSearch: 100,
+    metric: "cosine",
+    namespace: "coverage-hnsw",
+    maxElements: 1e5
+  },
+  defects: {
+    dimensions: EMBEDDING_CONFIG.DIMENSIONS,
+    M: 32,
+    // High connectivity for precision
+    efConstruction: 400,
+    efSearch: 200,
+    // Higher efSearch for better recall
+    metric: "cosine",
+    namespace: "defects-hnsw",
+    maxElements: 1e5
+  },
+  quality: {
+    dimensions: EMBEDDING_CONFIG.DIMENSIONS,
+    M: 16,
+    // Balanced configuration
+    efConstruction: 200,
+    efSearch: 100,
+    metric: "cosine",
+    namespace: "quality-hnsw",
+    maxElements: 1e5
+  },
+  learning: {
+    dimensions: EMBEDDING_CONFIG.DIMENSIONS,
+    M: 24,
+    // Higher recall for knowledge transfer
+    efConstruction: 300,
+    efSearch: 150,
+    metric: "cosine",
+    namespace: "learning-hnsw",
+    maxElements: 1e5
+  },
+  coordination: {
+    dimensions: EMBEDDING_CONFIG.DIMENSIONS,
+    M: 8,
+    // Fast lookup for coordination
+    efConstruction: 100,
+    efSearch: 50,
+    metric: "cosine",
+    namespace: "coordination-hnsw",
+    maxElements: 5e4
+    // Fewer entries needed
+  }
+};
+var DEFAULT_QE_UNIFIED_MEMORY_CONFIG = {
+  enableHNSW: {
+    "test-suites": true,
+    "coverage": true,
+    // Already has HNSW
+    "defects": true,
+    "quality": true,
+    "learning": true,
+    // Already has HNSW (ReasoningBank)
+    "coordination": true
+  },
+  defaultNamespace: "qe-unified",
+  enableCrossDomainSearch: true,
+  embeddingDimension: EMBEDDING_CONFIG.DIMENSIONS
+};
 
 // src/learning/index.ts
 init_dream();
@@ -151486,8 +152839,8 @@ var DEFAULT_POOL_CONFIG = {
 };
 var ConnectionPoolImpl = class {
   connections = /* @__PURE__ */ new Map();
-  connectionQueue = [];
-  // FIFO queue for LRU-style eviction
+  idleConnections = /* @__PURE__ */ new Set();
+  // O(1) acquire + release
   config;
   healthCheckInterval = null;
   initialized = false;
@@ -151569,16 +152922,18 @@ var ConnectionPoolImpl = class {
   doAcquire() {
     const startTime = performance.now();
     this.totalRequests++;
-    for (const connId of this.connectionQueue) {
+    for (const connId of this.idleConnections) {
       const conn = this.connections.get(connId);
-      if (conn && conn.isHealthy && !conn.inUse) {
+      if (conn && conn.isHealthy) {
         conn.inUse = true;
         conn.lastUsedAt = Date.now();
+        this.idleConnections.delete(connId);
         this.cacheHits++;
         const elapsed2 = performance.now() - startTime;
         this.trackAcquisitionTime(elapsed2);
         return conn;
       }
+      this.idleConnections.delete(connId);
     }
     if (this.config.autoCreate && this.connections.size < this.config.maxConnections) {
       const newConn = this.createConnectionSync();
@@ -151604,6 +152959,9 @@ var ConnectionPoolImpl = class {
     }
     conn.inUse = false;
     conn.lastUsedAt = Date.now();
+    if (conn.isHealthy) {
+      this.idleConnections.add(connectionId);
+    }
   }
   /**
    * Record a request completion for metrics
@@ -151670,10 +153028,7 @@ var ConnectionPoolImpl = class {
     }
     for (const id of pruned) {
       this.connections.delete(id);
-      const idx = this.connectionQueue.indexOf(id);
-      if (idx >= 0) {
-        this.connectionQueue.splice(idx, 1);
-      }
+      this.idleConnections.delete(id);
     }
     while (this.connections.size < this.config.minConnections) {
       this.createConnectionSync();
@@ -151685,7 +153040,7 @@ var ConnectionPoolImpl = class {
    */
   reset() {
     this.connections.clear();
-    this.connectionQueue.length = 0;
+    this.idleConnections.clear();
     this.totalRequests = 0;
     this.cacheHits = 0;
     this.acquisitionTimes = [];
@@ -151699,7 +153054,7 @@ var ConnectionPoolImpl = class {
       this.healthCheckInterval = null;
     }
     this.connections.clear();
-    this.connectionQueue.length = 0;
+    this.idleConnections.clear();
     this.initialized = false;
   }
   // ============================================================================
@@ -151723,7 +153078,7 @@ var ConnectionPoolImpl = class {
       }
     };
     this.connections.set(id, connection);
-    this.connectionQueue.push(id);
+    this.idleConnections.add(id);
   }
   createConnectionSync() {
     if (this.connections.size >= this.config.maxConnections) {
@@ -151746,7 +153101,7 @@ var ConnectionPoolImpl = class {
       }
     };
     this.connections.set(id, connection);
-    this.connectionQueue.push(id);
+    this.idleConnections.add(id);
     return connection;
   }
   performHealthChecks() {
@@ -151759,8 +153114,16 @@ var ConnectionPoolImpl = class {
       health -= errorRate * 0.8;
       health -= Math.min(0.2, avgLatency / 100 * 0.2);
       conn.health = Math.max(0, Math.min(1, health));
+      const wasHealthy = conn.isHealthy;
       conn.isHealthy = conn.health >= this.config.healthThreshold;
       conn.metrics.lastHealthCheck = now;
+      if (!conn.inUse) {
+        if (conn.isHealthy && !wasHealthy) {
+          this.idleConnections.add(conn.id);
+        } else if (!conn.isHealthy && wasHealthy) {
+          this.idleConnections.delete(conn.id);
+        }
+      }
     }
     if (this.config.autoPrune) {
       this.prune();
@@ -152731,7 +154094,7 @@ async function quickStart(config) {
 
 // src/mcp/http-server.ts
 import { createServer } from "http";
-import { join as join23, dirname as dirname8 } from "path";
+import { join as join24, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/adapters/a2a/agent-cards/schema.ts
@@ -155808,7 +157171,7 @@ init_unified_memory();
 
 // src/adapters/a2a/agent-cards/generator.ts
 import { readFile as readFile10, readdir as readdir5, stat as stat5 } from "fs/promises";
-import { join as join22, basename as basename4 } from "path";
+import { join as join23, basename as basename4 } from "path";
 var DEFAULT_GENERATOR_CONFIG = {
   baseUrl: "http://localhost:8080",
   defaultVersion: "3.0.0",
@@ -156157,7 +157520,7 @@ var AgentCardGenerator = class {
     const processDirectory = async (dirPath) => {
       const entries = await readdir5(dirPath);
       for (const entry of entries) {
-        const fullPath = join22(dirPath, entry);
+        const fullPath = join23(dirPath, entry);
         const stats = await stat5(fullPath);
         if (stats.isDirectory() && recursive) {
           await processDirectory(fullPath);
@@ -157609,7 +158972,7 @@ var HTTPServerImpl = class {
     this.skipCRDTInit = config.skipCRDTInit ?? false;
     this.enableWebSocket = config.enableWebSocket ?? true;
     const currentDir = dirname8(fileURLToPath3(import.meta.url));
-    this.agentMarkdownDir = config.agentMarkdownDir ?? join23(currentDir, "../../assets/agents/v3");
+    this.agentMarkdownDir = config.agentMarkdownDir ?? join24(currentDir, "../../assets/agents/v3");
     this.taskStore = createTaskStore();
     this.taskManager = config.taskManager ?? createTaskManager({
       storeConfig: {}
@@ -158117,7 +159480,7 @@ var HTTPServerImpl = class {
             resolve9({});
             return;
           }
-          resolve9(JSON.parse(body));
+          resolve9(safeJsonParse(body));
         } catch (error) {
           reject(new Error("Invalid JSON in request body"));
         }
@@ -159485,7 +160848,7 @@ function createInfraHealingOrchestratorSync(options) {
 }
 
 // src/mcp/entry.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 import { resolve as resolve8, dirname as dirname9 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var require2 = createRequire3(import.meta.url);
@@ -159544,7 +160907,7 @@ async function main() {
       const playbookPath = resolve8(__dirname2, "../strange-loop/infra-healing/default-playbook.yaml");
       let playbookContent;
       try {
-        playbookContent = readFileSync13(playbookPath, "utf-8");
+        playbookContent = readFileSync14(playbookPath, "utf-8");
       } catch {
         playbookContent = "";
       }