agentic-qe 3.7.5 → 3.7.6

package/dist/mcp/bundle.js

@@ -20388,7 +20388,7 @@ var init_ollama_client = __esm({
        * Sleep utility for retry delays
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Get Ollama server info
@@ -23174,7 +23174,7 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
        * Sleep for specified milliseconds
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Get cost per token for current model
@@ -23500,7 +23500,7 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
        * Sleep for specified milliseconds
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Get cost per token for current model
@@ -23784,7 +23784,7 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
        * Sleep for specified milliseconds
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Get cost per token for current model
@@ -24070,7 +24070,7 @@ var init_openrouter_provider = __esm({
        * Sleep for a given duration
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Get default system prompt for security verification
@@ -24353,7 +24353,7 @@ var init_ollama_provider = __esm({
        * Sleep for a given duration
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Get default system prompt for security verification
@@ -40800,7 +40800,7 @@ Provide:
           return err(new Error(`Test file not found: ${file}`));
         }
         const { command, args } = this.buildTestCommand(file, framework);
-        return new Promise((resolve9) => {
+        return new Promise((resolve10) => {
           let stdout = "";
           let stderr = "";
           let killed = false;
@@ -40817,7 +40817,7 @@ Provide:
           const timeoutId = setTimeout(() => {
             killed = true;
             proc.kill("SIGTERM");
-            resolve9(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
+            resolve10(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
           }, timeout);
           proc.stdout?.on("data", (data) => {
             stdout += data.toString();
@@ -40831,11 +40831,11 @@ Provide:
               return;
             }
             const parseResult = this.parseTestOutput(stdout, stderr, file, framework, code);
-            resolve9(parseResult);
+            resolve10(parseResult);
           });
           proc.on("error", (error) => {
             clearTimeout(timeoutId);
-            resolve9(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
+            resolve10(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
           });
         });
       }
@@ -41430,7 +41430,7 @@ var init_flaky_detector = __esm({
         const results = /* @__PURE__ */ new Map();
         const runId = v4_default();
         const startTime = Date.now();
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const args = [...this.config.testRunnerArgs, file];
           const cwd = this.config.cwd ?? process.cwd();
           const child = spawn2(this.config.testRunner, args, {
@@ -41495,7 +41495,7 @@ var init_flaky_detector = __esm({
                   results.set(testId, records);
                 }
               }
-              resolve9(results);
+              resolve10(results);
             } catch (parseError) {
               const testId = this.generateTestId(file, "main");
               results.set(testId, [
@@ -41511,7 +41511,7 @@ var init_flaky_detector = __esm({
                   }
                 }
               ]);
-              resolve9(results);
+              resolve10(results);
             }
           });
         });
@@ -42394,7 +42394,7 @@ var init_retry_handler = __esm({
        * Spawn a test process and parse the result
        */
       spawnTestProcess(command, args, cwd) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const timeout = this.config.testTimeout;
           let stdout = "";
           let stderr = "";
@@ -42423,7 +42423,7 @@ var init_retry_handler = __esm({
               return;
             }
             const result = this.parseTestResult(code, stdout, stderr);
-            resolve9(result);
+            resolve10(result);
           });
           proc.on("error", (err4) => {
             clearTimeout(timeoutHandle);
@@ -42512,7 +42512,7 @@ var init_retry_handler = __esm({
         return Math.min(delay, maxDelay);
       }
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       async recordRetry(testId, result) {
         const history = this.retryHistory.get(testId) ?? [];
@@ -43253,7 +43253,7 @@ var init_command_executor = __esm({
        * Execute a command asynchronously (for long-running ops)
        */
       async executeAsync(command, args = []) {
-        return new Promise((resolve9) => {
+        return new Promise((resolve10) => {
           const fullArgs = this.buildArgs(command, args);
           if (this.config.debug) {
             console.log(`[agent-browser] Executing async: npx agent-browser ${fullArgs.join(" ")}`);
@@ -43273,16 +43273,16 @@ var init_command_executor = __esm({
             if (code === 0) {
               try {
                 const parsed = safeJsonParse(stdout.trim());
-                resolve9({ success: true, data: parsed });
+                resolve10({ success: true, data: parsed });
               } catch {
-                resolve9({ success: true, data: stdout.trim() });
+                resolve10({ success: true, data: stdout.trim() });
               }
             } else {
-              resolve9({ success: false, error: stderr || `Exit code: ${code}` });
+              resolve10({ success: false, error: stderr || `Exit code: ${code}` });
             }
           });
           process2.on("error", (error) => {
-            resolve9({ success: false, error: error.message });
+            resolve10({ success: false, error: error.message });
           });
         });
       }
@@ -45933,7 +45933,7 @@ var init_wait_condition_handler = __esm({
        * Delay execution
        */
       delay(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -46369,7 +46369,7 @@ var init_step_executors = __esm({
         return new URL(url, baseUrl).toString();
       }
       delay(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -46793,13 +46793,13 @@ var init_step_retry_handler = __esm({
        * Wrap promise with timeout
        */
       async withTimeout(promise, timeout, stepId) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const timer = setTimeout(() => {
             reject(new StepTimeoutError(stepId, timeout));
           }, timeout);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve9(result);
+            resolve10(result);
           }).catch((error) => {
             clearTimeout(timer);
             reject(error);
@@ -46810,7 +46810,7 @@ var init_step_retry_handler = __esm({
        * Delay execution
        */
       delay(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -47173,7 +47173,7 @@ var init_e2e_coordinator = __esm({
        * Delay execution
        */
       delay(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       /**
        * Log message if verbose mode is enabled
@@ -70885,6 +70885,10 @@ var init_semantic_analyzer = __esm({
 });
 
 // src/domains/code-intelligence/services/impact-analyzer.ts
+var impact_analyzer_exports = {};
+__export(impact_analyzer_exports, {
+  ImpactAnalyzerService: () => ImpactAnalyzerService
+});
 var DEFAULT_CONFIG38, ImpactAnalyzerService;
 var init_impact_analyzer = __esm({
   "src/domains/code-intelligence/services/impact-analyzer.ts"() {
@@ -77258,7 +77262,7 @@ var init_http_client = __esm({
        * Sleep utility for retry delays
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -92374,13 +92378,13 @@ Provide:
         }
       }
       async executeTcpProbe(probe) {
-        return new Promise((resolve9) => {
+        return new Promise((resolve10) => {
           try {
             const [host, portStr] = probe.target.split(":");
             const port = parseInt(portStr, 10);
             if (!host || isNaN(port)) {
               console.log(`TCP probe invalid target: ${probe.target} (expected host:port)`);
-              resolve9(false);
+              resolve10(false);
               return;
             }
             const timeout = probe.timeout ?? 5e3;
@@ -92388,22 +92392,22 @@ Provide:
             const timer = setTimeout(() => {
               socket.destroy();
               console.log(`TCP probe timeout: ${probe.name} -> ${probe.target}`);
-              resolve9(false);
+              resolve10(false);
             }, timeout);
             socket.connect(port, host, () => {
               clearTimeout(timer);
               socket.destroy();
-              resolve9(true);
+              resolve10(true);
             });
             socket.on("error", (err4) => {
               clearTimeout(timer);
               socket.destroy();
               console.log(`TCP probe error: ${probe.name} -> ${err4.message}`);
-              resolve9(false);
+              resolve10(false);
             });
           } catch (error) {
             console.log(`TCP probe exception: ${probe.name} -> ${toErrorMessage(error)}`);
-            resolve9(false);
+            resolve10(false);
           }
         });
       }
@@ -92442,13 +92446,13 @@ Provide:
         // Node.js checks
       ];
       async executeCommandProbe(probe) {
-        return new Promise((resolve9) => {
+        return new Promise((resolve10) => {
           const timeout = probe.timeout ?? 1e4;
           const validation = validateCommand(probe.target, _ChaosEngineerService.ALLOWED_PROBE_COMMANDS);
           if (!validation.valid) {
             console.log(`Command probe ${probe.name} blocked: ${validation.error}`);
             console.log(`Blocked patterns: ${validation.blockedPatterns?.join(", ") || "none"}`);
-            resolve9(false);
+            resolve10(false);
             return;
           }
           const sanitizedCommand = validation.sanitizedCommand || probe.target;
@@ -92458,7 +92462,7 @@ Provide:
           execFile(executable, args, { timeout }, (error, stdout, _stderr) => {
             if (error) {
               console.log(`Command probe failed: ${probe.name} -> ${error.message}`);
-              resolve9(false);
+              resolve10(false);
               return;
             }
             if (probe.expectedOutput !== void 0) {
@@ -92466,10 +92470,10 @@ Provide:
               if (!passed) {
                 console.log(`Command probe ${probe.name}: output did not contain expected value`);
               }
-              resolve9(passed);
+              resolve10(passed);
               return;
             }
-            resolve9(true);
+            resolve10(true);
           });
         });
       }
@@ -92789,7 +92793,7 @@ Provide:
         // No-op commands
       ];
       executeCommandRollback(command, timeout) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const validation = validateCommand(command, _ChaosEngineerService.ALLOWED_ROLLBACK_COMMANDS);
           if (!validation.valid) {
             reject(new Error(`Rollback command blocked: ${validation.error}`));
@@ -92803,7 +92807,7 @@ Provide:
             if (error) {
               reject(new Error(`Command rollback failed: ${error.message}. ${stderr}`));
             } else {
-              resolve9();
+              resolve10();
             }
           });
         });
@@ -92824,7 +92828,7 @@ Provide:
         await this.sleep(100);
       }
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -93382,7 +93386,7 @@ var init_load_tester = __esm({
         return result;
       }
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -93954,7 +93958,7 @@ var init_performance_profiler = __esm({
         );
       }
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -99941,7 +99945,7 @@ var init_spreading_activation = __esm({
        * Helper to sleep for a duration
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -105018,14 +105022,13 @@ var init_workflow_orchestrator = __esm({
         let current = obj;
         for (let i58 = 0; i58 < parts.length - 1; i58++) {
           const part = parts[i58];
-          if (dangerousKeys.has(part)) throw new Error(`Invalid path segment: '${part}' is a dangerous prototype key`);
           if (!Object.hasOwn(current, part)) {
-            Object.defineProperty(current, part, { value: /* @__PURE__ */ Object.create(null), writable: true, enumerable: true, configurable: true });
+            const container = /* @__PURE__ */ Object.create(null);
+            Object.defineProperty(current, part, { value: container, writable: true, enumerable: true, configurable: true });
           }
           current = current[part];
         }
         const finalKey = parts[parts.length - 1];
-        if (dangerousKeys.has(finalKey)) throw new Error(`Invalid final key: '${finalKey}' is a dangerous prototype key`);
         Object.defineProperty(current, finalKey, { value, writable: true, enumerable: true, configurable: true });
       }
       // ============================================================================
@@ -105264,7 +105267,7 @@ var init_workflow_orchestrator = __esm({
       // Private Methods - Utilities
       // ============================================================================
       delay(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -115075,7 +115078,7 @@ function startWorkStealingTimer(config, doStealing) {
         clearInterval(timer);
         return;
       }
-      await new Promise((resolve9) => setTimeout(resolve9, backoffMs));
+      await new Promise((resolve10) => setTimeout(resolve10, backoffMs));
     }
   }, config.workStealing.checkInterval);
   return timer;
@@ -134566,13 +134569,13 @@ var init_trajectory_bridge = __esm({
        */
       async persistTrajectory(trajectory) {
         try {
-          const { join: join28 } = await import("path");
+          const { join: join29 } = await import("path");
           const { existsSync: existsSync20, mkdirSync: mkdirSync6 } = await import("fs");
           const { createRequire: createRequire12 } = await import("module");
           const require3 = createRequire12(import.meta.url);
           const { openDatabase: openDatabase2 } = require3("../../shared/safe-db.js");
-          const dbPath = join28(this.options.projectRoot, ".agentic-qe", "trajectories.db");
-          const dir = join28(this.options.projectRoot, ".agentic-qe");
+          const dbPath = join29(this.options.projectRoot, ".agentic-qe", "trajectories.db");
+          const dir = join29(this.options.projectRoot, ".agentic-qe");
           if (!existsSync20(dir)) {
             mkdirSync6(dir, { recursive: true });
           }
@@ -134939,7 +134942,7 @@ var init_pretrain_bridge = __esm({
         try {
           const glob = await import("fast-glob");
           const { existsSync: existsSync20, readFileSync: readFileSync17 } = await import("fs");
-          const { join: join28 } = await import("path");
+          const { join: join29 } = await import("path");
           const patterns = depth === "shallow" ? ["*.ts", "*.js", "*.json"] : depth === "medium" ? ["**/*.ts", "**/*.js", "**/*.json", "**/*.py"] : ["**/*"];
           const ignore = ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
           const files = await glob.default(patterns, {
@@ -134956,7 +134959,7 @@ var init_pretrain_bridge = __esm({
             if (file.endsWith(".go")) languages.add("go");
             if (file.endsWith(".rs")) languages.add("rust");
           }
-          const packageJsonPath = join28(targetPath, "package.json");
+          const packageJsonPath = join29(targetPath, "package.json");
           if (existsSync20(packageJsonPath)) {
             try {
               const pkg2 = safeJsonParse(readFileSync17(packageJsonPath, "utf-8"));
@@ -139082,7 +139085,7 @@ Ensure prime-radiant-advanced-wasm is installed.`
        * Sleep for a specified duration.
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       // ===========================================================================
       // ADR-052 A4.3: Fallback Mode Management
@@ -140864,7 +140867,7 @@ var init_aqe_learning_engine = __esm({
         try {
           const glob = await import("fast-glob");
           const { existsSync: existsSync20, readFileSync: readFileSync17 } = await import("fs");
-          const { join: join28 } = await import("path");
+          const { join: join29 } = await import("path");
           const patterns = depth === "shallow" ? ["*.ts", "*.js", "*.json"] : depth === "medium" ? ["**/*.ts", "**/*.js", "**/*.json", "**/*.py"] : ["**/*"];
           const ignore = ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
           const files = await glob.default(patterns, {
@@ -140881,7 +140884,7 @@ var init_aqe_learning_engine = __esm({
             if (file.endsWith(".go")) languages.add("go");
             if (file.endsWith(".rs")) languages.add("rust");
           }
-          const packageJsonPath = join28(targetPath, "package.json");
+          const packageJsonPath = join29(targetPath, "package.json");
           if (existsSync20(packageJsonPath)) {
             try {
               const pkg2 = safeJsonParse(readFileSync17(packageJsonPath, "utf-8"));
@@ -144467,11 +144470,11 @@ async function parseJSONCoverage(jsonPath, projectRoot) {
 }
 async function parseCoverage(coveragePath, projectRoot) {
   const ext = path21.extname(coveragePath).toLowerCase();
-  const basename5 = path21.basename(coveragePath).toLowerCase();
-  if (ext === ".json" || basename5.includes("coverage-final")) {
+  const basename7 = path21.basename(coveragePath).toLowerCase();
+  if (ext === ".json" || basename7.includes("coverage-final")) {
     return parseJSONCoverage(coveragePath, projectRoot);
   }
-  if (basename5 === "lcov.info" || ext === ".info" || basename5.includes("lcov")) {
+  if (basename7 === "lcov.info" || ext === ".info" || basename7.includes("lcov")) {
     return parseLCOV(coveragePath, projectRoot);
   }
   const content = await fs22.readFile(coveragePath, "utf-8");
@@ -151596,31 +151599,16 @@ var init_goap_planner = __esm({
         let current = state2;
         for (let i58 = 0; i58 < parts.length - 1; i58++) {
           const part = parts[i58];
-          if (DANGEROUS_PROPS.has(part)) {
-            console.warn(`[GOAPPlanner] Blocked prototype pollution: ${part}`);
-            return;
-          }
           if (!Object.hasOwn(current, part)) {
-            Object.defineProperty(current, part, {
-              value: /* @__PURE__ */ Object.create(null),
-              writable: true,
-              enumerable: true,
-              configurable: true
-            });
+            const container = /* @__PURE__ */ Object.create(null);
+            Object.defineProperty(current, part, { value: container, writable: true, enumerable: true, configurable: true });
           }
-          current = current[part];
+          const desc = Object.getOwnPropertyDescriptor(current, part);
+          if (!desc) return;
+          current = desc.value;
         }
         const finalKey = parts[parts.length - 1];
-        if (DANGEROUS_PROPS.has(finalKey)) {
-          console.warn(`[GOAPPlanner] Blocked prototype pollution: ${finalKey}`);
-          return;
-        }
-        Object.defineProperty(current, finalKey, {
-          value,
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
+        Object.defineProperty(current, finalKey, { value, writable: true, enumerable: true, configurable: true });
       }
       /**
        * Create hash of state for deduplication
@@ -152663,31 +152651,16 @@ Expected effects:`;
         let current = state2;
         for (let i58 = 0; i58 < parts.length - 1; i58++) {
           const part = parts[i58];
-          if (dangerousProps.has(part)) {
-            console.warn(`[PlanExecutor] Blocked prototype pollution: ${part}`);
-            return;
-          }
           if (!Object.hasOwn(current, part)) {
-            Object.defineProperty(current, part, {
-              value: /* @__PURE__ */ Object.create(null),
-              writable: true,
-              enumerable: true,
-              configurable: true
-            });
+            const container = /* @__PURE__ */ Object.create(null);
+            Object.defineProperty(current, part, { value: container, writable: true, enumerable: true, configurable: true });
           }
-          current = current[part];
+          const desc = Object.getOwnPropertyDescriptor(current, part);
+          if (!desc) return;
+          current = desc.value;
         }
         const finalKey = parts[parts.length - 1];
-        if (dangerousProps.has(finalKey)) {
-          console.warn(`[PlanExecutor] Blocked prototype pollution: ${finalKey}`);
-          return;
-        }
-        Object.defineProperty(current, finalKey, {
-          value,
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
+        Object.defineProperty(current, finalKey, { value, writable: true, enumerable: true, configurable: true });
       }
       /**
        * Deep clone world state.
@@ -152713,7 +152686,7 @@ Expected effects:`;
        * Delay helper for exponential backoff
        */
       delay(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
       // ==========================================================================
       // Cleanup
@@ -152745,7 +152718,7 @@ Expected effects:`;
         this.executionDelay = options?.executionDelay ?? 100;
       }
       async spawn(agentType, task) {
-        await new Promise((resolve9) => setTimeout(resolve9, this.executionDelay));
+        await new Promise((resolve10) => setTimeout(resolve10, this.executionDelay));
         const success = secureRandom() < this.successRate;
         const agentId = `mock-agent-${randomUUID23().slice(0, 8)}`;
         if (success) {
@@ -156712,6 +156685,3568 @@ var init_analyze2 = __esm({
   }
 });
 
+// src/test-scheduling/interfaces.ts
+var DEFAULT_TEST_PHASES;
+var init_interfaces7 = __esm({
+  "src/test-scheduling/interfaces.ts"() {
+    "use strict";
+    DEFAULT_TEST_PHASES = [
+      {
+        id: "unit",
+        name: "Unit Tests",
+        testTypes: ["unit"],
+        testPatterns: ["**/*.test.ts", "**/*.spec.ts", "!**/*.integration.*", "!**/*.e2e.*"],
+        thresholds: { minPassRate: 0.99, maxFlakyRatio: 0.01, minCoverage: 0.8 },
+        parallelism: 8,
+        timeoutMs: 6e4,
+        failFast: true
+      },
+      {
+        id: "integration",
+        name: "Integration Tests",
+        testTypes: ["integration", "contract"],
+        testPatterns: ["**/*.integration.test.ts", "**/*.integration.spec.ts"],
+        thresholds: { minPassRate: 0.95, maxFlakyRatio: 0.05, minCoverage: 0.7 },
+        parallelism: 4,
+        timeoutMs: 3e5,
+        failFast: false
+      },
+      {
+        id: "e2e",
+        name: "E2E Tests",
+        testTypes: ["e2e", "visual"],
+        testPatterns: ["**/*.e2e.test.ts", "**/*.e2e.spec.ts"],
+        thresholds: { minPassRate: 0.9, maxFlakyRatio: 0.1, minCoverage: 0.5 },
+        parallelism: 2,
+        timeoutMs: 6e5,
+        failFast: false
+      }
+    ];
+  }
+});
+
+// src/test-scheduling/phase-scheduler.ts
+function createPhaseScheduler(executor2, config) {
+  return new PhaseScheduler(executor2, {
+    phases: DEFAULT_TEST_PHASES,
+    failFast: true,
+    retryFailedPhases: false,
+    maxRetries: 1,
+    ...config
+  });
+}
+function checkQualityThresholds(result, thresholds) {
+  return result.passRate >= thresholds.minPassRate && result.flakyRatio <= thresholds.maxFlakyRatio && result.coverage >= thresholds.minCoverage;
+}
+var PhaseScheduler;
+var init_phase_scheduler = __esm({
+  "src/test-scheduling/phase-scheduler.ts"() {
+    "use strict";
+    init_interfaces7();
+    PhaseScheduler = class {
+      constructor(executor2, config = {
+        phases: DEFAULT_TEST_PHASES,
+        failFast: true,
+        retryFailedPhases: false,
+        maxRetries: 1
+      }) {
+        this.executor = executor2;
+        this.config = config;
+      }
+      state = "idle";
+      currentPhaseIndex = 0;
+      results = [];
+      startTime;
+      endTime;
+      abortController;
+      // --------------------------------------------------------------------------
+      // Public API
+      // --------------------------------------------------------------------------
+      /**
+       * Run all test phases sequentially
+       */
+      async run() {
+        if (this.state === "running") {
+          throw new Error("Scheduler is already running");
+        }
+        this.state = "running";
+        this.currentPhaseIndex = 0;
+        this.results = [];
+        this.startTime = /* @__PURE__ */ new Date();
+        this.abortController = new AbortController();
+        try {
+          for (const phase of this.config.phases) {
+            if (this.state === "paused") {
+              await this.waitForResume();
+            }
+            if (this.abortController.signal.aborted) {
+              break;
+            }
+            const result = await this.executePhaseWithRetry(phase);
+            this.results.push(result);
+            this.currentPhaseIndex++;
+            this.config.onPhaseComplete?.(result);
+            if (!result.success && this.config.failFast) {
+              this.state = "failed";
+              break;
+            }
+          }
+          this.endTime = /* @__PURE__ */ new Date();
+          this.state = this.results.every((r54) => r54.success) ? "completed" : "failed";
+          this.config.onAllComplete?.(this.results);
+          return this.results;
+        } catch (error) {
+          this.state = "failed";
+          this.endTime = /* @__PURE__ */ new Date();
+          throw error;
+        }
+      }
+      /**
+       * Run a specific phase by ID
+       */
+      async runPhase(phaseId) {
+        const phase = this.config.phases.find((p74) => p74.id === phaseId);
+        if (!phase) {
+          throw new Error(`Phase not found: ${phaseId}`);
+        }
+        return this.executePhaseWithRetry(phase);
+      }
+      /**
+       * Pause execution after current phase completes
+       */
+      pause() {
+        if (this.state === "running") {
+          this.state = "paused";
+        }
+      }
+      /**
+       * Resume paused execution
+       */
+      resume() {
+        if (this.state === "paused") {
+          this.state = "running";
+        }
+      }
+      /**
+       * Abort execution immediately
+       */
+      async abort() {
+        this.abortController?.abort();
+        await this.executor.abort();
+        this.state = "idle";
+      }
+      /**
+       * Get current scheduler stats
+       */
+      getStats() {
+        const durationMs = this.startTime && this.endTime ? this.endTime.getTime() - this.startTime.getTime() : this.startTime ? Date.now() - this.startTime.getTime() : void 0;
+        return {
+          state: this.state,
+          currentPhaseIndex: this.currentPhaseIndex,
+          totalPhases: this.config.phases.length,
+          completedPhases: this.results.filter((r54) => r54.success).length,
+          failedPhases: this.results.filter((r54) => !r54.success).length,
+          results: [...this.results],
+          startTime: this.startTime,
+          endTime: this.endTime,
+          durationMs
+        };
+      }
+      /**
+       * Check if scheduler is ready to run
+       */
+      async isReady() {
+        return this.executor.isReady();
+      }
+      // --------------------------------------------------------------------------
+      // Private Methods
+      // --------------------------------------------------------------------------
+      async executePhaseWithRetry(phase) {
+        let lastResult;
+        const maxAttempts = this.config.retryFailedPhases ? this.config.maxRetries : 1;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+          try {
+            lastResult = await this.executor.execute(phase);
+            if (lastResult.success || !this.config.retryFailedPhases) {
+              return lastResult;
+            }
+          } catch (error) {
+            this.config.onError?.(error, phase);
+            if (attempt === maxAttempts) {
+              return this.createErrorResult(phase, error);
+            }
+          }
+        }
+        return lastResult;
+      }
+      createErrorResult(phase, error) {
+        return {
+          phaseId: phase.id,
+          phaseName: phase.name,
+          success: false,
+          passRate: 0,
+          flakyRatio: 0,
+          coverage: 0,
+          durationMs: 0,
+          totalTests: 0,
+          passed: 0,
+          failed: 0,
+          skipped: 0,
+          testResults: [],
+          flakyTests: [],
+          error: error.message
+        };
+      }
+      waitForResume() {
+        return new Promise((resolve10) => {
+          const check = () => {
+            if (this.state !== "paused") {
+              resolve10();
+            } else {
+              setTimeout(check, 100);
+            }
+          };
+          check();
+        });
+      }
+    };
+  }
+});
+
+// src/test-scheduling/executors/vitest-executor.ts
+import { spawn as spawn5 } from "child_process";
+function createVitestExecutor(config) {
+  return new VitestPhaseExecutor(config);
+}
+var VitestPhaseExecutor;
+var init_vitest_executor = __esm({
+  "src/test-scheduling/executors/vitest-executor.ts"() {
+    "use strict";
+    init_safe_json();
+    VitestPhaseExecutor = class {
+      constructor(config = {}) {
+        this.config = config;
+      }
+      currentProcess = null;
+      isAborted = false;
+      // --------------------------------------------------------------------------
+      // PhaseExecutor Interface
+      // --------------------------------------------------------------------------
+      async execute(phase, testFiles) {
+        this.isAborted = false;
+        const startTime = Date.now();
+        try {
+          const args = this.buildArgs(phase, testFiles);
+          const result = await this.runVitest(args, phase.timeoutMs);
+          const endTime = Date.now();
+          return this.parseResult(phase, result, endTime - startTime);
+        } catch (error) {
+          const endTime = Date.now();
+          return this.createErrorResult(phase, error, endTime - startTime);
+        }
+      }
+      async isReady() {
+        try {
+          const result = await this.runCommand("npx", ["vitest", "--version"], 5e3);
+          return result.exitCode === 0;
+        } catch {
+          return false;
+        }
+      }
+      getName() {
+        return "vitest-executor";
+      }
+      async abort() {
+        this.isAborted = true;
+        if (this.currentProcess) {
+          this.currentProcess.kill("SIGTERM");
+          this.currentProcess = null;
+        }
+      }
+      // --------------------------------------------------------------------------
+      // Private Methods
+      // --------------------------------------------------------------------------
+      buildArgs(phase, testFiles) {
+        const args = ["vitest", "run", "--reporter=json"];
+        if (testFiles && testFiles.length > 0) {
+          args.push(...testFiles);
+        } else {
+          for (const pattern of phase.testPatterns) {
+            if (pattern.startsWith("!")) {
+              args.push("--exclude", pattern.slice(1));
+            } else {
+              args.push(pattern);
+            }
+          }
+        }
+        if (phase.parallelism > 0) {
+          args.push("--pool", "threads");
+          args.push("--poolOptions.threads.maxThreads", String(phase.parallelism));
+        }
+        if (phase.failFast) {
+          args.push("--bail", "1");
+        }
+        args.push("--coverage");
+        args.push("--coverage.reporter", this.config.coverageReporter || "json");
+        if (this.config.coverageDir) {
+          args.push("--coverage.reportsDirectory", this.config.coverageDir);
+        }
+        if (this.config.extraArgs) {
+          args.push(...this.config.extraArgs);
+        }
+        return args;
+      }
+      async runVitest(args, timeoutMs) {
+        const { stdout, exitCode } = await this.runCommand(
+          this.config.vitestPath || "npx",
+          args,
+          timeoutMs
+        );
+        try {
+          const jsonStart = stdout.indexOf("{");
+          const jsonEnd = stdout.lastIndexOf("}");
+          if (jsonStart === -1 || jsonEnd === -1) {
+            throw new Error("No JSON output from Vitest");
+          }
+          const jsonStr = stdout.slice(jsonStart, jsonEnd + 1);
+          return safeJsonParse(jsonStr);
+        } catch (parseError) {
+          return {
+            numTotalTestSuites: 0,
+            numPassedTestSuites: 0,
+            numFailedTestSuites: 0,
+            numTotalTests: 0,
+            numPassedTests: 0,
+            numFailedTests: 0,
+            numPendingTests: 0,
+            success: exitCode === 0,
+            startTime: Date.now(),
+            testResults: []
+          };
+        }
+      }
+      runCommand(command, args, timeoutMs) {
+        return new Promise((resolve10, reject) => {
+          let stdout = "";
+          let stderr = "";
+          const executable = process.platform === "win32" && command === "npx" ? "npx.cmd" : command;
+          this.currentProcess = spawn5(executable, args, {
+            cwd: this.config.cwd || process.cwd(),
+            env: { ...process.env, ...this.config.env },
+            shell: false
+          });
+          const timeout = setTimeout(() => {
+            this.currentProcess?.kill("SIGTERM");
+            reject(new Error(`Test execution timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          this.currentProcess.stdout?.on("data", (data) => {
+            stdout += data.toString();
+          });
+          this.currentProcess.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+          this.currentProcess.on("close", (code) => {
+            clearTimeout(timeout);
+            this.currentProcess = null;
+            if (this.isAborted) {
+              reject(new Error("Test execution aborted"));
+            } else {
+              resolve10({ stdout, stderr, exitCode: code ?? 1 });
+            }
+          });
+          this.currentProcess.on("error", (error) => {
+            clearTimeout(timeout);
+            this.currentProcess = null;
+            reject(error);
+          });
+        });
+      }
+      async parseResult(phase, vitestResult, durationMs) {
+        const testResults = [];
+        for (const file of vitestResult.testResults) {
+          for (const assertion of file.assertionResults) {
+            const testResult = {
+              file: file.name,
+              name: assertion.title,
+              suite: assertion.ancestorTitles.join(" > "),
+              passed: assertion.status === "passed",
+              durationMs: assertion.duration || 0,
+              // NOTE: Vitest JSON reporter doesn't include retry data.
+              // Flakiness is detected historically via FlakyTracker.
+              retries: 0,
+              error: assertion.failureMessages.join("\n") || void 0
+            };
+            testResults.push(testResult);
+          }
+        }
+        const tracker = this.config.flakyTracker;
+        if (tracker) {
+          tracker.recordResults(testResults);
+        }
+        const totalTests = vitestResult.numTotalTests;
+        const passed = vitestResult.numPassedTests;
+        const failed = vitestResult.numFailedTests;
+        const skipped = vitestResult.numPendingTests;
+        const passRate = totalTests > 0 ? passed / totalTests : 0;
+        let flakyTests = [];
+        let flakyRatio = 0;
+        if (tracker) {
+          const analysis = tracker.analyze();
+          flakyTests = analysis.flakyTests.map((r54) => r54.testId);
+          const runTestIds = new Set(
+            testResults.map((r54) => `${r54.file}:${r54.suite}:${r54.name}`)
+          );
+          const flakyInRun = flakyTests.filter((id) => runTestIds.has(id));
+          flakyRatio = totalTests > 0 ? flakyInRun.length / totalTests : 0;
+        }
+        const coverage = await this.getCoverageFromReport();
+        const success = passRate >= phase.thresholds.minPassRate && flakyRatio <= phase.thresholds.maxFlakyRatio && coverage >= phase.thresholds.minCoverage;
+        return {
+          phaseId: phase.id,
+          phaseName: phase.name,
+          success,
+          passRate,
+          flakyRatio,
+          coverage,
+          durationMs,
+          totalTests,
+          passed,
+          failed,
+          skipped,
+          testResults,
+          flakyTests
+        };
+      }
+      async getCoverageFromReport() {
+        try {
+          const fs26 = await import("fs/promises");
+          const path26 = await import("path");
+          const coverageDir = this.config.coverageDir || "coverage";
+          const coverageFile = path26.join(
+            this.config.cwd || process.cwd(),
+            coverageDir,
+            "coverage-summary.json"
+          );
+          const content = await fs26.readFile(coverageFile, "utf-8");
+          const coverage = safeJsonParse(content);
+          return (coverage.total?.lines?.pct ?? 0) / 100;
+        } catch {
+          return 0;
+        }
+      }
+      createErrorResult(phase, error, durationMs) {
+        return {
+          phaseId: phase.id,
+          phaseName: phase.name,
+          success: false,
+          passRate: 0,
+          flakyRatio: 0,
+          coverage: 0,
+          durationMs,
+          totalTests: 0,
+          passed: 0,
+          failed: 0,
+          skipped: 0,
+          testResults: [],
+          flakyTests: [],
+          error: error.message
+        };
+      }
+    };
+  }
+});
+
+// src/test-scheduling/git-aware/test-selector.ts
+import { spawn as spawn6 } from "child_process";
+import { resolve as resolve7, dirname as dirname7, basename as basename4 } from "path";
+function createTestSelector(config) {
+  return new GitAwareTestSelector(config);
+}
+async function getAffectedTests(impactAnalyzer, baseRef, cwd) {
+  const selector = createTestSelector({ impactAnalyzer, baseRef, cwd });
+  const result = await selector.selectAffectedTests();
+  if (result.runAllTests) {
+    return [];
+  }
+  return result.selectedTests;
+}
+var DEFAULT_MAPPING_RULES, GitAwareTestSelector;
+var init_test_selector = __esm({
+  "src/test-scheduling/git-aware/test-selector.ts"() {
+    "use strict";
+    DEFAULT_MAPPING_RULES = [
+      // src/foo/bar.ts -> tests/unit/foo/bar.test.ts
+      {
+        sourcePattern: /^src\/(.+)\.ts$/,
+        toTestPaths: (match, _sourceFile) => {
+          const path26 = match[1];
+          return [
+            `tests/unit/${path26}.test.ts`,
+            `tests/unit/${path26}.spec.ts`,
+            `tests/${path26}.test.ts`,
+            `tests/${path26}.spec.ts`,
+            `src/${path26}.test.ts`,
+            `src/${path26}.spec.ts`
+          ];
+        }
+      },
+      // src/foo/bar/index.ts -> tests/unit/foo/bar.test.ts
+      {
+        sourcePattern: /^src\/(.+)\/index\.ts$/,
+        toTestPaths: (match, _sourceFile) => {
+          const path26 = match[1];
+          return [
+            `tests/unit/${path26}.test.ts`,
+            `tests/unit/${path26}/index.test.ts`,
+            `tests/unit/${path26}.spec.ts`
+          ];
+        }
+      },
+      // Any changed test file selects itself
+      {
+        sourcePattern: /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+        toTestPaths: (_match, sourceFile) => [sourceFile]
+      },
+      // Config files run all tests
+      {
+        sourcePattern: /^(vitest\.config|jest\.config|tsconfig|package\.json)/,
+        toTestPaths: () => ["**/*.test.ts", "**/*.spec.ts"]
+      }
+    ];
+    GitAwareTestSelector = class {
+      constructor(config) {
+        this.config = config;
+        if (!config.impactAnalyzer) {
+          throw new Error(
+            "GitAwareTestSelector requires impactAnalyzer. Use ImpactAnalyzerService from code-intelligence domain. NO FALLBACK TO PATTERN MATCHING - use real dependency analysis."
+          );
+        }
+        this.cwd = config.cwd || process.cwd();
+        this.baseRef = config.baseRef || "HEAD~1";
+        this.mappingRules = config.mappingRules || DEFAULT_MAPPING_RULES;
+        this.impactAnalyzer = config.impactAnalyzer;
+      }
+      cwd;
+      baseRef;
+      mappingRules;
+      impactAnalyzer;
+      // --------------------------------------------------------------------------
+      // Public API
+      // --------------------------------------------------------------------------
+      /**
+       * Get tests affected by changes since base ref
+       */
+      async selectAffectedTests() {
+        try {
+          const changedFiles = await this.getChangedFiles();
+          if (changedFiles.length === 0) {
+            return {
+              changedFiles: [],
+              selectedTests: [],
+              mappings: [],
+              runAllTests: false
+            };
+          }
+          const { selectedTests, mappings, runAllTests, runAllReason } = await this.mapChangesToTests(changedFiles);
+          return {
+            changedFiles,
+            selectedTests: [...new Set(selectedTests)],
+            // Dedupe
+            mappings,
+            runAllTests,
+            runAllReason
+          };
+        } catch (error) {
+          return {
+            changedFiles: [],
+            selectedTests: [],
+            mappings: [],
+            runAllTests: true,
+            runAllReason: `Git error: ${error.message}`
+          };
+        }
+      }
+      /**
+       * Get tests for a specific list of changed files
+       */
+      async selectTestsForFiles(files) {
+        const changedFiles = files.map((path26) => ({
+          path: path26,
+          changeType: "modified"
+        }));
+        const { selectedTests, mappings, runAllTests, runAllReason } = await this.mapChangesToTests(changedFiles);
+        return {
+          changedFiles,
+          selectedTests: [...new Set(selectedTests)],
+          mappings,
+          runAllTests,
+          runAllReason
+        };
+      }
+      /**
+       * Get changed files since base ref
+       */
+      async getChangedFiles() {
+        const output = await this.git([
+          "diff",
+          "--name-status",
+          this.baseRef,
+          "HEAD"
+        ]);
+        const lines = output.trim().split("\n").filter(Boolean);
+        const changedFiles = [];
+        for (const line of lines) {
+          const [status, ...pathParts] = line.split("	");
+          const path26 = pathParts.join("	");
+          let changeType;
+          let previousPath;
+          switch (status[0]) {
+            case "A":
+              changeType = "added";
+              break;
+            case "M":
+              changeType = "modified";
+              break;
+            case "D":
+              changeType = "deleted";
+              break;
+            case "R":
+              changeType = "renamed";
+              previousPath = path26;
+              break;
+            default:
+              changeType = "modified";
+          }
+          changedFiles.push({
+            path: changeType === "renamed" ? pathParts[1] || path26 : path26,
+            changeType,
+            previousPath
+          });
+        }
+        return changedFiles;
+      }
+      /**
+       * Get the merge base between current branch and main
+       */
+      async getMergeBase(targetBranch = "main") {
+        try {
+          const output = await this.git(["merge-base", "HEAD", targetBranch]);
+          return output.trim();
+        } catch {
+          const output = await this.git(["merge-base", "HEAD", "master"]);
+          return output.trim();
+        }
+      }
+      // --------------------------------------------------------------------------
+      // Private Methods
+      // --------------------------------------------------------------------------
+      async mapChangesToTests(changedFiles) {
+        const selectedTests = [];
+        const mappings = [];
+        let runAllTests = false;
+        let runAllReason;
+        for (const file of changedFiles) {
+          if (this.isConfigFile(file.path)) {
+            return {
+              selectedTests: [],
+              mappings: [],
+              runAllTests: true,
+              runAllReason: `Config file changed: ${file.path}`
+            };
+          }
+        }
+        const changedPaths = changedFiles.filter((f74) => f74.changeType !== "deleted" || this.config.includeDeletedFileTests).map((f74) => f74.path);
+        if (changedPaths.length === 0) {
+          return { selectedTests: [], mappings: [], runAllTests: false };
+        }
+        const impactResult = await this.impactAnalyzer.getImpactedTests(changedPaths);
+        if (!impactResult.success) {
+          const failureResult = impactResult;
+          const errorMsg = failureResult.error instanceof Error ? failureResult.error.message : String(failureResult.error);
+          return {
+            selectedTests: [],
+            mappings: [],
+            runAllTests: true,
+            runAllReason: `Impact analysis failed: ${errorMsg}`
+          };
+        }
+        if (impactResult.value.length === 0) {
+          return { selectedTests: [], mappings: [], runAllTests: false };
+        }
+        selectedTests.push(...impactResult.value);
+        for (const changedFile of changedFiles) {
+          if (changedFile.changeType === "deleted" && !this.config.includeDeletedFileTests) {
+            continue;
+          }
+          const relatedTests = impactResult.value.filter(
+            (test) => test.includes(basename4(changedFile.path, ".ts").replace(/\.(tsx?|jsx?)$/, ""))
+          );
+          if (relatedTests.length > 0) {
+            mappings.push({
+              sourceFile: changedFile.path,
+              testFiles: relatedTests,
+              confidence: 0.95
+              // High confidence for graph-based analysis
+            });
+          }
+        }
+        return { selectedTests, mappings, runAllTests, runAllReason };
+      }
+      /**
+       * Check if a file is a config file that should trigger full test run
+       */
+      isConfigFile(path26) {
+        return /^(vitest\.config|jest\.config|tsconfig|package\.json)/.test(path26);
+      }
+      async findTestsHeuristically(sourcePath) {
+        const baseName = basename4(sourcePath, ".ts").replace(/\.(tsx?|jsx?)$/, "");
+        const dir = dirname7(sourcePath);
+        const candidates = [
+          `${dir}/${baseName}.test.ts`,
+          `${dir}/${baseName}.spec.ts`,
+          `${dir}/__tests__/${baseName}.test.ts`,
+          `tests/${dir}/${baseName}.test.ts`,
+          `tests/unit/${dir.replace("src/", "")}/${baseName}.test.ts`
+        ];
+        return this.filterExistingFiles(candidates);
+      }
+      async filterExistingFiles(files) {
+        const fs26 = await import("fs/promises");
+        const existing = [];
+        for (const file of files) {
+          try {
+            const fullPath = resolve7(this.cwd, file);
+            await fs26.access(fullPath);
+            existing.push(file);
+          } catch (error) {
+            console.debug("[TestSelector] File access check failed:", error instanceof Error ? error.message : error);
+          }
+        }
+        return existing;
+      }
+      git(args) {
+        return new Promise((resolve10, reject) => {
+          let stdout = "";
+          let stderr = "";
+          const proc = spawn6("git", args, { cwd: this.cwd });
+          proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+          });
+          proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+          proc.on("close", (code) => {
+            if (code === 0) {
+              resolve10(stdout);
+            } else {
+              reject(new Error(`git ${args.join(" ")} failed: ${stderr}`));
+            }
+          });
+          proc.on("error", reject);
+        });
+      }
+    };
+  }
+});
+
+// src/test-scheduling/flaky-tracking/flaky-tracker.ts
+function createFlakyTracker(config) {
+  return new FlakyTestTracker(config);
+}
+async function loadFlakyTracker(historyPath, config) {
+  const tracker = createFlakyTracker({ ...config, historyPath });
+  try {
+    const fs26 = await import("fs/promises");
+    const content = await fs26.readFile(historyPath, "utf-8");
+    const records = safeJsonParse(content);
+    tracker.importHistory(records);
+  } catch (error) {
+    console.debug("[FlakyTracker] History load failed, starting fresh:", error instanceof Error ? error.message : error);
+  }
+  return tracker;
+}
+async function saveFlakyTracker(tracker, historyPath) {
+  const fs26 = await import("fs/promises");
+  const history = tracker.exportHistory();
+  await fs26.writeFile(historyPath, JSON.stringify(history, null, 2));
+}
+var DEFAULT_CONFIG70, FlakyTestTracker;
+var init_flaky_tracker = __esm({
+  "src/test-scheduling/flaky-tracking/flaky-tracker.ts"() {
+    "use strict";
+    init_safe_json();
+    DEFAULT_CONFIG70 = {
+      minRunsForFlakiness: 5,
+      flakinessThreshold: 0.1,
+      // 10% failure rate = flaky
+      maxRecentErrors: 5,
+      historyRetentionDays: 30
+    };
+    FlakyTestTracker = class {
+      records = /* @__PURE__ */ new Map();
+      config;
+      constructor(config) {
+        this.config = { ...DEFAULT_CONFIG70, ...config };
+      }
+      // --------------------------------------------------------------------------
+      // Public API
+      // --------------------------------------------------------------------------
+      /**
+       * Record a test execution result
+       */
+      recordResult(result) {
+        const testId = this.getTestId(result);
+        const record = this.getOrCreateRecord(testId, result);
+        record.totalRuns++;
+        record.lastRun = /* @__PURE__ */ new Date();
+        if (result.passed) {
+          record.passCount++;
+        } else {
+          record.failCount++;
+          if (result.error) {
+            record.recentErrors = [
+              result.error,
+              ...record.recentErrors.slice(0, this.config.maxRecentErrors - 1)
+            ];
+          }
+        }
+        if (result.retries > 0 && result.passed) {
+          record.flakyCount++;
+          record.lastFlaky = /* @__PURE__ */ new Date();
+        }
+        record.flakinessScore = this.calculateFlakiness(record);
+      }
+      /**
+       * Record multiple test results
+       */
+      recordResults(results) {
+        for (const result of results) {
+          this.recordResult(result);
+        }
+      }
+      /**
+       * Get flaky test record by ID
+       */
+      getRecord(testId) {
+        return this.records.get(testId);
+      }
+      /**
+       * Get all flaky tests
+       */
+      getFlakyTests() {
+        return Array.from(this.records.values()).filter(
+          (record) => record.totalRuns >= this.config.minRunsForFlakiness && record.flakinessScore >= this.config.flakinessThreshold
+        );
+      }
+      /**
+       * Check if a specific test is flaky
+       */
+      isFlaky(testId) {
+        const record = this.records.get(testId);
+        if (!record) return false;
+        return record.totalRuns >= this.config.minRunsForFlakiness && record.flakinessScore >= this.config.flakinessThreshold;
+      }
+      /**
+       * Get comprehensive flaky analysis
+       */
+      analyze() {
+        const allRecords = Array.from(this.records.values());
+        const flakyTests = allRecords.filter(
+          (r54) => r54.totalRuns >= this.config.minRunsForFlakiness && r54.flakinessScore >= this.config.flakinessThreshold
+        );
+        const stabilizedTests = allRecords.filter(
+          (r54) => r54.totalRuns >= this.config.minRunsForFlakiness && r54.flakyCount > 0 && r54.flakinessScore < this.config.flakinessThreshold
+        );
+        const insufficientData = allRecords.filter(
+          (r54) => r54.totalRuns < this.config.minRunsForFlakiness
+        );
+        const totalWithSufficientData = allRecords.filter(
+          (r54) => r54.totalRuns >= this.config.minRunsForFlakiness
+        );
+        const overallFlakiness = totalWithSufficientData.length > 0 ? flakyTests.length / totalWithSufficientData.length : 0;
+        const trend = this.calculateTrend(flakyTests);
+        return {
+          totalTests: allRecords.length,
+          flakyTests: flakyTests.sort((a37, b68) => b68.flakinessScore - a37.flakinessScore),
+          stabilizedTests,
+          insufficientData,
+          overallFlakiness,
+          trend
+        };
+      }
+      /**
+       * Get quarantine list (tests that should be isolated)
+       */
+      getQuarantineList(threshold = 0.3) {
+        return Array.from(this.records.values()).filter((r54) => r54.flakinessScore >= threshold).map((r54) => r54.testId);
+      }
+      /**
+       * Clear old history based on retention policy
+       */
+      pruneHistory() {
+        const cutoff = /* @__PURE__ */ new Date();
+        cutoff.setDate(cutoff.getDate() - this.config.historyRetentionDays);
+        let pruned = 0;
+        for (const [testId, record] of this.records) {
+          if (record.lastRun < cutoff) {
+            this.records.delete(testId);
+            pruned++;
+          }
+        }
+        return pruned;
+      }
+      /**
+       * Export history for persistence
+       */
+      exportHistory() {
+        return Array.from(this.records.values());
+      }
+      /**
+       * Import history from persistence
+       */
+      importHistory(records) {
+        for (const record of records) {
+          const imported = {
+            ...record,
+            lastRun: new Date(record.lastRun),
+            lastFlaky: record.lastFlaky ? new Date(record.lastFlaky) : void 0
+          };
+          this.records.set(record.testId, imported);
+        }
+      }
+      /**
+       * Reset all tracking data
+       */
+      reset() {
+        this.records.clear();
+      }
+      // --------------------------------------------------------------------------
+      // Private Methods
+      // --------------------------------------------------------------------------
+      getTestId(result) {
+        return `${result.file}:${result.suite}:${result.name}`;
+      }
+      getOrCreateRecord(testId, result) {
+        let record = this.records.get(testId);
+        if (!record) {
+          record = {
+            testId,
+            file: result.file,
+            name: result.name,
+            totalRuns: 0,
+            passCount: 0,
+            failCount: 0,
+            flakyCount: 0,
+            flakinessScore: 0,
+            lastRun: /* @__PURE__ */ new Date(),
+            recentErrors: []
+          };
+          this.records.set(testId, record);
+        }
+        return record;
+      }
+      calculateFlakiness(record) {
+        if (record.totalRuns < this.config.minRunsForFlakiness) {
+          return 0;
+        }
+        const flakyRatio = record.flakyCount / record.totalRuns;
+        const passRatio = record.passCount / record.totalRuns;
+        const inconsistencyScore = passRatio > 0 && passRatio < 1 ? Math.min(passRatio, 1 - passRatio) * 2 : 0;
+        return Math.min(1, flakyRatio * 3 + inconsistencyScore);
+      }
+      calculateTrend(flakyTests) {
+        if (flakyTests.length === 0) {
+          return "stable";
+        }
+        const now = Date.now();
+        const oneWeekAgo = now - 7 * 24 * 60 * 60 * 1e3;
+        let recentFlaky = 0;
+        let oldFlaky = 0;
+        for (const test of flakyTests) {
+          if (test.lastFlaky) {
+            if (test.lastFlaky.getTime() > oneWeekAgo) {
+              recentFlaky++;
+            } else {
+              oldFlaky++;
+            }
+          }
+        }
+        if (recentFlaky > oldFlaky * 1.5) {
+          return "degrading";
+        } else if (oldFlaky > recentFlaky * 1.5) {
+          return "improving";
+        }
+        return "stable";
+      }
+    };
+  }
+});
+
+// src/test-scheduling/cicd/github-actions.ts
+function detectCIEnvironment() {
+  const env = process.env;
+  if (env.GITHUB_ACTIONS === "true") {
+    return {
+      isCI: true,
+      provider: "github-actions",
+      branch: env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME,
+      commitSha: env.GITHUB_SHA,
+      prNumber: env.GITHUB_EVENT_NAME === "pull_request" ? parseInt(env.GITHUB_REF?.split("/")[2] || "", 10) || void 0 : void 0,
+      baseBranch: env.GITHUB_BASE_REF,
+      buildUrl: `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}`
+    };
+  }
+  if (env.GITLAB_CI === "true") {
+    return {
+      isCI: true,
+      provider: "gitlab-ci",
+      branch: env.CI_COMMIT_REF_NAME,
+      commitSha: env.CI_COMMIT_SHA,
+      prNumber: env.CI_MERGE_REQUEST_IID ? parseInt(env.CI_MERGE_REQUEST_IID, 10) : void 0,
+      baseBranch: env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME,
+      buildUrl: env.CI_JOB_URL
+    };
+  }
+  if (env.JENKINS_URL) {
+    return {
+      isCI: true,
+      provider: "jenkins",
+      branch: env.GIT_BRANCH || env.BRANCH_NAME,
+      commitSha: env.GIT_COMMIT,
+      prNumber: env.CHANGE_ID ? parseInt(env.CHANGE_ID, 10) : void 0,
+      baseBranch: env.CHANGE_TARGET,
+      buildUrl: env.BUILD_URL
+    };
+  }
+  if (env.CIRCLECI === "true") {
+    return {
+      isCI: true,
+      provider: "circleci",
+      branch: env.CIRCLE_BRANCH,
+      commitSha: env.CIRCLE_SHA1,
+      prNumber: env.CIRCLE_PULL_REQUEST ? parseInt(env.CIRCLE_PULL_REQUEST.split("/").pop() || "", 10) : void 0,
+      buildUrl: env.CIRCLE_BUILD_URL
+    };
+  }
+  if (env.CI === "true" || env.CI === "1") {
+    return {
+      isCI: true,
+      provider: "unknown"
+    };
+  }
+  return { isCI: false };
+}
+function createGitHubActionsReporter(config) {
+  return new GitHubActionsReporter(config);
+}
+async function reportToGitHubActions(results, config) {
+  const reporter = createGitHubActionsReporter(config);
+  await reporter.writeOutput(results);
+}
+var DEFAULT_CONFIG71, GitHubActionsReporter;
+var init_github_actions = __esm({
+  "src/test-scheduling/cicd/github-actions.ts"() {
+    "use strict";
+    DEFAULT_CONFIG71 = {
+      enableAnnotations: true,
+      enableSummary: true,
+      enableOutputs: true,
+      maxAnnotations: 10,
+      includeFlakyWarnings: true,
+      includeCoverage: true
+    };
+    GitHubActionsReporter = class {
+      config;
+      constructor(config) {
+        this.config = { ...DEFAULT_CONFIG71, ...config };
+      }
+      // --------------------------------------------------------------------------
+      // Public API
+      // --------------------------------------------------------------------------
+      /**
+       * Generate complete GitHub Actions output
+       */
+      generateOutput(results) {
+        const annotations = this.config.enableAnnotations ? this.generateAnnotations(results) : [];
+        const summary = this.config.enableSummary ? this.generateSummary(results) : "";
+        const outputs = this.config.enableOutputs ? this.generateOutputs(results) : {};
+        return { summary, annotations, outputs };
+      }
+      /**
+       * Write output to GitHub Actions
+       */
+      async writeOutput(results) {
+        const output = this.generateOutput(results);
+        const fs26 = await import("fs/promises");
+        for (const annotation of output.annotations) {
+          this.writeAnnotation(annotation);
+        }
+        if (output.summary && process.env.GITHUB_STEP_SUMMARY) {
+          await fs26.appendFile(process.env.GITHUB_STEP_SUMMARY, output.summary);
+        }
+        if (process.env.GITHUB_OUTPUT) {
+          const outputLines = Object.entries(output.outputs).map(([key, value]) => `${key}=${value}`).join("\n");
+          await fs26.appendFile(process.env.GITHUB_OUTPUT, outputLines + "\n");
+        }
+      }
+      // --------------------------------------------------------------------------
+      // Annotation Generation
+      // --------------------------------------------------------------------------
+      generateAnnotations(results) {
+        const annotations = [];
+        for (const phase of results) {
+          for (const test of phase.testResults) {
+            if (!test.passed && annotations.length < this.config.maxAnnotations) {
+              annotations.push({
+                file: test.file,
+                line: this.extractLineNumber(test.stack) || 1,
+                level: "error",
+                title: `Test Failed: ${test.name}`,
+                message: test.error || "Test failed without error message"
+              });
+            }
+          }
+          if (this.config.includeFlakyWarnings) {
+            for (const flakyTest of phase.flakyTests) {
+              if (annotations.length < this.config.maxAnnotations) {
+                annotations.push({
+                  file: flakyTest,
+                  line: 1,
+                  level: "warning",
+                  title: "Flaky Test Detected",
+                  message: `This test is flaky and may cause intermittent failures`
+                });
+              }
+            }
+          }
+        }
+        return annotations;
+      }
+      // --------------------------------------------------------------------------
+      // Summary Generation
+      // --------------------------------------------------------------------------
+      generateSummary(results) {
+        const lines = ["## \u{1F9EA} Test Results\n"];
+        const allPassed = results.every((r54) => r54.success);
+        lines.push(allPassed ? "\u2705 **All phases passed**\n" : "\u274C **Some phases failed**\n");
+        lines.push("| Phase | Status | Pass Rate | Duration | Tests |");
+        lines.push("|-------|--------|-----------|----------|-------|");
+        for (const phase of results) {
+          const status = phase.success ? "\u2705" : "\u274C";
+          const passRate = `${(phase.passRate * 100).toFixed(1)}%`;
+          const duration = this.formatDuration(phase.durationMs);
+          const tests = `${phase.passed}/${phase.totalTests}`;
+          lines.push(`| ${phase.phaseName} | ${status} | ${passRate} | ${duration} | ${tests} |`);
+        }
+        lines.push("");
+        if (this.config.includeCoverage) {
+          lines.push("### \u{1F4CA} Coverage\n");
+          for (const phase of results) {
+            const coverage = `${(phase.coverage * 100).toFixed(1)}%`;
+            const bar = this.generateCoverageBar(phase.coverage);
+            lines.push(`- **${phase.phaseName}**: ${bar} ${coverage}`);
+          }
+          lines.push("");
+        }
+        const failedTests = results.flatMap(
+          (r54) => r54.testResults.filter((t50) => !t50.passed)
+        );
+        if (failedTests.length > 0) {
+          lines.push("### \u274C Failed Tests\n");
+          lines.push("<details>");
+          lines.push("<summary>Click to expand</summary>\n");
+          for (const test of failedTests.slice(0, 20)) {
+            lines.push(`#### ${test.suite} > ${test.name}`);
+            lines.push(`- **File**: \`${test.file}\``);
+            if (test.error) {
+              lines.push("```");
+              lines.push(test.error.slice(0, 500));
+              lines.push("```");
+            }
+            lines.push("");
+          }
+          if (failedTests.length > 20) {
+            lines.push(`_... and ${failedTests.length - 20} more failures_`);
+          }
+          lines.push("</details>\n");
+        }
+        const flakyTests = results.flatMap((r54) => r54.flakyTests);
+        if (flakyTests.length > 0 && this.config.includeFlakyWarnings) {
+          lines.push("### \u26A0\uFE0F Flaky Tests\n");
+          for (const test of flakyTests.slice(0, 10)) {
+            lines.push(`- \`${test}\``);
+          }
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      // --------------------------------------------------------------------------
+      // Output Variables
+      // --------------------------------------------------------------------------
+      generateOutputs(results) {
+        const totalTests = results.reduce((sum, r54) => sum + r54.totalTests, 0);
+        const totalPassed = results.reduce((sum, r54) => sum + r54.passed, 0);
+        const totalFailed = results.reduce((sum, r54) => sum + r54.failed, 0);
+        const allPassed = results.every((r54) => r54.success);
+        const avgCoverage = results.length > 0 ? results.reduce((sum, r54) => sum + r54.coverage, 0) / results.length : 0;
+        return {
+          test_result: allPassed ? "success" : "failure",
+          total_tests: String(totalTests),
+          passed_tests: String(totalPassed),
+          failed_tests: String(totalFailed),
+          coverage_percent: String((avgCoverage * 100).toFixed(1)),
+          phases_completed: String(results.length),
+          phases_passed: String(results.filter((r54) => r54.success).length),
+          has_flaky_tests: String(results.some((r54) => r54.flakyTests.length > 0))
+        };
+      }
+      // --------------------------------------------------------------------------
+      // Helpers
+      // --------------------------------------------------------------------------
+      writeAnnotation(annotation) {
+        const params = [
+          `file=${annotation.file}`,
+          `line=${annotation.line}`,
+          `title=${annotation.title}`
+        ].join(",");
+        console.log(`::${annotation.level} ${params}::${annotation.message}`);
+      }
+      extractLineNumber(stack) {
+        if (!stack) return void 0;
+        const match = stack.match(/:(\d+):\d+/);
+        return match ? parseInt(match[1], 10) : void 0;
+      }
+      formatDuration(ms) {
+        if (ms < 1e3) return `${ms}ms`;
+        if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+        return `${(ms / 6e4).toFixed(1)}m`;
+      }
+      generateCoverageBar(coverage) {
+        const filled = Math.round(coverage * 10);
+        const empty = 10 - filled;
+        return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+      }
+    };
+  }
+});
+
+// src/test-scheduling/pipeline.ts
+async function createTestPipeline(config) {
+  return TestSchedulingPipeline.create(config);
+}
+async function runTestPipeline(config) {
+  const pipeline10 = await createTestPipeline(config);
+  return pipeline10.run();
+}
+var TestSchedulingPipeline;
+var init_pipeline = __esm({
+  "src/test-scheduling/pipeline.ts"() {
+    "use strict";
+    init_phase_scheduler();
+    init_vitest_executor();
+    init_test_selector();
+    init_flaky_tracker();
+    init_github_actions();
+    TestSchedulingPipeline = class _TestSchedulingPipeline {
+      constructor(config, selector, executor2, scheduler, flakyTracker, reporter) {
+        this.config = config;
+        this.selector = selector;
+        this.executor = executor2;
+        this.scheduler = scheduler;
+        this.flakyTracker = flakyTracker;
+        this.reporter = reporter;
+        this.ciEnvironment = detectCIEnvironment();
+      }
+      selector;
+      executor;
+      scheduler;
+      flakyTracker;
+      reporter;
+      ciEnvironment;
+      /**
+       * Create a fully integrated test scheduling pipeline
+       *
+       * This factory method:
+       * 1. Creates FlakyTracker (loads history if exists)
+       * 2. Creates VitestExecutor with FlakyTracker integration
+       * 3. Optionally creates ImpactAnalyzerService for import graph analysis
+       * 4. Creates GitAwareTestSelector with ImpactAnalyzer integration
+       * 5. Creates PhaseScheduler with the executor
+       * 6. Creates GitHubActionsReporter
+       */
+      static async create(config) {
+        const flakyTracker = config.flakyHistoryPath ? await loadFlakyTracker(config.flakyHistoryPath, config.flakyTracker) : createFlakyTracker(config.flakyTracker);
+        const executor2 = new VitestPhaseExecutor({
+          ...config.vitest,
+          cwd: config.cwd,
+          flakyTracker
+          // INTEGRATION: Pass tracker to executor
+        });
+        const { ImpactAnalyzerService: ImpactAnalyzerService2 } = await Promise.resolve().then(() => (init_impact_analyzer(), impact_analyzer_exports));
+        const impactAnalyzer = new ImpactAnalyzerService2(config.memory);
+        const selector = createTestSelector({
+          cwd: config.cwd,
+          baseRef: config.baseRef,
+          impactAnalyzer
+          // INTEGRATION: Pass analyzer to selector
+        });
+        const scheduler = createPhaseScheduler(executor2, {
+          ...config.scheduler,
+          phases: config.phases
+        });
+        const reporter = createGitHubActionsReporter(config.reporter);
+        return new _TestSchedulingPipeline(
+          config,
+          selector,
+          executor2,
+          scheduler,
+          flakyTracker,
+          reporter
+        );
+      }
+      // --------------------------------------------------------------------------
+      // Public API
+      // --------------------------------------------------------------------------
+      /**
+       * Run the complete test scheduling pipeline:
+       * 1. Select affected tests (git-aware + import graph)
+       * 2. Execute tests in phases
+       * 3. Track flaky tests
+       * 4. Report to CI/CD
+       */
+      async run() {
+        const startTime = Date.now();
+        let selectedTests = [];
+        let ranAllTests = this.config.runAllTests ?? false;
+        if (!ranAllTests) {
+          const selectionResult = await this.selector.selectAffectedTests();
+          if (selectionResult.runAllTests) {
+            ranAllTests = true;
+            console.log(`[TestSchedulingPipeline] Running all tests: ${selectionResult.runAllReason}`);
+          } else if (selectionResult.selectedTests.length === 0) {
+            console.log("[TestSchedulingPipeline] No affected tests found, running all");
+            ranAllTests = true;
+          } else {
+            selectedTests = selectionResult.selectedTests;
+            console.log(`[TestSchedulingPipeline] Selected ${selectedTests.length} affected tests`);
+          }
+        }
+        let phaseResults;
+        if (ranAllTests) {
+          phaseResults = await this.scheduler.run();
+        } else {
+          phaseResults = await this.runWithSelectedTests(selectedTests);
+        }
+        const flakyAnalysis = this.flakyTracker.analyze();
+        if (this.config.flakyHistoryPath) {
+          await saveFlakyTracker(this.flakyTracker, this.config.flakyHistoryPath);
+        }
+        if (this.ciEnvironment.isCI) {
+          await this.reporter.writeOutput(phaseResults);
+        }
+        const totalDurationMs = Date.now() - startTime;
+        return {
+          phaseResults,
+          selectedTests,
+          ranAllTests,
+          flakyAnalysis,
+          ciEnvironment: this.ciEnvironment,
+          totalDurationMs
+        };
+      }
+      /**
+       * Run only affected tests for a specific phase
+       */
+      async runPhase(phaseId) {
+        return this.scheduler.runPhase(phaseId);
+      }
+      /**
+       * Get the flaky test tracker for direct access
+       */
+      getFlakyTracker() {
+        return this.flakyTracker;
+      }
+      /**
+       * Get the test selector for direct access
+       */
+      getSelector() {
+        return this.selector;
+      }
+      /**
+       * Get scheduler stats
+       */
+      getStats() {
+        return this.scheduler.getStats();
+      }
+      /**
+       * Abort running tests
+       */
+      async abort() {
+        await this.scheduler.abort();
+      }
+      // --------------------------------------------------------------------------
+      // Private Methods
+      // --------------------------------------------------------------------------
+      async runWithSelectedTests(testFiles) {
+        const results = [];
+        const phases = this.config.phases ?? [];
+        for (const phase of phases) {
+          const phaseTests = testFiles.filter(
+            (file) => phase.testPatterns.some((pattern) => {
+              if (pattern.startsWith("!")) return false;
+              const regex = this.patternToRegex(pattern);
+              return regex.test(file);
+            })
+          );
+          if (phaseTests.length > 0) {
+            const result = await this.executor.execute(phase, phaseTests);
+            results.push(result);
+          }
+        }
+        return results;
+      }
+      patternToRegex(pattern) {
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+        return new RegExp(escaped);
+      }
+    };
+  }
+});
+
+// src/test-scheduling/index.ts
+var test_scheduling_exports = {};
+__export(test_scheduling_exports, {
+  DEFAULT_TEST_PHASES: () => DEFAULT_TEST_PHASES,
+  FlakyTestTracker: () => FlakyTestTracker,
+  GitAwareTestSelector: () => GitAwareTestSelector,
+  GitHubActionsReporter: () => GitHubActionsReporter,
+  PhaseScheduler: () => PhaseScheduler,
+  TestSchedulingPipeline: () => TestSchedulingPipeline,
+  VitestPhaseExecutor: () => VitestPhaseExecutor,
+  checkQualityThresholds: () => checkQualityThresholds,
+  createFlakyTracker: () => createFlakyTracker,
+  createGitHubActionsReporter: () => createGitHubActionsReporter,
+  createPhaseScheduler: () => createPhaseScheduler,
+  createTestPipeline: () => createTestPipeline,
+  createTestSelector: () => createTestSelector,
+  createVitestExecutor: () => createVitestExecutor,
+  detectCIEnvironment: () => detectCIEnvironment,
+  getAffectedTests: () => getAffectedTests,
+  loadFlakyTracker: () => loadFlakyTracker,
+  reportToGitHubActions: () => reportToGitHubActions,
+  runTestPipeline: () => runTestPipeline,
+  saveFlakyTracker: () => saveFlakyTracker
+});
+var init_test_scheduling = __esm({
+  "src/test-scheduling/index.ts"() {
+    "use strict";
+    init_interfaces7();
+    init_phase_scheduler();
+    init_vitest_executor();
+    init_test_selector();
+    init_flaky_tracker();
+    init_github_actions();
+    init_pipeline();
+  }
+});
+
+// src/mcp/tools/test-execution/schedule.ts
+var TestScheduleTool;
+var init_schedule = __esm({
+  "src/mcp/tools/test-execution/schedule.ts"() {
+    "use strict";
+    init_base();
+    init_error_utils();
+    TestScheduleTool = class extends MCPToolBase {
+      config = {
+        name: "qe/tests/schedule",
+        description: "Schedule and execute tests using phase-based pipeline with git-aware selection and flaky tracking. Runs tests in phases (unit, integration, e2e), selects affected tests from git changes, and tracks flaky tests.",
+        domain: "test-execution",
+        schema: this.buildSchema()
+      };
+      buildSchema() {
+        return {
+          type: "object",
+          properties: {
+            cwd: {
+              type: "string",
+              description: "Working directory for test execution (defaults to project root)"
+            },
+            gitRef: {
+              type: "string",
+              description: 'Git ref to compare for affected test selection (e.g., "main", "HEAD~3")'
+            },
+            useGitAware: {
+              type: "boolean",
+              description: "Enable git-aware test selection to only run affected tests",
+              default: true
+            },
+            trackFlaky: {
+              type: "boolean",
+              description: "Enable flaky test tracking and quarantine",
+              default: true
+            }
+          }
+        };
+      }
+      async execute(params, context) {
+        try {
+          const { runTestPipeline: runTestPipeline2 } = await Promise.resolve().then(() => (init_test_scheduling(), test_scheduling_exports));
+          const memory = await getMemoryBackend(context);
+          const result = await runTestPipeline2({
+            cwd: params.cwd || process.cwd(),
+            memory,
+            baseRef: params.gitRef,
+            flakyHistoryPath: params.trackFlaky !== false ? ".agentic-qe/flaky-history.json" : void 0,
+            runAllTests: params.useGitAware === false
+          });
+          const totalTests = result.phaseResults.reduce((sum, pr3) => sum + pr3.totalTests, 0);
+          const totalPassed = result.phaseResults.reduce((sum, pr3) => sum + pr3.passed, 0);
+          const totalFailed = result.phaseResults.reduce((sum, pr3) => sum + pr3.failed, 0);
+          return {
+            success: true,
+            data: {
+              pipelineId: context.requestId,
+              phases: result.phaseResults.map((pr3) => ({
+                phaseId: pr3.phaseId,
+                phaseName: pr3.phaseName,
+                totalTests: pr3.totalTests,
+                passed: pr3.passed,
+                failed: pr3.failed,
+                passRate: pr3.passRate,
+                durationMs: pr3.durationMs
+              })),
+              gitAware: {
+                enabled: !result.ranAllTests,
+                selectedTests: result.selectedTests.length,
+                gitRef: params.gitRef
+              },
+              flakyTracking: {
+                enabled: params.trackFlaky !== false
+              },
+              totalDuration: result.totalDurationMs,
+              ranAllTests: result.ranAllTests,
+              summary: `Executed ${result.phaseResults.length} phases, ${totalTests} tests (${totalPassed} passed, ${totalFailed} failed) in ${result.totalDurationMs}ms`
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: toErrorMessage(error)
+          };
+        }
+      }
+    };
+  }
+});
+
+// src/testing/load/metrics-collector.ts
+function createMetricsCollector(config) {
+  return new MetricsCollector2(config);
+}
+var DEFAULT_CONFIG72, MetricsCollector2;
+var init_metrics_collector2 = __esm({
+  "src/testing/load/metrics-collector.ts"() {
+    "use strict";
+    init_utils();
+    DEFAULT_CONFIG72 = {
+      maxEvents: 1e5,
+      memorySampleInterval: 1e3,
+      enableTimeline: true,
+      timelineSampleInterval: 1e3
+    };
+    MetricsCollector2 = class {
+      config;
+      // Active agent tracking
+      activeAgents = /* @__PURE__ */ new Map();
+      // agentId -> spawnTimestamp
+      peakAgentCount = 0;
+      totalAgentsSpawned = 0;
+      // Task tracking
+      activeTasks = /* @__PURE__ */ new Map();
+      totalTasksStarted = 0;
+      totalTasksCompleted = 0;
+      // Latency buffers (using CircularBuffer for memory efficiency)
+      coordinationLatencies;
+      taskDurations;
+      // Memory tracking
+      memorySnapshots;
+      peakMemoryUsed = 0;
+      memorySum = 0;
+      memorySamples = 0;
+      // Timeline tracking
+      agentTimeline = [];
+      latencyTimeline = [];
+      memoryTimeline = [];
+      // Timing
+      startTime = 0;
+      endTime = 0;
+      running = false;
+      memorySamplerTimer = null;
+      timelineSamplerTimer = null;
+      // Issue tracking
+      issues = [];
+      constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG72, ...config };
+        this.coordinationLatencies = new CircularBuffer(this.config.maxEvents);
+        this.taskDurations = new CircularBuffer(this.config.maxEvents);
+        this.memorySnapshots = new CircularBuffer(1e4);
+      }
+      // ============================================================================
+      // Lifecycle
+      // ============================================================================
+      /**
+       * Start collecting metrics
+       */
+      start() {
+        if (this.running) return;
+        this.running = true;
+        this.startTime = Date.now();
+        this.memorySamplerTimer = setInterval(() => {
+          this.sampleMemory();
+        }, this.config.memorySampleInterval);
+        if (this.config.enableTimeline) {
+          this.timelineSamplerTimer = setInterval(() => {
+            this.sampleTimeline();
+          }, this.config.timelineSampleInterval);
+        }
+      }
+      /**
+       * Stop collecting metrics
+       */
+      stop() {
+        if (!this.running) return;
+        this.running = false;
+        this.endTime = Date.now();
+        if (this.memorySamplerTimer) {
+          clearInterval(this.memorySamplerTimer);
+          this.memorySamplerTimer = null;
+        }
+        if (this.timelineSamplerTimer) {
+          clearInterval(this.timelineSamplerTimer);
+          this.timelineSamplerTimer = null;
+        }
+      }
+      /**
+       * Reset all metrics
+       */
+      reset() {
+        this.stop();
+        this.activeAgents.clear();
+        this.peakAgentCount = 0;
+        this.totalAgentsSpawned = 0;
+        this.activeTasks.clear();
+        this.totalTasksStarted = 0;
+        this.totalTasksCompleted = 0;
+        this.coordinationLatencies.clear();
+        this.taskDurations.clear();
+        this.memorySnapshots.clear();
+        this.peakMemoryUsed = 0;
+        this.memorySum = 0;
+        this.memorySamples = 0;
+        this.agentTimeline.length = 0;
+        this.latencyTimeline.length = 0;
+        this.memoryTimeline.length = 0;
+        this.startTime = 0;
+        this.endTime = 0;
+        this.issues.length = 0;
+      }
+      // ============================================================================
+      // Recording Methods
+      // ============================================================================
+      /**
+       * Record agent spawn
+       */
+      recordAgentSpawn(agentId, timestamp = Date.now()) {
+        this.activeAgents.set(agentId, timestamp);
+        this.totalAgentsSpawned++;
+        const currentCount = this.activeAgents.size;
+        if (currentCount > this.peakAgentCount) {
+          this.peakAgentCount = currentCount;
+        }
+      }
+      /**
+       * Record agent termination
+       */
+      recordAgentTerminate(agentId, _timestamp = Date.now()) {
+        this.activeAgents.delete(agentId);
+      }
+      /**
+       * Record task start
+       */
+      recordTaskStart(agentId, taskId, timestamp = Date.now()) {
+        this.activeTasks.set(taskId, { agentId, startTime: timestamp });
+        this.totalTasksStarted++;
+      }
+      /**
+       * Record task completion with duration
+       */
+      recordTaskComplete(agentId, taskId, duration, _timestamp = Date.now()) {
+        const taskInfo = this.activeTasks.get(taskId);
+        if (taskInfo && taskInfo.agentId === agentId) {
+          this.activeTasks.delete(taskId);
+          this.taskDurations.push(duration);
+          this.totalTasksCompleted++;
+        }
+      }
+      /**
+       * Record coordination latency
+       */
+      recordCoordination(agentId, latency, _timestamp = Date.now()) {
+        this.coordinationLatencies.push(latency);
+        if (latency > 100) {
+          this.issues.push(`High coordination latency for agent ${agentId}: ${latency}ms`);
+        }
+      }
+      /**
+       * Record memory usage
+       */
+      recordMemoryUsage(heapUsed, heapTotal) {
+        const snapshot = {
+          timestamp: Date.now(),
+          heapUsed,
+          heapTotal,
+          external: 0,
+          rss: 0
+        };
+        this.memorySnapshots.push(snapshot);
+        this.memorySum += heapUsed;
+        this.memorySamples++;
+        if (heapUsed > this.peakMemoryUsed) {
+          this.peakMemoryUsed = heapUsed;
+        }
+        const MEMORY_LIMIT = 4 * 1024 * 1024 * 1024;
+        if (heapUsed > MEMORY_LIMIT) {
+          this.issues.push(`Memory exceeded 4GB limit: ${(heapUsed / 1024 / 1024 / 1024).toFixed(2)}GB`);
+        }
+      }
+      /**
+       * Record an issue
+       */
+      recordIssue(message) {
+        this.issues.push(message);
+      }
+      // ============================================================================
+      // Query Methods
+      // ============================================================================
+      /**
+       * Get current active agent count
+       */
+      getAgentCount() {
+        return this.activeAgents.size;
+      }
+      /**
+       * Get peak agent count
+       */
+      getPeakAgentCount() {
+        return this.peakAgentCount;
+      }
+      /**
+       * Get total agents spawned
+       */
+      getTotalAgentsSpawned() {
+        return this.totalAgentsSpawned;
+      }
+      /**
+       * Get coordination latency at P95
+       */
+      getP95CoordinationLatency() {
+        return this.calculatePercentile(this.coordinationLatencies.toArray(), 0.95);
+      }
+      /**
+       * Get coordination latency at P99
+       */
+      getP99CoordinationLatency() {
+        return this.calculatePercentile(this.coordinationLatencies.toArray(), 0.99);
+      }
+      /**
+       * Get coordination latency percentiles
+       */
+      getCoordinationLatencyPercentiles() {
+        return this.calculatePercentiles(this.coordinationLatencies.toArray());
+      }
+      /**
+       * Get task latency percentiles
+       */
+      getTaskLatencyPercentiles() {
+        return this.calculatePercentiles(this.taskDurations.toArray());
+      }
+      /**
+       * Get maximum memory usage
+       */
+      getMaxMemoryUsage() {
+        return this.peakMemoryUsed;
+      }
+      /**
+       * Get average memory usage
+       */
+      getAverageMemoryUsage() {
+        return this.memorySamples > 0 ? this.memorySum / this.memorySamples : 0;
+      }
+      /**
+       * Get throughput metrics
+       */
+      getThroughput() {
+        const duration = this.getDuration();
+        const durationSeconds = duration / 1e3;
+        return {
+          tasks: this.totalTasksCompleted,
+          tasksPerSecond: durationSeconds > 0 ? this.totalTasksCompleted / durationSeconds : 0,
+          agents: this.totalAgentsSpawned,
+          agentsPerSecond: durationSeconds > 0 ? this.totalAgentsSpawned / durationSeconds : 0
+        };
+      }
+      /**
+       * Get test duration in milliseconds
+       */
+      getDuration() {
+        if (this.startTime === 0) return 0;
+        const end = this.endTime > 0 ? this.endTime : Date.now();
+        return end - this.startTime;
+      }
+      /**
+       * Check if any agents are starving (no tasks for extended period)
+       */
+      hasAgentStarvation() {
+        const activeAgentCount = this.activeAgents.size;
+        const activeTaskCount = this.activeTasks.size;
+        return activeAgentCount > 0 && activeTaskCount === 0 && this.totalTasksCompleted > 0;
+      }
+      /**
+       * Check for potential deadlocks (tasks started but not completing)
+       */
+      hasDeadlocks() {
+        const now = Date.now();
+        const DEADLOCK_THRESHOLD = 6e4;
+        const tasks = Array.from(this.activeTasks.values());
+        for (const taskInfo of tasks) {
+          if (now - taskInfo.startTime > DEADLOCK_THRESHOLD) {
+            return true;
+          }
+        }
+        return false;
+      }
+      // ============================================================================
+      // Report Generation
+      // ============================================================================
+      /**
+       * Export complete load test report
+       */
+      exportReport() {
+        const duration = this.getDuration();
+        const coordinationLatency = this.getCoordinationLatencyPercentiles();
+        const taskLatency = this.getTaskLatencyPercentiles();
+        const throughput = this.getThroughput();
+        const AGENT_TARGET = 100;
+        const MEMORY_LIMIT = 4 * 1024 * 1024 * 1024;
+        const LATENCY_TARGET = 100;
+        const successCriteria = {
+          agentCount: this.peakAgentCount >= AGENT_TARGET,
+          memoryLimit: this.peakMemoryUsed < MEMORY_LIMIT,
+          coordinationLatency: coordinationLatency.p95 <= LATENCY_TARGET,
+          noDeadlocks: !this.hasDeadlocks(),
+          noStarvation: !this.hasAgentStarvation()
+        };
+        const allCriteriaMet = Object.values(successCriteria).every(Boolean);
+        const recommendations = this.generateRecommendations(
+          coordinationLatency,
+          this.peakMemoryUsed,
+          throughput
+        );
+        return {
+          summary: {
+            totalAgents: this.totalAgentsSpawned,
+            peakAgents: this.peakAgentCount,
+            totalTasks: this.totalTasksCompleted,
+            duration,
+            success: allCriteriaMet,
+            successCriteria
+          },
+          performance: {
+            coordinationLatency,
+            taskLatency,
+            throughput
+          },
+          resources: {
+            memoryPeak: this.peakMemoryUsed,
+            memoryAverage: this.getAverageMemoryUsage(),
+            cpuPeak: 0,
+            // Not tracked yet
+            cpuAverage: 0
+          },
+          timeline: {
+            agentCounts: [...this.agentTimeline],
+            latencies: [...this.latencyTimeline],
+            memoryUsage: [...this.memoryTimeline]
+          },
+          issues: [...this.issues],
+          recommendations
+        };
+      }
+      // ============================================================================
+      // Private Methods
+      // ============================================================================
+      sampleMemory() {
+        const memUsage = process.memoryUsage();
+        this.recordMemoryUsage(memUsage.heapUsed, memUsage.heapTotal);
+      }
+      sampleTimeline() {
+        const now = Date.now();
+        this.agentTimeline.push({
+          timestamp: now,
+          count: this.activeAgents.size
+        });
+        const latencies = this.coordinationLatencies.toArray();
+        if (latencies.length > 0) {
+          this.latencyTimeline.push({
+            timestamp: now,
+            p95: this.calculatePercentile(latencies, 0.95)
+          });
+        }
+        const memUsage = process.memoryUsage();
+        this.memoryTimeline.push({
+          timestamp: now,
+          heapUsed: memUsage.heapUsed
+        });
+        const MAX_TIMELINE_POINTS = 1e3;
+        if (this.agentTimeline.length > MAX_TIMELINE_POINTS) {
+          this.agentTimeline.shift();
+        }
+        if (this.latencyTimeline.length > MAX_TIMELINE_POINTS) {
+          this.latencyTimeline.shift();
+        }
+        if (this.memoryTimeline.length > MAX_TIMELINE_POINTS) {
+          this.memoryTimeline.shift();
+        }
+      }
+      calculatePercentile(values, percentile) {
+        if (values.length === 0) return 0;
+        const sorted = [...values].sort((a37, b68) => a37 - b68);
+        const index = Math.ceil(sorted.length * percentile) - 1;
+        return sorted[Math.max(0, index)];
+      }
+      calculatePercentiles(values) {
+        if (values.length === 0) {
+          return { p50: 0, p95: 0, p99: 0, max: 0, min: 0, avg: 0, count: 0 };
+        }
+        const sorted = [...values].sort((a37, b68) => a37 - b68);
+        const sum = sorted.reduce((a37, b68) => a37 + b68, 0);
+        return {
+          p50: this.calculatePercentile(sorted, 0.5),
+          p95: this.calculatePercentile(sorted, 0.95),
+          p99: this.calculatePercentile(sorted, 0.99),
+          max: sorted[sorted.length - 1],
+          min: sorted[0],
+          avg: sum / sorted.length,
+          count: sorted.length
+        };
+      }
+      generateRecommendations(latency, memoryPeak, throughput) {
+        const recommendations = [];
+        if (latency.p95 > 100) {
+          recommendations.push(
+            `P95 coordination latency (${latency.p95.toFixed(1)}ms) exceeds 100ms target. Consider optimizing gossip protocol or reducing agent count.`
+          );
+        }
+        if (latency.p99 > latency.p95 * 2) {
+          recommendations.push(
+            "High P99/P95 ratio indicates latency outliers. Investigate specific agents or network conditions."
+          );
+        }
+        const memoryGB = memoryPeak / 1024 / 1024 / 1024;
+        if (memoryGB > 3) {
+          recommendations.push(
+            `Memory usage (${memoryGB.toFixed(2)}GB) approaching 4GB limit. Consider implementing agent pooling or reducing per-agent memory.`
+          );
+        }
+        if (throughput.tasksPerSecond < 10) {
+          recommendations.push(
+            `Task throughput (${throughput.tasksPerSecond.toFixed(1)}/s) is low. Consider parallelizing task execution or reducing task complexity.`
+          );
+        }
+        if (this.issues.length > 10) {
+          recommendations.push(
+            `${this.issues.length} issues recorded. Review issue log for patterns and prioritize fixes.`
+          );
+        }
+        return recommendations;
+      }
+    };
+  }
+});
+
+// src/testing/load/bottleneck-analyzer.ts
+function createBottleneckAnalyzer(config) {
+  return new BottleneckAnalyzer(config);
+}
+function createBottleneckAnalyzerWithThresholds(thresholds) {
+  return new BottleneckAnalyzer({
+    thresholds: { ...DEFAULT_THRESHOLDS2, ...thresholds }
+  });
+}
+var DEFAULT_THRESHOLDS2, DEFAULT_CONFIG73, BottleneckAnalyzer;
+var init_bottleneck_analyzer = __esm({
+  "src/testing/load/bottleneck-analyzer.ts"() {
+    "use strict";
+    DEFAULT_THRESHOLDS2 = {
+      // Memory (Issue #177: <4GB)
+      memoryWarning: 3 * 1024 * 1024 * 1024,
+      // 3GB
+      memoryCritical: 4 * 1024 * 1024 * 1024,
+      // 4GB
+      // Coordination latency (Issue #177: <100ms p95)
+      latencyP95Warning: 75,
+      latencyP95Critical: 100,
+      latencyP99Warning: 150,
+      latencyP99Critical: 200,
+      // Agent health
+      agentStarvationTime: 3e4,
+      // 30 seconds
+      deadlockTimeout: 6e4,
+      // 60 seconds
+      // Throughput
+      minTasksPerSecond: 5,
+      minAgentUtilization: 0.5,
+      // Gossip protocol
+      gossipConvergenceTime: 5e3,
+      gossipMaxPartitions: 0
+    };
+    DEFAULT_CONFIG73 = {
+      thresholds: DEFAULT_THRESHOLDS2,
+      enableDetailedAnalysis: true
+    };
+    BottleneckAnalyzer = class {
+      config;
+      constructor(config = {}) {
+        this.config = {
+          ...DEFAULT_CONFIG73,
+          ...config,
+          thresholds: {
+            ...DEFAULT_THRESHOLDS2,
+            ...config.thresholds
+          }
+        };
+      }
+      // ============================================================================
+      // Main Analysis Methods
+      // ============================================================================
+      /**
+       * Perform complete bottleneck analysis on collected metrics
+       */
+      analyze(metrics) {
+        const bottlenecks = [];
+        bottlenecks.push(this.checkMemoryPressure(metrics));
+        bottlenecks.push(this.checkCoordinationLatencyP95(metrics));
+        bottlenecks.push(this.checkCoordinationLatencyP99(metrics));
+        bottlenecks.push(this.checkAgentStarvation(metrics));
+        bottlenecks.push(this.checkDeadlocks(metrics));
+        bottlenecks.push(this.checkThroughput(metrics));
+        const detected = bottlenecks.filter((b68) => b68.detected);
+        const summary = {
+          totalChecks: bottlenecks.length,
+          detected: detected.length,
+          critical: detected.filter((b68) => b68.severity === "critical").length,
+          high: detected.filter((b68) => b68.severity === "high").length,
+          medium: detected.filter((b68) => b68.severity === "medium").length,
+          low: detected.filter((b68) => b68.severity === "low").length
+        };
+        let overallSeverity = "low";
+        if (summary.critical > 0) {
+          overallSeverity = "critical";
+        } else if (summary.high > 0) {
+          overallSeverity = "high";
+        } else if (summary.medium > 0) {
+          overallSeverity = "medium";
+        }
+        const recommendations = this.generatePrioritizedRecommendations(detected);
+        return {
+          overallSeverity,
+          hasCritical: summary.critical > 0,
+          bottlenecks,
+          summary,
+          recommendations,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+      /**
+       * Analyze from a load test report
+       */
+      analyzeReport(report) {
+        const bottlenecks = [];
+        bottlenecks.push(this.checkMemoryFromReport(report));
+        bottlenecks.push(this.checkLatencyP95FromReport(report));
+        bottlenecks.push(this.checkLatencyP99FromReport(report));
+        bottlenecks.push(this.checkThroughputFromReport(report));
+        bottlenecks.push(this.checkSuccessCriteria(report));
+        const detected = bottlenecks.filter((b68) => b68.detected);
+        const summary = {
+          totalChecks: bottlenecks.length,
+          detected: detected.length,
+          critical: detected.filter((b68) => b68.severity === "critical").length,
+          high: detected.filter((b68) => b68.severity === "high").length,
+          medium: detected.filter((b68) => b68.severity === "medium").length,
+          low: detected.filter((b68) => b68.severity === "low").length
+        };
+        let overallSeverity = "low";
+        if (summary.critical > 0) {
+          overallSeverity = "critical";
+        } else if (summary.high > 0) {
+          overallSeverity = "high";
+        } else if (summary.medium > 0) {
+          overallSeverity = "medium";
+        }
+        const recommendations = this.generatePrioritizedRecommendations(detected);
+        return {
+          overallSeverity,
+          hasCritical: summary.critical > 0,
+          bottlenecks,
+          summary,
+          recommendations,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+      // ============================================================================
+      // Individual Check Methods
+      // ============================================================================
+      /**
+       * Check for memory pressure
+       */
+      checkMemoryPressure(metrics) {
+        const actual = metrics?.getMaxMemoryUsage() ?? process.memoryUsage().heapUsed;
+        const { memoryWarning, memoryCritical } = this.config.thresholds;
+        const detected = actual >= memoryWarning;
+        let severity = "low";
+        let recommendation = "Memory usage is within acceptable limits.";
+        if (actual >= memoryCritical) {
+          severity = "critical";
+          recommendation = "Memory usage exceeds 4GB limit. Implement agent pooling, reduce per-agent state, or decrease concurrent agent count.";
+        } else if (actual >= memoryWarning) {
+          severity = "high";
+          recommendation = "Memory usage approaching critical threshold. Consider optimizing agent memory footprint or implementing memory pressure relief mechanisms.";
+        }
+        return {
+          detected,
+          severity,
+          metric: "memory_pressure",
+          threshold: memoryCritical,
+          actual,
+          recommendation,
+          context: {
+            usedGB: actual / 1024 / 1024 / 1024,
+            warningThresholdGB: memoryWarning / 1024 / 1024 / 1024,
+            criticalThresholdGB: memoryCritical / 1024 / 1024 / 1024
+          }
+        };
+      }
+      /**
+       * Check coordination latency P95
+       */
+      checkCoordinationLatency() {
+        return this.checkCoordinationLatencyP95();
+      }
+      checkCoordinationLatencyP95(metrics) {
+        const actual = metrics?.getP95CoordinationLatency() ?? 0;
+        const { latencyP95Warning, latencyP95Critical } = this.config.thresholds;
+        const detected = actual >= latencyP95Warning;
+        let severity = "low";
+        let recommendation = "P95 coordination latency is within acceptable limits.";
+        if (actual >= latencyP95Critical) {
+          severity = "critical";
+          recommendation = "P95 coordination latency exceeds 100ms target. Optimize gossip protocol, reduce message size, or implement batching.";
+        } else if (actual >= latencyP95Warning) {
+          severity = "medium";
+          recommendation = "P95 coordination latency approaching target. Monitor closely and consider proactive optimization.";
+        }
+        return {
+          detected,
+          severity,
+          metric: "coordination_latency_p95",
+          threshold: latencyP95Critical,
+          actual,
+          recommendation
+        };
+      }
+      checkCoordinationLatencyP99(metrics) {
+        const actual = metrics?.getP99CoordinationLatency() ?? 0;
+        const { latencyP99Warning, latencyP99Critical } = this.config.thresholds;
+        const detected = actual >= latencyP99Warning;
+        let severity = "low";
+        let recommendation = "P99 coordination latency is within acceptable limits.";
+        if (actual >= latencyP99Critical) {
+          severity = "high";
+          recommendation = "P99 coordination latency indicates outliers. Investigate specific agents or network conditions causing delays.";
+        } else if (actual >= latencyP99Warning) {
+          severity = "medium";
+          recommendation = "P99 coordination latency elevated. Some agents may be experiencing delays.";
+        }
+        return {
+          detected,
+          severity,
+          metric: "coordination_latency_p99",
+          threshold: latencyP99Critical,
+          actual,
+          recommendation
+        };
+      }
+      /**
+       * Check for agent starvation
+       */
+      checkAgentStarvation(metrics) {
+        const hasStarvation = metrics?.hasAgentStarvation() ?? false;
+        return {
+          detected: hasStarvation,
+          severity: hasStarvation ? "high" : "low",
+          metric: "agent_starvation",
+          threshold: this.config.thresholds.agentStarvationTime,
+          actual: hasStarvation ? 1 : 0,
+          recommendation: hasStarvation ? "Agent starvation detected. Agents are idle without tasks. Review task distribution algorithm and work stealing configuration." : "No agent starvation detected."
+        };
+      }
+      /**
+       * Check for deadlocks
+       */
+      checkDeadlocks(metrics) {
+        const hasDeadlocks = metrics?.hasDeadlocks() ?? false;
+        return {
+          detected: hasDeadlocks,
+          severity: hasDeadlocks ? "critical" : "low",
+          metric: "deadlock_detection",
+          threshold: this.config.thresholds.deadlockTimeout,
+          actual: hasDeadlocks ? 1 : 0,
+          recommendation: hasDeadlocks ? "Potential deadlock detected. Tasks running for extended period. Review lock ordering and add timeout mechanisms." : "No deadlocks detected."
+        };
+      }
+      /**
+       * Check gossip protocol stability
+       */
+      checkGossipStability() {
+        return {
+          detected: false,
+          severity: "low",
+          metric: "gossip_stability",
+          threshold: this.config.thresholds.gossipMaxPartitions,
+          actual: 0,
+          recommendation: "Gossip protocol stability check requires integration with gossip metrics."
+        };
+      }
+      /**
+       * Check throughput
+       */
+      checkThroughput(metrics) {
+        const throughput = metrics?.getThroughput();
+        const actual = throughput?.tasksPerSecond ?? 0;
+        const threshold = this.config.thresholds.minTasksPerSecond;
+        const detected = actual < threshold && actual > 0;
+        return {
+          detected,
+          severity: detected ? "medium" : "low",
+          metric: "throughput",
+          threshold,
+          actual,
+          recommendation: detected ? `Task throughput (${actual.toFixed(1)}/s) below minimum (${threshold}/s). Consider parallelizing task execution or optimizing task handlers.` : "Task throughput is acceptable."
+        };
+      }
+      // ============================================================================
+      // Report-based Check Methods
+      // ============================================================================
+      checkMemoryFromReport(report) {
+        const actual = report.resources.memoryPeak;
+        const { memoryCritical } = this.config.thresholds;
+        return {
+          detected: actual >= memoryCritical,
+          severity: actual >= memoryCritical ? "critical" : "low",
+          metric: "memory_pressure",
+          threshold: memoryCritical,
+          actual,
+          recommendation: actual >= memoryCritical ? "Memory exceeded 4GB limit during test." : "Memory usage within limits."
+        };
+      }
+      checkLatencyP95FromReport(report) {
+        const actual = report.performance.coordinationLatency.p95;
+        const { latencyP95Critical } = this.config.thresholds;
+        return {
+          detected: actual >= latencyP95Critical,
+          severity: actual >= latencyP95Critical ? "critical" : "low",
+          metric: "coordination_latency_p95",
+          threshold: latencyP95Critical,
+          actual,
+          recommendation: actual >= latencyP95Critical ? "P95 coordination latency exceeded 100ms target." : "P95 latency within target."
+        };
+      }
+      checkLatencyP99FromReport(report) {
+        const actual = report.performance.coordinationLatency.p99;
+        const { latencyP99Critical } = this.config.thresholds;
+        return {
+          detected: actual >= latencyP99Critical,
+          severity: actual >= latencyP99Critical ? "high" : "low",
+          metric: "coordination_latency_p99",
+          threshold: latencyP99Critical,
+          actual,
+          recommendation: actual >= latencyP99Critical ? "P99 coordination latency indicates significant outliers." : "P99 latency acceptable."
+        };
+      }
+      checkThroughputFromReport(report) {
+        const actual = report.performance.throughput.tasksPerSecond;
+        const threshold = this.config.thresholds.minTasksPerSecond;
+        return {
+          detected: actual < threshold && actual > 0,
+          severity: actual < threshold ? "medium" : "low",
+          metric: "throughput",
+          threshold,
+          actual,
+          recommendation: actual < threshold ? "Throughput below minimum target." : "Throughput acceptable."
+        };
+      }
+      checkSuccessCriteria(report) {
+        const criteria = report.summary.successCriteria;
+        const failedCriteria = Object.entries(criteria).filter(([_56, passed]) => !passed).map(([name]) => name);
+        return {
+          detected: failedCriteria.length > 0,
+          severity: failedCriteria.length > 0 ? "high" : "low",
+          metric: "success_criteria",
+          threshold: 0,
+          actual: failedCriteria.length,
+          recommendation: failedCriteria.length > 0 ? `Failed criteria: ${failedCriteria.join(", ")}` : "All success criteria met.",
+          context: { failedCriteria }
+        };
+      }
+      // ============================================================================
+      // Private Methods
+      // ============================================================================
+      generatePrioritizedRecommendations(detectedBottlenecks) {
+        const priorityMap = {
+          critical: 0,
+          high: 1,
+          medium: 2,
+          low: 3
+        };
+        const sorted = [...detectedBottlenecks].sort(
+          (a37, b68) => priorityMap[a37.severity] - priorityMap[b68.severity]
+        );
+        const seen = /* @__PURE__ */ new Set();
+        const recommendations = [];
+        for (const bottleneck of sorted) {
+          if (!seen.has(bottleneck.recommendation)) {
+            seen.add(bottleneck.recommendation);
+            recommendations.push(
+              `[${bottleneck.severity.toUpperCase()}] ${bottleneck.metric}: ${bottleneck.recommendation}`
+            );
+          }
+        }
+        return recommendations;
+      }
+    };
+  }
+});
+
+// src/testing/load/agent-load-tester.ts
+function createAgentLoadTester(config, metricsConfig, thresholds) {
+  return new AgentLoadTester(config, metricsConfig, thresholds);
+}
+function createLoadTesterForTarget(targetAgents, workloadProfile = "medium") {
+  return new AgentLoadTester({
+    maxAgents: targetAgents,
+    workloadProfile,
+    mockMode: true
+  });
+}
+var DEFAULT_CONFIG74, 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";
+    init_esm_node();
+    init_metrics_collector2();
+    init_error_utils();
+    init_bottleneck_analyzer();
+    DEFAULT_CONFIG74 = {
+      maxAgents: 100,
+      memoryLimit: 4 * 1024 * 1024 * 1024,
+      // 4GB
+      coordinationTimeout: 100,
+      workloadProfile: "medium",
+      mockMode: true
+    };
+    DEFAULT_SUCCESS_CRITERIA = {
+      agentCount: 100,
+      memoryLimit: 4 * 1024 * 1024 * 1024,
+      coordinationLatency: 100,
+      noAgentStarvation: true,
+      noDeadlocks: true,
+      gossipStable: true
+    };
+    WORKLOAD_PROFILES = {
+      light: {
+        taskCount: 5,
+        taskDuration: 50,
+        memoryUsage: 5 * 1024 * 1024,
+        // 5MB
+        coordinationFrequency: 2,
+        durationVariance: 0.1
+      },
+      medium: {
+        taskCount: 10,
+        taskDuration: 100,
+        memoryUsage: 10 * 1024 * 1024,
+        // 10MB
+        coordinationFrequency: 5,
+        durationVariance: 0.2
+      },
+      heavy: {
+        taskCount: 20,
+        taskDuration: 200,
+        memoryUsage: 20 * 1024 * 1024,
+        // 20MB
+        coordinationFrequency: 10,
+        durationVariance: 0.3
+      }
+    };
+    SCENARIO_RAMP_UP_100 = {
+      name: "ramp-up-100",
+      description: "Gradually add agents until reaching 100",
+      steps: [
+        { agents: 25, holdTime: 3e4 },
+        { agents: 50, holdTime: 3e4 },
+        { agents: 75, holdTime: 3e4 },
+        { agents: 100, holdTime: 6e4 }
+      ],
+      workload: WORKLOAD_PROFILES.medium
+    };
+    SCENARIO_BURST_100 = {
+      name: "burst-100",
+      description: "Instantly spawn 100 agents",
+      steps: [{ agents: 100, holdTime: 12e4 }],
+      workload: {
+        taskCount: 20,
+        taskDuration: 50,
+        memoryUsage: 10 * 1024 * 1024,
+        coordinationFrequency: 5
+      }
+    };
+    SCENARIO_CHURN_100 = {
+      name: "churn-100",
+      description: "Maintain 100 agents with continuous spawn/terminate",
+      steps: [{ agents: 100, holdTime: 18e4, churnRate: 0.1 }],
+      workload: {
+        taskCount: 15,
+        taskDuration: 75,
+        memoryUsage: 10 * 1024 * 1024,
+        coordinationFrequency: 5
+      }
+    };
+    SCENARIO_STRESS_150 = {
+      name: "stress-150",
+      description: "Push beyond 100 agents to find limits",
+      steps: [
+        { agents: 100, holdTime: 3e4 },
+        { agents: 125, holdTime: 3e4 },
+        { agents: 150, holdTime: 6e4 }
+      ],
+      workload: WORKLOAD_PROFILES.heavy,
+      criteria: {
+        agentCount: 150
+      }
+    };
+    AgentLoadTester = class {
+      config;
+      metrics;
+      analyzer;
+      running = false;
+      stopRequested = false;
+      // Mock agents for mock mode
+      mockAgents = /* @__PURE__ */ new Map();
+      mockTaskTimers = /* @__PURE__ */ new Map();
+      mockCoordinationTimers = /* @__PURE__ */ new Map();
+      churnTimer = null;
+      // Random number generator (seeded for reproducibility)
+      random;
+      constructor(config = {}, metricsConfig, thresholds) {
+        this.config = { ...DEFAULT_CONFIG74, ...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);
+      }
+      // ============================================================================
+      // Public API
+      // ============================================================================
+      /**
+       * Run a load test with specified agent count and duration
+       */
+      async runTest(agentCount, duration) {
+        const scenario = {
+          name: "custom",
+          description: `Custom test with ${agentCount} agents for ${duration}ms`,
+          steps: [{ agents: agentCount, holdTime: duration }],
+          workload: this.getWorkload()
+        };
+        return this.runScenario(scenario);
+      }
+      /**
+       * Run a predefined load test scenario
+       */
+      async runScenario(scenario) {
+        if (this.running) {
+          throw new Error("Load test already running");
+        }
+        this.running = true;
+        this.stopRequested = false;
+        const startTime = Date.now();
+        try {
+          this.metrics.reset();
+          this.metrics.start();
+          for (const step of scenario.steps) {
+            if (this.stopRequested) break;
+            await this.executeStep(step, scenario.workload);
+          }
+          this.metrics.stop();
+          const report = this.metrics.exportReport();
+          const bottlenecks = this.analyzer.analyzeReport(report);
+          const criteria = { ...DEFAULT_SUCCESS_CRITERIA, ...scenario.criteria };
+          const success = this.evaluateSuccess(report, criteria);
+          return {
+            success,
+            report,
+            bottlenecks,
+            config: this.config,
+            duration: Date.now() - startTime
+          };
+        } catch (error) {
+          this.metrics.stop();
+          return {
+            success: false,
+            report: this.metrics.exportReport(),
+            bottlenecks: this.analyzer.analyze(this.metrics),
+            config: this.config,
+            duration: Date.now() - startTime,
+            error: toErrorMessage(error)
+          };
+        } finally {
+          await this.cleanup();
+          this.running = false;
+        }
+      }
+      /**
+       * Gradually ramp up to target agent count
+       */
+      async rampUp(targetCount, rampDuration) {
+        const currentCount = this.mockAgents.size;
+        const agentsToSpawn = targetCount - currentCount;
+        if (agentsToSpawn <= 0) return;
+        const spawnInterval = rampDuration / agentsToSpawn;
+        const workload = this.getWorkload();
+        for (let i58 = 0; i58 < agentsToSpawn && !this.stopRequested; i58++) {
+          await this.spawnMockAgent(workload);
+          await this.delay(spawnInterval);
+        }
+      }
+      /**
+       * Simulate a single agent's lifecycle
+       */
+      async simulateAgent(agentId, workload) {
+        const startTime = Date.now();
+        let tasksCompleted = 0;
+        let coordinationEvents = 0;
+        for (let i58 = 0; i58 < workload.taskCount && !this.stopRequested; i58++) {
+          const taskId = `${agentId}_task_${i58}`;
+          const taskStart = Date.now();
+          this.metrics.recordTaskStart(agentId, taskId, taskStart);
+          const variance = workload.durationVariance ?? 0.2;
+          const actualDuration = workload.taskDuration * (1 + (this.random() - 0.5) * 2 * variance);
+          await this.delay(actualDuration);
+          this.metrics.recordTaskComplete(agentId, taskId, Date.now() - taskStart);
+          tasksCompleted++;
+          const coordLatency = this.simulateCoordinationLatency();
+          this.metrics.recordCoordination(agentId, coordLatency);
+          coordinationEvents++;
+        }
+        return {
+          agentId,
+          tasksCompleted,
+          totalDuration: Date.now() - startTime,
+          coordinationEvents
+        };
+      }
+      /**
+       * Stop the running test
+       */
+      async stop() {
+        this.stopRequested = true;
+        await this.delay(100);
+        await this.cleanup();
+      }
+      /**
+       * Get current metrics collector
+       */
+      getMetrics() {
+        return this.metrics;
+      }
+      /**
+       * Get current agent count
+       */
+      getAgentCount() {
+        return this.mockAgents.size;
+      }
+      /**
+       * Check if test is running
+       */
+      isRunning() {
+        return this.running;
+      }
+      // ============================================================================
+      // Private Methods - Scenario Execution
+      // ============================================================================
+      async executeStep(step, workload) {
+        const targetAgents = step.agents;
+        const currentAgents = this.mockAgents.size;
+        if (targetAgents > currentAgents) {
+          await this.spawnAgents(targetAgents - currentAgents, workload);
+        } else if (targetAgents < currentAgents) {
+          await this.terminateAgents(currentAgents - targetAgents);
+        }
+        if (step.churnRate && step.churnRate > 0) {
+          this.startChurn(step.churnRate, targetAgents, workload);
+        }
+        await this.hold(step.holdTime);
+        this.stopChurn();
+      }
+      async spawnAgents(count, workload) {
+        const promises2 = [];
+        for (let i58 = 0; i58 < count && !this.stopRequested; i58++) {
+          promises2.push(this.spawnMockAgent(workload));
+          if (promises2.length >= 10) {
+            await Promise.all(promises2);
+            promises2.length = 0;
+            await this.delay(10);
+          }
+        }
+        if (promises2.length > 0) {
+          await Promise.all(promises2);
+        }
+      }
+      async terminateAgents(count) {
+        const agents = Array.from(this.mockAgents.keys()).slice(0, count);
+        for (const agentId of agents) {
+          await this.terminateMockAgent(agentId);
+        }
+      }
+      async hold(duration) {
+        const checkInterval = 100;
+        let elapsed = 0;
+        while (elapsed < duration && !this.stopRequested) {
+          await this.delay(checkInterval);
+          elapsed += checkInterval;
+        }
+      }
+      startChurn(rate, targetCount, workload) {
+        const churnPerMinute = Math.ceil(targetCount * rate);
+        const churnInterval = 6e4 / churnPerMinute;
+        this.churnTimer = setInterval(async () => {
+          if (this.random() < 0.5) {
+            const agents = Array.from(this.mockAgents.keys());
+            if (agents.length > 0) {
+              const randomAgent = agents[Math.floor(this.random() * agents.length)];
+              await this.terminateMockAgent(randomAgent);
+            }
+          }
+          if (this.mockAgents.size < targetCount) {
+            await this.spawnMockAgent(workload);
+          }
+        }, churnInterval);
+      }
+      stopChurn() {
+        if (this.churnTimer) {
+          clearInterval(this.churnTimer);
+          this.churnTimer = null;
+        }
+      }
+      // ============================================================================
+      // Private Methods - Mock Agent Management
+      // ============================================================================
+      async spawnMockAgent(workload) {
+        const agentId = `agent_${v4_default().slice(0, 8)}`;
+        const now = Date.now();
+        const agent = {
+          id: agentId,
+          domain: this.getRandomDomain(),
+          spawnedAt: now,
+          workload,
+          activeTasks: 0,
+          totalTasks: 0,
+          terminated: false
+        };
+        this.mockAgents.set(agentId, agent);
+        this.metrics.recordAgentSpawn(agentId, now);
+        this.startAgentTasks(agent);
+        this.startAgentCoordination(agent);
+        this.simulateMemoryUsage();
+      }
+      async terminateMockAgent(agentId) {
+        const agent = this.mockAgents.get(agentId);
+        if (!agent) return;
+        agent.terminated = true;
+        const taskTimer = this.mockTaskTimers.get(agentId);
+        if (taskTimer) {
+          clearInterval(taskTimer);
+          this.mockTaskTimers.delete(agentId);
+        }
+        const coordTimer = this.mockCoordinationTimers.get(agentId);
+        if (coordTimer) {
+          clearInterval(coordTimer);
+          this.mockCoordinationTimers.delete(agentId);
+        }
+        this.mockAgents.delete(agentId);
+        this.metrics.recordAgentTerminate(agentId, Date.now());
+      }
+      startAgentTasks(agent) {
+        const taskInterval = agent.workload.taskDuration * 1.5;
+        const timer = setInterval(() => {
+          if (agent.terminated || agent.totalTasks >= agent.workload.taskCount) {
+            clearInterval(timer);
+            this.mockTaskTimers.delete(agent.id);
+            return;
+          }
+          const taskId = `${agent.id}_task_${agent.totalTasks}`;
+          const taskStart = Date.now();
+          agent.activeTasks++;
+          agent.totalTasks++;
+          this.metrics.recordTaskStart(agent.id, taskId, taskStart);
+          const variance = agent.workload.durationVariance ?? 0.2;
+          const duration = agent.workload.taskDuration * (1 + (this.random() - 0.5) * 2 * variance);
+          setTimeout(() => {
+            if (!agent.terminated) {
+              agent.activeTasks--;
+              this.metrics.recordTaskComplete(agent.id, taskId, Date.now() - taskStart);
+            }
+          }, duration);
+        }, taskInterval);
+        this.mockTaskTimers.set(agent.id, timer);
+      }
+      startAgentCoordination(agent) {
+        const coordInterval = 1e3 / agent.workload.coordinationFrequency;
+        const timer = setInterval(() => {
+          if (agent.terminated) {
+            clearInterval(timer);
+            this.mockCoordinationTimers.delete(agent.id);
+            return;
+          }
+          const latency = this.simulateCoordinationLatency();
+          this.metrics.recordCoordination(agent.id, latency);
+        }, coordInterval);
+        this.mockCoordinationTimers.set(agent.id, timer);
+      }
+      // ============================================================================
+      // Private Methods - Simulation Helpers
+      // ============================================================================
+      simulateCoordinationLatency() {
+        const baseLatency = 5;
+        const variableLatency = this.random() * 30;
+        const spike = this.random() < 0.05 ? this.random() * 100 : 0;
+        const loadFactor = Math.min(this.mockAgents.size / 100, 2);
+        const loadLatency = loadFactor * 10;
+        return baseLatency + variableLatency + spike + loadLatency;
+      }
+      simulateMemoryUsage() {
+        const agentCount = this.mockAgents.size;
+        const avgMemoryPerAgent = this.getWorkload().memoryUsage;
+        const baseMemory = 50 * 1024 * 1024;
+        const agentMemory = agentCount * avgMemoryPerAgent;
+        const overhead = agentCount * 1024 * 100;
+        const estimatedHeapUsed = baseMemory + agentMemory + overhead;
+        const estimatedHeapTotal = estimatedHeapUsed * 1.5;
+        this.metrics.recordMemoryUsage(estimatedHeapUsed, estimatedHeapTotal);
+      }
+      getRandomDomain() {
+        const domains = [
+          "test-generation",
+          "test-execution",
+          "coverage-analysis",
+          "quality-assessment",
+          "defect-intelligence",
+          "security-compliance"
+        ];
+        return domains[Math.floor(this.random() * domains.length)];
+      }
+      getWorkload() {
+        if (this.config.customWorkload) {
+          return this.config.customWorkload;
+        }
+        return WORKLOAD_PROFILES[this.config.workloadProfile];
+      }
+      evaluateSuccess(report, criteria) {
+        const { summary, performance: performance4 } = report;
+        if (summary.peakAgents < criteria.agentCount) return false;
+        if (report.resources.memoryPeak >= criteria.memoryLimit) return false;
+        if (performance4.coordinationLatency.p95 > criteria.coordinationLatency) return false;
+        if (criteria.noAgentStarvation && !summary.successCriteria.noStarvation) return false;
+        if (criteria.noDeadlocks && !summary.successCriteria.noDeadlocks) return false;
+        return true;
+      }
+      async cleanup() {
+        this.stopChurn();
+        const agents = Array.from(this.mockAgents.keys());
+        for (const agentId of agents) {
+          await this.terminateMockAgent(agentId);
+        }
+        this.mockTaskTimers.forEach((timer) => {
+          clearInterval(timer);
+        });
+        this.mockTaskTimers.clear();
+        this.mockCoordinationTimers.forEach((timer) => {
+          clearInterval(timer);
+        });
+        this.mockCoordinationTimers.clear();
+      }
+      delay(ms) {
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
+      }
+      seededRandom(seed) {
+        return function() {
+          let t50 = seed += 1831565813;
+          t50 = Math.imul(t50 ^ t50 >>> 15, t50 | 1);
+          t50 ^= t50 + Math.imul(t50 ^ t50 >>> 7, t50 | 61);
+          return ((t50 ^ t50 >>> 14) >>> 0) / 4294967296;
+        };
+      }
+    };
+  }
+});
+
+// src/testing/load/index.ts
+var load_exports = {};
+__export(load_exports, {
+  AgentLoadTester: () => AgentLoadTester,
+  BottleneckAnalyzer: () => BottleneckAnalyzer,
+  DEFAULT_ANALYZER_CONFIG: () => DEFAULT_CONFIG73,
+  DEFAULT_LOAD_TEST_CONFIG: () => DEFAULT_CONFIG74,
+  DEFAULT_SUCCESS_CRITERIA: () => DEFAULT_SUCCESS_CRITERIA,
+  DEFAULT_THRESHOLDS: () => DEFAULT_THRESHOLDS2,
+  MetricsCollector: () => MetricsCollector2,
+  SCENARIO_BURST_100: () => SCENARIO_BURST_100,
+  SCENARIO_CHURN_100: () => SCENARIO_CHURN_100,
+  SCENARIO_RAMP_UP_100: () => SCENARIO_RAMP_UP_100,
+  SCENARIO_STRESS_150: () => SCENARIO_STRESS_150,
+  WORKLOAD_PROFILES: () => WORKLOAD_PROFILES,
+  createAgentLoadTester: () => createAgentLoadTester,
+  createBottleneckAnalyzer: () => createBottleneckAnalyzer,
+  createBottleneckAnalyzerWithThresholds: () => createBottleneckAnalyzerWithThresholds,
+  createLoadTesterForTarget: () => createLoadTesterForTarget,
+  createMetricsCollector: () => createMetricsCollector
+});
+var init_load = __esm({
+  "src/testing/load/index.ts"() {
+    "use strict";
+    init_agent_load_tester();
+    init_metrics_collector2();
+    init_bottleneck_analyzer();
+  }
+});
+
+// src/mcp/tools/test-execution/load-test.ts
+var LoadTestTool;
+var init_load_test = __esm({
+  "src/mcp/tools/test-execution/load-test.ts"() {
+    "use strict";
+    init_base();
+    init_error_utils();
+    LoadTestTool = class extends MCPToolBase {
+      config = {
+        name: "qe/tests/load",
+        description: "Run agent load tests to validate fleet scalability. Supports light, medium, and heavy workload profiles. Uses mock agents by default (safe); set mockMode=false to test with real fleet agents (requires fleet_init). Reports bottlenecks and pass/fail criteria.",
+        domain: "test-execution",
+        schema: this.buildSchema(),
+        timeout: 3e5
+      };
+      buildSchema() {
+        return {
+          type: "object",
+          properties: {
+            targetAgents: {
+              type: "number",
+              description: "Target number of concurrent agents to simulate",
+              default: 10,
+              minimum: 1,
+              maximum: 200
+            },
+            profile: {
+              type: "string",
+              description: "Workload profile: light, medium, or heavy",
+              enum: ["light", "medium", "heavy"],
+              default: "medium"
+            },
+            durationMs: {
+              type: "number",
+              description: "Test duration in milliseconds",
+              default: 3e4,
+              minimum: 5e3,
+              maximum: 3e5
+            },
+            mockMode: {
+              type: "boolean",
+              description: "Use mock agents (true, default) or real fleet agents (false, requires fleet_init)",
+              default: true
+            }
+          }
+        };
+      }
+      async execute(params, context) {
+        try {
+          const { createAgentLoadTester: createAgentLoadTester2 } = await Promise.resolve().then(() => (init_load(), load_exports));
+          const profile = params.profile || "medium";
+          const targetAgents = params.targetAgents || 10;
+          const durationMs = params.durationMs || 3e4;
+          const mockMode = params.mockMode !== false;
+          const tester = createAgentLoadTester2({
+            maxAgents: targetAgents,
+            workloadProfile: profile,
+            mockMode
+          });
+          const result = await tester.runTest(targetAgents, durationMs);
+          const bottlenecks = result.bottlenecks;
+          return {
+            success: true,
+            data: {
+              testId: context.requestId,
+              profile,
+              targetAgents,
+              duration: result.duration,
+              mockMode,
+              passed: result.success,
+              bottleneckCount: bottlenecks?.bottlenecks?.length ?? 0,
+              report: {
+                overallSeverity: bottlenecks?.overallSeverity ?? "none",
+                hasCritical: bottlenecks?.hasCritical ?? false,
+                checksPerformed: bottlenecks?.summary?.totalChecks ?? 0,
+                bottlenecksDetected: bottlenecks?.summary?.detected ?? 0
+              },
+              summary: `Load test (${profile}, ${mockMode ? "mock" : "real"}): ${targetAgents} agents, ${durationMs}ms \u2014 ${result.success ? "PASSED" : "FAILED"}` + (bottlenecks?.hasCritical ? " [CRITICAL BOTTLENECKS]" : "")
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: toErrorMessage(error)
+          };
+        }
+      }
+    };
+  }
+});
+
+// src/mcp/tools/security-compliance/visual-security.ts
+var PII_PATTERNS, VisualSecurityTool;
+var init_visual_security = __esm({
+  "src/mcp/tools/security-compliance/visual-security.ts"() {
+    "use strict";
+    init_base();
+    init_error_utils();
+    PII_PATTERNS = [
+      {
+        type: "email",
+        pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+        mask: (m74) => m74[0] + "***@" + m74.split("@")[1]
+      },
+      {
+        type: "ssn",
+        pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
+        mask: () => "***-**-****"
+      },
+      {
+        type: "credit-card",
+        pattern: /\b(?:\d[ -]*?){13,19}\b/g,
+        mask: (m74) => "****-****-****-" + m74.replace(/\D/g, "").slice(-4)
+      },
+      {
+        type: "phone",
+        pattern: /\b(?:\+?1[-.\s]?)?(?:\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}\b/g,
+        mask: (m74) => m74.slice(0, 3) + "***" + m74.slice(-2)
+      },
+      {
+        type: "api-key",
+        // Common API key patterns: long hex/base64 strings in query params
+        pattern: /(?:key|token|api_key|apikey|secret|password|passwd|auth)=([A-Za-z0-9_\-]{16,})/gi,
+        mask: () => "***REDACTED***"
+      }
+    ];
+    VisualSecurityTool = class extends MCPToolBase {
+      config = {
+        name: "qe/security/url-validate",
+        description: "Validate URL security: checks for XSS/injection patterns, unsafe protocols, and scans URL query parameters for PII exposure (emails, SSNs, credit cards, API keys).",
+        domain: "security-compliance",
+        schema: this.buildSchema()
+      };
+      buildSchema() {
+        return {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "URL to validate for security threats and PII exposure"
+            },
+            enablePII: {
+              type: "boolean",
+              description: "Enable PII exposure scanning in URL and query parameters",
+              default: true
+            }
+          },
+          required: ["url"]
+        };
+      }
+      async execute(params, context) {
+        try {
+          const urlSecurity = this.validateURLSecurity(params.url);
+          const piiExposure = params.enablePII !== false ? this.scanForPII(params.url) : { scanned: false, found: false, types: [], details: [] };
+          const issueCount = urlSecurity.issues.length + (piiExposure.found ? piiExposure.types.length : 0);
+          const summary = issueCount === 0 ? `URL passed all checks (security: clean, PII: ${piiExposure.scanned ? "none found" : "not scanned"})` : `URL has ${urlSecurity.issues.length} security issue(s)${piiExposure.found ? ` and ${piiExposure.types.length} PII type(s) exposed in URL` : ""}`;
+          return {
+            success: true,
+            data: {
+              url: params.url,
+              urlSecurity,
+              piiExposure,
+              summary
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: toErrorMessage(error)
+          };
+        }
+      }
+      validateURLSecurity(url) {
+        const issues = [];
+        let riskLevel = "none";
+        try {
+          const parsed = new URL(url);
+          if (!["http:", "https:"].includes(parsed.protocol)) {
+            issues.push({
+              type: "unsafe-protocol",
+              description: `Protocol ${parsed.protocol} is not allowed`,
+              severity: "high"
+            });
+            riskLevel = "high";
+          }
+          const xssPatterns = [/<script/i, /javascript:/i, /on\w+=/i, /data:text\/html/i];
+          for (const pattern of xssPatterns) {
+            if (pattern.test(url)) {
+              issues.push({
+                type: "xss",
+                description: "Potential XSS pattern detected in URL",
+                severity: "critical"
+              });
+              riskLevel = "critical";
+              break;
+            }
+          }
+          const sqlPatterns = [/'.*or.*'/i, /union.*select/i, /drop.*table/i, /;\s*--/i];
+          for (const pattern of sqlPatterns) {
+            if (pattern.test(url)) {
+              issues.push({
+                type: "sql-injection",
+                description: "Potential SQL injection pattern detected in URL",
+                severity: "critical"
+              });
+              riskLevel = "critical";
+              break;
+            }
+          }
+          if (/\.\.[/\\]/.test(url)) {
+            issues.push({
+              type: "path-traversal",
+              description: "Potential path traversal pattern (../) detected",
+              severity: "high"
+            });
+            if (riskLevel !== "critical") riskLevel = "high";
+          }
+          const redirectParams = ["redirect", "url", "next", "return", "returnUrl", "goto"];
+          for (const param of redirectParams) {
+            const value = parsed.searchParams.get(param);
+            if (value && /^https?:\/\//.test(value)) {
+              issues.push({
+                type: "open-redirect",
+                description: `Query parameter "${param}" contains an external URL \u2014 potential open redirect`,
+                severity: "medium"
+              });
+              if (riskLevel === "none") riskLevel = "medium";
+            }
+          }
+        } catch {
+          issues.push({
+            type: "invalid-url",
+            description: "URL could not be parsed",
+            severity: "critical"
+          });
+          riskLevel = "critical";
+        }
+        return { valid: issues.length === 0, riskLevel, issues };
+      }
+      scanForPII(url) {
+        const details = [];
+        const typesFound = /* @__PURE__ */ new Set();
+        let decoded;
+        try {
+          decoded = decodeURIComponent(url);
+        } catch {
+          decoded = url;
+        }
+        let queryString = "";
+        let pathString = "";
+        try {
+          const parsed = new URL(decoded);
+          queryString = parsed.search;
+          pathString = parsed.pathname;
+        } catch {
+          queryString = decoded;
+        }
+        for (const { type, pattern, mask } of PII_PATTERNS) {
+          pattern.lastIndex = 0;
+          let match;
+          while ((match = pattern.exec(decoded)) !== null) {
+            typesFound.add(type);
+            const location = queryString.includes(match[0]) ? "query-parameter" : pathString.includes(match[0]) ? "path" : "url";
+            details.push({
+              type,
+              location,
+              masked: mask(match[0])
+            });
+          }
+        }
+        return {
+          scanned: true,
+          found: typesFound.size > 0,
+          types: Array.from(typesFound),
+          details
+        };
+      }
+    };
+  }
+});
+
+// src/workflows/browser/workflow-loader.ts
+import { readFile as readFile16, readdir as readdir5 } from "fs/promises";
+import { join as join25, basename as basename5 } from "path";
+import { parse as parseYaml2 } from "yaml";
+function interpolateVariables(template, variables) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    const trimmedKey = key.trim();
+    const keys = trimmedKey.split(".");
+    let value = variables;
+    for (const k68 of keys) {
+      if (value && typeof value === "object" && k68 in value) {
+        value = value[k68];
+      } else {
+        return match;
+      }
+    }
+    return value !== void 0 && value !== null ? String(value) : match;
+  });
+}
+function evaluateCondition(condition, context) {
+  const evalContext = {
+    ...context.variables,
+    result: context.results.get("__last_result__")
+  };
+  const interpolated = interpolateVariables(condition, evalContext);
+  return safeEvaluateBoolean(interpolated, evalContext, false);
+}
+var WorkflowLoader, defaultWorkflowLoader;
+var init_workflow_loader = __esm({
+  "src/workflows/browser/workflow-loader.ts"() {
+    "use strict";
+    init_safe_expression_evaluator();
+    WorkflowLoader = class {
+      templatesDir;
+      cache = /* @__PURE__ */ new Map();
+      constructor(templatesDir) {
+        this.templatesDir = templatesDir || join25(__dirname, "templates");
+      }
+      /**
+       * Load a workflow template by name
+       */
+      async load(templateName) {
+        if (this.cache.has(templateName)) {
+          return this.cache.get(templateName);
+        }
+        try {
+          const templatePath = join25(this.templatesDir, `${templateName}.yaml`);
+          const content = await readFile16(templatePath, "utf-8");
+          const workflow = parseYaml2(content);
+          const validation = await this.validate(workflow);
+          if (!validation.valid) {
+            throw new Error(
+              `Invalid workflow template ${templateName}:
+${validation.errors.join("\n")}`
+            );
+          }
+          this.cache.set(templateName, workflow);
+          return workflow;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            throw new Error(`Workflow template not found: ${templateName}`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * List all available workflow templates
+       */
+      async list() {
+        try {
+          const files = await readdir5(this.templatesDir);
+          return files.filter((file) => file.endsWith(".yaml") || file.endsWith(".yml")).map((file) => basename5(file, file.endsWith(".yaml") ? ".yaml" : ".yml")).sort();
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return [];
+          }
+          throw error;
+        }
+      }
+      /**
+       * Validate a workflow template
+       */
+      async validate(workflow) {
+        const errors = [];
+        const warnings = [];
+        if (!workflow.name) {
+          errors.push("Workflow must have a name");
+        }
+        if (!workflow.version) {
+          errors.push("Workflow must have a version");
+        }
+        if (!workflow.description) {
+          warnings.push("Workflow should have a description");
+        }
+        if (!Array.isArray(workflow.variables)) {
+          errors.push("Workflow must have a variables array");
+        } else {
+          workflow.variables.forEach((variable, index) => {
+            if (!variable.name) {
+              errors.push(`Variable at index ${index} must have a name`);
+            }
+            if (!variable.type) {
+              errors.push(`Variable ${variable.name} must have a type`);
+            }
+            if (variable.required === void 0) {
+              warnings.push(`Variable ${variable.name} should specify if it's required`);
+            }
+          });
+        }
+        if (!Array.isArray(workflow.steps)) {
+          errors.push("Workflow must have a steps array");
+        } else if (workflow.steps.length === 0) {
+          errors.push("Workflow must have at least one step");
+        } else {
+          workflow.steps.forEach((step, index) => {
+            if (!step.name) {
+              errors.push(`Step at index ${index} must have a name`);
+            }
+            if (!step.action) {
+              errors.push(`Step ${step.name || index} must have an action`);
+            }
+            if (!step.config || typeof step.config !== "object") {
+              errors.push(`Step ${step.name || index} must have a config object`);
+            }
+            if (step.assertions && Array.isArray(step.assertions)) {
+              step.assertions.forEach((assertion, assertionIndex) => {
+                if (!assertion.condition) {
+                  errors.push(
+                    `Assertion ${assertionIndex} in step ${step.name || index} must have a condition`
+                  );
+                }
+                if (!assertion.message) {
+                  warnings.push(
+                    `Assertion ${assertionIndex} in step ${step.name || index} should have a message`
+                  );
+                }
+              });
+            }
+          });
+          const stepNames = workflow.steps.map((s70) => s70.name);
+          const duplicates = stepNames.filter(
+            (name, index) => stepNames.indexOf(name) !== index
+          );
+          if (duplicates.length > 0) {
+            errors.push(`Duplicate step names found: ${duplicates.join(", ")}`);
+          }
+        }
+        return {
+          valid: errors.length === 0,
+          errors,
+          warnings
+        };
+      }
+      /**
+       * Create a workflow execution context with resolved variables
+       */
+      async createContext(templateName, variables) {
+        const workflow = await this.load(templateName);
+        const missingVars = workflow.variables.filter((v62) => v62.required && !(v62.name in variables)).map((v62) => v62.name);
+        if (missingVars.length > 0) {
+          throw new Error(
+            `Missing required variables: ${missingVars.join(", ")}`
+          );
+        }
+        const resolvedVariables = {};
+        workflow.variables.forEach((varDef) => {
+          if (varDef.name in variables) {
+            resolvedVariables[varDef.name] = variables[varDef.name];
+          } else if ("default" in varDef) {
+            resolvedVariables[varDef.name] = varDef.default;
+          }
+        });
+        return {
+          variables: resolvedVariables,
+          results: /* @__PURE__ */ new Map(),
+          metadata: {
+            startTime: Date.now(),
+            workflow: workflow.name,
+            templateName
+          }
+        };
+      }
+      /**
+       * Get workflow metadata without loading the full workflow
+       */
+      async getMetadata(templateName) {
+        try {
+          const templatePath = join25(this.templatesDir, `${templateName}.yaml`);
+          const content = await readFile16(templatePath, "utf-8");
+          const workflow = parseYaml2(content);
+          return {
+            name: workflow.name,
+            version: workflow.version,
+            description: workflow.description
+          };
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            throw new Error(`Workflow template not found: ${templateName}`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Clear the workflow cache
+       */
+      clearCache() {
+        this.cache.clear();
+      }
+      /**
+       * Reload a specific workflow template
+       */
+      async reload(templateName) {
+        this.cache.delete(templateName);
+        return this.load(templateName);
+      }
+    };
+    defaultWorkflowLoader = new WorkflowLoader();
+  }
+});
+
+// src/workflows/browser/index.ts
+var browser_exports = {};
+__export(browser_exports, {
+  WORKFLOW_CATEGORIES: () => WORKFLOW_CATEGORIES,
+  WORKFLOW_DESCRIPTIONS: () => WORKFLOW_DESCRIPTIONS,
+  WORKFLOW_TEMPLATES: () => WORKFLOW_TEMPLATES,
+  WorkflowLoader: () => WorkflowLoader,
+  defaultWorkflowLoader: () => defaultWorkflowLoader,
+  evaluateCondition: () => evaluateCondition,
+  getAllWorkflowTemplates: () => getAllWorkflowTemplates,
+  getWorkflowsByCategory: () => getWorkflowsByCategory,
+  interpolateVariables: () => interpolateVariables,
+  isValidWorkflowTemplate: () => isValidWorkflowTemplate
+});
+function getWorkflowsByCategory(category) {
+  return WORKFLOW_CATEGORIES[category];
+}
+function isValidWorkflowTemplate(name) {
+  return WORKFLOW_TEMPLATES.includes(name);
+}
+function getAllWorkflowTemplates() {
+  return WORKFLOW_TEMPLATES.map((name) => {
+    const category = Object.entries(WORKFLOW_CATEGORIES).find(
+      ([_56, templates]) => templates.includes(name)
+    )?.[0] || "other";
+    return {
+      name,
+      description: WORKFLOW_DESCRIPTIONS[name],
+      category
+    };
+  });
+}
+var WORKFLOW_TEMPLATES, WORKFLOW_DESCRIPTIONS, WORKFLOW_CATEGORIES;
+var init_browser2 = __esm({
+  "src/workflows/browser/index.ts"() {
+    "use strict";
+    init_workflow_loader();
+    WORKFLOW_TEMPLATES = [
+      "login-flow",
+      "oauth-flow",
+      "scraping-workflow",
+      "visual-regression",
+      "form-validation",
+      "navigation-flow",
+      "api-integration",
+      "performance-audit",
+      "accessibility-audit"
+    ];
+    WORKFLOW_DESCRIPTIONS = {
+      "login-flow": "Authentication testing workflow for login forms with credential validation",
+      "oauth-flow": "OAuth2/OIDC authentication testing workflow with provider integration",
+      "scraping-workflow": "Data extraction workflow for web scraping with pagination and structured output",
+      "visual-regression": "Screenshot comparison workflow for visual regression testing across breakpoints",
+      "form-validation": "Input validation testing workflow for form fields with error handling",
+      "navigation-flow": "Multi-page navigation workflow for testing user journeys and state persistence",
+      "api-integration": "Browser-API hybrid testing workflow for validating frontend-backend integration",
+      "performance-audit": "Lighthouse-style performance audit workflow with Core Web Vitals",
+      "accessibility-audit": "WCAG 2.1 Level AA compliance audit workflow with automated accessibility testing"
+    };
+    WORKFLOW_CATEGORIES = {
+      authentication: ["login-flow", "oauth-flow"],
+      testing: ["form-validation", "navigation-flow", "api-integration"],
+      quality: ["visual-regression", "performance-audit", "accessibility-audit"],
+      automation: ["scraping-workflow"]
+    };
+  }
+});
+
+// src/mcp/tools/test-execution/browser-workflow.ts
+var BrowserWorkflowTool;
+var init_browser_workflow = __esm({
+  "src/mcp/tools/test-execution/browser-workflow.ts"() {
+    "use strict";
+    init_base();
+    init_error_utils();
+    BrowserWorkflowTool = class extends MCPToolBase {
+      config = {
+        name: "qe/workflows/browser-load",
+        description: "Load, validate, and prepare browser automation workflows from inline YAML or built-in templates. Returns the resolved workflow with steps and variable bindings, ready for browser execution. Templates: login-flow, form-validation, visual-regression, oauth-flow, etc.",
+        domain: "test-execution",
+        schema: this.buildSchema()
+      };
+      buildSchema() {
+        return {
+          type: "object",
+          properties: {
+            workflowYaml: {
+              type: "string",
+              description: "Inline YAML workflow definition. Mutually exclusive with templateName."
+            },
+            templateName: {
+              type: "string",
+              description: "Built-in template name to load.",
+              enum: [
+                "login-flow",
+                "oauth-flow",
+                "scraping-workflow",
+                "visual-regression",
+                "form-validation",
+                "navigation-flow",
+                "api-integration",
+                "performance-audit",
+                "accessibility-audit"
+              ]
+            },
+            variables: {
+              type: "object",
+              description: 'Runtime variable overrides (e.g., { "baseUrl": "https://example.com" })'
+            }
+          }
+        };
+      }
+      async execute(params, context) {
+        try {
+          const {
+            WorkflowLoader: WorkflowLoader2,
+            WORKFLOW_TEMPLATES: WORKFLOW_TEMPLATES2,
+            WORKFLOW_DESCRIPTIONS: WORKFLOW_DESCRIPTIONS2,
+            interpolateVariables: interpolateVariables2
+          } = await Promise.resolve().then(() => (init_browser2(), browser_exports));
+          const { parse: parseYaml4 } = await import("yaml");
+          const loader = new WorkflowLoader2();
+          const templateList = [...WORKFLOW_TEMPLATES2];
+          const descriptions = WORKFLOW_DESCRIPTIONS2;
+          if (!params.workflowYaml && !params.templateName) {
+            return {
+              success: true,
+              data: {
+                workflowName: "none",
+                description: "No workflow specified. Use templateName or workflowYaml.",
+                source: "none",
+                templateUsed: null,
+                steps: [],
+                variables: { defined: [], provided: {} },
+                validation: { valid: true, errors: [], warnings: [] },
+                availableTemplates: templateList,
+                summary: `Available templates: ${templateList.join(", ")}`
+              }
+            };
+          }
+          let workflow;
+          let source;
+          let templateUsed = null;
+          if (params.workflowYaml) {
+            source = "inline-yaml";
+            workflow = parseYaml4(params.workflowYaml);
+          } else {
+            source = "template";
+            templateUsed = params.templateName;
+            workflow = await loader.load(params.templateName);
+          }
+          const validation = await loader.validate(workflow);
+          const resolvedSteps = (workflow.steps ?? []).map((step) => {
+            let config = step.config;
+            if (params.variables) {
+              const interpolated = {};
+              for (const [k68, v62] of Object.entries(config)) {
+                interpolated[k68] = typeof v62 === "string" ? interpolateVariables2(v62, params.variables) : v62;
+              }
+              config = interpolated;
+            }
+            return {
+              name: step.name,
+              action: step.action,
+              config,
+              optional: step.optional ?? false,
+              assertionCount: step.assertions?.length ?? 0
+            };
+          });
+          return {
+            success: true,
+            data: {
+              workflowName: workflow.name || templateUsed || "custom",
+              description: workflow.description || (templateUsed ? descriptions[templateUsed] || "" : ""),
+              source,
+              templateUsed,
+              steps: resolvedSteps,
+              variables: {
+                defined: (workflow.variables ?? []).map((v62) => ({
+                  name: v62.name,
+                  type: v62.type,
+                  required: v62.required,
+                  hasDefault: v62.default !== void 0
+                })),
+                provided: params.variables || {}
+              },
+              validation: {
+                valid: validation.valid,
+                errors: validation.errors,
+                warnings: validation.warnings
+              },
+              availableTemplates: templateList,
+              summary: validation.valid ? `Workflow "${workflow.name}" loaded (${source}): ${resolvedSteps.length} steps, ${(workflow.variables ?? []).length} variables` : `Workflow "${workflow.name}" has validation errors: ${validation.errors.join("; ")}`
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: toErrorMessage(error)
+          };
+        }
+      }
+    };
+  }
+});
+
 // src/mcp/tools/registry.ts
 function resetAllToolCaches() {
   for (const tool of QE_TOOLS) {
@@ -156741,6 +160276,10 @@ var init_registry = __esm({
     init_embeddings2();
     init_coherence3();
     init_analyze2();
+    init_schedule();
+    init_load_test();
+    init_visual_security();
+    init_browser_workflow();
     QE_TOOL_NAMES = {
       // Test Generation
       TEST_GENERATE: "qe/tests/generate",
@@ -156787,7 +160326,15 @@ var init_registry = __esm({
       // Coherence Tools (ADR-052)
       ...COHERENCE_TOOL_NAMES,
       // QX Analysis (Quality Experience)
-      QX_ANALYZE: "qe/qx/analyze"
+      QX_ANALYZE: "qe/qx/analyze",
+      // Test Scheduling (pipeline, git-aware, flaky tracking)
+      TEST_SCHEDULE: "qe/tests/schedule",
+      // Load Testing (agent fleet scalability)
+      LOAD_TEST: "qe/tests/load",
+      // URL Security Validation (threat detection, PII exposure scanning)
+      URL_VALIDATE: "qe/security/url-validate",
+      // Browser Workflow Loader (YAML template loading and validation)
+      BROWSER_WORKFLOW: "qe/workflows/browser-load"
     };
     QE_TOOLS = [
       // Test Generation Domain
@@ -156835,7 +160382,15 @@ var init_registry = __esm({
       // Coherence Tools (ADR-052)
       ...COHERENCE_TOOLS,
       // QX Analysis (Quality Experience)
-      new QXAnalyzeTool()
+      new QXAnalyzeTool(),
+      // Test Scheduling (pipeline, git-aware, flaky tracking)
+      new TestScheduleTool(),
+      // Load Testing (agent fleet scalability)
+      new LoadTestTool(),
+      // Security-Visual Audit (URL validation, PII detection)
+      new VisualSecurityTool(),
+      // Browser Workflows (YAML template execution)
+      new BrowserWorkflowTool()
     ];
   }
 });
@@ -157367,7 +160922,7 @@ var init_protocol_executor = __esm({
        * Sleep helper
        */
       sleep(ms) {
-        return new Promise((resolve9) => setTimeout(resolve9, ms));
+        return new Promise((resolve10) => setTimeout(resolve10, ms));
       }
     };
   }
@@ -158611,6 +162166,178 @@ var init_task_handlers = __esm({
   }
 });
 
+// src/monitoring/structural-health.ts
+var structural_health_exports = {};
+__export(structural_health_exports, {
+  DEFAULT_STRUCTURAL_HEALTH_CONFIG: () => DEFAULT_STRUCTURAL_HEALTH_CONFIG,
+  StructuralHealthMonitor: () => StructuralHealthMonitor,
+  createStructuralHealthMonitor: () => createStructuralHealthMonitor
+});
+function createStructuralHealthMonitor(config) {
+  return new StructuralHealthMonitor(config);
+}
+var DEFAULT_STRUCTURAL_HEALTH_CONFIG, StructuralHealthMonitor;
+var init_structural_health = __esm({
+  "src/monitoring/structural-health.ts"() {
+    "use strict";
+    init_mincut_wrapper();
+    DEFAULT_STRUCTURAL_HEALTH_CONFIG = {
+      healthyThreshold: 0.4,
+      warningThreshold: 0.2,
+      maxHistoryEntries: 100,
+      enableLogging: false
+    };
+    StructuralHealthMonitor = class {
+      config;
+      minCutService;
+      history = [];
+      constructor(config) {
+        this.config = { ...DEFAULT_STRUCTURAL_HEALTH_CONFIG, ...config };
+        this.minCutService = createQEMinCutService();
+      }
+      /**
+       * Compute fleet health from an array of agent nodes
+       *
+       * @param agents - Current agent fleet
+       * @returns Fleet health result
+       */
+      computeFleetHealth(agents) {
+        if (agents.length === 0) {
+          return this.emptyFleetResult();
+        }
+        const graph = this.minCutService.buildTaskGraphFromTopology(agents);
+        return this.computeFleetHealthFromGraph(graph, agents.length);
+      }
+      /**
+       * Compute fleet health from a pre-built task graph
+       *
+       * @param graph - Task graph representing the fleet
+       * @param agentCount - Number of agents (for history tracking)
+       * @returns Fleet health result
+       */
+      computeFleetHealthFromGraph(graph, agentCount) {
+        if (graph.nodes.length === 0) {
+          return this.emptyFleetResult();
+        }
+        const healthReport = this.minCutService.getStructuralHealth(graph);
+        const status = this.determineStatus(healthReport.normalizedLambda);
+        const result = {
+          lambda: healthReport.lambda,
+          healthy: healthReport.healthy,
+          weakPoints: healthReport.weakPoints,
+          normalizedLambda: healthReport.normalizedLambda,
+          riskScore: healthReport.riskScore,
+          status,
+          suggestions: healthReport.suggestions,
+          measuredAt: /* @__PURE__ */ new Date()
+        };
+        this.addHistoryEntry({
+          lambda: healthReport.lambda,
+          healthy: healthReport.healthy,
+          weakPointCount: healthReport.weakPoints.length,
+          agentCount: agentCount ?? graph.nodes.length,
+          timestamp: result.measuredAt
+        });
+        if (this.config.enableLogging) {
+          this.logHealth(result);
+        }
+        return result;
+      }
+      /**
+       * Get health trend from history
+       *
+       * @returns 'improving', 'stable', or 'degrading'
+       */
+      getTrend() {
+        if (this.history.length < 2) {
+          return "stable";
+        }
+        const recentCount = Math.min(5, this.history.length);
+        const recent = this.history.slice(-recentCount);
+        const firstLambda = recent[0].lambda;
+        const lastLambda = recent[recent.length - 1].lambda;
+        const delta = lastLambda - firstLambda;
+        if (Math.abs(delta) < 0.05) {
+          return "stable";
+        }
+        return delta > 0 ? "improving" : "degrading";
+      }
+      /**
+       * Get health history
+       *
+       * @param limit - Maximum entries to return
+       * @returns Array of history entries, most recent last
+       */
+      getHistory(limit) {
+        const entries = [...this.history];
+        if (limit !== void 0 && limit < entries.length) {
+          return entries.slice(-limit);
+        }
+        return entries;
+      }
+      /**
+       * Clear health history
+       */
+      clearHistory() {
+        this.history.length = 0;
+      }
+      /**
+       * Get the underlying QEMinCutService
+       */
+      getMinCutService() {
+        return this.minCutService;
+      }
+      // ==========================================================================
+      // Private Helpers
+      // ==========================================================================
+      /**
+       * Determine status string from normalized lambda
+       */
+      determineStatus(normalizedLambda) {
+        if (normalizedLambda >= this.config.healthyThreshold) {
+          return "healthy";
+        }
+        if (normalizedLambda >= this.config.warningThreshold) {
+          return "warning";
+        }
+        return "critical";
+      }
+      /**
+       * Add an entry to the history, trimming if over limit
+       */
+      addHistoryEntry(entry) {
+        this.history.push(entry);
+        if (this.history.length > this.config.maxHistoryEntries) {
+          this.history.splice(0, this.history.length - this.config.maxHistoryEntries);
+        }
+      }
+      /**
+       * Create result for empty fleet
+       */
+      emptyFleetResult() {
+        return {
+          lambda: 0,
+          healthy: false,
+          weakPoints: [],
+          normalizedLambda: 0,
+          riskScore: 1,
+          status: "empty",
+          suggestions: ["No agents in fleet. Spawn agents to build a topology."],
+          measuredAt: /* @__PURE__ */ new Date()
+        };
+      }
+      /**
+       * Log health check result to stderr
+       */
+      logHealth(result) {
+        console.error(
+          `[StructuralHealth] Status: ${result.status} | Lambda: ${result.normalizedLambda.toFixed(3)} | Weak points: ${result.weakPoints.length} | Risk: ${(result.riskScore * 100).toFixed(0)}%`
+        );
+      }
+    };
+  }
+});
+
 // src/mcp/handlers/core-handlers.ts
 function getFleetState() {
   return state;
@@ -158873,6 +162600,36 @@ async function handleFleetHealth(params) {
         timestamp: issue.timestamp.toISOString()
       }));
     }
+    try {
+      const { StructuralHealthMonitor: StructuralHealthMonitor2 } = await Promise.resolve().then(() => (init_structural_health(), structural_health_exports));
+      const monitor = new StructuralHealthMonitor2();
+      const allAgents = [];
+      for (const [domain] of health.domainHealth) {
+        const domainAgents = state.queen.getAgentsByDomain(domain);
+        for (const a37 of domainAgents) {
+          allAgents.push({ id: a37.id, name: a37.name, domain: a37.domain });
+        }
+      }
+      const agentNodes = allAgents.map((a37) => ({
+        id: a37.id,
+        name: a37.name,
+        domain: a37.domain,
+        capabilities: [a37.domain],
+        dependsOn: [],
+        weight: 1
+      }));
+      const structuralHealth = monitor.computeFleetHealth(agentNodes);
+      result.structuralHealth = {
+        lambda: structuralHealth.lambda,
+        healthy: structuralHealth.healthy,
+        normalizedLambda: structuralHealth.normalizedLambda,
+        riskScore: structuralHealth.riskScore,
+        status: structuralHealth.status,
+        weakPoints: structuralHealth.weakPoints,
+        suggestions: structuralHealth.suggestions
+      };
+    } catch {
+    }
     return {
       success: true,
       data: result
@@ -158976,7 +162733,7 @@ async function handleAQEHealth() {
       success: true,
       data: {
         status: healthStatus,
-        version: true ? "3.7.5" : "3.7.2",
+        version: true ? "3.7.6" : "3.7.2",
         loadedDomains: domainCount,
         memory: memoryStats,
         hnsw: hnswStats,
@@ -159302,17 +163059,17 @@ var StdioTransport = class {
   async writeOnce(data) {
     const message = data + "\n";
     if (this.outputStream.writableNeedDrain) {
-      await new Promise((resolve9, reject) => {
+      await new Promise((resolve10, reject) => {
         const drainTimeout = setTimeout(() => {
           reject(new Error("Transport drain timeout after 30 seconds"));
         }, 3e4);
         this.outputStream.once("drain", () => {
           clearTimeout(drainTimeout);
-          resolve9();
+          resolve10();
         });
       });
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const writeTimeout = setTimeout(() => {
         this.metrics.errors++;
         reject(new Error("Transport write timeout after 120 seconds"));
@@ -159325,7 +163082,7 @@ var StdioTransport = class {
         } else {
           this.metrics.messagesSent++;
           this.metrics.bytesSent += Buffer.byteLength(message, "utf-8");
-          resolve9();
+          resolve10();
         }
       });
     });
@@ -159856,7 +163613,7 @@ var SSETransport = class {
     if (!this.config.parseBody) {
       throw new Error("Request body parsing is disabled");
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const chunks = [];
       let size = 0;
       req.on("data", (chunk) => {
@@ -159875,7 +163632,7 @@ var SSETransport = class {
             return;
           }
           const parsed = safeJsonParse(body);
-          resolve9(parsed);
+          resolve10(parsed);
         } catch (error) {
           reject(new Error("Invalid JSON in request body"));
         }
@@ -160578,7 +164335,7 @@ var WebSocketTransport = class extends EventEmitter2 {
    * Handle a manual WebSocket upgrade (for testing or custom servers)
    */
   handleUpgrade(request, socket, head) {
-    return new Promise(async (resolve9, reject) => {
+    return new Promise(async (resolve10, reject) => {
       if (this.disposed) {
         socket.write("HTTP/1.1 503 Service Unavailable\r\n\r\n");
         socket.destroy();
@@ -160606,7 +164363,7 @@ var WebSocketTransport = class extends EventEmitter2 {
         };
         this.wsServer.handleUpgrade(request, socket, head, (ws) => {
           this.wsServer.emit("connection", ws, request, upgradeInfo);
-          resolve9();
+          resolve10();
         });
       } catch (error) {
         socket.write("HTTP/1.1 500 Internal Server Error\r\n\r\n");
@@ -164316,6 +168073,72 @@ async function handleMemoryShare(params) {
 init_cross_phase_memory();
 init_cross_phase_hooks();
 
+// src/mcp/qe-tool-bridge.ts
+init_registry();
+var ALREADY_REGISTERED = /* @__PURE__ */ new Set([
+  "qe/tests/generate",
+  // → test_generate_enhanced
+  "qe/tests/execute",
+  // → test_execute_parallel
+  "qe/coverage/analyze",
+  // → coverage_analyze_sublinear
+  "qe/quality/evaluate",
+  // → quality_assess
+  "qe/defects/predict",
+  // → defect_predict
+  "qe/requirements/validate",
+  // → requirements_validate
+  "qe/code/analyze",
+  // → code_index
+  "qe/security/scan",
+  // → security_scan_comprehensive
+  "qe/contracts/validate",
+  // → contract_validate
+  "qe/a11y/audit",
+  // → accessibility_test
+  "qe/chaos/inject"
+  // → chaos_test
+]);
+function schemaToParameters(tool) {
+  const schema = tool.getSchema();
+  const requiredSet = new Set(schema.required || []);
+  const params = [];
+  for (const [name, prop] of Object.entries(schema.properties)) {
+    params.push({
+      name,
+      type: prop.type,
+      description: prop.description,
+      required: requiredSet.has(name) || void 0,
+      default: prop.default,
+      enum: prop.enum
+    });
+  }
+  return params;
+}
+function registerMissingQETools(registerFn) {
+  let count = 0;
+  for (const tool of QE_TOOLS) {
+    if (ALREADY_REGISTERED.has(tool.name)) {
+      continue;
+    }
+    const entry = {
+      definition: {
+        name: tool.name,
+        description: tool.description,
+        category: "domain",
+        parameters: schemaToParameters(tool)
+      },
+      handler: async (params) => {
+        const result = await tool.invoke(params);
+        return result;
+      }
+    };
+    registerFn(entry);
+    count++;
+  }
+  return count;
+}
+
 // src/mcp/connection-pool.ts
 import { randomUUID as randomUUID25 } from "crypto";
 var DEFAULT_POOL_CONFIG = {
@@ -164384,8 +168207,8 @@ var ConnectionPoolImpl = class {
    * This is the recommended method when concurrent access is expected
    */
   acquireAsync() {
-    return new Promise((resolve9) => {
-      this.acquireQueue.push(resolve9);
+    return new Promise((resolve10) => {
+      this.acquireQueue.push(resolve10);
       this.processAcquireQueue();
     });
   }
@@ -164397,10 +168220,10 @@ var ConnectionPoolImpl = class {
       return;
     }
     this.acquireLock = true;
-    const resolve9 = this.acquireQueue.shift();
+    const resolve10 = this.acquireQueue.shift();
     try {
       const conn = this.doAcquire();
-      resolve9(conn);
+      resolve10(conn);
     } finally {
       this.acquireLock = false;
       if (this.acquireQueue.length > 0) {
@@ -164984,10 +168807,10 @@ var MCPProtocolServer = class {
         this.reconnecting = false;
         const buffered2 = [...this.pendingRequests];
         this.pendingRequests = [];
-        for (const { resolve: resolve9, request } of buffered2) {
+        for (const { resolve: resolve10, request } of buffered2) {
           try {
             const result = await this.handleRequest(request);
-            resolve9(result);
+            resolve10(result);
           } catch (err4) {
             console.error(`[MCP] Failed to replay buffered request: ${request.method}`);
           }
@@ -165677,7 +169500,8 @@ var MCPProtocolServer = class {
       },
       handler: () => handleAQEHealth()
     });
-    console.error(`[MCP] Registered ${this.tools.size} tools`);
+    const bridgedCount = registerMissingQETools((entry) => this.registerTool(entry));
+    console.error(`[MCP] Registered ${this.tools.size} tools (${bridgedCount} via QE bridge)`);
   }
   registerTool(entry) {
     this.tools.set(entry.definition.name, entry);
@@ -165726,7 +169550,7 @@ async function quickStart(config) {
 // src/mcp/http-server.ts
 init_safe_json();
 import { createServer } from "http";
-import { join as join26, dirname as dirname8 } from "path";
+import { join as join27, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/adapters/a2a/agent-cards/schema.ts
@@ -168804,7 +172628,7 @@ var WebhookService = class extends EventEmitter7 {
    * Sleep for a specified duration
    */
   sleep(ms) {
-    return new Promise((resolve9) => setTimeout(resolve9, ms));
+    return new Promise((resolve10) => setTimeout(resolve10, ms));
   }
 };
 function createWebhookService(config = {}) {
@@ -168818,8 +172642,8 @@ init_error_utils();
 
 // src/adapters/a2a/agent-cards/generator.ts
 init_error_utils();
-import { readFile as readFile16, readdir as readdir5, stat as stat5 } from "fs/promises";
-import { join as join25, basename as basename4 } from "path";
+import { readFile as readFile17, readdir as readdir6, stat as stat5 } from "fs/promises";
+import { join as join26, basename as basename6 } from "path";
 var DEFAULT_GENERATOR_CONFIG = {
   baseUrl: "http://localhost:8080",
   defaultVersion: "3.0.0",
@@ -169154,8 +172978,8 @@ var AgentCardGenerator = class {
    * Generate an agent card from a markdown file path
    */
   async generateFromFile(filePath) {
-    const markdown = await readFile16(filePath, "utf-8");
-    const agentId = basename4(filePath, ".md");
+    const markdown = await readFile17(filePath, "utf-8");
+    const agentId = basename6(filePath, ".md");
     return this.generateFromMarkdown(markdown, agentId);
   }
   /**
@@ -169166,9 +172990,9 @@ var AgentCardGenerator = class {
     const cards = /* @__PURE__ */ new Map();
     const errors = /* @__PURE__ */ new Map();
     const processDirectory = async (dirPath) => {
-      const entries = await readdir5(dirPath);
+      const entries = await readdir6(dirPath);
       for (const entry of entries) {
-        const fullPath = join25(dirPath, entry);
+        const fullPath = join26(dirPath, entry);
         const stats = await stat5(fullPath);
         if (stats.isDirectory() && recursive) {
           await processDirectory(fullPath);
@@ -170627,8 +174451,8 @@ var HTTPServerImpl = class {
     this.skipAgentCardLoading = config.skipAgentCardLoading ?? false;
     this.skipCRDTInit = config.skipCRDTInit ?? false;
     this.enableWebSocket = config.enableWebSocket ?? true;
-    const currentDir = dirname8(fileURLToPath3(import.meta.url));
-    this.agentMarkdownDir = config.agentMarkdownDir ?? join26(currentDir, "../../assets/agents/v3");
+    const currentDir = dirname9(fileURLToPath3(import.meta.url));
+    this.agentMarkdownDir = config.agentMarkdownDir ?? join27(currentDir, "../../assets/agents/v3");
     this.taskStore = createTaskStore();
     this.taskManager = config.taskManager ?? createTaskManager({
       storeConfig: {}
@@ -170782,7 +174606,7 @@ var HTTPServerImpl = class {
     });
     try {
       this.taskManager.startTask(task.id);
-      await new Promise((resolve9) => setTimeout(resolve9, 100));
+      await new Promise((resolve10) => setTimeout(resolve10, 100));
       if (!signal.aborted) {
         this.taskManager.completeTask(task.id, [
           this.taskManager.createTextArtifact(
@@ -171117,7 +174941,7 @@ var HTTPServerImpl = class {
   // Helpers
   // ============================================================================
   async parseBody(req) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const chunks = [];
       let size = 0;
       const maxSize = 1024 * 1024;
@@ -171133,10 +174957,10 @@ var HTTPServerImpl = class {
         try {
           const body = Buffer.concat(chunks).toString("utf-8");
           if (!body) {
-            resolve9({});
+            resolve10({});
             return;
           }
-          resolve9(safeJsonParse(body));
+          resolve10(safeJsonParse(body));
         } catch (error) {
           reject(new Error("Invalid JSON in request body"));
         }
@@ -171185,7 +175009,7 @@ var HTTPServerImpl = class {
         logger21.warn("Failed to load agent cards", { error });
       }
     }
-    return new Promise(async (resolve9, reject) => {
+    return new Promise(async (resolve10, reject) => {
       this.server = createServer((req, res) => {
         this.handleHttpRequest(req, res).catch((error) => {
           logger21.error("Request error", error instanceof Error ? error : new Error(String(error)));
@@ -171230,7 +175054,7 @@ var HTTPServerImpl = class {
           console.error(`[AQE]   Hot reload enabled for agent cards`);
         }
         console.error(`[AQE]   GET  /health                - Health check`);
-        resolve9();
+        resolve10();
       });
     });
   }
@@ -171250,12 +175074,12 @@ var HTTPServerImpl = class {
     if (!this.running || !this.server) {
       return;
     }
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       this.server.close(() => {
         this.running = false;
         this.server = null;
         console.error("[AQE] HTTP server stopped");
-        resolve9();
+        resolve10();
       });
       this.sseTransport.dispose();
       if (this.webSocketTransport) {
@@ -171367,7 +175191,7 @@ async function createDefaultMemoryBackend(autoInitialize = true) {
 }
 
 // src/init/token-bootstrap.ts
-var DEFAULT_CONFIG70 = {
+var DEFAULT_CONFIG75 = {
   enableOptimization: true,
   enablePersistence: true,
   storagePath: process.env.AQE_STORAGE_PATH ?? ".aqe",
@@ -171381,7 +175205,7 @@ async function bootstrapTokenTracking(config) {
   if (initialized) {
     return;
   }
-  const cfg = { ...DEFAULT_CONFIG70, ...config };
+  const cfg = { ...DEFAULT_CONFIG75, ...config };
   if (cfg.verbose) {
     console.log("[TokenBootstrap] Initializing token tracking...");
   }
@@ -171920,7 +175744,7 @@ function createTestOutputObserver(customSignatures) {
 
 // src/strange-loop/infra-healing/recovery-playbook.ts
 import * as fs25 from "node:fs/promises";
-import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml3 } from "yaml";
 var RecoveryPlaybook = class {
   config = null;
   variables;
@@ -171938,7 +175762,7 @@ var RecoveryPlaybook = class {
    * Load playbook from a YAML string (for testing or inline config).
    */
   loadFromString(yamlContent) {
-    const raw = parseYaml2(yamlContent);
+    const raw = parseYaml3(yamlContent);
     this.config = this.parsePlaybook(raw);
   }
   /**
@@ -172126,7 +175950,7 @@ var ShellCommandRunner = class {
   async run(command, timeoutMs) {
     const { execFile: execFile3 } = await import("node:child_process");
     const startTime = Date.now();
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const child = execFile3(
         "/bin/sh",
         ["-c", command],
@@ -172136,7 +175960,7 @@ var ShellCommandRunner = class {
           const timedOut = (error?.message?.includes("TIMEOUT") || error?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") ?? false;
           const errWithCode = error;
           const exitCode = error ? typeof errWithCode?.code === "number" ? errWithCode.code : 1 : 0;
-          resolve9({
+          resolve10({
             exitCode,
             stdout: stdout ?? "",
             stderr: stderr ?? "",
@@ -172146,7 +175970,7 @@ var ShellCommandRunner = class {
         }
       );
       child.on("error", () => {
-        resolve9({
+        resolve10({
           exitCode: 1,
           stdout: "",
           stderr: "Process execution error",
@@ -172301,7 +176125,7 @@ var InfraActionExecutor = class {
     this.stats.byService[serviceName][field]++;
   }
   sleep(ms) {
-    return new Promise((resolve9) => setTimeout(resolve9, ms));
+    return new Promise((resolve10) => setTimeout(resolve10, ms));
   }
 };
 function createInfraActionExecutor(runner, playbook, lock) {
@@ -172515,7 +176339,7 @@ init_global_instance();
 
 // src/mcp/entry.ts
 import { readFileSync as readFileSync16 } from "node:fs";
-import { resolve as resolve8, dirname as dirname9 } from "node:path";
+import { resolve as resolve9, dirname as dirname10 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var require2 = createRequire11(import.meta.url);
 var pkg = require2("../../package.json");
@@ -172587,8 +176411,8 @@ async function main() {
     originalStderrWrite("[MCP] Initializing infra-healing...\n");
     try {
       const __filename2 = fileURLToPath4(import.meta.url);
-      const __dirname2 = dirname9(__filename2);
-      const playbookPath = resolve8(__dirname2, "../strange-loop/infra-healing/default-playbook.yaml");
+      const __dirname2 = dirname10(__filename2);
+      const playbookPath = resolve9(__dirname2, "../strange-loop/infra-healing/default-playbook.yaml");
       let playbookContent;
       try {
         playbookContent = readFileSync16(playbookPath, "utf-8");