@hyperfixi/testing-framework 2.5.0 → 2.6.0

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

@@ -157,7 +157,92 @@ export class ConsoleReporter implements Reporter {
       }
     }
 
+    this.reportDegeneratePasses(results);
+    this.reportExecutionFailures(results);
+
+    this.log('');
+  }
+
+  /**
+   * 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
+   * behave differently at runtime, so they're reported separately.
+   */
+  private reportExecutionFailures(results: TestResults): void {
+    // pattern id -> languages where execution diverged
+    const byPattern = new Map<string, string[]>();
+    const scored = results.languageResults.filter(l => l.avgExecutionFidelity !== undefined);
+    for (const lang of scored) {
+      for (const id of lang.executionFailures ?? []) {
+        let langs = byPattern.get(id);
+        if (!langs) {
+          langs = [];
+          byPattern.set(id, langs);
+        }
+        langs.push(lang.language);
+      }
+    }
+    if (scored.length === 0) return;
+
+    const avg = scored.reduce((sum, l) => sum + (l.avgExecutionFidelity ?? 0), 0) / scored.length;
+    this.log('');
+    this.log(
+      this.bright(`Execution (R2): avgExecutionFidelity ${avg.toFixed(4)} over curated subset`)
+    );
+    if (byPattern.size === 0) return;
+
+    const totalInstances = [...byPattern.values()].reduce((n, langs) => n + langs.length, 0);
+    this.log(
+      this.yellow(
+        `⚠ Execution divergence: ${totalInstances} instance(s) across ${byPattern.size} pattern(s)`
+      )
+    );
+    this.log(
+      this.dim('  (DOM effects differ from the en reference in jsdom — not parse failures)')
+    );
+    for (const [id, langs] of [...byPattern.entries()].sort((a, b) => b[1].length - a[1].length)) {
+      this.log(
+        `  ${this.dim('-')} ${id} ${this.dim(`(${langs.length}: ${langs.sort().join(',')})`)}`
+      );
+    }
+  }
+
+  /**
+   * Surface *degenerate* passes — patterns that parse non-null but drop most of
+   * the English reference's command structure (structural fidelity below the
+   * threshold). These pass the parse-rate gate yet aren't faithful translations,
+   * so they're reported separately rather than silently counted as green.
+   */
+  private reportDegeneratePasses(results: TestResults): void {
+    // pattern id -> languages where it's a degenerate pass
+    const byPattern = new Map<string, string[]>();
+    for (const lang of results.languageResults) {
+      for (const id of lang.degeneratePasses ?? []) {
+        let langs = byPattern.get(id);
+        if (!langs) {
+          langs = [];
+          byPattern.set(id, langs);
+        }
+        langs.push(lang.language);
+      }
+    }
+    if (byPattern.size === 0) return;
+
+    const totalInstances = [...byPattern.values()].reduce((n, langs) => n + langs.length, 0);
     this.log('');
+    this.log(
+      this.yellow(
+        `⚠ Degenerate passes: ${totalInstances} instance(s) across ${byPattern.size} pattern(s)`
+      )
+    );
+    this.log(
+      this.dim('  (parse non-null but lost >50% of the English command structure — not failures)')
+    );
+    for (const [id, langs] of [...byPattern.entries()].sort((a, b) => b[1].length - a[1].length)) {
+      this.log(
+        `  ${this.dim('-')} ${id} ${this.dim(`(${langs.length}: ${langs.sort().join(',')})`)}`
+      );
+    }
   }
 
   /**
@@ -211,6 +296,22 @@ export class ConsoleReporter implements Reporter {
         this.log(`  ${this.green('New Successes:')} ${result.newSuccesses.length}`);
       }
 
+      // Fidelity regressions (faithful pass → degenerate pass)
+      if (result.newDegeneratePasses.length > 0) {
+        this.log(
+          `  ${this.yellow('Fidelity Regressions:')} ${result.newDegeneratePasses.length}` +
+            ` ${this.dim(`(${result.newDegeneratePasses.join(', ')})`)}`
+        );
+      }
+
+      // R2 — execution regressions (faithful execution → divergent DOM effects)
+      if (result.newExecutionFailures.length > 0) {
+        this.log(
+          `  ${this.red('Execution Regressions:')} ${result.newExecutionFailures.length}` +
+            ` ${this.dim(`(${result.newExecutionFailures.join(', ')})`)}`
+        );
+      }
+
       this.log('');
     }
   }

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

@@ -0,0 +1,406 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { writeFileSync, readFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { RegressionReporter } from './regression-reporter';
+import type { TestResults, LanguageResults, ParseResult, Baseline } from '../types';
+
+/** Minimal ParseResult for a successful pattern. */
+function pass(id: string): ParseResult {
+  return {
+    pattern: {
+      codeExampleId: id,
+      language: 'ja',
+      hyperscript: '',
+      wordOrder: 'SOV',
+      confidence: 1,
+      verifiedParses: 0,
+      roleAlignmentScore: 0,
+    },
+    success: true,
+    duration: 0,
+  };
+}
+
+function lang(
+  parseResults: ParseResult[],
+  degeneratePasses: string[],
+  lossyPasses: string[] = [],
+  avgFidelity = 1
+): LanguageResults {
+  const parseSuccess = parseResults.filter(r => r.success).length;
+  return {
+    language: 'ja',
+    bundle: 'browser-priority',
+    parseResults,
+    parseSuccess,
+    parseFailure: parseResults.length - parseSuccess,
+    parseRate: parseSuccess / parseResults.length,
+    avgConfidence: 1,
+    avgFidelity,
+    degeneratePasses,
+    lossyPasses,
+    duration: 0,
+    status: 'pass',
+  };
+}
+
+function results(language: LanguageResults): TestResults {
+  return {
+    timestamp: '',
+    commit: 'test',
+    config: {} as TestResults['config'],
+    languageResults: [language],
+    bundles: {},
+    summary: {
+      totalPatterns: language.parseResults.length,
+      totalSuccess: language.parseSuccess,
+      totalFailure: language.parseFailure,
+      totalDuration: 0,
+      overallStatus: 'pass',
+    },
+  };
+}
+
+describe('RegressionReporter fidelity ratchet', () => {
+  let dir: string;
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function reporterWith(baseline: Baseline): RegressionReporter {
+    dir = mkdtempSync(join(tmpdir(), 'fidelity-'));
+    const path = join(dir, 'baseline.json');
+    writeFileSync(path, JSON.stringify(baseline));
+    return new RegressionReporter(path);
+  }
+
+  const baseline: Baseline = {
+    timestamp: '',
+    commit: 'base',
+    languages: {
+      ja: {
+        parseSuccess: 3,
+        parseFailure: 1,
+        parseRate: 0.75,
+        avgConfidence: 1,
+        avgFidelity: 0.9,
+        // `was-degenerate` already degenerate; `was-faithful` is a clean pass;
+        // `was-fail` failed in baseline.
+        degeneratePasses: ['was-degenerate'],
+        lossyPasses: ['was-lossy'],
+        bundleSize: undefined,
+        patterns: {
+          'was-faithful': { success: true, confidence: 1 },
+          'was-degenerate': { success: true, confidence: 1 },
+          'was-lossy': { success: true, confidence: 1 },
+          stable: { success: true, confidence: 1 },
+          'was-fail': { success: false, confidence: undefined },
+        },
+      },
+    },
+    bundles: {},
+  };
+
+  it('flags a faithful baseline pass that became degenerate', () => {
+    const reporter = reporterWith(baseline);
+    // `was-faithful` is now degenerate; `was-fail` now parses degenerately (improvement).
+    reporter.reportComplete(
+      results(
+        lang(
+          [pass('was-faithful'), pass('was-degenerate'), pass('stable'), pass('was-fail')],
+          ['was-faithful', 'was-degenerate', 'was-fail']
+        )
+      )
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    // Only the faithful→degenerate transition is a regression.
+    expect(r.newDegeneratePasses).toEqual(['was-faithful']);
+    // `was-degenerate` (already degenerate) and `was-fail` (was failing) are excluded.
+    expect(r.newDegeneratePasses).not.toContain('was-degenerate');
+    expect(r.newDegeneratePasses).not.toContain('was-fail');
+    expect(r.status).toBe('regressed');
+  });
+
+  it('does not flag anything when fidelity is unchanged', () => {
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(
+      results(
+        lang([pass('was-faithful'), pass('was-degenerate'), pass('stable')], ['was-degenerate'])
+      )
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newDegeneratePasses).toEqual([]);
+  });
+
+  it('never retro-flags when the baseline has no fidelity data', () => {
+    const noFidelity: Baseline = structuredClone(baseline);
+    delete noFidelity.languages.ja!.degeneratePasses;
+    const reporter = reporterWith(noFidelity);
+    reporter.reportComplete(
+      results(lang([pass('was-faithful'), pass('stable')], ['was-faithful', 'stable']))
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newDegeneratePasses).toEqual([]);
+  });
+});
+
+describe('RegressionReporter correctness (lossy) ratchet — R0', () => {
+  let dir: string;
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function reporterWith(baseline: Baseline): RegressionReporter {
+    dir = mkdtempSync(join(tmpdir(), 'lossy-'));
+    const path = join(dir, 'baseline.json');
+    writeFileSync(path, JSON.stringify(baseline));
+    return new RegressionReporter(path);
+  }
+
+  const baseline: Baseline = {
+    timestamp: '',
+    commit: 'base',
+    languages: {
+      ja: {
+        parseSuccess: 4,
+        parseFailure: 0,
+        parseRate: 1,
+        avgConfidence: 1,
+        avgFidelity: 0.9,
+        degeneratePasses: ['was-degenerate'],
+        lossyPasses: ['was-lossy'],
+        bundleSize: undefined,
+        patterns: {
+          'was-faithful': { success: true, confidence: 1 },
+          'was-lossy': { success: true, confidence: 1 },
+          'was-degenerate': { success: true, confidence: 1 },
+          stable: { success: true, confidence: 1 },
+        },
+      },
+    },
+    bundles: {},
+  };
+
+  it('flags a faithful baseline pass that became lossy (silent command-drop)', () => {
+    const reporter = reporterWith(baseline);
+    // `was-faithful` is now lossy; `was-lossy` stays lossy (not re-flagged).
+    reporter.reportComplete(
+      results(
+        lang(
+          [pass('was-faithful'), pass('was-lossy'), pass('stable')],
+          [],
+          ['was-faithful', 'was-lossy'],
+          0.85
+        )
+      )
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newLossyPasses).toEqual(['was-faithful']);
+    expect(r.newLossyPasses).not.toContain('was-lossy'); // already lossy in baseline
+    expect(r.avgFidelityDelta).toBeCloseTo(-0.05, 5);
+    expect(r.status).toBe('regressed');
+  });
+
+  it('does not flag when lossy set is unchanged', () => {
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(
+      results(
+        lang([pass('was-faithful'), pass('was-lossy'), pass('stable')], [], ['was-lossy'], 0.9)
+      )
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newLossyPasses).toEqual([]);
+    expect(r.avgFidelityDelta).toBeCloseTo(0, 5);
+  });
+
+  it('treats faithful→lossy as improvement-neutral for an already-lossy or failing pattern', () => {
+    // A pattern lossy in baseline that becomes faithful is not a regression (and not
+    // listed); only faithful→lossy is flagged.
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(
+      results(lang([pass('was-faithful'), pass('was-lossy'), pass('stable')], [], [], 0.95))
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newLossyPasses).toEqual([]);
+  });
+
+  it('never retro-flags when the baseline has no lossy data', () => {
+    const noLossy: Baseline = structuredClone(baseline);
+    delete noLossy.languages.ja!.lossyPasses;
+    const reporter = reporterWith(noLossy);
+    reporter.reportComplete(
+      results(lang([pass('was-faithful'), pass('stable')], [], ['was-faithful', 'stable'], 0.5))
+    );
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newLossyPasses).toEqual([]);
+  });
+});
+
+describe('RegressionReporter execution ratchet — R2 (session 5)', () => {
+  // LOCK: the R2 execution ratchet flags ONLY pass→fail transitions on the
+  // curated execution subset, with the same never-retro-flag guard as the
+  // degenerate/lossy ratchets (an un-regenerated baseline carries no
+  // `executionFailures`, so nothing is flagged until one is saved). Trapped
+  // runtime errors are deliberately NOT part of the match signal — only the
+  // deterministic DOM-effect comparison is (see execution-validator.ts).
+  let dir: string;
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function reporterWith(baseline: Baseline): RegressionReporter {
+    dir = mkdtempSync(join(tmpdir(), 'execution-'));
+    const path = join(dir, 'baseline.json');
+    writeFileSync(path, JSON.stringify(baseline));
+    return new RegressionReporter(path);
+  }
+
+  function langWithExecution(
+    executionFailures: string[],
+    avgExecutionFidelity: number
+  ): LanguageResults {
+    const l = lang([pass('stable')], []);
+    l.avgExecutionFidelity = avgExecutionFidelity;
+    l.executionFailures = executionFailures;
+    return l;
+  }
+
+  const baseline: Baseline = {
+    timestamp: '',
+    commit: 'base',
+    languages: {
+      ja: {
+        parseSuccess: 1,
+        parseFailure: 0,
+        parseRate: 1,
+        avgConfidence: 1,
+        avgFidelity: 1,
+        avgExecutionFidelity: 0.8,
+        executionFailures: ['was-failing'],
+        degeneratePasses: [],
+        lossyPasses: [],
+        bundleSize: undefined,
+        patterns: { stable: { success: true, confidence: 1 } },
+      },
+    },
+    bundles: {},
+  };
+
+  it('flags a faithfully-executing baseline pattern that now diverges', () => {
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(results(langWithExecution(['was-failing', 'was-passing'], 0.7)));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newExecutionFailures).toEqual(['was-passing']);
+    // Already failing in baseline = burn-down list, not a regression.
+    expect(r.newExecutionFailures).not.toContain('was-failing');
+    expect(r.avgExecutionFidelityDelta).toBeCloseTo(-0.1, 5);
+    expect(r.status).toBe('regressed');
+  });
+
+  it('does not flag when the failure set is unchanged', () => {
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(results(langWithExecution(['was-failing'], 0.8)));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newExecutionFailures).toEqual([]);
+    expect(r.avgExecutionFidelityDelta).toBeCloseTo(0, 5);
+  });
+
+  it('never retro-flags when the baseline has no execution data', () => {
+    const noExecution: Baseline = structuredClone(baseline);
+    delete noExecution.languages.ja!.executionFailures;
+    delete noExecution.languages.ja!.avgExecutionFidelity;
+    const reporter = reporterWith(noExecution);
+    reporter.reportComplete(results(langWithExecution(['anything', 'everything'], 0.1)));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.newExecutionFailures).toEqual([]);
+    expect(r.avgExecutionFidelityDelta).toBe(0);
+  });
+
+  it('persists execution data when saving a baseline', () => {
+    const reporter = reporterWith(baseline);
+    const res = results(langWithExecution(['was-failing'], 0.8));
+    reporter.reportComplete(res);
+    reporter.saveAsBaseline(res);
+    const saved = JSON.parse(readFileSync(join(dir, 'baseline.json'), 'utf-8')) as Baseline;
+    expect(saved.languages.ja!.avgExecutionFidelity).toBeCloseTo(0.8, 5);
+    expect(saved.languages.ja!.executionFailures).toEqual(['was-failing']);
+  });
+});
+
+describe('RegressionReporter precision ratchet — R0-precision (trust floor)', () => {
+  // LOCK: avgPrecision is the phantom-command signal recall (avgFidelity) cannot
+  // see — the fraction of each parse's actions justified by the en reference. The
+  // reporter computes avgPrecisionDelta with the SAME both-sides guard as R1/R2 (an
+  // un-regenerated baseline carries no avgPrecision, so the delta is 0 and nothing
+  // retro-flags). The CLI turns a delta < -0.02 into a CI failure.
+  let dir: string;
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function reporterWith(baseline: Baseline): RegressionReporter {
+    dir = mkdtempSync(join(tmpdir(), 'precision-'));
+    const path = join(dir, 'baseline.json');
+    writeFileSync(path, JSON.stringify(baseline));
+    return new RegressionReporter(path);
+  }
+
+  function langWithPrecision(avgPrecision: number): LanguageResults {
+    const l = lang([pass('stable')], []);
+    l.avgPrecision = avgPrecision;
+    return l;
+  }
+
+  const baseline: Baseline = {
+    timestamp: '',
+    commit: 'base',
+    languages: {
+      ja: {
+        parseSuccess: 1,
+        parseFailure: 0,
+        parseRate: 1,
+        avgConfidence: 1,
+        avgFidelity: 1,
+        avgPrecision: 1,
+        degeneratePasses: [],
+        lossyPasses: [],
+        bundleSize: undefined,
+        patterns: { stable: { success: true, confidence: 1 } },
+      },
+    },
+    bundles: {},
+  };
+
+  it('reports a negative avgPrecisionDelta when precision drops (phantom commands injected)', () => {
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(results(langWithPrecision(0.9)));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.avgPrecisionDelta).toBeCloseTo(-0.1, 5);
+  });
+
+  it('reports ~0 delta when precision is unchanged', () => {
+    const reporter = reporterWith(baseline);
+    reporter.reportComplete(results(langWithPrecision(1)));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.avgPrecisionDelta).toBeCloseTo(0, 5);
+  });
+
+  it('never retro-flags when the baseline has no precision data', () => {
+    const noPrecision: Baseline = structuredClone(baseline);
+    delete noPrecision.languages.ja!.avgPrecision;
+    const reporter = reporterWith(noPrecision);
+    reporter.reportComplete(results(langWithPrecision(0.1)));
+    const r = reporter.getRegressionResults().find(x => x.language === 'ja')!;
+    expect(r.avgPrecisionDelta).toBe(0);
+  });
+
+  it('persists avgPrecision when saving a baseline', () => {
+    const reporter = reporterWith(baseline);
+    const res = results(langWithPrecision(0.95));
+    reporter.reportComplete(res);
+    reporter.saveAsBaseline(res);
+    const saved = JSON.parse(readFileSync(join(dir, 'baseline.json'), 'utf-8')) as Baseline;
+    expect(saved.languages.ja!.avgPrecision).toBeCloseTo(0.95, 5);
+  });
+});

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

@@ -111,15 +111,47 @@ export class RegressionReporter implements Reporter {
 
       const parseRateDelta = (langResult.parseRate - baselineLang.parseRate) * 100;
       const avgConfidenceDelta = langResult.avgConfidence - baselineLang.avgConfidence;
+      const avgFidelityDelta = (langResult.avgFidelity ?? 0) - (baselineLang.avgFidelity ?? 0);
+      // R0-precision — both-sides guard: an un-regenerated baseline (no
+      // avgPrecision yet) must never retro-flag.
+      const avgPrecisionDelta =
+        langResult.avgPrecision !== undefined && baselineLang.avgPrecision !== undefined
+          ? langResult.avgPrecision - baselineLang.avgPrecision
+          : 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;
+      // R2 — same both-sides guard: an un-regenerated baseline (no execution
+      // data yet) must never retro-flag.
+      const avgExecutionFidelityDelta =
+        langResult.avgExecutionFidelity !== undefined &&
+        baselineLang.avgExecutionFidelity !== undefined
+          ? langResult.avgExecutionFidelity - baselineLang.avgExecutionFidelity
+          : 0;
       const bundleSizeDelta = this.getBundleSizeDelta(langResult, baselineLang);
 
       // Identify new failures and successes
       const newFailures = this.findNewFailures(langResult, baselineLang);
       const newSuccesses = this.findNewSuccesses(langResult, baselineLang);
+      // Fidelity ratchet: faithful pass in baseline → degenerate pass now.
+      const newDegeneratePasses = this.findNewDegeneratePasses(langResult, baselineLang);
+      // Correctness ratchet (R0): faithful pass in baseline → lossy pass now.
+      const newLossyPasses = this.findNewLossyPasses(langResult, baselineLang);
+      // Execution ratchet (R2): faithful execution in baseline → divergent now.
+      const newExecutionFailures = this.findNewExecutionFailures(langResult, baselineLang);
 
       // Determine status
       let status: 'improved' | 'regressed' | 'unchanged' = 'unchanged';
-      if (parseRateDelta < -5 || newFailures.length > 0) {
+      if (
+        parseRateDelta < -5 ||
+        newFailures.length > 0 ||
+        newDegeneratePasses.length > 0 ||
+        newLossyPasses.length > 0 ||
+        newExecutionFailures.length > 0
+      ) {
         status = 'regressed';
       } else if (parseRateDelta > 5 || newSuccesses.length > 0) {
         status = 'improved';
@@ -129,9 +161,16 @@ export class RegressionReporter implements Reporter {
         language: langResult.language,
         parseRateDelta,
         avgConfidenceDelta,
+        avgFidelityDelta,
+        avgPrecisionDelta,
+        avgRoleFidelityDelta,
+        avgExecutionFidelityDelta,
         bundleSizeDelta: bundleSizeDelta !== undefined ? bundleSizeDelta : undefined,
         newFailures,
         newSuccesses,
+        newDegeneratePasses,
+        newLossyPasses,
+        newExecutionFailures,
         status,
       });
     }
@@ -200,6 +239,87 @@ export class RegressionReporter implements Reporter {
     return newSuccesses.slice(0, 10); // Limit to 10 for reporting
   }
 
+  /**
+   * Find patterns that *regressed in fidelity*: a faithful (non-degenerate) pass
+   * in the baseline that is now a degenerate pass (still parses, but lost most of
+   * the English command structure). This is the fidelity ratchet's signal.
+   *
+   * Returns [] when the baseline carries no fidelity data yet (`degeneratePasses`
+   * undefined) so adopting the signal never retro-flags the whole corpus. A
+   * pattern that went FAIL → degenerate-pass is an improvement (it now parses),
+   * not a regression, and is excluded because it wasn't a baseline pass.
+   */
+  private findNewDegeneratePasses(
+    current: LanguageResults,
+    baseline: {
+      patterns: Record<string, { success: boolean; confidence: number | undefined }> | undefined;
+      degeneratePasses?: string[] | undefined;
+    }
+  ): string[] {
+    if (!baseline.degeneratePasses || !baseline.patterns) return [];
+    const baselineDegenerate = new Set(baseline.degeneratePasses);
+    const currentDegenerate = new Set(current.degeneratePasses ?? []);
+
+    const regressed: string[] = [];
+    for (const id of currentDegenerate) {
+      const wasPass = baseline.patterns[id]?.success === true;
+      // Faithful baseline pass (passed, not already degenerate) that is now degenerate.
+      if (wasPass && !baselineDegenerate.has(id)) regressed.push(id);
+    }
+    return regressed.sort();
+  }
+
+  /**
+   * Correctness ratchet (R0): patterns that were a *faithful* pass (fidelity 1.0) in
+   * the baseline but are now a *lossy* pass (0.5 ≤ fid < 1.0 — still parses, clears the
+   * degenerate floor, but silently drops ≥1 command). This is the band the degenerate
+   * ratchet misses (it only catches drops below 0.5). "Faithful in baseline" = a pass
+   * that was neither degenerate nor lossy.
+   *
+   * Returns [] when the baseline carries no lossy data yet (`lossyPasses` undefined) so
+   * adopting the signal never retro-flags the whole corpus — same guard as the
+   * degenerate ratchet. A pattern already lossy in the baseline is not re-flagged.
+   */
+  private findNewLossyPasses(
+    current: LanguageResults,
+    baseline: {
+      patterns: Record<string, { success: boolean; confidence: number | undefined }> | undefined;
+      degeneratePasses?: string[] | undefined;
+      lossyPasses?: string[] | undefined;
+    }
+  ): string[] {
+    if (!baseline.lossyPasses || !baseline.patterns) return [];
+    const baselineDegenerate = new Set(baseline.degeneratePasses ?? []);
+    const baselineLossy = new Set(baseline.lossyPasses);
+    const currentLossy = new Set(current.lossyPasses ?? []);
+
+    const regressed: string[] = [];
+    for (const id of currentLossy) {
+      const wasPass = baseline.patterns[id]?.success === true;
+      // Faithful baseline pass = passed AND not degenerate AND not already lossy.
+      if (wasPass && !baselineDegenerate.has(id) && !baselineLossy.has(id)) regressed.push(id);
+    }
+    return regressed.sort();
+  }
+
+  /**
+   * Execution ratchet (R2): curated-subset patterns that executed faithfully in
+   * the baseline (scored, and not in its `executionFailures`) but diverge from
+   * the en reference now. Returns [] when the baseline carries no execution
+   * data yet (`executionFailures` undefined) so adopting the signal never
+   * retro-flags — same guard as the degenerate/lossy ratchets. A pattern
+   * already failing in the baseline is not re-flagged (that's the burn-down
+   * list, not a regression).
+   */
+  private findNewExecutionFailures(
+    current: LanguageResults,
+    baseline: { executionFailures?: string[] | undefined }
+  ): string[] {
+    if (!baseline.executionFailures) return [];
+    const baselineFailures = new Set(baseline.executionFailures);
+    return (current.executionFailures ?? []).filter(id => !baselineFailures.has(id)).sort();
+  }
+
   /**
    * Save current results as new baseline
    */
@@ -238,6 +358,21 @@ export class RegressionReporter implements Reporter {
         parseFailure: langResult.parseFailure,
         parseRate: langResult.parseRate,
         avgConfidence: langResult.avgConfidence,
+        // Structural fidelity vs the English reference parse — tracks degenerate
+        // (non-null but shallow) passes that the parse rate alone can't surface.
+        avgFidelity: langResult.avgFidelity ?? undefined,
+        // 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,
+        // 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,
+        // R2 — execution fidelity over the curated subset (DOM effects vs the
+        // en reference in jsdom). Recorded + ratcheted; burn-down deferred.
+        avgExecutionFidelity: langResult.avgExecutionFidelity ?? undefined,
+        executionFailures: langResult.executionFailures ?? undefined,
+        degeneratePasses: langResult.degeneratePasses ?? undefined,
+        lossyPasses: langResult.lossyPasses ?? undefined,
         bundleSize: langResult.bundleSize ?? undefined,
         patterns,
       };