agentic-qe 3.7.20 → 3.7.22

package/dist/mcp/bundle.js

@@ -5151,6 +5151,9 @@ var init_console_logger = __esm({
 });
 
 // src/logging/logger-factory.ts
+function createLogger(domain, context) {
+  return LoggerFactory.create(domain, context);
+}
 var DEFAULT_FACTORY_CONFIG, LoggerFactory;
 var init_logger_factory = __esm({
   "src/logging/logger-factory.ts"() {
@@ -6180,6 +6183,33 @@ var init_better_sqlite3 = __esm({
   }
 });
 
+// src/shared/safe-db.ts
+var safe_db_exports = {};
+__export(safe_db_exports, {
+  openDatabase: () => openDatabase
+});
+function openDatabase(dbPath, opts) {
+  const readonly = opts?.readonly ?? false;
+  const fileMustExist = opts?.fileMustExist ?? false;
+  const busyTimeout = opts?.busyTimeout ?? 5e3;
+  const walMode = opts?.walMode ?? !readonly;
+  const db = new better_sqlite3_default(dbPath, {
+    readonly,
+    fileMustExist
+  });
+  db.pragma(`busy_timeout = ${busyTimeout}`);
+  if (walMode) {
+    db.pragma("journal_mode = WAL");
+  }
+  return db;
+}
+var init_safe_db = __esm({
+  "src/shared/safe-db.ts"() {
+    "use strict";
+    init_better_sqlite3();
+  }
+});
+
 // src/shared/sql-safety.ts
 function validateTableName(tableName) {
   if (!ALLOWED_TABLE_NAMES.has(tableName)) {
@@ -8952,7 +8982,7 @@ var logger3, _cachedProjectRoot, DEFAULT_UNIFIED_MEMORY_CONFIG, UnifiedMemoryMan
 var init_unified_memory = __esm({
   "src/kernel/unified-memory.ts"() {
     "use strict";
-    init_better_sqlite3();
+    init_safe_db();
     init_safe_json();
     init_error_utils();
     init_constants();
@@ -9068,13 +9098,12 @@ var init_unified_memory = __esm({
               dbSizeBefore = newest.size;
             }
           }
-          this.db = new better_sqlite3_default(this.config.dbPath);
-          if (this.config.walMode) {
-            this.db.pragma("journal_mode = WAL");
-          }
+          this.db = openDatabase(this.config.dbPath, {
+            walMode: this.config.walMode,
+            busyTimeout: this.config.busyTimeout
+          });
           this.db.pragma(`mmap_size = ${this.config.mmapSize}`);
           this.db.pragma(`cache_size = ${this.config.cacheSize}`);
-          this.db.pragma(`busy_timeout = ${this.config.busyTimeout}`);
           this.db.pragma("foreign_keys = ON");
           await this.runMigrations();
           if (dbExistedBefore && dbSizeBefore > 1e6) {
@@ -57291,6 +57320,7 @@ var init_mincut_test_optimizer = __esm({
           criticalTests.add(promotedId);
           skippableTests.delete(promotedId);
           const promotedTest = testMap.get(promotedId);
+          if (!promotedTest) continue;
           for (const file of promotedTest.coveredFiles) {
             covered.add(file);
           }
@@ -83016,33 +83046,6 @@ var init_coordinator_consensus = __esm({
   }
 });
 
-// src/shared/safe-db.ts
-var safe_db_exports = {};
-__export(safe_db_exports, {
-  openDatabase: () => openDatabase
-});
-function openDatabase(dbPath, opts) {
-  const readonly = opts?.readonly ?? false;
-  const fileMustExist = opts?.fileMustExist ?? false;
-  const busyTimeout = opts?.busyTimeout ?? 5e3;
-  const walMode = opts?.walMode ?? !readonly;
-  const db = new better_sqlite3_default(dbPath, {
-    readonly,
-    fileMustExist
-  });
-  db.pragma(`busy_timeout = ${busyTimeout}`);
-  if (walMode) {
-    db.pragma("journal_mode = WAL");
-  }
-  return db;
-}
-var init_safe_db = __esm({
-  "src/shared/safe-db.ts"() {
-    "use strict";
-    init_better_sqlite3();
-  }
-});
-
 // src/domains/code-intelligence/coordinator.ts
 var DEFAULT_CONFIG40, CodeIntelligenceCoordinator;
 var init_coordinator7 = __esm({
@@ -84551,8 +84554,10 @@ var init_scanner_types = __esm({
       dastActiveScanning: false,
       enableLLMAnalysis: true,
       // On by default - opt-out (ADR-051)
-      llmModelTier: 4
+      llmModelTier: 4,
       // Opus for security analysis (needs expert reasoning)
+      enableSemgrep: true
+      // Use semgrep when installed for real SAST
     };
   }
 });
@@ -85041,6 +85046,179 @@ var init_security_patterns = __esm({
   }
 });
 
+// src/domains/security-compliance/services/semgrep-integration.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify4 } from "util";
+import * as path14 from "path";
+async function isSemgrepAvailable() {
+  try {
+    await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getSemgrepVersion() {
+  try {
+    const { stdout } = await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function runSemgrep(config) {
+  const fullConfig = {
+    target: config.target || ".",
+    config: config.config || "auto",
+    exclude: config.exclude || ["node_modules", ".git", "dist", "build", "coverage"],
+    maxFileSize: config.maxFileSize || 5e6,
+    // 5MB
+    timeout: config.timeout || 300,
+    verbose: config.verbose || false
+  };
+  const available = await isSemgrepAvailable();
+  if (!available) {
+    return {
+      success: false,
+      findings: [],
+      errors: ["Semgrep is not installed. Install with: pip install semgrep"]
+    };
+  }
+  try {
+    const args = [
+      "scan",
+      `--config=${fullConfig.config}`,
+      "--json",
+      fullConfig.verbose ? "--verbose" : "--quiet",
+      `--max-target-bytes=${fullConfig.maxFileSize}`
+    ];
+    for (const excludePattern of fullConfig.exclude) {
+      args.push(`--exclude=${excludePattern}`);
+    }
+    args.push(fullConfig.target);
+    const timeoutMs = (fullConfig.timeout ?? 300) * 1e3;
+    const { stdout, stderr } = await execFileAsync2("semgrep", args, {
+      timeout: timeoutMs,
+      maxBuffer: 50 * 1024 * 1024,
+      // 50MB buffer for large results
+      cwd: path14.isAbsolute(fullConfig.target) ? void 0 : process.cwd()
+    });
+    const result = parseSemgrepOutput(stdout);
+    if (stderr && fullConfig.verbose) {
+      result.errors.push(stderr);
+    }
+    result.version = await getSemgrepVersion() || void 0;
+    return result;
+  } catch (error) {
+    const execError = error;
+    if (execError.stdout) {
+      try {
+        const result = parseSemgrepOutput(execError.stdout);
+        result.version = await getSemgrepVersion() || void 0;
+        return result;
+      } catch {
+      }
+    }
+    return {
+      success: false,
+      findings: [],
+      errors: [execError.message ?? String(error)]
+    };
+  }
+}
+function parseSemgrepOutput(stdout) {
+  try {
+    const parsed = safeJsonParse(stdout);
+    const results = parsed.results || parsed.findings || [];
+    const errors = parsed.errors?.map((e20) => e20.message || String(e20)) || [];
+    return {
+      success: true,
+      findings: results.map((r54) => ({
+        check_id: r54.check_id || r54.rule_id || "unknown",
+        path: r54.path,
+        start: { line: r54.start?.line || 1, col: r54.start?.col || 1 },
+        end: { line: r54.end?.line || r54.start?.line || 1, col: r54.end?.col || 1 },
+        extra: {
+          message: r54.extra?.message || r54.message || "Security issue detected",
+          severity: r54.extra?.severity || r54.severity || "WARNING",
+          lines: r54.extra?.lines || "",
+          metadata: {
+            cwe: r54.extra?.metadata?.cwe || r54.metadata?.cwe,
+            owasp: r54.extra?.metadata?.owasp || r54.metadata?.owasp,
+            category: r54.extra?.metadata?.category || r54.metadata?.category,
+            description: r54.extra?.metadata?.description || r54.metadata?.description,
+            fix: r54.extra?.metadata?.fix || r54.extra?.fix,
+            references: r54.extra?.metadata?.references || r54.metadata?.references,
+            confidence: r54.extra?.metadata?.confidence || r54.metadata?.confidence
+          }
+        }
+      })),
+      errors
+    };
+  } catch (error) {
+    return {
+      success: false,
+      findings: [],
+      errors: [`Failed to parse semgrep output: ${toErrorMessage(error)}`]
+    };
+  }
+}
+async function runSemgrepWithRules(target, rules, options) {
+  const configMapping = {
+    "owasp-top-10": "p/owasp-top-ten",
+    "cwe-sans-25": "p/cwe-top-25",
+    "nodejs-security": "p/nodejs",
+    "typescript-security": "p/typescript",
+    "javascript-security": "p/javascript",
+    "react-security": "p/react",
+    "express-security": "p/express",
+    "secrets": "p/secrets",
+    "sql-injection": "p/sql-injection",
+    "xss": "p/xss",
+    "command-injection": "p/command-injection",
+    "path-traversal": "p/path-traversal"
+  };
+  const configs = rules.map((r54) => configMapping[r54] || `p/${r54}`).join(",");
+  return runSemgrep({
+    ...options,
+    target,
+    config: configs || "auto"
+  });
+}
+function mapSemgrepSeverity(severity) {
+  const mapping = {
+    ERROR: "high",
+    WARNING: "medium",
+    INFO: "low"
+  };
+  return mapping[severity] || "medium";
+}
+function convertSemgrepFindings(findings) {
+  return findings.map((f74) => ({
+    id: f74.check_id,
+    title: f74.check_id.split(".").pop() || f74.check_id,
+    description: f74.extra.message,
+    severity: mapSemgrepSeverity(f74.extra.severity),
+    file: f74.path,
+    line: f74.start.line,
+    column: f74.start.col,
+    snippet: f74.extra.lines,
+    cweId: f74.extra.metadata?.cwe?.[0],
+    owaspCategory: f74.extra.metadata?.owasp?.[0],
+    remediation: f74.extra.metadata?.fix || "Review and fix the identified security issue",
+    references: f74.extra.metadata?.references || []
+  }));
+}
+var execFileAsync2;
+var init_semgrep_integration = __esm({
+  "src/domains/security-compliance/services/semgrep-integration.ts"() {
+    "use strict";
+    init_error_utils();
+    init_safe_json();
+    execFileAsync2 = promisify4(execFile2);
+  }
+});
+
 // src/domains/security-compliance/services/scanners/sast-scanner.ts
 var SASTScanner;
 var init_sast_scanner = __esm({
@@ -85051,6 +85229,7 @@ var init_sast_scanner = __esm({
     init_security_patterns();
     init_error_utils();
     init_safe_json();
+    init_semgrep_integration();
     SASTScanner = class {
       config;
       memory;
@@ -85072,7 +85251,9 @@ var init_sast_scanner = __esm({
         return this.scanWithRules(files, this.config.defaultRuleSets);
       }
       /**
-       * Scan with specific rule sets
+       * Scan with specific rule sets.
+       * Runs pattern-based scanning and semgrep (when available) in parallel,
+       * then merges and deduplicates results.
        */
       async scanWithRules(files, ruleSetIds) {
         const scanId = v4_default();
@@ -85088,23 +85269,26 @@ var init_sast_scanner = __esm({
           if (ruleSets.length === 0) {
             return err(new Error(`No valid rule sets found: ${ruleSetIds.join(", ")}`));
           }
-          const vulnerabilities = [];
-          let linesScanned = 0;
-          for (const file of files) {
-            const fileVulns = await this.analyzeFile(file, ruleSets);
-            vulnerabilities.push(...fileVulns.vulnerabilities);
-            linesScanned += fileVulns.linesScanned;
-          }
+          const [patternResult, semgrepVulns] = await Promise.all([
+            this.runPatternScanning(files, ruleSets),
+            this.runSemgrepScanning(files, ruleSetIds)
+          ]);
+          const vulnerabilities = this.mergeVulnerabilities(
+            patternResult.vulnerabilities,
+            semgrepVulns
+          );
+          const linesScanned = patternResult.linesScanned;
           const scanDurationMs = Date.now() - startTime;
           const summary = this.calculateSummary(
             vulnerabilities,
             files.length,
             scanDurationMs
           );
+          const patternRules = ruleSets.reduce((acc, rs2) => acc + rs2.ruleCount, 0);
           const coverage = {
             filesScanned: files.length,
             linesScanned,
-            rulesApplied: ruleSets.reduce((acc, rs2) => acc + rs2.ruleCount, 0)
+            rulesApplied: patternRules + (semgrepVulns.length > 0 ? semgrepVulns.length : 0)
           };
           await this.storeScanResults(scanId, "sast", vulnerabilities, summary);
           this.activeScans.set(scanId, "completed");
@@ -85119,6 +85303,119 @@ var init_sast_scanner = __esm({
           return err(toError(error));
         }
       }
+      /**
+       * Run pattern-based scanning on all files
+       */
+      async runPatternScanning(files, ruleSets) {
+        const vulnerabilities = [];
+        let linesScanned = 0;
+        for (const file of files) {
+          const fileVulns = await this.analyzeFile(file, ruleSets);
+          vulnerabilities.push(...fileVulns.vulnerabilities);
+          linesScanned += fileVulns.linesScanned;
+        }
+        return { vulnerabilities, linesScanned };
+      }
+      /**
+       * Run semgrep scanning when enabled and available.
+       * Returns converted vulnerabilities or empty array on failure/unavailability.
+       */
+      async runSemgrepScanning(files, ruleSetIds) {
+        if (!this.config.enableSemgrep) {
+          return [];
+        }
+        try {
+          const available = await isSemgrepAvailable();
+          if (!available) {
+            return [];
+          }
+          const targetDir = this.resolveTargetDirectory(files);
+          const semgrepResult = await runSemgrepWithRules(targetDir, ruleSetIds);
+          if (!semgrepResult.success || semgrepResult.findings.length === 0) {
+            return [];
+          }
+          const converted = convertSemgrepFindings(semgrepResult.findings);
+          return converted.map((f74) => ({
+            id: v4_default(),
+            cveId: void 0,
+            title: f74.title,
+            description: `[semgrep] ${f74.description}`,
+            severity: f74.severity,
+            category: this.mapSemgrepCategory(f74.owaspCategory),
+            location: {
+              file: f74.file,
+              line: f74.line,
+              column: f74.column,
+              snippet: f74.snippet
+            },
+            remediation: {
+              description: f74.remediation,
+              estimatedEffort: "moderate",
+              automatable: false
+            },
+            references: f74.references
+          }));
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * Resolve the common parent directory from a set of file paths
+       */
+      resolveTargetDirectory(files) {
+        if (files.length === 0) return ".";
+        if (files.length === 1) return files[0].directory || ".";
+        const dirs = files.map((f74) => f74.directory || ".");
+        const first = dirs[0];
+        let commonLen = first.length;
+        for (let i58 = 1; i58 < dirs.length; i58++) {
+          const dir = dirs[i58];
+          const maxLen = Math.min(commonLen, dir.length);
+          let j52 = 0;
+          while (j52 < maxLen && first[j52] === dir[j52]) j52++;
+          commonLen = j52;
+        }
+        const common = first.substring(0, commonLen);
+        const lastSep = common.lastIndexOf("/");
+        return lastSep > 0 ? common.substring(0, lastSep) : common || ".";
+      }
+      /**
+       * Map semgrep OWASP category string to VulnerabilityCategory
+       */
+      mapSemgrepCategory(owaspCategory) {
+        if (!owaspCategory) return "injection";
+        const categoryMap = {
+          "A01": "access-control",
+          "A02": "sensitive-data",
+          "A03": "injection",
+          "A04": "insecure-deserialization",
+          "A05": "security-misconfiguration",
+          "A06": "vulnerable-components",
+          "A07": "broken-auth",
+          "A08": "insecure-deserialization",
+          "A09": "insufficient-logging",
+          "A10": "xxe"
+        };
+        for (const [key, value] of Object.entries(categoryMap)) {
+          if (owaspCategory.startsWith(key)) return value;
+        }
+        return "injection";
+      }
+      /**
+       * Merge pattern-based and semgrep vulnerabilities, deduplicating
+       * findings that overlap on the same file and line.
+       */
+      mergeVulnerabilities(patternVulns, semgrepVulns) {
+        if (semgrepVulns.length === 0) return patternVulns;
+        if (patternVulns.length === 0) return semgrepVulns;
+        const patternKeys = new Set(
+          patternVulns.map((v65) => `${v65.location.file}:${v65.location.line ?? 0}:${v65.category}`)
+        );
+        const uniqueSemgrep = semgrepVulns.filter(
+          (v65) => !patternKeys.has(`${v65.location.file}:${v65.location.line ?? 0}:${v65.category}`)
+        );
+        return [...patternVulns, ...uniqueSemgrep];
+      }
       /**
        * Get available rule sets
        */
@@ -87819,7 +88116,7 @@ var init_security_auditor_types = __esm({
 
 // src/domains/security-compliance/services/security-auditor-sast.ts
 import * as fs12 from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 function getSASTVulnerabilityPatterns() {
   return [
     // SQL Injection patterns
@@ -87970,7 +88267,7 @@ async function performSASTScan(findSourceFiles, shouldExclude) {
       if (shouldExclude(filePath)) {
         continue;
       }
-      const ext = path14.extname(filePath).toLowerCase();
+      const ext = path15.extname(filePath).toLowerCase();
       if (![".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
         continue;
       }
@@ -88696,7 +88993,7 @@ var init_security_auditor_reports = __esm({
 
 // src/domains/security-compliance/services/security-auditor.ts
 import * as fs14 from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 var SecurityAuditorService;
 var init_security_auditor = __esm({
   "src/domains/security-compliance/services/security-auditor.ts"() {
@@ -89182,7 +89479,7 @@ var init_security_auditor = __esm({
         const vulnerabilities = [];
         const outdatedPackages = [];
         try {
-          const manifestPath = path15.join(process.cwd(), "package.json");
+          const manifestPath = path16.join(process.cwd(), "package.json");
           const dependencies = await this.parseDependencies(manifestPath, "npm");
           for (const dep of dependencies) {
             const vulns = await this.checkDependencyVulnerabilities(dep, dep.ecosystem);
@@ -89236,14 +89533,14 @@ var init_security_auditor = __esm({
         try {
           const entries = await fs14.readdir(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path15.join(dir, entry.name);
+            const fullPath = path16.join(dir, entry.name);
             if (this.shouldExclude(fullPath)) {
               continue;
             }
             if (entry.isDirectory()) {
               await this.findSourceFiles(fullPath, files);
             } else if (entry.isFile()) {
-              const ext = path15.extname(entry.name).toLowerCase();
+              const ext = path16.extname(entry.name).toLowerCase();
               if (sourceExtensions.includes(ext) || entry.name.startsWith(".env")) {
                 files.push(fullPath);
               }
@@ -101280,7 +101577,7 @@ var init_plugin10 = __esm({
 
 // src/domains/chaos-resilience/services/chaos-engineer.ts
 import * as net from "net";
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 var DEFAULT_CONFIG55, ChaosEngineerService;
 var init_chaos_engineer = __esm({
   "src/domains/chaos-resilience/services/chaos-engineer.ts"() {
@@ -101790,7 +102087,7 @@ Provide:
           const parts = sanitizedCommand.trim().split(/\s+/);
           const executable = parts[0];
           const args = parts.slice(1);
-          execFile2(executable, args, { timeout }, (error, stdout, _stderr) => {
+          execFile3(executable, args, { timeout }, (error, stdout, _stderr) => {
             if (error) {
               console.log(`Command probe failed: ${probe.name} -> ${error.message}`);
               resolve11(false);
@@ -102134,7 +102431,7 @@ Provide:
           const parts = sanitizedCommand.trim().split(/\s+/);
           const executable = parts[0];
           const args = parts.slice(1);
-          execFile2(executable, args, { timeout }, (error, _stdout, stderr) => {
+          execFile3(executable, args, { timeout }, (error, _stdout, stderr) => {
             if (error) {
               reject(new Error(`Command rollback failed: ${error.message}. ${stderr}`));
             } else {
@@ -114833,179 +115130,6 @@ var init_coverage_analysis = __esm({
   }
 });
 
-// src/domains/security-compliance/services/semgrep-integration.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify4 } from "util";
-import * as path16 from "path";
-async function isSemgrepAvailable() {
-  try {
-    await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getSemgrepVersion() {
-  try {
-    const { stdout } = await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function runSemgrep(config) {
-  const fullConfig = {
-    target: config.target || ".",
-    config: config.config || "auto",
-    exclude: config.exclude || ["node_modules", ".git", "dist", "build", "coverage"],
-    maxFileSize: config.maxFileSize || 5e6,
-    // 5MB
-    timeout: config.timeout || 300,
-    verbose: config.verbose || false
-  };
-  const available = await isSemgrepAvailable();
-  if (!available) {
-    return {
-      success: false,
-      findings: [],
-      errors: ["Semgrep is not installed. Install with: pip install semgrep"]
-    };
-  }
-  try {
-    const args = [
-      "scan",
-      `--config=${fullConfig.config}`,
-      "--json",
-      fullConfig.verbose ? "--verbose" : "--quiet",
-      `--max-target-bytes=${fullConfig.maxFileSize}`
-    ];
-    for (const excludePattern of fullConfig.exclude) {
-      args.push(`--exclude=${excludePattern}`);
-    }
-    args.push(fullConfig.target);
-    const timeoutMs = (fullConfig.timeout ?? 300) * 1e3;
-    const { stdout, stderr } = await execFileAsync2("semgrep", args, {
-      timeout: timeoutMs,
-      maxBuffer: 50 * 1024 * 1024,
-      // 50MB buffer for large results
-      cwd: path16.isAbsolute(fullConfig.target) ? void 0 : process.cwd()
-    });
-    const result = parseSemgrepOutput(stdout);
-    if (stderr && fullConfig.verbose) {
-      result.errors.push(stderr);
-    }
-    result.version = await getSemgrepVersion() || void 0;
-    return result;
-  } catch (error) {
-    const execError = error;
-    if (execError.stdout) {
-      try {
-        const result = parseSemgrepOutput(execError.stdout);
-        result.version = await getSemgrepVersion() || void 0;
-        return result;
-      } catch {
-      }
-    }
-    return {
-      success: false,
-      findings: [],
-      errors: [execError.message ?? String(error)]
-    };
-  }
-}
-function parseSemgrepOutput(stdout) {
-  try {
-    const parsed = safeJsonParse(stdout);
-    const results = parsed.results || parsed.findings || [];
-    const errors = parsed.errors?.map((e20) => e20.message || String(e20)) || [];
-    return {
-      success: true,
-      findings: results.map((r54) => ({
-        check_id: r54.check_id || r54.rule_id || "unknown",
-        path: r54.path,
-        start: { line: r54.start?.line || 1, col: r54.start?.col || 1 },
-        end: { line: r54.end?.line || r54.start?.line || 1, col: r54.end?.col || 1 },
-        extra: {
-          message: r54.extra?.message || r54.message || "Security issue detected",
-          severity: r54.extra?.severity || r54.severity || "WARNING",
-          lines: r54.extra?.lines || "",
-          metadata: {
-            cwe: r54.extra?.metadata?.cwe || r54.metadata?.cwe,
-            owasp: r54.extra?.metadata?.owasp || r54.metadata?.owasp,
-            category: r54.extra?.metadata?.category || r54.metadata?.category,
-            description: r54.extra?.metadata?.description || r54.metadata?.description,
-            fix: r54.extra?.metadata?.fix || r54.extra?.fix,
-            references: r54.extra?.metadata?.references || r54.metadata?.references,
-            confidence: r54.extra?.metadata?.confidence || r54.metadata?.confidence
-          }
-        }
-      })),
-      errors
-    };
-  } catch (error) {
-    return {
-      success: false,
-      findings: [],
-      errors: [`Failed to parse semgrep output: ${toErrorMessage(error)}`]
-    };
-  }
-}
-async function runSemgrepWithRules(target, rules, options) {
-  const configMapping = {
-    "owasp-top-10": "p/owasp-top-ten",
-    "cwe-sans-25": "p/cwe-top-25",
-    "nodejs-security": "p/nodejs",
-    "typescript-security": "p/typescript",
-    "javascript-security": "p/javascript",
-    "react-security": "p/react",
-    "express-security": "p/express",
-    "secrets": "p/secrets",
-    "sql-injection": "p/sql-injection",
-    "xss": "p/xss",
-    "command-injection": "p/command-injection",
-    "path-traversal": "p/path-traversal"
-  };
-  const configs = rules.map((r54) => configMapping[r54] || `p/${r54}`).join(",");
-  return runSemgrep({
-    ...options,
-    target,
-    config: configs || "auto"
-  });
-}
-function mapSemgrepSeverity(severity) {
-  const mapping = {
-    ERROR: "high",
-    WARNING: "medium",
-    INFO: "low"
-  };
-  return mapping[severity] || "medium";
-}
-function convertSemgrepFindings(findings) {
-  return findings.map((f74) => ({
-    id: f74.check_id,
-    title: f74.check_id.split(".").pop() || f74.check_id,
-    description: f74.extra.message,
-    severity: mapSemgrepSeverity(f74.extra.severity),
-    file: f74.path,
-    line: f74.start.line,
-    column: f74.start.col,
-    snippet: f74.extra.lines,
-    cweId: f74.extra.metadata?.cwe?.[0],
-    owaspCategory: f74.extra.metadata?.owasp?.[0],
-    remediation: f74.extra.metadata?.fix || "Review and fix the identified security issue",
-    references: f74.extra.metadata?.references || []
-  }));
-}
-var execFileAsync2;
-var init_semgrep_integration = __esm({
-  "src/domains/security-compliance/services/semgrep-integration.ts"() {
-    "use strict";
-    init_error_utils();
-    init_safe_json();
-    execFileAsync2 = promisify4(execFile3);
-  }
-});
-
 // src/domains/security-compliance/index.ts
 var init_security_compliance = __esm({
   "src/domains/security-compliance/index.ts"() {
@@ -119094,6 +119218,457 @@ var init_queen_integration2 = __esm({
   }
 });
 
+// src/routing/co-execution-repository.ts
+function getCoExecutionRepository() {
+  if (!_instance2) {
+    _instance2 = new CoExecutionRepository();
+  }
+  return _instance2;
+}
+var CONFIDENCE_RAMP_THRESHOLD, CoExecutionRepository, _instance2;
+var init_co_execution_repository = __esm({
+  "src/routing/co-execution-repository.ts"() {
+    "use strict";
+    init_error_utils();
+    CONFIDENCE_RAMP_THRESHOLD = 20;
+    CoExecutionRepository = class {
+      db = null;
+      initialized = false;
+      /**
+       * Initialize with a database connection.
+       * Creates the co-execution table if it doesn't exist.
+       */
+      initialize(db) {
+        if (this.initialized) return;
+        this.db = db;
+        try {
+          this.db.exec(`
+        CREATE TABLE IF NOT EXISTS qe_agent_co_execution (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          agent_a TEXT NOT NULL,
+          agent_b TEXT NOT NULL,
+          domain TEXT NOT NULL,
+          success INTEGER NOT NULL DEFAULT 0,
+          task_description TEXT,
+          created_at TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_co_exec_agents
+          ON qe_agent_co_execution(agent_a, agent_b);
+        CREATE INDEX IF NOT EXISTS idx_co_exec_domain
+          ON qe_agent_co_execution(domain);
+      `);
+          this.initialized = true;
+        } catch (error) {
+          console.error(`[CoExecutionRepository] Init error: ${toErrorMessage(error)}`);
+        }
+      }
+      /**
+       * Record a co-execution event between two agents.
+       * Agent order is normalized (sorted) so A-B and B-A are the same pair.
+       */
+      recordCoExecution(record) {
+        if (!this.db) return;
+        const [a37, b68] = [record.agentA, record.agentB].sort();
+        try {
+          this.db.prepare(`
+        INSERT INTO qe_agent_co_execution (agent_a, agent_b, domain, success, task_description)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(
+            a37,
+            b68,
+            record.domain,
+            record.success ? 1 : 0,
+            record.taskDescription?.slice(0, 500) || null
+          );
+        } catch (error) {
+          console.debug(`[CoExecutionRepository] Record error: ${toErrorMessage(error)}`);
+        }
+      }
+      /**
+       * Get co-execution stats for a specific agent pair.
+       * Returns behavioral confidence using linear ramp: min(1.0, successCount / 20).
+       */
+      getCoExecutionStats(agentA, agentB) {
+        if (!this.db) return null;
+        const [a37, b68] = [agentA, agentB].sort();
+        try {
+          const row2 = this.db.prepare(`
+        SELECT
+          agent_a,
+          agent_b,
+          COUNT(*) as total_executions,
+          SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count
+        FROM qe_agent_co_execution
+        WHERE agent_a = ? AND agent_b = ?
+        GROUP BY agent_a, agent_b
+      `).get(a37, b68);
+          if (!row2) return null;
+          const successRate = row2.total_executions > 0 ? row2.success_count / row2.total_executions : 0;
+          const behavioralConfidence = Math.min(1, row2.success_count / CONFIDENCE_RAMP_THRESHOLD);
+          return {
+            agentA: row2.agent_a,
+            agentB: row2.agent_b,
+            totalExecutions: row2.total_executions,
+            successCount: row2.success_count,
+            successRate,
+            behavioralConfidence
+          };
+        } catch (error) {
+          console.debug(`[CoExecutionRepository] Stats error: ${toErrorMessage(error)}`);
+          return null;
+        }
+      }
+      /**
+       * Get all agents that have successfully co-executed with the given agent.
+       * Returns them sorted by behavioral confidence (descending).
+       */
+      getCoExecutionPartners(agentId, limit = 10) {
+        if (!this.db) return [];
+        try {
+          const rows = this.db.prepare(`
+        SELECT
+          agent_a,
+          agent_b,
+          COUNT(*) as total_executions,
+          SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count
+        FROM qe_agent_co_execution
+        WHERE agent_a = ? OR agent_b = ?
+        GROUP BY agent_a, agent_b
+        ORDER BY success_count DESC
+        LIMIT ?
+      `).all(agentId, agentId, limit);
+          return rows.map((row2) => {
+            const successRate = row2.total_executions > 0 ? row2.success_count / row2.total_executions : 0;
+            return {
+              agentA: row2.agent_a,
+              agentB: row2.agent_b,
+              totalExecutions: row2.total_executions,
+              successCount: row2.success_count,
+              successRate,
+              behavioralConfidence: Math.min(1, row2.success_count / CONFIDENCE_RAMP_THRESHOLD)
+            };
+          });
+        } catch (error) {
+          console.debug(`[CoExecutionRepository] Partners error: ${toErrorMessage(error)}`);
+          return [];
+        }
+      }
+      /**
+       * Record a batch of co-executions from a swarm task.
+       * Given a list of agents that participated in a task together,
+       * records co-execution for every unique pair.
+       */
+      recordSwarmCoExecution(agentIds, domain, success, taskDescription) {
+        if (!this.db || agentIds.length < 2) return;
+        try {
+          const insert = this.db.prepare(`
+        INSERT INTO qe_agent_co_execution (agent_a, agent_b, domain, success, task_description)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+          const transaction = this.db.transaction(() => {
+            for (let i58 = 0; i58 < agentIds.length; i58++) {
+              for (let j52 = i58 + 1; j52 < agentIds.length; j52++) {
+                const [a37, b68] = [agentIds[i58], agentIds[j52]].sort();
+                insert.run(a37, b68, domain, success ? 1 : 0, taskDescription?.slice(0, 500) || null);
+              }
+            }
+          });
+          transaction();
+        } catch (error) {
+          console.debug(`[CoExecutionRepository] Swarm record error: ${toErrorMessage(error)}`);
+        }
+      }
+    };
+    _instance2 = null;
+  }
+});
+
+// src/validation/steps/agent-mcp-validator.ts
+import { readFileSync as readFileSync9, existsSync as existsSync11, readdirSync as readdirSync6 } from "fs";
+import { join as join16 } from "path";
+function getAvailableMcpServers(projectRoot) {
+  const servers = [];
+  const mcpConfigPaths = [
+    join16(projectRoot, ".claude", "mcp.json"),
+    join16(projectRoot, ".mcp.json")
+  ];
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  if (homeDir) {
+    mcpConfigPaths.push(join16(homeDir, ".claude", "mcp.json"));
+  }
+  for (const configPath of mcpConfigPaths) {
+    if (!existsSync11(configPath)) continue;
+    try {
+      const content = readFileSync9(configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.mcpServers && typeof config.mcpServers === "object") {
+        servers.push(...Object.keys(config.mcpServers));
+      }
+    } catch {
+    }
+  }
+  return [...new Set(servers)];
+}
+var MAX_SCAN_SIZE_BYTES;
+var init_agent_mcp_validator = __esm({
+  "src/validation/steps/agent-mcp-validator.ts"() {
+    "use strict";
+    MAX_SCAN_SIZE_BYTES = 100 * 1024;
+  }
+});
+
+// src/routing/agent-dependency-graph.ts
+import { readFileSync as readFileSync10, existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
+import { join as join17, basename as basename3 } from "path";
+function extractFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines.length < 2 || lines[0].trim() !== "---") return null;
+  for (let i58 = 1; i58 < lines.length; i58++) {
+    if (lines[i58].trim() === "---") return lines.slice(1, i58).join("\n");
+  }
+  return null;
+}
+function parseYamlValue(raw) {
+  const t50 = raw.trim();
+  if (t50.startsWith('"') && t50.endsWith('"') || t50.startsWith("'") && t50.endsWith("'")) {
+    return t50.slice(1, -1);
+  }
+  return t50;
+}
+function parseDependenciesFromFrontmatter(content) {
+  const frontmatter = extractFrontmatter(content);
+  if (!frontmatter) return null;
+  const lines = frontmatter.split("\n");
+  let depsStart = -1;
+  for (let i58 = 0; i58 < lines.length; i58++) {
+    if (/^dependencies:\s*$/.test(lines[i58])) {
+      depsStart = i58 + 1;
+      break;
+    }
+  }
+  if (depsStart === -1) return null;
+  const depsLines = [];
+  for (let i58 = depsStart; i58 < lines.length; i58++) {
+    const line = lines[i58];
+    if (line.trim() === "") continue;
+    if (line.length > 0 && line[0] !== " " && line[0] !== "	") break;
+    depsLines.push(line);
+  }
+  if (depsLines.length === 0) return null;
+  const result = {};
+  const st2 = { section: "none", item: {}, inList: false };
+  const flushAgent = () => {
+    if (!st2.item.name) return;
+    if (!result.agents) result.agents = [];
+    result.agents.push({ name: st2.item.name, type: st2.item.type || "hard", reason: st2.item.reason || "" });
+    st2.item = {};
+  };
+  const flushMcp = () => {
+    if (!st2.item.name) return;
+    if (!result.mcpServers) result.mcpServers = [];
+    result.mcpServers.push({ name: st2.item.name, required: st2.item.required === "true" });
+    st2.item = {};
+  };
+  for (const line of depsLines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const secMatch = trimmed.match(/^(agents|mcp_servers|models):\s*$/);
+    if (secMatch) {
+      if (st2.section === "agents" && st2.inList) flushAgent();
+      if (st2.section === "mcp_servers" && st2.inList) flushMcp();
+      st2.inList = false;
+      st2.section = secMatch[1];
+      continue;
+    }
+    if (st2.section === "agents" || st2.section === "mcp_servers") {
+      const listStart = trimmed.match(/^-\s+(\w+):\s*(.*)$/);
+      if (listStart) {
+        if (st2.inList) {
+          st2.section === "agents" ? flushAgent() : flushMcp();
+        }
+        st2.inList = true;
+        st2.item = { [listStart[1]]: parseYamlValue(listStart[2]) };
+        continue;
+      }
+      if (st2.inList) {
+        const kv = trimmed.match(/^(\w+):\s*(.*)$/);
+        if (kv) {
+          st2.item[kv[1]] = parseYamlValue(kv[2]);
+          continue;
+        }
+      }
+    }
+    if (st2.section === "models") {
+      if (!result.models) result.models = {};
+      const kv = trimmed.match(/^(\w+):\s*(.*)$/);
+      if (kv) {
+        const val = parseYamlValue(kv[2]);
+        if (kv[1] === "minimum") result.models = { ...result.models, minimum: val };
+        else if (kv[1] === "capabilities") {
+          const arr = val.match(/^\[(.+)]$/);
+          if (arr) result.models = { ...result.models, capabilities: arr[1].split(",").map((s70) => parseYamlValue(s70.trim())) };
+        }
+      }
+      const li = trimmed.match(/^-\s+(.+)$/);
+      if (li && result.models) {
+        const caps = result.models.capabilities || [];
+        result.models = { ...result.models, capabilities: [...caps, parseYamlValue(li[1])] };
+      }
+    }
+  }
+  if (st2.section === "agents" && st2.inList) flushAgent();
+  if (st2.section === "mcp_servers" && st2.inList) flushMcp();
+  if (!result.agents && !result.mcpServers && !result.models) return null;
+  return result;
+}
+function extractAgentName(content) {
+  const fm = extractFrontmatter(content);
+  if (!fm) return null;
+  for (const line of fm.split("\n")) {
+    const m74 = line.match(/^name:\s*(.+)$/);
+    if (m74) return parseYamlValue(m74[1]);
+  }
+  return null;
+}
+function buildDependencyGraph(agentsDir) {
+  const nodes = /* @__PURE__ */ new Map();
+  const warnings = [];
+  if (!existsSync12(agentsDir)) {
+    warnings.push(`Agents directory not found: ${agentsDir}`);
+    return { nodes, spawnOrder: [], cycles: [], warnings };
+  }
+  const files = readdirSync7(agentsDir).filter((f74) => f74.startsWith("qe-") && f74.endsWith(".md"));
+  for (const file of files) {
+    let content;
+    try {
+      content = readFileSync10(join17(agentsDir, file), "utf-8");
+    } catch {
+      warnings.push(`Failed to read agent file: ${file}`);
+      continue;
+    }
+    const agentName = extractAgentName(content) || basename3(file, ".md");
+    const deps = parseDependenciesFromFrontmatter(content);
+    const hardDeps = [], softDeps = [], peerDeps = [];
+    if (deps?.agents) {
+      for (const dep of deps.agents) {
+        if (dep.type === "hard") hardDeps.push(dep.name);
+        else if (dep.type === "soft") softDeps.push(dep.name);
+        else if (dep.type === "peer") peerDeps.push(dep.name);
+      }
+    }
+    nodes.set(agentName, { agentName, hardDeps, softDeps, peerDeps, dependencies: deps || {} });
+  }
+  const allNames = new Set(nodes.keys());
+  for (const [name, node] of nodes) {
+    for (const dep of node.hardDeps) {
+      if (!allNames.has(dep)) {
+        warnings.push(`Agent "${name}" declares hard dependency on "${dep}" which is not in the agent directory`);
+      }
+    }
+  }
+  const cycles = detectCycles(nodes);
+  for (const cycle of cycles) warnings.push(`Dependency cycle detected: ${cycle.join(" -> ")}`);
+  return { nodes, spawnOrder: topologicalSort(nodes, cycles), cycles, warnings };
+}
+function detectCycles(nodes) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path31 = [];
+  function dfs(name) {
+    visited.add(name);
+    stack.add(name);
+    path31.push(name);
+    const node = nodes.get(name);
+    if (node) {
+      for (const dep of node.hardDeps) {
+        if (!visited.has(dep) && nodes.has(dep)) dfs(dep);
+        else if (stack.has(dep)) {
+          const start = path31.indexOf(dep);
+          if (start !== -1) cycles.push([...path31.slice(start), dep]);
+        }
+      }
+    }
+    path31.pop();
+    stack.delete(name);
+  }
+  for (const name of nodes.keys()) {
+    if (!visited.has(name)) dfs(name);
+  }
+  return cycles;
+}
+function topologicalSort(nodes, cycles) {
+  const cycleAgents = new Set(cycles.flat());
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const temp = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name) || cycleAgents.has(name) || temp.has(name)) return;
+    temp.add(name);
+    const node = nodes.get(name);
+    if (node) {
+      for (const dep of node.hardDeps) {
+        if (nodes.has(dep)) visit(dep);
+      }
+    }
+    temp.delete(name);
+    visited.add(name);
+    sorted.push(name);
+  }
+  for (const name of nodes.keys()) visit(name);
+  for (const agent of cycleAgents) {
+    if (!sorted.includes(agent)) sorted.push(agent);
+  }
+  return sorted;
+}
+function createSpawnPlan(agentNames, graph) {
+  const requested = new Set(agentNames);
+  const warnings = [];
+  const unsatisfiedHardDeps = [];
+  for (const name of agentNames) {
+    const node = graph.nodes.get(name);
+    if (!node) continue;
+    const missing = node.hardDeps.filter((d74) => !requested.has(d74));
+    if (missing.length > 0) {
+      unsatisfiedHardDeps.push({ agent: name, missing });
+      warnings.push(`Advisory: "${name}" has unsatisfied hard dependencies: ${missing.join(", ")}. Proceeding anyway.`);
+    }
+  }
+  const phases = [];
+  const placed = /* @__PURE__ */ new Set();
+  let remaining = new Set(agentNames);
+  while (remaining.size > 0) {
+    const phase = [];
+    for (const name of remaining) {
+      const node = graph.nodes.get(name);
+      if (!node) {
+        phase.push(name);
+        continue;
+      }
+      const inScopeHard = node.hardDeps.filter((d74) => requested.has(d74));
+      if (inScopeHard.every((d74) => placed.has(d74))) phase.push(name);
+    }
+    if (phase.length === 0) {
+      warnings.push(`Could not resolve dependency ordering for: ${[...remaining].join(", ")}. Placing in final phase.`);
+      phases.push([...remaining]);
+      break;
+    }
+    phases.push(phase);
+    for (const a37 of phase) {
+      placed.add(a37);
+      remaining.delete(a37);
+    }
+    remaining = /* @__PURE__ */ new Set([...remaining]);
+  }
+  return { phases, unsatisfiedHardDeps, warnings };
+}
+var init_agent_dependency_graph = __esm({
+  "src/routing/agent-dependency-graph.ts"() {
+    "use strict";
+  }
+});
+
 // src/coordination/agent-teams/types.ts
 var DEFAULT_AGENT_TEAMS_CONFIG;
 var init_types9 = __esm({
@@ -123757,8 +124332,8 @@ var init_cross_phase_memory = __esm({
 });
 
 // src/hooks/cross-phase-hooks.ts
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
+import { join as join18 } from "path";
 import { parse as parseYaml } from "yaml";
 function getCrossPhaseHookExecutor(configPath) {
   if (!executor) {
@@ -123777,19 +124352,19 @@ var init_cross_phase_hooks = __esm({
       configPath;
       listeners = /* @__PURE__ */ new Map();
       constructor(configPath) {
-        this.configPath = configPath || join16(process.cwd(), ".claude/hooks/cross-phase-memory.yaml");
+        this.configPath = configPath || join18(process.cwd(), ".claude/hooks/cross-phase-memory.yaml");
         this.memory = getCrossPhaseMemory();
       }
       // ---------------------------------------------------------------------------
       // Initialization
       // ---------------------------------------------------------------------------
       async initialize() {
-        if (!existsSync11(this.configPath)) {
+        if (!existsSync13(this.configPath)) {
           console.warn(`[CrossPhaseHooks] Config not found: ${this.configPath}`);
           return false;
         }
         try {
-          const content = readFileSync9(this.configPath, "utf-8");
+          const content = readFileSync11(this.configPath, "utf-8");
           this.config = parseYaml(content);
           if (!this.config.enabled) {
             console.log("[CrossPhaseHooks] Hooks disabled in config");
@@ -124620,6 +125195,17 @@ async function handleTaskCompletionCallback(ctx, result) {
     ctx.auditLogger.logFail(result.taskId, execution.assignedAgents[0], result.error || "Unknown error");
   }
   ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+  if (ctx.coExecutionRepo && execution.assignedAgents.length >= 2) {
+    try {
+      ctx.coExecutionRepo.recordSwarmCoExecution(
+        execution.assignedAgents,
+        execution.assignedDomain || "unknown",
+        result.success,
+        execution.task.type
+      );
+    } catch {
+    }
+  }
   for (const agentId of execution.assignedAgents) {
     await ctx.agentCoordinator.stop(agentId);
   }
@@ -124851,6 +125437,9 @@ var init_queen_coordinator = __esm({
     init_queen_integration();
     init_shared_singleton();
     init_queen_integration2();
+    init_co_execution_repository();
+    init_agent_mcp_validator();
+    init_agent_dependency_graph();
     init_governance();
     init_agent_teams();
     init_domain_team_manager();
@@ -124936,6 +125525,10 @@ var init_queen_coordinator = __esm({
       hypothesisManager = null;
       federationMailbox = null;
       dynamicScaler = null;
+      // Issue #342: Dependency intelligence
+      coExecutionRepo = null;
+      dependencyGraph = null;
+      availableMcpServers = [];
       // ============================================================================
       // Lifecycle
       // ============================================================================
@@ -124976,6 +125569,28 @@ var init_queen_coordinator = __esm({
           logger10.warn("Governance initialization failed (continuing)", { error: govError });
         }
         this.initializeSubsystems();
+        try {
+          const { join: join41 } = await import("path");
+          const agentsDir = join41(process.cwd(), ".claude", "agents", "v3");
+          this.dependencyGraph = buildDependencyGraph(agentsDir);
+          this.availableMcpServers = getAvailableMcpServers(process.cwd());
+          const { getUnifiedMemory: getUnifiedMemory2 } = await Promise.resolve().then(() => (init_unified_memory(), unified_memory_exports));
+          const unifiedMemory = getUnifiedMemory2();
+          await unifiedMemory.initialize();
+          this.coExecutionRepo = getCoExecutionRepository();
+          this.coExecutionRepo.initialize(unifiedMemory.getDatabase());
+          if (this.dependencyGraph.warnings.length > 0) {
+            logger10.warn(`Dependency graph: ${this.dependencyGraph.warnings.length} warning(s)`, {
+              warnings: this.dependencyGraph.warnings.slice(0, 5)
+            });
+          }
+          logger10.info("Dependency intelligence initialized", {
+            agents: this.dependencyGraph.nodes.size,
+            mcpServers: this.availableMcpServers.length
+          });
+        } catch (depError) {
+          logger10.warn("Dependency intelligence initialization failed (continuing)", { error: depError });
+        }
         await this.publishEvent("QueenInitialized", {
           timestamp: /* @__PURE__ */ new Date(),
           config: this.config,
@@ -125154,6 +125769,23 @@ var init_queen_coordinator = __esm({
         return ALL_DOMAINS.filter((domain) => this.getDomainLoad(domain) > this.config.workStealing.loadThreshold);
       }
       // ============================================================================
+      // Issue #342 Item 2: Dependency-Aware Spawn Planning
+      // ============================================================================
+      /**
+       * Get a phased spawn plan that respects hard agent dependencies.
+       * Use this when spawning multiple agents for a swarm task.
+       */
+      getSpawnPlan(agentNames) {
+        if (!this.dependencyGraph) return { phases: [agentNames], warnings: [], unsatisfiedHardDeps: [] };
+        return createSpawnPlan(agentNames, this.dependencyGraph);
+      }
+      /**
+       * Get the dependency graph for the agent fleet.
+       */
+      getDependencyGraph() {
+        return this.dependencyGraph;
+      }
+      // ============================================================================
       // Work Stealing
       // ============================================================================
       enableWorkStealing() {
@@ -125187,6 +125819,24 @@ var init_queen_coordinator = __esm({
         if (!this.agentCoordinator.canSpawn()) {
           return err(new Error("Maximum concurrent agents reached (15)"));
         }
+        if (this.dependencyGraph && this.availableMcpServers.length > 0) {
+          try {
+            for (const [, node] of this.dependencyGraph.nodes) {
+              const mcpDeps = node.dependencies.mcpServers;
+              if (!mcpDeps || mcpDeps.length === 0) continue;
+              const missing = mcpDeps.filter((s70) => s70.required && !this.availableMcpServers.includes(s70.name));
+              if (missing.length > 0) {
+                logger10.warn(`Pre-spawn MCP advisory: ${node.agentName} needs ${missing.map((m74) => m74.name).join(", ")}`, {
+                  agent: node.agentName,
+                  domain,
+                  missing: missing.map((m74) => m74.name)
+                });
+                break;
+              }
+            }
+          } catch {
+          }
+        }
         const result = await this.agentCoordinator.spawn({
           name: `${domain}-${type}-${Date.now()}`,
           domain,
@@ -125596,6 +126246,9 @@ var init_queen_coordinator = __esm({
             return self.traceCollector;
           },
           taskTraceContexts: self.taskTraceContexts,
+          get coExecutionRepo() {
+            return self.coExecutionRepo;
+          },
           requestAgentSpawn: (d74, t50, c70) => self.requestAgentSpawn(d74, t50, c70),
           publishEvent: (t50, p74) => self.publishEvent(t50, p74),
           getDomainLoad: (d74) => self.getDomainLoad(d74),
@@ -127072,8 +127725,8 @@ var init_transforms = __esm({
 });
 
 // src/integrations/agentic-flow/pattern-loader.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
-import { join as join18, dirname as dirname3 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
+import { join as join20, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getPatternLoader() {
   return PatternLoader.getInstance();
@@ -127139,10 +127792,10 @@ var init_pattern_loader = __esm({
           const currentFileUrl = import.meta.url;
           const currentFilePath = fileURLToPath(currentFileUrl);
           const currentDir = dirname3(currentFilePath);
-          const projectRoot = join18(currentDir, "..", "..", "..");
-          return join18(projectRoot, "assets", "patterns");
+          const projectRoot = join20(currentDir, "..", "..", "..");
+          return join20(projectRoot, "assets", "patterns");
         } catch {
-          return join18(process.cwd(), "assets", "patterns");
+          return join20(process.cwd(), "assets", "patterns");
         }
       }
       /**
@@ -127188,9 +127841,9 @@ var init_pattern_loader = __esm({
        * Load a JSON file from the patterns directory
        */
       loadJsonFile(filename) {
-        const filePath = join18(this.config.basePath, filename);
+        const filePath = join20(this.config.basePath, filename);
         try {
-          if (!existsSync12(filePath)) {
+          if (!existsSync14(filePath)) {
             const errorMsg = `Pattern file not found: ${filePath}`;
             this.patterns.errors.push(errorMsg);
             if (this.config.throwOnMissing) {
@@ -127198,7 +127851,7 @@ var init_pattern_loader = __esm({
             }
             return null;
           }
-          const content = readFileSync10(filePath, "utf-8");
+          const content = readFileSync12(filePath, "utf-8");
           return safeJsonParse(content);
         } catch (error) {
           if (error instanceof PatternLoaderError) {
@@ -128540,6 +129193,22 @@ var init_sqlite_persistence = __esm({
         FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
       );
 
+      -- Agent co-execution tracking (Issue #342 Item 3)
+      CREATE TABLE IF NOT EXISTS qe_agent_co_execution (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_a TEXT NOT NULL,
+        agent_b TEXT NOT NULL,
+        domain TEXT NOT NULL,
+        success INTEGER NOT NULL DEFAULT 0,
+        task_description TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_co_exec_agents
+        ON qe_agent_co_execution(agent_a, agent_b);
+      CREATE INDEX IF NOT EXISTS idx_co_exec_domain
+        ON qe_agent_co_execution(domain);
+
       -- Unique constraint to prevent duplicate patterns
       CREATE UNIQUE INDEX IF NOT EXISTS idx_patterns_unique_name_domain_type
         ON qe_patterns(name, qe_domain, pattern_type);
@@ -138032,8 +138701,8 @@ var init_qe_agent_registry = __esm({
 });
 
 // src/context/sources/memory-source.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join21 } from "path";
 var MemoryContextSource;
 var init_memory_source = __esm({
   "src/context/sources/memory-source.ts"() {
@@ -138046,12 +138715,12 @@ var init_memory_source = __esm({
       async gather(request) {
         const fragments = [];
         try {
-          const dbPath = join19(process.cwd(), ".agentic-qe", "memory.db");
-          if (!existsSync13(dbPath)) {
+          const dbPath = join21(process.cwd(), ".agentic-qe", "memory.db");
+          if (!existsSync15(dbPath)) {
             return this.fallbackGather(request);
           }
-          const Database = (await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports))).default;
-          const db = new Database(dbPath, { readonly: true });
+          const { openDatabase: openDatabase2 } = await Promise.resolve().then(() => (init_safe_db(), safe_db_exports));
+          const db = openDatabase2(dbPath, { readonly: true });
           try {
             const domainKeywords = this.extractDomainKeywords(request.taskDescription);
             if (domainKeywords.length > 0) {
@@ -138166,8 +138835,8 @@ ${log}`;
 });
 
 // src/context/sources/test-source.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { basename as basename3, dirname as dirname4, join as join20 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join22 } from "path";
 var TestContextSource;
 var init_test_source = __esm({
   "src/context/sources/test-source.ts"() {
@@ -138182,16 +138851,16 @@ var init_test_source = __esm({
         for (const file of request.targetFiles.slice(0, 3)) {
           const testPaths = this.findTestPaths(file);
           for (const testPath of testPaths) {
-            if (existsSync14(testPath)) {
+            if (existsSync16(testPath)) {
               try {
-                const content = readFileSync11(testPath, "utf-8");
+                const content = readFileSync13(testPath, "utf-8");
                 const testNames = content.match(/(?:it|test|describe)\s*\(\s*['"`]([^'"`]+)['"`]/g) || [];
                 if (testNames.length > 0) {
-                  const summary = `Tests for ${basename3(file)} (${testPath}):
+                  const summary = `Tests for ${basename4(file)} (${testPath}):
 ${testNames.join("\n")}`;
                   fragments.push({
                     sourceId: this.id,
-                    title: `Tests: ${basename3(file)}`,
+                    title: `Tests: ${basename4(file)}`,
                     content: summary,
                     estimatedTokens: Math.ceil(summary.length / 3.5),
                     relevance: 0.8
@@ -138205,14 +138874,14 @@ ${testNames.join("\n")}`;
         return fragments;
       }
       findTestPaths(filePath) {
-        const base = basename3(filePath).replace(/\.(ts|js|tsx|jsx)$/, "");
+        const base = basename4(filePath).replace(/\.(ts|js|tsx|jsx)$/, "");
         const dir = dirname4(filePath);
         const extensions = [".test.ts", ".spec.ts", ".test.js", ".spec.js"];
         const paths = [];
         for (const ext of extensions) {
-          paths.push(join20(dir, `${base}${ext}`));
-          paths.push(join20(dir, "__tests__", `${base}${ext}`));
-          paths.push(join20(dir, "..", "tests", `${base}${ext}`));
+          paths.push(join22(dir, `${base}${ext}`));
+          paths.push(join22(dir, "__tests__", `${base}${ext}`));
+          paths.push(join22(dir, "..", "tests", `${base}${ext}`));
         }
         return paths;
       }
@@ -138221,8 +138890,8 @@ ${testNames.join("\n")}`;
 });
 
 // src/context/sources/coverage-source.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { join as join21, basename as basename4 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { join as join23, basename as basename5 } from "path";
 var CoverageContextSource;
 var init_coverage_source = __esm({
   "src/context/sources/coverage-source.ts"() {
@@ -138235,18 +138904,18 @@ var init_coverage_source = __esm({
       async gather(request) {
         const fragments = [];
         const coveragePaths = [
-          join21(process.cwd(), "coverage", "coverage-summary.json"),
-          join21(process.cwd(), "coverage", "coverage-final.json"),
-          join21(process.cwd(), ".coverage", "coverage-summary.json")
+          join23(process.cwd(), "coverage", "coverage-summary.json"),
+          join23(process.cwd(), "coverage", "coverage-final.json"),
+          join23(process.cwd(), ".coverage", "coverage-summary.json")
         ];
         for (const coveragePath of coveragePaths) {
-          if (!existsSync15(coveragePath)) continue;
+          if (!existsSync17(coveragePath)) continue;
           try {
-            const raw = readFileSync12(coveragePath, "utf-8");
+            const raw = readFileSync14(coveragePath, "utf-8");
             const data = JSON.parse(raw);
             const targetCoverage = [];
             for (const targetFile of request.targetFiles) {
-              const fileName = basename4(targetFile);
+              const fileName = basename5(targetFile);
               for (const [filePath, metrics] of Object.entries(data)) {
                 if (filePath.includes(fileName) && metrics && typeof metrics === "object") {
                   const m74 = metrics;
@@ -138295,8 +138964,8 @@ ${targetCoverage.join("\n")}`;
 });
 
 // src/context/sources/requirements-source.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { join as join24 } from "path";
 var RequirementsContextSource;
 var init_requirements_source = __esm({
   "src/context/sources/requirements-source.ts"() {
@@ -138309,12 +138978,12 @@ var init_requirements_source = __esm({
       async gather(request) {
         const fragments = [];
         try {
-          const dbPath = join22(process.cwd(), ".agentic-qe", "memory.db");
-          if (!existsSync16(dbPath)) {
+          const dbPath = join24(process.cwd(), ".agentic-qe", "memory.db");
+          if (!existsSync18(dbPath)) {
             return this.fallbackGather(request);
           }
-          const Database = (await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports))).default;
-          const db = new Database(dbPath, { readonly: true });
+          const { openDatabase: openDatabase2 } = await Promise.resolve().then(() => (init_safe_db(), safe_db_exports));
+          const db = openDatabase2(dbPath, { readonly: true });
           try {
             const tableCheck = db.prepare(
               "SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'"
@@ -138433,8 +139102,8 @@ ${content}`,
 });
 
 // src/context/sources/defect-source.ts
-import { existsSync as existsSync17 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join25 } from "path";
 var DefectContextSource;
 var init_defect_source = __esm({
   "src/context/sources/defect-source.ts"() {
@@ -138447,12 +139116,12 @@ var init_defect_source = __esm({
       async gather(request) {
         const fragments = [];
         try {
-          const dbPath = join23(process.cwd(), ".agentic-qe", "memory.db");
-          if (!existsSync17(dbPath)) {
+          const dbPath = join25(process.cwd(), ".agentic-qe", "memory.db");
+          if (!existsSync19(dbPath)) {
             return [];
           }
-          const Database = (await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports))).default;
-          const db = new Database(dbPath, { readonly: true });
+          const { openDatabase: openDatabase2 } = await Promise.resolve().then(() => (init_safe_db(), safe_db_exports));
+          const db = openDatabase2(dbPath, { readonly: true });
           try {
             const tableCheck = db.prepare(
               "SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'"
@@ -140663,17 +141332,19 @@ function createTaskExecutor(kernel, config) {
 }
 async function resetServiceCaches() {
 }
-var DomainTaskExecutor;
+var logger13, DomainTaskExecutor;
 var init_task_executor = __esm({
   "src/coordination/task-executor.ts"() {
     "use strict";
     init_esm_node();
     init_error_utils();
     init_result_saver();
+    init_logger_factory();
     init_agent_booster();
     init_task_router();
     init_domain_service_registry();
     init_handlers();
+    logger13 = createLogger("TaskExecutor");
     DomainTaskExecutor = class {
       constructor(kernel, eventBus, config) {
         this.kernel = kernel;
@@ -140891,7 +141562,8 @@ var init_task_executor = __esm({
           if (routingTier === 0 || useAgentBooster) {
             const boosterResult = await this.executeWithAgentBooster(task, startTime, domain);
             if (boosterResult) {
-              this.recordOutcome(task, 0, true, Date.now() - startTime).catch(() => {
+              this.recordOutcome(task, 0, true, Date.now() - startTime).catch((e20) => {
+                logger13.warn("recordOutcome failed", { error: e20 instanceof Error ? e20.message : String(e20), taskId: task.id });
               });
               await this.publishTaskCompleted(task.id, boosterResult.data, domain);
               return boosterResult;
@@ -140907,7 +141579,8 @@ var init_task_executor = __esm({
               duration: Date.now() - startTime,
               domain
             };
-            this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch(() => {
+            this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e20) => {
+              logger13.warn("recordOutcome failed", { error: e20 instanceof Error ? e20.message : String(e20), taskId: task.id });
             });
             return result2;
           }
@@ -140918,7 +141591,8 @@ var init_task_executor = __esm({
           if (!result.success) {
             const errorMsg = "error" in result ? result.error.message : "Unknown error";
             await this.publishTaskFailed(task.id, errorMsg, domain);
-            this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch(() => {
+            this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e20) => {
+              logger13.warn("recordOutcome failed", { error: e20 instanceof Error ? e20.message : String(e20), taskId: task.id });
             });
             return {
               taskId: task.id,
@@ -140929,7 +141603,8 @@ var init_task_executor = __esm({
             };
           }
           await this.publishTaskCompleted(task.id, result.value, domain);
-          this.recordOutcome(task, routingTier, true, Date.now() - startTime).catch(() => {
+          this.recordOutcome(task, routingTier, true, Date.now() - startTime).catch((e20) => {
+            logger13.warn("recordOutcome failed", { error: e20 instanceof Error ? e20.message : String(e20), taskId: task.id });
           });
           let savedFiles;
           if (this._config.saveResults) {
@@ -140964,7 +141639,8 @@ var init_task_executor = __esm({
         } catch (error) {
           const errorMessage = toErrorMessage(error);
           await this.publishTaskFailed(task.id, errorMessage, domain);
-          this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch(() => {
+          this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e20) => {
+            logger13.warn("recordOutcome failed", { error: e20 instanceof Error ? e20.message : String(e20), taskId: task.id });
           });
           return {
             taskId: task.id,
@@ -144385,7 +145061,7 @@ var init_pattern_store = __esm({
 function createQEReasoningBank(memory, eventBus, config, coherenceService) {
   return new QEReasoningBank(memory, eventBus, config, coherenceService);
 }
-var logger13, DEFAULT_QE_REASONING_BANK_CONFIG, QEReasoningBank;
+var logger14, DEFAULT_QE_REASONING_BANK_CONFIG, QEReasoningBank;
 var init_qe_reasoning_bank = __esm({
   "src/learning/qe-reasoning-bank.ts"() {
     "use strict";
@@ -144399,7 +145075,7 @@ var init_qe_reasoning_bank = __esm({
     init_witness_chain();
     init_qe_patterns();
     init_qe_guidance();
-    logger13 = LoggerFactory.create("QEReasoningBank");
+    logger14 = LoggerFactory.create("QEReasoningBank");
     DEFAULT_QE_REASONING_BANK_CONFIG = {
       enableLearning: true,
       enableGuidance: true,
@@ -144444,7 +145120,7 @@ var init_qe_reasoning_bank = __esm({
         if (!this.sqliteStore) {
           this.sqliteStore = createSQLitePatternStore();
           this.sqliteStore.initialize().catch((e20) => {
-            logger13.warn("SQLitePatternStore init failed", { error: toErrorMessage(e20) });
+            logger14.warn("SQLitePatternStore init failed", { error: toErrorMessage(e20) });
           });
         }
         return this.sqliteStore;
@@ -144532,7 +145208,7 @@ var init_qe_reasoning_bank = __esm({
           await store.initialize();
           this.patternStore.setSqliteStore(store);
         } catch (e20) {
-          logger13.warn("Failed to wire SQLitePatternStore into PatternStore", { error: toErrorMessage(e20) });
+          logger14.warn("Failed to wire SQLitePatternStore into PatternStore", { error: toErrorMessage(e20) });
         }
         await this.loadPretrainedPatterns();
         this.initialized = true;
@@ -144544,12 +145220,12 @@ var init_qe_reasoning_bank = __esm({
             await this.seedCrossDomainPatterns();
           } else {
             const stats = await this.patternStore.getStats();
-            logger13.info("Cross-domain transfer already complete", { totalPatterns: stats.totalPatterns });
+            logger14.info("Cross-domain transfer already complete", { totalPatterns: stats.totalPatterns });
           }
         } catch (error) {
-          logger13.warn("Cross-domain seeding failed (non-fatal)", { error });
+          logger14.warn("Cross-domain seeding failed (non-fatal)", { error });
         }
-        logger13.info("Initialized");
+        logger14.info("Initialized");
       }
       /**
        * Load pre-trained patterns for common QE scenarios
@@ -144557,7 +145233,7 @@ var init_qe_reasoning_bank = __esm({
       async loadPretrainedPatterns() {
         const stats = await this.patternStore.getStats();
         if (stats.totalPatterns > 0) {
-          logger13.info("Found existing patterns", { totalPatterns: stats.totalPatterns });
+          logger14.info("Found existing patterns", { totalPatterns: stats.totalPatterns });
           return;
         }
         const foundationalPatterns = [
@@ -145275,10 +145951,10 @@ On promotion:
           try {
             await this.patternStore.create(options);
           } catch (error) {
-            logger13.warn("Failed to load pattern", { name: options.name, error });
+            logger14.warn("Failed to load pattern", { name: options.name, error });
           }
         }
-        logger13.info("Loaded foundational patterns", { count: foundationalPatterns.length });
+        logger14.info("Loaded foundational patterns", { count: foundationalPatterns.length });
       }
       /**
        * Seed cross-domain patterns by transferring generalizable patterns
@@ -145361,7 +146037,7 @@ On promotion:
             }
           }
         }
-        logger13.info("Cross-domain transfer complete", { transferred, skipped });
+        logger14.info("Cross-domain transfer complete", { transferred, skipped });
         return { transferred, skipped };
       }
       /**
@@ -145382,13 +146058,14 @@ On promotion:
         }
         const result = await this.patternStore.create(options);
         if (result.success) {
-          getWitnessChain().then((wc) => wc.append("PATTERN_CREATE", { patternId: result.value.id, domain: result.value.qeDomain, confidence: result.value.confidence, name: result.value.name }, "reasoning-bank")).catch(() => {
+          getWitnessChain().then((wc) => wc.append("PATTERN_CREATE", { patternId: result.value.id, domain: result.value.qeDomain, confidence: result.value.confidence, name: result.value.name }, "reasoning-bank")).catch((e20) => {
+            logger14.warn("Witness chain PATTERN_CREATE failed", { error: toErrorMessage(e20) });
           });
           if (this.rvfDualWriter && result.value.embedding && result.value.embedding.length > 0) {
             try {
               this.rvfDualWriter.writePattern(result.value.id, result.value.embedding);
             } catch (rvfErr) {
-              logger13.warn("RVF dual-write failed (non-fatal)", { patternId: result.value.id, error: toErrorMessage(rvfErr) });
+              logger14.warn("RVF dual-write failed (non-fatal)", { patternId: result.value.id, error: toErrorMessage(rvfErr) });
             }
           }
         }
@@ -145452,19 +146129,20 @@ On promotion:
             outcome.feedback
           );
         } catch (persistError) {
-          logger13.warn("SQLite pattern usage persist failed", { error: toErrorMessage(persistError) });
+          logger14.warn("SQLite pattern usage persist failed", { error: toErrorMessage(persistError) });
         }
         if (result.success) {
           this.stats.learningOutcomes++;
           if (outcome.success) {
             this.stats.successfulOutcomes++;
           }
-          getWitnessChain().then((wc) => wc.append("PATTERN_UPDATE", { patternId: outcome.patternId, success: outcome.success }, "reasoning-bank")).catch(() => {
+          getWitnessChain().then((wc) => wc.append("PATTERN_UPDATE", { patternId: outcome.patternId, success: outcome.success }, "reasoning-bank")).catch((e20) => {
+            logger14.warn("Witness chain PATTERN_UPDATE failed", { error: toErrorMessage(e20) });
           });
           const pattern = await this.getPattern(outcome.patternId);
           if (pattern && await this.checkPatternPromotionWithCoherence(pattern)) {
             await this.promotePattern(outcome.patternId);
-            logger13.info("Pattern promoted to long-term", { name: pattern.name });
+            logger14.info("Pattern promoted to long-term", { name: pattern.name });
           }
         }
         return result;
@@ -145511,7 +146189,7 @@ On promotion:
                 payload: event
               });
             }
-            logger13.info("Pattern promotion blocked due to coherence violation", {
+            logger14.info("Pattern promotion blocked due to coherence violation", {
               name: pattern.name,
               energy: coherenceResult.energy
             });
@@ -145540,7 +146218,7 @@ On promotion:
           try {
             this.getSqliteStore().promotePattern(patternId);
           } catch (e20) {
-            logger13.warn("SQLite pattern promotion persist failed", { error: toErrorMessage(e20) });
+            logger14.warn("SQLite pattern promotion persist failed", { error: toErrorMessage(e20) });
           }
           if (this.rvfDualWriter) {
             try {
@@ -145549,12 +146227,13 @@ On promotion:
                 this.rvfDualWriter.writePattern(patternId, promoted.embedding);
               }
             } catch (rvfErr) {
-              logger13.warn("RVF dual-write on promote failed (non-fatal)", { patternId, error: toErrorMessage(rvfErr) });
+              logger14.warn("RVF dual-write on promote failed (non-fatal)", { patternId, error: toErrorMessage(rvfErr) });
             }
           }
-          getWitnessChain().then((wc) => wc.append("PATTERN_PROMOTE", { patternId }, "reasoning-bank")).catch(() => {
+          getWitnessChain().then((wc) => wc.append("PATTERN_PROMOTE", { patternId }, "reasoning-bank")).catch((e20) => {
+            logger14.warn("Witness chain PATTERN_PROMOTE failed", { error: toErrorMessage(e20) });
           });
-          logger13.info("Promoted pattern to long-term", { patternId });
+          logger14.info("Promoted pattern to long-term", { patternId });
           if (this.eventBus) {
             await this.eventBus.publish({
               id: `pattern-promoted-${patternId}`,
@@ -145565,7 +146244,7 @@ On promotion:
             });
           }
         } else {
-          logger13.error("Failed to promote pattern", result.error, { patternId });
+          logger14.error("Failed to promote pattern", result.error, { patternId });
         }
       }
       /**
@@ -145691,7 +146370,7 @@ On promotion:
             return embedding;
           } catch (error) {
             if (process.env.DEBUG) {
-              logger13.warn("ONNX embeddings unavailable, using hash fallback", {
+              logger14.warn("ONNX embeddings unavailable, using hash fallback", {
                 error: toErrorMessage(error)
               });
             }
@@ -145813,8 +146492,8 @@ On promotion:
 });
 
 // src/adapters/claude-flow/detect.ts
-import { existsSync as existsSync19, readFileSync as readFileSync14 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync16 } from "node:fs";
+import { join as join29 } from "node:path";
 import { execSync as execSync7 } from "node:child_process";
 function detectClaudeFlow(projectRoot) {
   if (cachedResult && Date.now() - cacheTimestamp < CACHE_TTL_MS2) {
@@ -145835,20 +146514,20 @@ function doDetection(projectRoot) {
   return { available: false };
 }
 function checkMCPConfig(projectRoot) {
-  const mcpJsonPath = join27(projectRoot, ".claude", "mcp.json");
-  if (existsSync19(mcpJsonPath)) {
+  const mcpJsonPath = join29(projectRoot, ".claude", "mcp.json");
+  if (existsSync21(mcpJsonPath)) {
     try {
-      const config = safeJsonParse(readFileSync14(mcpJsonPath, "utf-8"));
+      const config = safeJsonParse(readFileSync16(mcpJsonPath, "utf-8"));
       if (config.mcpServers?.["claude-flow"]) {
         return { available: true, method: "mcp-config" };
       }
     } catch {
     }
   }
-  const settingsPath = join27(projectRoot, ".claude", "settings.json");
-  if (existsSync19(settingsPath)) {
+  const settingsPath = join29(projectRoot, ".claude", "settings.json");
+  if (existsSync21(settingsPath)) {
     try {
-      const settings = safeJsonParse(readFileSync14(settingsPath, "utf-8"));
+      const settings = safeJsonParse(readFileSync16(settingsPath, "utf-8"));
       const servers = settings.mcpServers || settings.mcp?.servers || {};
       if (servers["claude-flow"] || servers["@anthropic/claude-flow"]) {
         return { available: true, method: "mcp-config" };
@@ -145859,10 +146538,10 @@ function checkMCPConfig(projectRoot) {
   return null;
 }
 function checkPackageJson(projectRoot) {
-  const packageJsonPath = join27(projectRoot, "package.json");
-  if (!existsSync19(packageJsonPath)) return null;
+  const packageJsonPath = join29(projectRoot, "package.json");
+  if (!existsSync21(packageJsonPath)) return null;
   try {
-    const pkg2 = safeJsonParse(readFileSync14(packageJsonPath, "utf-8"));
+    const pkg2 = safeJsonParse(readFileSync16(packageJsonPath, "utf-8"));
     const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
     if (deps["@claude-flow/cli"] || deps["claude-flow"]) {
       return { available: true, method: "npm-dependency" };
@@ -145929,10 +146608,14 @@ var init_trajectory_bridge = __esm({
         const id = `trajectory-${randomUUID18()}`;
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const agentArg = agent ? `--agent ${this.escapeArg(agent)}` : "";
-            const result = execSync8(
-              `npx --no-install @claude-flow/cli hooks intelligence trajectory-start --task ${this.escapeArg(task)} ${agentArg}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const args = ["--no-install", "@claude-flow/cli", "hooks", "intelligence", "trajectory-start", "--task", task];
+            if (agent) {
+              args.push("--agent", agent);
+            }
+            const result = execFileSync2(
+              "npx",
+              args,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             const match = result.match(/trajectoryId[:\s]+["']?([^"'\s,}]+)/i);
@@ -145958,11 +146641,17 @@ var init_trajectory_bridge = __esm({
       async recordStep(trajectoryId, action, result, quality) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const resultArg = result ? `--result ${this.escapeArg(result)}` : "";
-            const qualityArg = quality !== void 0 ? `--quality ${quality}` : "";
-            execSync8(
-              `npx --no-install @claude-flow/cli hooks intelligence trajectory-step --trajectory-id ${this.escapeArg(trajectoryId)} --action ${this.escapeArg(action)} ${resultArg} ${qualityArg}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const args = ["--no-install", "@claude-flow/cli", "hooks", "intelligence", "trajectory-step", "--trajectory-id", trajectoryId, "--action", action];
+            if (result) {
+              args.push("--result", result);
+            }
+            if (quality !== void 0) {
+              args.push("--quality", String(quality));
+            }
+            execFileSync2(
+              "npx",
+              args,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             return;
@@ -145987,10 +146676,14 @@ var init_trajectory_bridge = __esm({
       async endTrajectory(trajectoryId, success, feedback) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const feedbackArg = feedback ? `--feedback ${this.escapeArg(feedback)}` : "";
-            execSync8(
-              `npx --no-install @claude-flow/cli hooks intelligence trajectory-end --trajectory-id ${this.escapeArg(trajectoryId)} --success ${success} ${feedbackArg}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const args = ["--no-install", "@claude-flow/cli", "hooks", "intelligence", "trajectory-end", "--trajectory-id", trajectoryId, "--success", String(success)];
+            if (feedback) {
+              args.push("--feedback", feedback);
+            }
+            execFileSync2(
+              "npx",
+              args,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
           } catch {
@@ -146023,14 +146716,14 @@ var init_trajectory_bridge = __esm({
        */
       async persistTrajectory(trajectory) {
         try {
-          const { join: join39 } = await import("path");
-          const { existsSync: existsSync28, mkdirSync: mkdirSync7 } = await import("fs");
+          const { join: join41 } = await import("path");
+          const { existsSync: existsSync30, mkdirSync: mkdirSync7 } = await import("fs");
           const { createRequire: createRequire13 } = await import("module");
           const require3 = createRequire13(import.meta.url);
           const { openDatabase: openDatabase2 } = require3("../../shared/safe-db.js");
-          const dbPath = join39(this.options.projectRoot, ".agentic-qe", "trajectories.db");
-          const dir = join39(this.options.projectRoot, ".agentic-qe");
-          if (!existsSync28(dir)) {
+          const dbPath = join41(this.options.projectRoot, ".agentic-qe", "trajectories.db");
+          const dir = join41(this.options.projectRoot, ".agentic-qe");
+          if (!existsSync30(dir)) {
             mkdirSync7(dir, { recursive: true });
           }
           const db = openDatabase2(dbPath);
@@ -146066,15 +146759,6 @@ var init_trajectory_bridge = __esm({
           console.debug("[TrajectoryBridge] Trajectory persistence failed:", error instanceof Error ? error.message : error);
         }
       }
-      /**
-       * Escape shell argument using $'...' syntax for complete safety
-       * This ANSI-C quoting handles ALL special characters including backslashes
-       * CodeQL: js/incomplete-sanitization - Fixed by escaping backslashes AND quotes
-       */
-      escapeArg(arg) {
-        const escaped = arg.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-        return "$'" + escaped + "'";
-      }
     };
   }
 });
@@ -146136,9 +146820,10 @@ var init_model_router_bridge = __esm({
       async routeTask(task) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const result = execSync8(
-              `npx --no-install @claude-flow/cli hooks model-route --task ${this.escapeArg(task)}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const result = execFileSync2(
+              "npx",
+              ["--no-install", "@claude-flow/cli", "hooks", "model-route", "--task", task],
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             const modelMatch = result.match(/model[:\s]+["']?(haiku|sonnet|opus)/i);
@@ -146167,9 +146852,10 @@ var init_model_router_bridge = __esm({
         }
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            execSync8(
-              `npx --no-install @claude-flow/cli hooks model-outcome --task ${this.escapeArg(outcome.task)} --model ${outcome.model} --outcome ${outcome.outcome}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            execFileSync2(
+              "npx",
+              ["--no-install", "@claude-flow/cli", "hooks", "model-outcome", "--task", outcome.task, "--model", outcome.model, "--outcome", outcome.outcome],
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
           } catch (error) {
@@ -146248,15 +146934,6 @@ var init_model_router_bridge = __esm({
           reasoning: "Medium complexity task - using sonnet for balance"
         };
       }
-      /**
-       * Escape shell argument using $'...' syntax for complete safety
-       * This ANSI-C quoting handles ALL special characters including backslashes
-       * CodeQL: js/incomplete-sanitization - Fixed by escaping backslashes AND quotes
-       */
-      escapeArg(arg) {
-        const escaped = arg.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-        return "$'" + escaped + "'";
-      }
     };
   }
 });
@@ -146299,9 +146976,10 @@ var init_pretrain_bridge = __esm({
         }
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const result = execSync8(
-              `npx --no-install @claude-flow/cli hooks pretrain --path ${this.escapeArg(targetPath)} --depth ${depth}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const result = execFileSync2(
+              "npx",
+              ["--no-install", "@claude-flow/cli", "hooks", "pretrain", "--path", targetPath, "--depth", depth],
               { encoding: "utf-8", timeout: 12e4, cwd: this.options.projectRoot }
             );
             try {
@@ -146334,9 +147012,10 @@ var init_pretrain_bridge = __esm({
       async generateAgentConfigs(format = "yaml") {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const result = execSync8(
-              `npx --no-install @claude-flow/cli hooks build-agents --format ${format}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const result = execFileSync2(
+              "npx",
+              ["--no-install", "@claude-flow/cli", "hooks", "build-agents", "--format", format],
               { encoding: "utf-8", timeout: 6e4, cwd: this.options.projectRoot }
             );
             try {
@@ -146357,9 +147036,10 @@ var init_pretrain_bridge = __esm({
       async transferPatterns(sourcePath, minConfidence = 0.7) {
         if (this.claudeFlowAvailable) {
           try {
-            const { execSync: execSync8 } = await import("child_process");
-            const result = execSync8(
-              `npx --no-install @claude-flow/cli hooks transfer --source-path ${this.escapeArg(sourcePath)} --min-confidence ${minConfidence}`,
+            const { execFileSync: execFileSync2 } = await import("child_process");
+            const result = execFileSync2(
+              "npx",
+              ["--no-install", "@claude-flow/cli", "hooks", "transfer", "--source-path", sourcePath, "--min-confidence", String(minConfidence)],
               { encoding: "utf-8", timeout: 6e4, cwd: this.options.projectRoot }
             );
             const transferredMatch = result.match(/transferred[:\s]+(\d+)/i);
@@ -146380,23 +147060,14 @@ var init_pretrain_bridge = __esm({
       isClaudeFlowAvailable() {
         return this.claudeFlowAvailable;
       }
-      /**
-       * Escape shell argument using $'...' syntax for complete safety
-       * This ANSI-C quoting handles ALL special characters including backslashes
-       * CodeQL: js/incomplete-sanitization - Fixed by escaping backslashes AND quotes
-       */
-      escapeArg(arg) {
-        const escaped = arg.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-        return "$'" + escaped + "'";
-      }
       /**
        * Local analysis using file system scanning
        */
       async localAnalyze(targetPath, depth) {
         try {
           const glob = await import("fast-glob");
-          const { existsSync: existsSync28, readFileSync: readFileSync21 } = await import("fs");
-          const { join: join39 } = await import("path");
+          const { existsSync: existsSync30, readFileSync: readFileSync23 } = await import("fs");
+          const { join: join41 } = await import("path");
           const patterns = depth === "shallow" ? ["*.ts", "*.js", "*.json"] : depth === "medium" ? ["**/*.ts", "**/*.js", "**/*.json", "**/*.py"] : ["**/*"];
           const ignore = ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
           const files = await glob.default(patterns, {
@@ -146413,10 +147084,10 @@ var init_pretrain_bridge = __esm({
             if (file.endsWith(".go")) languages.add("go");
             if (file.endsWith(".rs")) languages.add("rust");
           }
-          const packageJsonPath = join39(targetPath, "package.json");
-          if (existsSync28(packageJsonPath)) {
+          const packageJsonPath = join41(targetPath, "package.json");
+          if (existsSync30(packageJsonPath)) {
             try {
-              const pkg2 = safeJsonParse(readFileSync21(packageJsonPath, "utf-8"));
+              const pkg2 = safeJsonParse(readFileSync23(packageJsonPath, "utf-8"));
               const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
               if (deps.react) frameworks.add("react");
               if (deps.vue) frameworks.add("vue");
@@ -146563,7 +147234,7 @@ function computeBinaryReward(outcome) {
 function createExperienceCaptureService(memory, patternStore, eventBus, config) {
   return new ExperienceCaptureService(memory, patternStore, eventBus, config);
 }
-var logger14, TEST_OUTCOME_REWARDS, VALID_TEST_OUTCOMES, DEFAULT_EXPERIENCE_CONFIG, ExperienceCaptureService;
+var logger15, TEST_OUTCOME_REWARDS, VALID_TEST_OUTCOMES, DEFAULT_EXPERIENCE_CONFIG, ExperienceCaptureService;
 var init_experience_capture = __esm({
   "src/learning/experience-capture.ts"() {
     "use strict";
@@ -146571,7 +147242,7 @@ var init_experience_capture = __esm({
     init_types();
     init_logging();
     init_qe_patterns();
-    logger14 = LoggerFactory.create("experience-capture");
+    logger15 = LoggerFactory.create("experience-capture");
     TEST_OUTCOME_REWARDS = {
       "catches-bug": 1,
       "flaky": -1,
@@ -146737,7 +147408,7 @@ var init_experience_capture = __esm({
           this.activeExperiences.delete(id);
           flushed++;
         }
-        logger14.info(`Flushed ${flushed} pending experiences before compaction`);
+        logger15.info(`Flushed ${flushed} pending experiences before compaction`);
         return flushed;
       }
       /**
@@ -147161,7 +147832,7 @@ Duration: ${experience.durationMs}ms`;
             this.stats.byDomain = new Map(savedStats.byDomain);
           }
         } catch (e20) {
-          logger14.debug("Stats restoration failed, starting fresh", { error: e20 instanceof Error ? e20.message : String(e20) });
+          logger15.debug("Stats restoration failed, starting fresh", { error: e20 instanceof Error ? e20.message : String(e20) });
         }
       }
       /**
@@ -150029,8 +150700,8 @@ var init_prime_radiant_advanced_wasm = __esm({
 // src/integrations/coherence/wasm-loader.ts
 import { createRequire as createRequire10 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname5, join as join28 } from "node:path";
-import { readFileSync as readFileSync15, existsSync as existsSync20 } from "node:fs";
+import { dirname as dirname5, join as join30 } from "node:path";
+import { readFileSync as readFileSync17, existsSync as existsSync22 } from "node:fs";
 var FALLBACK_RETRY_DELAYS_MS, WasmLoader, wasmLoader;
 var init_wasm_loader = __esm({
   "src/integrations/coherence/wasm-loader.ts"() {
@@ -150294,15 +150965,15 @@ var init_wasm_loader = __esm({
             (() => {
               try {
                 const modulePath = require3.resolve("prime-radiant-advanced-wasm");
-                return join28(dirname5(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
+                return join30(dirname5(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
               } catch {
                 return null;
               }
             })(),
-            join28(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
+            join30(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
           ].filter((p74) => p74 !== null);
           for (const path31 of wasmPaths) {
-            if (existsSync20(path31)) {
+            if (existsSync22(path31)) {
               return true;
             }
           }
@@ -150553,19 +151224,19 @@ var init_wasm_loader = __esm({
           (() => {
             try {
               const modulePath = require3.resolve("prime-radiant-advanced-wasm");
-              return join28(dirname5(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
+              return join30(dirname5(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
             } catch {
               return null;
             }
           })(),
           // Direct node_modules path from current file
-          join28(dirname5(fileURLToPath2(import.meta.url)), "../../../../node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm"),
+          join30(dirname5(fileURLToPath2(import.meta.url)), "../../../../node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm"),
           // Workspace root
-          join28(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
+          join30(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
         ].filter((p74) => p74 !== null);
         let wasmPath = null;
         for (const path31 of wasmPaths) {
-          if (existsSync20(path31)) {
+          if (existsSync22(path31)) {
             wasmPath = path31;
             break;
           }
@@ -150577,7 +151248,7 @@ ${wasmPaths.join("\n")}
 Ensure prime-radiant-advanced-wasm is installed.`
           );
         }
-        const wasmBytes = readFileSync15(wasmPath);
+        const wasmBytes = readFileSync17(wasmPath);
         if (wasmModule2.initSync && typeof wasmModule2.initSync === "function") {
           wasmModule2.initSync({ module: wasmBytes });
         } else {
@@ -150775,7 +151446,7 @@ __export(rvf_native_adapter_exports, {
   openRvfStore: () => openRvfStore,
   openRvfStoreReadonly: () => openRvfStoreReadonly
 });
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync2, copyFileSync as copyFileSync2, existsSync as existsSync21 } from "fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync2, copyFileSync as copyFileSync2, existsSync as existsSync23 } from "fs";
 function getNative() {
   if (_nativeChecked) return _native;
   _nativeChecked = true;
@@ -150798,9 +151469,9 @@ function loadIdMap(rvfPath) {
   const strToNum = /* @__PURE__ */ new Map();
   const numToStr = /* @__PURE__ */ new Map();
   let nextLabel = 1;
-  if (existsSync21(p74)) {
+  if (existsSync23(p74)) {
     try {
-      const raw = JSON.parse(readFileSync16(p74, "utf-8"));
+      const raw = JSON.parse(readFileSync18(p74, "utf-8"));
       nextLabel = raw.nextLabel;
       for (const [str, num] of raw.entries) {
         strToNum.set(str, num);
@@ -152477,8 +153148,8 @@ var init_aqe_learning_engine = __esm({
       async localAnalyze(targetPath, depth) {
         try {
           const glob = await import("fast-glob");
-          const { existsSync: existsSync28, readFileSync: readFileSync21 } = await import("fs");
-          const { join: join39 } = await import("path");
+          const { existsSync: existsSync30, readFileSync: readFileSync23 } = await import("fs");
+          const { join: join41 } = await import("path");
           const patterns = depth === "shallow" ? ["*.ts", "*.js", "*.json"] : depth === "medium" ? ["**/*.ts", "**/*.js", "**/*.json", "**/*.py"] : ["**/*"];
           const ignore = ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
           const files = await glob.default(patterns, {
@@ -152495,10 +153166,10 @@ var init_aqe_learning_engine = __esm({
             if (file.endsWith(".go")) languages.add("go");
             if (file.endsWith(".rs")) languages.add("rust");
           }
-          const packageJsonPath = join39(targetPath, "package.json");
-          if (existsSync28(packageJsonPath)) {
+          const packageJsonPath = join41(targetPath, "package.json");
+          if (existsSync30(packageJsonPath)) {
             try {
-              const pkg2 = safeJsonParse(readFileSync21(packageJsonPath, "utf-8"));
+              const pkg2 = safeJsonParse(readFileSync23(packageJsonPath, "utf-8"));
               const deps = { ...pkg2.dependencies, ...pkg2.devDependencies };
               if (deps.react) frameworks.add("react");
               if (deps.vue) frameworks.add("vue");
@@ -154478,13 +155149,15 @@ ${parts.join(" | ")}`;
 function formatCostUsd(cost) {
   return `$${cost.toFixed(2)}`;
 }
-var DEFAULT_COST_CONFIG, DEFAULT_PERSISTENCE_CONFIG2, TokenMetricsCollectorImpl, TokenMetricsCollector;
+var ttLogger, DEFAULT_COST_CONFIG, DEFAULT_PERSISTENCE_CONFIG2, TokenMetricsCollectorImpl, TokenMetricsCollector;
 var init_token_tracker = __esm({
   "src/learning/token-tracker.ts"() {
     "use strict";
     init_unified_memory();
     init_error_utils();
     init_safe_json();
+    init_logger_factory();
+    ttLogger = createLogger("TokenTracker");
     DEFAULT_COST_CONFIG = {
       costPerInputToken: 3e-3 / 1e3,
       // $3 per 1M input tokens
@@ -154537,7 +155210,8 @@ var init_token_tracker = __esm({
         if (config) {
           this.costConfig = { ...DEFAULT_COST_CONFIG, ...config };
         }
-        this.initializeDb().catch(() => {
+        this.initializeDb().catch((e20) => {
+          ttLogger.warn("DB initialization failed", { error: e20 instanceof Error ? e20.message : String(e20) });
         });
         this.startAutoSave();
       }
@@ -155017,7 +155691,8 @@ var init_token_tracker = __esm({
         this.kvPersistCount++;
         if (this.kvPersistCount >= _TokenMetricsCollectorImpl.KV_PERSIST_INTERVAL) {
           this.kvPersistCount = 0;
-          this.persistToKv().catch(() => {
+          this.persistToKv().catch((e20) => {
+            ttLogger.warn("KV persist failed", { error: e20 instanceof Error ? e20.message : String(e20) });
           });
         }
       }
@@ -156166,11 +156841,11 @@ async function parseJSONCoverage(jsonPath, projectRoot) {
 }
 async function parseCoverage(coveragePath, projectRoot) {
   const ext = path24.extname(coveragePath).toLowerCase();
-  const basename9 = path24.basename(coveragePath).toLowerCase();
-  if (ext === ".json" || basename9.includes("coverage-final")) {
+  const basename10 = path24.basename(coveragePath).toLowerCase();
+  if (ext === ".json" || basename10.includes("coverage-final")) {
     return parseJSONCoverage(coveragePath, projectRoot);
   }
-  if (basename9 === "lcov.info" || ext === ".info" || basename9.includes("lcov")) {
+  if (basename10 === "lcov.info" || ext === ".info" || basename10.includes("lcov")) {
     return parseLCOV(coveragePath, projectRoot);
   }
   const content = await fs24.readFile(coveragePath, "utf-8");
@@ -157630,8 +158305,8 @@ var init_types20 = __esm({
 });
 
 // src/domains/requirements-validation/services/quality-criteria/quality-criteria-service.ts
-import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync19 } from "fs";
+import { join as join33 } from "path";
 function createQualityCriteriaService(config) {
   return new QualityCriteriaService(config);
 }
@@ -157657,14 +158332,14 @@ var init_quality_criteria_service = __esm({
       findTemplatePath() {
         const possiblePaths = [
           // Relative to v3 package
-          join31(process.cwd(), ".claude/helpers/v3/quality-criteria/quality-criteria-reference-template.html"),
+          join33(process.cwd(), ".claude/helpers/v3/quality-criteria/quality-criteria-reference-template.html"),
           // In node_modules
-          join31(process.cwd(), "node_modules/agentic-qe/assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html"),
+          join33(process.cwd(), "node_modules/agentic-qe/assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html"),
           // Development path
-          join31(__dirname, "../../../../../assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html")
+          join33(__dirname, "../../../../../assets/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html")
         ];
         for (const path31 of possiblePaths) {
-          if (existsSync23(path31)) {
+          if (existsSync25(path31)) {
             return path31;
           }
         }
@@ -157681,8 +158356,8 @@ var init_quality_criteria_service = __esm({
        */
       analyze(input) {
         let epicContent = input.epicContent || "";
-        if (input.epicPath && existsSync23(input.epicPath)) {
-          epicContent = readFileSync17(input.epicPath, "utf-8");
+        if (input.epicPath && existsSync25(input.epicPath)) {
+          epicContent = readFileSync19(input.epicPath, "utf-8");
         }
         if (!epicContent && !input.epicPath) {
           throw new Error("Either epicPath or epicContent is required for analysis");
@@ -157848,8 +158523,8 @@ Analyze the requirements above and return the complete QualityCriteriaAnalysis.`
        * Generate HTML output
        */
       generateHTML(analysis) {
-        if (!this.templateCache && existsSync23(this.config.templatePath)) {
-          this.templateCache = readFileSync17(this.config.templatePath, "utf-8");
+        if (!this.templateCache && existsSync25(this.config.templatePath)) {
+          this.templateCache = readFileSync19(this.config.templatePath, "utf-8");
         }
         if (!this.templateCache) {
           return this.generateFallbackHTML(analysis);
@@ -157990,7 +158665,7 @@ var init_requirements_validation = __esm({
 });
 
 // src/mcp/tools/requirements-validation/quality-criteria.ts
-import { existsSync as existsSync24, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
 var QualityCriteriaTool, QUALITY_CRITERIA_SCHEMA, qualityCriteriaTool;
 var init_quality_criteria2 = __esm({
   "src/mcp/tools/requirements-validation/quality-criteria.ts"() {
@@ -158096,8 +158771,8 @@ var init_quality_criteria2 = __esm({
             message: "Preparing agent invocation for semantic HTSM analysis"
           });
           let content = epicContent || "";
-          if (epicPath && existsSync24(epicPath)) {
-            content = readFileSync18(epicPath, "utf-8");
+          if (epicPath && existsSync26(epicPath)) {
+            content = readFileSync20(epicPath, "utf-8");
           }
           if (!content && !epicPath) {
             return {
@@ -165846,19 +166521,6 @@ var init_check = __esm({
   }
 });
 
-// src/learning/v2-to-v3-migration.ts
-var logger15;
-var init_v2_to_v3_migration = __esm({
-  "src/learning/v2-to-v3-migration.ts"() {
-    "use strict";
-    init_safe_db();
-    init_error_utils();
-    init_safe_json();
-    init_logging();
-    logger15 = LoggerFactory.create("v2-to-v3-migration");
-  }
-});
-
 // src/learning/qe-unified-memory.ts
 var logger16, QE_DOMAIN_HNSW_CONFIGS, DEFAULT_QE_UNIFIED_MEMORY_CONFIG;
 var init_qe_unified_memory = __esm({
@@ -165866,7 +166528,6 @@ var init_qe_unified_memory = __esm({
     "use strict";
     init_logging();
     init_types();
-    init_v2_to_v3_migration();
     init_types2();
     init_error_utils();
     init_hnsw_index();
@@ -166399,42 +167060,42 @@ var init_pattern_lifecycle = __esm({
       // Experience Extraction
       // ============================================================================
       /**
-       * Get recent experiences from learning_experiences table
+       * Get recent experiences from captured_experiences table.
        */
       getRecentExperiences(options = {}) {
         const minReward = options.minReward ?? this.config.promotionRewardThreshold;
         const limit = options.limit ?? 100;
         const sinceDays = options.sinceDays ?? 7;
-        const sinceTimestamp = Date.now() - sinceDays * 24 * 60 * 60 * 1e3;
-        const tableExists2 = this.db.prepare(`
-      SELECT name FROM sqlite_master
-      WHERE type='table' AND name='learning_experiences'
-    `).get();
+        const tableExists2 = this.db.prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name='captured_experiences'"
+        ).get();
         if (!tableExists2) {
-          console.log("[PatternLifecycle] learning_experiences table not found");
+          logger19.debug("captured_experiences table not found");
           return [];
         }
+        const sinceDate = new Date(Date.now() - sinceDays * 864e5).toISOString().replace("T", " ").slice(0, 19);
         const aggregates = this.db.prepare(`
       SELECT
-        task_type,
+        domain as task_type,
         COUNT(*) as count,
-        AVG(reward) as avg_reward,
-        MAX(reward) as max_reward,
-        MIN(reward) as min_reward,
-        SUM(CASE WHEN reward >= ? THEN 1 ELSE 0 END) as success_count,
-        GROUP_CONCAT(DISTINCT action) as actions,
-        MAX(created_at) as latest_at
-      FROM learning_experiences
-      WHERE created_at >= ? AND reward >= ?
-      GROUP BY task_type
+        AVG(quality) as avg_reward,
+        MAX(quality) as max_reward,
+        MIN(quality) as min_reward,
+        SUM(CASE WHEN quality >= ? THEN 1 ELSE 0 END) as success_count,
+        GROUP_CONCAT(DISTINCT agent) as actions,
+        MAX(started_at) as latest_at
+      FROM captured_experiences
+      WHERE started_at >= ?
+        AND quality >= ?
+        AND agent != 'cli-hook'
+      GROUP BY domain
       HAVING COUNT(*) >= ?
       ORDER BY avg_reward DESC
       LIMIT ?
     `).all(
           minReward,
-          sinceTimestamp,
+          sinceDate,
           minReward * 0.5,
-          // Include experiences above half threshold for context
           this.config.promotionMinOccurrences,
           limit
         );
@@ -167120,7 +167781,6 @@ var init_learning = __esm({
     init_real_embeddings();
     init_sqlite_persistence();
     init_qe_unified_memory();
-    init_v2_to_v3_migration();
     init_token_tracker();
     init_dream();
     init_aqe_learning_engine();
@@ -169621,7 +170281,7 @@ var init_vitest_executor = __esm({
 
 // src/test-scheduling/git-aware/test-selector.ts
 import { spawn as spawn6 } from "child_process";
-import { resolve as resolve7, dirname as dirname8, basename as basename6 } from "path";
+import { resolve as resolve7, dirname as dirname8, basename as basename7 } from "path";
 function createTestSelector(config) {
   return new GitAwareTestSelector(config);
 }
@@ -169842,7 +170502,7 @@ var init_test_selector = __esm({
             continue;
           }
           const relatedTests = impactResult.value.filter(
-            (test) => test.includes(basename6(changedFile.path, ".ts").replace(/\.(tsx?|jsx?)$/, ""))
+            (test) => test.includes(basename7(changedFile.path, ".ts").replace(/\.(tsx?|jsx?)$/, ""))
           );
           if (relatedTests.length > 0) {
             mappings.push({
@@ -169862,7 +170522,7 @@ var init_test_selector = __esm({
         return /^(vitest\.config|jest\.config|tsconfig|package\.json)/.test(path31);
       }
       async findTestsHeuristically(sourcePath) {
-        const baseName = basename6(sourcePath, ".ts").replace(/\.(tsx?|jsx?)$/, "");
+        const baseName = basename7(sourcePath, ".ts").replace(/\.(tsx?|jsx?)$/, "");
         const dir = dirname8(sourcePath);
         const candidates = [
           `${dir}/${baseName}.test.ts`,
@@ -172295,7 +172955,7 @@ var init_visual_security = __esm({
 
 // src/workflows/browser/workflow-loader.ts
 import { readFile as readFile16, readdir as readdir5 } from "fs/promises";
-import { join as join34, basename as basename7 } from "path";
+import { join as join36, basename as basename8 } from "path";
 import { parse as parseYaml2 } from "yaml";
 function interpolateVariables(template, variables) {
   return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
@@ -172329,7 +172989,7 @@ var init_workflow_loader = __esm({
       templatesDir;
       cache = /* @__PURE__ */ new Map();
       constructor(templatesDir) {
-        this.templatesDir = templatesDir || join34(__dirname, "templates");
+        this.templatesDir = templatesDir || join36(__dirname, "templates");
       }
       /**
        * Load a workflow template by name
@@ -172339,7 +172999,7 @@ var init_workflow_loader = __esm({
           return this.cache.get(templateName);
         }
         try {
-          const templatePath = join34(this.templatesDir, `${templateName}.yaml`);
+          const templatePath = join36(this.templatesDir, `${templateName}.yaml`);
           const content = await readFile16(templatePath, "utf-8");
           const workflow = parseYaml2(content);
           const validation = await this.validate(workflow);
@@ -172364,7 +173024,7 @@ ${validation.errors.join("\n")}`
       async list() {
         try {
           const files = await readdir5(this.templatesDir);
-          return files.filter((file) => file.endsWith(".yaml") || file.endsWith(".yml")).map((file) => basename7(file, file.endsWith(".yaml") ? ".yaml" : ".yml")).sort();
+          return files.filter((file) => file.endsWith(".yaml") || file.endsWith(".yml")).map((file) => basename8(file, file.endsWith(".yaml") ? ".yaml" : ".yml")).sort();
         } catch (error) {
           if (error.code === "ENOENT") {
             return [];
@@ -172480,7 +173140,7 @@ ${validation.errors.join("\n")}`
        */
       async getMetadata(templateName) {
         try {
-          const templatePath = join34(this.templatesDir, `${templateName}.yaml`);
+          const templatePath = join36(this.templatesDir, `${templateName}.yaml`);
           const content = await readFile16(templatePath, "utf-8");
           const workflow = parseYaml2(content);
           return {
@@ -175214,7 +175874,7 @@ async function handleAQEHealth() {
       success: true,
       data: {
         status: healthStatus,
-        version: true ? "3.7.20" : "3.7.2",
+        version: true ? "3.7.22" : "3.7.2",
         loadedDomains: domainCount,
         memory: memoryStats,
         hnsw: hnswStats,
@@ -183855,6 +184515,8 @@ async function handleAgentStatus(params) {
 init_esm_node();
 init_unified_memory();
 init_error_utils();
+init_logger_factory();
+var ecLogger = createLogger("ExperienceCapture");
 var EXPERIENCE_TIMEOUT_MS = 10 * 60 * 1e3;
 var CLEANUP_INTERVAL_MS = 2 * 60 * 1e3;
 var MAX_JSON_SIZE_BYTES = 1024 * 1024;
@@ -183934,15 +184596,15 @@ async function doInitialize() {
       ).get().cnt > 0;
       if (tableExists2) {
         const columns = db.prepare("PRAGMA table_info(captured_experiences)").all();
-        const colNames = new Set(columns.map((c70) => c70.name));
-        if (!colNames.has("success") || !colNames.has("task")) {
+        const colNames2 = new Set(columns.map((c70) => c70.name));
+        if (!colNames2.has("success") || !colNames2.has("task")) {
           db.exec("ALTER TABLE captured_experiences RENAME TO captured_experiences_v2_backup");
           needsCreate = true;
         } else {
-          if (!colNames.has("domain")) {
+          if (!colNames2.has("domain")) {
             db.exec("ALTER TABLE captured_experiences ADD COLUMN domain TEXT NOT NULL DEFAULT ''");
           }
-          if (!colNames.has("source")) {
+          if (!colNames2.has("source")) {
             db.exec("ALTER TABLE captured_experiences ADD COLUMN source TEXT DEFAULT 'middleware'");
           }
         }
@@ -183976,6 +184638,27 @@ async function doInitialize() {
         CREATE INDEX IF NOT EXISTS idx_captured_exp_agent ON captured_experiences(agent);
         CREATE INDEX IF NOT EXISTS idx_captured_exp_completed ON captured_experiences(completed_at DESC);
       `);
+      const colNames = new Set(
+        db.prepare("PRAGMA table_info(captured_experiences)").all().map((c70) => c70.name)
+      );
+      const consolidationCols = [
+        ["application_count", "INTEGER DEFAULT 0"],
+        ["avg_token_savings", "REAL DEFAULT 0"],
+        ["embedding", "BLOB"],
+        ["embedding_dimension", "INTEGER"],
+        ["tags", "TEXT"],
+        ["last_applied_at", "TEXT"],
+        ["consolidated_into", "TEXT DEFAULT NULL"],
+        ["consolidation_count", "INTEGER DEFAULT 1"],
+        ["quality_updated_at", "TEXT DEFAULT NULL"],
+        ["reuse_success_count", "INTEGER DEFAULT 0"],
+        ["reuse_failure_count", "INTEGER DEFAULT 0"]
+      ];
+      for (const [col, def] of consolidationCols) {
+        if (!colNames.has(col)) {
+          db.exec(`ALTER TABLE captured_experiences ADD COLUMN ${col} ${def}`);
+        }
+      }
     }
     startCleanupTimer();
     console.log("[ExperienceCaptureMiddleware] Initialized");
@@ -184067,7 +184750,8 @@ async function persistExperience(context, outcome) {
       context.startedAt.toISOString(),
       "middleware"
     );
-    computeExperienceEmbedding(db, outcome.id, context.task, context.domain).catch(() => {
+    computeExperienceEmbedding(db, outcome.id, context.task, context.domain).catch((e20) => {
+      ecLogger.warn("Embedding computation failed", { error: e20 instanceof Error ? e20.message : String(e20), experienceId: outcome.id, domain: context.domain });
     });
   } catch (error) {
     console.error("[ExperienceCaptureMiddleware] Failed to persist experience:", error);
@@ -185515,7 +186199,7 @@ async function handlePipelineValidate(params) {
 }
 
 // src/mcp/handlers/validation-pipeline-handler.ts
-import { readFileSync as readFileSync19, existsSync as existsSync26 } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync28 } from "fs";
 import { resolve as resolve8 } from "path";
 
 // src/validation/pipeline.ts
@@ -186239,14 +186923,14 @@ async function handleValidationPipeline(params) {
     content = params.content;
   } else if (params.filePath) {
     const absPath = resolve8(process.cwd(), params.filePath);
-    if (!existsSync26(absPath)) {
+    if (!existsSync28(absPath)) {
       return {
         success: false,
         error: `File not found: ${params.filePath}`
       };
     }
     try {
-      content = readFileSync19(absPath, "utf-8");
+      content = readFileSync21(absPath, "utf-8");
     } catch (readErr) {
       return {
         success: false,
@@ -188147,7 +188831,7 @@ async function quickStart(config) {
 // src/mcp/http-server.ts
 init_safe_json();
 import { createServer } from "http";
-import { join as join37, dirname as dirname10 } from "path";
+import { join as join39, dirname as dirname10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/adapters/a2a/agent-cards/schema.ts
@@ -191240,7 +191924,7 @@ init_error_utils();
 // src/adapters/a2a/agent-cards/generator.ts
 init_error_utils();
 import { readFile as readFile18, readdir as readdir7, stat as stat5 } from "fs/promises";
-import { join as join36, basename as basename8 } from "path";
+import { join as join38, basename as basename9 } from "path";
 var DEFAULT_GENERATOR_CONFIG = {
   baseUrl: "http://localhost:8080",
   defaultVersion: "3.0.0",
@@ -191576,7 +192260,7 @@ var AgentCardGenerator = class {
    */
   async generateFromFile(filePath) {
     const markdown = await readFile18(filePath, "utf-8");
-    const agentId = basename8(filePath, ".md");
+    const agentId = basename9(filePath, ".md");
     return this.generateFromMarkdown(markdown, agentId);
   }
   /**
@@ -191589,7 +192273,7 @@ var AgentCardGenerator = class {
     const processDirectory = async (dirPath) => {
       const entries = await readdir7(dirPath);
       for (const entry of entries) {
-        const fullPath = join36(dirPath, entry);
+        const fullPath = join38(dirPath, entry);
         const stats = await stat5(fullPath);
         if (stats.isDirectory() && recursive) {
           await processDirectory(fullPath);
@@ -193049,7 +193733,7 @@ var HTTPServerImpl = class {
     this.skipCRDTInit = config.skipCRDTInit ?? false;
     this.enableWebSocket = config.enableWebSocket ?? true;
     const currentDir = dirname10(fileURLToPath3(import.meta.url));
-    this.agentMarkdownDir = config.agentMarkdownDir ?? join37(currentDir, "../../assets/agents/v3");
+    this.agentMarkdownDir = config.agentMarkdownDir ?? join39(currentDir, "../../assets/agents/v3");
     this.taskStore = createTaskStore();
     this.taskManager = config.taskManager ?? createTaskManager({
       storeConfig: {}
@@ -194935,7 +195619,7 @@ function createInfraHealingOrchestratorSync(options) {
 init_global_instance();
 
 // src/mcp/entry.ts
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 import { resolve as resolve10, dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var require2 = createRequire12(import.meta.url);
@@ -195021,7 +195705,7 @@ async function main() {
       const playbookPath = resolve10(__dirname2, "../strange-loop/infra-healing/default-playbook.yaml");
       let playbookContent;
       try {
-        playbookContent = readFileSync20(playbookPath, "utf-8");
+        playbookContent = readFileSync22(playbookPath, "utf-8");
       } catch {
         playbookContent = [
           "services:",