agentic-qe 3.15.14 → 3.15.16

package/dist/domains/visual-accessibility/services/accessibility-tester-browser.d.ts

@@ -6,6 +6,7 @@ import { Result } from '../../../shared/types/index.js';
 import { AccessibilityReport, WCAGCriterion, ContrastAnalysis, KeyboardNavigationReport, KeyboardIssue, AuditOptions } from '../interfaces.js';
 import type { VibiumClient, AccessibilityResult as VibiumAccessibilityResult } from '../../../integrations/vibium/index.js';
 import type { IBrowserClient, IAgentBrowserClient } from '../../../integrations/browser/index.js';
+import { type AxeContrastData } from './accessibility-contrast.js';
 /**
  * Axe-core result structure from browser evaluation
  */
@@ -22,6 +23,8 @@ export interface AxeCoreResult {
             html: string;
             target: string[];
             failureSummary?: string;
+            /** color-contrast check data: the measured colours and ratio (#1228) */
+            contrast?: AxeContrastData;
         }>;
     }>;
     passes: string[];
@@ -38,13 +41,18 @@ export declare function isAgentBrowserClient(client: IBrowserClient): client is
  */
 export declare function getAxeTagsForWcagLevel(level: 'A' | 'AA' | 'AAA'): string[];
 /**
- * Map Vibium Severity type to our impact type
+ * Map an axe-core impact or a Vibium severity to our impact type
  */
 export declare function mapImpactSeverity(severity: string): 'critical' | 'serious' | 'moderate' | 'minor';
 /**
  * Extract error message from a Result
  */
 export declare function getErrorMessage<T, E extends Error>(result: Result<T, E>): string;
+/**
+ * Browser-side statements that load axe-core into the page when it is not
+ * loaded yet. For use inside an async function.
+ */
+export declare const AXE_LOADER_JS = "\n      // Check if axe is already loaded\n      if (typeof axe === 'undefined') {\n        // Inject axe-core from CDN\n        const script = document.createElement('script');\n        script.src = 'https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.8.4/axe.min.js';\n        script.crossOrigin = 'anonymous';\n        document.head.appendChild(script);\n\n        // Wait for script to load\n        await new Promise((resolve, reject) => {\n          script.onload = resolve;\n          script.onerror = () => reject(new Error('Failed to load axe-core'));\n          setTimeout(() => reject(new Error('Timeout loading axe-core')), 10000);\n        });\n      }";
 /**
  * Inject and run axe-core in the browser context
  */
@@ -62,9 +70,11 @@ export declare function mapAxeResultToReport(url: string, axeResult: AxeCoreResu
  */
 export declare function mapVibiumResultToReport(url: string, vibiumResult: VibiumAccessibilityResult, wcagLevel: 'A' | 'AA' | 'AAA'): AccessibilityReport;
 /**
- * Extract contrast analysis from Vibium accessibility result
+ * Extract contrast analysis from Vibium accessibility result.
+ * Only elements the audit reported are listed, with the values it reported
+ * (#1228). An error means the contrast rule produced no result.
  */
-export declare function extractContrastFromVibiumResult(vibiumResult: VibiumAccessibilityResult, defaultWCAGLevel: 'A' | 'AA' | 'AAA'): ContrastAnalysis[];
+export declare function extractContrastFromVibiumResult(vibiumResult: VibiumAccessibilityResult, defaultWCAGLevel: 'A' | 'AA' | 'AAA'): Result<ContrastAnalysis[], Error>;
 /**
  * Run accessibility audit using unified browser client (agent-browser or other)
  */
@@ -100,6 +110,11 @@ export declare function checkKeyboardWithVibium(vibiumClient: VibiumClient, url:
     headless: boolean;
     timeout: number;
 }): Promise<Result<KeyboardNavigationReport, Error>>;
+/**
+ * What an automated keyboard check does not measure (#1228): it lists the
+ * focusable elements and runs rule checks, but tabs through nothing.
+ */
+export declare const KEYBOARD_NOT_MEASURED: readonly string[];
 /**
  * Get element type from tag name
  */

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

@@ -6,6 +6,7 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { AXE_CONTRAST_DATA_JS, contrastValues, isContrastRule, toContrastAnalysis, } from './accessibility-contrast.js';
 /**
  * WCAG 2.2 criteria definitions (shared reference)
  */
@@ -51,11 +52,16 @@ export function getAxeTagsForWcagLevel(level) {
     return [...aaTags, 'wcag2aaa', 'wcag21aaa', 'wcag22aaa'];
 }
 /**
- * Map Vibium Severity type to our impact type
+ * Map an axe-core impact or a Vibium severity to our impact type
  */
 export function mapImpactSeverity(severity) {
     const severityMap = {
+        // axe-core impacts (#1270)
         critical: 'critical',
+        serious: 'serious',
+        moderate: 'moderate',
+        minor: 'minor',
+        // Vibium severities
         high: 'serious',
         medium: 'moderate',
         low: 'minor',
@@ -76,13 +82,10 @@ export function getErrorMessage(result) {
 // Axe-Core Injection & Execution
 // ============================================================================
 /**
- * Inject and run axe-core in the browser context
+ * Browser-side statements that load axe-core into the page when it is not
+ * loaded yet. For use inside an async function.
  */
-export async function runAxeCore(client, wcagLevel, options) {
-    const tags = getAxeTagsForWcagLevel(wcagLevel);
-    const excludeSelectors = options?.excludeSelectors ?? [];
-    const axeScript = `
-    (async function() {
+export const AXE_LOADER_JS = `
       // Check if axe is already loaded
       if (typeof axe === 'undefined') {
         // Inject axe-core from CDN
@@ -97,7 +100,16 @@ export async function runAxeCore(client, wcagLevel, options) {
           script.onerror = () => reject(new Error('Failed to load axe-core'));
           setTimeout(() => reject(new Error('Timeout loading axe-core')), 10000);
         });
-      }
+      }`;
+/**
+ * Inject and run axe-core in the browser context
+ */
+export async function runAxeCore(client, wcagLevel, options) {
+    const tags = getAxeTagsForWcagLevel(wcagLevel);
+    const excludeSelectors = options?.excludeSelectors ?? [];
+    const axeScript = `
+    (async function() {
+      ${AXE_LOADER_JS}
 
       // Configure and run axe
       const config = {
@@ -122,7 +134,8 @@ export async function runAxeCore(client, wcagLevel, options) {
             selector: n.target.join(' > '),
             html: n.html,
             target: n.target,
-            failureSummary: n.failureSummary
+            failureSummary: n.failureSummary,
+            contrast: (${AXE_CONTRAST_DATA_JS})(n)
           }))
         })),
         passes: results.passes.map(p => p.id),
@@ -188,6 +201,8 @@ export function mapAxeResultToReport(url, axeResult, wcagLevel) {
             html: n.html,
             target: n.target,
             failureSummary: n.failureSummary ?? '',
+            // #1228: keep the colours and ratio axe-core measured
+            ...(isContrastRule(v.id) ? { contrast: contrastValues(n.contrast, n.failureSummary) } : {}),
         })),
     }));
     const passes = axeResult.passes.map(ruleId => ({
@@ -271,42 +286,24 @@ export function mapVibiumResultToReport(url, vibiumResult, wcagLevel) {
     };
 }
 /**
- * Extract contrast analysis from Vibium accessibility result
+ * Extract contrast analysis from Vibium accessibility result.
+ * Only elements the audit reported are listed, with the values it reported
+ * (#1228). An error means the contrast rule produced no result.
  */
 export function extractContrastFromVibiumResult(vibiumResult, defaultWCAGLevel) {
     const analyses = [];
     for (const violation of vibiumResult.violations) {
-        if (violation.rule.includes('contrast') || violation.id.includes('contrast')) {
+        if (isContrastRule(violation.rule) || isContrastRule(violation.id)) {
             for (const node of violation.nodes) {
-                const colorMatch = node.failureSummary.match(/foreground:?\s*([#\w\d]+).*?background:?\s*([#\w\d]+)/i);
-                const ratioMatch = node.failureSummary.match(/ratio\s*[:\s]*(\d+\.?\d*)/i);
-                analyses.push({
-                    element: node.selector,
-                    foreground: colorMatch?.[1] || '#000000',
-                    background: colorMatch?.[2] || '#ffffff',
-                    ratio: ratioMatch ? parseFloat(ratioMatch[1]) : 1.0,
-                    requiredRatio: defaultWCAGLevel === 'AAA' ? 7 : 4.5,
-                    passes: false,
-                    wcagLevel: defaultWCAGLevel,
-                });
+                analyses.push(toContrastAnalysis(node.selector, contrastValues(undefined, node.failureSummary), false, defaultWCAGLevel));
             }
         }
     }
-    if (analyses.length === 0 && vibiumResult.passedRules.some(r => r.includes('contrast'))) {
-        const commonElements = ['h1', 'p', 'a', 'button'];
-        for (const element of commonElements) {
-            analyses.push({
-                element,
-                foreground: '#333333',
-                background: '#ffffff',
-                ratio: 12.63,
-                requiredRatio: defaultWCAGLevel === 'AAA' ? 7 : 4.5,
-                passes: true,
-                wcagLevel: defaultWCAGLevel,
-            });
-        }
+    if (analyses.length === 0 && !vibiumResult.passedRules.some(isContrastRule)) {
+        return err(new Error('the contrast rule reported neither a violation nor a pass'));
     }
-    return analyses;
+    // A passing rule is reported without its elements, so no element is listed for it.
+    return ok(analyses);
 }
 // ============================================================================
 // Browser Audit Methods
@@ -454,8 +451,7 @@ export async function checkContrastWithVibium(vibiumClient, url, defaultWCAGLeve
             if (!a11yResult.success) {
                 return err(new Error(`Contrast check failed: ${getErrorMessage(a11yResult)}`));
             }
-            const analyses = extractContrastFromVibiumResult(a11yResult.value, defaultWCAGLevel);
-            return ok(analyses);
+            return extractContrastFromVibiumResult(a11yResult.value, defaultWCAGLevel);
         }
         finally {
             await vibiumClient.quit();
@@ -497,7 +493,8 @@ export async function checkKeyboardWithVibium(vibiumClient, url, defaultWCAGLeve
                 index,
                 selector: elem.selector,
                 elementType: getElementType(elem.tagName),
-                hasVisibleFocus: true,
+                // #1228: the focus indicator is not checked, so it is not reported as visible
+                hasVisibleFocus: null,
             }));
             const a11yResult = await vibiumClient.checkAccessibility({
                 wcagLevel: defaultWCAGLevel,
@@ -507,6 +504,10 @@ export async function checkKeyboardWithVibium(vibiumClient, url, defaultWCAGLeve
             });
             const issues = [];
             const traps = [];
+            const notMeasured = [...KEYBOARD_NOT_MEASURED];
+            if (!a11yResult.success) {
+                notMeasured.push(`keyboard rule checks (${getErrorMessage(a11yResult)})`);
+            }
             if (a11yResult.success) {
                 for (const violation of a11yResult.value.violations) {
                     if (violation.rule.includes('focus') || violation.rule.includes('keyboard')) {
@@ -535,6 +536,7 @@ export async function checkKeyboardWithVibium(vibiumClient, url, defaultWCAGLeve
                 tabOrder,
                 issues,
                 traps,
+                notMeasured,
             };
             return ok(report);
         }
@@ -549,6 +551,14 @@ export async function checkKeyboardWithVibium(vibiumClient, url, defaultWCAGLeve
 // ============================================================================
 // Keyboard Helpers
 // ============================================================================
+/**
+ * What an automated keyboard check does not measure (#1228): it lists the
+ * focusable elements and runs rule checks, but tabs through nothing.
+ */
+export const KEYBOARD_NOT_MEASURED = [
+    'visible focus indicator (hasVisibleFocus is null)',
+    'focus traps (no element was tabbed through)',
+];
 /**
  * Get element type from tag name
  */
@@ -572,7 +582,7 @@ export function mapKeyboardIssueType(rule) {
     if (rule.includes('skip') || rule.includes('bypass')) {
         return 'skip-link-missing';
     }
-    if (rule.includes('order') || rule.includes('sequence')) {
+    if (rule.includes('order') || rule.includes('sequence') || rule.includes('tabindex')) {
         return 'incorrect-tab-order';
     }
     return 'non-interactive-focusable';

package/dist/domains/visual-accessibility/services/accessibility-tester-checks.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Contrast and keyboard checks through the unified browser client (#1228)
+ *
+ * The page audit runs through agent-browser (the default browser for audits);
+ * these checks use the same client, so they are measured whenever the audit is.
+ * Each runs axe-core in the loaded page and reports only what it returned.
+ */
+import { Result } from '../../../shared/types/index.js';
+import type { IBrowserClient } from '../../../integrations/browser/index.js';
+import type { ContrastAnalysis, KeyboardNavigationReport } from '../interfaces.js';
+type WcagLevel = 'A' | 'AA' | 'AAA';
+type BrowserConfig = {
+    headless: boolean;
+    timeout: number;
+};
+/**
+ * Check colour contrast with axe-core's contrast rule. Lists every element the
+ * rule checked, failing and passing, with the colours and ratio it measured.
+ */
+export declare function checkContrastWithBrowserClient(client: IBrowserClient, url: string, wcagLevel: WcagLevel, browserConfig: BrowserConfig): Promise<Result<ContrastAnalysis[], Error>>;
+/**
+ * Check keyboard navigation: the focusable elements in document order and
+ * axe-core's keyboard rules. Focus indicators and traps are not measured.
+ */
+export declare function checkKeyboardWithBrowserClient(client: IBrowserClient, url: string, browserConfig: BrowserConfig): Promise<Result<KeyboardNavigationReport, Error>>;
+export {};
+//# sourceMappingURL=accessibility-tester-checks.d.ts.map

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

@@ -0,0 +1,137 @@
+/**
+ * Agentic QE v3 - Contrast and keyboard checks through the unified browser client (#1228)
+ *
+ * The page audit runs through agent-browser (the default browser for audits);
+ * these checks use the same client, so they are measured whenever the audit is.
+ * Each runs axe-core in the loaded page and reports only what it returned.
+ */
+import { ok, err } from '../../../shared/types/index.js';
+import { toError } from '../../../shared/error-utils.js';
+import { safeJsonParse } from '../../../shared/safe-json.js';
+import { AXE_LOADER_JS, KEYBOARD_NOT_MEASURED, getElementType, mapKeyboardIssueType } from './accessibility-tester-browser.js';
+import { AXE_CONTRAST_DATA_JS, contrastValues, toContrastAnalysis } from './accessibility-contrast.js';
+/** axe-core rules that concern keyboard operation and focus order. */
+const KEYBOARD_RULES = ['bypass', 'tabindex', 'scrollable-region-focusable', 'accesskeys', 'frame-focusable-content'];
+/** Browser-side helper that builds a CSS selector for an element. */
+const CSS_PATH_JS = `function (el) {
+  if (el.id) return '#' + CSS.escape(el.id);
+  var parts = [];
+  while (el && el.nodeType === 1 && el !== document.documentElement) {
+    var part = el.tagName.toLowerCase();
+    var parent = el.parentElement;
+    if (parent) {
+      var same = Array.prototype.filter.call(parent.children, function (c) { return c.tagName === el.tagName; });
+      if (same.length > 1) part += ':nth-of-type(' + (same.indexOf(el) + 1) + ')';
+    }
+    parts.unshift(part);
+    el = parent;
+  }
+  return parts.join(' > ');
+}`;
+/**
+ * Check colour contrast with axe-core's contrast rule. Lists every element the
+ * rule checked, failing and passing, with the colours and ratio it measured.
+ */
+export async function checkContrastWithBrowserClient(client, url, wcagLevel, browserConfig) {
+    const rule = wcagLevel === 'AAA' ? 'color-contrast-enhanced' : 'color-contrast';
+    const script = `
+    (async function() {
+      ${AXE_LOADER_JS}
+      const contrastOf = ${AXE_CONTRAST_DATA_JS};
+      const results = await axe.run(document, { runOnly: { type: 'rule', values: ['${rule}'] } });
+      const nodesOf = (rules) => rules.flatMap(r => r.nodes.map(n => ({
+        selector: n.target.join(' > '),
+        failureSummary: n.failureSummary,
+        contrast: contrastOf(n)
+      })));
+      return JSON.stringify({ violations: nodesOf(results.violations), passes: nodesOf(results.passes) });
+    })();
+  `;
+    const result = await withLoadedPage(client, url, browserConfig, () => evaluateJson(client, script, 'contrast check'));
+    if (!result.success)
+        return result;
+    return ok([
+        ...result.value.violations.map((n) => toContrastAnalysis(n.selector, contrastValues(n.contrast, n.failureSummary), false, wcagLevel)),
+        ...result.value.passes.map((n) => toContrastAnalysis(n.selector, contrastValues(n.contrast, n.failureSummary), true, wcagLevel)),
+    ]);
+}
+/**
+ * Check keyboard navigation: the focusable elements in document order and
+ * axe-core's keyboard rules. Focus indicators and traps are not measured.
+ */
+export async function checkKeyboardWithBrowserClient(client, url, browserConfig) {
+    const script = `
+    (async function() {
+      ${AXE_LOADER_JS}
+      const cssPath = ${CSS_PATH_JS};
+      const candidates = document.querySelectorAll('a[href], button, input, select, textarea, [tabindex]:not([tabindex="-1"])');
+      const focusable = Array.from(candidates)
+        .filter(el => !el.disabled && el.getClientRects().length > 0)
+        .map(el => ({ selector: cssPath(el), tagName: el.tagName }));
+      const results = await axe.run(document, { runOnly: { type: 'rule', values: ${JSON.stringify(KEYBOARD_RULES)} } });
+      return JSON.stringify({
+        focusable,
+        violations: results.violations.map(v => ({
+          id: v.id,
+          nodes: v.nodes.map(n => ({ selector: n.target.join(' > '), failureSummary: n.failureSummary }))
+        }))
+      });
+    })();
+  `;
+    const result = await withLoadedPage(client, url, browserConfig, () => evaluateJson(client, script, 'keyboard check'));
+    if (!result.success)
+        return result;
+    const tabOrder = result.value.focusable.map((el, index) => ({
+        index,
+        selector: el.selector,
+        elementType: getElementType(el.tagName),
+        hasVisibleFocus: null,
+    }));
+    const issues = result.value.violations.flatMap((v) => v.nodes.map((n) => ({
+        type: mapKeyboardIssueType(v.id),
+        selector: n.selector,
+        description: n.failureSummary ?? v.id,
+    })));
+    return ok({
+        url,
+        focusableElements: tabOrder.length,
+        tabOrder,
+        issues,
+        traps: [],
+        notMeasured: [...KEYBOARD_NOT_MEASURED],
+    });
+}
+async function withLoadedPage(client, url, browserConfig, run) {
+    try {
+        const launchResult = await client.launch({ headless: browserConfig.headless });
+        if (!launchResult.success) {
+            return err(new Error(`Failed to launch browser: ${launchResult.error?.message ?? 'Unknown error'}`));
+        }
+        try {
+            const navResult = await client.navigate(url);
+            if (!navResult.success) {
+                return err(new Error(`Failed to navigate to ${url}: ${navResult.error?.message ?? 'Unknown error'}`));
+            }
+            return await run();
+        }
+        finally {
+            await client.quit();
+        }
+    }
+    catch (error) {
+        return err(toError(error));
+    }
+}
+async function evaluateJson(client, script, label) {
+    const evalResult = await client.evaluate(script);
+    if (!evalResult.success) {
+        return err(new Error(`Failed to run the ${label}: ${evalResult.error?.message ?? 'Unknown error'}`));
+    }
+    try {
+        return ok(safeJsonParse(evalResult.value));
+    }
+    catch (parseError) {
+        return err(new Error(`Failed to parse the ${label} results: ${parseError}`));
+    }
+}
+//# sourceMappingURL=accessibility-tester-checks.js.map

package/dist/domains/visual-accessibility/services/accessibility-tester.d.ts

@@ -65,6 +65,11 @@ export declare class AccessibilityTesterService implements IAccessibilityAuditin
     /** Simulation mode: synthetic results, labelled unmeasured and never stored. */
     private auditSimulated;
     checkContrast(url: string): Promise<Result<ContrastAnalysis[], Error>>;
+    /**
+     * Run a check with the browser client the page audit uses (agent-browser),
+     * then Vibium (#1228). The error is the not-measured reason when neither ran.
+     */
+    private runBrowserCheck;
     validateWCAGLevel(url: string, level: 'A' | 'AA' | 'AAA'): Promise<Result<WCAGValidationResult, Error>>;
     checkKeyboardNavigation(url: string): Promise<Result<KeyboardNavigationReport, Error>>;
     private storeReport;

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

@@ -30,6 +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 { checkContrastWithBrowserClient, checkKeyboardWithBrowserClient, } from './accessibility-tester-checks.js';
 import { initializeRules, filterRulesByLevel, runSimulatedRule, hashUrl, } from './accessibility-tester-heuristics.js';
 const DEFAULT_CONFIG = {
     defaultWCAGLevel: 'AA',
@@ -245,26 +246,47 @@ export class AccessibilityTesterService {
     // ============================================================================
     async checkContrast(url) {
         try {
-            // v2 (#1145): never serve a guessed result cached by an earlier version.
-            const cacheKey = `visual-accessibility:contrast:v2:${hashUrl(url)}`;
+            // v3 (#1145, #1228): never serve a guessed result cached by an earlier version.
+            const cacheKey = `visual-accessibility:contrast:v3:${hashUrl(url)}`;
             const cached = await this.memory.get(cacheKey);
             if (cached)
                 return ok(cached);
-            if (!this.shouldUseBrowserMode() || !this.vibiumClient) {
-                return err(notMeasuredError('Color contrast', url, this.notMeasuredReason([])));
-            }
-            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);
+            const level = this.config.defaultWCAGLevel;
+            const result = await this.runBrowserCheck((client) => checkContrastWithBrowserClient(client, url, level, this.config.browserConfig), (vibium) => checkContrastWithVibium(vibium, url, level, this.config.browserConfig));
+            if (!result.success)
+                return err(notMeasuredError('Color contrast', url, result.error.message));
+            await this.memory.set(cacheKey, result.value, { namespace: 'visual-accessibility', ttl: 3600 });
+            return ok(result.value);
         }
         catch (error) {
             return err(toError(error));
         }
     }
+    /**
+     * Run a check with the browser client the page audit uses (agent-browser),
+     * then Vibium (#1228). The error is the not-measured reason when neither ran.
+     */
+    async runBrowserCheck(withClient, withVibium) {
+        const failures = [];
+        if (this.shouldUseBrowserMode()) {
+            const browserClient = await this.getBrowserClient();
+            if (browserClient) {
+                const result = await withClient(browserClient);
+                if (result.success)
+                    return result;
+                failures.push(getErrorMessage(result));
+                logger.warn(`Browser client check failed: ${getErrorMessage(result)}`);
+            }
+            if (this.vibiumClient) {
+                const result = await withVibium(this.vibiumClient);
+                if (result.success)
+                    return result;
+                failures.push(getErrorMessage(result));
+                logger.warn(`Vibium check failed: ${getErrorMessage(result)}`);
+            }
+        }
+        return err(new Error(this.notMeasuredReason(failures)));
+    }
     // ============================================================================
     // WCAG Validation
     // ============================================================================
@@ -297,22 +319,19 @@ export class AccessibilityTesterService {
     // ============================================================================
     async checkKeyboardNavigation(url) {
         try {
-            const cacheKey = `visual-accessibility:keyboard:v2:${hashUrl(url)}`;
+            // v3 (#1228): earlier versions cached hasVisibleFocus: true without measuring it.
+            const cacheKey = `visual-accessibility:keyboard:v3:${hashUrl(url)}`;
             const cached = await this.memory.get(cacheKey);
             if (cached)
                 return ok(cached);
-            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));
+            if (!this.config.enableKeyboardCheck) {
+                return err(notMeasuredError('Keyboard navigation', url, 'the keyboard check is disabled'));
             }
-            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);
+            const result = await this.runBrowserCheck((client) => checkKeyboardWithBrowserClient(client, url, this.config.browserConfig), (vibium) => checkKeyboardWithVibium(vibium, url, this.config.defaultWCAGLevel, this.config.browserConfig));
+            if (!result.success)
+                return err(notMeasuredError('Keyboard navigation', url, result.error.message));
+            await this.memory.set(cacheKey, result.value, { namespace: 'visual-accessibility', ttl: 3600 });
+            return ok(result.value);
         }
         catch (error) {
             return err(toError(error));

package/dist/domains/visual-accessibility/services/browser-swarm-coordinator.d.ts

@@ -178,9 +178,8 @@ export declare class BrowserSwarmCoordinator {
     /**
      * Run accessibility audit across all viewports
      *
-     * Navigates to the URL and runs accessibility audits in each viewport.
-     * Note: This is a placeholder implementation. Real accessibility auditing
-     * would require integration with axe-core or similar tools.
+     * Navigates to the URL and runs axe-core in each viewport. A viewport whose
+     * audit did not run is listed under failures, never as a clean report (#1228).
      *
      * @param url - URL to audit
      * @returns Accessibility audit results by viewport

package/dist/domains/visual-accessibility/services/browser-swarm-coordinator.js

@@ -24,6 +24,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { FilePath } from '../../../shared/value-objects/index.js';
 import { toError } from '../../../shared/error-utils.js';
+import { runAxeCore, mapAxeResultToReport } from './accessibility-tester-browser.js';
 import { getBrowserClientForUseCase, } from '../../../integrations/browser/index.js';
 /**
  * Standard viewport configurations for common devices
@@ -304,9 +305,8 @@ export class BrowserSwarmCoordinator {
     /**
      * Run accessibility audit across all viewports
      *
-     * Navigates to the URL and runs accessibility audits in each viewport.
-     * Note: This is a placeholder implementation. Real accessibility auditing
-     * would require integration with axe-core or similar tools.
+     * Navigates to the URL and runs axe-core in each viewport. A viewport whose
+     * audit did not run is listed under failures, never as a clean report (#1228).
      *
      * @param url - URL to audit
      * @returns Accessibility audit results by viewport
@@ -326,17 +326,11 @@ export class BrowserSwarmCoordinator {
                 if (this.isAgentBrowserClient(session.client)) {
                     await session.client.setViewport(viewport.width, viewport.height);
                 }
-                // TODO: Integrate with axe-core or similar accessibility testing tool
-                // For now, return a placeholder report
-                const report = {
-                    url,
-                    timestamp: new Date(),
-                    violations: [],
-                    passes: [],
-                    incomplete: [],
-                    score: 100,
-                    wcagLevel: 'AA',
-                };
+                const axeResult = await runAxeCore(session.client, 'AA');
+                if (!axeResult.success) {
+                    throw new Error(`Accessibility NOT MEASURED in this viewport: ${axeResult.error.message}`);
+                }
+                const report = { ...mapAxeResultToReport(url, axeResult.value, 'AA'), measured: true };
                 return report;
             });
             // Process results

package/dist/feedback/coverage-learner.js

@@ -171,12 +171,15 @@ export class CoverageLearner {
     /**
      * Persist a coverage session to the database
      */
-    persistSession(session) {
+    async persistSession(session) {
         if (!this.db)
             return;
         try {
-            const database = this.db.getDatabase();
-            database.prepare(`
+            const memory = this.db;
+            const database = memory.getDatabase();
+            // #1283: queued, so a locked memory.db does not freeze the MCP server's
+            // event loop while the tool call that recorded this coverage session waits.
+            await memory.writeWhenUnlocked(() => database.prepare(`
         INSERT OR REPLACE INTO coverage_sessions (
           id, target_path, agent_id, technique,
           before_lines, before_branches, before_functions,
@@ -184,10 +187,10 @@ export class CoverageLearner {
           tests_generated, tests_passed, gaps_json,
           duration_ms, started_at, completed_at, context_json
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(session.id, session.targetPath, session.agentId, session.technique, session.beforeCoverage.lines, session.beforeCoverage.branches, session.beforeCoverage.functions, session.afterCoverage.lines, session.afterCoverage.branches, session.afterCoverage.functions, session.testsGenerated, session.testsPassed, JSON.stringify(session.gapsTargeted), session.durationMs, session.startedAt instanceof Date ? session.startedAt.toISOString() : session.startedAt, session.completedAt instanceof Date ? session.completedAt.toISOString() : session.completedAt, session.context ? JSON.stringify(session.context) : null);
+      `).run(session.id, session.targetPath, session.agentId, session.technique, session.beforeCoverage.lines, session.beforeCoverage.branches, session.beforeCoverage.functions, session.afterCoverage.lines, session.afterCoverage.branches, session.afterCoverage.functions, session.testsGenerated, session.testsPassed, JSON.stringify(session.gapsTargeted), session.durationMs, session.startedAt instanceof Date ? session.startedAt.toISOString() : session.startedAt, session.completedAt instanceof Date ? session.completedAt.toISOString() : session.completedAt, session.context ? JSON.stringify(session.context) : null));
             this.persistCount++;
             if (this.persistCount % CoverageLearner.RETENTION_CLEANUP_INTERVAL === 0) {
-                this.enforceRetention(database);
+                await this.enforceRetention(memory);
             }
         }
         catch (error) {
@@ -197,14 +200,15 @@ export class CoverageLearner {
     /**
      * Delete oldest rows beyond retention limit
      */
-    enforceRetention(database) {
+    async enforceRetention(memory) {
         try {
+            const database = memory.getDatabase();
             const maxRows = this.config.maxOutcomesInMemory * 2;
-            database.prepare(`
+            await memory.writeWhenUnlocked(() => database.prepare(`
         DELETE FROM coverage_sessions WHERE id NOT IN (
           SELECT id FROM coverage_sessions ORDER BY created_at DESC LIMIT ?
         )
-      `).run(maxRows);
+      `).run(maxRows));
         }
         catch (error) {
             console.warn('[CoverageLearner] Retention cleanup failed:', toErrorMessage(error));
@@ -216,7 +220,7 @@ export class CoverageLearner {
     async learnFromSession(session) {
         // Store session
         this.sessionStore.add(session);
-        this.persistSession(session);
+        await this.persistSession(session);
         // Calculate improvement
         const improvement = this.calculateOverallImprovement(session);
         // Only learn from significant improvements