agentic-qe 3.15.12 → 3.15.13

package/dist/domains/visual-accessibility/services/accessibility-tester.js

@@ -3,9 +3,10 @@
  * Implements WCAG 2.2 compliance auditing with browser mode support
  *
  * This service supports multiple modes of operation:
- * 1. Heuristic Mode (default): URL-pattern-based analysis without browser automation
- * 2. Browser Mode (agent-browser): Real DOM inspection via unified browser client
- * 3. Browser Mode (Vibium): Real DOM inspection via Vibium MCP integration
+ * 1. Browser Mode (agent-browser): Real DOM inspection via unified browser client
+ * 2. Browser Mode (Vibium): Real DOM inspection via Vibium MCP integration
+ * 3. Not measured: no browser could load the page. The report says so
+ *    (`measured: false`) and carries no findings (#1145).
  *
  * Browser mode provides more accurate results by:
  * - Running actual axe-core accessibility checks in the browser
@@ -15,7 +16,8 @@
  * Browser Client Integration:
  * - Prefers agent-browser when available (supports snapshots and axe-core injection)
  * - Falls back to Vibium if agent-browser unavailable
- * - Uses heuristic mode when no browser tool is available
+ * - Reports "not measured" when no browser tool could audit the page; it never
+ *   guesses findings from the URL (#1145)
  *
  * @module domains/visual-accessibility/services/accessibility-tester
  */
@@ -28,7 +30,7 @@ import { toError } from '../../../shared/error-utils.js';
 import { getBrowserClientForUseCase, } from '../../../integrations/browser/index.js';
 // Extracted modules
 import { WCAG_CRITERIA, getErrorMessage, auditWithBrowserClient, auditWithVibium, auditElementWithVibium, checkContrastWithVibium, checkKeyboardWithVibium, } from './accessibility-tester-browser.js';
-import { initializeRules, filterRulesByLevel, runRule, validateCriterion, analyzeContrastForElements, generateKeyboardReportWithHeuristics, hashUrl, } from './accessibility-tester-heuristics.js';
+import { initializeRules, filterRulesByLevel, runSimulatedRule, hashUrl, } from './accessibility-tester-heuristics.js';
 const DEFAULT_CONFIG = {
     defaultWCAGLevel: 'AA',
     includeWarnings: true,
@@ -109,28 +111,29 @@ export class AccessibilityTesterService {
     async audit(url, options) {
         try {
             const wcagLevel = options?.wcagLevel || this.config.defaultWCAGLevel;
+            const failures = [];
             if (this.shouldUseBrowserMode()) {
                 const browserClient = await this.getBrowserClient();
                 if (browserClient) {
                     const browserResult = await auditWithBrowserClient(browserClient, url, wcagLevel, this.config.browserConfig, options);
-                    if (browserResult.success) {
-                        await this.storeReport(browserResult.value);
-                        return browserResult;
-                    }
+                    if (browserResult.success)
+                        return await this.measuredReport(browserResult.value);
                     const errorMsg = getErrorMessage(browserResult);
+                    failures.push(errorMsg);
                     logger.warn(`Browser client audit failed: ${errorMsg}`);
                 }
                 if (this.vibiumClient && isBrowserModeEnabled() && isAxeCoreEnabled()) {
                     const vibiumResult = await auditWithVibium(this.vibiumClient, url, wcagLevel, this.config.browserConfig, options);
-                    if (vibiumResult.success) {
-                        await this.storeReport(vibiumResult.value);
-                        return vibiumResult;
-                    }
+                    if (vibiumResult.success)
+                        return await this.measuredReport(vibiumResult.value);
                     const errorMsg = getErrorMessage(vibiumResult);
-                    logger.warn(`Vibium audit failed, falling back to heuristic mode: ${errorMsg}`);
+                    failures.push(errorMsg);
+                    logger.warn(`Vibium audit failed; the page is not measured: ${errorMsg}`);
                 }
             }
-            return this.auditWithHeuristics(url, wcagLevel, options);
+            if (this.config.simulationMode)
+                return this.auditSimulated(url, wcagLevel, options);
+            return ok(this.notMeasuredReport(url, wcagLevel, this.notMeasuredReason(failures)));
         }
         catch (error) {
             return err(toError(error));
@@ -139,12 +142,10 @@ export class AccessibilityTesterService {
     async auditElement(url, selector) {
         if (this.shouldUseBrowserMode() && this.vibiumClient) {
             const browserResult = await auditElementWithVibium(this.vibiumClient, url, selector, this.config.defaultWCAGLevel, this.config.browserConfig);
-            if (browserResult.success) {
-                await this.storeReport(browserResult.value);
-                return browserResult;
-            }
+            if (browserResult.success)
+                return await this.measuredReport(browserResult.value);
             const errorMsg = getErrorMessage(browserResult);
-            logger.warn(`Browser mode element audit failed, falling back to heuristic mode: ${errorMsg}`);
+            logger.warn(`Browser mode element audit failed, falling back to a page audit: ${errorMsg}`);
         }
         return this.audit(url, {
             excludeSelectors: [],
@@ -152,9 +153,38 @@ export class AccessibilityTesterService {
         });
     }
     // ============================================================================
-    // Heuristic Audit
+    // Unmeasured Results (#1145)
     // ============================================================================
-    async auditWithHeuristics(url, wcagLevel, options) {
+    async measuredReport(report) {
+        const measured = { ...report, measured: true };
+        await this.storeReport(measured);
+        return ok(measured);
+    }
+    notMeasuredReason(failures) {
+        if (failures.length > 0)
+            return `no browser could audit the page (${failures.join('; ')})`;
+        if (!this.config.useBrowserMode)
+            return 'browser mode is disabled, and only a browser run measures a page';
+        return 'no browser is available (install agent-browser or connect Vibium) to load the page';
+    }
+    /** A report that says nothing was measured: no violations, no passes, no verdict. */
+    notMeasuredReport(url, wcagLevel, reason) {
+        return {
+            url,
+            timestamp: new Date(),
+            violations: [],
+            passes: [],
+            incomplete: filterRulesByLevel(this.rules, wcagLevel).map((rule) => ({
+                id: rule.id, description: rule.description, reason: 'Not measured: see notMeasuredReason', nodes: [],
+            })),
+            score: -1,
+            wcagLevel,
+            measured: false,
+            notMeasuredReason: reason,
+        };
+    }
+    /** Simulation mode: synthetic results, labelled unmeasured and never stored. */
+    async auditSimulated(url, wcagLevel, options) {
         try {
             const includeWarnings = options?.includeWarnings ?? this.config.includeWarnings;
             const applicableRules = includeWarnings
@@ -164,7 +194,7 @@ export class AccessibilityTesterService {
             const passes = [];
             const incomplete = [];
             for (const rule of applicableRules) {
-                const result = runRule(rule, { url }, this.config.simulationMode, this.config.enableColorContrastCheck);
+                const result = runSimulatedRule(rule, { url });
                 if (result.nodes.length > 0) {
                     violations.push({
                         id: rule.id,
@@ -192,19 +222,18 @@ export class AccessibilityTesterService {
                     });
                 }
             }
-            const totalChecks = applicableRules.length;
-            const failedChecks = violations.length;
-            const score = Math.round(((totalChecks - failedChecks) / totalChecks) * 100);
             const report = {
                 url,
                 timestamp: new Date(),
                 violations,
                 passes,
                 incomplete,
-                score,
+                // The synthetic score is not a measurement: -1, like every unmeasured score
+                score: -1,
                 wcagLevel,
+                measured: false,
+                notMeasuredReason: 'simulation mode: synthetic results, the page was not loaded',
             };
-            await this.storeReport(report);
             return ok(report);
         }
         catch (error) {
@@ -216,25 +245,19 @@ export class AccessibilityTesterService {
     // ============================================================================
     async checkContrast(url) {
         try {
-            const cacheKey = `visual-accessibility:contrast:${hashUrl(url)}`;
+            // v2 (#1145): never serve a guessed result cached by an earlier version.
+            const cacheKey = `visual-accessibility:contrast:v2:${hashUrl(url)}`;
             const cached = await this.memory.get(cacheKey);
             if (cached)
                 return ok(cached);
-            let analyses;
-            if (this.shouldUseBrowserMode() && this.vibiumClient) {
-                const browserResult = await checkContrastWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
-                if (browserResult.success) {
-                    analyses = browserResult.value;
-                }
-                else {
-                    const errorMsg = getErrorMessage(browserResult);
-                    logger.warn(`Browser mode contrast check failed, falling back to heuristic mode: ${errorMsg}`);
-                    analyses = analyzeContrastForElements(url);
-                }
+            if (!this.shouldUseBrowserMode() || !this.vibiumClient) {
+                return err(notMeasuredError('Color contrast', url, this.notMeasuredReason([])));
             }
-            else {
-                analyses = analyzeContrastForElements(url);
+            const browserResult = await checkContrastWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
+            if (!browserResult.success) {
+                return err(notMeasuredError('Color contrast', url, this.notMeasuredReason([getErrorMessage(browserResult)])));
             }
+            const analyses = browserResult.value;
             await this.memory.set(cacheKey, analyses, { namespace: 'visual-accessibility', ttl: 3600 });
             return ok(analyses);
         }
@@ -247,25 +270,23 @@ export class AccessibilityTesterService {
     // ============================================================================
     async validateWCAGLevel(url, level) {
         try {
-            const levelOrder = { A: 1, AA: 2, AAA: 3 };
-            const targetLevel = levelOrder[level];
-            const applicableCriteria = Object.values(WCAG_CRITERIA).filter((c) => levelOrder[c.level] <= targetLevel);
-            const failedCriteria = [];
-            const passedCriteria = [];
-            const urlHash = hashUrl(url);
-            const hashNum = parseInt(urlHash, 36);
-            for (const criterion of applicableCriteria) {
-                const ruleResult = validateCriterion(criterion, hashNum);
-                if (ruleResult.passed) {
-                    passedCriteria.push(criterion);
-                }
-                else {
-                    failedCriteria.push(criterion);
-                }
+            const audit = await this.audit(url, { wcagLevel: level, includeWarnings: true });
+            if (!audit.success)
+                return err(audit.error);
+            if (audit.value.measured !== true) {
+                return err(notMeasuredError(`WCAG ${level} validation`, url, audit.value.notMeasuredReason ?? 'not audited'));
             }
-            const passed = failedCriteria.length === 0;
+            const levelOrder = { A: 1, AA: 2, AAA: 3 };
+            const applicableCriteria = Object.values(WCAG_CRITERIA).filter((c) => levelOrder[c.level] <= levelOrder[level]);
+            const violated = new Set(audit.value.violations.flatMap((v) => v.wcagCriteria.map((c) => c.id)));
+            const failedCriteria = applicableCriteria.filter((c) => violated.has(c.id));
+            const passedCriteria = applicableCriteria.filter((c) => !violated.has(c.id));
             const score = Math.round((passedCriteria.length / applicableCriteria.length) * 100);
-            return ok({ level, passed, failedCriteria, passedCriteria, score });
+            return ok({
+                level, passed: failedCriteria.length === 0, failedCriteria, passedCriteria, score, measured: true,
+                limitations: ['A passed criterion means no automated axe-core check failed for it; ' +
+                        'keyboard operation, focus order and similar criteria still need manual review.'],
+            });
         }
         catch (error) {
             return err(toError(error));
@@ -276,25 +297,20 @@ export class AccessibilityTesterService {
     // ============================================================================
     async checkKeyboardNavigation(url) {
         try {
-            const cacheKey = `visual-accessibility:keyboard:${hashUrl(url)}`;
+            const cacheKey = `visual-accessibility:keyboard:v2:${hashUrl(url)}`;
             const cached = await this.memory.get(cacheKey);
             if (cached)
                 return ok(cached);
-            let report;
-            if (this.shouldUseBrowserMode() && this.config.enableKeyboardCheck && this.vibiumClient) {
-                const browserResult = await checkKeyboardWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
-                if (browserResult.success) {
-                    report = browserResult.value;
-                }
-                else {
-                    const errorMsg = getErrorMessage(browserResult);
-                    logger.warn(`Browser mode keyboard check failed, falling back to heuristic mode: ${errorMsg}`);
-                    report = generateKeyboardReportWithHeuristics(url);
-                }
+            if (!this.shouldUseBrowserMode() || !this.config.enableKeyboardCheck || !this.vibiumClient) {
+                const reason = this.config.enableKeyboardCheck
+                    ? this.notMeasuredReason([]) : 'the keyboard check is disabled';
+                return err(notMeasuredError('Keyboard navigation', url, reason));
             }
-            else {
-                report = generateKeyboardReportWithHeuristics(url);
+            const browserResult = await checkKeyboardWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
+            if (!browserResult.success) {
+                return err(notMeasuredError('Keyboard navigation', url, this.notMeasuredReason([getErrorMessage(browserResult)])));
             }
+            const report = browserResult.value;
             await this.memory.set(cacheKey, report, { namespace: 'visual-accessibility', ttl: 3600 });
             return ok(report);
         }
@@ -322,6 +338,9 @@ export class AccessibilityTesterService {
             if (!wcagResult.success) {
                 return err(new Error(`WCAG audit failed: ${wcagResult.error.message}`));
             }
+            if (wcagResult.value.measured !== true) {
+                return err(notMeasuredError('EU compliance', url, wcagResult.value.notMeasuredReason ?? 'not audited'));
+            }
             const euResult = await this.euComplianceService.validateCompliance(wcagResult.value, options);
             return euResult;
         }
@@ -348,4 +367,8 @@ export class AccessibilityTesterService {
         }
     }
 }
+/** #1145: an unmeasured check is an error with its reason, never an empty pass. */
+function notMeasuredError(check, url, reason) {
+    return new Error(`${check} NOT MEASURED for ${url}: ${reason}. No findings or verdict were produced.`);
+}
 //# sourceMappingURL=accessibility-tester.js.map

package/dist/integrations/embeddings/index/HNSWIndex.js

@@ -10,6 +10,10 @@
  * @module integrations/embeddings/index/HNSWIndex
  */
 import { createRequire } from 'node:module';
+// Static import so the bundlers inline the adapter. A runtime
+// require('../../../kernel/hnsw-adapter.js') resolves against the bundle
+// file instead and fails, which silently capped the index at 10,000 (#1237).
+import { HnswAdapter } from '../../../kernel/hnsw-adapter.js';
 const require = createRequire(import.meta.url);
 let cachedHnswlibCtor = null;
 function loadHnswlibConstructor() {
@@ -70,8 +74,6 @@ export class HNSWEmbeddingIndex {
         // ADR-071: Route through unified HnswAdapter when flag is enabled
         if (this.useUnified && this.unifiedAdapters) {
             try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const { HnswAdapter } = require('../../../kernel/hnsw-adapter.js');
                 const adapter = new HnswAdapter(`embedding-${namespace}`, {
                     dimensions: this.config.dimension,
                     M: this.config.M,
@@ -84,8 +86,10 @@ export class HNSWEmbeddingIndex {
                 this.nextId.set(namespace, 0);
                 return;
             }
-            catch {
-                // Fall through to hnswlib-node
+            catch (error) {
+                // Fall through to hnswlib-node, which holds at most 10,000 entries.
+                console.warn(`[HNSWEmbeddingIndex] Unified HNSW adapter unavailable for '${namespace}', ` +
+                    `using the legacy index (max 10000 entries): ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         // Legacy path: hnswlib-node

package/dist/integrations/ruvector/transfer-coherence-stub.js

@@ -11,9 +11,11 @@
  *
  * @module integrations/ruvector/transfer-coherence-stub
  */
-import { createRequire } from 'module';
 import { getRuVectorFeatureFlags } from './feature-flags.js';
-const esmRequire = createRequire(import.meta.url);
+// Static import so the bundlers inline the gate. A runtime
+// require('./coherence-gate.js') resolves against the bundle file instead,
+// fails, and silently returned the approve-everything stub (#1237).
+import { CoherenceGate } from './coherence-gate-core.js';
 // ============================================================================
 // Stub Implementation
 // ============================================================================
@@ -49,14 +51,7 @@ export class TransferCoherenceStub {
  */
 export function createTransferCoherenceGate() {
     if (getRuVectorFeatureFlags().useCoherenceGate) {
-        try {
-            // Dynamic require to avoid circular dependency at module level
-            const { CoherenceGate } = esmRequire('./coherence-gate.js');
-            return new CoherenceGate();
-        }
-        catch {
-            // Fall through to stub if CoherenceGate fails to load
-        }
+        return new CoherenceGate();
     }
     return new TransferCoherenceStub();
 }