agentic-qe 3.6.9 → 3.6.11

package/v3/dist/mcp/bundle.js

@@ -4597,13 +4597,78 @@ var init_sql_safety = __esm({
   }
 });
 
+// native-require:@ruvector/gnn
+var gnn_exports = {};
+__export(gnn_exports, {
+  DotProductAttention: () => DotProductAttention2,
+  FlashAttention: () => FlashAttention2,
+  HyperbolicAttention: () => HyperbolicAttention2,
+  LinearAttention: () => LinearAttention2,
+  MoEAttention: () => MoEAttention2,
+  MultiHeadAttention: () => MultiHeadAttention2,
+  RuvectorLayer: () => RuvectorLayer2,
+  SonaEngine: () => SonaEngine2,
+  TensorCompress: () => TensorCompress2,
+  default: () => gnn_default,
+  differentiableSearch: () => differentiableSearch2,
+  getCompressionLevel: () => getCompressionLevel2,
+  hierarchicalForward: () => hierarchicalForward2,
+  init: () => init2,
+  pipeline: () => pipeline2
+});
+import { createRequire as createRequire2 } from "module";
+var __require3, __mod2, gnn_default, RuvectorLayer2, TensorCompress2, differentiableSearch2, hierarchicalForward2, getCompressionLevel2, init2, FlashAttention2, DotProductAttention2, MultiHeadAttention2, HyperbolicAttention2, LinearAttention2, MoEAttention2, SonaEngine2, pipeline2;
+var init_gnn = __esm({
+  "native-require:@ruvector/gnn"() {
+    __require3 = createRequire2(import.meta.url);
+    __mod2 = __require3("@ruvector/gnn");
+    gnn_default = __mod2;
+    ({
+      RuvectorLayer: RuvectorLayer2,
+      TensorCompress: TensorCompress2,
+      differentiableSearch: differentiableSearch2,
+      hierarchicalForward: hierarchicalForward2,
+      getCompressionLevel: getCompressionLevel2,
+      init: init2,
+      FlashAttention: FlashAttention2,
+      DotProductAttention: DotProductAttention2,
+      MultiHeadAttention: MultiHeadAttention2,
+      HyperbolicAttention: HyperbolicAttention2,
+      LinearAttention: LinearAttention2,
+      MoEAttention: MoEAttention2,
+      SonaEngine: SonaEngine2,
+      pipeline: pipeline2
+    } = __mod2 || {});
+  }
+});
+
 // src/kernel/unified-memory-hnsw.ts
-var BinaryHeap, InMemoryHNSWIndex;
+function computeNorm(v62) {
+  let sum = 0;
+  for (let i58 = 0; i58 < v62.length; i58++) sum += v62[i58] * v62[i58];
+  return Math.sqrt(sum);
+}
+function fastCosine(a37, b68, normA, normB) {
+  const denom = normA * normB;
+  if (denom === 0) return 0;
+  let dot = 0;
+  for (let i58 = 0; i58 < a37.length; i58++) dot += a37[i58] * b68[i58];
+  return dot / denom;
+}
+var ruvectorDifferentiableSearch, ruvectorInit, BinaryHeap, InMemoryHNSWIndex, RuvectorFlatIndex;
 var init_unified_memory_hnsw = __esm({
   "src/kernel/unified-memory-hnsw.ts"() {
     "use strict";
     init_vector_math();
     init_constants();
+    ruvectorDifferentiableSearch = null;
+    ruvectorInit = null;
+    try {
+      const gnn = (init_gnn(), __toCommonJS(gnn_exports));
+      ruvectorDifferentiableSearch = gnn.differentiableSearch;
+      ruvectorInit = gnn.init;
+    } catch {
+    }
     BinaryHeap = class {
       data = [];
       compareFn;
@@ -4936,6 +5001,94 @@ var init_unified_memory_hnsw = __esm({
         this.currentMaxLevel = -1;
       }
     };
+    RuvectorFlatIndex = class {
+      ids = [];
+      vectors = [];
+      /** Pre-computed L2 norms for each vector (enables dot-product-only cosine). */
+      norms = [];
+      idToIndex = /* @__PURE__ */ new Map();
+      initialized = false;
+      constructor() {
+        if (ruvectorInit && !this.initialized) {
+          try {
+            ruvectorInit();
+            this.initialized = true;
+          } catch {
+            this.initialized = ruvectorDifferentiableSearch !== null;
+          }
+        }
+      }
+      add(id, embedding) {
+        const f322 = new Float32Array(embedding);
+        const norm = computeNorm(f322);
+        if (this.idToIndex.has(id)) {
+          const idx2 = this.idToIndex.get(id);
+          this.vectors[idx2] = f322;
+          this.norms[idx2] = norm;
+          return;
+        }
+        const idx = this.ids.length;
+        this.ids.push(id);
+        this.vectors.push(f322);
+        this.norms.push(norm);
+        this.idToIndex.set(id, idx);
+      }
+      search(query, k68) {
+        if (this.ids.length === 0) return [];
+        const actualK = Math.min(k68, this.ids.length);
+        if (ruvectorDifferentiableSearch && this.vectors.length > 0) {
+          const queryF322 = new Float32Array(query);
+          const queryNorm2 = computeNorm(queryF322);
+          const result = ruvectorDifferentiableSearch(
+            queryF322,
+            this.vectors,
+            actualK,
+            1
+          );
+          return result.indices.map((idx) => ({
+            id: this.ids[idx],
+            score: fastCosine(queryF322, this.vectors[idx], queryNorm2, this.norms[idx])
+          }));
+        }
+        const queryF32 = new Float32Array(query);
+        const queryNorm = computeNorm(queryF32);
+        const scored = [];
+        for (let i58 = 0; i58 < this.ids.length; i58++) {
+          scored.push({
+            id: this.ids[i58],
+            score: fastCosine(queryF32, this.vectors[i58], queryNorm, this.norms[i58])
+          });
+        }
+        scored.sort((a37, b68) => b68.score - a37.score);
+        return scored.slice(0, actualK);
+      }
+      remove(id) {
+        const idx = this.idToIndex.get(id);
+        if (idx === void 0) return false;
+        const lastIdx = this.ids.length - 1;
+        if (idx !== lastIdx) {
+          const lastId = this.ids[lastIdx];
+          this.ids[idx] = lastId;
+          this.vectors[idx] = this.vectors[lastIdx];
+          this.norms[idx] = this.norms[lastIdx];
+          this.idToIndex.set(lastId, idx);
+        }
+        this.ids.pop();
+        this.vectors.pop();
+        this.norms.pop();
+        this.idToIndex.delete(id);
+        return true;
+      }
+      clear() {
+        this.ids = [];
+        this.vectors = [];
+        this.norms = [];
+        this.idToIndex.clear();
+      }
+      size() {
+        return this.ids.length;
+      }
+    };
   }
 });
 
@@ -6490,6 +6643,7 @@ __export(unified_memory_exports, {
   BinaryHeap: () => BinaryHeap,
   DEFAULT_UNIFIED_MEMORY_CONFIG: () => DEFAULT_UNIFIED_MEMORY_CONFIG,
   InMemoryHNSWIndex: () => InMemoryHNSWIndex,
+  RuvectorFlatIndex: () => RuvectorFlatIndex,
   UnifiedMemoryManager: () => UnifiedMemoryManager,
   clearProjectRootCache: () => clearProjectRootCache,
   findProjectRoot: () => findProjectRoot,
@@ -6620,7 +6774,7 @@ var init_unified_memory = __esm({
       vectorsLoaded = false;
       initPromise = null;
       preparedStatements = /* @__PURE__ */ new Map();
-      vectorIndex = new InMemoryHNSWIndex();
+      vectorIndex = new RuvectorFlatIndex();
       // CRDT store for distributed state synchronization
       crdtStore = null;
       constructor(config) {
@@ -6788,7 +6942,7 @@ var init_unified_memory = __esm({
           this.vectorIndex.add(row2.id, embedding);
         }
         this.vectorsLoaded = true;
-        console.log(`[UnifiedMemory] Loaded ${rows.length} vectors into HNSW index`);
+        console.log(`[UnifiedMemory] Loaded ${rows.length} vectors into vector index (ruvector flat)`);
       }
       // ============================================================================
       // KV Store Operations (v2 compatible)
@@ -7092,9 +7246,8 @@ var init_unified_memory = __esm({
         return buffer;
       }
       bufferToFloatArray(buffer, dimensions) {
-        const arr = [];
-        for (let i58 = 0; i58 < dimensions; i58++) arr.push(buffer.readFloatLE(i58 * 4));
-        return arr;
+        const f322 = new Float32Array(buffer.buffer, buffer.byteOffset, dimensions);
+        return Array.from(f322);
       }
     };
     exitHandlersRegistered = false;
@@ -7105,45 +7258,45 @@ var init_unified_memory = __esm({
 // native-require:@xenova/transformers
 var transformers_exports = {};
 __export(transformers_exports, {
-  DotProductAttention: () => DotProductAttention2,
-  FlashAttention: () => FlashAttention2,
-  HyperbolicAttention: () => HyperbolicAttention2,
-  LinearAttention: () => LinearAttention2,
-  MoEAttention: () => MoEAttention2,
-  MultiHeadAttention: () => MultiHeadAttention2,
-  RuvectorLayer: () => RuvectorLayer2,
-  SonaEngine: () => SonaEngine2,
-  TensorCompress: () => TensorCompress2,
+  DotProductAttention: () => DotProductAttention3,
+  FlashAttention: () => FlashAttention3,
+  HyperbolicAttention: () => HyperbolicAttention3,
+  LinearAttention: () => LinearAttention3,
+  MoEAttention: () => MoEAttention3,
+  MultiHeadAttention: () => MultiHeadAttention3,
+  RuvectorLayer: () => RuvectorLayer3,
+  SonaEngine: () => SonaEngine3,
+  TensorCompress: () => TensorCompress3,
   default: () => transformers_default,
-  differentiableSearch: () => differentiableSearch2,
-  getCompressionLevel: () => getCompressionLevel2,
-  hierarchicalForward: () => hierarchicalForward2,
-  init: () => init2,
-  pipeline: () => pipeline2
+  differentiableSearch: () => differentiableSearch3,
+  getCompressionLevel: () => getCompressionLevel3,
+  hierarchicalForward: () => hierarchicalForward3,
+  init: () => init3,
+  pipeline: () => pipeline3
 });
-import { createRequire as createRequire2 } from "module";
-var __require3, __mod2, transformers_default, RuvectorLayer2, TensorCompress2, differentiableSearch2, hierarchicalForward2, getCompressionLevel2, init2, FlashAttention2, DotProductAttention2, MultiHeadAttention2, HyperbolicAttention2, LinearAttention2, MoEAttention2, SonaEngine2, pipeline2;
+import { createRequire as createRequire3 } from "module";
+var __require4, __mod3, transformers_default, RuvectorLayer3, TensorCompress3, differentiableSearch3, hierarchicalForward3, getCompressionLevel3, init3, FlashAttention3, DotProductAttention3, MultiHeadAttention3, HyperbolicAttention3, LinearAttention3, MoEAttention3, SonaEngine3, pipeline3;
 var init_transformers = __esm({
   "native-require:@xenova/transformers"() {
-    __require3 = createRequire2(import.meta.url);
-    __mod2 = __require3("@xenova/transformers");
-    transformers_default = __mod2;
+    __require4 = createRequire3(import.meta.url);
+    __mod3 = __require4("@xenova/transformers");
+    transformers_default = __mod3;
     ({
-      RuvectorLayer: RuvectorLayer2,
-      TensorCompress: TensorCompress2,
-      differentiableSearch: differentiableSearch2,
-      hierarchicalForward: hierarchicalForward2,
-      getCompressionLevel: getCompressionLevel2,
-      init: init2,
-      FlashAttention: FlashAttention2,
-      DotProductAttention: DotProductAttention2,
-      MultiHeadAttention: MultiHeadAttention2,
-      HyperbolicAttention: HyperbolicAttention2,
-      LinearAttention: LinearAttention2,
-      MoEAttention: MoEAttention2,
-      SonaEngine: SonaEngine2,
-      pipeline: pipeline2
-    } = __mod2 || {});
+      RuvectorLayer: RuvectorLayer3,
+      TensorCompress: TensorCompress3,
+      differentiableSearch: differentiableSearch3,
+      hierarchicalForward: hierarchicalForward3,
+      getCompressionLevel: getCompressionLevel3,
+      init: init3,
+      FlashAttention: FlashAttention3,
+      DotProductAttention: DotProductAttention3,
+      MultiHeadAttention: MultiHeadAttention3,
+      HyperbolicAttention: HyperbolicAttention3,
+      LinearAttention: LinearAttention3,
+      MoEAttention: MoEAttention3,
+      SonaEngine: SonaEngine3,
+      pipeline: pipeline3
+    } = __mod3 || {});
   }
 });
 
@@ -7171,10 +7324,10 @@ async function initializeModel(config = {}) {
   initPromise = (async () => {
     try {
       const transformers = await Promise.resolve().then(() => (init_transformers(), transformers_exports));
-      pipeline3 = transformers.pipeline;
+      pipeline4 = transformers.pipeline;
       console.log(`[RealEmbeddings] Loading model: ${fullConfig.modelName}`);
       const startTime = performance.now();
-      embeddingModel = await pipeline3("feature-extraction", fullConfig.modelName, {
+      embeddingModel = await pipeline4("feature-extraction", fullConfig.modelName, {
         quantized: fullConfig.quantized
       });
       const loadTime = performance.now() - startTime;
@@ -7292,20 +7445,20 @@ function getEmbeddingDimension() {
   return 384;
 }
 function resetInitialization() {
-  pipeline3 = null;
+  pipeline4 = null;
   embeddingModel = null;
   initPromise = null;
   initializationFailed = false;
   failureReason = "";
   embeddingCache.clear();
 }
-var pipeline3, embeddingModel, initPromise, initializationFailed, failureReason, DEFAULT_EMBEDDING_CONFIG, embeddingCache, CACHE_TTL_MS;
+var pipeline4, embeddingModel, initPromise, initializationFailed, failureReason, DEFAULT_EMBEDDING_CONFIG, embeddingCache, CACHE_TTL_MS;
 var init_real_embeddings = __esm({
   "src/learning/real-embeddings.ts"() {
     "use strict";
     init_vector_math();
     init_error_utils();
-    pipeline3 = null;
+    pipeline4 = null;
     embeddingModel = null;
     initPromise = null;
     initializationFailed = false;
@@ -7526,6 +7679,105 @@ var init_unified_persistence = __esm({
   }
 });
 
+// src/learning/qe-patterns.ts
+function detectQEDomain(taskDescription) {
+  for (const [domain, pattern] of Object.entries(QE_DOMAINS)) {
+    if (pattern.test(taskDescription)) {
+      return domain;
+    }
+  }
+  return null;
+}
+function detectQEDomains(taskDescription) {
+  const detected = [];
+  for (const [domain, pattern] of Object.entries(QE_DOMAINS)) {
+    if (pattern.test(taskDescription)) {
+      detected.push(domain);
+    }
+  }
+  return detected;
+}
+function mapQEDomainToAQE(qeDomain) {
+  return qeDomain;
+}
+function calculateQualityScore(pattern) {
+  const usageScore = Math.min(pattern.usageCount / 100, 1);
+  return pattern.confidence * 0.3 + usageScore * 0.2 + pattern.successRate * 0.5;
+}
+function shouldPromotePattern(pattern, coherenceEnergy, coherenceThreshold = 0.4) {
+  const meetsUsageCriteria = pattern.tier === "short-term" && pattern.successfulUses >= 3;
+  const meetsQualityCriteria = pattern.successRate >= 0.7 && pattern.confidence >= 0.6;
+  const meetsCoherenceCriteria = coherenceEnergy === void 0 || coherenceEnergy < coherenceThreshold;
+  let blockReason;
+  if (!meetsUsageCriteria) {
+    blockReason = "insufficient_usage";
+  } else if (!meetsQualityCriteria) {
+    blockReason = "low_quality";
+  } else if (!meetsCoherenceCriteria) {
+    blockReason = "coherence_violation";
+  }
+  return {
+    meetsUsageCriteria,
+    meetsQualityCriteria,
+    meetsCoherenceCriteria,
+    blockReason
+  };
+}
+function validateQEPattern(pattern) {
+  const errors = [];
+  if (!pattern.id) errors.push("Pattern ID is required");
+  if (!pattern.patternType) errors.push("Pattern type is required");
+  if (!pattern.qeDomain) errors.push("QE domain is required");
+  if (!pattern.name) errors.push("Pattern name is required");
+  if (!pattern.template?.content) errors.push("Template content is required");
+  if (pattern.confidence !== void 0 && (pattern.confidence < 0 || pattern.confidence > 1)) {
+    errors.push("Confidence must be between 0 and 1");
+  }
+  if (pattern.successRate !== void 0 && (pattern.successRate < 0 || pattern.successRate > 1)) {
+    errors.push("Success rate must be between 0 and 1");
+  }
+  if (pattern.template?.variables) {
+    const variableNames = /* @__PURE__ */ new Set();
+    for (const variable of pattern.template.variables) {
+      if (variableNames.has(variable.name)) {
+        errors.push(`Duplicate variable name: ${variable.name}`);
+      }
+      variableNames.add(variable.name);
+      if (!pattern.template.content.includes(`{{${variable.name}}}`)) {
+        errors.push(
+          `Variable ${variable.name} not referenced in template`
+        );
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+var QE_DOMAINS, QE_DOMAIN_LIST;
+var init_qe_patterns = __esm({
+  "src/learning/qe-patterns.ts"() {
+    "use strict";
+    QE_DOMAINS = {
+      // Core Testing Domains
+      "test-generation": /test|spec|describe|it\(|expect|assert|mock|stub|fixture|tdd|bdd/i,
+      "test-execution": /run|execute|parallel|retry|flaky|timeout|worker|orchestrat/i,
+      "coverage-analysis": /coverage|branch|line|uncovered|gap|untested|percentage|sublinear/i,
+      // Quality Domains
+      "quality-assessment": /quality|gate|deploy|readiness|metric|threshold|sla|score/i,
+      "defect-intelligence": /defect|bug|predict|root.?cause|regression|failure|incident/i,
+      "requirements-validation": /requirement|bdd|gherkin|testabil|accept|criteri|scenario/i,
+      // Analysis Domains
+      "code-intelligence": /semantic|knowledge|graph|ast|symbol|reference|impact|depend/i,
+      "security-compliance": /vuln|cve|owasp|xss|sqli|injection|csrf|auth|secret|compliance|sast|dast/i,
+      "contract-testing": /contract|pact|openapi|swagger|graphql|schema|endpoint|api/i,
+      // Specialized Testing Domains
+      "visual-accessibility": /screenshot|visual|snapshot|pixel|percy|a11y|aria|wcag|screen.?reader|accessible|contrast/i,
+      "chaos-resilience": /chaos|resilience|fault|inject|blast|recover|latency|failure|stress|load/i,
+      "learning-optimization": /learn|pattern|optim|neural|embedding|vector|memory|adapt|train/i
+    };
+    QE_DOMAIN_LIST = Object.keys(QE_DOMAINS);
+  }
+});
+
 // src/coordination/consensus/model-provider.ts
 function buildVerificationPrompt(finding, options = {}) {
   const {
@@ -9354,45 +9606,45 @@ Format your response with: verdict (confirmed/rejected/uncertain), confidence (0
 // native-require:@ruvector/sona
 var sona_exports = {};
 __export(sona_exports, {
-  DotProductAttention: () => DotProductAttention3,
-  FlashAttention: () => FlashAttention3,
-  HyperbolicAttention: () => HyperbolicAttention3,
-  LinearAttention: () => LinearAttention3,
-  MoEAttention: () => MoEAttention3,
-  MultiHeadAttention: () => MultiHeadAttention3,
-  RuvectorLayer: () => RuvectorLayer3,
-  SonaEngine: () => SonaEngine3,
-  TensorCompress: () => TensorCompress3,
+  DotProductAttention: () => DotProductAttention4,
+  FlashAttention: () => FlashAttention4,
+  HyperbolicAttention: () => HyperbolicAttention4,
+  LinearAttention: () => LinearAttention4,
+  MoEAttention: () => MoEAttention4,
+  MultiHeadAttention: () => MultiHeadAttention4,
+  RuvectorLayer: () => RuvectorLayer4,
+  SonaEngine: () => SonaEngine4,
+  TensorCompress: () => TensorCompress4,
   default: () => sona_default,
-  differentiableSearch: () => differentiableSearch3,
-  getCompressionLevel: () => getCompressionLevel3,
-  hierarchicalForward: () => hierarchicalForward3,
-  init: () => init3,
-  pipeline: () => pipeline4
+  differentiableSearch: () => differentiableSearch4,
+  getCompressionLevel: () => getCompressionLevel4,
+  hierarchicalForward: () => hierarchicalForward4,
+  init: () => init4,
+  pipeline: () => pipeline5
 });
-import { createRequire as createRequire3 } from "module";
-var __require4, __mod3, sona_default, RuvectorLayer3, TensorCompress3, differentiableSearch3, hierarchicalForward3, getCompressionLevel3, init3, FlashAttention3, DotProductAttention3, MultiHeadAttention3, HyperbolicAttention3, LinearAttention3, MoEAttention3, SonaEngine3, pipeline4;
+import { createRequire as createRequire4 } from "module";
+var __require5, __mod4, sona_default, RuvectorLayer4, TensorCompress4, differentiableSearch4, hierarchicalForward4, getCompressionLevel4, init4, FlashAttention4, DotProductAttention4, MultiHeadAttention4, HyperbolicAttention4, LinearAttention4, MoEAttention4, SonaEngine4, pipeline5;
 var init_sona = __esm({
   "native-require:@ruvector/sona"() {
-    __require4 = createRequire3(import.meta.url);
-    __mod3 = __require4("@ruvector/sona");
-    sona_default = __mod3;
+    __require5 = createRequire4(import.meta.url);
+    __mod4 = __require5("@ruvector/sona");
+    sona_default = __mod4;
     ({
-      RuvectorLayer: RuvectorLayer3,
-      TensorCompress: TensorCompress3,
-      differentiableSearch: differentiableSearch3,
-      hierarchicalForward: hierarchicalForward3,
-      getCompressionLevel: getCompressionLevel3,
-      init: init3,
-      FlashAttention: FlashAttention3,
-      DotProductAttention: DotProductAttention3,
-      MultiHeadAttention: MultiHeadAttention3,
-      HyperbolicAttention: HyperbolicAttention3,
-      LinearAttention: LinearAttention3,
-      MoEAttention: MoEAttention3,
-      SonaEngine: SonaEngine3,
-      pipeline: pipeline4
-    } = __mod3 || {});
+      RuvectorLayer: RuvectorLayer4,
+      TensorCompress: TensorCompress4,
+      differentiableSearch: differentiableSearch4,
+      hierarchicalForward: hierarchicalForward4,
+      getCompressionLevel: getCompressionLevel4,
+      init: init4,
+      FlashAttention: FlashAttention4,
+      DotProductAttention: DotProductAttention4,
+      MultiHeadAttention: MultiHeadAttention4,
+      HyperbolicAttention: HyperbolicAttention4,
+      LinearAttention: LinearAttention4,
+      MoEAttention: MoEAttention4,
+      SonaEngine: SonaEngine4,
+      pipeline: pipeline5
+    } = __mod4 || {});
   }
 });
 
@@ -9534,7 +9786,7 @@ var init_sona_wrapper = __esm({
           qualityThreshold: this.config.qualityThreshold,
           enableSimd: this.config.enableSimd
         };
-        this.engine = SonaEngine3.withConfig(jsConfig);
+        this.engine = SonaEngine4.withConfig(jsConfig);
         this.registry = new QESONAPatternRegistry(this.config.maxPatterns ?? 1e4);
       }
       /**
@@ -9963,45 +10215,45 @@ var init_sona_wrapper = __esm({
 // native-require:@ruvector/attention
 var attention_exports = {};
 __export(attention_exports, {
-  DotProductAttention: () => DotProductAttention4,
-  FlashAttention: () => FlashAttention4,
-  HyperbolicAttention: () => HyperbolicAttention4,
-  LinearAttention: () => LinearAttention4,
-  MoEAttention: () => MoEAttention4,
-  MultiHeadAttention: () => MultiHeadAttention4,
-  RuvectorLayer: () => RuvectorLayer4,
-  SonaEngine: () => SonaEngine4,
-  TensorCompress: () => TensorCompress4,
+  DotProductAttention: () => DotProductAttention5,
+  FlashAttention: () => FlashAttention5,
+  HyperbolicAttention: () => HyperbolicAttention5,
+  LinearAttention: () => LinearAttention5,
+  MoEAttention: () => MoEAttention5,
+  MultiHeadAttention: () => MultiHeadAttention5,
+  RuvectorLayer: () => RuvectorLayer5,
+  SonaEngine: () => SonaEngine5,
+  TensorCompress: () => TensorCompress5,
   default: () => attention_default,
-  differentiableSearch: () => differentiableSearch4,
-  getCompressionLevel: () => getCompressionLevel4,
-  hierarchicalForward: () => hierarchicalForward4,
-  init: () => init4,
-  pipeline: () => pipeline5
+  differentiableSearch: () => differentiableSearch5,
+  getCompressionLevel: () => getCompressionLevel5,
+  hierarchicalForward: () => hierarchicalForward5,
+  init: () => init5,
+  pipeline: () => pipeline6
 });
-import { createRequire as createRequire4 } from "module";
-var __require5, __mod4, attention_default, RuvectorLayer4, TensorCompress4, differentiableSearch4, hierarchicalForward4, getCompressionLevel4, init4, FlashAttention4, DotProductAttention4, MultiHeadAttention4, HyperbolicAttention4, LinearAttention4, MoEAttention4, SonaEngine4, pipeline5;
+import { createRequire as createRequire5 } from "module";
+var __require6, __mod5, attention_default, RuvectorLayer5, TensorCompress5, differentiableSearch5, hierarchicalForward5, getCompressionLevel5, init5, FlashAttention5, DotProductAttention5, MultiHeadAttention5, HyperbolicAttention5, LinearAttention5, MoEAttention5, SonaEngine5, pipeline6;
 var init_attention = __esm({
   "native-require:@ruvector/attention"() {
-    __require5 = createRequire4(import.meta.url);
-    __mod4 = __require5("@ruvector/attention");
-    attention_default = __mod4;
+    __require6 = createRequire5(import.meta.url);
+    __mod5 = __require6("@ruvector/attention");
+    attention_default = __mod5;
     ({
-      RuvectorLayer: RuvectorLayer4,
-      TensorCompress: TensorCompress4,
-      differentiableSearch: differentiableSearch4,
-      hierarchicalForward: hierarchicalForward4,
-      getCompressionLevel: getCompressionLevel4,
-      init: init4,
-      FlashAttention: FlashAttention4,
-      DotProductAttention: DotProductAttention4,
-      MultiHeadAttention: MultiHeadAttention4,
-      HyperbolicAttention: HyperbolicAttention4,
-      LinearAttention: LinearAttention4,
-      MoEAttention: MoEAttention4,
-      SonaEngine: SonaEngine4,
-      pipeline: pipeline5
-    } = __mod4 || {});
+      RuvectorLayer: RuvectorLayer5,
+      TensorCompress: TensorCompress5,
+      differentiableSearch: differentiableSearch5,
+      hierarchicalForward: hierarchicalForward5,
+      getCompressionLevel: getCompressionLevel5,
+      init: init5,
+      FlashAttention: FlashAttention5,
+      DotProductAttention: DotProductAttention5,
+      MultiHeadAttention: MultiHeadAttention5,
+      HyperbolicAttention: HyperbolicAttention5,
+      LinearAttention: LinearAttention5,
+      MoEAttention: MoEAttention5,
+      SonaEngine: SonaEngine5,
+      pipeline: pipeline6
+    } = __mod5 || {});
   }
 });
 
@@ -10159,23 +10411,23 @@ var init_attention_wrapper = __esm({
       static create(config) {
         switch (config.strategy) {
           case "flash":
-            return new FlashAttention4(config.dim, config.blockSize);
+            return new FlashAttention5(config.dim, config.blockSize);
           case "dot-product":
-            return new DotProductAttention4(config.dim);
+            return new DotProductAttention5(config.dim);
           case "multi-head":
-            return new MultiHeadAttention4(config.dim, config.numHeads ?? 8);
+            return new MultiHeadAttention5(config.dim, config.numHeads ?? 8);
           case "hyperbolic":
-            return new HyperbolicAttention4(config.dim, config.curvature);
+            return new HyperbolicAttention5(config.dim, config.curvature);
           case "linear":
-            return new LinearAttention4(config.dim, config.features);
+            return new LinearAttention5(config.dim, config.features);
           case "moe":
-            return MoEAttention4.simple(
+            return MoEAttention5.simple(
               config.dim,
               config.moeConfig?.numExperts ?? 8,
               config.moeConfig?.topK ?? 2
             );
           default:
-            return new FlashAttention4(config.dim, config.blockSize);
+            return new FlashAttention5(config.dim, config.blockSize);
         }
       }
     };
@@ -10232,20 +10484,20 @@ var init_attention_wrapper = __esm({
         const keys = this.splitMatrix(K58, seqLen, dim);
         const values = this.splitMatrix(V45, seqLen, dim);
         let output;
-        if (this.attention instanceof FlashAttention4) {
+        if (this.attention instanceof FlashAttention5) {
           output = this.attention.compute(query, keys, values);
-        } else if (this.attention instanceof DotProductAttention4) {
+        } else if (this.attention instanceof DotProductAttention5) {
           output = this.attention.compute(query, keys, values);
-        } else if (this.attention instanceof MultiHeadAttention4) {
+        } else if (this.attention instanceof MultiHeadAttention5) {
           output = this.attention.compute(query, keys, values);
-        } else if (this.attention instanceof HyperbolicAttention4) {
+        } else if (this.attention instanceof HyperbolicAttention5) {
           output = this.attention.compute(query, keys, values);
-        } else if (this.attention instanceof LinearAttention4) {
+        } else if (this.attention instanceof LinearAttention5) {
           output = this.attention.compute(query, keys, values);
-        } else if (this.attention instanceof MoEAttention4) {
+        } else if (this.attention instanceof MoEAttention5) {
           output = this.attention.compute(query, keys, values);
         } else {
-          const fallback = new FlashAttention4(this.config.dim);
+          const fallback = new FlashAttention5(this.config.dim);
           output = fallback.compute(query, keys, values);
         }
         const endTime = performance.now();
@@ -10490,65 +10742,20 @@ var init_attention_wrapper = __esm({
   }
 });
 
-// native-require:@ruvector/gnn
-var gnn_exports = {};
-__export(gnn_exports, {
-  DotProductAttention: () => DotProductAttention5,
-  FlashAttention: () => FlashAttention5,
-  HyperbolicAttention: () => HyperbolicAttention5,
-  LinearAttention: () => LinearAttention5,
-  MoEAttention: () => MoEAttention5,
-  MultiHeadAttention: () => MultiHeadAttention5,
-  RuvectorLayer: () => RuvectorLayer5,
-  SonaEngine: () => SonaEngine5,
-  TensorCompress: () => TensorCompress5,
-  default: () => gnn_default,
-  differentiableSearch: () => differentiableSearch5,
-  getCompressionLevel: () => getCompressionLevel5,
-  hierarchicalForward: () => hierarchicalForward5,
-  init: () => init5,
-  pipeline: () => pipeline6
-});
-import { createRequire as createRequire5 } from "module";
-var __require6, __mod5, gnn_default, RuvectorLayer5, TensorCompress5, differentiableSearch5, hierarchicalForward5, getCompressionLevel5, init5, FlashAttention5, DotProductAttention5, MultiHeadAttention5, HyperbolicAttention5, LinearAttention5, MoEAttention5, SonaEngine5, pipeline6;
-var init_gnn = __esm({
-  "native-require:@ruvector/gnn"() {
-    __require6 = createRequire5(import.meta.url);
-    __mod5 = __require6("@ruvector/gnn");
-    gnn_default = __mod5;
-    ({
-      RuvectorLayer: RuvectorLayer5,
-      TensorCompress: TensorCompress5,
-      differentiableSearch: differentiableSearch5,
-      hierarchicalForward: hierarchicalForward5,
-      getCompressionLevel: getCompressionLevel5,
-      init: init5,
-      FlashAttention: FlashAttention5,
-      DotProductAttention: DotProductAttention5,
-      MultiHeadAttention: MultiHeadAttention5,
-      HyperbolicAttention: HyperbolicAttention5,
-      LinearAttention: LinearAttention5,
-      MoEAttention: MoEAttention5,
-      SonaEngine: SonaEngine5,
-      pipeline: pipeline6
-    } = __mod5 || {});
-  }
-});
-
 // src/integrations/ruvector/gnn-wrapper.ts
 var gnn_wrapper_exports = {};
 __export(gnn_wrapper_exports, {
   GNNLayerFactory: () => GNNLayerFactory,
   QEGNNEmbeddingIndex: () => QEGNNEmbeddingIndex,
   QEGNNIndexFactory: () => QEGNNIndexFactory,
-  RuvectorLayer: () => RuvectorLayer5,
-  TensorCompress: () => TensorCompress5,
+  RuvectorLayer: () => RuvectorLayer2,
+  TensorCompress: () => TensorCompress2,
   TensorCompressionFactory: () => TensorCompressionFactory,
   batchDifferentiableSearch: () => batchDifferentiableSearch,
-  differentiableSearch: () => differentiableSearch5,
-  getCompressionLevel: () => getCompressionLevel5,
-  hierarchicalForward: () => hierarchicalForward5,
-  init: () => init5,
+  differentiableSearch: () => differentiableSearch2,
+  getCompressionLevel: () => getCompressionLevel2,
+  hierarchicalForward: () => hierarchicalForward2,
+  init: () => init2,
   initGNN: () => initGNN,
   toFloat32Array: () => toFloat32Array2,
   toIEmbedding: () => toIEmbedding,
@@ -10556,7 +10763,7 @@ __export(gnn_wrapper_exports, {
 });
 function initGNN() {
   if (!gnnInitialized) {
-    const result = init5();
+    const result = init2();
     gnnInitialized = true;
     return result;
   }
@@ -10597,7 +10804,7 @@ function batchDifferentiableSearch(queries, candidateEmbeddings, k68, temperatur
   );
   for (const query of queries) {
     const queryFloat32 = query instanceof Float32Array ? query : new Float32Array(query);
-    const result = differentiableSearch5(
+    const result = differentiableSearch2(
       queryFloat32,
       candidatesFloat32,
       k68,
@@ -10635,7 +10842,7 @@ var init_gnn_wrapper = __esm({
         this.indexes = /* @__PURE__ */ new Map();
         this.nextId = /* @__PURE__ */ new Map();
         this.gnnLayers = /* @__PURE__ */ new Map();
-        this.compressor = new TensorCompress5();
+        this.compressor = new TensorCompress2();
         initGNN();
       }
       /**
@@ -10696,7 +10903,7 @@ var init_gnn_wrapper = __esm({
         }
         const queryFloat32 = new Float32Array(query.vector);
         const candidateFloat32s = candidates.map((c70) => new Float32Array(c70.vector));
-        const result = differentiableSearch5(
+        const result = differentiableSearch2(
           queryFloat32,
           candidateFloat32s,
           Math.min(k68, candidates.length),
@@ -10719,7 +10926,7 @@ var init_gnn_wrapper = __esm({
         const candidateVectors = candidates.map(
           (c70) => new Float32Array(c70.embedding.vector)
         );
-        const result = differentiableSearch5(
+        const result = differentiableSearch2(
           queryVector,
           candidateVectors,
           Math.min(k68, candidates.length),
@@ -10740,7 +10947,7 @@ var init_gnn_wrapper = __esm({
         if (!this.gnnLayers.has(layerKey)) {
           const layers = [];
           for (const config of layerConfigs) {
-            const layer2 = new RuvectorLayer5(
+            const layer2 = new RuvectorLayer2(
               config.inputDim,
               config.hiddenDim,
               config.heads,
@@ -10756,7 +10963,7 @@ var init_gnn_wrapper = __esm({
         const layerEmbeddingsFloat32 = layerEmbeddings.map(
           (layer2) => layer2.map((emb) => new Float32Array(emb))
         );
-        return Array.from(hierarchicalForward5(
+        return Array.from(hierarchicalForward2(
           queryFloat32,
           layerEmbeddingsFloat32,
           [gnnLayerJson]
@@ -10771,7 +10978,7 @@ var init_gnn_wrapper = __esm({
        * - Cold data (low access): product quantization
        */
       compressEmbedding(embedding, accessFreq) {
-        const rawLevel = getCompressionLevel5(accessFreq);
+        const rawLevel = getCompressionLevel2(accessFreq);
         const levelMap = {
           "none": "none",
           "half": "half",
@@ -10817,7 +11024,7 @@ var init_gnn_wrapper = __esm({
        * Get compression level for access frequency
        */
       getCompressionLevelForFrequency(accessFreq) {
-        return getCompressionLevel5(accessFreq);
+        return getCompressionLevel2(accessFreq);
       }
       /**
        * Get index statistics
@@ -10961,7 +11168,7 @@ var init_gnn_wrapper = __esm({
       static getLayer(config) {
         const key = `${config.inputDim}-${config.hiddenDim}-${config.heads}-${config.dropout}`;
         if (!this.layers.has(key)) {
-          const layer = new RuvectorLayer5(
+          const layer = new RuvectorLayer2(
             config.inputDim,
             config.hiddenDim,
             config.heads,
@@ -10975,7 +11182,7 @@ var init_gnn_wrapper = __esm({
        * Create layer from JSON
        */
       static layerFromJson(json) {
-        return RuvectorLayer5.fromJson(json);
+        return RuvectorLayer2.fromJson(json);
       }
       /**
        * Clear cached layers
@@ -10985,7 +11192,7 @@ var init_gnn_wrapper = __esm({
       }
     };
     TensorCompressionFactory = class {
-      static compressor = new TensorCompress5();
+      static compressor = new TensorCompress2();
       /**
        * Compress tensor with specific level
        */
@@ -11011,7 +11218,7 @@ var init_gnn_wrapper = __esm({
        * Get compression level for frequency
        */
       static getLevel(accessFreq) {
-        return getCompressionLevel5(accessFreq);
+        return getCompressionLevel2(accessFreq);
       }
     };
   }
@@ -11028,14 +11235,14 @@ __export(wrappers_exports, {
   QE_FLASH_ATTENTION_CONFIG: () => QE_FLASH_ATTENTION_CONFIG,
   QE_PERFORMANCE_TARGETS: () => QE_PERFORMANCE_TARGETS,
   QE_SONA_CONFIG: () => QE_SONA_CONFIG,
-  RuvectorDotProductAttention: () => DotProductAttention4,
-  RuvectorFlashAttention: () => FlashAttention4,
-  RuvectorHyperbolicAttention: () => HyperbolicAttention4,
-  RuvectorLayer: () => RuvectorLayer5,
-  RuvectorLinearAttention: () => LinearAttention4,
-  RuvectorMoEAttention: () => MoEAttention4,
-  RuvectorMultiHeadAttention: () => MultiHeadAttention4,
-  TensorCompress: () => TensorCompress5,
+  RuvectorDotProductAttention: () => DotProductAttention5,
+  RuvectorFlashAttention: () => FlashAttention5,
+  RuvectorHyperbolicAttention: () => HyperbolicAttention5,
+  RuvectorLayer: () => RuvectorLayer2,
+  RuvectorLinearAttention: () => LinearAttention5,
+  RuvectorMoEAttention: () => MoEAttention5,
+  RuvectorMultiHeadAttention: () => MultiHeadAttention5,
+  TensorCompress: () => TensorCompress2,
   TensorCompressionFactory: () => TensorCompressionFactory,
   batchComputeAttention: () => batchComputeAttention,
   batchDifferentiableSearch: () => batchDifferentiableSearch,
@@ -11043,14 +11250,14 @@ __export(wrappers_exports, {
   createDomainQESONA: () => createDomainQESONA,
   createQEFlashAttention: () => createQEFlashAttention,
   createQESONA: () => createQESONA,
-  differentiableSearch: () => differentiableSearch5,
-  getCompressionLevel: () => getCompressionLevel5,
+  differentiableSearch: () => differentiableSearch2,
+  getCompressionLevel: () => getCompressionLevel2,
   getOptimalBlockConfig: () => getOptimalBlockConfig,
   getQEFlashAttentionConfig: () => getQEFlashAttentionConfig,
   getRuvectorPackageVersions: () => getRuvectorPackageVersions,
   getWorkloadTypes: () => getWorkloadTypes,
-  hierarchicalForward: () => hierarchicalForward5,
-  init: () => init5,
+  hierarchicalForward: () => hierarchicalForward2,
+  init: () => init2,
   initAllRuvectorPackages: () => initAllRuvectorPackages,
   initGNN: () => initGNN,
   toFloat32Array: () => toFloat32Array,
@@ -11254,7 +11461,7 @@ var init_hnsw_index = __esm({
         if (!this.initialized) {
           await this.initialize();
         }
-        this.validateVector(vector);
+        vector = this.validateVector(vector);
         if (this.keyToLabel.has(key)) {
           await this.delete(key);
         }
@@ -11283,7 +11490,7 @@ var init_hnsw_index = __esm({
         if (!this.initialized) {
           await this.initialize();
         }
-        this.validateVector(query);
+        query = this.validateVector(query);
         const startTime = performance.now();
         const results = this.stats.vectorCount > 0 ? this.searchRuvector(query, k68) : [];
         const endTime = performance.now();
@@ -11408,17 +11615,46 @@ var init_hnsw_index = __esm({
       // ============================================================================
       // Private Helper Methods
       // ============================================================================
+      /**
+       * Validate and auto-resize vectors to match HNSW configured dimensions.
+       * Fix #279: Prevents Rust WASM panic when RealEmbeddings (768-dim) are
+       * passed to a 128-dim HNSW index.
+       */
       validateVector(vector) {
         if (vector.length !== this.config.dimensions) {
-          throw new Error(
-            `Vector dimension mismatch: expected ${this.config.dimensions}, got ${vector.length}`
-          );
+          return this.resizeVector(vector, this.config.dimensions);
         }
         for (let i58 = 0; i58 < vector.length; i58++) {
           if (!Number.isFinite(vector[i58])) {
             throw new Error(`Invalid vector value at index ${i58}: ${vector[i58]}`);
           }
         }
+        return vector;
+      }
+      /**
+       * Resize vector to target dimensions using averaging (shrink) or zero-padding (grow).
+       */
+      resizeVector(vector, targetDim) {
+        if (vector.length === targetDim) return vector;
+        if (vector.length > targetDim) {
+          const result2 = new Array(targetDim).fill(0);
+          const ratio = vector.length / targetDim;
+          for (let i58 = 0; i58 < targetDim; i58++) {
+            const start = Math.floor(i58 * ratio);
+            const end = Math.floor((i58 + 1) * ratio);
+            let sum = 0;
+            for (let j52 = start; j52 < end; j52++) {
+              sum += vector[j52];
+            }
+            result2[i58] = sum / (end - start);
+          }
+          return result2;
+        }
+        const result = new Array(targetDim).fill(0);
+        for (let i58 = 0; i58 < vector.length; i58++) {
+          result[i58] = vector[i58];
+        }
+        return result;
       }
       buildKey(key) {
         return `${this.config.namespace}:${key}`;
@@ -14209,105 +14445,6 @@ var init_dream = __esm({
   }
 });
 
-// src/learning/qe-patterns.ts
-function detectQEDomain(taskDescription) {
-  for (const [domain, pattern] of Object.entries(QE_DOMAINS)) {
-    if (pattern.test(taskDescription)) {
-      return domain;
-    }
-  }
-  return null;
-}
-function detectQEDomains(taskDescription) {
-  const detected = [];
-  for (const [domain, pattern] of Object.entries(QE_DOMAINS)) {
-    if (pattern.test(taskDescription)) {
-      detected.push(domain);
-    }
-  }
-  return detected;
-}
-function mapQEDomainToAQE(qeDomain) {
-  return qeDomain;
-}
-function calculateQualityScore(pattern) {
-  const usageScore = Math.min(pattern.usageCount / 100, 1);
-  return pattern.confidence * 0.3 + usageScore * 0.2 + pattern.successRate * 0.5;
-}
-function shouldPromotePattern(pattern, coherenceEnergy, coherenceThreshold = 0.4) {
-  const meetsUsageCriteria = pattern.tier === "short-term" && pattern.successfulUses >= 3;
-  const meetsQualityCriteria = pattern.successRate >= 0.7 && pattern.confidence >= 0.6;
-  const meetsCoherenceCriteria = coherenceEnergy === void 0 || coherenceEnergy < coherenceThreshold;
-  let blockReason;
-  if (!meetsUsageCriteria) {
-    blockReason = "insufficient_usage";
-  } else if (!meetsQualityCriteria) {
-    blockReason = "low_quality";
-  } else if (!meetsCoherenceCriteria) {
-    blockReason = "coherence_violation";
-  }
-  return {
-    meetsUsageCriteria,
-    meetsQualityCriteria,
-    meetsCoherenceCriteria,
-    blockReason
-  };
-}
-function validateQEPattern(pattern) {
-  const errors = [];
-  if (!pattern.id) errors.push("Pattern ID is required");
-  if (!pattern.patternType) errors.push("Pattern type is required");
-  if (!pattern.qeDomain) errors.push("QE domain is required");
-  if (!pattern.name) errors.push("Pattern name is required");
-  if (!pattern.template?.content) errors.push("Template content is required");
-  if (pattern.confidence !== void 0 && (pattern.confidence < 0 || pattern.confidence > 1)) {
-    errors.push("Confidence must be between 0 and 1");
-  }
-  if (pattern.successRate !== void 0 && (pattern.successRate < 0 || pattern.successRate > 1)) {
-    errors.push("Success rate must be between 0 and 1");
-  }
-  if (pattern.template?.variables) {
-    const variableNames = /* @__PURE__ */ new Set();
-    for (const variable of pattern.template.variables) {
-      if (variableNames.has(variable.name)) {
-        errors.push(`Duplicate variable name: ${variable.name}`);
-      }
-      variableNames.add(variable.name);
-      if (!pattern.template.content.includes(`{{${variable.name}}}`)) {
-        errors.push(
-          `Variable ${variable.name} not referenced in template`
-        );
-      }
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-var QE_DOMAINS, QE_DOMAIN_LIST;
-var init_qe_patterns = __esm({
-  "src/learning/qe-patterns.ts"() {
-    "use strict";
-    QE_DOMAINS = {
-      // Core Testing Domains
-      "test-generation": /test|spec|describe|it\(|expect|assert|mock|stub|fixture|tdd|bdd/i,
-      "test-execution": /run|execute|parallel|retry|flaky|timeout|worker|orchestrat/i,
-      "coverage-analysis": /coverage|branch|line|uncovered|gap|untested|percentage|sublinear/i,
-      // Quality Domains
-      "quality-assessment": /quality|gate|deploy|readiness|metric|threshold|sla|score/i,
-      "defect-intelligence": /defect|bug|predict|root.?cause|regression|failure|incident/i,
-      "requirements-validation": /requirement|bdd|gherkin|testabil|accept|criteri|scenario/i,
-      // Analysis Domains
-      "code-intelligence": /semantic|knowledge|graph|ast|symbol|reference|impact|depend/i,
-      "security-compliance": /vuln|cve|owasp|xss|sqli|injection|csrf|auth|secret|compliance|sast|dast/i,
-      "contract-testing": /contract|pact|openapi|swagger|graphql|schema|endpoint|api/i,
-      // Specialized Testing Domains
-      "visual-accessibility": /screenshot|visual|snapshot|pixel|percy|a11y|aria|wcag|screen.?reader|accessible|contrast/i,
-      "chaos-resilience": /chaos|resilience|fault|inject|blast|recover|latency|failure|stress|load/i,
-      "learning-optimization": /learn|pattern|optim|neural|embedding|vector|memory|adapt|train/i
-    };
-    QE_DOMAIN_LIST = Object.keys(QE_DOMAINS);
-  }
-});
-
 // src/integrations/agentic-flow/agent-booster/types.ts
 var ALL_TRANSFORM_TYPES, TRANSFORM_METADATA, DEFAULT_AGENT_BOOSTER_CONFIG, AgentBoosterError, TransformError, WasmUnavailableError, TransformTimeoutError, FileTooLargeError;
 var init_types4 = __esm({
@@ -17688,7 +17825,13 @@ var init_signal_collector = __esm({
         "test generation",
         "error handling",
         "validation logic",
-        "api integration"
+        "api integration",
+        "code index",
+        "coverage analysis",
+        "quality assessment",
+        "defect prediction",
+        "predict defect",
+        "analyze coverage"
       ],
       // Tier 3 - High complexity
       complex: [
@@ -17699,7 +17842,14 @@ var init_signal_collector = __esm({
         "migration",
         "cross-domain",
         "workflow",
-        "system design"
+        "system design",
+        "analyze security",
+        "security scan",
+        "security analysis",
+        "vulnerability scan",
+        "chaos test",
+        "resilience test",
+        "contract validation"
       ],
       // Tier 4 - Critical/expert
       critical: [
@@ -17710,7 +17860,12 @@ var init_signal_collector = __esm({
         "system-wide",
         "vulnerability",
         "cryptography",
-        "performance critical"
+        "performance critical",
+        "hardcoded secret",
+        "cve",
+        "owasp",
+        "penetration test",
+        "exploit"
       ]
     };
     SCOPE_PATTERNS = {
@@ -18007,11 +18162,15 @@ var init_score_calculator = __esm({
        * Calculate overall complexity score (0-100)
        */
       calculateOverallComplexity(codeComplexity, reasoningComplexity, scopeComplexity, signals) {
-        if (signals.isMechanicalTransform) {
+        if (signals.isMechanicalTransform && !signals.hasSecurityScope && !signals.hasArchitectureScope && !signals.requiresMultiStepReasoning && !signals.requiresCrossDomainCoordination && codeComplexity === 0 && reasoningComplexity === 0 && scopeComplexity === 0) {
           return 5;
         }
         const weighted = codeComplexity * 0.3 + reasoningComplexity * 0.4 + scopeComplexity * 0.3;
-        return Math.min(Math.round(weighted), 100);
+        let minScore = 0;
+        if (signals.hasSecurityScope) minScore = Math.max(minScore, 50);
+        if (signals.hasArchitectureScope) minScore = Math.max(minScore, 55);
+        if (signals.requiresCrossDomainCoordination) minScore = Math.max(minScore, 35);
+        return Math.min(Math.max(Math.round(weighted), minScore), 100);
       }
       /**
        * Calculate confidence in complexity assessment (0-1)
@@ -18814,7 +18973,7 @@ var init_router = __esm({
           agentBoosterStats: {
             eligible: agentBoosterEligible,
             used: agentBoosterUsed,
-            fallbackToLLM: agentBoosterEligible - agentBoosterUsed,
+            fallbackToLLM: Math.max(0, agentBoosterEligible - agentBoosterUsed),
             successRate: agentBoosterUsed > 0 ? agentBoosterSuccess / agentBoosterUsed : 0
           },
           budgetStats: {
@@ -38624,7 +38783,7 @@ var JestVitestGenerator = class extends BaseTestGenerator {
    * Generate complete test file from analysis
    */
   generateTests(context) {
-    const { moduleName, importPath, testType, patterns, analysis } = context;
+    const { moduleName, importPath, testType, patterns, analysis, dependencies } = context;
     if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
       return this.generateStubTests(context);
     }
@@ -38634,8 +38793,23 @@ var JestVitestGenerator = class extends BaseTestGenerator {
     const mockImport = this.framework === "vitest" ? ", vi" : "";
     let testCode = `${patternComment}import { describe, it, expect, beforeEach${mockImport} } from '${this.framework}';
 ${importStatement}
-
 `;
+    if (dependencies && dependencies.imports.length > 0) {
+      const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
+      testCode += `
+// Auto-generated mocks from Knowledge Graph dependency analysis
+`;
+      for (const dep of dependencies.imports.slice(0, 10)) {
+        const depName = dep.split("/").pop()?.replace(/[^a-zA-Z0-9_]/g, "_") || dep;
+        testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
+`;
+      }
+      testCode += `
+`;
+    } else {
+      testCode += `
+`;
+    }
     for (const fn of analysis.functions) {
       testCode += this.generateFunctionTests(fn, testType);
     }
@@ -38755,22 +38929,80 @@ ${importStatement}
    * Generate stub tests when no AST analysis is available
    */
   generateStubTests(context) {
-    const { moduleName, importPath, testType, patterns } = context;
+    const { moduleName, importPath, testType, patterns, dependencies, similarCode } = context;
     const patternComment = this.generatePatternComment(patterns);
     const basicOpsTest = this.generateBasicOpsTest(moduleName, patterns);
     const edgeCaseTest = this.generateEdgeCaseTest(moduleName, patterns);
     const errorHandlingTest = this.generateErrorHandlingTest(moduleName, patterns);
+    let mockDeclarations = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
+      mockDeclarations += `
+// Auto-generated mocks from Knowledge Graph dependency analysis
+`;
+      for (const dep of dependencies.imports.slice(0, 10)) {
+        mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
+`;
+      }
+    }
+    let similarityComment = "";
+    if (similarCode && similarCode.snippets.length > 0) {
+      similarityComment += `  // KG: Similar modules found - consider testing shared patterns:
+`;
+      for (const s70 of similarCode.snippets.slice(0, 3)) {
+        similarityComment += `  //   - ${s70.file} (${(s70.score * 100).toFixed(0)}% similar)
+`;
+      }
+      similarityComment += `
+`;
+    }
+    let depTest = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      depTest += `
+    it('should interact with dependencies correctly', () => {
+`;
+      depTest += `      // KG-informed: module depends on ${dependencies.imports.length} imports
+`;
+      depTest += `      const instance = typeof ${moduleName} === 'function'
+`;
+      depTest += `        ? new ${moduleName}()
+`;
+      depTest += `        : ${moduleName};
+`;
+      depTest += `      expect(instance).toBeDefined();
+`;
+      depTest += `    });
+`;
+    }
+    let callerTest = "";
+    if (dependencies && dependencies.importedBy.length > 0) {
+      callerTest += `
+    it('should expose stable API for ${dependencies.importedBy.length} consumers', () => {
+`;
+      callerTest += `      // KG-informed: used by ${dependencies.importedBy.slice(0, 3).join(", ")}
+`;
+      callerTest += `      const publicKeys = Object.keys(typeof ${moduleName} === 'function'
+`;
+      callerTest += `        ? ${moduleName}.prototype || {}
+`;
+      callerTest += `        : ${moduleName});
+`;
+      callerTest += `      expect(publicKeys.length).toBeGreaterThan(0);
+`;
+      callerTest += `    });
+`;
+    }
     return `${patternComment}import { ${moduleName} } from '${importPath}';
-
+${mockDeclarations}
 describe('${moduleName}', () => {
-  describe('${testType} tests', () => {
+${similarityComment}  describe('${testType} tests', () => {
     it('should be defined', () => {
       expect(${moduleName}).toBeDefined();
     });
 
 ${basicOpsTest}
 ${edgeCaseTest}
-${errorHandlingTest}
+${errorHandlingTest}${depTest}${callerTest}
   });
 });
 `;
@@ -38978,18 +39210,51 @@ var MochaGenerator = class extends BaseTestGenerator {
    * Generate complete test file from analysis
    */
   generateTests(context) {
-    const { moduleName, importPath, testType, patterns, analysis } = context;
+    const { moduleName, importPath, testType, patterns, analysis, dependencies } = context;
     if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
       return this.generateStubTests(context);
     }
     const patternComment = this.generatePatternComment(patterns);
     const exports = this.extractExports(analysis.functions, analysis.classes);
     const importStatement = this.generateImportStatement(exports, importPath, moduleName);
+    let sinonImport = "";
+    let stubSetup = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      sinonImport = `import sinon from 'sinon';
+`;
+      const depsToMock = dependencies.imports.slice(0, 5);
+      stubSetup += `  // Auto-generated stubs from Knowledge Graph dependency analysis
+`;
+      stubSetup += `  let stubs;
+
+`;
+      stubSetup += `  beforeEach(function() {
+`;
+      stubSetup += `    stubs = {
+`;
+      for (const dep of depsToMock) {
+        const depName = dep.split("/").pop()?.replace(/[^a-zA-Z0-9_]/g, "_") || dep;
+        stubSetup += `      ${depName}: sinon.stub(),
+`;
+      }
+      stubSetup += `    };
+`;
+      stubSetup += `  });
+
+`;
+      stubSetup += `  afterEach(function() {
+`;
+      stubSetup += `    sinon.restore();
+`;
+      stubSetup += `  });
+
+`;
+    }
     let code = `${patternComment}import { expect } from 'chai';
-${importStatement}
+${sinonImport}${importStatement}
 
 describe('${moduleName} - ${testType} tests', function() {
-`;
+${stubSetup}`;
     for (const fn of analysis.functions) {
       code += this.generateFunctionTests(fn, testType);
     }
@@ -39079,18 +39344,100 @@ describe('${moduleName} - ${testType} tests', function() {
    * Generate stub tests when no AST analysis is available
    */
   generateStubTests(context) {
-    const { moduleName, importPath, testType, patterns } = context;
+    const { moduleName, importPath, testType, patterns, dependencies, similarCode } = context;
     const patternComment = this.generatePatternComment(patterns);
     const isAsync = patterns.some(
       (p74) => p74.name.toLowerCase().includes("async") || p74.name.toLowerCase().includes("promise")
     );
     const asyncSetup = isAsync ? "async " : "";
+    let sinonImport = "";
+    let stubSetup = "";
+    let stubTeardown = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      sinonImport = `import sinon from 'sinon';
+`;
+      const depsToMock = dependencies.imports.slice(0, 5);
+      stubSetup += `
+    // Auto-generated stubs from Knowledge Graph dependency analysis
+`;
+      stubSetup += `    let stubs;
+
+`;
+      stubSetup += `    beforeEach(function() {
+`;
+      stubSetup += `      stubs = {
+`;
+      for (const dep of depsToMock) {
+        const depName = dep.split("/").pop()?.replace(/[^a-zA-Z0-9_]/g, "_") || dep;
+        stubSetup += `        ${depName}: sinon.stub(),
+`;
+      }
+      stubSetup += `      };
+`;
+      stubSetup += `    });
+
+`;
+      stubTeardown += `    afterEach(function() {
+`;
+      stubTeardown += `      sinon.restore();
+`;
+      stubTeardown += `    });
+
+`;
+    }
+    let similarityComment = "";
+    if (similarCode && similarCode.snippets.length > 0) {
+      similarityComment += `    // KG: Similar modules found - consider testing shared patterns:
+`;
+      for (const s70 of similarCode.snippets.slice(0, 3)) {
+        similarityComment += `    //   - ${s70.file} (${(s70.score * 100).toFixed(0)}% similar)
+`;
+      }
+      similarityComment += `
+`;
+    }
+    let depTest = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      depTest += `
+    it('should interact with dependencies correctly', function() {
+`;
+      depTest += `      // KG-informed: module depends on ${dependencies.imports.length} imports
+`;
+      depTest += `      const instance = typeof ${moduleName} === 'function'
+`;
+      depTest += `        ? new ${moduleName}()
+`;
+      depTest += `        : ${moduleName};
+`;
+      depTest += `      expect(instance).to.exist;
+`;
+      depTest += `    });
+`;
+    }
+    let callerTest = "";
+    if (dependencies && dependencies.importedBy.length > 0) {
+      callerTest += `
+    it('should expose stable API for ${dependencies.importedBy.length} consumers', function() {
+`;
+      callerTest += `      // KG-informed: used by ${dependencies.importedBy.slice(0, 3).join(", ")}
+`;
+      callerTest += `      const publicKeys = Object.keys(typeof ${moduleName} === 'function'
+`;
+      callerTest += `        ? ${moduleName}.prototype || {}
+`;
+      callerTest += `        : ${moduleName});
+`;
+      callerTest += `      expect(publicKeys.length).to.be.greaterThan(0);
+`;
+      callerTest += `    });
+`;
+    }
     return `${patternComment}import { expect } from 'chai';
-import { ${moduleName} } from '${importPath}';
+${sinonImport}import { ${moduleName} } from '${importPath}';
 
 describe('${moduleName}', function() {
   describe('${testType} tests', function() {
-    it('should be defined', function() {
+${stubSetup}${stubTeardown}${similarityComment}    it('should be defined', function() {
       expect(${moduleName}).to.not.be.undefined;
     });
 
@@ -39124,7 +39471,7 @@ describe('${moduleName}', function() {
           : ${moduleName};
         return instance;
       }).to.not.throw();
-    });
+    });${depTest}${callerTest}
   });
 });
 `;
@@ -39172,7 +39519,7 @@ var PytestGenerator = class extends BaseTestGenerator {
    * Generate complete test file from analysis
    */
   generateTests(context) {
-    const { moduleName, importPath, testType, patterns, analysis } = context;
+    const { moduleName, importPath, testType, patterns, analysis, dependencies } = context;
     if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
       return this.generateStubTests(context);
     }
@@ -39180,8 +39527,18 @@ var PytestGenerator = class extends BaseTestGenerator {
     const exports = this.extractExports(analysis.functions, analysis.classes);
     const pythonImport = importPath.replace(/\//g, ".").replace(/\.(ts|js)$/, "");
     const importStatement = exports.length > 0 ? `from ${pythonImport} import ${exports.join(", ")}` : `import ${pythonImport} as ${moduleName}`;
+    let mockImport = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      mockImport = `from unittest.mock import patch, MagicMock
+`;
+    }
+    const depsToMock = dependencies?.imports.slice(0, 5) || [];
+    const patchDecorators = depsToMock.map((dep) => {
+      const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
+      return `@patch('${depModule}')`;
+    });
     let code = `${patternComment}import pytest
-${importStatement}
+${mockImport}${importStatement}
 
 
 class Test${this.pascalCase(moduleName)}:
@@ -39189,7 +39546,7 @@ class Test${this.pascalCase(moduleName)}:
 
 `;
     for (const fn of analysis.functions) {
-      code += this.generateFunctionTests(fn, testType);
+      code += this.generateFunctionTestsWithPatches(fn, testType, patchDecorators);
     }
     for (const cls of analysis.classes) {
       code += this.generateClassTests(cls, testType);
@@ -39200,8 +39557,18 @@ class Test${this.pascalCase(moduleName)}:
    * Generate tests for a standalone function
    */
   generateFunctionTests(fn, _testType) {
+    return this.generateFunctionTestsWithPatches(fn, _testType, []);
+  }
+  /**
+   * Generate tests for a function with @patch decorators from KG dependencies
+   */
+  generateFunctionTestsWithPatches(fn, _testType, patchDecorators) {
     const validParams = fn.parameters.map((p74) => this.generatePythonTestValue(p74)).join(", ");
-    let code = `    def test_${fn.name}_valid_input(self):
+    const mockParams = patchDecorators.map((_56, i58) => `mock_dep_${i58}`).reverse().join(", ");
+    const allParams = mockParams ? `self, ${mockParams}` : "self";
+    const patchPrefix = patchDecorators.map((d74) => `    ${d74}
+`).join("");
+    let code = `${patchPrefix}    def test_${fn.name}_valid_input(${allParams}):
 `;
     code += `        """Test ${fn.name} with valid input"""
 `;
@@ -39212,7 +39579,7 @@ class Test${this.pascalCase(moduleName)}:
 `;
     for (const param of fn.parameters) {
       if (!param.optional && param.type?.includes("str")) {
-        code += `    def test_${fn.name}_empty_${param.name}(self):
+        code += `${patchPrefix}    def test_${fn.name}_empty_${param.name}(${allParams}):
 `;
         code += `        """Test ${fn.name} with empty ${param.name}"""
 `;
@@ -39267,21 +39634,84 @@ class Test${cls.name}:
    * Generate stub tests when no AST analysis is available
    */
   generateStubTests(context) {
-    const { moduleName, importPath, testType, patterns } = context;
+    const { moduleName, importPath, testType, patterns, dependencies, similarCode } = context;
     const patternComment = this.generatePythonPatternComment(patterns);
     const isAsync = patterns.some(
       (p74) => p74.name.toLowerCase().includes("async") || p74.name.toLowerCase().includes("promise")
     );
     const asyncDecorator = isAsync ? "@pytest.mark.asyncio\n    " : "";
     const asyncDef = isAsync ? "async def" : "def";
+    let mockImports = "";
+    let mockPatches = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      mockImports = `from unittest.mock import patch, MagicMock
+`;
+      const depsToMock = dependencies.imports.slice(0, 5);
+      for (const dep of depsToMock) {
+        const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
+        mockPatches += `    @patch('${depModule}')
+`;
+      }
+    }
+    let similarityComment = "";
+    if (similarCode && similarCode.snippets.length > 0) {
+      similarityComment = `    # KG: Similar modules found - consider testing shared patterns:
+`;
+      for (const s70 of similarCode.snippets.slice(0, 3)) {
+        similarityComment += `    #   - ${s70.file} (${(s70.score * 100).toFixed(0)}% similar)
+`;
+      }
+      similarityComment += `
+`;
+    }
+    let depTests = "";
+    if (dependencies && dependencies.imports.length > 0) {
+      depTests += `
+    def test_dependencies_importable(self):
+`;
+      depTests += `        """Verify all dependencies are importable (KG-informed)."""
+`;
+      for (const dep of dependencies.imports.slice(0, 5)) {
+        const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
+        depTests += `        import importlib
+`;
+        depTests += `        mod = importlib.import_module('${depModule}')
+`;
+        depTests += `        assert mod is not None
+`;
+      }
+      depTests += `
+    def test_dependency_interactions(self):
+`;
+      depTests += `        """Test module interactions with its dependencies (KG-informed)."""
+`;
+      depTests += `        # Module should handle dependency failures gracefully
+`;
+      depTests += `        assert ${moduleName} is not None
+`;
+      depTests += `        assert hasattr(${moduleName}, '__name__') or hasattr(${moduleName}, '__class__')
+`;
+    }
+    let callerTests = "";
+    if (dependencies && dependencies.importedBy.length > 0) {
+      callerTests += `
+    def test_public_api_surface(self):
+`;
+      callerTests += `        """Verify public API used by ${dependencies.importedBy.length} consumers (KG-informed)."""
+`;
+      callerTests += `        public_attrs = [a for a in dir(${moduleName}) if not a.startswith('_')]
+`;
+      callerTests += `        assert len(public_attrs) > 0, "Module should expose public API"
+`;
+    }
     return `${patternComment}import pytest
-from ${importPath} import ${moduleName}
+${mockImports}from ${importPath} import ${moduleName}
 
 
 class Test${this.pascalCase(moduleName)}:
     """${testType} tests for ${moduleName}"""
 
-    def test_is_defined(self):
+${similarityComment}    def test_is_defined(self):
         """Verify the module is properly exported and defined."""
         assert ${moduleName} is not None
 
@@ -39315,7 +39745,7 @@ class Test${this.pascalCase(moduleName)}:
         except TypeError:
             # Expected if constructor requires arguments
             pass
-`;
+${depTests}${callerTests}`;
   }
   /**
    * Generate coverage-focused tests for specific lines
@@ -40333,10 +40763,46 @@ var TestGeneratorService = class {
    * Enhance generated test code using LLM
    * Adds edge cases, improves assertions, and adds documentation
    */
-  async enhanceTestWithLLM(testCode, sourceCode, analysis) {
+  async enhanceTestWithLLM(testCode, sourceCode, analysis, context) {
     if (!this.llmRouter) return testCode;
     try {
-      const prompt = this.buildTestEnhancementPrompt(testCode, sourceCode, analysis);
+      let prompt = this.buildTestEnhancementPrompt(testCode, sourceCode, analysis);
+      if (context?.dependencies) {
+        prompt += `
+## Dependency Context (from Knowledge Graph):
+`;
+        if (context.dependencies.imports.length > 0) {
+          prompt += `- Imports: ${context.dependencies.imports.join(", ")}
+`;
+          prompt += `  \u2192 Generate mock declarations for these dependencies
+`;
+        }
+        if (context.dependencies.importedBy.length > 0) {
+          prompt += `- Imported by: ${context.dependencies.importedBy.join(", ")}
+`;
+          prompt += `  \u2192 Focus tests on the public API surface these consumers use
+`;
+        }
+        if (context.dependencies.callers.length > 0) {
+          prompt += `- Called by: ${context.dependencies.callers.join(", ")}
+`;
+        }
+        if (context.dependencies.callees.length > 0) {
+          prompt += `- Calls: ${context.dependencies.callees.join(", ")}
+`;
+        }
+      }
+      if (context?.similarCode && context.similarCode.snippets.length > 0) {
+        prompt += `
+## Similar Code Patterns (from Knowledge Graph):
+`;
+        for (const s70 of context.similarCode.snippets.slice(0, 3)) {
+          prompt += `- ${s70.file} (similarity: ${(s70.score * 100).toFixed(0)}%): ${s70.snippet}
+`;
+        }
+        prompt += `  \u2192 Use similar patterns as templates for assertions
+`;
+      }
       const modelId = this.getModelForTier(this.config.llmModelTier);
       const response = await this.llmRouter.chat({
         messages: [
@@ -40576,6 +41042,15 @@ ${sourceCode}
       codeAnalysis = this.analyzeSourceCode(sourceContent, sourceFile);
     } catch {
     }
+    let dependencies;
+    let similarCode;
+    if (this.memory && sourceContent) {
+      const hasKGVectors = await this.hasKGVectors();
+      if (hasKGVectors) {
+        dependencies = await this.queryKGDependencies(sourceFile, sourceContent);
+        similarCode = await this.queryKGSimilarCode(sourceContent);
+      }
+    }
     const generator = this.generatorFactory.create(framework);
     const moduleName = this.extractModuleName(sourceFile);
     const importPath = this.getImportPath(sourceFile);
@@ -40584,11 +41059,13 @@ ${sourceCode}
       importPath,
       testType,
       patterns: applicablePatterns,
-      analysis: codeAnalysis ?? void 0
+      analysis: codeAnalysis ?? void 0,
+      dependencies,
+      similarCode
     };
     let testCode = generator.generateTests(context);
     if (this.isLLMEnhancementAvailable() && sourceContent) {
-      testCode = await this.enhanceTestWithLLM(testCode, sourceContent, codeAnalysis);
+      testCode = await this.enhanceTestWithLLM(testCode, sourceContent, codeAnalysis, context);
     }
     const test = {
       id: v4_default(),
@@ -40783,6 +41260,107 @@ ${sourceCode}
     return complexity;
   }
   // ============================================================================
+  // Private Helper Methods - Knowledge Graph Queries
+  // ============================================================================
+  /**
+   * Check if KG vectors exist by probing a vector search.
+   * Returns true if vectorSearch returns any results (indicating indexed code exists).
+   */
+  async hasKGVectors() {
+    try {
+      const probe = new Array(768).fill(0);
+      probe[0] = 1;
+      const results = await this.memory.vectorSearch(probe, 1);
+      return results.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Query KG for dependency information about a file.
+   * Extracts imports from source and cross-references with KG vector index
+   * to find which indexed modules this file depends on and which depend on it.
+   */
+  async queryKGDependencies(filePath, sourceContent) {
+    try {
+      const imports = [];
+      const importedBy = [];
+      const callees = [];
+      const callers = [];
+      const tsImports = sourceContent.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g);
+      const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+      for (const match of tsImports) {
+        imports.push(match[1]);
+      }
+      for (const match of pyImports) {
+        imports.push(match[1] || match[2]);
+      }
+      const normalizedPath = filePath.replace(/\\/g, "/");
+      const baseName = normalizedPath.split("/").pop()?.replace(/\.(ts|js|tsx|jsx|py)$/, "") || "";
+      const nodeKeys = await this.memory.search(`code-intelligence:kg:node:*${baseName}*`, 50);
+      for (const key of nodeKeys) {
+        if (!key.includes(baseName)) continue;
+        const parts = key.split(":");
+        const nodeType = parts[parts.length - 2];
+        const nodeName = parts[parts.length - 1];
+        if (nodeType === "function") {
+          callees.push(nodeName);
+        }
+      }
+      if (imports.length === 0 && importedBy.length === 0 && callees.length === 0 && callers.length === 0) {
+        return void 0;
+      }
+      return { imports, importedBy, callees, callers };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Query KG for semantically similar code snippets.
+   * Uses vector search against the persisted vectors table.
+   * KG nodes are stored as vectors with IDs like code-intelligence:kg:node:*
+   */
+  async queryKGSimilarCode(sourceContent) {
+    try {
+      const embedding = this.generatePseudoEmbedding(sourceContent);
+      const results = await this.memory.vectorSearch(embedding, 5);
+      if (results.length === 0) return void 0;
+      const snippets = [];
+      for (const result of results) {
+        if (result.score < 0.1) continue;
+        const metadata = result.metadata;
+        const file = metadata?.file || result.key;
+        const snippet = metadata?.name || metadata?.type || result.key.split(":").pop() || "";
+        snippets.push({ file, snippet, score: result.score });
+      }
+      return snippets.length > 0 ? { snippets } : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Generate a simple pseudo-embedding for vector search.
+   * Uses token-based feature extraction similar to semantic-analyzer.
+   */
+  generatePseudoEmbedding(code) {
+    const dimension = 768;
+    const embedding = new Array(dimension).fill(0);
+    const tokens = code.split(/[^a-zA-Z0-9_$]+/).filter((t50) => t50.length > 1);
+    for (let i58 = 0; i58 < tokens.length; i58++) {
+      const token = tokens[i58];
+      for (let j52 = 0; j52 < token.length && j52 < embedding.length; j52++) {
+        embedding[(i58 + j52) % dimension] += token.charCodeAt(j52) / 1e3;
+      }
+    }
+    const magnitude2 = Math.sqrt(embedding.reduce((sum, v62) => sum + v62 * v62, 0));
+    if (magnitude2 > 0) {
+      for (let i58 = 0; i58 < dimension; i58++) {
+        embedding[i58] /= magnitude2;
+      }
+    }
+    return embedding;
+  }
+  // ============================================================================
   // Private Helper Methods - Utility Functions
   // ============================================================================
   async findApplicablePatterns(sourceFile, requestedPatterns) {
@@ -42703,6 +43281,7 @@ var TypeScriptASTParser = class {
 // src/learning/qe-hooks.ts
 init_error_utils();
 init_logging();
+init_qe_patterns();
 var logger6 = LoggerFactory.create("qe-hooks");
 var QE_HOOK_EVENTS = {
   // Test lifecycle
@@ -85572,7 +86151,35 @@ import { join as join10, extname as extname3 } from "path";
 // src/domains/code-intelligence/services/metric-collector/interfaces.ts
 var DEFAULT_METRIC_CONFIG = {
   timeout: 6e4,
-  excludeDirs: ["node_modules", "dist", "coverage", "build", ".git", "vendor", "target"],
+  excludeDirs: [
+    // JS/TS ecosystem
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".nyc_output",
+    ".next",
+    ".nuxt",
+    ".output",
+    // Python ecosystem
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".eggs",
+    "*.egg-info",
+    // Rust / Java / Go
+    "target",
+    ".gradle",
+    "vendor",
+    ".bundle",
+    // General
+    ".git",
+    ".svn",
+    ".hg"
+  ],
   testPatterns: ["**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js"],
   enableCache: true,
   cacheTTL: 3e5
@@ -85580,7 +86187,7 @@ var DEFAULT_METRIC_CONFIG = {
 
 // src/domains/code-intelligence/services/metric-collector/loc-counter.ts
 import { execSync as execSync3, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join8, extname } from "path";
 init_safe_json();
 async function countLOC(projectPath, config = {}) {
@@ -85724,22 +86331,35 @@ function getLanguageForExtension(ext) {
 function manualLOCCount(projectPath, config) {
   const byLanguage = {};
   let total = 0;
-  function walkDirectory2(dirPath) {
-    if (!existsSync6(dirPath)) {
+  const excludeSet = new Set(config.excludeDirs);
+  const MAX_FILE_SIZE = 2 * 1024 * 1024;
+  function walkDirectory2(dirPath, depth) {
+    if (!existsSync6(dirPath) || depth > 20) {
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dirPath, { withFileTypes: true });
+    } catch {
       return;
     }
-    const entries = readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = join8(dirPath, entry.name);
       if (entry.isDirectory()) {
-        if (config.excludeDirs.includes(entry.name)) {
+        if (excludeSet.has(entry.name) || entry.name.startsWith(".")) {
           continue;
         }
-        walkDirectory2(fullPath);
+        walkDirectory2(fullPath, depth + 1);
       } else if (entry.isFile()) {
         const ext = extname(entry.name);
         const language = getLanguageForExtension(ext);
         if (language) {
+          try {
+            const stat6 = statSync2(fullPath);
+            if (stat6.size > MAX_FILE_SIZE) continue;
+          } catch {
+            continue;
+          }
           const lines = countFileLines(fullPath);
           byLanguage[language] = (byLanguage[language] || 0) + lines;
           total += lines;
@@ -85747,11 +86367,11 @@ function manualLOCCount(projectPath, config) {
       }
     }
   }
-  walkDirectory2(projectPath);
+  walkDirectory2(projectPath, 0);
   return {
     total,
     byLanguage,
-    source: "fallback",
+    source: "node-native",
     excludedDirs: config.excludeDirs
   };
 }
@@ -86382,12 +87002,19 @@ var MetricCollectorService = class {
     const toolsUsed = [];
     if (loc.source !== "fallback") toolsUsed.push(loc.source);
     if (tests.source !== "fallback") toolsUsed.push(tests.source);
+    const locAccuracy = loc.source === "fallback" ? "approximate" : "accurate";
+    const testAccuracy = tests.source === "fallback" ? "approximate" : "accurate";
     const metrics = {
       loc,
       tests,
       patterns,
       collectedAt: /* @__PURE__ */ new Date(),
-      toolsUsed
+      toolsUsed,
+      accuracy: {
+        loc: locAccuracy,
+        tests: testAccuracy,
+        overall: locAccuracy === "accurate" && testAccuracy === "accurate" ? "accurate" : "approximate"
+      }
     };
     if (this.config.enableCache) {
       this.setInCache(cacheKey, metrics);
@@ -88617,9 +89244,15 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
     try {
       console.log(`[CodeIntelligence] Collecting real metrics for ${projectPath}`);
       const metrics = await this.metricCollector.collectAll(projectPath);
+      const toolsLabel = metrics.toolsUsed.length > 0 ? metrics.toolsUsed.join(", ") : metrics.loc.source === "node-native" ? "node-native" : "fallback";
       console.log(
-        `[CodeIntelligence] Real metrics collected: ${metrics.loc.total} LOC, ${metrics.tests.total} tests, tools: ${metrics.toolsUsed.join(", ") || "fallback"}`
+        `[CodeIntelligence] Real metrics collected: ${metrics.loc.total} LOC, ${metrics.tests.total} tests, tools: ${toolsLabel}`
       );
+      if (metrics.loc.source === "node-native") {
+        console.log(
+          `[CodeIntelligence] Using Node.js-native line counter (no cloc/tokei needed)`
+        );
+      }
       await this.storeProjectMetricsInMemory(projectPath, metrics);
       if (this.config.publishEvents) {
         const event = createEvent(
@@ -132322,13 +132955,58 @@ function parseLcovInfo(content) {
 async function discoverSourceFiles(targetPath, options = {}) {
   const files = [];
   const { includeTests = true, languages } = options;
-  let extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  let extensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    // JavaScript/TypeScript
+    ".py",
+    ".pyw",
+    // Python
+    ".go",
+    // Go
+    ".rs",
+    // Rust
+    ".java",
+    ".kt",
+    ".kts",
+    // Java/Kotlin
+    ".rb",
+    // Ruby
+    ".cs",
+    // C#
+    ".php",
+    // PHP
+    ".swift",
+    // Swift
+    ".c",
+    ".h",
+    ".cpp",
+    ".hpp",
+    ".cc",
+    // C/C++
+    ".scala"
+    // Scala
+  ];
   if (languages && languages.length > 0) {
     extensions = [];
     for (const lang of languages) {
       if (lang === "typescript") extensions.push(".ts", ".tsx");
       if (lang === "javascript") extensions.push(".js", ".jsx", ".mjs", ".cjs");
-      if (lang === "python") extensions.push(".py");
+      if (lang === "python") extensions.push(".py", ".pyw");
+      if (lang === "go") extensions.push(".go");
+      if (lang === "rust") extensions.push(".rs");
+      if (lang === "java") extensions.push(".java");
+      if (lang === "kotlin") extensions.push(".kt", ".kts");
+      if (lang === "ruby") extensions.push(".rb");
+      if (lang === "csharp" || lang === "c#") extensions.push(".cs");
+      if (lang === "php") extensions.push(".php");
+      if (lang === "swift") extensions.push(".swift");
+      if (lang === "c" || lang === "cpp" || lang === "c++") extensions.push(".c", ".h", ".cpp", ".hpp", ".cc");
+      if (lang === "scala") extensions.push(".scala");
     }
   }
   async function walkDir(dir) {
@@ -132337,7 +133015,23 @@ async function discoverSourceFiles(targetPath, options = {}) {
       for (const entry of entries) {
         const fullPath = path16.join(dir, entry.name);
         if (entry.isDirectory()) {
-          if (["node_modules", ".git", "dist", "build", "coverage", ".nyc_output"].includes(entry.name)) {
+          if ([
+            "node_modules",
+            ".git",
+            "dist",
+            "build",
+            "coverage",
+            ".nyc_output",
+            "__pycache__",
+            ".venv",
+            "venv",
+            ".tox",
+            ".mypy_cache",
+            "target",
+            ".gradle",
+            "vendor",
+            ".bundle"
+          ].includes(entry.name)) {
             continue;
           }
           await walkDir(fullPath);
@@ -132503,7 +133197,24 @@ var DomainTaskExecutor = class {
         } else if (payload.filePath) {
           sourceFiles = [payload.filePath];
         } else if (payload.sourceCode) {
-          const tempPath = `/tmp/aqe-temp-${v4_default()}.ts`;
+          const langExtMap = {
+            python: ".py",
+            typescript: ".ts",
+            javascript: ".js",
+            go: ".go",
+            rust: ".rs",
+            java: ".java",
+            ruby: ".rb",
+            kotlin: ".kt",
+            csharp: ".cs",
+            php: ".php",
+            swift: ".swift",
+            cpp: ".cpp",
+            c: ".c",
+            scala: ".scala"
+          };
+          const ext = langExtMap[payload.language?.toLowerCase() || "typescript"] || ".ts";
+          const tempPath = `/tmp/aqe-temp-${v4_default()}${ext}`;
           await fs15.writeFile(tempPath, payload.sourceCode, "utf-8");
           sourceFiles = [tempPath];
         }
@@ -132619,12 +133330,96 @@ var DomainTaskExecutor = class {
               sast: payload.sast !== false,
               dast: payload.dast || false
             },
-            warning: `No TypeScript/JavaScript files found in ${targetPath}`
+            warning: `No source files found in ${targetPath}`
           });
         }
-        const filePathObjects = filesToScan.map((filePath) => FilePath.create(filePath));
+        const jstsFiles = filesToScan.filter((f74) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f74));
+        const otherFiles = filesToScan.filter((f74) => !/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f74));
+        const crossLangVulns = [];
+        for (const filePath of otherFiles) {
+          try {
+            const content = await fs15.readFile(filePath, "utf-8");
+            const lines = content.split("\n");
+            const relPath = filePath.startsWith(targetPath) ? filePath.slice(targetPath.length).replace(/^\//, "") : filePath;
+            const secretPatterns = [
+              { regex: /(?:secret|password|api_key|apikey|token|jwt_secret|private_key)\s*[=:]\s*['"][^'"]{8,}['"]/gi, title: "Hardcoded secret", severity: "critical" },
+              { regex: /(?:AWS_SECRET|GITHUB_TOKEN|SLACK_TOKEN)\s*[=:]\s*['"][^'"]+['"]/gi, title: "Hardcoded cloud credential", severity: "critical" }
+            ];
+            for (const pattern of secretPatterns) {
+              for (let i58 = 0; i58 < lines.length; i58++) {
+                if (pattern.regex.test(lines[i58])) {
+                  crossLangVulns.push({
+                    title: pattern.title,
+                    severity: pattern.severity,
+                    location: { file: relPath, line: i58 + 1 },
+                    description: `Potential hardcoded secret found at line ${i58 + 1}`,
+                    category: "sensitive-data"
+                  });
+                }
+                pattern.regex.lastIndex = 0;
+              }
+            }
+            const sqlPatterns = /(?:execute|query|cursor\.execute)\s*\(\s*(?:f['"]|['"].*%s|['"].*\+\s*\w)/gi;
+            for (let i58 = 0; i58 < lines.length; i58++) {
+              if (sqlPatterns.test(lines[i58])) {
+                crossLangVulns.push({
+                  title: "Potential SQL injection",
+                  severity: "high",
+                  location: { file: relPath, line: i58 + 1 },
+                  description: "String interpolation in SQL query \u2014 use parameterized queries",
+                  category: "injection"
+                });
+              }
+              sqlPatterns.lastIndex = 0;
+            }
+            if (/allow_origins\s*=\s*\[?\s*['"]?\*['"]?\s*\]?/i.test(content)) {
+              crossLangVulns.push({
+                title: "CORS wildcard origin",
+                severity: "high",
+                location: { file: relPath, line: lines.findIndex((l75) => /allow_origins/i.test(l75)) + 1 },
+                description: "CORS configured with wildcard (*) origin \u2014 restrict to specific domains",
+                category: "security-misconfiguration"
+              });
+            }
+            if (/(?:DEBUG|debug)\s*[=:]\s*(?:True|true|1)/i.test(content)) {
+              crossLangVulns.push({
+                title: "Debug mode enabled",
+                severity: "medium",
+                location: { file: relPath, line: lines.findIndex((l75) => /DEBUG\s*[=:]\s*(?:True|true|1)/i.test(l75)) + 1 },
+                description: "Debug mode should be disabled in production",
+                category: "security-misconfiguration"
+              });
+            }
+            if (/\b(?:eval|exec)\s*\(/i.test(content)) {
+              crossLangVulns.push({
+                title: "Dangerous eval/exec usage",
+                severity: "high",
+                location: { file: relPath, line: lines.findIndex((l75) => /\b(?:eval|exec)\s*\(/.test(l75)) + 1 },
+                description: "eval/exec can lead to code injection \u2014 avoid using with user input",
+                category: "injection"
+              });
+            }
+          } catch {
+          }
+        }
+        const depManifests = ["requirements.txt", "pyproject.toml", "Gemfile", "go.mod", "Cargo.toml"];
+        for (const manifest of depManifests) {
+          const manifestPath = path16.join(targetPath, manifest);
+          try {
+            await fs15.access(manifestPath);
+            crossLangVulns.push({
+              title: "Dependency audit recommended",
+              severity: "informational",
+              location: { file: manifest, line: 1 },
+              description: `Found ${manifest} \u2014 run language-specific dependency audit (e.g., pip-audit, npm audit, cargo audit)`,
+              category: "dependencies"
+            });
+          } catch {
+          }
+        }
+        const filePathObjects = jstsFiles.map((filePath) => FilePath.create(filePath));
         let sastResult = null;
-        if (payload.sast !== false) {
+        if (payload.sast !== false && filePathObjects.length > 0) {
           const result = await scanner.scanFiles(filePathObjects);
           if (result.success) {
             sastResult = result.value;
@@ -132641,16 +133436,24 @@ var DomainTaskExecutor = class {
             dastResult = result.value;
           }
         }
+        const crossLangSeverityCounts = {
+          critical: crossLangVulns.filter((v62) => v62.severity === "critical").length,
+          high: crossLangVulns.filter((v62) => v62.severity === "high").length,
+          medium: crossLangVulns.filter((v62) => v62.severity === "medium").length,
+          low: crossLangVulns.filter((v62) => v62.severity === "low").length,
+          informational: crossLangVulns.filter((v62) => v62.severity === "informational").length
+        };
         const summary = {
-          critical: (sastResult?.summary?.critical || 0) + (dastResult?.summary?.critical || 0),
-          high: (sastResult?.summary?.high || 0) + (dastResult?.summary?.high || 0),
-          medium: (sastResult?.summary?.medium || 0) + (dastResult?.summary?.medium || 0),
-          low: (sastResult?.summary?.low || 0) + (dastResult?.summary?.low || 0),
-          informational: (sastResult?.summary?.informational || 0) + (dastResult?.summary?.informational || 0)
+          critical: (sastResult?.summary?.critical || 0) + (dastResult?.summary?.critical || 0) + crossLangSeverityCounts.critical,
+          high: (sastResult?.summary?.high || 0) + (dastResult?.summary?.high || 0) + crossLangSeverityCounts.high,
+          medium: (sastResult?.summary?.medium || 0) + (dastResult?.summary?.medium || 0) + crossLangSeverityCounts.medium,
+          low: (sastResult?.summary?.low || 0) + (dastResult?.summary?.low || 0) + crossLangSeverityCounts.low,
+          informational: (sastResult?.summary?.informational || 0) + (dastResult?.summary?.informational || 0) + crossLangSeverityCounts.informational
         };
         const allVulns = [
           ...sastResult?.vulnerabilities || [],
-          ...dastResult?.vulnerabilities || []
+          ...dastResult?.vulnerabilities || [],
+          ...crossLangVulns
         ];
         const topVulnerabilities = allVulns.sort((a37, b68) => {
           const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, informational: 4 };
@@ -132677,7 +133480,12 @@ var DomainTaskExecutor = class {
             dast: payload.dast || false
           },
           filesScanned: filesToScan.length,
-          coverage: sastResult?.coverage
+          jstsFilesScanned: jstsFiles.length,
+          otherFilesScanned: otherFiles.length,
+          coverage: sastResult?.coverage,
+          ...otherFiles.length > 0 && jstsFiles.length === 0 ? {
+            note: "Non-JS/TS files were scanned with cross-language pattern matching. For deeper analysis, use language-specific security tools."
+          } : {}
         });
       } catch (error) {
         return err(toError(error));
@@ -132700,9 +133508,9 @@ var DomainTaskExecutor = class {
             edgesCreated: 0,
             target: targetPath,
             incremental: payload.incremental || false,
-            languages: payload.languages || ["typescript", "javascript"],
+            languages: payload.languages || [],
             duration: Date.now() - startTime,
-            warning: `No source files found in ${targetPath}`
+            warning: `No source files found in ${targetPath}. Searched for: TypeScript, JavaScript, Python, Go, Rust, Java, Ruby, C/C++, and more.`
           });
         }
         const result = await kg.index({
@@ -132716,11 +133524,35 @@ var DomainTaskExecutor = class {
         }
         const indexResult = result.value;
         const detectedLanguages = /* @__PURE__ */ new Set();
+        const extToLang = {
+          ts: "typescript",
+          tsx: "typescript",
+          js: "javascript",
+          jsx: "javascript",
+          mjs: "javascript",
+          cjs: "javascript",
+          py: "python",
+          pyw: "python",
+          go: "go",
+          rs: "rust",
+          java: "java",
+          kt: "kotlin",
+          kts: "kotlin",
+          rb: "ruby",
+          cs: "csharp",
+          php: "php",
+          swift: "swift",
+          c: "c",
+          h: "c",
+          cpp: "cpp",
+          hpp: "cpp",
+          cc: "cpp",
+          scala: "scala"
+        };
         for (const file of filesToIndex) {
           const ext = path16.extname(file).slice(1);
-          if (["ts", "tsx"].includes(ext)) detectedLanguages.add("typescript");
-          if (["js", "jsx", "mjs", "cjs"].includes(ext)) detectedLanguages.add("javascript");
-          if (ext === "py") detectedLanguages.add("python");
+          const lang = extToLang[ext];
+          if (lang) detectedLanguages.add(lang);
         }
         return ok({
           filesIndexed: indexResult.filesIndexed,
@@ -132818,25 +133650,103 @@ var DomainTaskExecutor = class {
     });
     this.taskHandlers.set("predict-defects", async (task) => {
       const payload = task.payload;
-      return ok({
-        predictedDefects: [
-          {
-            file: `${payload.target}/complex-module.ts`,
-            probability: 0.78,
-            reason: "High cyclomatic complexity combined with low test coverage"
-          },
-          {
-            file: `${payload.target}/legacy-handler.ts`,
-            probability: 0.65,
-            reason: "Frequent changes in recent commits with error-prone patterns"
+      try {
+        const targetPath = payload.target || process.cwd();
+        const minConfidence = payload.minConfidence || 0.5;
+        const sourceFiles = await discoverSourceFiles(targetPath, { includeTests: false });
+        if (sourceFiles.length === 0) {
+          return ok({
+            predictedDefects: [],
+            riskScore: 0,
+            recommendations: [
+              `No source files found in ${targetPath}. Ensure the path contains source code files.`
+            ],
+            warning: `No source files found in ${targetPath}`,
+            filesAnalyzed: 0
+          });
+        }
+        const predictedDefects = [];
+        for (const filePath of sourceFiles) {
+          try {
+            const content = await fs15.readFile(filePath, "utf-8");
+            const lines = content.split("\n");
+            const lineCount = lines.length;
+            let probability = 0;
+            const reasons = [];
+            if (lineCount > 500) {
+              probability += 0.25;
+              reasons.push(`Large file (${lineCount} lines)`);
+            } else if (lineCount > 300) {
+              probability += 0.15;
+              reasons.push(`Medium-large file (${lineCount} lines)`);
+            }
+            const branchKeywords = content.match(/\b(if|else|switch|case|for|while|catch|&&|\|\|)\b/g) || [];
+            const branchDensity = branchKeywords.length / Math.max(lineCount, 1);
+            if (branchDensity > 0.15) {
+              probability += 0.25;
+              reasons.push(`High branch density (${branchKeywords.length} branches in ${lineCount} lines)`);
+            } else if (branchDensity > 0.08) {
+              probability += 0.1;
+              reasons.push("Moderate branch complexity");
+            }
+            const maxIndent = Math.max(...lines.map((l75) => {
+              const match = l75.match(/^(\s*)/);
+              return match ? match[1].length : 0;
+            }));
+            if (maxIndent > 20) {
+              probability += 0.15;
+              reasons.push("Deep nesting detected");
+            }
+            const debtComments = (content.match(/\b(TODO|FIXME|HACK|XXX|WORKAROUND)\b/gi) || []).length;
+            if (debtComments > 3) {
+              probability += 0.15;
+              reasons.push(`${debtComments} technical debt markers`);
+            }
+            const functionStarts = (content.match(/\b(function|def|func|async)\b/g) || []).length;
+            if (functionStarts > 0 && lineCount / functionStarts > 80) {
+              probability += 0.1;
+              reasons.push("Potentially long functions");
+            }
+            probability = Math.min(probability, 0.95);
+            if (probability >= minConfidence) {
+              const relativePath = filePath.startsWith(targetPath) ? filePath.slice(targetPath.length).replace(/^\//, "") : filePath;
+              predictedDefects.push({
+                file: relativePath,
+                probability: Math.round(probability * 100) / 100,
+                reason: reasons.join("; ")
+              });
+            }
+          } catch {
           }
-        ],
-        riskScore: 42,
-        recommendations: [
-          "Add integration tests for complex-module.ts",
-          "Refactor legacy-handler.ts to reduce complexity"
-        ]
-      });
+        }
+        predictedDefects.sort((a37, b68) => b68.probability - a37.probability);
+        const avgProb = predictedDefects.length > 0 ? predictedDefects.reduce((sum, d74) => sum + d74.probability, 0) / predictedDefects.length : 0;
+        const riskScore = Math.round(avgProb * 100);
+        const recommendations = [];
+        if (predictedDefects.length > 0) {
+          recommendations.push(`${predictedDefects.length} files flagged for potential defects out of ${sourceFiles.length} analyzed`);
+          const topFile = predictedDefects[0];
+          recommendations.push(`Highest risk: ${topFile.file} (${Math.round(topFile.probability * 100)}%) \u2014 ${topFile.reason}`);
+        }
+        if (predictedDefects.some((d74) => d74.reason.includes("Large file"))) {
+          recommendations.push("Consider splitting large files to reduce complexity");
+        }
+        if (predictedDefects.some((d74) => d74.reason.includes("technical debt"))) {
+          recommendations.push("Address TODO/FIXME comments to reduce technical debt");
+        }
+        if (predictedDefects.length === 0) {
+          recommendations.push("No files exceeded the defect probability threshold \u2014 code looks healthy");
+        }
+        return ok({
+          predictedDefects: predictedDefects.slice(0, 20),
+          // Top 20
+          riskScore,
+          recommendations,
+          filesAnalyzed: sourceFiles.length
+        });
+      } catch (error) {
+        return err(toError(error));
+      }
     });
     this.taskHandlers.set("validate-requirements", async (task) => {
       const payload = task.payload;
@@ -137056,50 +137966,54 @@ var coverageAnalyzeConfig = {
     const learning = generateV2LearningFeedback("coverage-analyzer");
     const detailedGaps = gaps.map((gap, i58) => {
       const g67 = gap;
+      if (!g67?.file) return null;
       return {
         id: `gap-${Date.now()}-${i58}`,
-        file: g67?.file || `src/module${i58}.ts`,
-        line: g67?.lines?.[0] || 10 + i58 * 5,
-        uncoveredLines: g67?.lines || [10 + i58 * 5, 20 + i58 * 5],
-        type: g67?.type || "uncovered-line",
-        severity: g67?.severity || (i58 < 2 ? "high" : "medium"),
-        reason: g67?.reason || "Missing test case",
-        priority: g67?.priority || (i58 < 2 ? "high" : "medium"),
-        suggestion: g67?.suggestedTest || `Add test for line ${10 + i58 * 5}`,
-        suggestedTest: g67?.suggestedTest || `Add test for line ${10 + i58 * 5}`,
-        riskScore: g67?.riskScore || 0.8 - i58 * 0.1,
-        confidence: g67?.confidence || 0.85
+        file: g67.file,
+        line: g67.lines?.[0] || 0,
+        uncoveredLines: g67.lines || [],
+        type: g67.type || "uncovered-line",
+        severity: g67.severity || "medium",
+        reason: g67.reason || "Missing test case",
+        priority: g67.priority || "medium",
+        suggestion: g67.suggestedTest || "Add test coverage",
+        suggestedTest: g67.suggestedTest || "Add test coverage",
+        riskScore: g67.riskScore || 0.5,
+        confidence: g67.confidence || 0.7
       };
-    });
-    return {
-      // V2-compatible fields
-      coverageByFile: Array.from({ length: totalFiles }, (_56, i58) => {
-        const variation = (i58 % 3 - 1) * 5;
-        return {
-          file: `src/module${i58}.ts`,
-          lineCoverage: Math.max(0, Math.min(100, lineCoverage + variation)),
-          branchCoverage: Math.max(0, Math.min(100, branchCoverage + variation - 2)),
-          functionCoverage: Math.max(0, Math.min(100, functionCoverage + variation + 2))
-        };
-      }),
+    }).filter((g67) => g67 !== null);
+    const coverageByFileData = data.coverageByFile;
+    const realCoverageByFile = coverageByFileData ? coverageByFileData.map((f74) => ({
+      file: f74.file,
+      lineCoverage: f74.lineCoverage || 0,
+      branchCoverage: f74.branchCoverage || 0,
+      functionCoverage: f74.functionCoverage || 0
+    })) : [];
+    return {
+      // V2-compatible fields — only real data, no synthetic file paths
+      coverageByFile: realCoverageByFile,
       gapAnalysis: {
         totalGaps: detailedGaps.length,
         highPriority: detailedGaps.filter((g67) => g67.priority === "high").length,
         gaps: detailedGaps
       },
       trends: {
-        lineCoverageTrend: "stable",
-        branchCoverageTrend: "improving",
-        weeklyChange: 2.5
+        lineCoverageTrend: totalFiles > 0 ? "stable" : "no-data",
+        branchCoverageTrend: totalFiles > 0 ? "stable" : "no-data",
+        weeklyChange: 0
       },
-      aiInsights: {
-        recommendations: [
-          "Focus on uncovered branches in authentication module",
-          "Add edge case tests for error handling paths",
-          "Consider property-based testing for utility functions"
+      aiInsights: totalFiles > 0 ? {
+        recommendations: data.recommendations || [
+          "Run tests with coverage enabled to get accurate metrics"
         ],
         riskAssessment: lineCoverage < 70 ? "high" : lineCoverage < 85 ? "medium" : "low",
         confidence: 0.88
+      } : {
+        recommendations: [
+          "No coverage data found. Run tests with coverage first (e.g., npm test -- --coverage, or pytest --cov)"
+        ],
+        riskAssessment: "unknown",
+        confidence: 0
       },
       learning,
       // V3 fields
@@ -152819,14 +153733,22 @@ async function handleTaskOrchestrate(params) {
   }
   const { queen, workflowOrchestrator } = getFleetState();
   try {
+    const inferredDomain = params.context?.project || inferDomainFromDescription(params.task);
+    const inferredIsCritical = params.priority === "critical" || /\b(security|vulnerability|cve|owasp|critical|production|exploit)\b/i.test(params.task);
     const router = await getTaskRouter();
     const routingResult = await router.routeTask({
       task: params.task,
       codeContext: params.codeContext,
       filePaths: params.filePaths,
       manualTier: params.manualTier,
-      isCritical: params.priority === "critical",
-      domain: params.context?.project
+      isCritical: inferredIsCritical,
+      agentType: `qe-${inferredDomain}`,
+      domain: inferredDomain,
+      metadata: {
+        inferredDomain,
+        hasCodeContext: !!params.codeContext,
+        fileCount: params.filePaths?.length
+      }
     });
     const reasoningBankService = await getReasoningBankService();
     const experienceGuidance = await reasoningBankService.getExperienceGuidance(
@@ -152964,14 +153886,22 @@ async function handleTaskOrchestrate(params) {
 async function handleModelRoute(params) {
   try {
     const router = await getTaskRouter();
+    const inferredDomain = params.domain || inferDomainFromDescription(params.task);
+    const inferredIsCritical = params.isCritical ?? /\b(security|vulnerability|cve|owasp|critical|production|exploit)\b/i.test(params.task);
     const result = await router.routeTask({
       task: params.task,
       codeContext: params.codeContext,
       filePaths: params.filePaths,
       manualTier: params.manualTier,
-      isCritical: params.isCritical,
-      agentType: params.agentType,
-      domain: params.domain
+      isCritical: inferredIsCritical,
+      agentType: params.agentType || `qe-${inferredDomain}`,
+      domain: inferredDomain,
+      // Pass metadata to help the complexity analyzer
+      metadata: {
+        inferredDomain,
+        hasCodeContext: !!params.codeContext,
+        fileCount: params.filePaths?.length
+      }
     });
     return {
       success: true,
@@ -153034,6 +153964,43 @@ async function handleRoutingMetrics(params) {
     };
   }
 }
+function inferDomainFromDescription(description) {
+  const lower = description.toLowerCase();
+  if (/\b(security|vulnerabilit|cve|owasp|secret|credential|injection|xss|csrf)\b/.test(lower)) {
+    return "security-compliance";
+  }
+  if (/\b(chaos|resilience|fault.?inject|disaster|failover)\b/.test(lower)) {
+    return "chaos-resilience";
+  }
+  if (/\b(defect|bug.?predict|risk.?assess|mutation)\b/.test(lower)) {
+    return "defect-intelligence";
+  }
+  if (/\b(coverage|uncovered|gap.?analy)\b/.test(lower)) {
+    return "coverage-analysis";
+  }
+  if (/\b(quality|code.?review|maintain|tech.?debt)\b/.test(lower)) {
+    return "quality-assessment";
+  }
+  if (/\b(contract|api.?compat|breaking.?change|pact)\b/.test(lower)) {
+    return "contract-testing";
+  }
+  if (/\b(index|knowledge.?graph|semantic|code.?intel)\b/.test(lower)) {
+    return "code-intelligence";
+  }
+  if (/\b(accessib|a11y|wcag|screen.?read)\b/.test(lower)) {
+    return "visual-accessibility";
+  }
+  if (/\b(requirement|bdd|acceptance|user.?stor)\b/.test(lower)) {
+    return "requirements-validation";
+  }
+  if (/\b(generat.*test|test.*generat|write.*test|create.*test)\b/.test(lower)) {
+    return "test-generation";
+  }
+  if (/\b(run.*test|execut.*test)\b/.test(lower)) {
+    return "test-execution";
+  }
+  return "test-generation";
+}
 function inferTaskType(description) {
   const lower = description.toLowerCase();
   if (/run\s+(?:\w+\s+)*tests?/.test(lower) || /execute\s+(?:\w+\s+)*tests?/.test(lower) || lower.includes("run tests") || lower.includes("execute tests")) {
@@ -154793,7 +155760,18 @@ var MCPProtocolServer = class {
   async start() {
     await initializeConnectionPool();
     this.transport.onRequest(async (request) => {
-      return this.handleRequest(request);
+      try {
+        return await this.handleRequest(request);
+      } catch (err4) {
+        const message = err4 instanceof Error ? err4.message : String(err4);
+        console.error(`[MCP] Unhandled error in request handler: ${message}`);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: false, error: `Internal error: ${message}` })
+          }]
+        };
+      }
     });
     this.transport.onNotification(async (notification) => {
       await this.handleNotification(notification);