@hyperfixi/testing-framework 2.7.2 → 2.9.0

package/src/multilingual/fidelity.ts

@@ -121,6 +121,39 @@ export function computeFidelity(
   return hits / reference.length;
 }
 
+/**
+ * R0-recall on the **multiset** in [0, 1]: the fraction of the reference's
+ * actions — counting duplicates — also present in the candidate.
+ *
+ * {@link computeFidelity} scores the deduped Set signature, so a candidate that
+ * drops a REPEATED command scores 1.0: reference `[bind, bind]` collapses to
+ * `{bind}`, which `[bind]` satisfies in full. That is how `bind-two-way` sat at
+ * fidelity 1.0 across all 24 languages while every one of them parsed only the
+ * first of its two `bind`s. R1 (role signatures) is a Set too, and is equally
+ * blind. {@link computePrecision} catches the mirror case — a candidate that ADDS
+ * a duplicate — so before this signal existed the ratchet saw spurious commands
+ * but never dropped ones.
+ *
+ * Pass multisets (see {@link collectActionsMultiset}) on both sides.
+ * Returns `undefined` when the reference has no actions to compare against.
+ */
+export function computeMultisetRecall(
+  reference: readonly string[],
+  candidate: readonly string[]
+): number | undefined {
+  if (reference.length === 0) return undefined;
+  const cand = actionCounts(candidate);
+  let matched = 0;
+  for (const a of reference) {
+    const remaining = cand.get(a) ?? 0;
+    if (remaining > 0) {
+      matched++;
+      cand.set(a, remaining - 1);
+    }
+  }
+  return matched / reference.length;
+}
+
 /**
  * Structural **precision** in [0, 1]: the fraction of the *candidate's* actions
  * that are justified by the reference (multiset-aware). The complement of
@@ -222,3 +255,123 @@ function walkRoles(node: unknown, acc: Set<string>, depth: number): void {
     }
   }
 }
+
+/**
+ * Role-value kinds never emitted by the R3 walker. `reference` values (`me`,
+ * `it`, …) are mostly `fillSchemaDefaults` injections present identically on
+ * both sides — noise. `flag` names and `property-path` properties are bare
+ * identifiers, excluded by v1 (see {@link collectRoleValueSignature}).
+ */
+const VALUE_KIND_EXCLUSIONS = new Set(['reference', 'flag', 'property-path']);
+
+/**
+ * A role value is compared cross-language only when its WHOLE surface form is
+ * code-shaped — language-invariant by construction, never legitimately
+ * translated. Conservative v1 whitelist; when a sweep firing turns out to be a
+ * legit translation difference, tighten here and document the exclusion.
+ */
+const INVARIANT_VALUE_PATTERNS: readonly RegExp[] = [
+  /^[#.[<@*]/, // selectors: #id  .class  [attr]  <tag/>  @attr  *style
+  /^[:$^][A-Za-z_]\w*$/, // sigil refs: :local  $global  ^element
+  /^\d+(\.\d+)?(ms|s|m|h)?$/, // numbers and time literals: 2  1.5  200ms
+  /^[A-Za-z_][\w-]*:[\w-]+$/, // colon-qualified event names: draggable:start
+  /^(\.{0,2}\/|https?:)/, // URLs / paths: /api/data  ./x  ../y  https://…
+];
+
+function isInvariantSurface(surface: string): boolean {
+  // Whole-surface rule, sweep-validated exclusions:
+  // - whitespace ⇒ mixed content. `if #modal exists` captures its condition as
+  //   `#modal exists` — starts selector-shaped, but `exists` is prose that every
+  //   language legitimately translates (16-language false firing without this).
+  // - `${` ⇒ template interpolation. `/api/search?q=${my value}` is an
+  //   expression, and tokenizers split it at different points per language, so
+  //   the captured surface isn't comparable verbatim.
+  if (/\s/.test(surface) || surface.includes('${')) return false;
+  return INVARIANT_VALUE_PATTERNS.some(re => re.test(surface));
+}
+
+/**
+ * The comparable surface form of a role value, or `undefined` when the value
+ * carries none: `.value` for `literal`/`selector` (string/number/boolean
+ * coerced), `.raw` for `expression`. Kinds in {@link VALUE_KIND_EXCLUSIONS}
+ * and values without a string `type` discriminator yield `undefined`.
+ */
+function roleValueSurface(value: unknown): string | undefined {
+  if (value === null || typeof value !== 'object') return undefined;
+  const rec = value as { type?: unknown; value?: unknown; raw?: unknown };
+  if (typeof rec.type !== 'string' || VALUE_KIND_EXCLUSIONS.has(rec.type)) return undefined;
+  if (rec.type === 'expression') {
+    return typeof rec.raw === 'string' ? rec.raw : undefined;
+  }
+  const v = rec.value;
+  return typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean'
+    ? String(v)
+    : undefined;
+}
+
+/**
+ * R3 — role-VALUE signature (invariant values only, multiset).
+ *
+ * R0/R1 compare actions and role *types*; values are never compared because
+ * they are legitimately translated. That leaves a live defect class with zero
+ * signal: right action counts, right role types, wrong role VALUE — the #633
+ * class, where ms captured `trigger` events named `draggable` instead of
+ * `draggable:start` (correct multiset, correct `trigger.event:literal`
+ * signature, silently wrong runtime behavior), and 18 other languages carried
+ * the same corruption with no side-effect at all.
+ *
+ * The subset of values compared here is language-invariant by construction —
+ * code, not prose (see {@link INVARIANT_VALUE_PATTERNS}). Emits a **multiset**
+ * of `` `action.role=value` `` entries (duplicates preserved, sorted); score
+ * with {@link computeMultisetRecall} so a dropped duplicate value is visible.
+ *
+ * Deliberately EXCLUDED in v1: bare-word identifiers (`startX` — usually
+ * invariant, but property/variable names occasionally get localized in seeds),
+ * string literals (message strings are legitimately translated), expression
+ * raws mixing native words + code (`次 .item`), and `reference` values
+ * (`me`/`it` — mostly `fillSchemaDefaults` injections on both sides).
+ *
+ * Blind spot: recall fires when a *translation* loses/corrupts an invariant
+ * value. If the **en reference itself** corrupts a value, every language flags
+ * at once — a 24-language R3 firestorm on one pattern means "suspect the en
+ * parse first" (unlike R0, where en corruption moves nothing).
+ *
+ * The roles container is a ReadonlyMap on live nodes (serializes to {} in
+ * results.json), so collect at validation time, never from the JSON.
+ */
+export function collectRoleValueSignature(node: unknown): string[] {
+  const acc: string[] = [];
+  walkRoleValues(node, acc, 0);
+  return acc.sort();
+}
+
+function walkRoleValues(node: unknown, acc: string[], depth: number): void {
+  if (depth > 64 || node === null || typeof node !== 'object') return;
+
+  const rec = node as Record<string, unknown>;
+  const action = rec.action;
+  if (typeof action === 'string' && !STRUCTURAL_ACTIONS.has(action)) {
+    const roles = rec.roles;
+    const entries: Array<[unknown, unknown]> =
+      roles instanceof Map
+        ? [...roles.entries()]
+        : roles && typeof roles === 'object'
+          ? Object.entries(roles)
+          : [];
+    for (const [role, value] of entries) {
+      if (value === undefined || value === null) continue;
+      const surface = roleValueSurface(value);
+      if (surface === undefined || !isInvariantSurface(surface)) continue;
+      acc.push(`${action}.${String(role)}=${surface}`);
+    }
+  }
+
+  for (const field of CHILD_FIELDS) {
+    const child = rec[field];
+    if (Array.isArray(child)) {
+      for (const c of child) walkRoleValues(c, acc, depth + 1);
+    } else if (child && typeof child === 'object') {
+      walkRoleValues(child, acc, depth + 1);
+    }
+  }
+}

package/src/multilingual/foreign-canonical-validity.ts

@@ -0,0 +1,158 @@
+/**
+ * Foreign→English canonical-validity gate
+ * ---------------------------------------
+ * The sibling en-render gate (canonical-validity.ts) renders every corpus English
+ * reference and parses it on the real `hyperscript.org` engine. But the PRODUCTION
+ * path is foreign→English: an authored non-English source is parsed and rendered to
+ * English (`preprocessToEnglish` → `render`). A parse can be role-faithful (the
+ * fidelity ratchet scores ~1.0) yet still render English the canonical parser rejects.
+ * (The build-time `@hyperscript-tools/i18n` transpiler now parse-gates its ENGLISH
+ * side with the same loader recipe; faithful foreign-output gating there still awaits
+ * the v2 semantic-engine transpiler, since its GrammarTransformer is lossy in reverse.)
+ *
+ * This gate closes that blind spot for the multilingual path: for every language, it
+ * renders each authored `pattern_translation` to English and parses the result on
+ * the canonical engine, failing on any invalid (pattern, language) pair that is not
+ * in the committed allowlist. The allowlist is keyed by pattern id → the languages
+ * that currently fail, so a fix that clears a family across languages shrinks (or
+ * removes) its entry — the list only ever ratchets down.
+ *
+ * Denominator: only (pattern, language) pairs whose EN reference the canonical parser
+ * already accepts are scored, so a handful of inherently non-canonical corpus rows
+ * never distort the signal (same fairness rule as the en gate).
+ *
+ * DB dependency: reads authored translations from `pattern_translations`, which only
+ * exist after `npm run populate`. Generate the baseline and run the gate against a
+ * freshly populated DB (CI's multilingual-validation job populates; see the
+ * provenance-stamp discipline in packages/patterns-reference/CLAUDE.md).
+ */
+
+import { getAllPatterns, getTranslationsByLanguage } from '@hyperfixi/patterns-reference';
+import { parseSemantic, render } from '@lokascript/semantic';
+import { loadCanonicalParser, type CanonicalValidate } from './canonical-validity';
+
+/**
+ * The 23 non-English priority languages (the `browser-priority` corpus set). English
+ * is the reference, scored by the sibling en gate.
+ */
+export const FOREIGN_LANGUAGES = [
+  'es',
+  'fr',
+  'pt',
+  'it',
+  'id',
+  'ms',
+  'sw',
+  'zh',
+  'vi',
+  'tl',
+  'ja',
+  'ko',
+  'tr',
+  'qu',
+  'hi',
+  'bn',
+  'ar',
+  'de',
+  'ru',
+  'uk',
+  'pl',
+  'th',
+  'he',
+] as const;
+
+export interface ForeignValidityFailure {
+  /** Corpus pattern id (`code_example` id the translation belongs to). */
+  id: string;
+  language: string;
+  /** The authored foreign source that was rendered. */
+  foreign: string;
+  /** The English the renderer produced from the foreign parse. */
+  rendered: string;
+  error: string;
+}
+
+export interface ForeignValidityResult {
+  /** (pattern, language) pairs whose EN reference the canonical parser accepts. */
+  checked: number;
+  valid: number;
+  failures: ForeignValidityFailure[];
+}
+
+/**
+ * Render every authored foreign `pattern_translation` to English and parse it on the
+ * canonical engine. Only pairs whose EN reference is itself canonical-valid are scored.
+ */
+export async function checkForeignRenderValidity(opts?: {
+  validate?: CanonicalValidate;
+  languages?: readonly string[];
+  /** Translations fetched per language (defaults comfortably above the corpus size). */
+  perLanguageLimit?: number;
+}): Promise<ForeignValidityResult> {
+  const validate = opts?.validate ?? (await loadCanonicalParser());
+  const languages = opts?.languages ?? FOREIGN_LANGUAGES;
+  const limit = opts?.perLanguageLimit ?? 500;
+
+  const patterns = await getAllPatterns();
+  const enAccepts = new Map(patterns.map(p => [p.id, validate(p.rawCode).length === 0]));
+
+  const failures: ForeignValidityFailure[] = [];
+  let checked = 0;
+  let valid = 0;
+
+  for (const language of languages) {
+    const translations = await getTranslationsByLanguage(language, limit);
+    for (const t of translations) {
+      if (!enAccepts.get(t.codeExampleId)) continue; // fair denominator: EN accepts the reference
+      checked++;
+
+      let rendered: string;
+      let errors: string[];
+      try {
+        const node = parseSemantic(t.hyperscript, language).node;
+        rendered = node ? render(node, 'en') : '(no node)';
+        errors = validate(rendered);
+      } catch (e) {
+        // parseSemantic/render only — validate never throws (its tokenizer-level
+        // throws fold into the returned array), so an invalid render is reported
+        // WITH the render that caused it, not discarded as '(threw)'.
+        rendered = '(threw)';
+        errors = ['threw: ' + (e as Error).message.split('\n')[0]];
+      }
+
+      if (errors.length === 0) {
+        valid++;
+      } else {
+        failures.push({
+          id: t.codeExampleId,
+          language,
+          foreign: t.hyperscript,
+          rendered,
+          error: errors[0] ?? 'unknown error',
+        });
+      }
+    }
+  }
+
+  return { checked, valid, failures };
+}
+
+/**
+ * Group failures into the committed allowlist shape: `{ patternId: [langs…] }`
+ * (languages sorted for a stable diff). Used by the baseline generator and by the
+ * gate's stale-entry check.
+ */
+export function groupFailuresByPattern(
+  failures: readonly ForeignValidityFailure[]
+): Record<string, string[]> {
+  const byPattern = new Map<string, Set<string>>();
+  for (const f of failures) {
+    if (!byPattern.has(f.id)) byPattern.set(f.id, new Set());
+    byPattern.get(f.id)!.add(f.language);
+  }
+  const out: Record<string, string[]> = {};
+  for (const id of [...byPattern.keys()].sort()) {
+    out[id] = [...byPattern.get(id)!].sort();
+  }
+  return out;
+}

package/src/multilingual/orchestrator.ts

@@ -20,7 +20,13 @@ import type {
   Reporter,
   BundleInfo,
 } from './types';
-import { computeFidelity, computePrecision, FIDELITY_THRESHOLD } from './fidelity';
+import {
+  computeFidelity,
+  computePrecision,
+  computeMultisetRecall,
+  spuriousActions,
+  FIDELITY_THRESHOLD,
+} from './fidelity';
 
 const execAsync = promisify(exec);
 
@@ -258,6 +264,8 @@ export class TestOrchestrator {
     const multisetReference = new Map<string, string[]>();
     // R1: codeExampleId -> English role signature (action.role:valueType set).
     const roleReference = new Map<string, string[]>();
+    // R3: codeExampleId -> English role-VALUE signature (invariant values, multiset).
+    const roleValueReference = new Map<string, string[]>();
     for (const r of en.parseResults) {
       if (r.success && r.actionSignature && r.actionSignature.length > 0) {
         reference.set(r.pattern.codeExampleId, r.actionSignature);
@@ -268,6 +276,9 @@ export class TestOrchestrator {
       if (r.success && r.roleSignature && r.roleSignature.length > 0) {
         roleReference.set(r.pattern.codeExampleId, r.roleSignature);
       }
+      if (r.success && r.roleValueSignature && r.roleValueSignature.length > 0) {
+        roleValueReference.set(r.pattern.codeExampleId, r.roleValueSignature);
+      }
     }
 
     for (const lang of languageResults) {
@@ -277,7 +288,9 @@ export class TestOrchestrator {
       const lossy: string[] = [];
       const scores: number[] = [];
       const precisionScores: number[] = [];
+      const multisetRecallScores: number[] = [];
       const roleScores: number[] = [];
+      const valueRecallScores: number[] = [];
 
       for (const result of lang.parseResults) {
         if (!result.success || !result.actionSignature) continue;
@@ -294,6 +307,9 @@ export class TestOrchestrator {
 
         // R0-precision — fraction of THIS parse's actions justified by the en
         // multiset reference (catches phantom/spurious commands recall misses).
+        // R0-recall-multiset — the mirror: fraction of the en reference's actions,
+        // counting duplicates, present here (catches a DROPPED repeated command,
+        // which the Set-based fidelity/roleFidelity above cannot see).
         const multisetRef = multisetReference.get(result.pattern.codeExampleId);
         if (multisetRef && result.actionMultisetSignature) {
           const precision = computePrecision(multisetRef, result.actionMultisetSignature);
@@ -301,6 +317,11 @@ export class TestOrchestrator {
             result.precision = precision;
             precisionScores.push(precision);
           }
+          const multisetRecall = computeMultisetRecall(multisetRef, result.actionMultisetSignature);
+          if (multisetRecall !== undefined) {
+            result.multisetRecall = multisetRecall;
+            multisetRecallScores.push(multisetRecall);
+          }
         }
 
         // R1 — role recall vs the en role signature (role name + value type).
@@ -312,6 +333,23 @@ export class TestOrchestrator {
             roleScores.push(roleFidelity);
           }
         }
+
+        // R3 — invariant role-VALUE recall vs the en value signature (multiset).
+        // Values are compared verbatim: the filtered subset (selectors, sigil
+        // refs, time literals, colon-qualified events, URLs) is code, not prose.
+        const valueRef = roleValueReference.get(result.pattern.codeExampleId);
+        if (valueRef && result.roleValueSignature) {
+          const valueRecall = computeMultisetRecall(valueRef, result.roleValueSignature);
+          if (valueRecall !== undefined) {
+            result.valueRecall = valueRecall;
+            valueRecallScores.push(valueRecall);
+            if (valueRecall < 1) {
+              // Missing = reference entries not covered here (multiset diff;
+              // spuriousActions with the arguments swapped).
+              result.valueRecallMissing = spuriousActions(result.roleValueSignature, valueRef);
+            }
+          }
+        }
       }
 
       lang.avgFidelity =
@@ -320,10 +358,18 @@ export class TestOrchestrator {
         precisionScores.length > 0
           ? precisionScores.reduce((a, b) => a + b, 0) / precisionScores.length
           : undefined;
+      lang.avgMultisetRecall =
+        multisetRecallScores.length > 0
+          ? multisetRecallScores.reduce((a, b) => a + b, 0) / multisetRecallScores.length
+          : undefined;
       lang.avgRoleFidelity =
         roleScores.length > 0
           ? roleScores.reduce((a, b) => a + b, 0) / roleScores.length
           : undefined;
+      lang.avgValueRecall =
+        valueRecallScores.length > 0
+          ? valueRecallScores.reduce((a, b) => a + b, 0) / valueRecallScores.length
+          : undefined;
       lang.degeneratePasses = degenerate.sort();
       lang.lossyPasses = lossy.sort();
     }

package/src/multilingual/reporters/console-reporter.ts

@@ -158,11 +158,62 @@ export class ConsoleReporter implements Reporter {
     }
 
     this.reportDegeneratePasses(results);
+    this.reportValueRecall(results);
     this.reportExecutionFailures(results);
 
     this.log('');
   }
 
+  /**
+   * R3 — surface parses that lost/corrupted a language-invariant role VALUE
+   * (selector, sigil ref, time literal, colon-qualified event name, URL) vs
+   * the en reference. These score 1.0 on every action/type-based signal yet
+   * behave differently at runtime, so they're reported separately. Report-only:
+   * the ratchet gate lives in the --regression path.
+   */
+  private reportValueRecall(results: TestResults): void {
+    const scored = results.languageResults.filter(l => l.avgValueRecall !== undefined);
+    if (scored.length === 0) return;
+
+    const avg = scored.reduce((sum, l) => sum + (l.avgValueRecall ?? 0), 0) / scored.length;
+    this.log('');
+    this.log(
+      this.bright(`Role values (R3): avgValueRecall ${avg.toFixed(4)} over invariant values`)
+    );
+
+    // pattern id -> "lang: missing entries" rows
+    const byPattern = new Map<string, string[]>();
+    let instances = 0;
+    for (const lang of scored) {
+      for (const r of lang.parseResults) {
+        if (r.valueRecall === undefined || r.valueRecall >= 1) continue;
+        instances++;
+        let rows = byPattern.get(r.pattern.codeExampleId);
+        if (!rows) {
+          rows = [];
+          byPattern.set(r.pattern.codeExampleId, rows);
+        }
+        rows.push(`${lang.language}: missing ${(r.valueRecallMissing ?? []).join(', ')}`);
+      }
+    }
+    if (byPattern.size === 0) return;
+
+    this.log(
+      this.yellow(
+        `⚠ Invariant value loss: ${instances} instance(s) across ${byPattern.size} pattern(s)`
+      )
+    );
+    this.log(
+      this.dim(
+        '  (an action.role=value present in the en reference is absent — not parse failures)'
+      )
+    );
+    for (const [id, rows] of [...byPattern.entries()].sort((a, b) => b[1].length - a[1].length)) {
+      this.log(`  ${this.dim('-')} ${id}`);
+      for (const row of rows.sort()) this.log(`      ${this.dim(row)}`);
+    }
+  }
+
   /**
    * R2 — surface curated-subset patterns whose jsdom execution diverged from
    * the en reference's DOM effects. These can score 1.0 on parse fidelity yet

package/src/multilingual/reporters/regression-reporter.test.ts

@@ -404,3 +404,81 @@ describe('RegressionReporter precision ratchet — R0-precision (trust floor)',
     expect(saved.languages.ja!.avgPrecision).toBeCloseTo(0.95, 5);
   });
 });
+
+describe('RegressionReporter per-pattern parse ratchet — R5', () => {
+  let dir: string;
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function reporterWith(baseline: Baseline): RegressionReporter {
+    dir = mkdtempSync(join(tmpdir(), 'parse-ratchet-'));
+    const path = join(dir, 'baseline.json');
+    writeFileSync(path, JSON.stringify(baseline));
+    return new RegressionReporter(path);
+  }
+
+  /** Minimal ParseResult for a pattern that no longer parses. */
+  function fail(id: string): ParseResult {
+    return { ...pass(id), success: false };
+  }
+
+  function baselineOf(ids: string[], failing: string[] = []): Baseline {
+    const patterns: Record<string, { success: boolean; confidence: number | undefined }> = {};
+    for (const id of ids) {
+      patterns[id] = { success: !failing.includes(id), confidence: 1 };
+    }
+    return {
+      timestamp: '',
+      commit: 'base',
+      languages: {
+        ja: {
+          parseSuccess: ids.length - failing.length,
+          parseFailure: failing.length,
+          parseRate: (ids.length - failing.length) / ids.length,
+          avgConfidence: 1,
+          avgFidelity: 1,
+          degeneratePasses: [],
+          lossyPasses: [],
+          bundleSize: undefined,
+          patterns,
+        },
+      },
+      bundles: {},
+    };
+  }
+
+  it('flags a baseline pass that no longer parses', () => {
+    const reporter = reporterWith(baselineOf(['a', 'b', 'c']));
+    reporter.reportComplete(results(lang([pass('a'), fail('b'), pass('c')], [])));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newFailures).toEqual(['b']);
+  });
+
+  it('does not flag a pattern that was already failing in the baseline', () => {
+    const reporter = reporterWith(baselineOf(['a', 'b'], ['b']));
+    reporter.reportComplete(results(lang([pass('a'), fail('b')], [])));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newFailures).toEqual([]);
+  });
+
+  it('never retro-flags when the baseline has no per-pattern data', () => {
+    const noPatterns = baselineOf(['a', 'b']);
+    delete (noPatterns.languages.ja as { patterns?: unknown }).patterns;
+    const reporter = reporterWith(noPatterns);
+    reporter.reportComplete(results(lang([fail('a'), fail('b')], [])));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newFailures).toEqual([]);
+  });
+
+  // The list is the R5 gate's evidence, not just a reporting nicety: it used to
+  // be `.slice(0, 10)`, which would have under-reported how much broke — and, if
+  // the gate ever counted it, capped the count at 10.
+  it('returns every new failure, uncapped', () => {
+    const ids = Array.from({ length: 25 }, (_, i) => `p${i}`);
+    const reporter = reporterWith(baselineOf(ids));
+    reporter.reportComplete(results(lang(ids.map(fail), [])));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newFailures).toHaveLength(25);
+  });
+});

package/src/multilingual/reporters/regression-reporter.ts

@@ -118,12 +118,25 @@ export class RegressionReporter implements Reporter {
         langResult.avgPrecision !== undefined && baselineLang.avgPrecision !== undefined
           ? langResult.avgPrecision - baselineLang.avgPrecision
           : 0;
+      // R0-recall-multiset — same both-sides guard. Negative = a repeated command
+      // is now being dropped, which avgFidelity (a Set) cannot see.
+      const avgMultisetRecallDelta =
+        langResult.avgMultisetRecall !== undefined && baselineLang.avgMultisetRecall !== undefined
+          ? langResult.avgMultisetRecall - baselineLang.avgMultisetRecall
+          : 0;
       // R1 — only meaningful when BOTH sides carry role data; an un-regenerated
       // baseline (no avgRoleFidelity yet) must never retro-flag.
       const avgRoleFidelityDelta =
         langResult.avgRoleFidelity !== undefined && baselineLang.avgRoleFidelity !== undefined
           ? langResult.avgRoleFidelity - baselineLang.avgRoleFidelity
           : 0;
+      // R3 — same both-sides guard. Negative = a language-invariant role VALUE
+      // (selector/sigil/time/colon-event/URL) is now lost or corrupted, which
+      // every action/type-based signal scores as perfect.
+      const avgValueRecallDelta =
+        langResult.avgValueRecall !== undefined && baselineLang.avgValueRecall !== undefined
+          ? langResult.avgValueRecall - baselineLang.avgValueRecall
+          : 0;
       // R2 — same both-sides guard: an un-regenerated baseline (no execution
       // data yet) must never retro-flag.
       const avgExecutionFidelityDelta =
@@ -163,7 +176,9 @@ export class RegressionReporter implements Reporter {
         avgConfidenceDelta,
         avgFidelityDelta,
         avgPrecisionDelta,
+        avgMultisetRecallDelta,
         avgRoleFidelityDelta,
+        avgValueRecallDelta,
         avgExecutionFidelityDelta,
         bundleSizeDelta: bundleSizeDelta !== undefined ? bundleSizeDelta : undefined,
         newFailures,
@@ -211,7 +226,11 @@ export class RegressionReporter implements Reporter {
       }
     }
 
-    return newFailures.slice(0, 10); // Limit to 10 for reporting
+    // Returned UNCAPPED: this list is the R5 parse ratchet's evidence (cli.ts),
+    // not just a reporting nicety, and a gate that silently truncated itself
+    // would under-report how much broke. Display sites do their own capping
+    // (console-reporter shows 5; the CLI shows 20).
+    return newFailures;
   }
 
   /**
@@ -364,9 +383,17 @@ export class RegressionReporter implements Reporter {
         // R0-precision — fraction of each parse's actions justified by the en
         // reference (phantom-command signal recall can't see). Recorded + ratcheted.
         avgPrecision: langResult.avgPrecision ?? undefined,
+        // R0-recall-multiset — the mirror of precision: a DROPPED repeated command
+        // (`[bind, bind]` parsed as `[bind]`) is invisible to the Set-based
+        // avgFidelity and avgRoleFidelity. Recorded + ratcheted.
+        avgMultisetRecall: langResult.avgMultisetRecall ?? undefined,
         // R1 — role fidelity (role name + value type vs the en reference).
         // Recorded + ratcheted; burn-down is NOT part of the parsing-track goal.
         avgRoleFidelity: langResult.avgRoleFidelity ?? undefined,
+        // R3 — invariant role-VALUE recall (verbatim value comparison over the
+        // code-shaped subset: selectors, sigil refs, time literals,
+        // colon-qualified event names, URLs). Recorded + ratcheted.
+        avgValueRecall: langResult.avgValueRecall ?? undefined,
         // R2 — execution fidelity over the curated subset (DOM effects vs the
         // en reference in jsdom). Recorded + ratcheted; burn-down deferred.
         avgExecutionFidelity: langResult.avgExecutionFidelity ?? undefined,