agentic-qe 3.7.6 → 3.7.7

package/dist/mcp/bundle.js

@@ -44957,6 +44957,499 @@ var init_client = __esm({
   }
 });
 
+// src/integrations/browser/stealth/stealth-types.ts
+var DEFAULT_STEALTH_CONFIG;
+var init_stealth_types = __esm({
+  "src/integrations/browser/stealth/stealth-types.ts"() {
+    "use strict";
+    DEFAULT_STEALTH_CONFIG = {
+      persistentContext: true,
+      cloudflareWaitSeconds: 0,
+      resourceBlocking: "functional"
+    };
+  }
+});
+
+// src/integrations/browser/resource-blocking.ts
+function shouldBlockRequest(url, resourceType, config) {
+  if (!config.enabled) {
+    return false;
+  }
+  if (config.allowPatterns?.length) {
+    for (const pattern of config.allowPatterns) {
+      if (urlMatchesPattern(url, pattern)) {
+        return false;
+      }
+    }
+  }
+  if (config.blockPatterns?.length) {
+    for (const pattern of config.blockPatterns) {
+      if (urlMatchesPattern(url, pattern)) {
+        return true;
+      }
+    }
+  }
+  const category = RESOURCE_TYPE_TO_CATEGORY[resourceType];
+  if (category && config.blockedCategories.includes(category)) {
+    return true;
+  }
+  if (config.blockedCategories.includes("tracking") && isDomainInSet(url, TRACKING_DOMAINS)) {
+    return true;
+  }
+  if (config.blockedCategories.includes("advertising") && isDomainInSet(url, ADVERTISING_DOMAINS)) {
+    return true;
+  }
+  return false;
+}
+function getResourceBlockingPreset(name) {
+  if (typeof name === "object") {
+    return name;
+  }
+  const preset = PRESETS[name];
+  if (!preset) {
+    return PRESETS.visual;
+  }
+  return { ...preset, blockedCategories: [...preset.blockedCategories] };
+}
+function urlMatchesPattern(url, pattern) {
+  let regex = patternCache.get(pattern);
+  if (!regex) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    regex = new RegExp(escaped, "i");
+    patternCache.set(pattern, regex);
+  }
+  return regex.test(url);
+}
+function isDomainInSet(url, domains) {
+  try {
+    const hostname = new URL(url).hostname;
+    for (const domain of domains) {
+      if (hostname === domain || hostname.endsWith(`.${domain}`)) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+var TRACKING_DOMAINS, ADVERTISING_DOMAINS, RESOURCE_TYPE_TO_CATEGORY, PRESETS, patternCache;
+var init_resource_blocking = __esm({
+  "src/integrations/browser/resource-blocking.ts"() {
+    "use strict";
+    TRACKING_DOMAINS = /* @__PURE__ */ new Set([
+      "google-analytics.com",
+      "googletagmanager.com",
+      "analytics.google.com",
+      "hotjar.com",
+      "fullstory.com",
+      "segment.io",
+      "segment.com",
+      "mixpanel.com",
+      "heap.io",
+      "heapanalytics.com",
+      "amplitude.com",
+      "mouseflow.com",
+      "crazyegg.com",
+      "optimizely.com",
+      "newrelic.com",
+      "nr-data.net",
+      "sentry.io",
+      "bugsnag.com",
+      "logrocket.com",
+      "clarity.ms",
+      "facebook.net",
+      "connect.facebook.net"
+    ]);
+    ADVERTISING_DOMAINS = /* @__PURE__ */ new Set([
+      "doubleclick.net",
+      "googlesyndication.com",
+      "googleadservices.com",
+      "google-analytics.com",
+      "adservice.google.com",
+      "pagead2.googlesyndication.com",
+      "ads.twitter.com",
+      "ads-api.twitter.com",
+      "adsserver.com",
+      "adnxs.com",
+      "amazon-adsystem.com",
+      "criteo.com",
+      "moatads.com",
+      "outbrain.com",
+      "taboola.com",
+      "bidswitch.net",
+      "rubiconproject.com"
+    ]);
+    RESOURCE_TYPE_TO_CATEGORY = {
+      image: "image",
+      font: "font",
+      media: "media",
+      stylesheet: "stylesheet",
+      websocket: "websocket"
+    };
+    PRESETS = {
+      /**
+       * Functional preset: block everything non-essential for functional testing.
+       * Fastest page loads — only HTML, JS, and XHR/fetch are allowed.
+       */
+      functional: {
+        enabled: true,
+        blockedCategories: ["image", "font", "media", "stylesheet", "tracking", "advertising"]
+      },
+      /**
+       * Visual preset: block nothing — needed for visual regression testing.
+       */
+      visual: {
+        enabled: false,
+        blockedCategories: []
+      },
+      /**
+       * Performance preset: block heavy resources and tracking only.
+       * Keeps stylesheets for layout accuracy but drops images/fonts/media.
+       */
+      performance: {
+        enabled: true,
+        blockedCategories: ["image", "font", "media", "tracking", "advertising"]
+      }
+    };
+    patternCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/integrations/browser/stealth/stealth-client.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function getPatchright() {
+  if (patchrightChecked) return patchrightModule;
+  patchrightChecked = true;
+  try {
+    patchrightModule = __require("patchright");
+  } catch {
+    patchrightModule = null;
+  }
+  return patchrightModule;
+}
+var patchrightModule, patchrightChecked, StealthBrowserClient;
+var init_stealth_client = __esm({
+  "src/integrations/browser/stealth/stealth-client.ts"() {
+    "use strict";
+    init_types5();
+    init_stealth_types();
+    init_resource_blocking();
+    patchrightModule = null;
+    patchrightChecked = false;
+    StealthBrowserClient = class {
+      tool = "stealth";
+      stealthConfig;
+      page = null;
+      context = null;
+      browser = null;
+      sessionId = null;
+      constructor(config) {
+        this.stealthConfig = { ...DEFAULT_STEALTH_CONFIG, ...config };
+      }
+      // ========================================================================
+      // Lifecycle
+      // ========================================================================
+      async isAvailable() {
+        return getPatchright() !== null;
+      }
+      async launch(options) {
+        const pr3 = getPatchright();
+        if (!pr3) {
+          return {
+            success: false,
+            error: new BrowserUnavailableError(
+              "stealth",
+              "Patchright is not installed. Install with: npm install patchright"
+            )
+          };
+        }
+        try {
+          const launchOptions = {
+            headless: options?.headless ?? true
+          };
+          if (options?.viewport) {
+            launchOptions.viewport = options.viewport;
+          }
+          if (options?.args) {
+            launchOptions.args = options.args;
+          }
+          if (this.stealthConfig.userAgent) {
+            launchOptions.userAgent = this.stealthConfig.userAgent;
+          }
+          if (this.stealthConfig.proxy) {
+            launchOptions.proxy = this.stealthConfig.proxy;
+          }
+          if (this.stealthConfig.persistentContext) {
+            const userDataDir = this.stealthConfig.userDataDir || `/tmp/stealth-browser-${randomUUID6()}`;
+            this.context = await pr3.chromium.launchPersistentContext(userDataDir, launchOptions);
+            const pages = this.context.pages();
+            this.page = pages.length > 0 ? pages[0] : await this.context.newPage();
+          } else {
+            this.browser = await pr3.chromium.launch(launchOptions);
+            this.page = await this.browser.newPage();
+          }
+          await this.applyResourceBlocking();
+          this.sessionId = randomUUID6();
+          return {
+            success: true,
+            value: {
+              id: this.sessionId,
+              tool: "stealth",
+              status: "active",
+              createdAt: /* @__PURE__ */ new Date()
+            }
+          };
+        } catch (err4) {
+          return {
+            success: false,
+            error: new BrowserError(
+              `Failed to launch stealth browser: ${err4 instanceof Error ? err4.message : String(err4)}`,
+              "LAUNCH_FAILED",
+              "stealth",
+              err4 instanceof Error ? err4 : void 0
+            )
+          };
+        }
+      }
+      async quit() {
+        try {
+          if (this.context) {
+            await this.context.close();
+            this.context = null;
+          }
+          if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+          }
+          this.page = null;
+          this.sessionId = null;
+          return { success: true, value: void 0 };
+        } catch (err4) {
+          return {
+            success: false,
+            error: new BrowserError(
+              "Failed to quit stealth browser",
+              "QUIT_FAILED",
+              "stealth",
+              err4 instanceof Error ? err4 : void 0
+            )
+          };
+        }
+      }
+      // ========================================================================
+      // Navigation
+      // ========================================================================
+      async navigate(url) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const start = Date.now();
+          const response = await this.page.goto(url, { waitUntil: "domcontentloaded" });
+          const statusCode = response?.status() ?? void 0;
+          if (this.stealthConfig.cloudflareWaitSeconds > 0) {
+            await this.waitForCloudflare();
+          }
+          const title = await this.page.title();
+          return {
+            success: true,
+            value: {
+              url: this.page.url(),
+              title,
+              success: true,
+              durationMs: Date.now() - start,
+              statusCode: statusCode ?? void 0
+            }
+          };
+        } catch (err4) {
+          return this.wrapError("navigate", err4);
+        }
+      }
+      async reload() {
+        if (!this.page) return this.notLaunched();
+        try {
+          await this.page.reload();
+          return { success: true, value: void 0 };
+        } catch (err4) {
+          return this.wrapError("reload", err4);
+        }
+      }
+      async goBack() {
+        if (!this.page) return this.notLaunched();
+        try {
+          await this.page.goBack();
+          return { success: true, value: void 0 };
+        } catch (err4) {
+          return this.wrapError("goBack", err4);
+        }
+      }
+      async goForward() {
+        if (!this.page) return this.notLaunched();
+        try {
+          await this.page.goForward();
+          return { success: true, value: void 0 };
+        } catch (err4) {
+          return this.wrapError("goForward", err4);
+        }
+      }
+      // ========================================================================
+      // Element Interaction
+      // ========================================================================
+      async click(target) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const selector = this.resolveSelector(target);
+          await this.page.click(selector);
+          return { success: true, value: void 0 };
+        } catch (err4) {
+          return this.wrapError("click", err4);
+        }
+      }
+      async fill(target, text2) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const selector = this.resolveSelector(target);
+          await this.page.fill(selector, text2);
+          return { success: true, value: void 0 };
+        } catch (err4) {
+          return this.wrapError("fill", err4);
+        }
+      }
+      async getText(target) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const selector = this.resolveSelector(target);
+          const text2 = await this.page.textContent(selector);
+          return { success: true, value: text2 ?? "" };
+        } catch (err4) {
+          return this.wrapError("getText", err4);
+        }
+      }
+      async isVisible(target) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const selector = this.resolveSelector(target);
+          const visible = await this.page.isVisible(selector);
+          return { success: true, value: visible };
+        } catch (err4) {
+          return this.wrapError("isVisible", err4);
+        }
+      }
+      // ========================================================================
+      // Screenshots
+      // ========================================================================
+      async screenshot(options) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const buffer = await this.page.screenshot({
+            path: options?.path,
+            fullPage: options?.fullPage,
+            type: "png"
+          });
+          return {
+            success: true,
+            value: {
+              base64: buffer.toString("base64"),
+              path: options?.path,
+              format: "png",
+              dimensions: { width: 0, height: 0 }
+              // Patchright doesn't expose dimensions directly
+            }
+          };
+        } catch (err4) {
+          return this.wrapError("screenshot", err4);
+        }
+      }
+      // ========================================================================
+      // Evaluate
+      // ========================================================================
+      async evaluate(script) {
+        if (!this.page) return this.notLaunched();
+        try {
+          const result = await this.page.evaluate(script);
+          return { success: true, value: result };
+        } catch (err4) {
+          return this.wrapError("evaluate", err4);
+        }
+      }
+      // ========================================================================
+      // Cleanup
+      // ========================================================================
+      async dispose() {
+        await this.quit();
+      }
+      // ========================================================================
+      // Private Helpers
+      // ========================================================================
+      resolveSelector(target) {
+        if (typeof target === "string") return target;
+        switch (target.type) {
+          case "css":
+            return target.value;
+          case "xpath":
+            return `xpath=${target.value}`;
+          case "text":
+            return `text=${target.value}`;
+          case "ref":
+            return target.value;
+          default:
+            return target.value;
+        }
+      }
+      async applyResourceBlocking() {
+        if (!this.page || !this.stealthConfig.resourceBlocking) return;
+        const config = typeof this.stealthConfig.resourceBlocking === "string" ? getResourceBlockingPreset(this.stealthConfig.resourceBlocking) : this.stealthConfig.resourceBlocking;
+        if (!config.enabled) return;
+        await this.page.route("**/*", (route) => {
+          const url = route.request().url();
+          const resourceType = route.request().resourceType();
+          if (shouldBlockRequest(url, resourceType, config)) {
+            route.abort().catch(() => {
+            });
+          } else {
+            route.continue().catch(() => {
+            });
+          }
+        });
+      }
+      async waitForCloudflare() {
+        if (!this.page || this.stealthConfig.cloudflareWaitSeconds <= 0) return;
+        const ms = this.stealthConfig.cloudflareWaitSeconds * 1e3;
+        const start = Date.now();
+        while (Date.now() - start < ms) {
+          try {
+            const title = await this.page.title();
+            if (!title.includes("Just a moment") && !title.includes("Checking your browser")) {
+              return;
+            }
+          } catch {
+          }
+          await new Promise((resolve10) => setTimeout(resolve10, 500));
+        }
+      }
+      notLaunched() {
+        return {
+          success: false,
+          error: new BrowserError(
+            "Stealth browser not launched. Call launch() first.",
+            "NOT_LAUNCHED",
+            "stealth"
+          )
+        };
+      }
+      wrapError(operation, err4) {
+        return {
+          success: false,
+          error: new BrowserError(
+            `Stealth ${operation} failed: ${err4 instanceof Error ? err4.message : String(err4)}`,
+            "OPERATION_FAILED",
+            "stealth",
+            err4 instanceof Error ? err4 : void 0
+          )
+        };
+      }
+    };
+  }
+});
+
 // src/integrations/browser/client-factory.ts
 async function isVibiumAvailable() {
   return false;
@@ -44974,12 +45467,23 @@ function requiresAgentBrowser(useCase) {
 }
 async function createBrowserClient(options = {}) {
   const { preference = "auto", useCase } = options;
+  if (useCase && STEALTH_PREFERRED_USE_CASES.includes(useCase)) {
+    if (await isStealthAvailable()) {
+      return new StealthBrowserClient();
+    }
+  }
   if (useCase && requiresAgentBrowser(useCase)) {
     return createAgentBrowserClient();
   }
   if (preference === "agent-browser") {
     return createAgentBrowserClient();
   }
+  if (preference === "stealth") {
+    if (await isStealthAvailable()) {
+      return new StealthBrowserClient();
+    }
+    throw new BrowserUnavailableError("stealth", "Patchright is not installed");
+  }
   if (preference === "vibium") {
     const available = await isVibiumAvailable();
     if (available) {
@@ -45003,12 +45507,21 @@ async function createAgentBrowserClient() {
 async function getBrowserClientForUseCase(useCase) {
   return createBrowserClient({ useCase });
 }
-var AGENT_BROWSER_REQUIRED_USE_CASES, VibiumClientStub;
+async function isStealthAvailable() {
+  try {
+    const client = new StealthBrowserClient();
+    return await client.isAvailable();
+  } catch {
+    return false;
+  }
+}
+var AGENT_BROWSER_REQUIRED_USE_CASES, STEALTH_PREFERRED_USE_CASES, VibiumClientStub;
 var init_client_factory = __esm({
   "src/integrations/browser/client-factory.ts"() {
     "use strict";
     init_types5();
     init_client();
+    init_stealth_client();
     AGENT_BROWSER_REQUIRED_USE_CASES = [
       "e2e-testing",
       // Requires refs and sessions
@@ -45019,6 +45532,10 @@ var init_client_factory = __esm({
       "auth-testing"
       // Requires state persistence
     ];
+    STEALTH_PREFERRED_USE_CASES = [
+      "stealth-testing"
+      // Bot-protected environments
+    ];
     VibiumClientStub = class {
       tool = "vibium";
       async isAvailable() {
@@ -45102,6 +45619,30 @@ var init_client_factory = __esm({
   }
 });
 
+// src/integrations/browser/page-pool-types.ts
+var init_page_pool_types = __esm({
+  "src/integrations/browser/page-pool-types.ts"() {
+    "use strict";
+  }
+});
+
+// src/integrations/browser/page-pool.ts
+var init_page_pool = __esm({
+  "src/integrations/browser/page-pool.ts"() {
+    "use strict";
+    init_page_pool_types();
+  }
+});
+
+// src/integrations/browser/stealth/index.ts
+var init_stealth = __esm({
+  "src/integrations/browser/stealth/index.ts"() {
+    "use strict";
+    init_stealth_client();
+    init_stealth_types();
+  }
+});
+
 // src/integrations/browser/web-content-fetcher.ts
 import { exec, execSync as execSync2 } from "child_process";
 import { promisify } from "util";
@@ -45123,10 +45664,402 @@ var init_browser = __esm({
     init_types5();
     init_client_factory();
     init_client();
+    init_resource_blocking();
+    init_page_pool();
+    init_page_pool_types();
+    init_stealth();
     init_web_content_fetcher();
   }
 });
 
+// src/domains/test-execution/services/e2e/adaptive-locator-types.ts
+var DEFAULT_ADAPTIVE_LOCATOR_CONFIG;
+var init_adaptive_locator_types = __esm({
+  "src/domains/test-execution/services/e2e/adaptive-locator-types.ts"() {
+    "use strict";
+    DEFAULT_ADAPTIVE_LOCATOR_CONFIG = {
+      enabled: true,
+      similarityThreshold: 0.6,
+      maxFingerprintsPerPage: 200,
+      namespace: "aqe/adaptive-locators",
+      fallbackChain: ["text", "aria", "fingerprint"]
+    };
+  }
+});
+
+// src/domains/test-execution/services/e2e/adaptive-locator-service.ts
+function buildCaptureScript(cssSelector) {
+  return `
+    (() => {
+      const el = document.querySelector(${JSON.stringify(cssSelector)});
+      if (!el) return null;
+      const parent = el.parentElement;
+      const siblings = parent ? parent.children : [];
+      let childIndex = 0;
+      for (let i = 0; i < siblings.length; i++) {
+        if (siblings[i] === el) { childIndex = i; break; }
+      }
+      return {
+        tagName: el.tagName.toLowerCase(),
+        classes: Array.from(el.classList),
+        ariaRole: el.getAttribute('role') || undefined,
+        ariaLabel: el.getAttribute('aria-label') || undefined,
+        textContent: (el.textContent || '').trim().slice(0, 200) || undefined,
+        attributes: {
+          id: el.id || undefined,
+          name: el.getAttribute('name') || undefined,
+          'data-testid': el.getAttribute('data-testid') || undefined,
+          type: el.getAttribute('type') || undefined,
+          placeholder: el.getAttribute('placeholder') || undefined,
+          href: el.getAttribute('href') || undefined,
+        },
+        positionHints: {
+          parentTag: parent ? parent.tagName.toLowerCase() : undefined,
+          childIndex,
+          siblingCount: siblings.length,
+        },
+        matchCount: 0,
+        lastMatchedAt: new Date().toISOString(),
+      };
+    })()
+  `;
+}
+function buildCandidatesScript() {
+  return `
+    (() => {
+      const interactiveTags = 'a,button,input,select,textarea,[role],[data-testid],[aria-label]';
+      const elements = document.querySelectorAll(interactiveTags);
+      const results = [];
+      for (let i = 0; i < Math.min(elements.length, 300); i++) {
+        const el = elements[i];
+        const parent = el.parentElement;
+        const siblings = parent ? parent.children : [];
+        let childIndex = 0;
+        for (let j = 0; j < siblings.length; j++) {
+          if (siblings[j] === el) { childIndex = j; break; }
+        }
+        results.push({
+          tagName: el.tagName.toLowerCase(),
+          classes: Array.from(el.classList),
+          ariaRole: el.getAttribute('role') || undefined,
+          ariaLabel: el.getAttribute('aria-label') || undefined,
+          textContent: (el.textContent || '').trim().slice(0, 200) || undefined,
+          attributes: {
+            id: el.id || undefined,
+            name: el.getAttribute('name') || undefined,
+            'data-testid': el.getAttribute('data-testid') || undefined,
+            type: el.getAttribute('type') || undefined,
+            placeholder: el.getAttribute('placeholder') || undefined,
+            href: el.getAttribute('href') || undefined,
+          },
+          positionHints: {
+            parentTag: parent ? parent.tagName.toLowerCase() : undefined,
+            childIndex,
+            siblingCount: siblings.length,
+          },
+          // Build a unique-enough CSS selector for this element
+          selector: buildSelector(el),
+        });
+      }
+
+      function buildSelector(el) {
+        if (el.id) return '#' + CSS.escape(el.id);
+        if (el.getAttribute('data-testid')) return '[data-testid="' + el.getAttribute('data-testid') + '"]';
+        if (el.getAttribute('name')) return el.tagName.toLowerCase() + '[name="' + el.getAttribute('name') + '"]';
+        // Fallback: tag + nth-child
+        const parent = el.parentElement;
+        if (!parent) return el.tagName.toLowerCase();
+        const siblings = Array.from(parent.children).filter(s => s.tagName === el.tagName);
+        const idx = siblings.indexOf(el) + 1;
+        return el.tagName.toLowerCase() + ':nth-of-type(' + idx + ')';
+      }
+
+      return results;
+    })()
+  `;
+}
+function jaccardSimilarity(a37, b68) {
+  if (a37.length === 0 && b68.length === 0) return 1;
+  const setA = new Set(a37);
+  const setB = new Set(b68);
+  let intersection = 0;
+  for (const item of setA) {
+    if (setB.has(item)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function textSimilarity(a37, b68) {
+  if (!a37 && !b68) return 1;
+  if (!a37 || !b68) return 0;
+  const la13 = a37.toLowerCase();
+  const lb = b68.toLowerCase();
+  if (la13 === lb) return 1;
+  if (la13.includes(lb) || lb.includes(la13)) return 0.8;
+  const setA = new Set(la13);
+  const setB = new Set(lb);
+  let common = 0;
+  for (const c70 of setA) {
+    if (setB.has(c70)) common++;
+  }
+  const total = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return total === 0 ? 0 : common / total * 0.6;
+}
+function computeSimilarity(stored, candidate) {
+  let score = 0;
+  score += (stored.tagName === candidate.tagName ? 1 : 0) * WEIGHTS.tagName;
+  if (stored.ariaRole || candidate.ariaRole) {
+    score += (stored.ariaRole === candidate.ariaRole ? 1 : 0) * WEIGHTS.ariaRole;
+  } else {
+    score += WEIGHTS.ariaRole;
+  }
+  score += jaccardSimilarity(stored.classes, candidate.classes) * WEIGHTS.classes;
+  score += textSimilarity(stored.textContent, candidate.textContent) * WEIGHTS.textContent;
+  const storedAttrs = Object.entries(stored.attributes).filter(([, v62]) => v62);
+  const candidateAttrs = Object.entries(candidate.attributes).filter(([, v62]) => v62);
+  if (storedAttrs.length === 0 && candidateAttrs.length === 0) {
+    score += WEIGHTS.attributes;
+  } else {
+    let matches = 0;
+    for (const [key, val] of storedAttrs) {
+      const candidateVal = candidate.attributes[key];
+      if (candidateVal === val) matches++;
+    }
+    const total = Math.max(storedAttrs.length, candidateAttrs.length, 1);
+    score += matches / total * WEIGHTS.attributes;
+  }
+  const posScore = computePositionScore(stored.positionHints, candidate.positionHints);
+  score += posScore * WEIGHTS.positionHints;
+  return Math.min(1, Math.max(0, score));
+}
+function computePositionScore(a37, b68) {
+  let total = 0;
+  let matches = 0;
+  total++;
+  if (a37.parentTag === b68.parentTag) matches++;
+  total++;
+  const indexDiff = Math.abs(a37.childIndex - b68.childIndex);
+  matches += Math.max(0, 1 - indexDiff / 10);
+  total++;
+  const sibDiff = Math.abs(a37.siblingCount - b68.siblingCount);
+  matches += Math.max(0, 1 - sibDiff / 10);
+  return matches / total;
+}
+var WEIGHTS, FingerprintStore, AdaptiveLocatorService;
+var init_adaptive_locator_service = __esm({
+  "src/domains/test-execution/services/e2e/adaptive-locator-service.ts"() {
+    "use strict";
+    init_adaptive_locator_types();
+    WEIGHTS = {
+      tagName: 0.2,
+      ariaRole: 0.15,
+      classes: 0.15,
+      textContent: 0.2,
+      attributes: 0.15,
+      positionHints: 0.15
+    };
+    FingerprintStore = class {
+      store = /* @__PURE__ */ new Map();
+      maxPerPage;
+      constructor(maxPerPage = 200) {
+        this.maxPerPage = maxPerPage;
+      }
+      key(pageUrl, selector) {
+        return `${pageUrl}::${selector}`;
+      }
+      get(pageUrl, selector) {
+        return this.store.get(this.key(pageUrl, selector));
+      }
+      set(pageUrl, selector, fp) {
+        const k68 = this.key(pageUrl, selector);
+        this.store.set(k68, fp);
+        const prefix = `${pageUrl}::`;
+        const pageKeys = [...this.store.keys()].filter((key) => key.startsWith(prefix));
+        if (pageKeys.length > this.maxPerPage) {
+          const toRemove = pageKeys.length - this.maxPerPage;
+          for (let i58 = 0; i58 < toRemove; i58++) {
+            this.store.delete(pageKeys[i58]);
+          }
+        }
+      }
+      size() {
+        return this.store.size;
+      }
+      clear() {
+        this.store.clear();
+      }
+    };
+    AdaptiveLocatorService = class {
+      config;
+      fingerprintStore;
+      constructor(config) {
+        this.config = { ...DEFAULT_ADAPTIVE_LOCATOR_CONFIG, ...config };
+        this.fingerprintStore = new FingerprintStore(this.config.maxFingerprintsPerPage);
+      }
+      /**
+       * Capture and store a fingerprint for a successfully-interacted element
+       */
+      async captureFingerprint(selector, client, pageUrl) {
+        if (!this.config.enabled) return null;
+        try {
+          const cssSelector = this.toCssForCapture(selector);
+          if (!cssSelector) return null;
+          const result = await client.evaluate(
+            buildCaptureScript(cssSelector)
+          );
+          if (!result.success || !result.value) return null;
+          const fingerprint = result.value;
+          fingerprint.matchCount = (this.fingerprintStore.get(pageUrl, selector)?.matchCount ?? 0) + 1;
+          fingerprint.lastMatchedAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.fingerprintStore.set(pageUrl, selector, fingerprint);
+          return fingerprint;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Resolve an element target with adaptive fallback chain.
+       *
+       * 1. Try primary selector
+       * 2. Text-based match
+       * 3. ARIA-based match
+       * 4. Fingerprint similarity matching
+       */
+      async resolveWithFallback(selector, client, pageUrl) {
+        if (!this.config.enabled) return null;
+        const storedFingerprint = this.fingerprintStore.get(pageUrl, selector);
+        if (!storedFingerprint) return null;
+        for (const method of this.config.fallbackChain) {
+          const result = await this.tryFallbackMethod(method, storedFingerprint, client);
+          if (result) return result;
+        }
+        return null;
+      }
+      /**
+       * Get the fingerprint store size (for diagnostics)
+       */
+      getStoreSize() {
+        return this.fingerprintStore.size();
+      }
+      /**
+       * Clear all stored fingerprints
+       */
+      clearFingerprints() {
+        this.fingerprintStore.clear();
+      }
+      // ==========================================================================
+      // Private Helpers
+      // ==========================================================================
+      async tryFallbackMethod(method, stored, client) {
+        switch (method) {
+          case "text":
+            return this.tryTextMatch(stored, client);
+          case "aria":
+            return this.tryAriaMatch(stored, client);
+          case "fingerprint":
+            return this.tryFingerprintMatch(stored, client);
+          default:
+            return null;
+        }
+      }
+      async tryTextMatch(stored, client) {
+        if (!stored.textContent) return null;
+        const safeText = JSON.stringify(stored.textContent);
+        const script = `
+      (() => {
+        const target = ${safeText};
+        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+        while (walker.nextNode()) {
+          const el = walker.currentNode;
+          const text = (el.textContent || '').trim().slice(0, 200);
+          if (text === target) {
+            if (el.id) return '#' + CSS.escape(el.id);
+            if (el.getAttribute('data-testid')) return '[data-testid="' + el.getAttribute('data-testid') + '"]';
+            return null;
+          }
+        }
+        return null;
+      })()
+    `;
+        try {
+          const result = await client.evaluate(script);
+          if (result.success && result.value) {
+            return {
+              resolvedSelector: result.value,
+              method: "text",
+              similarityScore: 0.9,
+              fingerprintUpdated: false
+            };
+          }
+        } catch {
+        }
+        return null;
+      }
+      async tryAriaMatch(stored, client) {
+        if (!stored.ariaRole && !stored.ariaLabel) return null;
+        let ariaSelector = "";
+        if (stored.ariaRole && stored.ariaLabel) {
+          ariaSelector = `[role="${stored.ariaRole}"][aria-label="${stored.ariaLabel}"]`;
+        } else if (stored.ariaLabel) {
+          ariaSelector = `[aria-label="${stored.ariaLabel}"]`;
+        } else if (stored.ariaRole) {
+          ariaSelector = `[role="${stored.ariaRole}"]`;
+        }
+        if (!ariaSelector) return null;
+        try {
+          const checkScript = `!!document.querySelector(${JSON.stringify(ariaSelector)})`;
+          const result = await client.evaluate(checkScript);
+          if (result.success && result.value) {
+            return {
+              resolvedSelector: ariaSelector,
+              method: "aria",
+              similarityScore: 0.85,
+              fingerprintUpdated: false
+            };
+          }
+        } catch {
+        }
+        return null;
+      }
+      async tryFingerprintMatch(stored, client) {
+        try {
+          const result = await client.evaluate(buildCandidatesScript());
+          if (!result.success || !result.value?.length) return null;
+          let bestScore = 0;
+          let bestSelector = "";
+          for (const candidate of result.value) {
+            const score = computeSimilarity(stored, candidate);
+            if (score > bestScore) {
+              bestScore = score;
+              bestSelector = candidate.selector;
+            }
+          }
+          if (bestScore >= this.config.similarityThreshold && bestSelector) {
+            return {
+              resolvedSelector: bestSelector,
+              method: "fingerprint",
+              similarityScore: bestScore,
+              fingerprintUpdated: false
+            };
+          }
+        } catch {
+        }
+        return null;
+      }
+      /**
+       * Convert a selector string to a CSS selector suitable for capture.
+       * Returns null for non-CSS selectors that can't be used with querySelector.
+       */
+      toCssForCapture(selector) {
+        if (selector.startsWith("//") || selector.startsWith("xpath=")) return null;
+        if (/^@?e\d+$/.test(selector)) return null;
+        if (selector.startsWith("text=")) return null;
+        return selector;
+      }
+    };
+  }
+});
+
 // src/domains/test-execution/services/e2e/browser-orchestrator.ts
 function isAgentBrowserClient(client) {
   return "tool" in client && client.tool === "agent-browser";
@@ -45196,18 +46129,24 @@ var init_browser_orchestrator = __esm({
   "src/domains/test-execution/services/e2e/browser-orchestrator.ts"() {
     "use strict";
     init_error_utils();
+    init_adaptive_locator_service();
+    init_browser();
     BrowserOrchestrator = class {
       client;
       unifiedClient;
       useAgentBrowser;
       config;
       log;
+      adaptiveLocator = null;
       constructor(client, config, logger22) {
         this.client = client;
         this.config = config;
         this.log = logger22;
         this.unifiedClient = config.browserClient ?? client;
         this.useAgentBrowser = isAgentBrowserClient(this.unifiedClient);
+        if (config.adaptiveLocator?.enabled) {
+          this.adaptiveLocator = new AdaptiveLocatorService(config.adaptiveLocator);
+        }
       }
       /**
        * Get the unified browser client
@@ -45235,6 +46174,9 @@ var init_browser_orchestrator = __esm({
             if (!launchResult.success) {
               return `Failed to launch browser: ${launchResult.error.message}`;
             }
+            if (this.config.resourceBlocking) {
+              await this.applyResourceBlocking(this.unifiedClient, this.config.resourceBlocking);
+            }
             return null;
           } else if (isVibiumClient(this.client)) {
             const session = await this.client.getSession();
@@ -45379,6 +46321,88 @@ var init_browser_orchestrator = __esm({
           await this.client.findElement({ selector, visible: true });
         }
       }
+      /**
+       * Resolve an element target with adaptive fallback.
+       * If the primary selector fails and adaptive locator is configured,
+       * attempts fallback matching via text, ARIA, and fingerprint similarity.
+       */
+      async resolveElementTarget(selector, pageUrl) {
+        const primaryTarget = toElementTarget(selector);
+        if (!this.adaptiveLocator || isVibiumClient(this.unifiedClient)) {
+          return primaryTarget;
+        }
+        const browserClient = this.unifiedClient;
+        try {
+          const result = await browserClient.isVisible(primaryTarget);
+          if (result.success && result.value) {
+            await this.adaptiveLocator.captureFingerprint(selector, browserClient, pageUrl);
+            return primaryTarget;
+          }
+        } catch {
+        }
+        const resolution = await this.adaptiveLocator.resolveWithFallback(
+          selector,
+          browserClient,
+          pageUrl
+        );
+        if (resolution) {
+          this.log(
+            `Adaptive locator: resolved "${selector}" via ${resolution.method} (score: ${resolution.similarityScore.toFixed(2)})`
+          );
+          return toElementTarget(resolution.resolvedSelector);
+        }
+        return primaryTarget;
+      }
+      /**
+       * Apply resource blocking to a browser client's page via evaluate-based interception.
+       * Injects a PerformanceObserver that aborts blocked resource loads.
+       * For full route-level blocking, use StealthBrowserClient which has native page.route().
+       */
+      async applyResourceBlocking(client, config) {
+        const blockingConfig = typeof config === "string" ? getResourceBlockingPreset(config) : config;
+        if (!blockingConfig.enabled) return;
+        this.log(`Resource blocking enabled: ${blockingConfig.blockedCategories.join(", ")}`);
+        if (isAgentBrowserClient(this.unifiedClient)) {
+          const agentClient = this.unifiedClient;
+          const patterns = [];
+          if (blockingConfig.blockedCategories.includes("tracking")) {
+            patterns.push(
+              "*google-analytics.com*",
+              "*googletagmanager.com*",
+              "*hotjar.com*",
+              "*segment.com*",
+              "*mixpanel.com*",
+              "*amplitude.com*",
+              "*fullstory.com*",
+              "*clarity.ms*",
+              "*facebook.net*"
+            );
+          }
+          if (blockingConfig.blockedCategories.includes("advertising")) {
+            patterns.push(
+              "*doubleclick.net*",
+              "*googlesyndication.com*",
+              "*googleadservices.com*",
+              "*adnxs.com*",
+              "*criteo.com*",
+              "*taboola.com*",
+              "*outbrain.com*"
+            );
+          }
+          if (blockingConfig.blockPatterns) {
+            patterns.push(...blockingConfig.blockPatterns);
+          }
+          for (const pattern of patterns) {
+            await agentClient.abortRoute(pattern);
+          }
+        }
+      }
+      /**
+       * Get the adaptive locator service (for external fingerprint capture)
+       */
+      getAdaptiveLocator() {
+        return this.adaptiveLocator;
+      }
       /**
        * Get browser context options from test case
        */
@@ -46042,7 +47066,10 @@ var init_step_executors = __esm({
       async executeClickStep(step, client, context) {
         if (!isVibiumClient(client)) {
           const browserClient = client;
-          const target = toElementTarget(step.target);
+          const target = await this.orchestrator.resolveElementTarget(
+            step.target,
+            this.getCurrentPageUrl(context)
+          );
           if (context.useAgentBrowser && isAgentBrowserClient(browserClient)) {
             const waitResult = await browserClient.waitForElement(target, step.timeout);
             if (!waitResult.success) {
@@ -46105,7 +47132,10 @@ var init_step_executors = __esm({
       async executeTypeStep(step, client, context) {
         if (!isVibiumClient(client)) {
           const browserClient = client;
-          const target = toElementTarget(step.target);
+          const target = await this.orchestrator.resolveElementTarget(
+            step.target,
+            this.getCurrentPageUrl(context)
+          );
           if (context.useAgentBrowser && isAgentBrowserClient(browserClient)) {
             const waitResult = await browserClient.waitForElement(target, step.timeout);
             if (!waitResult.success) {
@@ -46362,6 +47392,20 @@ var init_step_executors = __esm({
       // ==========================================================================
       // Utility Methods
       // ==========================================================================
+      /**
+       * Get the current page URL from context, falling back to baseUrl.
+       * Uses the last navigate step's URL if available, so adaptive locator
+       * fingerprints are keyed to the actual page, not just the base URL.
+       */
+      getCurrentPageUrl(context) {
+        for (let i58 = context.previousResults.length - 1; i58 >= 0; i58--) {
+          const result = context.previousResults[i58];
+          if (result.data?.url && typeof result.data.url === "string") {
+            return result.data.url;
+          }
+        }
+        return context.baseUrl;
+      }
       resolveUrl(url, baseUrl) {
         if (url.startsWith("http://") || url.startsWith("https://")) {
           return url;
@@ -99952,7 +100996,7 @@ var init_spreading_activation = __esm({
 });
 
 // src/learning/dream/insight-generator.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var DEFAULT_INSIGHT_CONFIG, InsightGenerator;
 var init_insight_generator = __esm({
   "src/learning/dream/insight-generator.ts"() {
@@ -100475,7 +101519,7 @@ var init_insight_generator = __esm({
        */
       generateId() {
         const timestamp = Date.now();
-        const random = randomUUID6().slice(0, 8);
+        const random = randomUUID7().slice(0, 8);
         return `insight-${timestamp}-${random}`;
       }
       /**
@@ -106839,7 +107883,7 @@ var init_plugin14 = __esm({
 });
 
 // src/kernel/kernel.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import * as path14 from "path";
 import * as fs13 from "fs";
 var DOMAIN_FACTORIES, DEFAULT_CONFIG64, QEKernelImpl;
@@ -106944,7 +107988,7 @@ var init_kernel = __esm({
         if (this._config.memoryBackend === "memory") {
           const tmpDbPath = path14.join(
             __require("os").tmpdir(),
-            `aqe-test-${Date.now()}-${randomUUID7().slice(0, 12)}.db`
+            `aqe-test-${Date.now()}-${randomUUID8().slice(0, 12)}.db`
           );
           await initializeUnifiedPersistence({ dbPath: tmpDbPath });
         } else {
@@ -110082,7 +111126,7 @@ var init_mailbox = __esm({
 });
 
 // src/coordination/agent-teams/tracing.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function encodeTraceContext(context) {
   return `${TRACE_PREFIX}${JSON.stringify({
     traceId: context.traceId,
@@ -110115,8 +111159,8 @@ var init_tracing = __esm({
        * @returns The new trace context and root span
        */
       startTrace(options) {
-        const traceId = randomUUID8();
-        const spanId = randomUUID8();
+        const traceId = randomUUID9();
+        const spanId = randomUUID9();
         const context = { traceId, spanId };
         const span = this.createSpan(context, options);
         return { context, span };
@@ -110132,8 +111176,8 @@ var init_tracing = __esm({
        */
       startSpan(options) {
         const parentContext = options.parentContext;
-        const traceId = parentContext?.traceId ?? randomUUID8();
-        const spanId = randomUUID8();
+        const traceId = parentContext?.traceId ?? randomUUID9();
+        const spanId = randomUUID9();
         const context = {
           traceId,
           spanId,
@@ -110292,7 +111336,7 @@ var init_tracing = __esm({
 });
 
 // src/coordination/agent-teams/adapter.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 function createAgentTeamsAdapter(config) {
   return new AgentTeamsAdapter(void 0, config);
 }
@@ -110436,7 +111480,7 @@ var init_adapter = __esm({
         const senderDomain = this.agentDomains.get(from);
         const correlationId = options?.traceContext ? encodeTraceContext(options.traceContext) : options?.correlationId;
         const message = {
-          id: randomUUID9(),
+          id: randomUUID10(),
           from,
           to: to2,
           domain: options?.domain ?? senderDomain,
@@ -110462,7 +111506,7 @@ var init_adapter = __esm({
         }
         const correlationId = options?.traceContext ? encodeTraceContext(options.traceContext) : options?.correlationId;
         const message = {
-          id: randomUUID9(),
+          id: randomUUID10(),
           from,
           to: "broadcast",
           domain,
@@ -112653,7 +113697,7 @@ var init_types11 = __esm({
 });
 
 // src/coordination/competing-hypotheses/hypothesis-manager.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 function createHypothesisManager(config) {
   return new HypothesisManager(config);
 }
@@ -112680,7 +113724,7 @@ var init_hypothesis_manager = __esm({
        * @returns Immutable snapshot of the created investigation
        */
       createInvestigation(taskId, domain, description) {
-        const id = `inv-${randomUUID10().slice(0, 8)}`;
+        const id = `inv-${randomUUID11().slice(0, 8)}`;
         const now = Date.now();
         const investigation = {
           id,
@@ -112718,7 +113762,7 @@ var init_hypothesis_manager = __esm({
           );
         }
         const hypothesis = {
-          id: `hyp-${randomUUID10().slice(0, 8)}`,
+          id: `hyp-${randomUUID11().slice(0, 8)}`,
           description,
           investigatorAgentId: agentId,
           strategy,
@@ -112786,7 +113830,7 @@ var init_hypothesis_manager = __esm({
         const hyp = this.findHypothesis(inv, hypothesisId);
         const fullEvidence = {
           ...evidence,
-          id: `evi-${randomUUID10().slice(0, 8)}`,
+          id: `evi-${randomUUID11().slice(0, 8)}`,
           hypothesisId,
           timestamp: Date.now()
         };
@@ -112997,7 +114041,7 @@ var init_types12 = __esm({
 });
 
 // src/coordination/federation/federation-mailbox.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 function toServiceSnapshot(service) {
   return {
     fleetId: service.fleetId,
@@ -113176,7 +114220,7 @@ var init_federation_mailbox = __esm({
           throw new Error(`No route found for ${sourceDomain} -> ${targetDomain}`);
         }
         const message = {
-          id: randomUUID11(),
+          id: randomUUID12(),
           sourceFleetId: this.config.localFleetId,
           targetFleetId: resolvedTarget,
           sourceDomain,
@@ -113400,7 +114444,7 @@ var init_types13 = __esm({
 });
 
 // src/coordination/dynamic-scaling/dynamic-scaler.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 function createDynamicScaler(initialAgents, config) {
   return new DynamicScaler(initialAgents, config);
 }
@@ -113555,7 +114599,7 @@ var init_dynamic_scaler = __esm({
        */
       async execute(decision, executor2) {
         const event = {
-          id: `scale-${randomUUID12().slice(0, 8)}`,
+          id: `scale-${randomUUID13().slice(0, 8)}`,
           decision,
           executedAt: Date.now(),
           success: true
@@ -113848,10 +114892,10 @@ var init_queen_types = __esm({
 });
 
 // src/types/cross-phase-signals.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function createSignalId(loopType, prefix) {
   const timestamp = Date.now();
-  const random = randomUUID13().split("-")[0];
+  const random = randomUUID14().split("-")[0];
   return `${prefix || loopType}-signal-${timestamp}-${random}`;
 }
 function calculateExpiry(ttlMs) {
@@ -125924,7 +126968,7 @@ var init_hyperbolic_ops = __esm({
 });
 
 // src/integrations/agentic-flow/onnx-embeddings/adapter.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 function createONNXEmbeddingsAdapter(config) {
   return new ONNXEmbeddingsAdapter(config);
 }
@@ -126231,7 +127275,7 @@ var init_adapter3 = __esm({
        * Generate unique ID for stored embeddings
        */
       generateId() {
-        return `emb_${Date.now()}_${randomUUID14().slice(0, 9)}`;
+        return `emb_${Date.now()}_${randomUUID15().slice(0, 9)}`;
       }
       /**
        * Check if adapter is ready
@@ -129597,7 +130641,7 @@ var init_test_outcome_tracker = __esm({
 });
 
 // src/feedback/coverage-learner.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 function createCoverageLearner(config) {
   return new CoverageLearner(config);
 }
@@ -129846,7 +130890,7 @@ var init_coverage_learner = __esm({
           };
         } else {
           strategy = {
-            id: `strategy-${Date.now()}-${randomUUID15().slice(0, 8)}`,
+            id: `strategy-${Date.now()}-${randomUUID16().slice(0, 8)}`,
             description: this.generateStrategyDescription(session, improvement),
             technique: session.technique,
             filePatterns: [filePattern],
@@ -131600,7 +132644,7 @@ var init_qe_agent_registry = __esm({
 });
 
 // src/routing/routing-feedback.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 function createRoutingFeedbackCollector(maxOutcomes = 1e4) {
   return new RoutingFeedbackCollector(maxOutcomes);
 }
@@ -131755,7 +132799,7 @@ var init_routing_feedback = __esm({
        */
       recordOutcome(task, decision, usedAgent, outcome) {
         const routingOutcome = {
-          id: `outcome-${Date.now()}-${randomUUID16().slice(0, 8)}`,
+          id: `outcome-${Date.now()}-${randomUUID17().slice(0, 8)}`,
           task,
           decision,
           usedAgent,
@@ -134444,7 +135488,7 @@ var init_detect = __esm({
 });
 
 // src/adapters/claude-flow/trajectory-bridge.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 var TrajectoryBridge;
 var init_trajectory_bridge = __esm({
   "src/adapters/claude-flow/trajectory-bridge.ts"() {
@@ -134472,7 +135516,7 @@ var init_trajectory_bridge = __esm({
        * Start a new trajectory
        */
       async startTrajectory(task, agent) {
-        const id = `trajectory-${randomUUID17()}`;
+        const id = `trajectory-${randomUUID18()}`;
         if (this.claudeFlowAvailable) {
           try {
             const { execSync: execSync6 } = await import("child_process");
@@ -140233,7 +141277,7 @@ __export(aqe_learning_engine_exports, {
   createAQELearningEngine: () => createAQELearningEngine,
   createDefaultLearningEngine: () => createDefaultLearningEngine
 });
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 function createAQELearningEngine(memory, config, eventBus) {
   return new AQELearningEngine(memory, config, eventBus);
 }
@@ -140519,7 +141563,7 @@ var init_aqe_learning_engine = __esm({
           avgSimilarity: results.length > 0 ? results.reduce((sum, r54) => sum + r54.similarity, 0) / results.length : 0
         };
         try {
-          const key = `pattern-usage:search:${Date.now()}-${randomUUID18().slice(0, 8)}`;
+          const key = `pattern-usage:search:${Date.now()}-${randomUUID19().slice(0, 8)}`;
           await this.memory.set(key, searchEvent, {
             persist: true,
             ttl: 7 * 24 * 60 * 60 * 1e3
@@ -140677,7 +141721,7 @@ var init_aqe_learning_engine = __esm({
        * Also starts experience capture for pattern learning.
        */
       async startTask(task, agent, domain) {
-        const id = `task-${Date.now()}-${randomUUID18().slice(0, 8)}`;
+        const id = `task-${Date.now()}-${randomUUID19().slice(0, 8)}`;
         let trajectoryId = id;
         if (this.claudeFlowBridge?.trajectory.isClaudeFlowAvailable()) {
           try {
@@ -140972,12 +142016,12 @@ var init_aqe_learning_engine = __esm({
 });
 
 // src/mcp/handlers/handler-factory.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 function generateTestId() {
-  return `test-${randomUUID19()}`;
+  return `test-${randomUUID20()}`;
 }
 function generateAgentId(type) {
-  return `${type}-${randomUUID19()}`;
+  return `${type}-${randomUUID20()}`;
 }
 function generateV2LearningFeedback(agentType) {
   return {
@@ -142734,7 +143778,7 @@ var init_early_exit_token_optimizer = __esm({
 });
 
 // src/learning/token-tracker.ts
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 function formatWithCommas(n61) {
   return n61.toLocaleString("en-US");
 }
@@ -142831,7 +143875,7 @@ var init_token_tracker = __esm({
       static KV_PERSIST_INTERVAL = 10;
       // every 10 operations
       constructor() {
-        this.sessionId = `session-${Date.now()}-${randomUUID20().substring(0, 8)}`;
+        this.sessionId = `session-${Date.now()}-${randomUUID21().substring(0, 8)}`;
         this.sessionStartTime = Date.now();
         this.costConfig = DEFAULT_COST_CONFIG;
       }
@@ -143121,7 +144165,7 @@ var init_token_tracker = __esm({
         this.taskMetrics = [];
         this.agentMetrics.clear();
         this.domainMetrics.clear();
-        this.sessionId = `session-${Date.now()}-${randomUUID20().substring(0, 8)}`;
+        this.sessionId = `session-${Date.now()}-${randomUUID21().substring(0, 8)}`;
         this.sessionStartTime = Date.now();
         this.cacheHits = 0;
         this.earlyExits = 0;
@@ -143481,7 +144525,7 @@ var init_token_tracker = __esm({
 });
 
 // src/optimization/token-optimizer-service.ts
-import { randomUUID as randomUUID21 } from "crypto";
+import { randomUUID as randomUUID22 } from "crypto";
 async function initializeTokenOptimizer(memoryBackend2, config) {
   await TokenOptimizerService.initialize(memoryBackend2, config);
 }
@@ -143594,7 +144638,7 @@ var init_token_optimizer_service = __esm({
         try {
           const result = await this.patternStore.store({
             ...pattern,
-            id: `pattern-${Date.now()}-${randomUUID21().slice(0, 8)}`,
+            id: `pattern-${Date.now()}-${randomUUID22().slice(0, 8)}`,
             createdAt: /* @__PURE__ */ new Date(),
             lastUsedAt: /* @__PURE__ */ new Date()
           });
@@ -151142,7 +152186,7 @@ var init_qe_action_library = __esm({
 });
 
 // src/planning/goap-planner.ts
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 function getSharedGOAPPlanner() {
   if (!sharedPlanner) {
     sharedPlanner = new GOAPPlanner();
@@ -151266,7 +152310,7 @@ var init_goap_planner = __esm({
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const action of allActions) {
-          const id = `action-${Date.now()}-${randomUUID22().slice(0, 8)}`;
+          const id = `action-${Date.now()}-${randomUUID23().slice(0, 8)}`;
           insertAction.run(
             id,
             action.name,
@@ -151284,7 +152328,7 @@ var init_goap_planner = __esm({
       VALUES (?, ?, ?, ?, ?, ?)
     `);
         for (const goal of QE_GOALS) {
-          const id = `goal-${Date.now()}-${randomUUID22().slice(0, 8)}`;
+          const id = `goal-${Date.now()}-${randomUUID23().slice(0, 8)}`;
           insertGoal.run(
             id,
             goal.name,
@@ -151316,7 +152360,7 @@ var init_goap_planner = __esm({
             this.recordPlanReuse(reusedPlan.id, true);
             return {
               ...reusedPlan,
-              id: `plan-${Date.now()}-${randomUUID22().slice(0, 8)}`,
+              id: `plan-${Date.now()}-${randomUUID23().slice(0, 8)}`,
               initialState: this.cloneState(currentState),
               reusedFrom: reusedPlan.id,
               status: "pending"
@@ -151334,7 +152378,7 @@ var init_goap_planner = __esm({
           return null;
         }
         const plan = {
-          id: `plan-${Date.now()}-${randomUUID22().slice(0, 8)}`,
+          id: `plan-${Date.now()}-${randomUUID23().slice(0, 8)}`,
           initialState: this.cloneState(currentState),
           goalState: goal,
           actions: actionSequence,
@@ -151703,7 +152747,7 @@ var init_goap_planner = __esm({
        */
       async addAction(action) {
         await this.initialize();
-        const id = `action-${Date.now()}-${randomUUID22().slice(0, 8)}`;
+        const id = `action-${Date.now()}-${randomUUID23().slice(0, 8)}`;
         this.ensureDb().prepare(
           `
       INSERT INTO goap_actions (
@@ -151865,7 +152909,7 @@ var init_goap_planner = __esm({
       ) VALUES (?, ?, ?, ?, ?, ?)
     `
         ).run(
-          `sig-${Date.now()}-${randomUUID22().slice(0, 8)}`,
+          `sig-${Date.now()}-${randomUUID23().slice(0, 8)}`,
           plan.id,
           goalHash,
           JSON.stringify(stateVector),
@@ -151949,7 +152993,7 @@ var init_goap_planner = __esm({
        */
       async addGoal(goal) {
         await this.initialize();
-        const id = `goal-${Date.now()}-${randomUUID22().slice(0, 8)}`;
+        const id = `goal-${Date.now()}-${randomUUID23().slice(0, 8)}`;
         this.ensureDb().prepare(
           `
       INSERT INTO goap_goals (id, name, description, conditions, priority, qe_domain)
@@ -152033,7 +153077,7 @@ var init_goap_planner = __esm({
 });
 
 // src/planning/plan-executor.ts
-import { randomUUID as randomUUID23 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 function createMockExecutor(planner, options) {
   const spawner = new MockAgentSpawner({
     successRate: options?.successRate ?? 1
@@ -152185,7 +153229,7 @@ var init_plan_executor = __esm({
       async executeWithCallbacks(plan, onStepStart, onStepComplete, initialState) {
         await this.initialize();
         const startTime = Date.now();
-        const executionId = `exec-${Date.now()}-${randomUUID23().slice(0, 8)}`;
+        const executionId = `exec-${Date.now()}-${randomUUID24().slice(0, 8)}`;
         this.currentExecution = { planId: plan.id, cancelled: false };
         const result = {
           planId: plan.id,
@@ -152197,7 +153241,7 @@ var init_plan_executor = __esm({
         };
         let currentState = initialState ? this.cloneState(initialState) : this.cloneState(plan.initialState);
         const steps = plan.actions.map((action, index) => ({
-          id: `step-${Date.now()}-${randomUUID23().slice(0, 8)}`,
+          id: `step-${Date.now()}-${randomUUID24().slice(0, 8)}`,
           planId: plan.id,
           action,
           stepOrder: index,
@@ -152720,7 +153764,7 @@ Expected effects:`;
       async spawn(agentType, task) {
         await new Promise((resolve10) => setTimeout(resolve10, this.executionDelay));
         const success = secureRandom() < this.successRate;
-        const agentId = `mock-agent-${randomUUID23().slice(0, 8)}`;
+        const agentId = `mock-agent-${randomUUID24().slice(0, 8)}`;
         if (success) {
           return {
             agentId,
@@ -154266,7 +155310,7 @@ var init_causal_verifier = __esm({
 });
 
 // src/learning/memory-auditor.ts
-import { randomUUID as randomUUID24 } from "crypto";
+import { randomUUID as randomUUID25 } from "crypto";
 function createMemoryAuditor(coherenceService, eventBus, config) {
   return new MemoryCoherenceAuditor(
     coherenceService,
@@ -154596,7 +155640,7 @@ var init_memory_auditor = __esm({
         if (!this.eventBus) return;
         try {
           await this.eventBus.publish({
-            id: `memory-audit-${Date.now()}-${randomUUID24().split("-")[0]}`,
+            id: `memory-audit-${Date.now()}-${randomUUID25().split("-")[0]}`,
             type: eventType,
             source: "learning-optimization",
             timestamp: /* @__PURE__ */ new Date(),
@@ -162733,7 +163777,7 @@ async function handleAQEHealth() {
       success: true,
       data: {
         status: healthStatus,
-        version: true ? "3.7.6" : "3.7.2",
+        version: true ? "3.7.7" : "3.7.2",
         loadedDomains: domainCount,
         memory: memoryStats,
         hnsw: hnswStats,
@@ -168140,7 +169184,7 @@ function registerMissingQETools(registerFn) {
 }
 
 // src/mcp/connection-pool.ts
-import { randomUUID as randomUUID25 } from "crypto";
+import { randomUUID as randomUUID26 } from "crypto";
 var DEFAULT_POOL_CONFIG = {
   maxConnections: 50,
   minConnections: 5,
@@ -168376,7 +169420,7 @@ var ConnectionPoolImpl = class {
   // Private Methods
   // ============================================================================
   async createConnection() {
-    const id = `conn-${Date.now()}-${randomUUID25().split("-")[0]}`;
+    const id = `conn-${Date.now()}-${randomUUID26().split("-")[0]}`;
     const now = Date.now();
     const connection = {
       id,
@@ -168399,7 +169443,7 @@ var ConnectionPoolImpl = class {
     if (this.connections.size >= this.config.maxConnections) {
       return null;
     }
-    const id = `conn-${Date.now()}-${randomUUID25().split("-")[0]}`;
+    const id = `conn-${Date.now()}-${randomUUID26().split("-")[0]}`;
     const now = Date.now();
     const connection = {
       id,
@@ -170709,7 +171753,7 @@ function createTaskStore(config = {}) {
 
 // src/adapters/a2a/tasks/task-manager.ts
 import { EventEmitter as EventEmitter5 } from "events";
-import { randomUUID as randomUUID26 } from "crypto";
+import { randomUUID as randomUUID27 } from "crypto";
 var VALID_TRANSITIONS = {
   submitted: ["working", "rejected", "canceled"],
   working: ["completed", "failed", "input_required", "auth_required", "canceled"],
@@ -170735,8 +171779,8 @@ var DEFAULT_TASK_MANAGER_CONFIG = {
   storeConfig: {},
   defaultAgentId: "default-agent",
   autoGenerateContextId: true,
-  idGenerator: () => `task-${Date.now()}-${randomUUID26().split("-")[0]}`,
-  contextIdGenerator: () => `ctx-${Date.now()}-${randomUUID26().split("-")[0]}`,
+  idGenerator: () => `task-${Date.now()}-${randomUUID27().split("-")[0]}`,
+  contextIdGenerator: () => `ctx-${Date.now()}-${randomUUID27().split("-")[0]}`,
   timestampGenerator: () => /* @__PURE__ */ new Date()
 };
 var TaskManager = class extends EventEmitter5 {
@@ -171038,7 +172082,7 @@ var TaskManager = class extends EventEmitter5 {
    */
   createArtifactFromMessage(message, name = "Message", description) {
     return {
-      id: `artifact-${Date.now()}-${randomUUID26().split("-")[0]}`,
+      id: `artifact-${Date.now()}-${randomUUID27().split("-")[0]}`,
       name,
       description,
       parts: message.parts
@@ -171303,7 +172347,7 @@ function generateSignatureHeader(payload, secret, timestamp) {
 }
 
 // src/adapters/a2a/notifications/subscription-store.ts
-import { randomUUID as randomUUID27 } from "crypto";
+import { randomUUID as randomUUID28 } from "crypto";
 var DEFAULT_SUBSCRIPTION_STORE_CONFIG = {
   maxSubscriptionsPerTask: 10,
   maxTotalSubscriptions: 1e4,
@@ -171684,7 +172728,7 @@ var SubscriptionStore = class {
   // Private Helpers
   // ============================================================================
   generateId() {
-    return `sub-${Date.now()}-${randomUUID27().split("-")[0]}`;
+    return `sub-${Date.now()}-${randomUUID28().split("-")[0]}`;
   }
   addToTaskIndex(taskId, subscriptionId) {
     let taskSubs = this.taskIndex.get(taskId);
@@ -171742,7 +172786,7 @@ function createSubscriptionStore(config = {}) {
 // src/adapters/a2a/notifications/retry-queue.ts
 init_crypto_random();
 import { EventEmitter as EventEmitter6 } from "events";
-import { randomUUID as randomUUID28 } from "crypto";
+import { randomUUID as randomUUID29 } from "crypto";
 var DEFAULT_RETRY_CONFIG2 = {
   maxAttempts: 5,
   baseDelayMs: 1e3,
@@ -171810,7 +172854,7 @@ var RetryQueue = class extends EventEmitter6 {
    */
   enqueueNew(params) {
     const now = /* @__PURE__ */ new Date();
-    const id = `retry-${Date.now()}-${randomUUID28().split("-")[0]}`;
+    const id = `retry-${Date.now()}-${randomUUID29().split("-")[0]}`;
     const delivery = {
       id,
       subscriptionId: params.subscriptionId,