ultra11y 2.31.0 → 2.31.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "ultra11y",
       "source": "./",
       "description": "Automatic accessibility review of the code under change before every commit, push and pull request, plus full WCAG 2.2 AA / RGAA audits and conformance deliverables on demand.",
-      "version": "2.31.0",
+      "version": "2.31.2",
       "author": { "name": "maxgfr" },
       "homepage": "https://github.com/maxgfr/ultra11y",
       "repository": "https://github.com/maxgfr/ultra11y",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ultra11y",
   "description": "Accessibility for WCAG 2.2 AA and country standards (RGAA…): an automatic review of the code under change before every commit, push and pull request, plus full audits and conformance deliverables on demand.",
-  "version": "2.31.0",
+  "version": "2.31.2",
   "author": { "name": "maxgfr" },
   "homepage": "https://github.com/maxgfr/ultra11y",
   "repository": "https://github.com/maxgfr/ultra11y",

package/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ultra11y",
   "description": "Accessibility for WCAG 2.2 AA and country standards (RGAA…): an automatic review of the code under change before every commit, push and pull request, plus full audits and conformance deliverables on demand.",
-  "version": "2.31.0",
+  "version": "2.31.2",
   "author": { "name": "maxgfr", "url": "https://github.com/maxgfr" },
   "homepage": "https://github.com/maxgfr/ultra11y",
   "repository": "https://github.com/maxgfr/ultra11y",

package/.opencode/plugins/ultra11y.js

@@ -27,7 +27,7 @@ import { fileURLToPath } from "node:url";
 // Ownership marker: `ultra11y install --opencode` refuses to overwrite a plugin file that
 // does not carry it, so a user's own ultra11y.js is never clobbered.
 const ULTRA11Y_OPENCODE_PLUGIN = "ULTRA11Y_OPENCODE_PLUGIN";
-const ULTRA11Y_PLUGIN_VERSION = "2.31.0";
+const ULTRA11Y_PLUGIN_VERSION = "2.31.2";
 
 const here = dirname(fileURLToPath(import.meta.url));
 

package/README.md

@@ -195,7 +195,7 @@ the one output an accessibility tool must never produce.
 
 ### Tools
 
-Ten read tools. `ultra11y_audit` is the entry point:
+Eleven read tools. `ultra11y_audit` is the entry point:
 
 | Tool | What it does |
 |------|--------------|
@@ -208,6 +208,7 @@ Ten read tools. `ultra11y_audit` is the entry point:
 | `ultra11y_verify` | Claim↔evidence worklist |
 | `ultra11y_pack_check` | Validate a country standards pack against what it really ships |
 | `ultra11y_sample_check` | Lint the normative page sample |
+| `ultra11y_pages` | The per-page view: the criterion × page grid, or one dossier per page |
 | `ultra11y_read` | A file, or a line range, from the project |
 
 `--allow-write` additionally exposes `ultra11y_fix` (safe codemods, dry-run by
@@ -216,6 +217,10 @@ project. `ultra11y_scan` is declared but declines over MCP: it drives a headless
 browser and may pull a Docker image, which is not a subprocess lifecycle a
 long-lived server should own. It tells you to run it from the CLI and re-audit.
 
+Every tool audits exactly what the CLI would: the rendered captures and the page
+snapshots under `.ultra11y/` are ingested here too, so the server never reports a
+smaller audit than the same command run by hand.
+
 Pass `--cwd <dir>` at startup to dedicate the server to one project — `cwd` then
 becomes optional on every tool.
 

package/dist/cypress-plugin.d.ts

@@ -5,6 +5,12 @@ interface TaskPayload extends SnapshotPayload {
     failOn?: string | false;
     /** The name `cy.screenshot()` was called with, when the browser half took one. */
     screenshotName?: string;
+    /** Forwarded from `cy.ultra11y({ report })` — the browser cannot write files, this side can. */
+    report?: boolean | {
+        out?: string;
+        standard?: string;
+        lang?: string;
+    };
 }
 interface TaskResult {
     findings: FindingLike[];

package/dist/cypress-plugin.mjs

@@ -48,6 +48,18 @@ ${res.stderr || ""}`);
 ${res.stdout.slice(0, 500)}`);
   }
 }
+function writePagesReport(opts = {}, engine = enginePath()) {
+  const args = [engine, "pages", "--in", "-", "--format", "report"];
+  if (opts.split !== false) args.push("--split", "page");
+  args.push("--out", opts.out ?? "audits/pages");
+  if (opts.standard) args.push("--standard", opts.standard);
+  if (opts.lang) args.push("--lang", opts.lang);
+  const audit = spawnSync(process.execPath, [engine, "audit", ".ultra11y/pages", "--json"], { encoding: "utf8", maxBuffer: 192 * 1024 * 1024 });
+  if (audit.error || !audit.stdout) return void 0;
+  const res = spawnSync(process.execPath, args, { input: audit.stdout, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  if (res.error || res.status !== 0) return void 0;
+  return res.stdout.trim() || void 0;
+}
 
 // src/integrations/cypress-plugin.ts
 function register(on) {
@@ -67,6 +79,7 @@ function register(on) {
         }
       }
       const result = auditSnapshot(withShot);
+      if (payload.report) writePagesReport(typeof payload.report === "object" ? payload.report : {});
       const failOn = payload.failOn === void 0 ? "blocking" : payload.failOn;
       const failing = failOn === false ? [] : failingFindings(result, failOn);
       return {

package/dist/cypress.d.ts

@@ -5,6 +5,17 @@ interface CypressCheckOptions extends CheckOptions {
     /** Capture a viewport screenshot so the pixel tier can run. On by default — the plugin
      *  reads it back through Cypress's `after:screenshot` event. */
     screenshot?: boolean;
+    /** Also write the per-page report once this page is recorded. Off by default: a report per
+     *  checked page would be wasteful in a suite, so turn it on in a final test.
+     *
+     *  Cypress test code runs in the browser and cannot write files, so the option is only
+     *  DECLARED here and forwarded — the Node half does the work. Same option, same behaviour
+     *  as Playwright's; a runner that silently ignored it would be worse than one that lacked it. */
+    report?: boolean | {
+        out?: string;
+        standard?: string;
+        lang?: string;
+    };
 }
 declare function registerUltra11yCommand(): void;
 

package/dist/cypress.mjs

@@ -154,6 +154,7 @@ function registerUltra11yCommand() {
       const payload = {
         ...buildPayload(collected, url, "cypress", opts),
         failOn: opts.failOn,
+        ...opts.report ? { report: opts.report } : {},
         ...shotName ? { screenshotName: shotName } : {}
       };
       return cy.task("ultra11ySnapshot", payload, { log: false }).then((res) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultra11y",
-  "version": "2.31.0",
+  "version": "2.31.2",
   "description": "Audit HTML/CSS/JSX against WCAG 2.2 AA and produce a dated compliance report, or author/review accessible markup (native-HTML-first). A skills.sh agent skill: an install-free static engine (bundled, no npm install) plus the agent's judgment, with check/verify gates against hallucinated non-conformities, and pluggable in-repo standards packs (RGAA France first; Section 508 & EN 301 549 next).",
   "type": "module",
   "packageManager": "pnpm@10.33.0",

package/scripts/ultra11y.mjs

@@ -6,7 +6,7 @@ import { join as join45, relative as relative5, sep as sep7, dirname as dirname1
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/types.ts
-var VERSION = "2.31.0";
+var VERSION = "2.31.2";
 var SCHEMA_VERSION = 2;
 
 // src/audit.ts
@@ -55414,7 +55414,15 @@ function startDevServer(opts) {
     }
     if (url.pathname === "/health") {
       res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" }).end(
-        JSON.stringify({ ok: true, tool: "ultra11y", version: VERSION, standard: opts.standard, lang: opts.lang, pages: readSnapshots(opts.root).length })
+        JSON.stringify({
+          ok: true,
+          tool: "ultra11y",
+          version: VERSION,
+          port: opts.port,
+          standard: opts.standard,
+          lang: opts.lang,
+          pages: readSnapshots(opts.root).length
+        })
       );
       return;
     }
@@ -56150,6 +56158,7 @@ function noop() {
 }
 
 // src/mcp/handlers.ts
+var CAPTURES_DIR = ".ultra11y/captures";
 var ToolError = class extends Error {
 };
 var MAX_READ_LINES = 2e3;
@@ -56220,6 +56229,8 @@ async function dispatch(name2, args2, cwd) {
       return handlePackCheck(args2, cwd);
     case "ultra11y_sample_check":
       return handleSampleCheck(cwd);
+    case "ultra11y_pages":
+      return handlePages(args2, cwd);
     case "ultra11y_read":
       return handleRead(args2, cwd);
     case "ultra11y_fix":
@@ -56240,8 +56251,11 @@ function audit(args2, cwd) {
   const warnings = [];
   try {
     process.chdir(cwd);
-    return runAudit({
-      inputs: strArray2(args2.globs) ?? DEFAULT_GLOBS,
+    const inputs = strArray2(args2.globs) ?? DEFAULT_GLOBS;
+    const scopedToDiff = bool(args2.changed) || bool(args2.staged) || str2(args2.since) !== void 0;
+    const extra = [CAPTURES_DIR, PAGES_DIR].filter((d) => !scopedToDiff && existsSync29(d) && !inputs.includes(d));
+    const result = runAudit({
+      inputs: [...inputs, ...extra],
       include: strArray2(args2.include),
       exclude: strArray2(args2.exclude),
       forceJsx: bool(args2.jsx),
@@ -56252,6 +56266,14 @@ function audit(args2, cwd) {
       maxFiles: positive(args2.max_files, "max_files"),
       onWarn: (m) => warnings.push(m)
     });
+    if (extra.includes(PAGES_DIR)) {
+      const scope = pageScopesFrom(readSnapshots("."));
+      if (scope.length) {
+        result.scope.pages = scope;
+        attributePages(result, scope);
+      }
+    }
+    return result;
   } finally {
     process.chdir(prev);
   }
@@ -56337,6 +56359,30 @@ function handleSampleCheck(cwd) {
   }
   return { cwd, config: raw, next: "Check the sample covers every page kind the methodology requires, not just the convenient ones." };
 }
+function handlePages(args2, cwd) {
+  const standard = standardOf(args2);
+  const lang = langOf(args2);
+  const r = audit(args2, cwd);
+  const scope = pagesOf(r);
+  if (!scope.length) {
+    throw new ToolError(
+      "no page in scope: this audit covers no snapshot (.ultra11y/pages) and no scanned sample. Capture pages with the E2E plugins, `ultra11y dev`, or `scan` (which snapshots every page it visits), then re-run."
+    );
+  }
+  attributePages(r, scope);
+  const derived = derivePages(r, scope);
+  const format = typeof args2.format === "string" ? args2.format : "grid";
+  const markdown = format === "report" ? renderPagesDocument(r, derived, { standard, lang }) : renderPageGrid(r, scope, standard, lang);
+  return {
+    cwd,
+    standard,
+    lang,
+    markdown,
+    pages: derived.map((p) => ({ id: p.id, name: p.name, url: p.url, basis: p.basis, conformancePct: p.conformancePct, findings: p.findings.length })),
+    unattributed: unattributedFindings(r).length,
+    next: 'A page whose basis is "attributed" has no snapshot: absence of a finding there is NOT conformity. Its undecided criteria stay yours to adjudicate.'
+  };
+}
 function handleFix(args2, cwd) {
   const prev = process.cwd();
   try {
@@ -56667,6 +56713,26 @@ var TOOLS2 = [
     description: "Validate a project's `.ultra11yrc.json` page sample against the methodology: a conformance claim covering only the pages that happened to be easy is not a conformance claim. Reads the config; changes nothing.",
     inputSchema: { type: "object", properties: { cwd: cwdProp }, required: ["cwd"] }
   },
+  {
+    name: "ultra11y_pages",
+    title: "The per-page view of the audit",
+    description: "RGAA \u2014 like every country standard \u2014 is a PER-PAGE norm, but the engine's verdict is scope-wide. This projects the audit onto the pages it covers: the criterion \xD7 page grid, or the per-page report (one dossier per page, every criterion of the standard with its status on THAT page). Two rules make it trustworthy: a finding belongs to a page only when something says so \u2014 never spread across pages \u2014 and a criterion is conforming by silence only on a page whose real rendered DOM was audited, and only for the criteria the engine can actually decide. Everything else stays \xAB to assess \xBB, which is what it is. Pages come from snapshots (.ultra11y/pages) or a scanned sample; with neither, there is nothing to project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: cwdProp,
+        globs: globsProp,
+        standard: standardProp,
+        lang: langProp,
+        format: {
+          type: "string",
+          enum: ["grid", "report"],
+          description: "`grid` (default) is the criterion \xD7 page matrix; `report` is the per-page dossiers."
+        }
+      },
+      required: ["cwd"]
+    }
+  },
   {
     name: "ultra11y_read",
     title: "Read a file from the project",
@@ -56754,6 +56820,7 @@ var TOOL_META2 = {
   ultra11y_adjudicate: { openWorld: false },
   ultra11y_pack_check: { openWorld: false },
   ultra11y_sample_check: { openWorld: false },
+  ultra11y_pages: { openWorld: false },
   ultra11y_read: { openWorld: false },
   // Rewrites source files. Not destructive in the delete sense, and it verifies
   // its own work — but it is the user's code.
@@ -59052,6 +59119,14 @@ async function cmdJudge(p) {
   }
   const max = typeof p.flags.max === "string" ? Number(p.flags.max) : void 0;
   const truncated = max !== void 0 && Number.isFinite(max) && max > 0 && items.length > max;
+  if (truncated && p.flags.apply === true) {
+    console.error(
+      lang === "fr" ? `ultra11y judge : --max ${max} ne couvre que ${max} des ${items.length} crit\xE8res, et --apply exige une adjudication COMPL\xC8TE (le gate refuse une couverture partielle).
+  Retirez --max pour tout adjuger, ou retirez --apply pour produire la worklist et l'appliquer plus tard.` : `ultra11y judge: --max ${max} covers only ${max} of ${items.length} criteria, and --apply requires a COMPLETE adjudication (the gate refuses partial coverage).
+  Drop --max to adjudicate everything, or drop --apply to produce the worklist and apply it later.`
+    );
+    return 2;
+  }
   if (truncated) items = items.slice(0, max);
   const batches = [];
   for (let i2 = 0; i2 < items.length; i2 += BATCH_SIZE) {

package/skills/review-a11y/SKILL.md

@@ -5,7 +5,7 @@ when_to_use: "Invoke WITHOUT being asked whenever changed front-end code should
 allowed-tools: Bash(node ${CLAUDE_SKILL_DIR}/scripts/ultra11y.mjs *), Read, Grep, Glob
 license: MIT
 metadata:
-  version: 2.31.0
+  version: 2.31.2
 ---
 
 # review-a11y — accessibility review of changed code

package/skills/review-a11y/scripts/ultra11y.mjs

@@ -6,7 +6,7 @@ import { join as join45, relative as relative5, sep as sep7, dirname as dirname1
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/types.ts
-var VERSION = "2.31.0";
+var VERSION = "2.31.2";
 var SCHEMA_VERSION = 2;
 
 // src/audit.ts
@@ -55414,7 +55414,15 @@ function startDevServer(opts) {
     }
     if (url.pathname === "/health") {
       res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" }).end(
-        JSON.stringify({ ok: true, tool: "ultra11y", version: VERSION, standard: opts.standard, lang: opts.lang, pages: readSnapshots(opts.root).length })
+        JSON.stringify({
+          ok: true,
+          tool: "ultra11y",
+          version: VERSION,
+          port: opts.port,
+          standard: opts.standard,
+          lang: opts.lang,
+          pages: readSnapshots(opts.root).length
+        })
       );
       return;
     }
@@ -56150,6 +56158,7 @@ function noop() {
 }
 
 // src/mcp/handlers.ts
+var CAPTURES_DIR = ".ultra11y/captures";
 var ToolError = class extends Error {
 };
 var MAX_READ_LINES = 2e3;
@@ -56220,6 +56229,8 @@ async function dispatch(name2, args2, cwd) {
       return handlePackCheck(args2, cwd);
     case "ultra11y_sample_check":
       return handleSampleCheck(cwd);
+    case "ultra11y_pages":
+      return handlePages(args2, cwd);
     case "ultra11y_read":
       return handleRead(args2, cwd);
     case "ultra11y_fix":
@@ -56240,8 +56251,11 @@ function audit(args2, cwd) {
   const warnings = [];
   try {
     process.chdir(cwd);
-    return runAudit({
-      inputs: strArray2(args2.globs) ?? DEFAULT_GLOBS,
+    const inputs = strArray2(args2.globs) ?? DEFAULT_GLOBS;
+    const scopedToDiff = bool(args2.changed) || bool(args2.staged) || str2(args2.since) !== void 0;
+    const extra = [CAPTURES_DIR, PAGES_DIR].filter((d) => !scopedToDiff && existsSync29(d) && !inputs.includes(d));
+    const result = runAudit({
+      inputs: [...inputs, ...extra],
       include: strArray2(args2.include),
       exclude: strArray2(args2.exclude),
       forceJsx: bool(args2.jsx),
@@ -56252,6 +56266,14 @@ function audit(args2, cwd) {
       maxFiles: positive(args2.max_files, "max_files"),
       onWarn: (m) => warnings.push(m)
     });
+    if (extra.includes(PAGES_DIR)) {
+      const scope = pageScopesFrom(readSnapshots("."));
+      if (scope.length) {
+        result.scope.pages = scope;
+        attributePages(result, scope);
+      }
+    }
+    return result;
   } finally {
     process.chdir(prev);
   }
@@ -56337,6 +56359,30 @@ function handleSampleCheck(cwd) {
   }
   return { cwd, config: raw, next: "Check the sample covers every page kind the methodology requires, not just the convenient ones." };
 }
+function handlePages(args2, cwd) {
+  const standard = standardOf(args2);
+  const lang = langOf(args2);
+  const r = audit(args2, cwd);
+  const scope = pagesOf(r);
+  if (!scope.length) {
+    throw new ToolError(
+      "no page in scope: this audit covers no snapshot (.ultra11y/pages) and no scanned sample. Capture pages with the E2E plugins, `ultra11y dev`, or `scan` (which snapshots every page it visits), then re-run."
+    );
+  }
+  attributePages(r, scope);
+  const derived = derivePages(r, scope);
+  const format = typeof args2.format === "string" ? args2.format : "grid";
+  const markdown = format === "report" ? renderPagesDocument(r, derived, { standard, lang }) : renderPageGrid(r, scope, standard, lang);
+  return {
+    cwd,
+    standard,
+    lang,
+    markdown,
+    pages: derived.map((p) => ({ id: p.id, name: p.name, url: p.url, basis: p.basis, conformancePct: p.conformancePct, findings: p.findings.length })),
+    unattributed: unattributedFindings(r).length,
+    next: 'A page whose basis is "attributed" has no snapshot: absence of a finding there is NOT conformity. Its undecided criteria stay yours to adjudicate.'
+  };
+}
 function handleFix(args2, cwd) {
   const prev = process.cwd();
   try {
@@ -56667,6 +56713,26 @@ var TOOLS2 = [
     description: "Validate a project's `.ultra11yrc.json` page sample against the methodology: a conformance claim covering only the pages that happened to be easy is not a conformance claim. Reads the config; changes nothing.",
     inputSchema: { type: "object", properties: { cwd: cwdProp }, required: ["cwd"] }
   },
+  {
+    name: "ultra11y_pages",
+    title: "The per-page view of the audit",
+    description: "RGAA \u2014 like every country standard \u2014 is a PER-PAGE norm, but the engine's verdict is scope-wide. This projects the audit onto the pages it covers: the criterion \xD7 page grid, or the per-page report (one dossier per page, every criterion of the standard with its status on THAT page). Two rules make it trustworthy: a finding belongs to a page only when something says so \u2014 never spread across pages \u2014 and a criterion is conforming by silence only on a page whose real rendered DOM was audited, and only for the criteria the engine can actually decide. Everything else stays \xAB to assess \xBB, which is what it is. Pages come from snapshots (.ultra11y/pages) or a scanned sample; with neither, there is nothing to project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: cwdProp,
+        globs: globsProp,
+        standard: standardProp,
+        lang: langProp,
+        format: {
+          type: "string",
+          enum: ["grid", "report"],
+          description: "`grid` (default) is the criterion \xD7 page matrix; `report` is the per-page dossiers."
+        }
+      },
+      required: ["cwd"]
+    }
+  },
   {
     name: "ultra11y_read",
     title: "Read a file from the project",
@@ -56754,6 +56820,7 @@ var TOOL_META2 = {
   ultra11y_adjudicate: { openWorld: false },
   ultra11y_pack_check: { openWorld: false },
   ultra11y_sample_check: { openWorld: false },
+  ultra11y_pages: { openWorld: false },
   ultra11y_read: { openWorld: false },
   // Rewrites source files. Not destructive in the delete sense, and it verifies
   // its own work — but it is the user's code.
@@ -59052,6 +59119,14 @@ async function cmdJudge(p) {
   }
   const max = typeof p.flags.max === "string" ? Number(p.flags.max) : void 0;
   const truncated = max !== void 0 && Number.isFinite(max) && max > 0 && items.length > max;
+  if (truncated && p.flags.apply === true) {
+    console.error(
+      lang === "fr" ? `ultra11y judge : --max ${max} ne couvre que ${max} des ${items.length} crit\xE8res, et --apply exige une adjudication COMPL\xC8TE (le gate refuse une couverture partielle).
+  Retirez --max pour tout adjuger, ou retirez --apply pour produire la worklist et l'appliquer plus tard.` : `ultra11y judge: --max ${max} covers only ${max} of ${items.length} criteria, and --apply requires a COMPLETE adjudication (the gate refuses partial coverage).
+  Drop --max to adjudicate everything, or drop --apply to produce the worklist and apply it later.`
+    );
+    return 2;
+  }
   if (truncated) items = items.slice(0, max);
   const batches = [];
   for (let i2 = 0; i2 < items.length; i2 += BATCH_SIZE) {

package/skills/ultra11y/SKILL.md

@@ -4,7 +4,7 @@ description: "Use to AUDIT existing HTML/CSS/JSX against WCAG 2.2 AA accessibili
 when_to_use: "Invoke when the user asks for an accessibility AUDIT or a formal deliverable: audit a repo, site or page against WCAG 2.2 AA or a country standard (RGAA, Section 508, EN 301 549); produce a dated conformance report, a criterion grid, a PRD remediation backlog or GitHub issues; author accessible markup from scratch; wire the repo gate (init --hook/--ci) or a rendered-DOM capture pipeline. For a review of the code UNDER CHANGE (diff, branch, PR), use the `review-a11y` skill instead."
 license: MIT
 metadata:
-  version: 2.31.0
+  version: 2.31.2
 ---
 
 # ultra11y — audit WCAG 2.2 AA and write accessible markup
@@ -189,6 +189,29 @@ Domain knowledge first, then the tooling. Read the one that matches the question
   something SAYS so (else it is reported as unattributed, never spread), and `C` by silence is
   earned only by a page whose real DOM was audited — a source-only page keeps its undecided
   criteria « à évaluer »; read **`references/pages.md`**.
+- **"I want a report PER PAGE, not a matrix"** → `pages --in audits/audit-latest.json
+  --standard rgaa --format report --split page --out audits/pages`: one dossier per page —
+  identity, its screenshot, its rate, EVERY criterion of the standard with its status on that
+  page, then each non-conformity as the ordinary auditor block. Nothing is re-decided (the
+  same projection as the grid) and no format is invented (the same auditor block as the
+  report), so a page sheet and the compliance report cannot disagree. `check` gates it against
+  invented criteria like any other report; read **`references/pages.md`**.
+- **"Which pages should I even audit?"** → `pages discover --crawl http://localhost:3000
+  --write` (or `--sitemap <url>`) writes the `sample.pages` block for you, taking each page's
+  name from its served `<title>` and NEVER overwriting the auth/storageState/notes already
+  declared. Then `sample check` lints the coverage and `scan --sample` scans and snapshots it.
+  A client-rendered SPA exposes no routes in its served HTML — use a sitemap there; read
+  **`references/dynamic.md`**.
+- **"Audit these URLs page by page, in CI"** → the shipped Action takes `urls`, `sitemap`,
+  `crawl` or `sample`, snapshots every page it visits, writes the per-page dossiers into its
+  artifact and adds a per-page scoreboard to the job summary and the PR comment; read
+  **`references/ci.md`**.
+- **"Nobody is here to rule on the judgment criteria"** → `judge --in audits/audit-latest.json
+  --standard rgaa [--apply]` adjudicates them with a model, for a run with no coding agent in
+  the loop (CI, the extension, an E2E run). It is a CALLER, not a second judge: same worklist,
+  same evidence, same prompt, and the verdicts pass the same fail-closed gate yours do. The
+  only command that takes an API key — inside an agent, use `verify --manual` instead and rule
+  yourself; read **`references/judgment.md`**.
 - **"Show the findings ON the pull request, not just a red job"** → `--format sarif` (upload
   to code scanning → inline annotations at the right file:line) or `--format github`
   (`::error::` workflow commands + a `$GITHUB_STEP_SUMMARY` table) — from `report

package/skills/ultra11y/references/ci.md

@@ -196,3 +196,37 @@ Two surfaces come out of it:
   standard with its status on that page, and each non-conformity as the ordinary auditor block.
 
 A run with no page in scope is not a failure: the report step says so and the job carries on.
+
+## The action is executed in ITS OWN CI, not just parsed
+
+`tests/action.test.ts` reads `action.yml` and gates its shape. That cannot prove the thing
+works: a composite action is bash — arrays, `set -e`, quoting — and the whole file could stay
+green while the action was broken for every consumer.
+
+So `ci.yml` has an `action` job that `uses: ./` for real, twice: report-only over a
+non-conforming fixture (asserting the declared outputs, the written report, and that the
+per-page step DEGRADES rather than failing when nothing was scanned), then the page-by-page
+path — a served two-page site, crawled, scanned, snapshotted, folded in and rendered as
+per-page dossiers, asserting that each crawled page is snapshot-based and that the finding on
+one page did not leak onto the clean one. Both run with `sarif: false`, so the job needs no
+`security-events: write` and works on a fork's pull request.
+
+Two traps are worth naming, because running it is what found them.
+
+`[ cond ] && cmd` returns 1 when the condition is false, and `-e` turns that into a dead job.
+A test now forbids the form in `action.yml` **and** in every CI workflow.
+
+And **artifact names are unique per workflow RUN, not per step**. Using the action twice in
+one job — the code diff, then the served pages — died on a `409 Conflict`, with the report
+written and never uploaded. Pass `artifact-name` on each invocation:
+
+```yaml
+- uses: maxgfr/ultra11y@v2
+  with: { since: auto, artifact-name: a11y-code }
+- uses: maxgfr/ultra11y@v2
+  with: { crawl: http://localhost:3000, artifact-name: a11y-pages }
+```
+
+Left unset it keeps the historical `ultra11y-<standard>`, so a single-invocation workflow is
+unaffected.
+

package/skills/ultra11y/references/e2e.md

@@ -114,10 +114,13 @@ between the two.
 
 ## A report straight out of the test run
 
-`checkA11y(page, { report: true })` (Playwright) writes the per-page report once the page is
-recorded — `audits/pages/index.md` plus one sheet per page, screenshots included. Off by
+`checkA11y(page, { report: true })` — and `cy.ultra11y({ report: true })` — writes the per-page
+report once the page is recorded — `audits/pages/index.md` plus one sheet per page, screenshots included. Off by
 default: a report per checked page would be wasteful in a suite, so turn it on in a final
-test, or run `pages --format report` yourself afterwards.
+test, or run `pages --format report` yourself afterwards. Cypress test code cannot write
+files, so there the option is declared in the browser and honoured by the Node plugin — same
+option, same behaviour, because a runner that silently ignored it would be worse than one
+that lacked it.
 
 ## Why the artefact matters more than the assertion
 

package/skills/ultra11y/references/extension.md

@@ -18,7 +18,7 @@ node scripts/ultra11y.mjs dev --standard rgaa      # the side-car (loopback only
 |---|---|
 | **Audit this page** | collects the page with the engine's own collector, posts it to the side-car, which persists it as a snapshot and audits it — the findings come back and are listed |
 | **Adjudicate with AI** | asks the side-car to rule on the judgment criteria (see `judgment.md`) |
-| **Page-by-page grid** | opens the dashboard, where every page you audited accumulates |
+| **Page-by-page grid** | opens the dashboard, where every page you audited accumulates — on the port the server actually answered on, not a default |
 
 Because the page is persisted as an ordinary snapshot, everything else already works on it:
 `ultra11y audit` re-audits it offline, `pages --format report` writes its dossier, and it

package/skills/ultra11y/references/judgment.md

@@ -149,5 +149,10 @@ gate refuses:
 A rejected adjudication leaves `audit-latest.json` untouched.
 
 **Strictly opt-in.** With no key the command explains itself and exits 2; nothing else in the
-engine changes. `--max` bounds the spend and says out loud which criteria it did not submit —
-and a bounded run then fails the coverage gate, which is the correct outcome.
+engine changes.
+
+`--max` bounds the spend and says out loud which criteria it did not submit. It is **refused
+together with `--apply`**, before any call is made: the gate rejects an incomplete
+adjudication by design, so the pair could only ever bill you for a guaranteed failure. Drop
+`--max` to adjudicate everything, or drop `--apply` to produce the worklist now and fold it
+in later.

package/skills/ultra11y/scripts/ultra11y.mjs

@@ -6,7 +6,7 @@ import { join as join45, relative as relative5, sep as sep7, dirname as dirname1
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/types.ts
-var VERSION = "2.31.0";
+var VERSION = "2.31.2";
 var SCHEMA_VERSION = 2;
 
 // src/audit.ts
@@ -55414,7 +55414,15 @@ function startDevServer(opts) {
     }
     if (url.pathname === "/health") {
       res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" }).end(
-        JSON.stringify({ ok: true, tool: "ultra11y", version: VERSION, standard: opts.standard, lang: opts.lang, pages: readSnapshots(opts.root).length })
+        JSON.stringify({
+          ok: true,
+          tool: "ultra11y",
+          version: VERSION,
+          port: opts.port,
+          standard: opts.standard,
+          lang: opts.lang,
+          pages: readSnapshots(opts.root).length
+        })
       );
       return;
     }
@@ -56150,6 +56158,7 @@ function noop() {
 }
 
 // src/mcp/handlers.ts
+var CAPTURES_DIR = ".ultra11y/captures";
 var ToolError = class extends Error {
 };
 var MAX_READ_LINES = 2e3;
@@ -56220,6 +56229,8 @@ async function dispatch(name2, args2, cwd) {
       return handlePackCheck(args2, cwd);
     case "ultra11y_sample_check":
       return handleSampleCheck(cwd);
+    case "ultra11y_pages":
+      return handlePages(args2, cwd);
     case "ultra11y_read":
       return handleRead(args2, cwd);
     case "ultra11y_fix":
@@ -56240,8 +56251,11 @@ function audit(args2, cwd) {
   const warnings = [];
   try {
     process.chdir(cwd);
-    return runAudit({
-      inputs: strArray2(args2.globs) ?? DEFAULT_GLOBS,
+    const inputs = strArray2(args2.globs) ?? DEFAULT_GLOBS;
+    const scopedToDiff = bool(args2.changed) || bool(args2.staged) || str2(args2.since) !== void 0;
+    const extra = [CAPTURES_DIR, PAGES_DIR].filter((d) => !scopedToDiff && existsSync29(d) && !inputs.includes(d));
+    const result = runAudit({
+      inputs: [...inputs, ...extra],
       include: strArray2(args2.include),
       exclude: strArray2(args2.exclude),
       forceJsx: bool(args2.jsx),
@@ -56252,6 +56266,14 @@ function audit(args2, cwd) {
       maxFiles: positive(args2.max_files, "max_files"),
       onWarn: (m) => warnings.push(m)
     });
+    if (extra.includes(PAGES_DIR)) {
+      const scope = pageScopesFrom(readSnapshots("."));
+      if (scope.length) {
+        result.scope.pages = scope;
+        attributePages(result, scope);
+      }
+    }
+    return result;
   } finally {
     process.chdir(prev);
   }
@@ -56337,6 +56359,30 @@ function handleSampleCheck(cwd) {
   }
   return { cwd, config: raw, next: "Check the sample covers every page kind the methodology requires, not just the convenient ones." };
 }
+function handlePages(args2, cwd) {
+  const standard = standardOf(args2);
+  const lang = langOf(args2);
+  const r = audit(args2, cwd);
+  const scope = pagesOf(r);
+  if (!scope.length) {
+    throw new ToolError(
+      "no page in scope: this audit covers no snapshot (.ultra11y/pages) and no scanned sample. Capture pages with the E2E plugins, `ultra11y dev`, or `scan` (which snapshots every page it visits), then re-run."
+    );
+  }
+  attributePages(r, scope);
+  const derived = derivePages(r, scope);
+  const format = typeof args2.format === "string" ? args2.format : "grid";
+  const markdown = format === "report" ? renderPagesDocument(r, derived, { standard, lang }) : renderPageGrid(r, scope, standard, lang);
+  return {
+    cwd,
+    standard,
+    lang,
+    markdown,
+    pages: derived.map((p) => ({ id: p.id, name: p.name, url: p.url, basis: p.basis, conformancePct: p.conformancePct, findings: p.findings.length })),
+    unattributed: unattributedFindings(r).length,
+    next: 'A page whose basis is "attributed" has no snapshot: absence of a finding there is NOT conformity. Its undecided criteria stay yours to adjudicate.'
+  };
+}
 function handleFix(args2, cwd) {
   const prev = process.cwd();
   try {
@@ -56667,6 +56713,26 @@ var TOOLS2 = [
     description: "Validate a project's `.ultra11yrc.json` page sample against the methodology: a conformance claim covering only the pages that happened to be easy is not a conformance claim. Reads the config; changes nothing.",
     inputSchema: { type: "object", properties: { cwd: cwdProp }, required: ["cwd"] }
   },
+  {
+    name: "ultra11y_pages",
+    title: "The per-page view of the audit",
+    description: "RGAA \u2014 like every country standard \u2014 is a PER-PAGE norm, but the engine's verdict is scope-wide. This projects the audit onto the pages it covers: the criterion \xD7 page grid, or the per-page report (one dossier per page, every criterion of the standard with its status on THAT page). Two rules make it trustworthy: a finding belongs to a page only when something says so \u2014 never spread across pages \u2014 and a criterion is conforming by silence only on a page whose real rendered DOM was audited, and only for the criteria the engine can actually decide. Everything else stays \xAB to assess \xBB, which is what it is. Pages come from snapshots (.ultra11y/pages) or a scanned sample; with neither, there is nothing to project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: cwdProp,
+        globs: globsProp,
+        standard: standardProp,
+        lang: langProp,
+        format: {
+          type: "string",
+          enum: ["grid", "report"],
+          description: "`grid` (default) is the criterion \xD7 page matrix; `report` is the per-page dossiers."
+        }
+      },
+      required: ["cwd"]
+    }
+  },
   {
     name: "ultra11y_read",
     title: "Read a file from the project",
@@ -56754,6 +56820,7 @@ var TOOL_META2 = {
   ultra11y_adjudicate: { openWorld: false },
   ultra11y_pack_check: { openWorld: false },
   ultra11y_sample_check: { openWorld: false },
+  ultra11y_pages: { openWorld: false },
   ultra11y_read: { openWorld: false },
   // Rewrites source files. Not destructive in the delete sense, and it verifies
   // its own work — but it is the user's code.
@@ -59052,6 +59119,14 @@ async function cmdJudge(p) {
   }
   const max = typeof p.flags.max === "string" ? Number(p.flags.max) : void 0;
   const truncated = max !== void 0 && Number.isFinite(max) && max > 0 && items.length > max;
+  if (truncated && p.flags.apply === true) {
+    console.error(
+      lang === "fr" ? `ultra11y judge : --max ${max} ne couvre que ${max} des ${items.length} crit\xE8res, et --apply exige une adjudication COMPL\xC8TE (le gate refuse une couverture partielle).
+  Retirez --max pour tout adjuger, ou retirez --apply pour produire la worklist et l'appliquer plus tard.` : `ultra11y judge: --max ${max} covers only ${max} of ${items.length} criteria, and --apply requires a COMPLETE adjudication (the gate refuses partial coverage).
+  Drop --max to adjudicate everything, or drop --apply to produce the worklist and apply it later.`
+    );
+    return 2;
+  }
   if (truncated) items = items.slice(0, max);
   const batches = [];
   for (let i2 = 0; i2 < items.length; i2 += BATCH_SIZE) {

package/src/cli.ts

@@ -2124,6 +2124,19 @@ async function cmdJudge(p: ParsedArgs): Promise<number> {
   }
   const max = typeof p.flags.max === "string" ? Number(p.flags.max) : undefined;
   const truncated = max !== undefined && Number.isFinite(max) && max > 0 && items.length > max;
+  // `--max` bounds the spend; `--apply` folds the verdicts through a gate that REFUSES an
+  // incomplete adjudication. Together they can never succeed — so say so before spending
+  // anything, instead of billing a full run and failing on coverage at the end.
+  if (truncated && p.flags.apply === true) {
+    console.error(
+      lang === "fr"
+        ? `ultra11y judge : --max ${max} ne couvre que ${max} des ${items.length} critères, et --apply exige une adjudication COMPLÈTE (le gate refuse une couverture partielle).\n` +
+            "  Retirez --max pour tout adjuger, ou retirez --apply pour produire la worklist et l'appliquer plus tard."
+        : `ultra11y judge: --max ${max} covers only ${max} of ${items.length} criteria, and --apply requires a COMPLETE adjudication (the gate refuses partial coverage).\n` +
+            "  Drop --max to adjudicate everything, or drop --apply to produce the worklist and apply it later.",
+    );
+    return 2;
+  }
   if (truncated) items = items.slice(0, max);
 
   // Batch, and render EACH batch through the very worklist formatter the agent reads. There

package/src/dev.ts

@@ -424,11 +424,17 @@ export function startDevServer(opts: DevOptions): Promise<DevServer> {
     }
     // A liveness probe, so a client can say "run `ultra11y dev`" instead of failing silently.
     if (url.pathname === "/health") {
-      res
-        .writeHead(200, { "content-type": "application/json", "cache-control": "no-store" })
-        .end(
-          JSON.stringify({ ok: true, tool: "ultra11y", version: VERSION, standard: opts.standard, lang: opts.lang, pages: readSnapshots(opts.root).length }),
-        );
+      res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" }).end(
+        JSON.stringify({
+          ok: true,
+          tool: "ultra11y",
+          version: VERSION,
+          port: opts.port,
+          standard: opts.standard,
+          lang: opts.lang,
+          pages: readSnapshots(opts.root).length,
+        }),
+      );
       return;
     }
     if (url.pathname === "/snapshot" && req.method === "POST") {

package/src/integrations/cypress-plugin.ts

@@ -15,7 +15,7 @@
 // If that event never fires, the page is recorded without a screenshot — the criterion stays
 // undecided, exactly as before, and is never guessed.
 import { readFileSync } from "node:fs";
-import { type AuditLike, type FindingLike, type SnapshotPayload, auditSnapshot, failingFindings, formatFailure } from "./core.js";
+import { type AuditLike, type FindingLike, type SnapshotPayload, auditSnapshot, failingFindings, formatFailure, writePagesReport } from "./core.js";
 
 interface ScreenshotDetails {
   name?: string;
@@ -29,6 +29,8 @@ export interface TaskPayload extends SnapshotPayload {
   failOn?: string | false;
   /** The name `cy.screenshot()` was called with, when the browser half took one. */
   screenshotName?: string;
+  /** Forwarded from `cy.ultra11y({ report })` — the browser cannot write files, this side can. */
+  report?: boolean | { out?: string; standard?: string; lang?: string };
 }
 
 export interface TaskResult {
@@ -61,6 +63,7 @@ export default function register(on: On): void {
         }
       }
       const result: AuditLike = auditSnapshot(withShot);
+      if (payload.report) writePagesReport(typeof payload.report === "object" ? payload.report : {});
       const failOn = payload.failOn === undefined ? "blocking" : payload.failOn;
       const failing = failOn === false ? [] : failingFindings(result, failOn);
       // Return rather than throw: the browser half raises the assertion, so the failure is

package/src/integrations/cypress.ts

@@ -24,6 +24,13 @@ export interface CypressCheckOptions extends CheckOptions {
   /** Capture a viewport screenshot so the pixel tier can run. On by default — the plugin
    *  reads it back through Cypress's `after:screenshot` event. */
   screenshot?: boolean;
+  /** Also write the per-page report once this page is recorded. Off by default: a report per
+   *  checked page would be wasteful in a suite, so turn it on in a final test.
+   *
+   *  Cypress test code runs in the browser and cannot write files, so the option is only
+   *  DECLARED here and forwarded — the Node half does the work. Same option, same behaviour
+   *  as Playwright's; a runner that silently ignored it would be worse than one that lacked it. */
+  report?: boolean | { out?: string; standard?: string; lang?: string };
 }
 
 export function registerUltra11yCommand(): void {
@@ -41,6 +48,7 @@ export function registerUltra11yCommand(): void {
       const payload = {
         ...buildPayload(collected, url, "cypress", opts),
         failOn: opts.failOn,
+        ...(opts.report ? { report: opts.report } : {}),
         ...(shotName ? { screenshotName: shotName } : {}),
       };
       return cy.task("ultra11ySnapshot", payload, { log: false }).then((res: { failing?: unknown[]; message?: string }) => {

package/src/mcp/handlers.ts

@@ -12,6 +12,13 @@ import { renderReport, renderPackReport } from "../report.js";
 import { buildWorklist, formatWorklist } from "../verify.js";
 import { allSC, getSC } from "../wcag.js";
 import { loadPack } from "../standards/index.js";
+import { attributePages, derivePages, pageScopesFrom, pagesOf, renderPageGrid, unattributedFindings } from "../pages.js";
+import { PAGES_DIR, readSnapshots } from "../snapshot.js";
+
+// The CLI's default capture directory (`--captures` overrides it there; the MCP surface has
+// no such flag, so the default is the contract).
+const CAPTURES_DIR = ".ultra11y/captures";
+import { renderPagesDocument } from "../pages-report.js";
 import { withProjectLock } from "../project-lock.js";
 import type { AuditResult, Lang } from "../types.js";
 import type { StandardId } from "../standards/index.js";
@@ -132,6 +139,8 @@ async function dispatch(name: string, args: Record<string, unknown>, cwd: string
       return handlePackCheck(args, cwd);
     case "ultra11y_sample_check":
       return handleSampleCheck(cwd);
+    case "ultra11y_pages":
+      return handlePages(args, cwd);
     case "ultra11y_read":
       return handleRead(args, cwd);
     case "ultra11y_fix":
@@ -161,8 +170,18 @@ function audit(args: Record<string, unknown>, cwd: string): AuditResult {
   const warnings: string[] = [];
   try {
     process.chdir(cwd);
-    return runAudit({
-      inputs: strArray(args.globs) ?? DEFAULT_GLOBS,
+    const inputs = strArray(args.globs) ?? DEFAULT_GLOBS;
+    const scopedToDiff = bool(args.changed) || bool(args.staged) || str(args.since) !== undefined;
+
+    // RENDERED ARTEFACTS. `cmdAudit` appends `.ultra11y/captures` and `.ultra11y/pages` to the
+    // inputs and records the page scope; this helper did not, so every MCP tool audited LESS
+    // than the same command on the CLI: no rendered tier, none of the page-scoped rules
+    // (lang, title, main landmark), and no page dimension at all. An agent driving the server
+    // was quietly getting a smaller audit than the one it would have run itself.
+    const extra = [CAPTURES_DIR, PAGES_DIR].filter((d) => !scopedToDiff && existsSync(d) && !inputs.includes(d));
+
+    const result = runAudit({
+      inputs: [...inputs, ...extra],
       include: strArray(args.include),
       exclude: strArray(args.exclude),
       forceJsx: bool(args.jsx),
@@ -173,6 +192,17 @@ function audit(args: Record<string, unknown>, cwd: string): AuditResult {
       maxFiles: positive(args.max_files, "max_files"),
       onWarn: (m) => warnings.push(m),
     });
+
+    // Record the pages in scope so the projection can rebuild from this result alone — the
+    // same step cmdAudit takes right after runAudit.
+    if (extra.includes(PAGES_DIR)) {
+      const scope = pageScopesFrom(readSnapshots("."));
+      if (scope.length) {
+        result.scope.pages = scope;
+        attributePages(result, scope);
+      }
+    }
+    return result;
   } finally {
     process.chdir(prev);
   }
@@ -271,6 +301,34 @@ function handleSampleCheck(cwd: string): unknown {
   return { cwd, config: raw, next: "Check the sample covers every page kind the methodology requires, not just the convenient ones." };
 }
 
+/** The page dimension. Everything it needs is already on the AuditResult, so it re-measures
+ *  nothing — the same projection the report and the CLI use. */
+function handlePages(args: Record<string, unknown>, cwd: string): unknown {
+  const standard = standardOf(args);
+  const lang = langOf(args);
+  const r = audit(args, cwd);
+  const scope = pagesOf(r);
+  if (!scope.length) {
+    throw new ToolError(
+      "no page in scope: this audit covers no snapshot (.ultra11y/pages) and no scanned sample. " +
+        "Capture pages with the E2E plugins, `ultra11y dev`, or `scan` (which snapshots every page it visits), then re-run.",
+    );
+  }
+  attributePages(r, scope);
+  const derived = derivePages(r, scope);
+  const format = typeof args.format === "string" ? args.format : "grid";
+  const markdown = format === "report" ? renderPagesDocument(r, derived, { standard, lang }) : renderPageGrid(r, scope, standard, lang);
+  return {
+    cwd,
+    standard,
+    lang,
+    markdown,
+    pages: derived.map((p) => ({ id: p.id, name: p.name, url: p.url, basis: p.basis, conformancePct: p.conformancePct, findings: p.findings.length })),
+    unattributed: unattributedFindings(r).length,
+    next: 'A page whose basis is "attributed" has no snapshot: absence of a finding there is NOT conformity. Its undecided criteria stay yours to adjudicate.',
+  };
+}
+
 function handleFix(args: Record<string, unknown>, cwd: string): unknown {
   const prev = process.cwd();
   try {

package/src/mcp/tools.ts

@@ -178,6 +178,31 @@ export const TOOLS: ToolDecl[] = [
       "is not a conformance claim. Reads the config; changes nothing.",
     inputSchema: { type: "object", properties: { cwd: cwdProp }, required: ["cwd"] },
   },
+  {
+    name: "ultra11y_pages",
+    title: "The per-page view of the audit",
+    description:
+      "RGAA — like every country standard — is a PER-PAGE norm, but the engine's verdict is scope-wide. This projects the audit onto the pages it covers: " +
+      "the criterion × page grid, or the per-page report (one dossier per page, every criterion of the standard with its status on THAT page). " +
+      "Two rules make it trustworthy: a finding belongs to a page only when something says so — never spread across pages — and a criterion is conforming " +
+      "by silence only on a page whose real rendered DOM was audited, and only for the criteria the engine can actually decide. Everything else stays " +
+      "« to assess », which is what it is. Pages come from snapshots (.ultra11y/pages) or a scanned sample; with neither, there is nothing to project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: cwdProp,
+        globs: globsProp,
+        standard: standardProp,
+        lang: langProp,
+        format: {
+          type: "string",
+          enum: ["grid", "report"],
+          description: "`grid` (default) is the criterion × page matrix; `report` is the per-page dossiers.",
+        },
+      },
+      required: ["cwd"],
+    },
+  },
   {
     name: "ultra11y_read",
     title: "Read a file from the project",
@@ -283,6 +308,7 @@ export const TOOL_META: Record<string, { write?: boolean; destructive?: boolean;
   ultra11y_adjudicate: { openWorld: false },
   ultra11y_pack_check: { openWorld: false },
   ultra11y_sample_check: { openWorld: false },
+  ultra11y_pages: { openWorld: false },
   ultra11y_read: { openWorld: false },
   // Rewrites source files. Not destructive in the delete sense, and it verifies
   // its own work — but it is the user's code.

package/src/types.ts

@@ -1,6 +1,6 @@
 // Single source of truth for shared types + the embedded version. sync-version.mjs
 // rewrites VERSION at release time (kept in lockstep with package.json + SKILL.md).
-export const VERSION = "2.31.0";
+export const VERSION = "2.31.2";
 export const SCHEMA_VERSION = 2;
 
 // Lang = the UI FRAME's language — the `L` localization tables each module (report,