agentic-qe 3.9.8 → 3.9.9

package/assets/skills/qe-browser/scripts/visual-diff.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+// qe-browser: visual regression against stored PNG baselines.
+//
+// Usage:
+//   node visual-diff.js --name homepage
+//   node visual-diff.js --name homepage --threshold 0.02
+//   node visual-diff.js --name hero --selector "#hero"      # not supported in v26.3.x
+//   node visual-diff.js --name homepage --update-baseline
+//
+// THRESHOLD SEMANTICS (M1 — devil's-advocate finding):
+//   --threshold is the MAX FRACTION of pixels allowed to differ before the
+//   check fails. The default is 0.10 (10% of pixels may differ).
+//     - threshold 0.00 → require pixel-perfect match
+//     - threshold 0.02 → allow up to 2% pixel difference
+//     - threshold 0.50 → allow up to 50% pixel difference (very lax)
+//   Internally we compute `similarity = 1 - diffPixels / totalPixels` and
+//   pass when `similarity >= 1 - threshold`. This is the standard convention
+//   used by Playwright's `maxDiffPixelRatio` and BackstopJS.
+//
+// Baselines live in .aqe/visual-baselines/<sanitized-name>.png
+// Diff images (if pixelmatch available) go to .aqe/visual-baselines/<name>.diff.png
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const {
+  vibium,
+  envelope,
+  parseArgs,
+  emit,
+  fail,
+  runOrSkip,
+  rethrowIfUnavailable,
+} = require('./lib/vibium');
+
+const BASELINE_DIR = path.join(process.cwd(), '.aqe', 'visual-baselines');
+
+function sanitize(name) {
+  return String(name).replace(/[^A-Za-z0-9_-]/g, '_');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+// Vibium screenshot quirks (verified against v26.3.18 on 2026-04-09):
+//   1. `vibium screenshot -o <path>` IGNORES the directory in <path>.
+//      Only the basename is used, and the file is saved to
+//      `~/Pictures/Vibium/<basename>`. We work around this by reading from
+//      Vibium's actual output dir and copying to the requested location.
+//   2. `--selector` flag does NOT exist on `vibium screenshot`. Selector-
+//      scoped baselines are not supported in v26.3.x. We surface a clear
+//      error if a caller passes one. Future Vibium versions may add it.
+function vibiumPicturesDir() {
+  // Vibium hardcodes ~/Pictures/Vibium as the screenshot output directory.
+  return path.join(process.env.HOME || '/home/vscode', 'Pictures', 'Vibium');
+}
+
+function captureScreenshot(selector, outputPath) {
+  if (selector) {
+    throw new Error(
+      'vibium screenshot --selector is not supported in Vibium v26.3.x. ' +
+      'Drop the --selector argument and crop the resulting full-page PNG with ' +
+      'a separate image-processing step (e.g. ImageMagick `convert -crop`). ' +
+      'Tracking upstream — if Vibium adds --selector support, this script ' +
+      'should switch to passing it through.'
+    );
+  }
+  const basename = path.basename(outputPath);
+  const args = ['screenshot', '-o', basename, '--full-page'];
+  const res = vibium(args);
+  if (res.status !== 0) {
+    throw new Error(`vibium screenshot failed: ${res.stderr.trim() || res.stdout.trim()}`);
+  }
+  // Vibium wrote the file to ~/Pictures/Vibium/<basename>, not outputPath.
+  // Copy it to where the caller asked. Use copy-then-unlink so we leave
+  // Vibium's own dir clean for the next run.
+  const vibiumPath = path.join(vibiumPicturesDir(), basename);
+  if (!fs.existsSync(vibiumPath)) {
+    throw new Error(`screenshot output not created at ${vibiumPath} (vibium said: ${res.stdout.trim()})`);
+  }
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.copyFileSync(vibiumPath, outputPath);
+  fs.unlinkSync(vibiumPath);
+  return outputPath;
+}
+
+function tryLoadPixelmatch() {
+  try {
+    const pixelmatch = require('pixelmatch');
+    const { PNG } = require('pngjs');
+    return { pixelmatch, PNG };
+  } catch (_err) {
+    return null;
+  }
+}
+
+function parsePngSize(buffer) {
+  // PNG header: 8 bytes signature + 8 bytes IHDR chunk length/type + 4 width + 4 height
+  if (buffer.length < 24) return null;
+  const sig = buffer.slice(0, 8);
+  const expected = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  if (!sig.equals(expected)) return null;
+  const width = buffer.readUInt32BE(16);
+  const height = buffer.readUInt32BE(20);
+  return { width, height };
+}
+
+function hashBuffer(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+function compareWithPixelmatch(baselineBuf, currentBuf, diffPath) {
+  const mod = tryLoadPixelmatch();
+  if (!mod) return null;
+  const { pixelmatch, PNG } = mod;
+  const baseline = PNG.sync.read(baselineBuf);
+  const current = PNG.sync.read(currentBuf);
+  if (baseline.width !== current.width || baseline.height !== current.height) {
+    return {
+      similarity: 0,
+      diffPixelCount: Math.max(
+        baseline.width * baseline.height,
+        current.width * current.height
+      ),
+      width: current.width,
+      height: current.height,
+      sizeMismatch: true,
+    };
+  }
+  const { width, height } = baseline;
+  const diff = new PNG({ width, height });
+  const diffCount = pixelmatch(baseline.data, current.data, diff.data, width, height, {
+    threshold: 0.1,
+  });
+  if (diffPath) {
+    fs.writeFileSync(diffPath, PNG.sync.write(diff));
+  }
+  const totalPixels = width * height;
+  return {
+    similarity: 1 - diffCount / totalPixels,
+    diffPixelCount: diffCount,
+    width,
+    height,
+    sizeMismatch: false,
+  };
+}
+
+function compareFallback(baselineBuf, currentBuf) {
+  // Exact-match fallback when pixelmatch is not installed.
+  // Same hash = identical; otherwise we only know width/height and rough similarity from byte diff.
+  const bSize = parsePngSize(baselineBuf);
+  const cSize = parsePngSize(currentBuf);
+  if (!bSize || !cSize) {
+    return {
+      similarity: 0,
+      diffPixelCount: 0,
+      width: cSize ? cSize.width : 0,
+      height: cSize ? cSize.height : 0,
+      sizeMismatch: true,
+      note: 'pixelmatch not installed and PNG header unreadable',
+    };
+  }
+  if (bSize.width !== cSize.width || bSize.height !== cSize.height) {
+    return {
+      similarity: 0,
+      diffPixelCount: 0,
+      width: cSize.width,
+      height: cSize.height,
+      sizeMismatch: true,
+      note: 'pixelmatch not installed; size mismatch',
+    };
+  }
+  const same = hashBuffer(baselineBuf) === hashBuffer(currentBuf);
+  return {
+    similarity: same ? 1 : 0,
+    diffPixelCount: same ? 0 : bSize.width * bSize.height,
+    width: cSize.width,
+    height: cSize.height,
+    sizeMismatch: false,
+    note: same ? undefined : 'pixelmatch not installed; exact-hash fallback reports 0 similarity',
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const name = args.name;
+  if (!name) return fail('visual-diff', 'missing --name argument');
+
+  const threshold = args.threshold !== undefined ? parseFloat(args.threshold) : 0.1;
+  if (Number.isNaN(threshold) || threshold < 0 || threshold > 1) {
+    return fail('visual-diff', '--threshold must be between 0 and 1');
+  }
+  const updateBaseline = Boolean(args['update-baseline']);
+  const selector = args.selector;
+
+  try {
+    ensureDir(BASELINE_DIR);
+    const sanitized = sanitize(name);
+    const baselinePath = path.join(BASELINE_DIR, `${sanitized}.png`);
+    const currentPath = path.join(BASELINE_DIR, `${sanitized}.current.png`);
+    const diffPath = path.join(BASELINE_DIR, `${sanitized}.diff.png`);
+
+    const startedAt = Date.now();
+    captureScreenshot(selector, currentPath);
+    const currentBuf = fs.readFileSync(currentPath);
+
+    if (!fs.existsSync(baselinePath) || updateBaseline) {
+      fs.writeFileSync(baselinePath, currentBuf);
+      const size = parsePngSize(currentBuf) || { width: 0, height: 0 };
+      return emit(
+        envelope({
+          operation: 'visual-diff',
+          summary: updateBaseline
+            ? `Baseline "${name}" updated`
+            : `Baseline "${name}" created`,
+          status: 'success',
+          details: {
+            visualDiff: {
+              name,
+              status: updateBaseline ? 'baseline_updated' : 'baseline_created',
+              similarity: 1,
+              diffPixelCount: 0,
+              width: size.width,
+              height: size.height,
+              threshold,
+              baselinePath,
+            },
+          },
+          metadata: { executionTimeMs: Date.now() - startedAt },
+        })
+      );
+    }
+
+    const baselineBuf = fs.readFileSync(baselinePath);
+    let cmp = compareWithPixelmatch(baselineBuf, currentBuf, diffPath);
+    if (cmp === null) cmp = compareFallback(baselineBuf, currentBuf);
+
+    const passed = cmp.similarity >= 1 - threshold && !cmp.sizeMismatch;
+    return emit(
+      envelope({
+        operation: 'visual-diff',
+        summary: passed
+          ? `Visual match for "${name}" (similarity ${cmp.similarity.toFixed(4)})`
+          : `Visual mismatch for "${name}" (similarity ${cmp.similarity.toFixed(4)} below threshold ${1 - threshold})`,
+        status: passed ? 'success' : 'failed',
+        details: {
+          visualDiff: {
+            name,
+            status: passed ? 'match' : 'mismatch',
+            similarity: cmp.similarity,
+            diffPixelCount: cmp.diffPixelCount,
+            width: cmp.width,
+            height: cmp.height,
+            threshold,
+            baselinePath,
+            diffPath: fs.existsSync(diffPath) ? diffPath : undefined,
+            note: cmp.note,
+          },
+        },
+        metadata: { executionTimeMs: Date.now() - startedAt },
+      })
+    );
+  } catch (err) {
+    rethrowIfUnavailable(err); // F1
+    return fail('visual-diff', err.message);
+  }
+}
+
+if (require.main === module) {
+  process.exit(runOrSkip('visual-diff', main));
+}
+
+module.exports = { compareWithPixelmatch, compareFallback, parsePngSize };

package/assets/skills/qe-visual-accessibility/SKILL.md

@@ -61,9 +61,39 @@ Task("Audit accessibility", `
 `, "qe-accessibility-agent")
 ```
 
+## Browser engine
+
+All browser automation in this skill uses the **qe-browser** fleet skill (Vibium engine). See `.claude/skills/qe-browser/SKILL.md`. The `vibium` binary is installed by `aqe init`.
+
 ## Visual Testing Operations
 
-### 1. Visual Regression
+### 1. Visual Regression (via qe-browser)
+
+```bash
+# Establish baselines for the pages we care about
+for path in / /login /dashboard /settings; do
+  slug=$(echo "$path" | tr '/' '_' | sed 's/^_//' || echo root)
+  vibium go "https://production.example.com$path" && vibium wait load
+  node .claude/skills/qe-browser/scripts/visual-diff.js --name "baseline_${slug:-root}"
+done
+
+# Compare staging against those baselines
+for path in / /login /dashboard /settings; do
+  slug=$(echo "$path" | tr '/' '_' | sed 's/^_//' || echo root)
+  vibium go "https://staging.example.com$path" && vibium wait load
+  node .claude/skills/qe-browser/scripts/visual-diff.js \
+    --name "baseline_${slug:-root}" --threshold 0.001  # 0.1% pixel diff
+done
+```
+
+Ignore dynamic regions (timestamps, live counts) by scoping the diff to a selector that excludes them:
+
+```bash
+node .claude/skills/qe-browser/scripts/visual-diff.js \
+  --name hero --selector "main > .content"
+```
+
+Legacy programmatic TypeScript API (still available for tests that prefer it over shelling out):
 
 ```typescript
 await visualTester.compareScreenshots({

package/assets/skills/security-visual-testing/SKILL.md

@@ -20,6 +20,24 @@ validation:
 
 # Security Visual Testing
 
+## Browser engine
+
+Uses the **qe-browser** fleet skill (`.claude/skills/qe-browser/`) for all browser automation. The Vibium engine (10MB Go binary, WebDriver BiDi) is installed automatically by `aqe init`. For security-visual workflows, qe-browser adds two things on top of stock visual testing: `check-injection.js` (scans page content for prompt-injection patterns before screenshots are stored) and `assert.js` (16 typed checks including `no_failed_requests` for detecting data-leak requests).
+
+```bash
+# Before storing any screenshot, scan the page
+vibium go "$TARGET_URL"
+vibium wait load
+node .claude/skills/qe-browser/scripts/check-injection.js --include-hidden
+INJ=$?
+if [ $INJ -ne 0 ]; then
+  echo "Prompt-injection findings — do NOT store screenshot"
+  exit $INJ
+fi
+# Safe to proceed with visual-diff
+node .claude/skills/qe-browser/scripts/visual-diff.js --name "${PAGE_NAME}"
+```
+
 <default_to_action>
 When performing security-aware visual testing:
 1. VALIDATE URLs before navigation (check for malicious patterns)

package/assets/skills/skills-manifest.json

@@ -1,14 +1,15 @@
 {
-  "version": "1.2.0",
-  "generated": "2026-01-27T00:00:00.000Z",
-  "totalSkills": 44,
-  "description": "Agentic QE Fleet skills manifest - Quality Engineering focused skills only. Claude Flow platform skills are managed separately.",
+  "version": "1.4.0",
+  "generated": "2026-04-09T00:00:00.000Z",
+  "totalSkills": 49,
+  "totalQESkills": 81,
+  "description": "Agentic QE Fleet skills manifest - 49 Tier 3 verified QE skills. Total 81 QE skills on disk (49 Tier 3 + 32 additional including QCSD swarms, n8n testing, enterprise integration, pentest validation, qe-* domains, qe-browser via ADR-091).",
   "categories": {
     "qcsd-phases": {
       "description": "QCSD (Quality Conscious Software Delivery) phase swarms for shift-left quality",
       "priority": "critical",
       "autoInvoke": true,
-      "skills": ["qcsd-ideation-swarm"]
+      "skills": ["qcsd-ideation-swarm", "qcsd-refinement-swarm", "qcsd-development-swarm", "qcsd-cicd-swarm"]
     },
     "qe-core": {
       "description": "Foundational quality engineering philosophy and agentic principles",
@@ -31,6 +32,7 @@
       "priority": "medium",
       "skills": [
         "security-testing",
+        "pentest-validation",
         "validation-pipeline",
         "performance-testing",
         "accessibility-testing",
@@ -47,6 +49,13 @@
         "regression-testing"
       ]
     },
+    "browser-automation": {
+      "description": "Browser automation fleet skill using Vibium (WebDriver BiDi) with typed assertions, batch execution, visual diff, prompt-injection scanning, and semantic intents. Supersedes per-skill browser glue across a11y-ally, e2e-flow-verifier, visual-testing-advanced, and others. See ADR-091.",
+      "priority": "high",
+      "skills": [
+        "qe-browser"
+      ]
+    },
     "analysis-review": {
       "description": "Code and quality analysis skills",
       "priority": "medium",
@@ -113,6 +122,8 @@
           "evaluate with qcsd",
           "run qcsd",
           "shift-left quality",
+          "shift-left quality assessment",
+          "analyze url for quality",
           "quality criteria session",
           "risk storming"
         ],
@@ -131,6 +142,169 @@
         }
       }
     },
+    "qcsd-refinement-swarm": {
+      "id": "qcsd-refinement-swarm",
+      "name": "QCSD Refinement Swarm",
+      "description": "QCSD Refinement phase swarm using SFDIPOT product factors, BDD scenario generation, and requirements validation for Sprint Refinement sessions.",
+      "category": "qcsd-phases",
+      "priority": "critical",
+      "file": "qcsd-refinement-swarm/SKILL.md",
+      "tokenEstimate": 3200,
+      "optimizationStatus": "active",
+      "optimizationVersion": "1.0",
+      "lastOptimized": "2026-02-02",
+      "tags": ["qcsd", "refinement", "sfdipot", "bdd", "gherkin", "requirements", "swarm"],
+      "dependencies": ["agentic-quality-engineering", "context-driven-testing"],
+      "agents": [
+        "qe-product-factors-assessor",
+        "qe-bdd-generator",
+        "qe-requirements-validator",
+        "qe-contract-validator",
+        "qe-impact-analyzer",
+        "qe-dependency-mapper",
+        "qe-test-idea-rewriter"
+      ],
+      "relatedSkills": ["context-driven-testing", "testability-scoring", "risk-based-testing"],
+      "triggers": {
+        "patterns": [
+          "qcsd refinement",
+          "refinement swarm",
+          "sfdipot analysis",
+          "product factors analysis",
+          "sprint refinement",
+          "story refinement",
+          "bdd generation",
+          "generate scenarios",
+          "refine story",
+          "refine epic"
+        ],
+        "autoInvoke": true,
+        "enforcementLevel": "strict"
+      },
+      "execution": {
+        "primary": "task-tool",
+        "parallel_batches": 3,
+        "requiresFlagDetection": true,
+        "requiresDirectWrite": true,
+        "conditionalAgents": {
+          "qe-contract-validator": "HAS_API",
+          "qe-impact-analyzer": "HAS_REFACTORING",
+          "qe-dependency-mapper": "HAS_DEPENDENCIES"
+        }
+      }
+    },
+    "qcsd-development-swarm": {
+      "id": "qcsd-development-swarm",
+      "name": "QCSD Development Swarm",
+      "description": "QCSD Development phase swarm for in-sprint code quality assurance using TDD adherence, code complexity analysis, coverage gap detection, and defect prediction.",
+      "category": "qcsd-phases",
+      "priority": "critical",
+      "file": "qcsd-development-swarm/SKILL.md",
+      "tokenEstimate": 3400,
+      "optimizationStatus": "active",
+      "optimizationVersion": "1.0",
+      "lastOptimized": "2026-02-03",
+      "tags": ["qcsd", "development", "tdd", "complexity", "coverage", "security", "performance", "mutation", "defect-prediction", "swarm"],
+      "dependencies": ["agentic-quality-engineering", "tdd-london-chicago"],
+      "agents": [
+        "qe-tdd-specialist",
+        "qe-code-complexity",
+        "qe-coverage-specialist",
+        "qe-security-scanner",
+        "qe-performance-tester",
+        "qe-mutation-tester",
+        "qe-defect-predictor"
+      ],
+      "relatedSkills": ["tdd-london-chicago", "mutation-testing", "performance-testing", "security-testing"],
+      "triggers": {
+        "patterns": [
+          "qcsd development",
+          "development swarm",
+          "code quality analysis",
+          "tdd analysis",
+          "coverage analysis",
+          "complexity analysis",
+          "development quality",
+          "development quality gate",
+          "code review swarm",
+          "analyze code quality",
+          "analyze code for quality",
+          "sprint code check",
+          "in-sprint quality check",
+          "mutation testing",
+          "defect prediction",
+          "is code ready to ship"
+        ],
+        "autoInvoke": true,
+        "enforcementLevel": "strict"
+      },
+      "execution": {
+        "primary": "task-tool",
+        "parallel_batches": 3,
+        "requiresFlagDetection": true,
+        "requiresDirectWrite": true,
+        "conditionalAgents": {
+          "qe-security-scanner": "HAS_SECURITY_CODE",
+          "qe-performance-tester": "HAS_PERFORMANCE_CODE",
+          "qe-mutation-tester": "HAS_CRITICAL_CODE"
+        }
+      }
+    },
+    "qcsd-cicd-swarm": {
+      "id": "qcsd-cicd-swarm",
+      "name": "QCSD CI/CD Swarm",
+      "description": "QCSD Verification phase swarm for CI/CD pipeline quality gates using regression analysis, flaky test detection, quality gate enforcement, and deployment readiness assessment.",
+      "category": "qcsd-phases",
+      "priority": "critical",
+      "file": "qcsd-cicd-swarm/SKILL.md",
+      "tokenEstimate": 3500,
+      "optimizationStatus": "active",
+      "optimizationVersion": "1.0",
+      "lastOptimized": "2026-02-03",
+      "tags": ["qcsd", "verification", "cicd", "pipeline", "quality-gate", "regression", "flaky", "security", "chaos", "coverage", "deployment", "swarm"],
+      "dependencies": ["agentic-quality-engineering", "shift-left-testing"],
+      "agents": [
+        "qe-quality-gate",
+        "qe-regression-analyzer",
+        "qe-flaky-hunter",
+        "qe-security-scanner",
+        "qe-chaos-engineer",
+        "qe-coverage-specialist",
+        "qe-deployment-advisor"
+      ],
+      "relatedSkills": ["shift-left-testing", "shift-right-testing", "regression-testing", "security-testing"],
+      "triggers": {
+        "patterns": [
+          "qcsd verification",
+          "qcsd cicd",
+          "cicd swarm",
+          "pipeline verification",
+          "release readiness",
+          "is this safe to release",
+          "deployment readiness",
+          "verify pipeline",
+          "release gate",
+          "quality gate check",
+          "pre-release check",
+          "release verification",
+          "verify build",
+          "pipeline quality"
+        ],
+        "autoInvoke": true,
+        "enforcementLevel": "strict"
+      },
+      "execution": {
+        "primary": "task-tool",
+        "parallel_batches": 3,
+        "requiresFlagDetection": true,
+        "requiresDirectWrite": true,
+        "conditionalAgents": {
+          "qe-security-scanner": "HAS_SECURITY_PIPELINE",
+          "qe-chaos-engineer": "HAS_PERFORMANCE_PIPELINE",
+          "qe-coverage-specialist": "HAS_INFRA_CHANGE"
+        }
+      }
+    },
     "agentic-quality-engineering": {
       "id": "agentic-quality-engineering",
       "name": "Agentic Quality Engineering",
@@ -659,7 +833,7 @@
     "validation-pipeline": {
       "id": "validation-pipeline",
       "name": "Validation Pipeline",
-      "description": "Run structured 13-step requirements validation pipeline with gate enforcement, weighted scoring, and detailed findings.",
+      "description": "Run structured 13-step requirements validation pipeline with gate enforcement, weighted scoring, and detailed findings. Supports format checking, vague term detection, testability analysis, and more.",
       "category": "specialized-testing",
       "priority": "high",
       "file": "validation-pipeline/SKILL.md",
@@ -669,7 +843,19 @@
       "lastOptimized": "2026-03-12",
       "tags": ["validation", "requirements", "pipeline", "gate-enforcement", "scoring", "bmad"],
       "dependencies": ["agentic-quality-engineering"],
-      "agents": ["qe-requirements-validator"]
+      "agents": ["qe-requirements-validator"],
+      "relatedSkills": ["verification-quality", "shift-left-testing", "context-driven-testing"],
+      "triggers": {
+        "patterns": [
+          "validate requirements",
+          "requirements validation",
+          "validation pipeline",
+          "run validation",
+          "check requirements quality"
+        ],
+        "autoInvoke": false,
+        "enforcementLevel": "standard"
+      }
     },
     "bug-reporting-excellence": {
       "id": "bug-reporting-excellence",
@@ -708,6 +894,9 @@
     },
     "byTask": {
       "qcsd-analysis": ["qcsd-ideation-swarm", "testability-scoring", "risk-based-testing", "context-driven-testing", "holistic-testing-pact"],
+      "qcsd-refinement": ["qcsd-refinement-swarm", "context-driven-testing", "testability-scoring", "risk-based-testing"],
+      "qcsd-development": ["qcsd-development-swarm", "tdd-london-chicago", "mutation-testing", "performance-testing", "security-testing"],
+      "qcsd-verification": ["qcsd-cicd-swarm", "shift-left-testing", "shift-right-testing", "regression-testing", "security-testing"],
       "url-quality-analysis": ["qcsd-ideation-swarm", "a11y-ally", "security-testing", "performance-testing"],
       "test-generation": ["tdd-london-chicago", "api-testing-patterns", "test-design-techniques"],
       "coverage-analysis": ["holistic-testing-pact", "quality-metrics", "testability-scoring"],
@@ -723,8 +912,8 @@
   "optimizationTracking": {
     "targetReduction": "40-50%",
     "optimizedSkills": 7,
-    "totalSkills": 42,
-    "progress": "14.6%",
+    "totalSkills": 47,
+    "progress": "15.2%",
     "tokensSaved": 10200,
     "optimizedList": [
       "agentic-quality-engineering",
@@ -750,9 +939,9 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "2.1.0",
-    "manifestVersion": "1.1.0",
-    "lastUpdated": "2025-12-02T00:00:00.000Z",
+    "fleetVersion": "3.9.9",
+    "manifestVersion": "1.4.0",
+    "lastUpdated": "2026-04-09T00:00:00.000Z",
     "contributors": [
       {
         "name": "@fndlalit",
@@ -760,10 +949,17 @@
         "url": "https://github.com/fndlalit"
       }
     ],
-    "notes": "This manifest contains only QE-focused skills. Claude Flow platform skills (agentdb, flow-nexus, github-*, swarm-*, hive-mind, etc.) are managed separately in the claude-flow package.",
+    "notes": "This manifest tracks 49 Tier 3 verified QE skills. Total 81 QE skills on disk (49 Tier 3 + 32 additional). qe-browser added 2026-04-09 per ADR-091. Claude Flow platform skills (33) are managed separately.",
+    "skillBreakdown": {
+      "qeSkillsTier3": 49,
+      "qeSkillsAdditional": 32,
+      "totalQESkills": 81,
+      "platformSkills": 36,
+      "totalOnDisk": 114
+    },
     "excludedCategories": {
-      "reason": "These are Claude Flow platform skills, not QE skills",
-      "categories": ["agentdb", "orchestration", "github-integration", "flow-nexus", "meta"]
+      "reason": "Platform skills are available but not tracked in this QE-focused manifest",
+      "categories": ["agentdb", "orchestration", "github-integration", "flow-nexus", "meta", "v3-internal"]
     }
   }
 }

package/assets/skills/testability-scoring/SKILL.md

@@ -22,6 +22,29 @@ validation:
 
 # Testability Scoring
 
+## Browser engine
+
+Uses the **qe-browser** fleet skill (`.claude/skills/qe-browser/`) as the primary browser engine. Vibium is installed by `aqe init`. The legacy `scripts/run-assessment.sh` + Playwright path remains as a fallback when a team already has a Playwright test suite configured, but new runs should prefer:
+
+```bash
+vibium go "$TARGET_URL"
+vibium wait load
+vibium a11y-tree --json > /tmp/testability/tree.json
+vibium eval --stdin --json <<'EOF' > /tmp/testability/signals.json
+JSON.stringify({
+  headings: document.querySelectorAll('h1,h2,h3,h4,h5,h6').length,
+  testIds: document.querySelectorAll('[data-testid]').length,
+  forms: document.querySelectorAll('form').length,
+  ariaLabels: document.querySelectorAll('[aria-label]').length,
+  links: document.querySelectorAll('a[href]').length,
+});
+EOF
+node .claude/skills/qe-browser/scripts/assert.js --checks '[
+  {"kind": "no_console_errors"},
+  {"kind": "no_failed_requests"}
+]'
+```
+
 <default_to_action>
 When assessing testability:
 1. RUN assessment against target URL