agentic-qe 3.7.6 → 3.7.8

package/dist/cli/bundle.js

@@ -7200,7 +7200,7 @@ function createMultiModelProviders(models = getRecommendedSecurityModels(), base
     })
   );
 }
-var MODEL_COSTS, DEFAULT_CONFIG5, OpenRouterModelProvider;
+var MODEL_COSTS, DEFAULT_CONFIG6, OpenRouterModelProvider;
 var init_openrouter_provider = __esm({
   "src/coordination/consensus/providers/openrouter-provider.ts"() {
     "use strict";
@@ -7235,7 +7235,7 @@ var init_openrouter_provider = __esm({
       // Cohere models
       "cohere/command-r-plus": { input: 2.5, output: 10, tier: "standard" }
     };
-    DEFAULT_CONFIG5 = {
+    DEFAULT_CONFIG6 = {
       defaultModel: "anthropic/claude-3.5-sonnet",
       defaultTimeout: 12e4,
       // 2 minutes
@@ -7262,7 +7262,7 @@ var init_openrouter_provider = __esm({
           );
         }
         this.config = {
-          ...DEFAULT_CONFIG5,
+          ...DEFAULT_CONFIG6,
           ...config,
           apiKey
         };
@@ -7506,14 +7506,14 @@ async function isOllamaAvailable(baseUrl = "http://localhost:11434") {
     return false;
   }
 }
-var DEFAULT_CONFIG6, OllamaModelProvider;
+var DEFAULT_CONFIG7, OllamaModelProvider;
 var init_ollama_provider = __esm({
   "src/coordination/consensus/providers/ollama-provider.ts"() {
     "use strict";
     init_model_provider();
     init_constants2();
     init_error_utils();
-    DEFAULT_CONFIG6 = {
+    DEFAULT_CONFIG7 = {
       baseUrl: OLLAMA_CONSTANTS.DEFAULT_BASE_URL,
       defaultModel: "llama3.1",
       defaultTimeout: CONSENSUS_CONSTANTS.OLLAMA_TIMEOUT_MS,
@@ -7535,7 +7535,7 @@ var init_ollama_provider = __esm({
       constructor(config = {}) {
         super();
         this.config = {
-          ...DEFAULT_CONFIG6,
+          ...DEFAULT_CONFIG7,
           ...config
         };
         this.id = `ollama-${(this.config.defaultModel ?? "default").replace(/[^a-z0-9]/gi, "-")}`;
@@ -12071,7 +12071,7 @@ var knowledge_graph_exports = {};
 __export(knowledge_graph_exports, {
   KnowledgeGraphService: () => KnowledgeGraphService
 });
-var DEFAULT_CONFIG29, KnowledgeGraphService;
+var DEFAULT_CONFIG30, KnowledgeGraphService;
 var init_knowledge_graph = __esm({
   "src/domains/code-intelligence/services/knowledge-graph.ts"() {
     "use strict";
@@ -12081,7 +12081,7 @@ var init_knowledge_graph = __esm({
     init_embeddings();
     init_error_utils();
     init_safe_json();
-    DEFAULT_CONFIG29 = {
+    DEFAULT_CONFIG30 = {
       maxNodes: 1e5,
       maxEdgesPerNode: 500,
       namespace: "code-intelligence:kg",
@@ -12109,7 +12109,7 @@ var init_knowledge_graph = __esm({
        * @param config - Optional configuration overrides
        */
       constructor(dependenciesOrMemory, config = {}) {
-        this.config = { ...DEFAULT_CONFIG29, ...config };
+        this.config = { ...DEFAULT_CONFIG30, ...config };
         if (this.isKnowledgeGraphDependencies(dependenciesOrMemory)) {
           this.memory = dependenciesOrMemory.memory;
           this.llmRouter = dependenciesOrMemory.llmRouter;
@@ -13074,7 +13074,7 @@ var impact_analyzer_exports = {};
 __export(impact_analyzer_exports, {
   ImpactAnalyzerService: () => ImpactAnalyzerService
 });
-var DEFAULT_CONFIG31, ImpactAnalyzerService;
+var DEFAULT_CONFIG32, ImpactAnalyzerService;
 var init_impact_analyzer = __esm({
   "src/domains/code-intelligence/services/impact-analyzer.ts"() {
     "use strict";
@@ -13082,7 +13082,7 @@ var init_impact_analyzer = __esm({
     init_types();
     init_error_utils();
     init_knowledge_graph();
-    DEFAULT_CONFIG31 = {
+    DEFAULT_CONFIG32 = {
       maxDepth: 5,
       riskWeights: {
         directImpact: 0.4,
@@ -13112,7 +13112,7 @@ var init_impact_analyzer = __esm({
     ImpactAnalyzerService = class {
       constructor(memory, knowledgeGraph, config = {}) {
         this.memory = memory;
-        this.config = { ...DEFAULT_CONFIG31, ...config };
+        this.config = { ...DEFAULT_CONFIG32, ...config };
         this.knowledgeGraph = knowledgeGraph || new KnowledgeGraphService(memory);
       }
       config;
@@ -14716,7 +14716,7 @@ var init_spreading_activation = __esm({
 });
 
 // src/learning/dream/insight-generator.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var DEFAULT_INSIGHT_CONFIG, InsightGenerator;
 var init_insight_generator = __esm({
   "src/learning/dream/insight-generator.ts"() {
@@ -15239,7 +15239,7 @@ var init_insight_generator = __esm({
        */
       generateId() {
         const timestamp = Date.now();
-        const random = randomUUID6().slice(0, 8);
+        const random = randomUUID7().slice(0, 8);
         return `insight-${timestamp}-${random}`;
       }
       /**
@@ -22046,12 +22046,12 @@ async function saveFlakyTracker(tracker, historyPath) {
   const history = tracker.exportHistory();
   await fs29.writeFile(historyPath, JSON.stringify(history, null, 2));
 }
-var DEFAULT_CONFIG60, FlakyTestTracker;
+var DEFAULT_CONFIG62, FlakyTestTracker;
 var init_flaky_tracker = __esm({
   "src/test-scheduling/flaky-tracking/flaky-tracker.ts"() {
     "use strict";
     init_safe_json();
-    DEFAULT_CONFIG60 = {
+    DEFAULT_CONFIG62 = {
       minRunsForFlakiness: 5,
       flakinessThreshold: 0.1,
       // 10% failure rate = flaky
@@ -22062,7 +22062,7 @@ var init_flaky_tracker = __esm({
       records = /* @__PURE__ */ new Map();
       config;
       constructor(config) {
-        this.config = { ...DEFAULT_CONFIG60, ...config };
+        this.config = { ...DEFAULT_CONFIG62, ...config };
       }
       // --------------------------------------------------------------------------
       // Public API
@@ -22319,11 +22319,11 @@ async function reportToGitHubActions(results, config) {
   const reporter = createGitHubActionsReporter(config);
   await reporter.writeOutput(results);
 }
-var DEFAULT_CONFIG61, GitHubActionsReporter;
+var DEFAULT_CONFIG63, GitHubActionsReporter;
 var init_github_actions = __esm({
   "src/test-scheduling/cicd/github-actions.ts"() {
     "use strict";
-    DEFAULT_CONFIG61 = {
+    DEFAULT_CONFIG63 = {
       enableAnnotations: true,
       enableSummary: true,
       enableOutputs: true,
@@ -22334,7 +22334,7 @@ var init_github_actions = __esm({
     GitHubActionsReporter = class {
       config;
       constructor(config) {
-        this.config = { ...DEFAULT_CONFIG61, ...config };
+        this.config = { ...DEFAULT_CONFIG63, ...config };
       }
       // --------------------------------------------------------------------------
       // Public API
@@ -22824,12 +22824,12 @@ var init_schedule = __esm({
 function createMetricsCollector(config) {
   return new MetricsCollector(config);
 }
-var DEFAULT_CONFIG62, MetricsCollector;
+var DEFAULT_CONFIG64, MetricsCollector;
 var init_metrics_collector = __esm({
   "src/testing/load/metrics-collector.ts"() {
     "use strict";
     init_utils();
-    DEFAULT_CONFIG62 = {
+    DEFAULT_CONFIG64 = {
       maxEvents: 1e5,
       memorySampleInterval: 1e3,
       enableTimeline: true,
@@ -22867,7 +22867,7 @@ var init_metrics_collector = __esm({
       // Issue tracking
       issues = [];
       constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG62, ...config };
+        this.config = { ...DEFAULT_CONFIG64, ...config };
         this.coordinationLatencies = new CircularBuffer(this.config.maxEvents);
         this.taskDurations = new CircularBuffer(this.config.maxEvents);
         this.memorySnapshots = new CircularBuffer(1e4);
@@ -23264,7 +23264,7 @@ function createBottleneckAnalyzerWithThresholds(thresholds) {
     thresholds: { ...DEFAULT_THRESHOLDS2, ...thresholds }
   });
 }
-var DEFAULT_THRESHOLDS2, DEFAULT_CONFIG63, BottleneckAnalyzer;
+var DEFAULT_THRESHOLDS2, DEFAULT_CONFIG65, BottleneckAnalyzer;
 var init_bottleneck_analyzer = __esm({
   "src/testing/load/bottleneck-analyzer.ts"() {
     "use strict";
@@ -23291,7 +23291,7 @@ var init_bottleneck_analyzer = __esm({
       gossipConvergenceTime: 5e3,
       gossipMaxPartitions: 0
     };
-    DEFAULT_CONFIG63 = {
+    DEFAULT_CONFIG65 = {
       thresholds: DEFAULT_THRESHOLDS2,
       enableDetailedAnalysis: true
     };
@@ -23299,7 +23299,7 @@ var init_bottleneck_analyzer = __esm({
       config;
       constructor(config = {}) {
         this.config = {
-          ...DEFAULT_CONFIG63,
+          ...DEFAULT_CONFIG65,
           ...config,
           thresholds: {
             ...DEFAULT_THRESHOLDS2,
@@ -23630,7 +23630,7 @@ function createLoadTesterForTarget(targetAgents, workloadProfile = "medium") {
     mockMode: true
   });
 }
-var DEFAULT_CONFIG64, DEFAULT_SUCCESS_CRITERIA, WORKLOAD_PROFILES, SCENARIO_RAMP_UP_100, SCENARIO_BURST_100, SCENARIO_CHURN_100, SCENARIO_STRESS_150, AgentLoadTester;
+var DEFAULT_CONFIG66, DEFAULT_SUCCESS_CRITERIA, WORKLOAD_PROFILES, SCENARIO_RAMP_UP_100, SCENARIO_BURST_100, SCENARIO_CHURN_100, SCENARIO_STRESS_150, AgentLoadTester;
 var init_agent_load_tester = __esm({
   "src/testing/load/agent-load-tester.ts"() {
     "use strict";
@@ -23638,7 +23638,7 @@ var init_agent_load_tester = __esm({
     init_metrics_collector();
     init_error_utils();
     init_bottleneck_analyzer();
-    DEFAULT_CONFIG64 = {
+    DEFAULT_CONFIG66 = {
       maxAgents: 100,
       memoryLimit: 4 * 1024 * 1024 * 1024,
       // 4GB
@@ -23740,7 +23740,7 @@ var init_agent_load_tester = __esm({
       // Random number generator (seeded for reproducibility)
       random;
       constructor(config = {}, metricsConfig, thresholds) {
-        this.config = { ...DEFAULT_CONFIG64, ...config };
+        this.config = { ...DEFAULT_CONFIG66, ...config };
         this.metrics = createMetricsCollector(metricsConfig);
         this.analyzer = thresholds ? createBottleneckAnalyzerWithThresholds(thresholds) : createBottleneckAnalyzer();
         this.random = this.config.seed !== void 0 ? this.seededRandom(this.config.seed) : Math.random.bind(Math);
@@ -24095,8 +24095,8 @@ var load_exports = {};
 __export(load_exports, {
   AgentLoadTester: () => AgentLoadTester,
   BottleneckAnalyzer: () => BottleneckAnalyzer,
-  DEFAULT_ANALYZER_CONFIG: () => DEFAULT_CONFIG63,
-  DEFAULT_LOAD_TEST_CONFIG: () => DEFAULT_CONFIG64,
+  DEFAULT_ANALYZER_CONFIG: () => DEFAULT_CONFIG65,
+  DEFAULT_LOAD_TEST_CONFIG: () => DEFAULT_CONFIG66,
   DEFAULT_SUCCESS_CRITERIA: () => DEFAULT_SUCCESS_CRITERIA,
   DEFAULT_THRESHOLDS: () => DEFAULT_THRESHOLDS2,
   MetricsCollector: () => MetricsCollector,
@@ -28055,7 +28055,7 @@ import chalk33 from "chalk";
 
 // src/kernel/kernel.ts
 init_types();
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 
 // src/kernel/event-bus.ts
 init_circular_buffer();
@@ -37281,7 +37281,475 @@ var TestDataGeneratorService = class {
 // src/domains/test-generation/services/test-generator.ts
 init_error_utils();
 init_safe_json();
+
+// src/domains/test-generation/gates/test-quality-gate.ts
 var DEFAULT_CONFIG3 = {
+  checkSourceImports: true,
+  checkTautologicalAssertions: true,
+  checkEmptyTestBodies: true,
+  checkMirroredAssertions: true,
+  minPassScore: 60
+};
+var TestQualityGate = class {
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+  }
+  /**
+   * Validate generated test code quality.
+   *
+   * @param testCode - The generated test source code
+   * @param sourceFilePath - Path to the source file under test
+   * @param sourceCode - Optional source code content for mirrored assertion check
+   * @returns Gate result with pass/fail, issues, and score
+   */
+  validate(testCode, sourceFilePath, sourceCode) {
+    const issues = [];
+    if (this.config.checkSourceImports) {
+      issues.push(...this.detectMissingSourceImports(testCode, sourceFilePath));
+    }
+    if (this.config.checkTautologicalAssertions) {
+      issues.push(...this.detectTautologicalAssertions(testCode));
+    }
+    if (this.config.checkEmptyTestBodies) {
+      issues.push(...this.detectEmptyTestBodies(testCode));
+    }
+    if (this.config.checkMirroredAssertions && sourceCode) {
+      issues.push(...this.detectMirroredAssertions(testCode, sourceCode));
+    }
+    const score = this.calculateScore(issues);
+    const passed = score >= this.config.minPassScore;
+    return { passed, issues, score };
+  }
+  // ============================================================================
+  // Detection Methods
+  // ============================================================================
+  /**
+   * Check whether the test code imports from the source file.
+   * If no import/require statement references the source file basename, flag an error.
+   */
+  detectMissingSourceImports(testCode, sourceFilePath) {
+    const parts = sourceFilePath.replace(/\\/g, "/").split("/");
+    const fileName = parts[parts.length - 1];
+    const baseName = fileName.replace(/\.(ts|js|tsx|jsx|mts|mjs|py)$/, "");
+    const importPaths = [];
+    const esImportRegex = /(?:import|from)\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = esImportRegex.exec(testCode)) !== null) {
+      importPaths.push(match[1]);
+    }
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while ((match = requireRegex.exec(testCode)) !== null) {
+      importPaths.push(match[1]);
+    }
+    const hasSourceImport = importPaths.some((importPath) => {
+      const importBaseName = importPath.replace(/\\/g, "/").split("/").pop()?.replace(/\.(ts|js|tsx|jsx|mts|mjs)$/, "")?.replace(/\.js$/, "");
+      return importBaseName === baseName;
+    });
+    if (!hasSourceImport && importPaths.length >= 0) {
+      return [
+        {
+          type: "no-source-import",
+          severity: "error",
+          description: `Test does not import from source file "${baseName}". Tests that never reference the source under test are likely mock-only or dead code.`,
+          suggestion: `Add an import statement that references the source module, e.g.: import { ... } from './${baseName}.js'`
+        }
+      ];
+    }
+    return [];
+  }
+  /**
+   * Detect tautological assertions where the expected and actual values are identical.
+   * Examples: expect(true).toBe(true), expect(x).toBe(x), expect('a').toEqual('a')
+   */
+  detectTautologicalAssertions(testCode) {
+    const issues = [];
+    const lines = testCode.split("\n");
+    const matchers = ["toBe", "toEqual", "toStrictEqual"];
+    const matcherPattern = matchers.join("|");
+    const literalPattern = new RegExp(
+      `expect\\s*\\(\\s*(true|false|null|undefined)\\s*\\)\\s*\\.\\s*(?:${matcherPattern})\\s*\\(\\s*\\1\\s*\\)`
+    );
+    const numericPattern = new RegExp(
+      `expect\\s*\\(\\s*(\\d+(?:\\.\\d+)?)\\s*\\)\\s*\\.\\s*(?:${matcherPattern})\\s*\\(\\s*\\1\\s*\\)`
+    );
+    const singleQuotePattern = new RegExp(
+      `expect\\s*\\(\\s*'([^']*)'\\s*\\)\\s*\\.\\s*(?:${matcherPattern})\\s*\\(\\s*'\\1'\\s*\\)`
+    );
+    const doubleQuotePattern = new RegExp(
+      `expect\\s*\\(\\s*"([^"]*)"\\s*\\)\\s*\\.\\s*(?:${matcherPattern})\\s*\\(\\s*"\\1"\\s*\\)`
+    );
+    const identifierPattern = new RegExp(
+      `expect\\s*\\(\\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*\\)\\s*\\.\\s*(?:${matcherPattern})\\s*\\(\\s*\\1\\s*\\)`
+    );
+    for (let i58 = 0; i58 < lines.length; i58++) {
+      const line = lines[i58];
+      const lineNum = i58 + 1;
+      if (literalPattern.test(line)) {
+        const literalMatch = line.match(literalPattern);
+        issues.push({
+          type: "tautological-assertion",
+          severity: "error",
+          line: lineNum,
+          description: `Tautological assertion: expect(${literalMatch?.[1]}) always equals itself.`,
+          suggestion: "Replace with a meaningful assertion that tests actual behavior, e.g.: expect(myFunction()).toBe(expectedValue)"
+        });
+      } else if (numericPattern.test(line)) {
+        const numMatch = line.match(numericPattern);
+        issues.push({
+          type: "tautological-assertion",
+          severity: "error",
+          line: lineNum,
+          description: `Tautological assertion: expect(${numMatch?.[1]}) always equals itself.`,
+          suggestion: "Replace with a meaningful assertion that tests actual behavior."
+        });
+      } else if (singleQuotePattern.test(line)) {
+        const strMatch = line.match(singleQuotePattern);
+        issues.push({
+          type: "tautological-assertion",
+          severity: "error",
+          line: lineNum,
+          description: `Tautological assertion: expect('${strMatch?.[1]}') always equals itself.`,
+          suggestion: "Replace with a meaningful assertion that tests actual behavior."
+        });
+      } else if (doubleQuotePattern.test(line)) {
+        const strMatch = line.match(doubleQuotePattern);
+        issues.push({
+          type: "tautological-assertion",
+          severity: "error",
+          line: lineNum,
+          description: `Tautological assertion: expect("${strMatch?.[1]}") always equals itself.`,
+          suggestion: "Replace with a meaningful assertion that tests actual behavior."
+        });
+      } else if (identifierPattern.test(line)) {
+        const idMatch = line.match(identifierPattern);
+        issues.push({
+          type: "tautological-assertion",
+          severity: "error",
+          line: lineNum,
+          description: `Tautological assertion: expect(${idMatch?.[1]}).toBe(${idMatch?.[1]}) compares a value to itself.`,
+          suggestion: "Compute expected value independently from the actual value."
+        });
+      }
+    }
+    return issues;
+  }
+  /**
+   * Detect empty test bodies - test/it blocks with no assertions or meaningful code.
+   * Matches: it('...', () => {}), test('...', () => { /* comment * / })
+   */
+  detectEmptyTestBodies(testCode) {
+    const issues = [];
+    const lines = testCode.split("\n");
+    const testBlockRegex = /(?:it|test)\s*\(\s*(?:'[^']*'|"[^"]*"|`[^`]*`)\s*,\s*(?:async\s+)?(?:\(\)\s*=>|function\s*\(\))\s*\{([^}]*)\}\s*\)/;
+    const isEmptyOrCommentOnly = (body) => {
+      const stripped = body.replace(/\/\*[^*]*\*\//g, "").replace(/\/\/[^\n]*/g, "");
+      return stripped.trim().length === 0;
+    };
+    for (let i58 = 0; i58 < lines.length; i58++) {
+      if (!/(?:it|test)\s*\(/.test(lines[i58])) continue;
+      const window = lines.slice(i58, i58 + 4).join(" ");
+      const match = testBlockRegex.exec(window);
+      if (match && isEmptyOrCommentOnly(match[1])) {
+        issues.push({
+          type: "empty-test-body",
+          severity: "error",
+          line: i58 + 1,
+          description: "Empty test body: this test has no assertions or meaningful code.",
+          suggestion: "Add assertions that verify the expected behavior of the code under test."
+        });
+      }
+    }
+    return issues;
+  }
+  /**
+   * Detect mirrored assertions - expected values that appear to be copy-pasted
+   * from source code literals rather than independently computed.
+   */
+  detectMirroredAssertions(testCode, sourceCode) {
+    const issues = [];
+    const sourceLiterals = this.extractNonTrivialLiterals(sourceCode);
+    if (sourceLiterals.length === 0) return issues;
+    const lines = testCode.split("\n");
+    const matcherPattern = /\.(?:toBe|toEqual|toStrictEqual)\s*\(\s*(.+?)\s*\)/;
+    for (let i58 = 0; i58 < lines.length; i58++) {
+      const line = lines[i58];
+      const assertionMatch = line.match(matcherPattern);
+      if (!assertionMatch) continue;
+      const expectedValue = assertionMatch[1].trim();
+      for (const literal of sourceLiterals) {
+        if (this.literalMatches(expectedValue, literal)) {
+          issues.push({
+            type: "mirrored-assertion",
+            severity: "warning",
+            line: i58 + 1,
+            description: `Assertion expected value "${expectedValue}" mirrors a literal from the source code. This may indicate the test was generated by copying source values rather than computing expected results independently.`,
+            suggestion: "Verify the expected value is derived from requirements, not copied from the implementation."
+          });
+          break;
+        }
+      }
+    }
+    return issues;
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Extract non-trivial string and number literals from source code.
+   * Trivial values (true, false, null, undefined, 0, 1, '', "") are excluded.
+   */
+  extractNonTrivialLiterals(sourceCode) {
+    const literals = /* @__PURE__ */ new Set();
+    const trivialValues = /* @__PURE__ */ new Set([
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "0",
+      "1",
+      "-1",
+      '""',
+      "''",
+      "``"
+    ]);
+    const stringRegex = /(?:=|return|:)\s*(['"])(.+?)\1/g;
+    let match;
+    while ((match = stringRegex.exec(sourceCode)) !== null) {
+      const value = match[2];
+      if (value.length >= 2 && !trivialValues.has(value)) {
+        literals.add(`'${value}'`);
+        literals.add(`"${value}"`);
+      }
+    }
+    const numberRegex = /(?:=|return|:)\s*(\d+(?:\.\d+)?)\b/g;
+    while ((match = numberRegex.exec(sourceCode)) !== null) {
+      const value = match[1];
+      if (!trivialValues.has(value)) {
+        literals.add(value);
+      }
+    }
+    return Array.from(literals);
+  }
+  /**
+   * Check if an assertion expected value matches a source literal.
+   */
+  literalMatches(expectedValue, sourceLiteral) {
+    if (expectedValue === sourceLiteral) return true;
+    const stripped = expectedValue.replace(/^['"`]|['"`]$/g, "");
+    const sourceStripped = sourceLiteral.replace(/^['"`]|['"`]$/g, "");
+    return stripped === sourceStripped && stripped.length >= 2;
+  }
+  /**
+   * Calculate quality score from issues.
+   * Start at 100, subtract per issue (error: -20, warning: -5), clamp to 0.
+   */
+  calculateScore(issues) {
+    let score = 100;
+    for (const issue of issues) {
+      if (issue.severity === "error") {
+        score -= 20;
+      } else {
+        score -= 5;
+      }
+    }
+    return Math.max(0, score);
+  }
+};
+
+// src/domains/test-generation/pattern-injection/edge-case-injector.ts
+var DEFAULT_INJECTION_CONFIG = {
+  topN: 3,
+  minConfidence: 0.5,
+  namespace: "aqe/v3/domains/test-generation"
+};
+function extractKeywords(sourceCode) {
+  const keywords = /* @__PURE__ */ new Set();
+  const noise = /* @__PURE__ */ new Set([
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "import",
+    "export",
+    "return",
+    "this",
+    "new",
+    "async",
+    "await",
+    "from",
+    "type",
+    "interface",
+    "string",
+    "number",
+    "boolean",
+    "void",
+    "null",
+    "undefined",
+    "true",
+    "false",
+    "map",
+    "filter",
+    "reduce",
+    "forEach",
+    "push",
+    "pop",
+    "length",
+    "toString",
+    "valueOf",
+    "constructor"
+  ]);
+  const funcDecl = sourceCode.matchAll(/function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g);
+  for (const m74 of funcDecl) keywords.add(m74[1]);
+  const constFn = sourceCode.matchAll(/(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g);
+  for (const m74 of constFn) keywords.add(m74[1]);
+  const classDef = sourceCode.matchAll(/class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g);
+  for (const m74 of classDef) keywords.add(m74[1]);
+  const importNames = sourceCode.matchAll(/import\s+(?:\{([^}]+)\}|([a-zA-Z_$][a-zA-Z0-9_$]*))\s+from/g);
+  for (const m74 of importNames) {
+    const namedImports = m74[1];
+    const defaultImport = m74[2];
+    if (namedImports) {
+      for (const name of namedImports.split(",")) {
+        const clean = name.trim().split(/\s+as\s+/).pop()?.trim();
+        if (clean && /^[a-zA-Z_$]/.test(clean)) keywords.add(clean);
+      }
+    }
+    if (defaultImport) keywords.add(defaultImport);
+  }
+  const methodDecl = sourceCode.matchAll(/(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*(?::\s*\S+\s*)?{/g);
+  for (const m74 of methodDecl) {
+    if (m74[1].length > 2 && !noise.has(m74[1])) keywords.add(m74[1]);
+  }
+  const methods = sourceCode.matchAll(/\.([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g);
+  for (const m74 of methods) {
+    if (m74[1].length > 2) keywords.add(m74[1]);
+  }
+  return Array.from(keywords).filter((k68) => !noise.has(k68) && k68.length > 1);
+}
+var EdgeCaseInjector = class {
+  constructor(memory, config) {
+    this.memory = memory;
+    this.config = { ...DEFAULT_INJECTION_CONFIG, ...config };
+  }
+  config;
+  /**
+   * Get injection context for a source file being tested.
+   * Searches memory for historical edge-case patterns relevant to the code,
+   * filters and ranks them, then formats as prompt context.
+   *
+   * @param sourceCode - The source code being tested
+   * @param domain - Optional domain hint for filtering (e.g., 'test-generation')
+   * @returns InjectionContext with formatted prompt and stats
+   */
+  async getInjectionContext(sourceCode, domain) {
+    const emptyResult = { promptContext: "", patternsUsed: 0, totalConsidered: 0 };
+    try {
+      const keywords = extractKeywords(sourceCode);
+      const retrieved = await this.searchPatterns(keywords, domain);
+      if (retrieved.length === 0) return emptyResult;
+      const totalConsidered = retrieved.length;
+      const filtered = retrieved.filter((p74) => p74.confidence >= this.config.minConfidence);
+      filtered.sort((a37, b68) => {
+        const scoreA = a37.successRate * 0.5 + a37.confidence * 0.3 + Math.log(a37.usageCount + 1) / 10 * 0.2;
+        const scoreB = b68.successRate * 0.5 + b68.confidence * 0.3 + Math.log(b68.usageCount + 1) / 10 * 0.2;
+        return scoreB - scoreA;
+      });
+      const selected = filtered.slice(0, this.config.topN);
+      if (selected.length === 0) {
+        return { promptContext: "", patternsUsed: 0, totalConsidered };
+      }
+      const promptContext = this.formatPromptContext(selected);
+      return {
+        promptContext,
+        patternsUsed: selected.length,
+        totalConsidered
+      };
+    } catch (error) {
+      console.warn("[EdgeCaseInjector] Failed to get injection context:", error);
+      return emptyResult;
+    }
+  }
+  /**
+   * Search memory backend for relevant patterns using keywords and domain.
+   */
+  async searchPatterns(keywords, domain) {
+    const patterns = [];
+    const searchQueries = [];
+    if (domain) {
+      searchQueries.push(`edge-case:${domain}:*`);
+      searchQueries.push(`pattern:${domain}:*`);
+    }
+    for (const keyword of keywords.slice(0, 5)) {
+      searchQueries.push(`edge-case:*${keyword}*`);
+      searchQueries.push(`pattern:*${keyword}*`);
+    }
+    searchQueries.push(`${this.config.namespace}:*`);
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const query of searchQueries) {
+      try {
+        const keys = await this.memory.search(query, 10);
+        for (const key of keys) {
+          if (seenKeys.has(key)) continue;
+          seenKeys.add(key);
+          try {
+            const value = await this.memory.get(key);
+            if (!value || typeof value !== "object") continue;
+            const pattern = this.parsePattern(key, value);
+            if (pattern) patterns.push(pattern);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Parse a retrieved memory entry into a RetrievedPattern.
+   * Handles various storage formats gracefully.
+   */
+  parsePattern(key, value) {
+    const name = typeof value.name === "string" ? value.name : key.split(":").pop() || key;
+    const description = typeof value.description === "string" ? value.description : "";
+    const confidence = typeof value.confidence === "number" ? value.confidence : 0.5;
+    const successRate = typeof value.successRate === "number" ? value.successRate : typeof value.success_rate === "number" ? value.success_rate : 0;
+    const usageCount = typeof value.usageCount === "number" ? value.usageCount : typeof value.usage_count === "number" ? value.usage_count : 0;
+    const tags = Array.isArray(value.tags) ? value.tags.filter((t50) => typeof t50 === "string") : [];
+    if (!name && !description) return null;
+    return { key, name, description, confidence, successRate, usageCount, tags };
+  }
+  /**
+   * Format selected patterns into a prompt context string.
+   */
+  formatPromptContext(patterns) {
+    const lines = ["## Historical Edge Cases (from patterns that caught real bugs):"];
+    for (let i58 = 0; i58 < patterns.length; i58++) {
+      const p74 = patterns[i58];
+      const tag = p74.tags.length > 0 ? p74.tags[0] : this.inferTag(p74);
+      const desc = p74.description || p74.name;
+      lines.push(`${i58 + 1}. [${tag}] ${desc}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Infer a short tag from pattern name when no tags are available.
+   */
+  inferTag(pattern) {
+    const name = pattern.name.toLowerCase();
+    if (name.includes("null") || name.includes("undefined")) return "null-check";
+    if (name.includes("empty") || name.includes("boundary") || name.includes("zero")) return "boundary";
+    if (name.includes("async") || name.includes("promise") || name.includes("reject")) return "async-error";
+    if (name.includes("error") || name.includes("throw") || name.includes("exception")) return "error-handling";
+    if (name.includes("type") || name.includes("cast") || name.includes("coerce")) return "type-safety";
+    if (name.includes("concurr") || name.includes("race") || name.includes("parallel")) return "concurrency";
+    return "edge-case";
+  }
+};
+
+// src/domains/test-generation/services/test-generator.ts
+var DEFAULT_CONFIG4 = {
   defaultFramework: "vitest",
   maxTestsPerFile: 50,
   coverageTargetDefault: 80,
@@ -37290,7 +37758,9 @@ var DEFAULT_CONFIG3 = {
   // On by default - opt-out
   llmModelTier: 2,
   // Sonnet by default
-  llmMaxTokens: 2048
+  llmMaxTokens: 2048,
+  enableTestQualityGate: true,
+  enableEdgeCaseInjection: true
 };
 var TestGeneratorService = class {
   config;
@@ -37300,14 +37770,18 @@ var TestGeneratorService = class {
   propertyTestGenerator;
   testDataGenerator;
   llmRouter;
+  qualityGate;
+  edgeCaseInjector;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.config = { ...DEFAULT_CONFIG4, ...config };
     this.memory = dependencies.memory;
     this.generatorFactory = dependencies.generatorFactory || new TestGeneratorFactory();
     this.tddGenerator = dependencies.tddGenerator || new TDDGeneratorService();
     this.propertyTestGenerator = dependencies.propertyTestGenerator || new PropertyTestGeneratorService();
     this.testDataGenerator = dependencies.testDataGenerator || new TestDataGeneratorService();
     this.llmRouter = dependencies.llmRouter;
+    this.qualityGate = this.config.enableTestQualityGate ? new TestQualityGate() : null;
+    this.edgeCaseInjector = this.config.enableEdgeCaseInjection ? new EdgeCaseInjector(this.memory) : null;
   }
   // ============================================================================
   // ADR-051: LLM Enhancement Methods
@@ -37343,6 +37817,17 @@ var TestGeneratorService = class {
     if (!this.llmRouter) return testCode;
     try {
       let prompt = this.buildTestEnhancementPrompt(testCode, sourceCode, analysis);
+      if (this.edgeCaseInjector) {
+        try {
+          const domain = context2?.dependencies ? "test-generation" : void 0;
+          const injection = await this.edgeCaseInjector.getInjectionContext(sourceCode, domain);
+          if (injection.promptContext) {
+            prompt = injection.promptContext + "\n\n" + prompt;
+          }
+        } catch (injectionError) {
+          console.warn("[TestGenerator] Edge case injection failed, continuing without it:", injectionError);
+        }
+      }
       if (context2?.dependencies) {
         prompt += `
 ## Dependency Context (from Knowledge Graph):
@@ -37654,6 +38139,13 @@ ${sourceCode}
       // ADR-051: Mark if LLM-enhanced
       llmEnhanced: this.isLLMEnhancementAvailable()
     };
+    if (this.qualityGate) {
+      test.qualityGateResult = this.qualityGate.validate(
+        testCode,
+        sourceFile,
+        sourceContent || void 0
+      );
+    }
     return ok({ tests: [test], patternsUsed });
   }
   async generateTestForLines(file, lines, framework) {
@@ -38094,7 +38586,7 @@ init_error_utils();
 import * as ts2 from "typescript/lib/typescript.js";
 import * as fs3 from "fs";
 import * as path3 from "path";
-var DEFAULT_CONFIG4 = {
+var DEFAULT_CONFIG5 = {
   maxPatterns: 100,
   minMatchScore: 0.5,
   enableVectorSearch: true,
@@ -38104,7 +38596,7 @@ var DEFAULT_CONFIG4 = {
 var PatternMatcherService = class _PatternMatcherService {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG4, ...config };
+    this.config = { ...DEFAULT_CONFIG5, ...config };
     this.tsParser = new TypeScriptASTParser();
     this.embedder = config.embedder ?? new NomicEmbedder({ enableFallback: true });
   }
@@ -40124,7 +40616,8 @@ var DEFAULT_CONSENSUS_CONFIG = {
   enableCostTracking: true,
   maxCostPerVerification: 0.5,
   // 50 cents max per verification
-  humanReviewThreshold: 0.6
+  humanReviewThreshold: 0.6,
+  enableSycophancyCheck: true
 };
 
 // src/coordination/consensus/index.ts
@@ -40609,11 +41102,136 @@ import { randomUUID } from "crypto";
 init_model_provider();
 init_types();
 init_error_utils();
+
+// src/coordination/consensus/sycophancy-scorer.ts
+function jaccardSimilarity(a37, b68) {
+  const setA = new Set(a37.toLowerCase().split(/\s+/).filter((w54) => w54.length > 2));
+  const setB = new Set(b68.toLowerCase().split(/\s+/).filter((w54) => w54.length > 2));
+  const intersection = new Set([...setA].filter((x67) => setB.has(x67)));
+  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+function standardDeviation(values) {
+  if (values.length < 2) return 0;
+  const mean2 = values.reduce((sum, v62) => sum + v62, 0) / values.length;
+  const squaredDiffs = values.map((v62) => (v62 - mean2) ** 2);
+  const variance = squaredDiffs.reduce((sum, v62) => sum + v62, 0) / values.length;
+  return Math.sqrt(variance);
+}
+function classifyLevel(score) {
+  if (score >= 0.7) return "severe";
+  if (score >= 0.5) return "moderate";
+  if (score >= 0.3) return "mild";
+  return "independent";
+}
+function generateRecommendation(level) {
+  switch (level) {
+    case "independent":
+      return "Votes appear independent. No action needed.";
+    case "mild":
+      return "Slight agreement bias detected. Consider monitoring for patterns.";
+    case "moderate":
+      return "Moderate rubber-stamping detected. Consider adding diverse model providers or requesting re-evaluation with varied prompts.";
+    case "severe":
+      return "Severe rubber-stamping detected. Recommend human review and adding independent model providers with different architectures.";
+  }
+}
+function calculateVerdictUnanimity(votes) {
+  if (votes.length < 2) return 0;
+  const agreesCount = votes.filter((v62) => v62.agrees).length;
+  const ratio = agreesCount / votes.length;
+  return Math.abs(ratio - 0.5) * 2;
+}
+function calculateReasoningSimilarity(votes) {
+  if (votes.length < 2) return 0;
+  const reasonings = votes.map((v62) => v62.reasoning).filter((r54) => r54.length > 0);
+  if (reasonings.length < 2) return 0;
+  let totalSimilarity = 0;
+  let pairCount = 0;
+  for (let i58 = 0; i58 < reasonings.length; i58++) {
+    for (let j52 = i58 + 1; j52 < reasonings.length; j52++) {
+      totalSimilarity += jaccardSimilarity(reasonings[i58], reasonings[j52]);
+      pairCount++;
+    }
+  }
+  return pairCount === 0 ? 0 : totalSimilarity / pairCount;
+}
+function calculateConfidenceUniformity(votes) {
+  if (votes.length < 2) return 0;
+  const confidences = votes.map((v62) => v62.confidence);
+  const stdDev2 = standardDeviation(confidences);
+  return Math.max(0, 1 - stdDev2 * 2);
+}
+function calculateIssueCountConsistency(votes) {
+  if (votes.length < 2) return 0;
+  const counts = votes.map((v62) => v62.suggestions?.length ?? 0);
+  if (counts.every((c70) => c70 === 0)) return 0.5;
+  const stdDev2 = standardDeviation(counts);
+  const mean2 = counts.reduce((sum, c70) => sum + c70, 0) / counts.length;
+  if (mean2 === 0) return 0.5;
+  const cv = stdDev2 / mean2;
+  return Math.max(0, 1 - cv);
+}
+var SycophancyScorer = class {
+  signalWeights;
+  constructor() {
+    this.signalWeights = [
+      { name: "verdict-unanimity", weight: 0.3, calculator: calculateVerdictUnanimity },
+      { name: "reasoning-similarity", weight: 0.3, calculator: calculateReasoningSimilarity },
+      { name: "confidence-uniformity", weight: 0.2, calculator: calculateConfidenceUniformity },
+      { name: "issue-count-consistency", weight: 0.2, calculator: calculateIssueCountConsistency }
+    ];
+  }
+  /**
+   * Evaluate a set of model votes for sycophancy signals
+   *
+   * @param votes - Array of model votes to evaluate
+   * @returns SycophancyResult with level, composite score, signals, and recommendation
+   */
+  evaluate(votes) {
+    if (votes.length < 2) {
+      return {
+        level: "independent",
+        compositeScore: 0,
+        signals: this.signalWeights.map((sw) => ({
+          name: sw.name,
+          weight: sw.weight,
+          score: 0
+        })),
+        recommendation: "Insufficient votes for sycophancy detection."
+      };
+    }
+    const signals = this.signalWeights.map((sw) => ({
+      name: sw.name,
+      weight: sw.weight,
+      score: sw.calculator(votes)
+    }));
+    const compositeScore = signals.reduce(
+      (sum, signal) => sum + signal.weight * signal.score,
+      0
+    );
+    const level = classifyLevel(compositeScore);
+    const recommendation = generateRecommendation(level);
+    return {
+      level,
+      compositeScore,
+      signals,
+      recommendation
+    };
+  }
+};
+function createSycophancyScorer() {
+  return new SycophancyScorer();
+}
+
+// src/coordination/consensus/consensus-engine.ts
 var ConsensusEngineImpl = class {
   registry;
   config;
   strategy;
   stats;
+  sycophancyScorer;
+  _onSevereSycophancy;
   disposed = false;
   /**
    * Create a new consensus engine
@@ -40626,8 +41244,18 @@ var ConsensusEngineImpl = class {
     this.registry = registry3;
     this.config = { ...DEFAULT_CONSENSUS_CONFIG, ...config };
     this.strategy = this.createStrategyFromConfig(strategyType);
+    this.sycophancyScorer = this.config.enableSycophancyCheck ? createSycophancyScorer() : null;
     this.stats = this.initializeStats();
   }
+  /**
+   * Register a callback for severe sycophancy detection.
+   * Use this to trigger Devil's Advocate reviews when rubber-stamping is detected.
+   *
+   * @param handler - Callback receiving the finding and votes that triggered detection
+   */
+  onSevereSycophancy(handler) {
+    this._onSevereSycophancy = handler;
+  }
   /**
    * Verify a security finding using multiple models
    *
@@ -40655,14 +41283,25 @@ var ConsensusEngineImpl = class {
       }
       const votes = await this.queryModels(finding, modelIds, options);
       const strategyResult = this.strategy.apply(votes);
+      const sycophancyCheck = this.sycophancyScorer?.evaluate(votes);
+      const isSevereSycophancy = sycophancyCheck?.level === "severe";
+      const requiresHumanReview = strategyResult.requiresHumanReview || isSevereSycophancy;
+      if (isSevereSycophancy && this._onSevereSycophancy) {
+        try {
+          this._onSevereSycophancy(finding, votes);
+        } catch (callbackError) {
+          console.warn("[ConsensusEngine] Sycophancy callback failed:", toErrorMessage(callbackError));
+        }
+      }
       const result = {
         verdict: strategyResult.verdict,
         finding,
         confidence: strategyResult.confidence,
         votes,
         agreementRatio: strategyResult.agreementRatio,
-        requiresHumanReview: strategyResult.requiresHumanReview,
+        requiresHumanReview,
         reasoning: strategyResult.reasoning,
+        sycophancyCheck,
         adjustedSeverity: this.determineAdjustedSeverity(votes, finding.severity),
         combinedSuggestions: this.combineSuggestions(votes),
         totalExecutionTime: Date.now() - startTime,
@@ -49604,7 +50243,7 @@ var ShardEmbeddingsManager = class {
 var shardEmbeddingsManager = new ShardEmbeddingsManager();
 
 // src/coordination/mixins/governance-aware-domain.ts
-var DEFAULT_CONFIG7 = {
+var DEFAULT_CONFIG8 = {
   enableGovernance: true,
   requireSecurityScan: false,
   requireBackupBeforeDelete: true,
@@ -49615,7 +50254,7 @@ var GovernanceAwareDomainMixin = class {
   config;
   constructor(domainName, config = {}) {
     this.domainName = domainName;
-    this.config = { ...DEFAULT_CONFIG7, ...config };
+    this.config = { ...DEFAULT_CONFIG8, ...config };
   }
   /**
    * Validate a memory write operation using MemoryWriteGate
@@ -52373,7 +53012,7 @@ function createTestGenerationCoherenceGate(coherenceService, embeddingService, c
 }
 
 // src/domains/test-generation/coordinator.ts
-var DEFAULT_CONFIG8 = {
+var DEFAULT_CONFIG9 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   // 60 seconds
@@ -52401,7 +53040,7 @@ var DEFAULT_CONFIG8 = {
 };
 var TestGenerationCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}, coherenceService, hookRegistry) {
-    const fullConfig = { ...DEFAULT_CONFIG8, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG9, ...config };
     super(eventBus, "test-generation", fullConfig, {
       verifyFindingTypes: [
         "test-pattern-selection",
@@ -54122,7 +54761,7 @@ var LLM_ANALYSIS_CONSTANTS = {
 init_error_utils();
 init_safe_json();
 init_crypto_random();
-var DEFAULT_CONFIG9 = {
+var DEFAULT_CONFIG10 = {
   simulateForTesting: false,
   simulatedTestsPerFile: 5,
   simulatedFailureRate: 0.2,
@@ -54146,7 +54785,7 @@ var TestExecutorService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG9, ...config };
+    this.config = { ...DEFAULT_CONFIG10, ...config };
   }
   /**
    * Execute a test suite sequentially
@@ -56330,7 +56969,7 @@ function createTestPrioritizationState(testId, metadata) {
 }
 
 // src/domains/test-execution/services/test-prioritizer.ts
-var DEFAULT_CONFIG10 = {
+var DEFAULT_CONFIG11 = {
   enableDT: true,
   minTrajectoriesForDT: 5,
   enableHeuristicFallback: true,
@@ -56343,7 +56982,7 @@ var DEFAULT_CONFIG10 = {
 var TestPrioritizerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG10, ...config };
+    this.config = { ...DEFAULT_CONFIG11, ...config };
     this.decisionTransformer = new DecisionTransformerAlgorithm({
       contextLength: this.config.contextLength,
       embeddingDim: this.config.embeddingDim
@@ -58496,6 +59135,480 @@ var AgentBrowserClient = class {
   }
 };
 
+// src/integrations/browser/stealth/stealth-client.ts
+import { randomUUID as randomUUID6 } from "crypto";
+
+// src/integrations/browser/stealth/stealth-types.ts
+var DEFAULT_STEALTH_CONFIG = {
+  persistentContext: true,
+  cloudflareWaitSeconds: 0,
+  resourceBlocking: "functional"
+};
+
+// src/integrations/browser/resource-blocking.ts
+var TRACKING_DOMAINS = /* @__PURE__ */ new Set([
+  "google-analytics.com",
+  "googletagmanager.com",
+  "analytics.google.com",
+  "hotjar.com",
+  "fullstory.com",
+  "segment.io",
+  "segment.com",
+  "mixpanel.com",
+  "heap.io",
+  "heapanalytics.com",
+  "amplitude.com",
+  "mouseflow.com",
+  "crazyegg.com",
+  "optimizely.com",
+  "newrelic.com",
+  "nr-data.net",
+  "sentry.io",
+  "bugsnag.com",
+  "logrocket.com",
+  "clarity.ms",
+  "facebook.net",
+  "connect.facebook.net"
+]);
+var ADVERTISING_DOMAINS = /* @__PURE__ */ new Set([
+  "doubleclick.net",
+  "googlesyndication.com",
+  "googleadservices.com",
+  "google-analytics.com",
+  "adservice.google.com",
+  "pagead2.googlesyndication.com",
+  "ads.twitter.com",
+  "ads-api.twitter.com",
+  "adsserver.com",
+  "adnxs.com",
+  "amazon-adsystem.com",
+  "criteo.com",
+  "moatads.com",
+  "outbrain.com",
+  "taboola.com",
+  "bidswitch.net",
+  "rubiconproject.com"
+]);
+var RESOURCE_TYPE_TO_CATEGORY = {
+  image: "image",
+  font: "font",
+  media: "media",
+  stylesheet: "stylesheet",
+  websocket: "websocket"
+};
+var PRESETS = {
+  /**
+   * Functional preset: block everything non-essential for functional testing.
+   * Fastest page loads — only HTML, JS, and XHR/fetch are allowed.
+   */
+  functional: {
+    enabled: true,
+    blockedCategories: ["image", "font", "media", "stylesheet", "tracking", "advertising"]
+  },
+  /**
+   * Visual preset: block nothing — needed for visual regression testing.
+   */
+  visual: {
+    enabled: false,
+    blockedCategories: []
+  },
+  /**
+   * Performance preset: block heavy resources and tracking only.
+   * Keeps stylesheets for layout accuracy but drops images/fonts/media.
+   */
+  performance: {
+    enabled: true,
+    blockedCategories: ["image", "font", "media", "tracking", "advertising"]
+  }
+};
+function shouldBlockRequest(url, resourceType, config) {
+  if (!config.enabled) {
+    return false;
+  }
+  if (config.allowPatterns?.length) {
+    for (const pattern of config.allowPatterns) {
+      if (urlMatchesPattern(url, pattern)) {
+        return false;
+      }
+    }
+  }
+  if (config.blockPatterns?.length) {
+    for (const pattern of config.blockPatterns) {
+      if (urlMatchesPattern(url, pattern)) {
+        return true;
+      }
+    }
+  }
+  const category = RESOURCE_TYPE_TO_CATEGORY[resourceType];
+  if (category && config.blockedCategories.includes(category)) {
+    return true;
+  }
+  if (config.blockedCategories.includes("tracking") && isDomainInSet(url, TRACKING_DOMAINS)) {
+    return true;
+  }
+  if (config.blockedCategories.includes("advertising") && isDomainInSet(url, ADVERTISING_DOMAINS)) {
+    return true;
+  }
+  return false;
+}
+function getResourceBlockingPreset(name) {
+  if (typeof name === "object") {
+    return name;
+  }
+  const preset = PRESETS[name];
+  if (!preset) {
+    return PRESETS.visual;
+  }
+  return { ...preset, blockedCategories: [...preset.blockedCategories] };
+}
+var patternCache = /* @__PURE__ */ new Map();
+function urlMatchesPattern(url, pattern) {
+  let regex = patternCache.get(pattern);
+  if (!regex) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    regex = new RegExp(escaped, "i");
+    patternCache.set(pattern, regex);
+  }
+  return regex.test(url);
+}
+function isDomainInSet(url, domains) {
+  try {
+    const hostname = new URL(url).hostname;
+    for (const domain of domains) {
+      if (hostname === domain || hostname.endsWith(`.${domain}`)) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/integrations/browser/stealth/stealth-client.ts
+var patchrightModule = null;
+var patchrightChecked = false;
+function getPatchright() {
+  if (patchrightChecked) return patchrightModule;
+  patchrightChecked = true;
+  try {
+    patchrightModule = __require("patchright");
+  } catch {
+    patchrightModule = null;
+  }
+  return patchrightModule;
+}
+var StealthBrowserClient = class {
+  tool = "stealth";
+  stealthConfig;
+  page = null;
+  context = null;
+  browser = null;
+  sessionId = null;
+  constructor(config) {
+    this.stealthConfig = { ...DEFAULT_STEALTH_CONFIG, ...config };
+  }
+  // ========================================================================
+  // Lifecycle
+  // ========================================================================
+  async isAvailable() {
+    return getPatchright() !== null;
+  }
+  async launch(options) {
+    const pr3 = getPatchright();
+    if (!pr3) {
+      return {
+        success: false,
+        error: new BrowserUnavailableError(
+          "stealth",
+          "Patchright is not installed. Install with: npm install patchright"
+        )
+      };
+    }
+    try {
+      const launchOptions = {
+        headless: options?.headless ?? true
+      };
+      if (options?.viewport) {
+        launchOptions.viewport = options.viewport;
+      }
+      if (options?.args) {
+        launchOptions.args = options.args;
+      }
+      if (this.stealthConfig.userAgent) {
+        launchOptions.userAgent = this.stealthConfig.userAgent;
+      }
+      if (this.stealthConfig.proxy) {
+        launchOptions.proxy = this.stealthConfig.proxy;
+      }
+      if (this.stealthConfig.persistentContext) {
+        const userDataDir = this.stealthConfig.userDataDir || `/tmp/stealth-browser-${randomUUID6()}`;
+        this.context = await pr3.chromium.launchPersistentContext(userDataDir, launchOptions);
+        const pages = this.context.pages();
+        this.page = pages.length > 0 ? pages[0] : await this.context.newPage();
+      } else {
+        this.browser = await pr3.chromium.launch(launchOptions);
+        this.page = await this.browser.newPage();
+      }
+      await this.applyResourceBlocking();
+      this.sessionId = randomUUID6();
+      return {
+        success: true,
+        value: {
+          id: this.sessionId,
+          tool: "stealth",
+          status: "active",
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      };
+    } catch (err3) {
+      return {
+        success: false,
+        error: new BrowserError(
+          `Failed to launch stealth browser: ${err3 instanceof Error ? err3.message : String(err3)}`,
+          "LAUNCH_FAILED",
+          "stealth",
+          err3 instanceof Error ? err3 : void 0
+        )
+      };
+    }
+  }
+  async quit() {
+    try {
+      if (this.context) {
+        await this.context.close();
+        this.context = null;
+      }
+      if (this.browser) {
+        await this.browser.close();
+        this.browser = null;
+      }
+      this.page = null;
+      this.sessionId = null;
+      return { success: true, value: void 0 };
+    } catch (err3) {
+      return {
+        success: false,
+        error: new BrowserError(
+          "Failed to quit stealth browser",
+          "QUIT_FAILED",
+          "stealth",
+          err3 instanceof Error ? err3 : void 0
+        )
+      };
+    }
+  }
+  // ========================================================================
+  // Navigation
+  // ========================================================================
+  async navigate(url) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const start = Date.now();
+      const response = await this.page.goto(url, { waitUntil: "domcontentloaded" });
+      const statusCode = response?.status() ?? void 0;
+      if (this.stealthConfig.cloudflareWaitSeconds > 0) {
+        await this.waitForCloudflare();
+      }
+      const title = await this.page.title();
+      return {
+        success: true,
+        value: {
+          url: this.page.url(),
+          title,
+          success: true,
+          durationMs: Date.now() - start,
+          statusCode: statusCode ?? void 0
+        }
+      };
+    } catch (err3) {
+      return this.wrapError("navigate", err3);
+    }
+  }
+  async reload() {
+    if (!this.page) return this.notLaunched();
+    try {
+      await this.page.reload();
+      return { success: true, value: void 0 };
+    } catch (err3) {
+      return this.wrapError("reload", err3);
+    }
+  }
+  async goBack() {
+    if (!this.page) return this.notLaunched();
+    try {
+      await this.page.goBack();
+      return { success: true, value: void 0 };
+    } catch (err3) {
+      return this.wrapError("goBack", err3);
+    }
+  }
+  async goForward() {
+    if (!this.page) return this.notLaunched();
+    try {
+      await this.page.goForward();
+      return { success: true, value: void 0 };
+    } catch (err3) {
+      return this.wrapError("goForward", err3);
+    }
+  }
+  // ========================================================================
+  // Element Interaction
+  // ========================================================================
+  async click(target) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const selector = this.resolveSelector(target);
+      await this.page.click(selector);
+      return { success: true, value: void 0 };
+    } catch (err3) {
+      return this.wrapError("click", err3);
+    }
+  }
+  async fill(target, text) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const selector = this.resolveSelector(target);
+      await this.page.fill(selector, text);
+      return { success: true, value: void 0 };
+    } catch (err3) {
+      return this.wrapError("fill", err3);
+    }
+  }
+  async getText(target) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const selector = this.resolveSelector(target);
+      const text = await this.page.textContent(selector);
+      return { success: true, value: text ?? "" };
+    } catch (err3) {
+      return this.wrapError("getText", err3);
+    }
+  }
+  async isVisible(target) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const selector = this.resolveSelector(target);
+      const visible = await this.page.isVisible(selector);
+      return { success: true, value: visible };
+    } catch (err3) {
+      return this.wrapError("isVisible", err3);
+    }
+  }
+  // ========================================================================
+  // Screenshots
+  // ========================================================================
+  async screenshot(options) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const buffer = await this.page.screenshot({
+        path: options?.path,
+        fullPage: options?.fullPage,
+        type: "png"
+      });
+      return {
+        success: true,
+        value: {
+          base64: buffer.toString("base64"),
+          path: options?.path,
+          format: "png",
+          dimensions: { width: 0, height: 0 }
+          // Patchright doesn't expose dimensions directly
+        }
+      };
+    } catch (err3) {
+      return this.wrapError("screenshot", err3);
+    }
+  }
+  // ========================================================================
+  // Evaluate
+  // ========================================================================
+  async evaluate(script) {
+    if (!this.page) return this.notLaunched();
+    try {
+      const result = await this.page.evaluate(script);
+      return { success: true, value: result };
+    } catch (err3) {
+      return this.wrapError("evaluate", err3);
+    }
+  }
+  // ========================================================================
+  // Cleanup
+  // ========================================================================
+  async dispose() {
+    await this.quit();
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  resolveSelector(target) {
+    if (typeof target === "string") return target;
+    switch (target.type) {
+      case "css":
+        return target.value;
+      case "xpath":
+        return `xpath=${target.value}`;
+      case "text":
+        return `text=${target.value}`;
+      case "ref":
+        return target.value;
+      default:
+        return target.value;
+    }
+  }
+  async applyResourceBlocking() {
+    if (!this.page || !this.stealthConfig.resourceBlocking) return;
+    const config = typeof this.stealthConfig.resourceBlocking === "string" ? getResourceBlockingPreset(this.stealthConfig.resourceBlocking) : this.stealthConfig.resourceBlocking;
+    if (!config.enabled) return;
+    await this.page.route("**/*", (route) => {
+      const url = route.request().url();
+      const resourceType = route.request().resourceType();
+      if (shouldBlockRequest(url, resourceType, config)) {
+        route.abort().catch(() => {
+        });
+      } else {
+        route.continue().catch(() => {
+        });
+      }
+    });
+  }
+  async waitForCloudflare() {
+    if (!this.page || this.stealthConfig.cloudflareWaitSeconds <= 0) return;
+    const ms = this.stealthConfig.cloudflareWaitSeconds * 1e3;
+    const start = Date.now();
+    while (Date.now() - start < ms) {
+      try {
+        const title = await this.page.title();
+        if (!title.includes("Just a moment") && !title.includes("Checking your browser")) {
+          return;
+        }
+      } catch {
+      }
+      await new Promise((resolve22) => setTimeout(resolve22, 500));
+    }
+  }
+  notLaunched() {
+    return {
+      success: false,
+      error: new BrowserError(
+        "Stealth browser not launched. Call launch() first.",
+        "NOT_LAUNCHED",
+        "stealth"
+      )
+    };
+  }
+  wrapError(operation, err3) {
+    return {
+      success: false,
+      error: new BrowserError(
+        `Stealth ${operation} failed: ${err3 instanceof Error ? err3.message : String(err3)}`,
+        "OPERATION_FAILED",
+        "stealth",
+        err3 instanceof Error ? err3 : void 0
+      )
+    };
+  }
+};
+
 // src/integrations/browser/client-factory.ts
 async function isVibiumAvailable() {
   return false;
@@ -58518,6 +59631,10 @@ var AGENT_BROWSER_REQUIRED_USE_CASES = [
   "auth-testing"
   // Requires state persistence
 ];
+var STEALTH_PREFERRED_USE_CASES = [
+  "stealth-testing"
+  // Bot-protected environments
+];
 function requiresAgentBrowser(useCase) {
   return AGENT_BROWSER_REQUIRED_USE_CASES.includes(useCase);
 }
@@ -58603,12 +59720,23 @@ var VibiumClientStub = class {
 };
 async function createBrowserClient(options = {}) {
   const { preference = "auto", useCase } = options;
+  if (useCase && STEALTH_PREFERRED_USE_CASES.includes(useCase)) {
+    if (await isStealthAvailable()) {
+      return new StealthBrowserClient();
+    }
+  }
   if (useCase && requiresAgentBrowser(useCase)) {
     return createAgentBrowserClient();
   }
   if (preference === "agent-browser") {
     return createAgentBrowserClient();
   }
+  if (preference === "stealth") {
+    if (await isStealthAvailable()) {
+      return new StealthBrowserClient();
+    }
+    throw new BrowserUnavailableError("stealth", "Patchright is not installed");
+  }
   if (preference === "vibium") {
     const available = await isVibiumAvailable();
     if (available) {
@@ -58632,6 +59760,14 @@ async function createAgentBrowserClient() {
 async function getBrowserClientForUseCase(useCase) {
   return createBrowserClient({ useCase });
 }
+async function isStealthAvailable() {
+  try {
+    const client = new StealthBrowserClient();
+    return await client.isAvailable();
+  } catch {
+    return false;
+  }
+}
 
 // src/integrations/browser/web-content-fetcher.ts
 import { exec, execSync as execSync2 } from "child_process";
@@ -58642,6 +59778,383 @@ var execAsync = promisify(exec);
 
 // src/domains/test-execution/services/e2e/browser-orchestrator.ts
 init_error_utils();
+
+// src/domains/test-execution/services/e2e/adaptive-locator-types.ts
+var DEFAULT_ADAPTIVE_LOCATOR_CONFIG = {
+  enabled: true,
+  similarityThreshold: 0.6,
+  maxFingerprintsPerPage: 200,
+  namespace: "aqe/adaptive-locators",
+  fallbackChain: ["text", "aria", "fingerprint"]
+};
+
+// src/domains/test-execution/services/e2e/adaptive-locator-service.ts
+function buildCaptureScript(cssSelector) {
+  return `
+    (() => {
+      const el = document.querySelector(${JSON.stringify(cssSelector)});
+      if (!el) return null;
+      const parent = el.parentElement;
+      const siblings = parent ? parent.children : [];
+      let childIndex = 0;
+      for (let i = 0; i < siblings.length; i++) {
+        if (siblings[i] === el) { childIndex = i; break; }
+      }
+      return {
+        tagName: el.tagName.toLowerCase(),
+        classes: Array.from(el.classList),
+        ariaRole: el.getAttribute('role') || undefined,
+        ariaLabel: el.getAttribute('aria-label') || undefined,
+        textContent: (el.textContent || '').trim().slice(0, 200) || undefined,
+        attributes: {
+          id: el.id || undefined,
+          name: el.getAttribute('name') || undefined,
+          'data-testid': el.getAttribute('data-testid') || undefined,
+          type: el.getAttribute('type') || undefined,
+          placeholder: el.getAttribute('placeholder') || undefined,
+          href: el.getAttribute('href') || undefined,
+        },
+        positionHints: {
+          parentTag: parent ? parent.tagName.toLowerCase() : undefined,
+          childIndex,
+          siblingCount: siblings.length,
+        },
+        matchCount: 0,
+        lastMatchedAt: new Date().toISOString(),
+      };
+    })()
+  `;
+}
+function buildCandidatesScript() {
+  return `
+    (() => {
+      const interactiveTags = 'a,button,input,select,textarea,[role],[data-testid],[aria-label]';
+      const elements = document.querySelectorAll(interactiveTags);
+      const results = [];
+      for (let i = 0; i < Math.min(elements.length, 300); i++) {
+        const el = elements[i];
+        const parent = el.parentElement;
+        const siblings = parent ? parent.children : [];
+        let childIndex = 0;
+        for (let j = 0; j < siblings.length; j++) {
+          if (siblings[j] === el) { childIndex = j; break; }
+        }
+        results.push({
+          tagName: el.tagName.toLowerCase(),
+          classes: Array.from(el.classList),
+          ariaRole: el.getAttribute('role') || undefined,
+          ariaLabel: el.getAttribute('aria-label') || undefined,
+          textContent: (el.textContent || '').trim().slice(0, 200) || undefined,
+          attributes: {
+            id: el.id || undefined,
+            name: el.getAttribute('name') || undefined,
+            'data-testid': el.getAttribute('data-testid') || undefined,
+            type: el.getAttribute('type') || undefined,
+            placeholder: el.getAttribute('placeholder') || undefined,
+            href: el.getAttribute('href') || undefined,
+          },
+          positionHints: {
+            parentTag: parent ? parent.tagName.toLowerCase() : undefined,
+            childIndex,
+            siblingCount: siblings.length,
+          },
+          // Build a unique-enough CSS selector for this element
+          selector: buildSelector(el),
+        });
+      }
+
+      function buildSelector(el) {
+        if (el.id) return '#' + CSS.escape(el.id);
+        if (el.getAttribute('data-testid')) return '[data-testid="' + el.getAttribute('data-testid') + '"]';
+        if (el.getAttribute('name')) return el.tagName.toLowerCase() + '[name="' + el.getAttribute('name') + '"]';
+        // Fallback: tag + nth-child
+        const parent = el.parentElement;
+        if (!parent) return el.tagName.toLowerCase();
+        const siblings = Array.from(parent.children).filter(s => s.tagName === el.tagName);
+        const idx = siblings.indexOf(el) + 1;
+        return el.tagName.toLowerCase() + ':nth-of-type(' + idx + ')';
+      }
+
+      return results;
+    })()
+  `;
+}
+var WEIGHTS = {
+  tagName: 0.2,
+  ariaRole: 0.15,
+  classes: 0.15,
+  textContent: 0.2,
+  attributes: 0.15,
+  positionHints: 0.15
+};
+function jaccardSimilarity2(a37, b68) {
+  if (a37.length === 0 && b68.length === 0) return 1;
+  const setA = new Set(a37);
+  const setB = new Set(b68);
+  let intersection = 0;
+  for (const item of setA) {
+    if (setB.has(item)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function textSimilarity(a37, b68) {
+  if (!a37 && !b68) return 1;
+  if (!a37 || !b68) return 0;
+  const la13 = a37.toLowerCase();
+  const lb = b68.toLowerCase();
+  if (la13 === lb) return 1;
+  if (la13.includes(lb) || lb.includes(la13)) return 0.8;
+  const setA = new Set(la13);
+  const setB = new Set(lb);
+  let common = 0;
+  for (const c70 of setA) {
+    if (setB.has(c70)) common++;
+  }
+  const total = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return total === 0 ? 0 : common / total * 0.6;
+}
+function computeSimilarity(stored, candidate) {
+  let score = 0;
+  score += (stored.tagName === candidate.tagName ? 1 : 0) * WEIGHTS.tagName;
+  if (stored.ariaRole || candidate.ariaRole) {
+    score += (stored.ariaRole === candidate.ariaRole ? 1 : 0) * WEIGHTS.ariaRole;
+  } else {
+    score += WEIGHTS.ariaRole;
+  }
+  score += jaccardSimilarity2(stored.classes, candidate.classes) * WEIGHTS.classes;
+  score += textSimilarity(stored.textContent, candidate.textContent) * WEIGHTS.textContent;
+  const storedAttrs = Object.entries(stored.attributes).filter(([, v62]) => v62);
+  const candidateAttrs = Object.entries(candidate.attributes).filter(([, v62]) => v62);
+  if (storedAttrs.length === 0 && candidateAttrs.length === 0) {
+    score += WEIGHTS.attributes;
+  } else {
+    let matches = 0;
+    for (const [key, val] of storedAttrs) {
+      const candidateVal = candidate.attributes[key];
+      if (candidateVal === val) matches++;
+    }
+    const total = Math.max(storedAttrs.length, candidateAttrs.length, 1);
+    score += matches / total * WEIGHTS.attributes;
+  }
+  const posScore = computePositionScore(stored.positionHints, candidate.positionHints);
+  score += posScore * WEIGHTS.positionHints;
+  return Math.min(1, Math.max(0, score));
+}
+function computePositionScore(a37, b68) {
+  let total = 0;
+  let matches = 0;
+  total++;
+  if (a37.parentTag === b68.parentTag) matches++;
+  total++;
+  const indexDiff = Math.abs(a37.childIndex - b68.childIndex);
+  matches += Math.max(0, 1 - indexDiff / 10);
+  total++;
+  const sibDiff = Math.abs(a37.siblingCount - b68.siblingCount);
+  matches += Math.max(0, 1 - sibDiff / 10);
+  return matches / total;
+}
+var FingerprintStore = class {
+  store = /* @__PURE__ */ new Map();
+  maxPerPage;
+  constructor(maxPerPage = 200) {
+    this.maxPerPage = maxPerPage;
+  }
+  key(pageUrl, selector) {
+    return `${pageUrl}::${selector}`;
+  }
+  get(pageUrl, selector) {
+    return this.store.get(this.key(pageUrl, selector));
+  }
+  set(pageUrl, selector, fp) {
+    const k68 = this.key(pageUrl, selector);
+    this.store.set(k68, fp);
+    const prefix = `${pageUrl}::`;
+    const pageKeys = [...this.store.keys()].filter((key) => key.startsWith(prefix));
+    if (pageKeys.length > this.maxPerPage) {
+      const toRemove = pageKeys.length - this.maxPerPage;
+      for (let i58 = 0; i58 < toRemove; i58++) {
+        this.store.delete(pageKeys[i58]);
+      }
+    }
+  }
+  size() {
+    return this.store.size;
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+var AdaptiveLocatorService = class {
+  config;
+  fingerprintStore;
+  constructor(config) {
+    this.config = { ...DEFAULT_ADAPTIVE_LOCATOR_CONFIG, ...config };
+    this.fingerprintStore = new FingerprintStore(this.config.maxFingerprintsPerPage);
+  }
+  /**
+   * Capture and store a fingerprint for a successfully-interacted element
+   */
+  async captureFingerprint(selector, client, pageUrl) {
+    if (!this.config.enabled) return null;
+    try {
+      const cssSelector = this.toCssForCapture(selector);
+      if (!cssSelector) return null;
+      const result = await client.evaluate(
+        buildCaptureScript(cssSelector)
+      );
+      if (!result.success || !result.value) return null;
+      const fingerprint = result.value;
+      fingerprint.matchCount = (this.fingerprintStore.get(pageUrl, selector)?.matchCount ?? 0) + 1;
+      fingerprint.lastMatchedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.fingerprintStore.set(pageUrl, selector, fingerprint);
+      return fingerprint;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Resolve an element target with adaptive fallback chain.
+   *
+   * 1. Try primary selector
+   * 2. Text-based match
+   * 3. ARIA-based match
+   * 4. Fingerprint similarity matching
+   */
+  async resolveWithFallback(selector, client, pageUrl) {
+    if (!this.config.enabled) return null;
+    const storedFingerprint = this.fingerprintStore.get(pageUrl, selector);
+    if (!storedFingerprint) return null;
+    for (const method of this.config.fallbackChain) {
+      const result = await this.tryFallbackMethod(method, storedFingerprint, client);
+      if (result) return result;
+    }
+    return null;
+  }
+  /**
+   * Get the fingerprint store size (for diagnostics)
+   */
+  getStoreSize() {
+    return this.fingerprintStore.size();
+  }
+  /**
+   * Clear all stored fingerprints
+   */
+  clearFingerprints() {
+    this.fingerprintStore.clear();
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  async tryFallbackMethod(method, stored, client) {
+    switch (method) {
+      case "text":
+        return this.tryTextMatch(stored, client);
+      case "aria":
+        return this.tryAriaMatch(stored, client);
+      case "fingerprint":
+        return this.tryFingerprintMatch(stored, client);
+      default:
+        return null;
+    }
+  }
+  async tryTextMatch(stored, client) {
+    if (!stored.textContent) return null;
+    const safeText = JSON.stringify(stored.textContent);
+    const script = `
+      (() => {
+        const target = ${safeText};
+        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+        while (walker.nextNode()) {
+          const el = walker.currentNode;
+          const text = (el.textContent || '').trim().slice(0, 200);
+          if (text === target) {
+            if (el.id) return '#' + CSS.escape(el.id);
+            if (el.getAttribute('data-testid')) return '[data-testid="' + el.getAttribute('data-testid') + '"]';
+            return null;
+          }
+        }
+        return null;
+      })()
+    `;
+    try {
+      const result = await client.evaluate(script);
+      if (result.success && result.value) {
+        return {
+          resolvedSelector: result.value,
+          method: "text",
+          similarityScore: 0.9,
+          fingerprintUpdated: false
+        };
+      }
+    } catch {
+    }
+    return null;
+  }
+  async tryAriaMatch(stored, client) {
+    if (!stored.ariaRole && !stored.ariaLabel) return null;
+    let ariaSelector = "";
+    if (stored.ariaRole && stored.ariaLabel) {
+      ariaSelector = `[role="${stored.ariaRole}"][aria-label="${stored.ariaLabel}"]`;
+    } else if (stored.ariaLabel) {
+      ariaSelector = `[aria-label="${stored.ariaLabel}"]`;
+    } else if (stored.ariaRole) {
+      ariaSelector = `[role="${stored.ariaRole}"]`;
+    }
+    if (!ariaSelector) return null;
+    try {
+      const checkScript = `!!document.querySelector(${JSON.stringify(ariaSelector)})`;
+      const result = await client.evaluate(checkScript);
+      if (result.success && result.value) {
+        return {
+          resolvedSelector: ariaSelector,
+          method: "aria",
+          similarityScore: 0.85,
+          fingerprintUpdated: false
+        };
+      }
+    } catch {
+    }
+    return null;
+  }
+  async tryFingerprintMatch(stored, client) {
+    try {
+      const result = await client.evaluate(buildCandidatesScript());
+      if (!result.success || !result.value?.length) return null;
+      let bestScore = 0;
+      let bestSelector = "";
+      for (const candidate of result.value) {
+        const score = computeSimilarity(stored, candidate);
+        if (score > bestScore) {
+          bestScore = score;
+          bestSelector = candidate.selector;
+        }
+      }
+      if (bestScore >= this.config.similarityThreshold && bestSelector) {
+        return {
+          resolvedSelector: bestSelector,
+          method: "fingerprint",
+          similarityScore: bestScore,
+          fingerprintUpdated: false
+        };
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Convert a selector string to a CSS selector suitable for capture.
+   * Returns null for non-CSS selectors that can't be used with querySelector.
+   */
+  toCssForCapture(selector) {
+    if (selector.startsWith("//") || selector.startsWith("xpath=")) return null;
+    if (/^@?e\d+$/.test(selector)) return null;
+    if (selector.startsWith("text=")) return null;
+    return selector;
+  }
+};
+
+// src/domains/test-execution/services/e2e/browser-orchestrator.ts
 function isAgentBrowserClient(client) {
   return "tool" in client && client.tool === "agent-browser";
 }
@@ -58708,12 +60221,16 @@ var BrowserOrchestrator = class {
   useAgentBrowser;
   config;
   log;
+  adaptiveLocator = null;
   constructor(client, config, logger23) {
     this.client = client;
     this.config = config;
     this.log = logger23;
     this.unifiedClient = config.browserClient ?? client;
     this.useAgentBrowser = isAgentBrowserClient(this.unifiedClient);
+    if (config.adaptiveLocator?.enabled) {
+      this.adaptiveLocator = new AdaptiveLocatorService(config.adaptiveLocator);
+    }
   }
   /**
    * Get the unified browser client
@@ -58741,6 +60258,9 @@ var BrowserOrchestrator = class {
         if (!launchResult.success) {
           return `Failed to launch browser: ${launchResult.error.message}`;
         }
+        if (this.config.resourceBlocking) {
+          await this.applyResourceBlocking(this.unifiedClient, this.config.resourceBlocking);
+        }
         return null;
       } else if (isVibiumClient(this.client)) {
         const session = await this.client.getSession();
@@ -58885,6 +60405,88 @@ var BrowserOrchestrator = class {
       await this.client.findElement({ selector, visible: true });
     }
   }
+  /**
+   * Resolve an element target with adaptive fallback.
+   * If the primary selector fails and adaptive locator is configured,
+   * attempts fallback matching via text, ARIA, and fingerprint similarity.
+   */
+  async resolveElementTarget(selector, pageUrl) {
+    const primaryTarget = toElementTarget(selector);
+    if (!this.adaptiveLocator || isVibiumClient(this.unifiedClient)) {
+      return primaryTarget;
+    }
+    const browserClient = this.unifiedClient;
+    try {
+      const result = await browserClient.isVisible(primaryTarget);
+      if (result.success && result.value) {
+        await this.adaptiveLocator.captureFingerprint(selector, browserClient, pageUrl);
+        return primaryTarget;
+      }
+    } catch {
+    }
+    const resolution = await this.adaptiveLocator.resolveWithFallback(
+      selector,
+      browserClient,
+      pageUrl
+    );
+    if (resolution) {
+      this.log(
+        `Adaptive locator: resolved "${selector}" via ${resolution.method} (score: ${resolution.similarityScore.toFixed(2)})`
+      );
+      return toElementTarget(resolution.resolvedSelector);
+    }
+    return primaryTarget;
+  }
+  /**
+   * Apply resource blocking to a browser client's page via evaluate-based interception.
+   * Injects a PerformanceObserver that aborts blocked resource loads.
+   * For full route-level blocking, use StealthBrowserClient which has native page.route().
+   */
+  async applyResourceBlocking(client, config) {
+    const blockingConfig = typeof config === "string" ? getResourceBlockingPreset(config) : config;
+    if (!blockingConfig.enabled) return;
+    this.log(`Resource blocking enabled: ${blockingConfig.blockedCategories.join(", ")}`);
+    if (isAgentBrowserClient(this.unifiedClient)) {
+      const agentClient = this.unifiedClient;
+      const patterns = [];
+      if (blockingConfig.blockedCategories.includes("tracking")) {
+        patterns.push(
+          "*google-analytics.com*",
+          "*googletagmanager.com*",
+          "*hotjar.com*",
+          "*segment.com*",
+          "*mixpanel.com*",
+          "*amplitude.com*",
+          "*fullstory.com*",
+          "*clarity.ms*",
+          "*facebook.net*"
+        );
+      }
+      if (blockingConfig.blockedCategories.includes("advertising")) {
+        patterns.push(
+          "*doubleclick.net*",
+          "*googlesyndication.com*",
+          "*googleadservices.com*",
+          "*adnxs.com*",
+          "*criteo.com*",
+          "*taboola.com*",
+          "*outbrain.com*"
+        );
+      }
+      if (blockingConfig.blockPatterns) {
+        patterns.push(...blockingConfig.blockPatterns);
+      }
+      for (const pattern of patterns) {
+        await agentClient.abortRoute(pattern);
+      }
+    }
+  }
+  /**
+   * Get the adaptive locator service (for external fingerprint capture)
+   */
+  getAdaptiveLocator() {
+    return this.adaptiveLocator;
+  }
   /**
    * Get browser context options from test case
    */
@@ -59522,7 +61124,10 @@ var StepExecutors = class {
   async executeClickStep(step, client, context2) {
     if (!isVibiumClient(client)) {
       const browserClient = client;
-      const target = toElementTarget(step.target);
+      const target = await this.orchestrator.resolveElementTarget(
+        step.target,
+        this.getCurrentPageUrl(context2)
+      );
       if (context2.useAgentBrowser && isAgentBrowserClient(browserClient)) {
         const waitResult = await browserClient.waitForElement(target, step.timeout);
         if (!waitResult.success) {
@@ -59585,7 +61190,10 @@ var StepExecutors = class {
   async executeTypeStep(step, client, context2) {
     if (!isVibiumClient(client)) {
       const browserClient = client;
-      const target = toElementTarget(step.target);
+      const target = await this.orchestrator.resolveElementTarget(
+        step.target,
+        this.getCurrentPageUrl(context2)
+      );
       if (context2.useAgentBrowser && isAgentBrowserClient(browserClient)) {
         const waitResult = await browserClient.waitForElement(target, step.timeout);
         if (!waitResult.success) {
@@ -59842,6 +61450,20 @@ var StepExecutors = class {
   // ==========================================================================
   // Utility Methods
   // ==========================================================================
+  /**
+   * Get the current page URL from context, falling back to baseUrl.
+   * Uses the last navigate step's URL if available, so adaptive locator
+   * fingerprints are keyed to the actual page, not just the base URL.
+   */
+  getCurrentPageUrl(context2) {
+    for (let i58 = context2.previousResults.length - 1; i58 >= 0; i58--) {
+      const result = context2.previousResults[i58];
+      if (result.data?.url && typeof result.data.url === "string") {
+        return result.data.url;
+      }
+    }
+    return context2.baseUrl;
+  }
   resolveUrl(url, baseUrl) {
     if (url.startsWith("http://") || url.startsWith("https://")) {
       return url;
@@ -62379,7 +64001,7 @@ init_error_utils();
 init_types();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG11 = {
+var DEFAULT_CONFIG12 = {
   defaultThreshold: 80,
   enableLLMAnalysis: true,
   // On by default - opt-out
@@ -62399,7 +64021,7 @@ var CoverageAnalyzerService = class _CoverageAnalyzerService {
    * @param config - Optional configuration overrides
    */
   constructor(memoryOrDependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG11, ...config };
+    this.config = { ...DEFAULT_CONFIG12, ...config };
     if (this.isMemoryBackend(memoryOrDependencies)) {
       this.memory = memoryOrDependencies;
       this.llmRouter = void 0;
@@ -62913,7 +64535,7 @@ ${truncatedSource}
 init_types();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG12 = {
+var DEFAULT_CONFIG13 = {
   minCoverage: 80,
   enableLLMAnalysis: true,
   // On by default - opt-out
@@ -62938,11 +64560,11 @@ var GapDetectorService = class _GapDetectorService {
     if ("memory" in dependenciesOrMemory) {
       this.memory = dependenciesOrMemory.memory;
       this.llmRouter = dependenciesOrMemory.llmRouter;
-      this.config = { ...DEFAULT_CONFIG12, ...config };
+      this.config = { ...DEFAULT_CONFIG13, ...config };
     } else {
       this.memory = dependenciesOrMemory;
       this.llmRouter = void 0;
-      this.config = { ...DEFAULT_CONFIG12 };
+      this.config = { ...DEFAULT_CONFIG13 };
     }
   }
   // ============================================================================
@@ -64352,7 +65974,7 @@ var ALL_CATEGORIES = [
   "absent-edge-case",
   "missing-security-check"
 ];
-var DEFAULT_CONFIG13 = {
+var DEFAULT_CONFIG14 = {
   dimensions: 768,
   minConfidence: 0.3,
   maxGaps: 50,
@@ -64370,7 +65992,7 @@ var GhostCoverageAnalyzerService = class _GhostCoverageAnalyzerService {
   cachedPhantomRatio = 1;
   initialized = false;
   constructor(deps, config = {}) {
-    this.config = { ...DEFAULT_CONFIG13, ...config };
+    this.config = { ...DEFAULT_CONFIG14, ...config };
     this.hnswIndex = deps.hnswIndex;
     this.embedder = deps.embedder;
   }
@@ -65404,7 +67026,7 @@ var QLearningAlgorithm = class extends BaseRLAlgorithm {
 
 // src/domains/coverage-analysis/coordinator.ts
 init_esm_node();
-var DEFAULT_CONFIG14 = {
+var DEFAULT_CONFIG15 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   publishEvents: true,
@@ -65420,7 +67042,7 @@ var DEFAULT_CONFIG14 = {
 };
 var CoverageAnalysisCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG14, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG15, ...config };
     super(eventBus, "coverage-analysis", fullConfig, {
       verifyFindingTypes: ["coverage-gap", "risk-zone", "quality-regression"],
       ...fullConfig.consensusConfig
@@ -66424,7 +68046,7 @@ init_error_utils();
 init_esm_node();
 init_types();
 init_error_utils();
-var DEFAULT_CONFIG15 = {
+var DEFAULT_CONFIG16 = {
   strictMode: false,
   enableWarnings: true,
   defaultSeverities: {
@@ -66469,7 +68091,7 @@ var DEFAULT_PRESETS = {
 var QualityGateService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG15, ...config };
+    this.config = { ...DEFAULT_CONFIG16, ...config };
     for (const [name, thresholds] of Object.entries(DEFAULT_PRESETS)) {
       this.presets.set(name, thresholds);
     }
@@ -67309,7 +68931,7 @@ function getSystemMetricsCollector() {
 // src/domains/quality-assessment/services/quality-analyzer.ts
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG16 = {
+var DEFAULT_CONFIG17 = {
   enableTrendAnalysis: true,
   trendDataPointsMin: 3,
   complexityThresholds: {
@@ -67344,7 +68966,7 @@ var QualityAnalyzerService = class {
    * 2. New: (dependencies: QualityAnalyzerDependencies, config?: Partial<QualityAnalyzerConfig>)
    */
   constructor(memoryOrDependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG16, ...config };
+    this.config = { ...DEFAULT_CONFIG17, ...config };
     this.metricsAnalyzer = getCodeMetricsAnalyzer();
     if ("memory" in memoryOrDependencies) {
       this.memory = memoryOrDependencies.memory;
@@ -67975,7 +69597,7 @@ init_esm_node();
 init_types();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG17 = {
+var DEFAULT_CONFIG18 = {
   riskWeights: {
     coverage: 0.15,
     testsPassing: 0.2,
@@ -68005,7 +69627,7 @@ var DeploymentAdvisorService = class {
   memory;
   llmRouter;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG17, ...config };
+    this.config = { ...DEFAULT_CONFIG18, ...config };
     if ("memory" in dependencies) {
       this.memory = dependencies.memory;
       this.llmRouter = dependencies.llmRouter;
@@ -70910,7 +72532,7 @@ async function verifyDeploymentAdviceWithConsensus(request, initialAdvice, conse
 
 // src/domains/quality-assessment/coordinator.ts
 init_witness_chain();
-var DEFAULT_CONFIG18 = {
+var DEFAULT_CONFIG19 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   publishEvents: true,
@@ -70934,7 +72556,7 @@ var DEFAULT_CONFIG18 = {
 };
 var QualityAssessmentCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG18, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG19, ...config };
     super(eventBus, "quality-assessment", fullConfig, {
       // Quality-specific finding types that require consensus
       verifyFindingTypes: [
@@ -72062,7 +73684,7 @@ import * as path9 from "path";
 function sanitizeGitArg(arg) {
   return arg.replace(/[;&|`$(){}[\]<>\\'"!\n\r]/g, "");
 }
-var DEFAULT_CONFIG19 = {
+var DEFAULT_CONFIG20 = {
   repoRoot: process.cwd(),
   maxCommits: 100,
   bugKeywords: ["fix", "bug", "patch", "issue", "error", "defect", "problem"],
@@ -72075,7 +73697,7 @@ var GitAnalyzer = class {
   cache = /* @__PURE__ */ new Map();
   isGitRepo = null;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG19, ...config };
+    this.config = { ...DEFAULT_CONFIG20, ...config };
   }
   /**
    * Check if current directory is a git repository
@@ -72591,7 +74213,7 @@ init_io();
 init_parsers();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG20 = {
+var DEFAULT_CONFIG21 = {
   defaultThreshold: 0.5,
   maxPredictionsPerBatch: 100,
   enableHistoricalAnalysis: true,
@@ -72638,7 +74260,7 @@ var DefectPredictorService = class {
    * Supports both old signature (memory, config, ...) and new signature (dependencies, config)
    */
   constructor(memoryOrDeps, config = {}, gitAnalyzer, fileReader, tsParser) {
-    this.config = { ...DEFAULT_CONFIG20, ...config };
+    this.config = { ...DEFAULT_CONFIG21, ...config };
     if (this.isDependenciesObject(memoryOrDeps)) {
       this.memory = memoryOrDeps.memory;
       this.gitAnalyzer = memoryOrDeps.gitAnalyzer ?? new GitAnalyzer({ enableCache: true });
@@ -73409,7 +75031,7 @@ init_esm_node();
 init_types();
 init_embeddings();
 init_error_utils();
-var DEFAULT_CONFIG21 = {
+var DEFAULT_CONFIG22 = {
   minPatternFrequency: 2,
   maxPatterns: 50,
   clusterThreshold: 0.7,
@@ -73456,7 +75078,7 @@ var KNOWN_PATTERNS = {
 var PatternLearnerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG21, ...config };
+    this.config = { ...DEFAULT_CONFIG22, ...config };
     this.embedder = config.embedder ?? new NomicEmbedder({ enableFallback: true });
     if (this.config.enableFlashAttention) {
       this.initializeFlashAttention();
@@ -74049,7 +75671,7 @@ var PatternLearnerService = class {
 init_types();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG22 = {
+var DEFAULT_CONFIG23 = {
   maxTimelineEvents: 20,
   maxRelatedFiles: 10,
   minConfidenceThreshold: 0.3,
@@ -74192,7 +75814,7 @@ var RootCauseAnalyzerService = class {
    * Supports both old signature (memory, config) and new signature (dependencies, config)
    */
   constructor(memoryOrDeps, config = {}) {
-    this.config = { ...DEFAULT_CONFIG22, ...config };
+    this.config = { ...DEFAULT_CONFIG23, ...config };
     if (this.isMemoryBackend(memoryOrDeps)) {
       this.memory = memoryOrDeps;
       this.llmRouter = void 0;
@@ -74734,7 +76356,7 @@ ${fix.codeExample}
 };
 
 // src/domains/defect-intelligence/coordinator.ts
-var DEFAULT_CONFIG23 = {
+var DEFAULT_CONFIG24 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   enablePatternLearning: true,
@@ -74752,7 +76374,7 @@ var DEFAULT_CONFIG23 = {
 };
 var DefectIntelligenceCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG23, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG24, ...config };
     super(eventBus, "defect-intelligence", fullConfig, {
       verifyFindingTypes: ["defect-prediction", "root-cause", "regression-risk", "pattern-classification"],
       ...fullConfig.consensusConfig
@@ -75653,7 +77275,7 @@ init_esm_node();
 init_types();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG24 = {
+var DEFAULT_CONFIG25 = {
   enableAmbiguityDetection: true,
   minAcceptanceCriteria: 1,
   strictMode: false,
@@ -75696,7 +77318,7 @@ var RequirementsValidatorService = class {
   memory;
   llmRouter;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG24, ...config };
+    this.config = { ...DEFAULT_CONFIG25, ...config };
     if ("memory" in dependencies && typeof dependencies.memory === "object") {
       this.memory = dependencies.memory;
       this.llmRouter = dependencies.llmRouter;
@@ -76271,7 +77893,7 @@ Please analyze these requirements for:
 init_esm_node();
 init_types();
 init_error_utils();
-var DEFAULT_CONFIG25 = {
+var DEFAULT_CONFIG26 = {
   defaultExampleCount: 3,
   includeBackgroundScenarios: true,
   generateNegativeScenarios: true,
@@ -76280,7 +77902,7 @@ var DEFAULT_CONFIG25 = {
 var BDDScenarioWriterService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG25, ...config };
+    this.config = { ...DEFAULT_CONFIG26, ...config };
   }
   config;
   /**
@@ -76735,7 +78357,7 @@ var DEFAULT_WEIGHTS = {
   traceability: 0.1,
   independency: 0.15
 };
-var DEFAULT_CONFIG26 = {
+var DEFAULT_CONFIG27 = {
   defaultThreshold: 60,
   weights: DEFAULT_WEIGHTS,
   enableAIScoring: false
@@ -76744,7 +78366,7 @@ var TestabilityScorerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
     this.config = {
-      ...DEFAULT_CONFIG26,
+      ...DEFAULT_CONFIG27,
       ...config,
       weights: { ...DEFAULT_WEIGHTS, ...config.weights }
     };
@@ -77456,7 +79078,7 @@ var RequirementsValidationEvents = {
   SprintValidated: "requirements-validation.SprintValidated",
   ValidationFailed: "requirements-validation.ValidationFailed"
 };
-var DEFAULT_CONFIG27 = {
+var DEFAULT_CONFIG28 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   publishEvents: true,
@@ -77509,7 +79131,7 @@ var InMemoryRequirementRepository = class {
 };
 var RequirementsValidationCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG27, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG28, ...config };
     super(eventBus, "requirements-validation", fullConfig, {
       verifyFindingTypes: ["requirement-conflict", "testability-assessment", "ambiguous-requirement"]
     });
@@ -79913,7 +81535,7 @@ function sanitizeId(str) {
 
 // src/domains/code-intelligence/services/product-factors-bridge.ts
 init_safe_json();
-var DEFAULT_CONFIG28 = {
+var DEFAULT_CONFIG29 = {
   cacheTtlMs: 36e5,
   // 1 hour
   publishEvents: true,
@@ -79978,7 +81600,7 @@ var ProductFactorsBridgeService = class {
   constructor(eventBus, memory, config = {}) {
     this.eventBus = eventBus;
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG28, ...config };
+    this.config = { ...DEFAULT_CONFIG29, ...config };
   }
   config;
   initialized = false;
@@ -80573,7 +82195,7 @@ init_knowledge_graph();
 init_types();
 init_embeddings();
 init_error_utils();
-var DEFAULT_CONFIG30 = {
+var DEFAULT_CONFIG31 = {
   embeddingDimension: EMBEDDING_CONFIG.DIMENSIONS,
   // 768 for Nomic
   minScore: 0.5,
@@ -80586,7 +82208,7 @@ var DEFAULT_CONFIG30 = {
 var SemanticAnalyzerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG30, ...config };
+    this.config = { ...DEFAULT_CONFIG31, ...config };
     if (config.embeddingProvider) {
       this.embedder = config.embeddingProvider;
       this.embedderInitialized = true;
@@ -83506,7 +85128,7 @@ async function verifyDependencyMapping(dependency, confidence, consensusMixin, d
 }
 
 // src/domains/code-intelligence/coordinator.ts
-var DEFAULT_CONFIG32 = {
+var DEFAULT_CONFIG33 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 12e4,
   // 2 minutes
@@ -83530,7 +85152,7 @@ var DEFAULT_CONFIG32 = {
 };
 var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG32, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG33, ...config };
     super(eventBus, "code-intelligence", fullConfig, {
       verifyFindingTypes: ["code-pattern-detection", "impact-analysis", "dependency-mapping"]
     });
@@ -84971,7 +86593,7 @@ var Version = class _Version {
 init_types();
 
 // src/domains/security-compliance/services/scanners/scanner-types.ts
-var DEFAULT_CONFIG33 = {
+var DEFAULT_CONFIG34 = {
   defaultRuleSets: ["owasp-top-10", "cwe-sans-25"],
   maxConcurrentScans: 4,
   timeout: 3e5,
@@ -86995,7 +88617,7 @@ function createHttpClient() {
 }
 
 // src/shared/security/osv-client.ts
-var DEFAULT_CONFIG34 = {
+var DEFAULT_CONFIG35 = {
   baseUrl: "https://api.osv.dev",
   timeout: 3e4,
   enableCache: true,
@@ -87007,7 +88629,7 @@ var OSVClient = class {
   http;
   cache = /* @__PURE__ */ new Map();
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG34, ...config };
+    this.config = { ...DEFAULT_CONFIG35, ...config };
     this.http = new HttpClient();
   }
   /**
@@ -87920,7 +89542,7 @@ var SecurityScannerService = class {
   dastScanner;
   dependencyScanner;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG33, ...config };
+    this.config = { ...DEFAULT_CONFIG34, ...config };
     if ("memory" in dependencies) {
       this.memory = dependencies.memory;
       this.llmRouter = dependencies.llmRouter;
@@ -88118,7 +89740,7 @@ async function httpGet(url) {
     data
   };
 }
-var DEFAULT_CONFIG35 = {
+var DEFAULT_CONFIG36 = {
   secretPatterns: [
     /(?:api[_-]?key|apikey)['":\s]*['"=]?\s*['"]?([a-zA-Z0-9_\-]{20,})['"]?/gi,
     /(?:password|passwd|pwd)['":\s]*['"=]?\s*['"]?([^\s'"]{8,})['"]?/gi,
@@ -88999,7 +90621,7 @@ function determinePriorityBucket(vuln) {
 var SecurityAuditorService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG35, ...config };
+    this.config = { ...DEFAULT_CONFIG36, ...config };
   }
   config;
   // ==========================================================================
@@ -89619,7 +91241,7 @@ var SecurityAuditorService = class {
 init_esm_node();
 init_types();
 init_error_utils();
-var DEFAULT_CONFIG36 = {
+var DEFAULT_CONFIG37 = {
   customStandards: [],
   strictMode: false,
   includeRecommended: true,
@@ -89822,7 +91444,7 @@ var BUILT_IN_STANDARDS = [
 var ComplianceValidatorService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG36, ...config };
+    this.config = { ...DEFAULT_CONFIG37, ...config };
     this.patternAnalyzer = getCompliancePatternAnalyzer();
     this.standards = /* @__PURE__ */ new Map();
     for (const std of BUILT_IN_STANDARDS) {
@@ -90675,7 +92297,7 @@ var DQNAlgorithm = class extends BaseRLAlgorithm {
 
 // src/domains/security-compliance/coordinator.ts
 init_wrappers();
-var DEFAULT_CONFIG37 = {
+var DEFAULT_CONFIG38 = {
   maxConcurrentWorkflows: 3,
   defaultTimeout: 3e5,
   // 5 minutes
@@ -90697,7 +92319,7 @@ var DEFAULT_CONFIG37 = {
 };
 var SecurityComplianceCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG37, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG38, ...config };
     super(eventBus, "security-compliance", fullConfig, {
       verifyFindingTypes: [
         "security-vulnerability",
@@ -91825,7 +93447,7 @@ init_types();
 init_regex_safety_validator();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG38 = {
+var DEFAULT_CONFIG39 = {
   strictMode: true,
   validateExamples: true,
   maxSchemaDepth: CONTRACT_CONSTANTS.MAX_SCHEMA_DEPTH,
@@ -91848,7 +93470,7 @@ var ContractValidatorService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG38, ...config };
+    this.config = { ...DEFAULT_CONFIG39, ...config };
   }
   /**
    * ADR-051: Check if LLM analysis is available
@@ -93187,7 +94809,7 @@ Provide:
 init_types();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG39 = {
+var DEFAULT_CONFIG40 = {
   strictEnumValidation: true,
   allowOptionalToRequired: false,
   trackDeprecations: true,
@@ -93196,7 +94818,7 @@ var DEFAULT_CONFIG39 = {
 var ApiCompatibilityService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG39, ...config };
+    this.config = { ...DEFAULT_CONFIG40, ...config };
   }
   config;
   /**
@@ -93860,7 +95482,7 @@ var ContractTestingEvents = {
   ConsumerContractCreated: "contract-testing.ConsumerContractCreated",
   VerificationFailed: "contract-testing.VerificationFailed"
 };
-var DEFAULT_CONFIG40 = {
+var DEFAULT_CONFIG41 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   // 60 seconds
@@ -93880,7 +95502,7 @@ var DEFAULT_CONFIG40 = {
 };
 var ContractTestingCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG40, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG41, ...config };
     super(eventBus, "contract-testing", fullConfig, {
       verifyFindingTypes: ["contract-violation", "breaking-change", "schema-incompatibility"]
     });
@@ -94923,7 +96545,7 @@ init_types();
 init_regex_safety_validator();
 init_error_utils();
 init_safe_json();
-var DEFAULT_CONFIG41 = {
+var DEFAULT_CONFIG42 = {
   strictMode: false,
   allowAdditionalProperties: true,
   maxRecursionDepth: 10,
@@ -94932,7 +96554,7 @@ var DEFAULT_CONFIG41 = {
 var SchemaValidatorService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG41, ...config };
+    this.config = { ...DEFAULT_CONFIG42, ...config };
   }
   config;
   /**
@@ -96311,7 +97933,7 @@ init_vector_math();
 init_esm_node();
 init_types();
 init_error_utils();
-var DEFAULT_CONFIG42 = {
+var DEFAULT_CONFIG43 = {
   baselineDirectory: ".visual-tests/baselines",
   diffDirectory: ".visual-tests/diffs",
   defaultViewport: {
@@ -96339,7 +97961,7 @@ var VisualTesterService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG42, ...config };
+    this.config = { ...DEFAULT_CONFIG43, ...config };
   }
   /**
    * Set the Vibium client for browser-based operations
@@ -97359,7 +98981,7 @@ function getWCAGLevel(criterionId) {
   if (levelAA.includes(criterionId)) return "AA";
   return "AAA";
 }
-var DEFAULT_CONFIG43 = {
+var DEFAULT_CONFIG44 = {
   en301549Version: "3.2.1",
   includeEAA: true,
   defaultProductCategory: "e-commerce",
@@ -97368,7 +98990,7 @@ var DEFAULT_CONFIG43 = {
 var EUComplianceService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG43, ...config };
+    this.config = { ...DEFAULT_CONFIG44, ...config };
   }
   config;
   /**
@@ -98504,7 +100126,7 @@ function hashUrl(url) {
 }
 
 // src/domains/visual-accessibility/services/accessibility-tester.ts
-var DEFAULT_CONFIG44 = {
+var DEFAULT_CONFIG45 = {
   defaultWCAGLevel: "AA",
   includeWarnings: true,
   auditTimeout: 3e4,
@@ -98522,7 +100144,7 @@ var DEFAULT_CONFIG44 = {
 var AccessibilityTesterService = class {
   constructor(memory, config = {}, vibiumClient) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG44, ...config };
+    this.config = { ...DEFAULT_CONFIG45, ...config };
     this.rules = initializeRules();
     this.vibiumClient = vibiumClient ?? null;
     this.browserClient = config.browserClient ?? null;
@@ -98911,7 +100533,7 @@ var DEVICE_VIEWPORTS = {
     hasTouch: false
   }
 };
-var DEFAULT_CONFIG45 = {
+var DEFAULT_CONFIG46 = {
   viewports: [
     DEVICE_VIEWPORTS["iphone-14"],
     DEVICE_VIEWPORTS["ipad-mini"],
@@ -98927,7 +100549,7 @@ var DEFAULT_CONFIG45 = {
 var ResponsiveTesterService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG45, ...config };
+    this.config = { ...DEFAULT_CONFIG46, ...config };
   }
   config;
   /**
@@ -99678,7 +101300,7 @@ var A2CAlgorithm = class extends BaseRLAlgorithm {
 
 // src/domains/visual-accessibility/coordinator.ts
 init_wrappers();
-var DEFAULT_CONFIG46 = {
+var DEFAULT_CONFIG47 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 12e4,
   // 2 minutes
@@ -99698,7 +101320,7 @@ var DEFAULT_CONFIG46 = {
 };
 var VisualAccessibilityCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}, visualConfig = {}, accessibilityConfig = {}, responsiveConfig = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG46, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG47, ...config };
     super(eventBus, "visual-accessibility", fullConfig, {
       verifyFindingTypes: [
         "accessibility-violation",
@@ -101355,7 +102977,7 @@ init_safe_json();
 init_crypto_random();
 import * as net from "net";
 import { execFile } from "child_process";
-var DEFAULT_CONFIG47 = {
+var DEFAULT_CONFIG48 = {
   defaultTimeout: 6e4,
   // 60 seconds
   maxConcurrentFaults: 3,
@@ -101381,7 +103003,7 @@ var ChaosEngineerService = class _ChaosEngineerService {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG47, ...config };
+    this.config = { ...DEFAULT_CONFIG48, ...config };
     this.httpClient = new HttpClient();
     this.metricsCollector = getSystemMetricsCollector();
   }
@@ -102231,7 +103853,7 @@ init_esm_node();
 init_types();
 init_error_utils();
 init_crypto_random();
-var DEFAULT_CONFIG48 = {
+var DEFAULT_CONFIG49 = {
   defaultTimeout: 3e5,
   // 5 minutes
   maxVirtualUsers: 1e3,
@@ -102243,7 +103865,7 @@ var DEFAULT_CONFIG48 = {
 var LoadTesterService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG48, ...config };
+    this.config = { ...DEFAULT_CONFIG49, ...config };
     this.httpClient = new HttpClient();
   }
   config;
@@ -102783,7 +104405,7 @@ init_types();
 init_error_utils();
 init_crypto_random();
 init_safe_json();
-var DEFAULT_CONFIG49 = {
+var DEFAULT_CONFIG50 = {
   defaultTimeout: 6e4,
   // 60 seconds
   healthCheckInterval: 1e3,
@@ -102797,7 +104419,7 @@ var DEFAULT_CONFIG49 = {
 var PerformanceProfilerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG49, ...config };
+    this.config = { ...DEFAULT_CONFIG50, ...config };
     this.httpClient = createHttpClient();
   }
   config;
@@ -103575,7 +105197,7 @@ var PolicyGradientAlgorithm = class extends BaseRLAlgorithm {
 };
 
 // src/domains/chaos-resilience/coordinator.ts
-var DEFAULT_CONFIG50 = {
+var DEFAULT_CONFIG51 = {
   maxConcurrentWorkflows: 3,
   defaultTimeout: 3e5,
   // 5 minutes
@@ -103595,7 +105217,7 @@ var DEFAULT_CONFIG50 = {
 };
 var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG50, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG51, ...config };
     super(eventBus, "chaos-resilience", fullConfig, {
       verifyFindingTypes: [
         "chaos-experiment",
@@ -105386,7 +107008,7 @@ init_esm_node();
 init_types();
 init_error_utils();
 init_wrappers();
-var DEFAULT_CONFIG51 = {
+var DEFAULT_CONFIG52 = {
   minExperiencesForPattern: 5,
   patternConfidenceThreshold: 0.7,
   maxPatternsPerDomain: 100,
@@ -105410,7 +107032,7 @@ var LearningCoordinatorService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG51, ...config };
+    this.config = { ...DEFAULT_CONFIG52, ...config };
   }
   // ============================================================================
   // FlashAttention Integration Methods (via @ruvector/attention)
@@ -106297,7 +107919,7 @@ Provide:
 init_esm_node();
 init_types();
 init_error_utils();
-var DEFAULT_CONFIG52 = {
+var DEFAULT_CONFIG53 = {
   maxKnowledgeItems: 1e3,
   relevanceThreshold: 0.5,
   transferDecayFactor: 0.1,
@@ -106306,7 +107928,7 @@ var DEFAULT_CONFIG52 = {
 var TransferSpecialistService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG52, ...config };
+    this.config = { ...DEFAULT_CONFIG53, ...config };
   }
   config;
   // ============================================================================
@@ -106813,7 +108435,7 @@ init_esm_node();
 init_types();
 init_error_utils();
 init_crypto_random();
-var DEFAULT_CONFIG53 = {
+var DEFAULT_CONFIG54 = {
   defaultConfidenceLevel: 0.95,
   minSamplesForOptimization: 20,
   maxOptimizationIterations: 100,
@@ -106827,7 +108449,7 @@ function isSafeKey(key) {
 var MetricsOptimizerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG53, ...config };
+    this.config = { ...DEFAULT_CONFIG54, ...config };
   }
   config;
   // ============================================================================
@@ -107432,7 +109054,7 @@ var MetricsOptimizerService = class {
 init_esm_node();
 init_types();
 init_error_utils();
-var DEFAULT_CONFIG54 = {
+var DEFAULT_CONFIG55 = {
   metricsRetentionDays: 90,
   anomalyThreshold: 2.5,
   trendWindowSize: 7,
@@ -107446,7 +109068,7 @@ var DEFAULT_CONFIG54 = {
 var ProductionIntelService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG54, ...config };
+    this.config = { ...DEFAULT_CONFIG55, ...config };
   }
   config;
   // ============================================================================
@@ -108234,7 +109856,7 @@ async function verifyCrossDomainInsight(insight, confidence, consensusMixin, dom
 }
 
 // src/domains/learning-optimization/coordinator.ts
-var DEFAULT_CONFIG55 = {
+var DEFAULT_CONFIG56 = {
   maxConcurrentWorkflows: 3,
   defaultTimeout: 12e4,
   // 2 minutes
@@ -108263,7 +109885,7 @@ var DEFAULT_CONFIG55 = {
 };
 var LearningOptimizationCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG55, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG56, ...config };
     super(eventBus, "learning-optimization", fullConfig, {
       verifyFindingTypes: ["pattern-recommendation", "optimization-suggestion", "cross-domain-insight"]
     });
@@ -111792,7 +113414,7 @@ var EnterpriseIntegrationEvents = {
   MiddlewareFlowTested: "enterprise-integration.MiddlewareFlowTested",
   IntegrationValidationFailed: "enterprise-integration.IntegrationValidationFailed"
 };
-var DEFAULT_CONFIG56 = {
+var DEFAULT_CONFIG57 = {
   maxConcurrentWorkflows: 8,
   defaultTimeout: 12e4,
   // 2 minutes (enterprise systems can be slower)
@@ -111807,7 +113429,7 @@ var DEFAULT_CONFIG56 = {
 };
 var EnterpriseIntegrationCoordinator = class extends BaseDomainCoordinator {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
-    const fullConfig = { ...DEFAULT_CONFIG56, ...config };
+    const fullConfig = { ...DEFAULT_CONFIG57, ...config };
     super(eventBus, "enterprise-integration", fullConfig, {
       verifyFindingTypes: [
         "soap-fault",
@@ -112841,7 +114463,7 @@ var DOMAIN_FACTORIES = {
   "enterprise-integration": (eb, m74, c70) => createEnterpriseIntegrationPlugin(eb, m74, c70),
   "coordination": (eb, m74, c70) => createCoordinationPlugin(eb, m74, c70)
 };
-var DEFAULT_CONFIG57 = {
+var DEFAULT_CONFIG58 = {
   maxConcurrentAgents: AGENT_CONSTANTS.MAX_CONCURRENT_AGENTS,
   memoryBackend: "hybrid",
   hnswEnabled: true,
@@ -112859,7 +114481,7 @@ var QEKernelImpl = class {
   _startTime;
   _initialized = false;
   constructor(config = {}) {
-    this._config = { ...DEFAULT_CONFIG57, ...config };
+    this._config = { ...DEFAULT_CONFIG58, ...config };
     this._startTime = /* @__PURE__ */ new Date();
     this._memory = new InMemoryBackend();
     this._eventBus = new InMemoryEventBus();
@@ -112894,7 +114516,7 @@ var QEKernelImpl = class {
     if (this._config.memoryBackend === "memory") {
       const tmpDbPath = path14.join(
         __require("os").tmpdir(),
-        `aqe-test-${Date.now()}-${randomUUID7().slice(0, 12)}.db`
+        `aqe-test-${Date.now()}-${randomUUID8().slice(0, 12)}.db`
       );
       await initializeUnifiedPersistence({ dbPath: tmpDbPath });
     } else {
@@ -113075,7 +114697,7 @@ init_types();
 init_utils();
 
 // src/coordination/services/task-audit-logger.ts
-var DEFAULT_CONFIG58 = {
+var DEFAULT_CONFIG59 = {
   enableConsoleLog: true,
   maxEntries: 1e3,
   logPrefix: "[TASK]"
@@ -113084,7 +114706,7 @@ var TaskAuditLogger = class {
   entries = [];
   config;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG58, ...config };
+    this.config = { ...DEFAULT_CONFIG59, ...config };
   }
   /**
    * Log a task operation
@@ -115154,7 +116776,9 @@ var DEFAULT_ROUTING_CONFIG = {
   tierMapping: DEFAULT_TIER_MAPPING,
   costOptimization: DEFAULT_COST_OPTIMIZATION,
   fallback: DEFAULT_FALLBACK_CONFIG,
-  verbose: false
+  verbose: false,
+  enableEMACalibration: true,
+  enableAutoEscalation: true
 };
 function loadRoutingConfigFromEnv(baseConfig = DEFAULT_ROUTING_CONFIG) {
   const config = structuredClone(baseConfig);
@@ -115909,11 +117533,11 @@ var MailboxService = class {
 };
 
 // src/coordination/agent-teams/adapter.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // src/coordination/agent-teams/tracing.ts
 init_safe_json();
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 var TraceCollector = class {
   spans = /* @__PURE__ */ new Map();
   traceIndex = /* @__PURE__ */ new Map();
@@ -115931,8 +117555,8 @@ var TraceCollector = class {
    * @returns The new trace context and root span
    */
   startTrace(options) {
-    const traceId = randomUUID8();
-    const spanId = randomUUID8();
+    const traceId = randomUUID9();
+    const spanId = randomUUID9();
     const context2 = { traceId, spanId };
     const span = this.createSpan(context2, options);
     return { context: context2, span };
@@ -115948,8 +117572,8 @@ var TraceCollector = class {
    */
   startSpan(options) {
     const parentContext = options.parentContext;
-    const traceId = parentContext?.traceId ?? randomUUID8();
-    const spanId = randomUUID8();
+    const traceId = parentContext?.traceId ?? randomUUID9();
+    const spanId = randomUUID9();
     const context2 = {
       traceId,
       spanId,
@@ -116249,7 +117873,7 @@ var AgentTeamsAdapter = class {
     const senderDomain = this.agentDomains.get(from);
     const correlationId = options?.traceContext ? encodeTraceContext(options.traceContext) : options?.correlationId;
     const message = {
-      id: randomUUID9(),
+      id: randomUUID10(),
       from,
       to: to2,
       domain: options?.domain ?? senderDomain,
@@ -116275,7 +117899,7 @@ var AgentTeamsAdapter = class {
     }
     const correlationId = options?.traceContext ? encodeTraceContext(options.traceContext) : options?.correlationId;
     const message = {
-      id: randomUUID9(),
+      id: randomUUID10(),
       from,
       to: "broadcast",
       domain,
@@ -117466,6 +119090,221 @@ var DEFAULT_TIER_CONFIGS = {
   crisis: CRISIS_TIER_CONFIG
 };
 
+// src/coordination/complexity-composition/team-composer.ts
+var DEFAULT_SECURITY_KEYWORDS = [
+  "password",
+  "secret",
+  "token",
+  "crypto",
+  "auth",
+  "credential",
+  "jwt",
+  "oauth"
+];
+var DEFAULT_CONCURRENCY_KEYWORDS = [
+  "async",
+  "await",
+  "Promise",
+  "setTimeout",
+  "setInterval",
+  "Worker",
+  "mutex",
+  "lock"
+];
+var DEFAULT_CONFIG60 = {
+  securityKeywords: DEFAULT_SECURITY_KEYWORDS,
+  concurrencyKeywords: DEFAULT_CONCURRENCY_KEYWORDS,
+  enableDimensionOverrides: false
+};
+function categorize(cyclomatic, cognitive) {
+  const combined = cyclomatic + cognitive;
+  if (combined <= 8) return "trivial";
+  if (combined <= 20) return "simple";
+  if (combined <= 40) return "moderate";
+  if (combined <= 70) return "complex";
+  return "critical";
+}
+var TeamComposer = class {
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG60, ...config };
+  }
+  /**
+   * Analyze extended complexity dimensions from raw source code.
+   * All scores are clamped to [0, 1].
+   */
+  analyzeExtendedDimensions(sourceCode) {
+    const lines = sourceCode.split("\n");
+    const totalLines = Math.max(lines.length, 1);
+    const securityHits = this.countKeywordLines(lines, this.config.securityKeywords);
+    const securitySurface = clamp(securityHits / totalLines, 0, 1);
+    const concurrencyHits = this.countKeywordLines(lines, this.config.concurrencyKeywords);
+    const concurrency = clamp(concurrencyHits / totalLines, 0, 1);
+    const dataFlowHits = this.countPatternMatches(sourceCode, /\.(map|filter|reduce|flatMap|forEach)\s*\(/g);
+    const dataFlow = clamp(dataFlowHits / totalLines, 0, 1);
+    const exportCount = this.countPatternMatches(sourceCode, /^export\s/gm);
+    const declarationCount = Math.max(
+      this.countPatternMatches(sourceCode, /^(export\s+)?(const|let|var|function|class|interface|type|enum)\s/gm),
+      1
+    );
+    const apiSurface = clamp(exportCount / declarationCount, 0, 1);
+    return { securitySurface, concurrency, dataFlow, apiSurface };
+  }
+  /**
+   * Compose an optimal agent team based on complexity metrics, fleet tier,
+   * and source code analysis.
+   *
+   * @param complexityMetrics - Core complexity metrics (cyclomatic, cognitive, etc.)
+   * @param tier - Fleet tier string (used for logging/context, composition is driven by metrics)
+   * @param sourceCode - Raw source code for extended dimension analysis
+   */
+  compose(complexityMetrics, tier, sourceCode) {
+    const category = categorize(complexityMetrics.cyclomatic, complexityMetrics.cognitive);
+    const dimensions = this.analyzeExtendedDimensions(sourceCode);
+    const agents = [];
+    const testTypes = [];
+    let recommendedTier;
+    switch (category) {
+      case "trivial":
+      case "simple":
+        agents.push({
+          agentType: "qe-test-generator",
+          priority: 1,
+          reason: `${category} complexity \u2014 basic test generation sufficient`
+        });
+        testTypes.push("unit");
+        recommendedTier = "haiku";
+        break;
+      case "moderate":
+        agents.push(
+          {
+            agentType: "qe-test-generator",
+            priority: 1,
+            reason: "Moderate complexity requires thorough test generation"
+          },
+          {
+            agentType: "qe-code-intelligence",
+            priority: 2,
+            reason: "Moderate complexity benefits from code intelligence analysis"
+          }
+        );
+        testTypes.push("unit", "integration");
+        recommendedTier = "sonnet";
+        break;
+      case "complex":
+        agents.push(
+          {
+            agentType: "qe-test-generator",
+            priority: 1,
+            reason: "Complex code needs comprehensive test generation"
+          },
+          {
+            agentType: "qe-security-scanner",
+            priority: 2,
+            reason: "High complexity warrants security analysis"
+          },
+          {
+            agentType: "qe-code-intelligence",
+            priority: 2,
+            reason: "Complex code requires deep code intelligence"
+          }
+        );
+        testTypes.push("unit", "integration", "security");
+        recommendedTier = "sonnet";
+        break;
+      case "critical":
+        agents.push(
+          {
+            agentType: "qe-test-generator",
+            priority: 1,
+            reason: "Critical complexity demands full test generation"
+          },
+          {
+            agentType: "qe-security-scanner",
+            priority: 1,
+            reason: "Critical complexity mandates security scanning"
+          },
+          {
+            agentType: "qe-code-intelligence",
+            priority: 1,
+            reason: "Critical complexity requires deep analysis"
+          },
+          {
+            agentType: "qe-chaos-resilience",
+            priority: 2,
+            reason: "Critical systems need chaos/resilience testing"
+          },
+          {
+            agentType: "qe-performance",
+            priority: 2,
+            reason: "Critical complexity warrants performance analysis"
+          }
+        );
+        testTypes.push("unit", "integration", "security", "chaos", "performance");
+        recommendedTier = "opus";
+        break;
+    }
+    if (dimensions.securitySurface > 0.3) {
+      if (!agents.some((a37) => a37.agentType === "qe-security-scanner")) {
+        agents.push({
+          agentType: "qe-security-scanner",
+          priority: 2,
+          reason: `High security surface (${(dimensions.securitySurface * 100).toFixed(0)}%) \u2014 security scanning recommended`
+        });
+      }
+      if (!testTypes.includes("security")) {
+        testTypes.push("security");
+      }
+    }
+    if (dimensions.concurrency > 0.3) {
+      if (!agents.some((a37) => a37.agentType === "qe-chaos-resilience")) {
+        agents.push({
+          agentType: "qe-chaos-resilience",
+          priority: 2,
+          reason: `High concurrency (${(dimensions.concurrency * 100).toFixed(0)}%) \u2014 chaos/resilience testing recommended`
+        });
+      }
+      if (!testTypes.includes("chaos")) {
+        testTypes.push("chaos");
+      }
+    }
+    if (dimensions.apiSurface > 0.5) {
+      if (!testTypes.includes("integration")) {
+        testTypes.push("integration");
+      }
+    }
+    agents.sort((a37, b68) => a37.priority - b68.priority);
+    return {
+      agents,
+      testTypes,
+      recommendedTier,
+      complexityCategory: category
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Private Helpers
+  // --------------------------------------------------------------------------
+  countKeywordLines(lines, keywords) {
+    let count = 0;
+    for (const line of lines) {
+      for (const kw of keywords) {
+        if (line.includes(kw)) {
+          count++;
+          break;
+        }
+      }
+    }
+    return count;
+  }
+  countPatternMatches(text, pattern) {
+    const matches = text.match(pattern);
+    return matches ? matches.length : 0;
+  }
+};
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
 // src/coordination/fleet-tiers/tier-selector.ts
 var MAX_HISTORY_SIZE = 200;
 var LARGE_PR_FILE_THRESHOLD = 10;
@@ -117630,6 +119469,36 @@ var TierSelector = class {
     };
   }
   // --------------------------------------------------------------------------
+  // Complexity-Composition Integration
+  // --------------------------------------------------------------------------
+  /** Optional team composer for complexity-driven agent composition */
+  _teamComposer;
+  /**
+   * Set the team composer for complexity-driven composition.
+   */
+  setTeamComposer(composer) {
+    this._teamComposer = composer;
+  }
+  /**
+   * Select tier and optionally enrich the result with a complexity-driven
+   * team composition. This does NOT change existing selectTier() behavior --
+   * it calls selectTier() internally and then appends composition data.
+   *
+   * @param context - The tier selection context
+   * @param complexityMetrics - Optional complexity metrics for composition
+   * @param sourceCode - Optional source code for extended dimension analysis
+   * @returns Tier selection result with optional team composition
+   */
+  selectTierWithComposition(context2, complexityMetrics, sourceCode) {
+    const result = this.selectTier(context2);
+    if (!complexityMetrics || !sourceCode) {
+      return { ...result, composition: void 0 };
+    }
+    const composer = this._teamComposer ?? new TeamComposer();
+    const composition = composer.compose(complexityMetrics, result.selectedTier, sourceCode);
+    return { ...result, composition };
+  }
+  // --------------------------------------------------------------------------
   // Private Helpers
   // --------------------------------------------------------------------------
   /**
@@ -118377,7 +120246,7 @@ var DEFAULT_COMPETING_HYPOTHESES_CONFIG = {
 };
 
 // src/coordination/competing-hypotheses/hypothesis-manager.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 var HypothesisManager = class {
   investigations = /* @__PURE__ */ new Map();
   config;
@@ -118396,7 +120265,7 @@ var HypothesisManager = class {
    * @returns Immutable snapshot of the created investigation
    */
   createInvestigation(taskId, domain, description) {
-    const id = `inv-${randomUUID10().slice(0, 8)}`;
+    const id = `inv-${randomUUID11().slice(0, 8)}`;
     const now = Date.now();
     const investigation = {
       id,
@@ -118434,7 +120303,7 @@ var HypothesisManager = class {
       );
     }
     const hypothesis = {
-      id: `hyp-${randomUUID10().slice(0, 8)}`,
+      id: `hyp-${randomUUID11().slice(0, 8)}`,
       description,
       investigatorAgentId: agentId,
       strategy,
@@ -118502,7 +120371,7 @@ var HypothesisManager = class {
     const hyp = this.findHypothesis(inv, hypothesisId);
     const fullEvidence = {
       ...evidence,
-      id: `evi-${randomUUID10().slice(0, 8)}`,
+      id: `evi-${randomUUID11().slice(0, 8)}`,
       hypothesisId,
       timestamp: Date.now()
     };
@@ -118690,7 +120559,7 @@ function createHypothesisManager(config) {
 }
 
 // src/coordination/federation/federation-mailbox.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 
 // src/coordination/federation/types.ts
 var DEFAULT_FEDERATION_CONFIG = {
@@ -118851,7 +120720,7 @@ var FederationMailbox = class {
       throw new Error(`No route found for ${sourceDomain} -> ${targetDomain}`);
     }
     const message = {
-      id: randomUUID11(),
+      id: randomUUID12(),
       sourceFleetId: this.config.localFleetId,
       targetFleetId: resolvedTarget,
       sourceDomain,
@@ -119082,7 +120951,7 @@ var DEFAULT_DYNAMIC_SCALING_CONFIG = {
 };
 
 // src/coordination/dynamic-scaling/dynamic-scaler.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 init_unified_memory();
 init_error_utils();
 var DynamicScaler = class _DynamicScaler {
@@ -119229,7 +121098,7 @@ var DynamicScaler = class _DynamicScaler {
    */
   async execute(decision, executor2) {
     const event = {
-      id: `scale-${randomUUID12().slice(0, 8)}`,
+      id: `scale-${randomUUID13().slice(0, 8)}`,
       decision,
       executedAt: Date.now(),
       success: true
@@ -119516,7 +121385,7 @@ import { parse as parseYaml } from "yaml";
 init_unified_memory();
 
 // src/types/cross-phase-signals.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 var SIGNAL_TTL = {
   RISK_WEIGHTS: 90 * 24 * 60 * 60 * 1e3,
   // 90 days
@@ -119529,7 +121398,7 @@ var SIGNAL_TTL = {
 };
 function createSignalId(loopType, prefix) {
   const timestamp = Date.now();
-  const random = randomUUID13().split("-")[0];
+  const random = randomUUID14().split("-")[0];
   return `${prefix || loopType}-signal-${timestamp}-${random}`;
 }
 function calculateExpiry(ttlMs) {
@@ -122467,7 +124336,7 @@ import * as path15 from "path";
 import * as fs14 from "fs";
 
 // src/optimization/token-optimizer-service.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 
 // src/optimization/early-exit-token-optimizer.ts
 init_qe_patterns();
@@ -122857,7 +124726,7 @@ init_pattern_store();
 init_unified_memory();
 init_error_utils();
 init_safe_json();
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 var DEFAULT_COST_CONFIG = {
   costPerInputToken: 3e-3 / 1e3,
   // $3 per 1M input tokens
@@ -122896,7 +124765,7 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
   static KV_PERSIST_INTERVAL = 10;
   // every 10 operations
   constructor() {
-    this.sessionId = `session-${Date.now()}-${randomUUID14().substring(0, 8)}`;
+    this.sessionId = `session-${Date.now()}-${randomUUID15().substring(0, 8)}`;
     this.sessionStartTime = Date.now();
     this.costConfig = DEFAULT_COST_CONFIG;
   }
@@ -123186,7 +125055,7 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
     this.taskMetrics = [];
     this.agentMetrics.clear();
     this.domainMetrics.clear();
-    this.sessionId = `session-${Date.now()}-${randomUUID14().substring(0, 8)}`;
+    this.sessionId = `session-${Date.now()}-${randomUUID15().substring(0, 8)}`;
     this.sessionStartTime = Date.now();
     this.cacheHits = 0;
     this.earlyExits = 0;
@@ -123694,7 +125563,7 @@ var TokenOptimizerServiceImpl = class {
     try {
       const result = await this.patternStore.store({
         ...pattern,
-        id: `pattern-${Date.now()}-${randomUUID15().slice(0, 8)}`,
+        id: `pattern-${Date.now()}-${randomUUID16().slice(0, 8)}`,
         createdAt: /* @__PURE__ */ new Date(),
         lastUsedAt: /* @__PURE__ */ new Date()
       });
@@ -123818,7 +125687,7 @@ async function createDefaultMemoryBackend(autoInitialize2 = true) {
 }
 
 // src/init/token-bootstrap.ts
-var DEFAULT_CONFIG59 = {
+var DEFAULT_CONFIG61 = {
   enableOptimization: true,
   enablePersistence: true,
   storagePath: process.env.AQE_STORAGE_PATH ?? ".aqe",
@@ -123832,7 +125701,7 @@ async function bootstrapTokenTracking(config) {
   if (initialized) {
     return;
   }
-  const cfg = { ...DEFAULT_CONFIG59, ...config };
+  const cfg = { ...DEFAULT_CONFIG61, ...config };
   if (cfg.verbose) {
     console.log("[TokenBootstrap] Initializing token tracking...");
   }
@@ -124568,7 +126437,7 @@ function calculateNextRun(cronExpression, fromDate = /* @__PURE__ */ new Date())
 init_safe_json();
 
 // src/cli/scheduler/persistent-scheduler.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 import * as fs16 from "fs";
 import * as path16 from "path";
 import * as os2 from "os";
@@ -124938,7 +126807,7 @@ function createPersistentScheduler(config = {}) {
 }
 function generateScheduleId() {
   const timestamp = Date.now().toString(36);
-  const random = randomUUID16().slice(0, 8);
+  const random = randomUUID17().slice(0, 8);
   return `sched-${timestamp}-${random}`;
 }
 function createScheduleEntry(params) {
@@ -125072,7 +126941,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.7.6" : "3.0.0";
+  return true ? "3.7.8" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -139596,7 +141465,7 @@ import chalk22 from "chalk";
 // src/validation/swarm-skill-validator.ts
 init_error_utils();
 init_crypto_random();
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 var DEFAULT_SWARM_VALIDATION_CONFIG = {
   topology: "hierarchical",
   maxConcurrentSkills: 10,
@@ -139734,7 +141603,7 @@ var SwarmSkillValidator = class {
     for (const skill of skills) {
       for (const model of models) {
         tasks.push({
-          id: `${skill}-${model}-${Date.now()}-${randomUUID17().slice(0, 8)}`,
+          id: `${skill}-${model}-${Date.now()}-${randomUUID18().slice(0, 8)}`,
           skill,
           model,
           trustTier,
@@ -140478,7 +142347,7 @@ function createParallelEvalRunner(skillValidationLearner, config = {}, executor2
 // src/validation/validation-result-aggregator.ts
 init_safe_json();
 import { readFileSync as readFileSync42, writeFileSync as writeFileSync30, existsSync as existsSync55 } from "fs";
-var DEFAULT_CONFIG65 = {
+var DEFAULT_CONFIG67 = {
   varianceThreshold: 0.04,
   // ~20% standard deviation
   regressionThreshold: 0.1,
@@ -140490,7 +142359,7 @@ var ValidationResultAggregator = class {
   constructor(learner, manifestPath, config = {}) {
     this.learner = learner;
     this.manifestPath = manifestPath;
-    this.config = { ...DEFAULT_CONFIG65, ...config };
+    this.config = { ...DEFAULT_CONFIG67, ...config };
   }
   config;
   /**
@@ -141464,7 +143333,7 @@ var AsymmetricLearningEngine = class {
   computeConfidenceUpdate(currentConfidence, outcome, domain) {
     const { successRate, failureRate } = this.getConfigForDomain(domain);
     const delta = outcome === "success" ? successRate : -failureRate;
-    return clamp(currentConfidence + delta, 0, 1);
+    return clamp2(currentConfidence + delta, 0, 1);
   }
   /**
    * Determine whether a pattern should be quarantined based on its
@@ -141553,7 +143422,7 @@ var AsymmetricLearningEngine = class {
     return failureRate / successRate;
   }
 };
-function clamp(value, min, max) {
+function clamp2(value, min, max) {
   if (value < min) return min;
   if (value > max) return max;
   return value;
@@ -145500,7 +147369,7 @@ function createSQLiteReader(config) {
 // src/sync/readers/json-reader.ts
 var import_secure_json_parse2 = __toESM(require_secure_json_parse(), 1);
 init_error_utils();
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import * as fs25 from "fs";
 import * as path25 from "path";
 var JSONReader = class {
@@ -145684,7 +147553,7 @@ var JSONReader = class {
         if (typeof memory === "object" && memory !== null) {
           const mem = memory;
           records.push({
-            id: mem.id || `mem_${Date.now()}_${randomUUID18().slice(0, 12)}`,
+            id: mem.id || `mem_${Date.now()}_${randomUUID19().slice(0, 12)}`,
             memory_type: mem.type || "file_access",
             content: mem.content || mem.path,
             embedding: mem.embedding,
@@ -147729,7 +149598,7 @@ function printPullReport(report) {
 // src/cli/commands/hooks.ts
 init_qe_reasoning_bank();
 init_safe_json();
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 import { Command as Command16 } from "commander";
 import chalk29 from "chalk";
 import path28 from "node:path";
@@ -151386,7 +153255,7 @@ async function persistCommandExperience(opts) {
       await um.initialize();
     }
     const db = um.getDatabase();
-    const id = `cli-${Date.now()}-${randomUUID19().slice(0, 8)}`;
+    const id = `cli-${Date.now()}-${randomUUID20().slice(0, 8)}`;
     db.prepare(`
       INSERT OR REPLACE INTO captured_experiences
         (id, task, agent, domain, success, quality, duration_ms,
@@ -151596,7 +153465,7 @@ Examples:
           await um.initialize();
         }
         const db = um.getDatabase();
-        const outcomeId = `route-${Date.now()}-${randomUUID19().slice(0, 8)}`;
+        const outcomeId = `route-${Date.now()}-${randomUUID20().slice(0, 8)}`;
         db.prepare(`
             INSERT OR REPLACE INTO routing_outcomes (
               id, task_json, decision_json, used_agent,
@@ -154236,7 +156105,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command20();
-var VERSION = true ? "3.7.6" : "0.0.0-dev";
+var VERSION = true ? "3.7.8" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry2 = createCommandRegistry(context, cleanupAndExit, ensureInitialized, ensureInitializedStrict);
 registry2.registerAll(program);