agentic-qe 3.7.20 → 3.7.21

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"() {
@@ -5253,18 +5256,18 @@ var init_logger_factory = __esm({
           return this.instances.get(domain);
         }
         const level = this.getDomainLevel(domain);
-        let logger22;
+        let logger23;
         if (this.config.silent) {
-          logger22 = new NullLogger(domain);
+          logger23 = new NullLogger(domain);
         } else if (this.customProvider) {
-          logger22 = this.customProvider(domain, level, context);
+          logger23 = this.customProvider(domain, level, context);
         } else {
-          logger22 = new ConsoleLogger(domain, level, this.config.consoleConfig, context);
+          logger23 = new ConsoleLogger(domain, level, this.config.consoleConfig, context);
         }
         if (!context) {
-          this.instances.set(domain, logger22);
+          this.instances.set(domain, logger23);
         }
-        return logger22;
+        return logger23;
       }
       /**
        * Get a logger (alias for create)
@@ -54239,8 +54242,8 @@ function toVibiumAccessibilityResult(axeResults) {
     checkedAt: /* @__PURE__ */ new Date()
   };
 }
-function createBrowserOrchestrator(client, config, logger22) {
-  return new BrowserOrchestrator(client, config, logger22);
+function createBrowserOrchestrator(client, config, logger23) {
+  return new BrowserOrchestrator(client, config, logger23);
 }
 var BrowserOrchestrator;
 var init_browser_orchestrator = __esm({
@@ -54256,10 +54259,10 @@ var init_browser_orchestrator = __esm({
       config;
       log;
       adaptiveLocator = null;
-      constructor(client, config, logger22) {
+      constructor(client, config, logger23) {
         this.client = client;
         this.config = config;
-        this.log = logger22;
+        this.log = logger23;
         this.unifiedClient = config.browserClient ?? client;
         this.useAgentBrowser = isAgentBrowserClient(this.unifiedClient);
         if (config.adaptiveLocator?.enabled) {
@@ -54542,8 +54545,8 @@ var init_browser_orchestrator = __esm({
 });
 
 // src/domains/test-execution/services/e2e/assertion-handlers.ts
-function createAssertionHandlers(orchestrator, logger22) {
-  return new AssertionHandlers(orchestrator, logger22);
+function createAssertionHandlers(orchestrator, logger23) {
+  return new AssertionHandlers(orchestrator, logger23);
 }
 var AssertionHandlers;
 var init_assertion_handlers = __esm({
@@ -54554,9 +54557,9 @@ var init_assertion_handlers = __esm({
     AssertionHandlers = class {
       orchestrator;
       log;
-      constructor(orchestrator, logger22) {
+      constructor(orchestrator, logger23) {
         this.orchestrator = orchestrator;
-        this.log = logger22;
+        this.log = logger23;
       }
       // ==========================================================================
       // Unified Browser Client Assertions
@@ -55082,8 +55085,8 @@ var init_wait_condition_handler = __esm({
 });
 
 // src/domains/test-execution/services/e2e/step-executors.ts
-function createStepExecutors(config, orchestrator, logger22) {
-  return new StepExecutors(config, orchestrator, logger22);
+function createStepExecutors(config, orchestrator, logger23) {
+  return new StepExecutors(config, orchestrator, logger23);
 }
 var StepExecutors;
 var init_step_executors = __esm({
@@ -55101,12 +55104,12 @@ var init_step_executors = __esm({
       assertionHandlers;
       waitConditionHandler;
       log;
-      constructor(config, orchestrator, logger22) {
+      constructor(config, orchestrator, logger23) {
         this.config = config;
         this.orchestrator = orchestrator;
-        this.assertionHandlers = createAssertionHandlers(orchestrator, logger22);
+        this.assertionHandlers = createAssertionHandlers(orchestrator, logger23);
         this.waitConditionHandler = createWaitConditionHandler(orchestrator);
-        this.log = logger22;
+        this.log = logger23;
       }
       /**
        * Execute a single step based on its type
@@ -55848,8 +55851,8 @@ var init_safe_expression_evaluator = __esm({
 });
 
 // src/domains/test-execution/services/e2e/step-retry-handler.ts
-function createStepRetryHandler(config, stepExecutors, logger22) {
-  return new StepRetryHandler(config, stepExecutors, logger22);
+function createStepRetryHandler(config, stepExecutors, logger23) {
+  return new StepRetryHandler(config, stepExecutors, logger23);
 }
 var StepRetryHandler;
 var init_step_retry_handler = __esm({
@@ -55862,10 +55865,10 @@ var init_step_retry_handler = __esm({
       config;
       stepExecutors;
       log;
-      constructor(config, stepExecutors, logger22) {
+      constructor(config, stepExecutors, logger23) {
         this.config = config;
         this.stepExecutors = stepExecutors;
-        this.log = logger22;
+        this.log = logger23;
       }
       /**
        * Execute a step with retry logic
@@ -56120,10 +56123,10 @@ var init_e2e_coordinator = __esm({
       constructor(client, config = {}) {
         this.client = client;
         this.config = { ...DEFAULT_E2E_RUNNER_CONFIG, ...config };
-        const logger22 = (message) => this.log(message);
-        this.orchestrator = createBrowserOrchestrator(client, this.config, logger22);
-        this.stepExecutors = createStepExecutors(this.config, this.orchestrator, logger22);
-        this.retryHandler = createStepRetryHandler(this.config, this.stepExecutors, logger22);
+        const logger23 = (message) => this.log(message);
+        this.orchestrator = createBrowserOrchestrator(client, this.config, logger23);
+        this.stepExecutors = createStepExecutors(this.config, this.orchestrator, logger23);
+        this.retryHandler = createStepRetryHandler(this.config, this.stepExecutors, logger23);
         this.resultCollector = createResultCollector();
         this.log(
           `E2E Runner initialized with ${this.orchestrator.isUsingAgentBrowser() ? "agent-browser" : "vibium"} client`
@@ -57291,6 +57294,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);
           }
@@ -84551,8 +84555,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 +85047,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 +85230,7 @@ var init_sast_scanner = __esm({
     init_security_patterns();
     init_error_utils();
     init_safe_json();
+    init_semgrep_integration();
     SASTScanner = class {
       config;
       memory;
@@ -85072,7 +85252,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 +85270,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 +85304,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 +88117,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 +88268,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 +88994,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 +89480,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 +89534,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 +101578,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 +102088,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 +102432,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 +115131,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 +119219,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 +124333,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 +124353,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 +125196,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 +125438,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 +125526,10 @@ var init_queen_coordinator = __esm({
       hypothesisManager = null;
       federationMailbox = null;
       dynamicScaler = null;
+      // Issue #342: Dependency intelligence
+      coExecutionRepo = null;
+      dependencyGraph = null;
+      availableMcpServers = [];
       // ============================================================================
       // Lifecycle
       // ============================================================================
@@ -124976,6 +125570,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 +125770,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 +125820,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 +126247,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),
@@ -126665,7 +127319,7 @@ function createErrorResult(code, transformType, error, startTime) {
     warnings: []
   };
 }
-function transformVarToConst(code, logger22 = { debug: () => {
+function transformVarToConst(code, logger23 = { debug: () => {
 }, info: () => {
 }, warn: () => {
 }, error: () => {
@@ -126706,7 +127360,7 @@ function transformVarToConst(code, logger22 = { debug: () => {
         )
       );
     }
-    logger22.debug("var-to-const transform completed", {
+    logger23.debug("var-to-const transform completed", {
       declarations: varDeclarations.length,
       reassigned: reassignedVars.size,
       loopVars: loopVars.size
@@ -126715,7 +127369,7 @@ function transformVarToConst(code, logger22 = { debug: () => {
     result.warnings = warnings;
     return result;
   } catch (error) {
-    logger22.error("var-to-const transform failed", error);
+    logger23.error("var-to-const transform failed", error);
     return createErrorResult(
       code,
       "var-to-const",
@@ -126724,7 +127378,7 @@ function transformVarToConst(code, logger22 = { debug: () => {
     );
   }
 }
-function transformAddTypes(code, logger22 = { debug: () => {
+function transformAddTypes(code, logger23 = { debug: () => {
 }, info: () => {
 }, warn: () => {
 }, error: () => {
@@ -126783,7 +127437,7 @@ function transformAddTypes(code, logger22 = { debug: () => {
         );
       }
     }
-    logger22.debug("add-types transform completed", { edits: edits.length });
+    logger23.debug("add-types transform completed", { edits: edits.length });
     const result = createSuccessResult(code, "add-types", edits, startTime, 0.7);
     result.warnings = warnings;
     if (edits.length > 0) {
@@ -126791,7 +127445,7 @@ function transformAddTypes(code, logger22 = { debug: () => {
     }
     return result;
   } catch (error) {
-    logger22.error("add-types transform failed", error);
+    logger23.error("add-types transform failed", error);
     return createErrorResult(
       code,
       "add-types",
@@ -126800,7 +127454,7 @@ function transformAddTypes(code, logger22 = { debug: () => {
     );
   }
 }
-function transformRemoveConsole(code, logger22 = { debug: () => {
+function transformRemoveConsole(code, logger23 = { debug: () => {
 }, info: () => {
 }, warn: () => {
 }, error: () => {
@@ -126837,7 +127491,7 @@ function transformRemoveConsole(code, logger22 = { debug: () => {
         `Inline console.${match[1]}() at offset ${match.index} - consider manual review`
       );
     }
-    logger22.debug("remove-console transform completed", {
+    logger23.debug("remove-console transform completed", {
       removed: edits.length,
       warnings: warnings.length
     });
@@ -126845,7 +127499,7 @@ function transformRemoveConsole(code, logger22 = { debug: () => {
     result.warnings = warnings;
     return result;
   } catch (error) {
-    logger22.error("remove-console transform failed", error);
+    logger23.error("remove-console transform failed", error);
     return createErrorResult(
       code,
       "remove-console",
@@ -126854,7 +127508,7 @@ function transformRemoveConsole(code, logger22 = { debug: () => {
     );
   }
 }
-function transformPromiseToAsync(code, logger22 = { debug: () => {
+function transformPromiseToAsync(code, logger23 = { debug: () => {
 }, info: () => {
 }, warn: () => {
 }, error: () => {
@@ -126883,7 +127537,7 @@ ${body.trim()}`;
         )
       );
     }
-    logger22.debug("promise-to-async transform completed", {
+    logger23.debug("promise-to-async transform completed", {
       converted: edits.length,
       warnings: warnings.length
     });
@@ -126896,7 +127550,7 @@ ${body.trim()}`;
     }
     return result;
   } catch (error) {
-    logger22.error("promise-to-async transform failed", error);
+    logger23.error("promise-to-async transform failed", error);
     return createErrorResult(
       code,
       "promise-to-async",
@@ -126905,7 +127559,7 @@ ${body.trim()}`;
     );
   }
 }
-function transformCjsToEsm(code, logger22 = { debug: () => {
+function transformCjsToEsm(code, logger23 = { debug: () => {
 }, info: () => {
 }, warn: () => {
 }, error: () => {
@@ -126955,12 +127609,12 @@ function transformCjsToEsm(code, logger22 = { debug: () => {
         createEdit(code, match.index, match.index + fullMatch.length, exportStmt, `Convert exports.${exportName} to named export`)
       );
     }
-    logger22.debug("cjs-to-esm transform completed", { edits: edits.length });
+    logger23.debug("cjs-to-esm transform completed", { edits: edits.length });
     const result = createSuccessResult(code, "cjs-to-esm", edits, startTime, 0.85);
     result.warnings = warnings;
     return result;
   } catch (error) {
-    logger22.error("cjs-to-esm transform failed", error);
+    logger23.error("cjs-to-esm transform failed", error);
     return createErrorResult(
       code,
       "cjs-to-esm",
@@ -126969,7 +127623,7 @@ function transformCjsToEsm(code, logger22 = { debug: () => {
     );
   }
 }
-function transformFuncToArrow(code, logger22 = { debug: () => {
+function transformFuncToArrow(code, logger23 = { debug: () => {
 }, info: () => {
 }, warn: () => {
 }, error: () => {
@@ -127019,7 +127673,7 @@ function transformFuncToArrow(code, logger22 = { debug: () => {
         createEdit(code, match.index, match.index + fullMatch.length, arrowFunc, `Convert callback to arrow function`)
       );
     }
-    logger22.debug("func-to-arrow transform completed", {
+    logger23.debug("func-to-arrow transform completed", {
       converted: edits.length,
       warnings: warnings.length
     });
@@ -127027,7 +127681,7 @@ function transformFuncToArrow(code, logger22 = { debug: () => {
     result.warnings = warnings;
     return result;
   } catch (error) {
-    logger22.error("func-to-arrow transform failed", error);
+    logger23.error("func-to-arrow transform failed", error);
     return createErrorResult(
       code,
       "func-to-arrow",
@@ -127036,7 +127690,7 @@ function transformFuncToArrow(code, logger22 = { debug: () => {
     );
   }
 }
-function executeTransform(code, type, logger22) {
+function executeTransform(code, type, logger23) {
   const transform2 = TRANSFORM_REGISTRY[type];
   if (!transform2) {
     return {
@@ -127054,7 +127708,7 @@ function executeTransform(code, type, logger22) {
       warnings: []
     };
   }
-  return transform2(code, logger22);
+  return transform2(code, logger23);
 }
 var TRANSFORM_REGISTRY;
 var init_transforms = __esm({
@@ -127072,8 +127726,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 +127793,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 +127842,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 +127852,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) {
@@ -127697,13 +128351,13 @@ async function loadWasmModule() {
 function getWasmLanguageForTransform(_type) {
   return WasmLanguage.TypeScript;
 }
-async function createAgentBoosterAdapter(config = {}, logger22, metricsTracker) {
-  const adapter = new AgentBoosterAdapter(config, logger22, metricsTracker);
+async function createAgentBoosterAdapter(config = {}, logger23, metricsTracker) {
+  const adapter = new AgentBoosterAdapter(config, logger23, metricsTracker);
   await adapter.initialize();
   return adapter;
 }
-function createAgentBoosterAdapterSync(config = {}, logger22, metricsTracker) {
-  return new AgentBoosterAdapter(config, logger22, metricsTracker);
+function createAgentBoosterAdapterSync(config = {}, logger23, metricsTracker) {
+  return new AgentBoosterAdapter(config, logger23, metricsTracker);
 }
 var WasmLanguage, wasmTransform, wasmWarmup, checkWasmAvailable, wasmModuleLoaded, wasmModuleError, TransformCache, AgentBoosterAdapter;
 var init_adapter2 = __esm({
@@ -127814,9 +128468,9 @@ var init_adapter2 = __esm({
        * @param logger - Optional logger for diagnostics
        * @param metricsTracker - Optional metrics tracker for recording outcomes
        */
-      constructor(config = {}, logger22, metricsTracker) {
+      constructor(config = {}, logger23, metricsTracker) {
         this.config = { ...DEFAULT_AGENT_BOOSTER_CONFIG, ...config };
-        this.logger = logger22 || {
+        this.logger = logger23 || {
           debug: () => {
           },
           info: () => {
@@ -128540,6 +129194,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 +138702,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,8 +138716,8 @@ 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;
@@ -138166,8 +138836,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 +138852,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 +138875,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 +138891,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 +138905,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 +138965,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,8 +138979,8 @@ 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;
@@ -138433,8 +139103,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,8 +139117,8 @@ 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;
@@ -140663,17 +141333,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 +141563,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 +141580,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 +141592,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 +141604,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 +141640,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 +145062,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 +145076,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 +145121,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 +145209,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 +145221,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 +145234,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 +145952,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 +146038,7 @@ On promotion:
             }
           }
         }
-        logger13.info("Cross-domain transfer complete", { transferred, skipped });
+        logger14.info("Cross-domain transfer complete", { transferred, skipped });
         return { transferred, skipped };
       }
       /**
@@ -145382,13 +146059,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 +146130,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 +146190,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 +146219,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 +146228,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 +146245,7 @@ On promotion:
             });
           }
         } else {
-          logger13.error("Failed to promote pattern", result.error, { patternId });
+          logger14.error("Failed to promote pattern", result.error, { patternId });
         }
       }
       /**
@@ -145691,7 +146371,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 +146493,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 +146515,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 +146539,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 +146609,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 +146642,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 +146677,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 +146717,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 +146760,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 +146821,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 +146853,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 +146935,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 +146977,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 +147013,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 +147037,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 +147061,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 +147085,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 +147235,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 +147243,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 +147409,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 +147833,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) });
         }
       }
       /**
@@ -147346,9 +148018,9 @@ var init_cohomology_adapter = __esm({
        * @param wasmLoader - WASM module loader
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
+      constructor(wasmLoader2, logger23 = DEFAULT_COHERENCE_LOGGER) {
         this.wasmLoader = wasmLoader2;
-        this.logger = logger22;
+        this.logger = logger23;
       }
       engine = null;
       initialized = false;
@@ -147699,9 +148371,9 @@ var init_spectral_adapter = __esm({
        * @param wasmLoader - WASM module loader
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
+      constructor(wasmLoader2, logger23 = DEFAULT_COHERENCE_LOGGER) {
         this.wasmLoader = wasmLoader2;
-        this.logger = logger22;
+        this.logger = logger23;
       }
       engine = null;
       initialized = false;
@@ -148117,9 +148789,9 @@ var init_causal_adapter = __esm({
        * @param wasmLoader - WASM module loader
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
+      constructor(wasmLoader2, logger23 = DEFAULT_COHERENCE_LOGGER) {
         this.wasmLoader = wasmLoader2;
-        this.logger = logger22;
+        this.logger = logger23;
       }
       engine = null;
       initialized = false;
@@ -148419,9 +149091,9 @@ var init_category_adapter = __esm({
        * @param wasmLoader - WASM module loader
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
+      constructor(wasmLoader2, logger23 = DEFAULT_COHERENCE_LOGGER) {
         this.wasmLoader = wasmLoader2;
-        this.logger = logger22;
+        this.logger = logger23;
       }
       engine = null;
       initialized = false;
@@ -148740,9 +149412,9 @@ var init_homotopy_adapter = __esm({
        * @param wasmLoader - WASM module loader
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
+      constructor(wasmLoader2, logger23 = DEFAULT_COHERENCE_LOGGER) {
         this.wasmLoader = wasmLoader2;
-        this.logger = logger22;
+        this.logger = logger23;
       }
       engine = null;
       initialized = false;
@@ -148950,9 +149622,9 @@ var init_witness_adapter = __esm({
        * @param wasmLoader - WASM module loader
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
+      constructor(wasmLoader2, logger23 = DEFAULT_COHERENCE_LOGGER) {
         this.wasmLoader = wasmLoader2;
-        this.logger = logger22;
+        this.logger = logger23;
       }
       engine = null;
       initialized = false;
@@ -149254,8 +149926,8 @@ var init_engines = __esm({
 });
 
 // src/integrations/coherence/coherence-service.ts
-async function createCoherenceService(wasmLoader2, config, logger22) {
-  const service = new CoherenceService(wasmLoader2, config, logger22);
+async function createCoherenceService(wasmLoader2, config, logger23) {
+  const service = new CoherenceService(wasmLoader2, config, logger23);
   await service.initialize();
   return service;
 }
@@ -149274,10 +149946,10 @@ var init_coherence_service = __esm({
        * @param config - Optional service configuration
        * @param logger - Optional logger for diagnostics
        */
-      constructor(wasmLoader2, config = {}, logger22) {
+      constructor(wasmLoader2, config = {}, logger23) {
         this.wasmLoader = wasmLoader2;
         this.config = { ...DEFAULT_COHERENCE_CONFIG, ...config };
-        this.logger = logger22 || DEFAULT_COHERENCE_LOGGER;
+        this.logger = logger23 || DEFAULT_COHERENCE_LOGGER;
       }
       config;
       logger;
@@ -150029,8 +150701,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 +150966,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 +151225,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 +151249,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 +151447,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 +151470,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);
@@ -151541,8 +152213,8 @@ var init_base = __esm({
       /**
        * Set logger for this tool
        */
-      setLogger(logger22) {
-        this.logger = logger22;
+      setLogger(logger23) {
+        this.logger = logger23;
       }
       /**
        * Mark result as coming from demo/sample data
@@ -152477,8 +153149,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 +153167,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 +155150,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 +155211,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 +155692,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 +156842,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 +158306,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 +158333,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 +158357,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 +158524,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 +158666,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 +158772,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 {
@@ -165847,7 +166523,7 @@ var init_check = __esm({
 });
 
 // src/learning/v2-to-v3-migration.ts
-var logger15;
+var logger16;
 var init_v2_to_v3_migration = __esm({
   "src/learning/v2-to-v3-migration.ts"() {
     "use strict";
@@ -165855,12 +166531,12 @@ var init_v2_to_v3_migration = __esm({
     init_error_utils();
     init_safe_json();
     init_logging();
-    logger15 = LoggerFactory.create("v2-to-v3-migration");
+    logger16 = LoggerFactory.create("v2-to-v3-migration");
   }
 });
 
 // src/learning/qe-unified-memory.ts
-var logger16, QE_DOMAIN_HNSW_CONFIGS, DEFAULT_QE_UNIFIED_MEMORY_CONFIG;
+var logger17, QE_DOMAIN_HNSW_CONFIGS, DEFAULT_QE_UNIFIED_MEMORY_CONFIG;
 var init_qe_unified_memory = __esm({
   "src/learning/qe-unified-memory.ts"() {
     "use strict";
@@ -165870,7 +166546,7 @@ var init_qe_unified_memory = __esm({
     init_types2();
     init_error_utils();
     init_hnsw_index();
-    logger16 = LoggerFactory.create("qe-unified-memory");
+    logger17 = LoggerFactory.create("qe-unified-memory");
     QE_DOMAIN_HNSW_CONFIGS = {
       "test-suites": {
         dimensions: EMBEDDING_CONFIG.DIMENSIONS,
@@ -165970,13 +166646,13 @@ function createMemoryAuditor(coherenceService, eventBus, config) {
     { ...DEFAULT_AUDITOR_CONFIG, ...config }
   );
 }
-var logger17, DEFAULT_AUDITOR_CONFIG, MemoryCoherenceAuditor;
+var logger18, DEFAULT_AUDITOR_CONFIG, MemoryCoherenceAuditor;
 var init_memory_auditor = __esm({
   "src/learning/memory-auditor.ts"() {
     "use strict";
     init_logging();
     init_error_utils();
-    logger17 = LoggerFactory.create("MemoryAuditor");
+    logger18 = LoggerFactory.create("MemoryAuditor");
     DEFAULT_AUDITOR_CONFIG = {
       batchSize: 50,
       energyThreshold: 0.4,
@@ -166052,7 +166728,7 @@ var init_memory_auditor = __esm({
               timestamp: /* @__PURE__ */ new Date()
             });
           } catch (eventError) {
-            logger17.warn("Failed to emit audit_failed event", { error: toErrorMessage(eventError) });
+            logger18.warn("Failed to emit audit_failed event", { error: toErrorMessage(eventError) });
           }
           throw error;
         }
@@ -166138,7 +166814,7 @@ var init_memory_auditor = __esm({
        */
       async runBackgroundAudit(patternSource) {
         if (this.isAuditing) {
-          logger17.warn("Audit already in progress, skipping");
+          logger18.warn("Audit already in progress, skipping");
           return;
         }
         this.isAuditing = true;
@@ -166299,7 +166975,7 @@ var init_memory_auditor = __esm({
             payload
           });
         } catch (error) {
-          logger17.warn("Failed to emit event", { eventType, error: toErrorMessage(error) });
+          logger18.warn("Failed to emit event", { eventType, error: toErrorMessage(error) });
         }
       }
     };
@@ -166307,13 +166983,13 @@ var init_memory_auditor = __esm({
 });
 
 // src/learning/skill-validation-learner.ts
-var logger18;
+var logger19;
 var init_skill_validation_learner = __esm({
   "src/learning/skill-validation-learner.ts"() {
     "use strict";
     init_safe_json();
     init_logging();
-    logger18 = LoggerFactory.create("skill-validation-learner");
+    logger19 = LoggerFactory.create("skill-validation-learner");
   }
 });
 
@@ -166321,7 +166997,7 @@ var init_skill_validation_learner = __esm({
 function createPatternLifecycleManager(db, config) {
   return new PatternLifecycleManager(db, config);
 }
-var logger19, DEFAULT_LIFECYCLE_CONFIG, PatternLifecycleManager;
+var logger20, DEFAULT_LIFECYCLE_CONFIG, PatternLifecycleManager;
 var init_pattern_lifecycle = __esm({
   "src/learning/pattern-lifecycle.ts"() {
     "use strict";
@@ -166329,7 +167005,7 @@ var init_pattern_lifecycle = __esm({
     init_asymmetric_learning();
     init_safe_json();
     init_logging();
-    logger19 = LoggerFactory.create("pattern-lifecycle");
+    logger20 = LoggerFactory.create("pattern-lifecycle");
     DEFAULT_LIFECYCLE_CONFIG = {
       promotionRewardThreshold: 0.7,
       promotionMinOccurrences: PROMOTION_THRESHOLD,
@@ -166366,7 +167042,7 @@ var init_pattern_lifecycle = __esm({
         SELECT deprecated_at FROM qe_patterns LIMIT 1
       `).get();
         } catch (e20) {
-          logger19.debug("Adding missing deprecated_at column", { error: e20 instanceof Error ? e20.message : String(e20) });
+          logger20.debug("Adding missing deprecated_at column", { error: e20 instanceof Error ? e20.message : String(e20) });
           this.db.exec(`
         ALTER TABLE qe_patterns ADD COLUMN deprecated_at TEXT DEFAULT NULL
       `);
@@ -166377,7 +167053,7 @@ var init_pattern_lifecycle = __esm({
         SELECT consecutive_failures FROM qe_patterns LIMIT 1
       `).get();
         } catch (e20) {
-          logger19.debug("Adding missing consecutive_failures column", { error: e20 instanceof Error ? e20.message : String(e20) });
+          logger20.debug("Adding missing consecutive_failures column", { error: e20 instanceof Error ? e20.message : String(e20) });
           this.db.exec(`
         ALTER TABLE qe_patterns ADD COLUMN consecutive_failures INTEGER DEFAULT 0
       `);
@@ -166388,7 +167064,7 @@ var init_pattern_lifecycle = __esm({
         SELECT promotion_date FROM qe_patterns LIMIT 1
       `).get();
         } catch (e20) {
-          logger19.debug("Adding missing promotion_date column", { error: e20 instanceof Error ? e20.message : String(e20) });
+          logger20.debug("Adding missing promotion_date column", { error: e20 instanceof Error ? e20.message : String(e20) });
           this.db.exec(`
         ALTER TABLE qe_patterns ADD COLUMN promotion_date TEXT DEFAULT NULL
       `);
@@ -167010,7 +167686,7 @@ Pattern extracted from ${exp.count} successful experiences.`;
 });
 
 // src/learning/metrics-tracker.ts
-var logger20;
+var logger21;
 var init_metrics_tracker2 = __esm({
   "src/learning/metrics-tracker.ts"() {
     "use strict";
@@ -167018,7 +167694,7 @@ var init_metrics_tracker2 = __esm({
     init_qe_patterns();
     init_safe_json();
     init_logging();
-    logger20 = LoggerFactory.create("metrics-tracker");
+    logger21 = LoggerFactory.create("metrics-tracker");
   }
 });
 
@@ -169621,7 +170297,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 +170518,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 +170538,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 +172971,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 +173005,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 +173015,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 +173040,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 +173156,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 +175890,7 @@ async function handleAQEHealth() {
       success: true,
       data: {
         status: healthStatus,
-        version: true ? "3.7.20" : "3.7.2",
+        version: true ? "3.7.21" : "3.7.2",
         loadedDomains: domainCount,
         memory: memoryStats,
         hnsw: hnswStats,
@@ -183855,6 +184531,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;
@@ -184067,7 +184745,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 +186194,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 +186918,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 +188826,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 +191919,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 +192255,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 +192268,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);
@@ -192985,7 +193664,7 @@ var CATALOG_INFO = {
 // src/mcp/http-server.ts
 init_unified_memory();
 init_logging();
-var logger21 = LoggerFactory.create("HTTPServer");
+var logger22 = LoggerFactory.create("HTTPServer");
 var SimpleRouter = class {
   routes = [];
   add(method, path31, handler) {
@@ -193049,7 +193728,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: {}
@@ -193107,7 +193786,7 @@ var HTTPServerImpl = class {
         this.webhookService.notifyArtifactCreated(event.taskId, {
           id: event.artifact.id ?? "unknown",
           name: event.artifact.name ?? "artifact"
-        }).catch((err4) => logger21.error("Artifact webhook delivery failed", err4 instanceof Error ? err4 : new Error(String(err4))));
+        }).catch((err4) => logger22.error("Artifact webhook delivery failed", err4 instanceof Error ? err4 : new Error(String(err4))));
       });
     }
     this.enableHotReload = config.enableHotReload ?? false;
@@ -193591,25 +194270,25 @@ var HTTPServerImpl = class {
         const memory = getUnifiedMemory();
         if (!memory.isCRDTInitialized()) {
           memory.initializeCRDT(`aqe-http-${process.pid}-${Date.now()}`);
-          logger21.info("CRDT store initialized");
+          logger22.info("CRDT store initialized");
         }
       } catch (error) {
-        logger21.warn("Failed to initialize CRDT", { error });
+        logger22.warn("Failed to initialize CRDT", { error });
       }
     }
     if (!this.skipAgentCardLoading) {
       try {
         await this.discoveryService.loadCards(this.agentMarkdownDir);
         this.agentCardsLoaded = true;
-        logger21.info(`Loaded ${this.discoveryService.getAgentCount()} agent cards`);
+        logger22.info(`Loaded ${this.discoveryService.getAgentCount()} agent cards`);
       } catch (error) {
-        logger21.warn("Failed to load agent cards", { error });
+        logger22.warn("Failed to load agent cards", { error });
       }
     }
     return new Promise(async (resolve11, reject) => {
       this.server = createServer((req, res) => {
         this.handleHttpRequest(req, res).catch((error) => {
-          logger21.error("Request error", error instanceof Error ? error : new Error(String(error)));
+          logger22.error("Request error", error instanceof Error ? error : new Error(String(error)));
           this.sendError(res, 500, "Internal server error");
         });
       });
@@ -193619,14 +194298,14 @@ var HTTPServerImpl = class {
       if (this.webSocketTransport && this.enableWebSocket) {
         try {
           await this.webSocketTransport.attach(this.server, "/agent/ws");
-          logger21.info("WebSocket transport attached at /agent/ws");
+          logger22.info("WebSocket transport attached at /agent/ws");
         } catch (error) {
-          logger21.warn("Failed to attach WebSocket transport", { error });
+          logger22.warn("Failed to attach WebSocket transport", { error });
         }
       }
       if (this.enableHotReload && this.hotReloadService) {
         this.hotReloadService.start().then(() => {
-          logger21.info("Hot reload enabled for agent cards");
+          logger22.info("Hot reload enabled for agent cards");
         }).catch((err4) => {
           console.error("[AQE] WARNING: Failed to start hot reload:", err4);
         });
@@ -194935,7 +195614,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 +195700,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:",