observability-toolkit 2.0.0 → 2.1.0

package/dist/lib/quality/quality-feature-engineering.test.js

@@ -0,0 +1,2908 @@
+/**
+ * Tests for Feature Engineering (Design Doc Section 16)
+ */
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import * as assert from 'node:assert';
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { scoreColorBand, adaptiveScoreColorBand, empiricalCDF, inferScoreDirection, labelToOrdinal, ordinalToCategory, computeCQI, computeCQISensitivity, computeMetricDynamics, computeCoverageWeightedConfidence, computeNormalizedEntropy, computeDegradationSignal, computeEWMA, computeMAD, detectEWMADrift, VARIANCE_INCREASE_THRESHOLD, computePearsonR, computeSpearmanR, computeCorrelationMatrix, computeGrangerCausality, pearsonPValue, benjaminiHochberg, injectDegradationScenario, METRIC_SCALE_STRATEGY, computePercentileDistribution, computePercentileRank, StreamingPercentile, computeDerivedFeatures, computeStdDev, computeRollingDegradationSignals, loadDegradationState, saveDegradationState, computePSI, computeCalibrationDistributions, loadCalibrationState, saveCalibrationState, shouldRecalibrate, MIN_QUANTILE_SAMPLE_SIZE, computeAHPWeights, computeCRITICWeights, computeHybridCQIWeights, tunedCQIWeightsSchema, computeTaPR, backtestDegradationConfig, sweepDegradationParams, sweepWithCrossValidation, BACKTEST_SWEEP, CURRENT_PRODUCTION_CONFIG, } from './quality-feature-engineering.js';
+import { TEST_CORE_METRIC_COUNT, TEST_DECIMAL_EPSILON, TEST_LABEL_PASS_ORDINAL, TEST_SCORE_ADEQUATE, TEST_SCORE_BASELINE, TEST_SCORE_BORDERLINE, TEST_SCORE_EXCELLENT, TEST_SCORE_GOOD, TEST_SCORE_HIGH, TEST_SCORE_LOW, TEST_SCORE_MID, TEST_SCORE_POOR, TEST_SCORE_PASSING, TEST_SCORE_STRONG, TEST_SCORE_VERY_LOW, TEST_SCORE_WARNING, } from './quality-test-constants.js';
+import { SCORE_BAND_ADEQUATE, MAD_CONSISTENCY_FACTOR, SCORE_BAND_POOR, PSI_RECALIBRATION_THRESHOLD, LATENCY_SKEW_SIGNAL_THRESHOLD, } from './quality-constants.js';
+import { COUNT_EIGHT, COUNT_FIFTEEN, COUNT_FIFTY, COUNT_FIVE, COUNT_FORTY, COUNT_FOUR, COUNT_FOURTEEN, COUNT_HUNDRED, COUNT_NINE, COUNT_SEVEN, COUNT_SIX, COUNT_SIXTY, COUNT_TEN, COUNT_THREE, COUNT_THIRTY, COUNT_THOUSAND, COUNT_TWENTY, COUNT_TWENTY_FIVE, COUNT_TWO, DELTA, } from '../../test-helpers/test-constants.js';
+import { requireDefined } from '../../test-helpers/assertions.js';
+const TEST_MINIMIZE_GOOD_INPUT = 0.15;
+const TEST_MINIMIZE_ADEQUATE_INPUT = 0.35;
+const TEST_MINIMIZE_POOR_INPUT = 0.55;
+const TEST_MAXIMIZE_FAILING_INPUT = 0.39;
+const TEST_CDF_ABOVE_P90_INPUT = 0.98;
+const TEST_CDF_INTERPOLATION_INPUT = 0.75;
+const TEST_CDF_INTERPOLATION_MIN = 0.25;
+const TEST_VERY_LOW_HALLUCINATION = 0.001;
+const TEST_CQI_WEIGHT_RELEVANCE = 0.25;
+const TEST_CQI_WEIGHT_COHERENCE = 0.10;
+const TEST_CQI_WEIGHT_SUM = 0.35;
+const TEST_TASK_COMPLETION_STRONG_SCORE = 0.88;
+const TEST_CQI_CONTRIBUTION_TOLERANCE = 0.02;
+const TEST_CQI_CUSTOM_DELTA = 0.10;
+const TEST_MIN_PERIOD_HOURS_BELOW_THRESHOLD = 0.001;
+const TEST_SINGLE_TREND_CONFIDENCE = 0.275;
+const TEST_DUAL_TREND_CONFIDENCE = 0.35;
+const TEST_ENTROPY_DOMINANT_PRIMARY = 70;
+const TEST_ENTROPY_NEAR_UNIFORM_MIN = 0.99;
+const TEST_CONCENTRATED_COVERAGE_PRIMARY = 95;
+const TEST_STABLE_SERIES_HIGH = 0.81;
+const TEST_STABLE_SERIES_LOW = 0.79;
+const TEST_STABLE_SERIES_HIGHER = 0.82;
+const TEST_VARIANCE_STABLE_INPUT = 0.09;
+const TEST_VARIANCE_INCREASING_INPUT = 0.125;
+const TEST_VARIANCE_DECREASING_INPUT = 0.02;
+const TEST_LATENCY_P95 = 10.0;
+const TEST_LATENCY_P50 = 2.0;
+const TEST_PEARSON_NEAR_PERFECT = 0.999;
+const TEST_PVALUE_STRICT = 0.001;
+const TEST_PEARSON_CASE_ONE_R = 0.6033;
+const TEST_PEARSON_CASE_ONE_P = 0.0649;
+const TEST_PEARSON_CASE_TWO_P = 0.0247;
+const TEST_PEARSON_CASE_THREE_P = 0.1082;
+const TEST_PEARSON_CASE_FOUR_P = 0.0056;
+const TEST_PEARSON_COMPARISON_TOLERANCE = 0.002;
+const TEST_PVALUE_CASE_MID = 0.002;
+const TEST_PVALUE_CASE_HIGH = 0.003;
+const TEST_SEQUENCE_TWELVE = 12;
+const TEST_SEQUENCE_SIXTEEN = 16;
+const TEST_SEQUENCE_EIGHTEEN = 18;
+const TEST_PERCENTILE_DIVISOR_MAX_INDEX = 99;
+const TEST_STREAMING_MONOTONIC_SAMPLE_SIZE = 500;
+const TEST_VARIANCE_SPIKE_MULTIPLIER = 3.0;
+const TEST_ABSOLUTE_EPSILON = 1e-10;
+const TEST_STD_DEV_REFERENCE_HIGH = 2.1381;
+const TEST_STD_DEV_REFERENCE_LOW = 0.7071;
+const TEST_YEAR_2026 = 2026;
+// ============================================================================
+// Helper Factories
+// ============================================================================
+function makeMetricResult(overrides) {
+    return {
+        displayName: overrides.name,
+        values: {
+            avg: TEST_SCORE_STRONG,
+            p50: 0.84,
+            p95: TEST_SCORE_PASSING,
+            p99: null,
+            min: TEST_SCORE_BASELINE,
+            max: TEST_SCORE_EXCELLENT,
+            count: COUNT_HUNDRED,
+        },
+        sampleCount: COUNT_HUNDRED,
+        alerts: [],
+        status: 'healthy',
+        ...overrides,
+    };
+}
+function makeTrend(overrides) {
+    return {
+        direction: 'stable',
+        delta: 0,
+        percentChange: 0,
+        previousValue: TEST_SCORE_STRONG,
+        currentValue: TEST_SCORE_STRONG,
+        aggregation: 'avg',
+        ...overrides,
+    };
+}
+// ============================================================================
+// Score Color Band Tests
+// ============================================================================
+describe('quality-feature-engineering', () => {
+    describe('scoreColorBand', () => {
+        it('returns correct bands for maximize direction', () => {
+            assert.strictEqual(scoreColorBand(TEST_SCORE_EXCELLENT, 'maximize'), 'excellent');
+            assert.strictEqual(scoreColorBand(TEST_SCORE_STRONG, 'maximize'), 'good');
+            assert.strictEqual(scoreColorBand(TEST_SCORE_ADEQUATE, 'maximize'), 'adequate');
+            assert.strictEqual(scoreColorBand(TEST_SCORE_BORDERLINE, 'maximize'), 'poor');
+            assert.strictEqual(scoreColorBand(TEST_SCORE_MID - TEST_SCORE_LOW, 'maximize'), 'failing');
+        });
+        it('returns inverted bands for minimize direction', () => {
+            assert.strictEqual(scoreColorBand(DELTA, 'minimize'), 'excellent');
+            assert.strictEqual(scoreColorBand(TEST_MINIMIZE_GOOD_INPUT, 'minimize'), 'good');
+            assert.strictEqual(scoreColorBand(TEST_MINIMIZE_ADEQUATE_INPUT, 'minimize'), 'adequate');
+            assert.strictEqual(scoreColorBand(TEST_MINIMIZE_POOR_INPUT, 'minimize'), 'poor');
+            assert.strictEqual(scoreColorBand(TEST_SCORE_GOOD, 'minimize'), 'failing');
+        });
+        it('defaults to maximize direction', () => {
+            assert.strictEqual(scoreColorBand(TEST_SCORE_EXCELLENT), 'excellent');
+        });
+        it('handles boundary values (>=)', () => {
+            assert.strictEqual(scoreColorBand(TEST_SCORE_HIGH, 'maximize'), 'excellent');
+            assert.strictEqual(scoreColorBand(TEST_SCORE_GOOD, 'maximize'), 'good');
+            assert.strictEqual(scoreColorBand(SCORE_BAND_ADEQUATE, 'maximize'), 'adequate');
+            assert.strictEqual(scoreColorBand(SCORE_BAND_POOR, 'maximize'), 'poor');
+            assert.strictEqual(scoreColorBand(TEST_MAXIMIZE_FAILING_INPUT, 'maximize'), 'failing');
+        });
+    });
+    describe('empiricalCDF', () => {
+        const dist = {
+            p10: TEST_SCORE_BASELINE, p25: TEST_SCORE_PASSING, p50: TEST_SCORE_GOOD, p75: TEST_SCORE_STRONG, p90: TEST_SCORE_EXCELLENT,
+        };
+        it('returns 0.5 for p50 value', () => {
+            assert.strictEqual(empiricalCDF(TEST_SCORE_GOOD, dist), TEST_SCORE_MID);
+        });
+        it('returns ~0.1 for p10 value', () => {
+            assert.ok(Math.abs(empiricalCDF(TEST_SCORE_BASELINE, dist) - TEST_SCORE_WARNING) < TEST_DECIMAL_EPSILON);
+        });
+        it('returns ~0.9 for p90 value', () => {
+            assert.ok(Math.abs(empiricalCDF(TEST_SCORE_EXCELLENT, dist) - TEST_SCORE_HIGH) < TEST_DECIMAL_EPSILON);
+        });
+        it('returns value < 0.1 for below p10', () => {
+            const result = empiricalCDF(TEST_SCORE_LOW, dist);
+            assert.ok(result < TEST_SCORE_WARNING, `Expected < ${TEST_SCORE_WARNING}, got ${result}`);
+            assert.ok(result >= 0, `Expected >= 0, got ${result}`);
+        });
+        it('returns value > 0.9 for above p90', () => {
+            const result = empiricalCDF(TEST_CDF_ABOVE_P90_INPUT, dist);
+            assert.ok(result > TEST_SCORE_HIGH, `Expected > ${TEST_SCORE_HIGH}, got ${result}`);
+            assert.ok(result <= 1, `Expected <= 1, got ${result}`);
+        });
+        it('interpolates between percentile points', () => {
+            const result = empiricalCDF(TEST_CDF_INTERPOLATION_INPUT, dist); // Between p25 (0.7) and p50 (0.8)
+            assert.ok(result > TEST_CDF_INTERPOLATION_MIN && result < TEST_SCORE_MID, `Expected between 0.25 and 0.5, got ${result}`);
+        });
+        it('handles negative values by clamping to >= 0', () => {
+            const result = empiricalCDF(-TEST_SCORE_WARNING, dist);
+            assert.ok(result >= 0, `Expected >= 0, got ${result}`);
+            assert.ok(result < TEST_SCORE_WARNING, `Expected < ${TEST_SCORE_WARNING}, got ${result}`);
+        });
+        it('returns 0.5 for NaN input', () => {
+            assert.strictEqual(empiricalCDF(NaN, dist), TEST_SCORE_MID);
+        });
+        it('returns 0.5 for Infinity input', () => {
+            assert.strictEqual(empiricalCDF(Infinity, dist), TEST_SCORE_MID);
+            assert.strictEqual(empiricalCDF(-Infinity, dist), TEST_SCORE_MID);
+        });
+    });
+    describe('adaptiveScoreColorBand', () => {
+        it('uses uniform strategy for unknown metrics', () => {
+            assert.strictEqual(adaptiveScoreColorBand(TEST_SCORE_EXCELLENT, 'unknown_metric'), 'excellent');
+        });
+        it('uses binary strategy for faithfulness', () => {
+            assert.strictEqual(adaptiveScoreColorBand(TEST_CDF_INTERPOLATION_INPUT, 'faithfulness'), 'excellent');
+            assert.strictEqual(adaptiveScoreColorBand(TEST_SCORE_ADEQUATE, 'faithfulness'), 'failing');
+        });
+        it('uses log strategy for hallucination', () => {
+            // Very low hallucination (0.001) -> logNorm = -log10(0.001)/3 = 1.0 -> excellent
+            assert.strictEqual(adaptiveScoreColorBand(TEST_VERY_LOW_HALLUCINATION, 'hallucination'), 'excellent');
+            // Low hallucination (0.01) -> logNorm = -log10(0.01)/3 = 0.667 -> adequate
+            assert.strictEqual(adaptiveScoreColorBand(TEST_DECIMAL_EPSILON, 'hallucination'), 'adequate');
+            // High hallucination (0.5) -> logNorm = -log10(0.5)/3 = 0.1 -> failing
+            assert.strictEqual(adaptiveScoreColorBand(TEST_SCORE_MID, 'hallucination'), 'failing');
+        });
+        it('uses step strategy for task_completion', () => {
+            assert.strictEqual(adaptiveScoreColorBand(TEST_SCORE_HIGH, 'task_completion'), 'excellent');
+            assert.strictEqual(adaptiveScoreColorBand(SCORE_BAND_ADEQUATE, 'task_completion'), 'adequate');
+            assert.strictEqual(adaptiveScoreColorBand(TEST_SCORE_LOW, 'task_completion'), 'failing');
+        });
+        it('uses quantile strategy with distribution for relevance', () => {
+            const dist = {
+                p10: TEST_SCORE_BASELINE,
+                p25: TEST_SCORE_PASSING,
+                p50: TEST_SCORE_GOOD,
+                p75: TEST_SCORE_STRONG,
+                p90: TEST_SCORE_EXCELLENT,
+            };
+            const band = adaptiveScoreColorBand(TEST_SCORE_GOOD, 'relevance', 'maximize', dist);
+            // 0.8 is at p50, so rank = 0.5 -> 'poor' in uniform but wait...
+            // Actually rank 0.5 maps to: v=0.5, >= 0.4 -> 'poor'
+            // This is expected -- in a left-skewed distribution, p50 is not great
+            assert.ok(['poor', 'adequate'].includes(band));
+        });
+        it('falls back to uniform when no distribution for quantile metrics', () => {
+            assert.strictEqual(adaptiveScoreColorBand(TEST_SCORE_EXCELLENT, 'relevance'), 'excellent');
+        });
+    });
+    describe('inferScoreDirection', () => {
+        it('returns minimize for above threshold direction', () => {
+            assert.strictEqual(inferScoreDirection('above'), 'minimize');
+        });
+        it('returns maximize for below threshold direction', () => {
+            assert.strictEqual(inferScoreDirection('below'), 'maximize');
+        });
+        it('defaults to maximize for undefined', () => {
+            assert.strictEqual(inferScoreDirection(undefined), 'maximize');
+        });
+    });
+    // ============================================================================
+    // Label Ordinal Encoding Tests
+    // ============================================================================
+    describe('labelToOrdinal', () => {
+        it('maps excellent labels to ordinal 4 (Pass)', () => {
+            const result = labelToOrdinal('excellent');
+            assert.strictEqual(result.ordinal, TEST_LABEL_PASS_ORDINAL);
+            assert.strictEqual(result.category, 'Pass');
+            assert.strictEqual(result.mapped, true);
+        });
+        it('maps good labels to ordinal 3 (Pass)', () => {
+            assert.strictEqual(labelToOrdinal('relevant').ordinal, COUNT_THREE);
+            assert.strictEqual(labelToOrdinal('good').ordinal, COUNT_THREE);
+            assert.strictEqual(labelToOrdinal('pass').ordinal, COUNT_THREE);
+        });
+        it('maps review labels to ordinal 2 (Review)', () => {
+            assert.strictEqual(labelToOrdinal('partial').ordinal, COUNT_TWO);
+            assert.strictEqual(labelToOrdinal('borderline').category, 'Review');
+        });
+        it('maps fail labels to ordinal 1 (Fail)', () => {
+            assert.strictEqual(labelToOrdinal('off_topic').ordinal, 1);
+            assert.strictEqual(labelToOrdinal('irrelevant').category, 'Fail');
+        });
+        it('maps critical fail labels to ordinal 0 (Fail)', () => {
+            assert.strictEqual(labelToOrdinal('hallucinated').ordinal, 0);
+            assert.strictEqual(labelToOrdinal('toxic').category, 'Fail');
+        });
+        it('normalizes hyphens to underscores', () => {
+            const result = labelToOrdinal('highly-relevant');
+            assert.strictEqual(result.ordinal, TEST_LABEL_PASS_ORDINAL);
+            assert.strictEqual(result.mapped, true);
+        });
+        it('normalizes case', () => {
+            assert.strictEqual(labelToOrdinal('EXCELLENT').ordinal, TEST_LABEL_PASS_ORDINAL);
+            assert.strictEqual(labelToOrdinal('Partial').ordinal, COUNT_TWO);
+        });
+        it('returns ordinal 2 (Review) for unmapped labels with mapped=false', () => {
+            const result = labelToOrdinal('custom_label_xyz');
+            assert.strictEqual(result.ordinal, COUNT_TWO);
+            assert.strictEqual(result.category, 'Review');
+            assert.strictEqual(result.mapped, false);
+        });
+        it('handles whitespace in labels', () => {
+            const result = labelToOrdinal('  excellent  ');
+            assert.strictEqual(result.ordinal, TEST_LABEL_PASS_ORDINAL);
+            assert.strictEqual(result.mapped, true);
+        });
+    });
+    describe('ordinalToCategory', () => {
+        it('maps ordinals to correct categories', () => {
+            assert.strictEqual(ordinalToCategory(TEST_LABEL_PASS_ORDINAL), 'Pass');
+            assert.strictEqual(ordinalToCategory(COUNT_THREE), 'Pass');
+            assert.strictEqual(ordinalToCategory(COUNT_TWO), 'Review');
+            assert.strictEqual(ordinalToCategory(1), 'Fail');
+            assert.strictEqual(ordinalToCategory(0), 'Fail');
+        });
+    });
+    // ============================================================================
+    // Composite Quality Index Tests
+    // ============================================================================
+    describe('computeCQI', () => {
+        it('computes weighted composite from all 7 metrics', () => {
+            const metrics = [
+                makeMetricResult({ name: 'relevance', values: { avg: TEST_SCORE_STRONG, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({ name: 'faithfulness', values: { avg: TEST_SCORE_HIGH, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({
+                    name: 'hallucination',
+                    values: { avg: DELTA, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED },
+                    alerts: [{ severity: 'warning', message: '', aggregation: 'avg', threshold: TEST_SCORE_WARNING, actualValue: DELTA, direction: 'above' }],
+                }),
+                makeMetricResult({ name: 'task_completion', values: { avg: TEST_TASK_COMPLETION_STRONG_SCORE, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({ name: 'coherence', values: { avg: 0.82, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({ name: 'tool_correctness', values: { avg: TEST_SCORE_EXCELLENT, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({
+                    name: 'evaluation_latency',
+                    values: { avg: 2.5, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED },
+                    alerts: [{ severity: 'warning', message: '', aggregation: 'p95', threshold: COUNT_FIVE, actualValue: 2.5, direction: 'above' }],
+                }),
+            ];
+            const cqi = computeCQI(metrics);
+            assert.ok(cqi !== undefined);
+            assert.strictEqual(requireDefined(cqi).featureVersion, '1.0');
+            assert.ok(requireDefined(cqi).value >= 0 && requireDefined(cqi).value <= 1);
+            assert.strictEqual(requireDefined(cqi).contributions.length, TEST_CORE_METRIC_COUNT);
+            // Hallucination should be inverted (0.05 -> 0.95 normalized)
+            const hallContrib = requireDefined(cqi).contributions.find(c => c.metric === 'hallucination');
+            assert.ok(requireDefined(hallContrib).normalizedScore > TEST_SCORE_HIGH, `Expected hallucination normalized > 0.9, got ${requireDefined(hallContrib).normalizedScore}`);
+        });
+        it('returns undefined when no metrics have data', () => {
+            const metrics = [
+                makeMetricResult({ name: 'relevance', values: { avg: null, p50: null, p95: null, p99: null, min: null, max: null, count: 0 } }),
+            ];
+            assert.strictEqual(computeCQI(metrics), undefined);
+        });
+        it('renormalizes weights when some metrics are missing', () => {
+            const metrics = [
+                makeMetricResult({ name: 'relevance', values: { avg: TEST_SCORE_HIGH, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({ name: 'coherence', values: { avg: TEST_SCORE_GOOD, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            ];
+            const cqi = computeCQI(metrics);
+            assert.ok(cqi !== undefined);
+            assert.strictEqual(requireDefined(cqi).contributions.length, COUNT_TWO);
+            // With only relevance (0.25 weight) and coherence (0.10 weight),
+            // totalWeight = 0.35, value = (0.9*0.25 + 0.8*0.10) / 0.35
+            const expected = (TEST_SCORE_HIGH * TEST_CQI_WEIGHT_RELEVANCE + TEST_SCORE_GOOD * TEST_CQI_WEIGHT_COHERENCE) / TEST_CQI_WEIGHT_SUM;
+            assert.ok(Math.abs(requireDefined(cqi).value - expected) < TEST_DECIMAL_EPSILON);
+        });
+        it('accepts custom weights', () => {
+            const metrics = [
+                makeMetricResult({ name: 'relevance', values: { avg: 1.0, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_FIFTY } }),
+            ];
+            const cqi = computeCQI(metrics, { relevance: 1.0 });
+            assert.ok(cqi !== undefined);
+            assert.ok(Math.abs(requireDefined(cqi).value - 1.0) < TEST_DECIMAL_EPSILON);
+        });
+        it('returns undefined when all weights are zero (ER22)', () => {
+            const metrics = [
+                makeMetricResult({ name: 'relevance', values: { avg: TEST_SCORE_HIGH, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            ];
+            assert.strictEqual(computeCQI(metrics, { relevance: 0 }), undefined);
+        });
+        it('contributions sum to value after renormalization (ER11)', () => {
+            const metrics = [
+                makeMetricResult({ name: 'relevance', values: { avg: TEST_SCORE_STRONG, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+                makeMetricResult({ name: 'coherence', values: { avg: 0.80, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            ];
+            const cqi = computeCQI(metrics);
+            assert.ok(cqi !== undefined);
+            const contribSum = requireDefined(cqi).contributions.reduce((s, c) => s + c.contribution, 0);
+            assert.ok(Math.abs(contribSum - requireDefined(cqi).value) < TEST_CQI_CONTRIBUTION_TOLERANCE, `contributions sum ${contribSum} should approximate value ${requireDefined(cqi).value}`);
+        });
+    });
+    // ============================================================================
+    // CQI Sensitivity Tests
+    // ============================================================================
+    describe('computeCQISensitivity', () => {
+        const baseMetrics = [
+            makeMetricResult({ name: 'relevance', values: { avg: 0.90, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            makeMetricResult({ name: 'faithfulness', values: { avg: TEST_SCORE_STRONG, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            makeMetricResult({ name: 'coherence', values: { avg: 0.80, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+        ];
+        it('reports range for each weight when perturbed +/- 0.05', () => {
+            const sens = computeCQISensitivity(baseMetrics);
+            assert.ok(sens !== undefined);
+            assert.ok(requireDefined(sens).baseValue > 0);
+            assert.strictEqual(requireDefined(sens).delta, DELTA);
+            // Only metrics present in both data and weights should appear
+            const metricNames = requireDefined(sens).entries.map(e => e.metric);
+            assert.ok(metricNames.includes('relevance'));
+            assert.ok(metricNames.includes('coherence'));
+        });
+        it('entries are sorted by range descending', () => {
+            const sens = computeCQISensitivity(baseMetrics);
+            assert.ok(sens !== undefined);
+            for (let i = 1; i < requireDefined(sens).entries.length; i++) {
+                assert.ok(requireDefined(sens).entries[i - 1].range >= requireDefined(sens).entries[i].range, `Entry ${i - 1} range (${requireDefined(sens).entries[i - 1].range}) should be >= entry ${i} range (${requireDefined(sens).entries[i].range})`);
+            }
+        });
+        it('returns undefined when no metrics have data', () => {
+            const empty = [
+                makeMetricResult({ name: 'relevance', values: { avg: null, p50: null, p95: null, p99: null, min: null, max: null, count: 0 } }),
+            ];
+            assert.strictEqual(computeCQISensitivity(empty), undefined);
+        });
+        it('accepts custom delta', () => {
+            const sens = computeCQISensitivity(baseMetrics, undefined, TEST_CQI_CUSTOM_DELTA);
+            assert.ok(sens !== undefined);
+            assert.strictEqual(requireDefined(sens).delta, TEST_CQI_CUSTOM_DELTA);
+            // Larger delta should produce wider ranges than default
+            const sensSmall = computeCQISensitivity(baseMetrics, undefined, TEST_DECIMAL_EPSILON);
+            assert.ok(sensSmall !== undefined);
+            const maxRangeLarge = Math.max(...requireDefined(sens).entries.map(e => e.range));
+            const maxRangeSmall = Math.max(...requireDefined(sensSmall).entries.map(e => e.range));
+            assert.ok(maxRangeLarge >= maxRangeSmall);
+        });
+        it('low <= baseValue <= high for each entry', () => {
+            const sens = computeCQISensitivity(baseMetrics);
+            assert.ok(sens !== undefined);
+            for (const entry of requireDefined(sens).entries) {
+                assert.ok(entry.low <= requireDefined(sens).baseValue + TEST_DECIMAL_EPSILON, `${entry.metric}: low (${entry.low}) should be <= baseValue (${requireDefined(sens).baseValue})`);
+                assert.ok(entry.high >= requireDefined(sens).baseValue - TEST_DECIMAL_EPSILON, `${entry.metric}: high (${entry.high}) should be >= baseValue (${requireDefined(sens).baseValue})`);
+            }
+        });
+        it('filters out metrics with zero or negative weights (pipe implementation)', () => {
+            const customWeights = {
+                relevance: 0.3,
+                faithfulness: 0, // filtered out
+                coherence: 0.5,
+                completeness: -0.05, // filtered out
+            };
+            const sens = computeCQISensitivity(baseMetrics, customWeights);
+            assert.ok(sens !== undefined);
+            const metricNames = requireDefined(sens).entries.map(e => e.metric);
+            assert.ok(metricNames.includes('relevance'), 'positive weights should be included');
+            assert.ok(metricNames.includes('coherence'), 'positive weights should be included');
+            assert.strictEqual(metricNames.includes('faithfulness'), false, 'zero weights should be filtered');
+            assert.strictEqual(metricNames.includes('completeness'), false, 'negative weights should be filtered');
+        });
+        it('maintains consistent ordering across multiple calls (sort stability)', () => {
+            const sens1 = computeCQISensitivity(baseMetrics);
+            const sens2 = computeCQISensitivity(baseMetrics);
+            assert.ok(sens1 !== undefined && sens2 !== undefined);
+            const entries1 = requireDefined(sens1).entries;
+            const entries2 = requireDefined(sens2).entries;
+            assert.strictEqual(entries1.length, entries2.length, 'entry counts should match');
+            for (let i = 0; i < entries1.length; i++) {
+                assert.strictEqual(entries1[i].metric, entries2[i].metric, `Entry ${i} metric should be consistent across calls`);
+                assert.strictEqual(entries1[i].range, entries2[i].range, `Entry ${i} range should be consistent across calls`);
+            }
+        });
+        it('range is always non-negative (absolute value in pipe)', () => {
+            const sens = computeCQISensitivity(baseMetrics);
+            assert.ok(sens !== undefined);
+            for (const entry of requireDefined(sens).entries) {
+                assert.ok(entry.range >= 0, `${entry.metric}: range (${entry.range}) should be non-negative`);
+            }
+        });
+    });
+    // ============================================================================
+    // Metric Dynamics Tests
+    // ============================================================================
+    describe('computeMetricDynamics', () => {
+        it('computes velocity from trend delta and period', () => {
+            const trend = makeTrend({ delta: TEST_SCORE_WARNING, currentValue: TEST_SCORE_STRONG });
+            const result = computeMetricDynamics(trend, undefined, COUNT_TWO);
+            assert.ok(result !== undefined);
+            assert.strictEqual(requireDefined(result).velocity, DELTA); // 0.1 / 2hrs
+            assert.strictEqual(requireDefined(result).acceleration, 0);
+            assert.strictEqual(requireDefined(result).inflectionDetected, false);
+        });
+        it('computes acceleration from two trends', () => {
+            const currentTrend = makeTrend({ delta: TEST_SCORE_VERY_LOW, currentValue: TEST_SCORE_STRONG });
+            const previousTrend = makeTrend({ delta: TEST_SCORE_WARNING, previousValue: TEST_SCORE_ADEQUATE, currentValue: 0.75 });
+            const result = computeMetricDynamics(currentTrend, previousTrend, 1);
+            assert.ok(result !== undefined);
+            assert.strictEqual(requireDefined(result).velocity, TEST_SCORE_VERY_LOW);
+            assert.strictEqual(requireDefined(result).acceleration, TEST_SCORE_WARNING); // (0.2 - 0.1) / 1hr
+        });
+        it('detects inflection point when velocity changes sign', () => {
+            const currentTrend = makeTrend({ delta: -DELTA, currentValue: TEST_SCORE_STRONG });
+            const previousTrend = makeTrend({ delta: TEST_SCORE_WARNING, currentValue: 0.90 });
+            const result = computeMetricDynamics(currentTrend, previousTrend, 1);
+            assert.ok(result !== undefined);
+            assert.strictEqual(requireDefined(result).inflectionDetected, true);
+        });
+        it('projects breach time for degrading metric', () => {
+            const trend = makeTrend({ delta: -TEST_SCORE_WARNING, currentValue: 0.75 });
+            const thresholds = [
+                { value: TEST_SCORE_PASSING, direction: 'below', severity: 'warning' },
+                { value: TEST_SCORE_MID, direction: 'below', severity: 'critical' },
+            ];
+            const result = computeMetricDynamics(trend, undefined, 1, thresholds);
+            assert.ok(result !== undefined);
+            assert.strictEqual(requireDefined(result).projectedStatus, 'warning');
+            assert.ok(requireDefined(result).projectedBreachTime !== undefined);
+        });
+        it('returns undefined for zero period hours', () => {
+            const trend = makeTrend();
+            assert.strictEqual(computeMetricDynamics(trend, undefined, 0), undefined);
+        });
+        it('returns undefined for sub-minimum period hours', () => {
+            const trend = makeTrend();
+            assert.strictEqual(computeMetricDynamics(trend, undefined, TEST_MIN_PERIOD_HOURS_BELOW_THRESHOLD), undefined);
+        });
+        it('includes confidence field based on data points', () => {
+            const trend = makeTrend({ delta: TEST_SCORE_WARNING, currentValue: TEST_SCORE_STRONG });
+            const single = computeMetricDynamics(trend, undefined, 1);
+            assert.ok(single !== undefined);
+            assert.strictEqual(requireDefined(single).confidence, TEST_SINGLE_TREND_CONFIDENCE); // 0.2 + 0.075 * 1
+            const previous = makeTrend({ delta: DELTA, currentValue: 0.80 });
+            const dual = computeMetricDynamics(trend, previous, 1);
+            assert.ok(dual !== undefined);
+            assert.strictEqual(requireDefined(dual).confidence, TEST_DUAL_TREND_CONFIDENCE); // 0.2 + 0.075 * 2
+        });
+        it('applies exponential smoothing when trendHistory provided', () => {
+            // 5 trends with noisy deltas
+            const history = [
+                makeTrend({ delta: 0.10 }),
+                makeTrend({ delta: -DELTA }),
+                makeTrend({ delta: 0.08 }),
+                makeTrend({ delta: -0.02 }),
+                makeTrend({ delta: 0.06 }),
+            ];
+            const current = history[history.length - 1];
+            const result = computeMetricDynamics(current, undefined, 1, undefined, history);
+            assert.ok(result !== undefined);
+            // EMA smoothing should produce less volatile velocity than raw 0.06
+            assert.ok(typeof requireDefined(result).velocity === 'number');
+            assert.ok(requireDefined(result).confidence > TEST_SCORE_MID); // 5 data points → 0.2 + 0.075*5 = 0.575
+        });
+        it('caps confidence at 0.95 for large history', () => {
+            const history = Array.from({ length: COUNT_FIFTEEN }, (_, i) => makeTrend({ delta: TEST_DECIMAL_EPSILON * (i + 1) }));
+            const result = computeMetricDynamics(history[14], undefined, 1, undefined, history);
+            assert.ok(result !== undefined);
+            assert.strictEqual(requireDefined(result).confidence, TEST_SCORE_EXCELLENT);
+        });
+        it('detects inflection from smoothed velocity series', () => {
+            // Positive then negative deltas
+            const history = [
+                makeTrend({ delta: TEST_SCORE_WARNING }),
+                makeTrend({ delta: 0.08 }),
+                makeTrend({ delta: 0.02 }),
+                makeTrend({ delta: -DELTA }),
+                makeTrend({ delta: -TEST_SCORE_WARNING }),
+            ];
+            const result = computeMetricDynamics(history[COUNT_FOUR], undefined, 1, undefined, history);
+            assert.ok(result !== undefined);
+            // Smoothed velocity should eventually become negative → inflection possible
+            assert.ok(requireDefined(result).velocity < DELTA); // Smoothed toward negative
+        });
+    });
+    // ============================================================================
+    // Coverage-Weighted Confidence Tests
+    // ============================================================================
+    describe('computeNormalizedEntropy', () => {
+        it('returns 1 for perfectly uniform distribution', () => {
+            const result = computeNormalizedEntropy([COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN]);
+            assert.ok(Math.abs(result - 1) < TEST_DECIMAL_EPSILON, `Expected ~1, got ${result}`);
+        });
+        it('returns low value for concentrated distribution', () => {
+            const result = computeNormalizedEntropy([COUNT_HUNDRED, 0, 0, 0]);
+            assert.strictEqual(result, 0);
+        });
+        it('returns 1 for single element', () => {
+            assert.strictEqual(computeNormalizedEntropy([COUNT_FIFTY]), 1);
+        });
+        it('returns 1 for empty array (vacuously uniform)', () => {
+            assert.strictEqual(computeNormalizedEntropy([]), 1);
+        });
+        it('returns 0 for all zeros', () => {
+            assert.strictEqual(computeNormalizedEntropy([0, 0, 0]), 0);
+        });
+        it('sharply detects zero categories', () => {
+            // Single active category: entropy = 0
+            const entropyOne = computeNormalizedEntropy([COUNT_HUNDRED, 0, 0, 0, 0, 0, 0]);
+            assert.strictEqual(entropyOne, 0, 'Entropy should be 0 for single active category');
+            // Two active categories: both low but below 0.4
+            const entropyTwo = computeNormalizedEntropy([COUNT_FIFTY, COUNT_FIFTY, 0, 0, 0, 0, 0]);
+            assert.ok(entropyTwo < TEST_SCORE_POOR, `Expected entropy < 0.4, got ${entropyTwo}`);
+        });
+        it('discriminates bimodal from dominant distributions', () => {
+            const bimodal = computeNormalizedEntropy([COUNT_FIFTY, COUNT_FIFTY, 0, 0, 0, 0, 0]);
+            const dominant = computeNormalizedEntropy([TEST_ENTROPY_DOMINANT_PRIMARY, COUNT_FIVE, COUNT_FIVE, COUNT_FIVE, COUNT_FIVE, COUNT_FIVE, COUNT_FIVE]);
+            // Dominant has more categories active -> higher entropy
+            assert.ok(dominant > bimodal, `Expected dominant (${dominant}) > bimodal (${bimodal})`);
+        });
+        it('near-uniform distribution returns close to 1', () => {
+            const result = computeNormalizedEntropy([COUNT_FOURTEEN, COUNT_FOURTEEN, COUNT_FOURTEEN, COUNT_FOURTEEN, COUNT_FOURTEEN, COUNT_FIFTEEN, COUNT_FIFTEEN]);
+            assert.ok(result > TEST_ENTROPY_NEAR_UNIFORM_MIN, `Expected > 0.99, got ${result}`);
+        });
+    });
+    describe('computeCoverageWeightedConfidence', () => {
+        const highBase = {
+            level: 'high',
+            sampleCount: COUNT_HUNDRED,
+            scoreStdDev: DELTA,
+            evaluatorCount: 1,
+            evaluatorAgreement: null,
+        };
+        it('maintains high confidence for uniform coverage', () => {
+            const result = computeCoverageWeightedConfidence(highBase, [COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN, COUNT_TEN]);
+            assert.strictEqual(result.adjustedLevel, 'high');
+            assert.ok(result.effectiveSampleSize >= COUNT_THIRTY);
+            assert.ok(result.coverageUniformity > TEST_SCORE_HIGH);
+        });
+        it('downgrades confidence for concentrated coverage', () => {
+            const result = computeCoverageWeightedConfidence(highBase, [TEST_CONCENTRATED_COVERAGE_PRIMARY, 1, 1, 1, 1, 1]);
+            assert.ok(result.adjustedLevel !== 'high' || result.effectiveSampleSize >= COUNT_THIRTY);
+            assert.ok(result.coverageUniformity < TEST_SCORE_GOOD, `Expected < 0.8, got ${result.coverageUniformity}`);
+        });
+        it('enforces minimum 30 effective samples for high', () => {
+            const lowSample = {
+                level: 'medium',
+                sampleCount: COUNT_TWENTY,
+                scoreStdDev: DELTA,
+                evaluatorCount: 1,
+                evaluatorAgreement: null,
+            };
+            const result = computeCoverageWeightedConfidence(lowSample, [COUNT_FIVE, COUNT_FIVE, COUNT_FIVE, COUNT_FIVE]);
+            assert.ok(result.effectiveSampleSize < COUNT_THIRTY);
+            assert.notStrictEqual(result.adjustedLevel, 'high');
+        });
+        it('preserves base confidence fields', () => {
+            const result = computeCoverageWeightedConfidence(highBase, [COUNT_FIFTY, COUNT_FIFTY]);
+            assert.strictEqual(result.sampleCount, COUNT_HUNDRED);
+            assert.strictEqual(result.scoreStdDev, DELTA);
+            assert.strictEqual(result.featureVersion, '2.0');
+        });
+    });
+    // ============================================================================
+    // Degradation Signal Tests
+    // ============================================================================
+    describe('computeEWMA', () => {
+        it('returns first value for single-element array', () => {
+            assert.strictEqual(computeEWMA([TEST_SCORE_MID]), TEST_SCORE_MID);
+        });
+        it('returns undefined for empty array', () => {
+            assert.strictEqual(computeEWMA([]), undefined);
+        });
+        it('converges toward recent values with default lambda', () => {
+            // Series with a shift: 0.8 x 10, then 0.4 x 10
+            const stable = Array(COUNT_TEN).fill(TEST_SCORE_GOOD);
+            const shifted = [...stable, ...Array(COUNT_TEN).fill(TEST_SCORE_POOR)];
+            const ewma = requireDefined(computeEWMA(shifted), 'Expected EWMA result');
+            // EWMA should be between 0.4 and 0.8, pulled toward 0.4
+            assert.ok(ewma > TEST_SCORE_POOR && ewma < TEST_SCORE_GOOD, `Expected between 0.4 and 0.8, got ${ewma}`);
+        });
+        it('lambda=1 returns the last value', () => {
+            assert.strictEqual(computeEWMA([TEST_SCORE_WARNING, TEST_SCORE_MID, TEST_SCORE_HIGH], 1.0), TEST_SCORE_HIGH);
+        });
+    });
+    describe('computeMAD', () => {
+        it('returns 0 for single element', () => {
+            assert.strictEqual(computeMAD([COUNT_FIVE]), 0);
+        });
+        it('returns 0 for constant values', () => {
+            assert.strictEqual(computeMAD([COUNT_THREE, COUNT_THREE, COUNT_THREE, COUNT_THREE]), 0);
+        });
+        it('computes scaled MAD for simple series', () => {
+            // [1,2,3,4,5]: median=3, deviations=[2,1,0,1,2], median_dev=1, scaled=1.4826
+            const result = computeMAD([1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE]);
+            assert.ok(Math.abs(result - MAD_CONSISTENCY_FACTOR) < TEST_DECIMAL_EPSILON, `Expected ~1.4826, got ${result}`);
+        });
+        it('is robust to outliers', () => {
+            const normal = computeMAD([1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE]);
+            const withOutlier = computeMAD([1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_HUNDRED]);
+            // MAD should be similar despite outlier; stdDev would explode
+            assert.ok(Math.abs(normal - withOutlier) < COUNT_TWO, `Expected similar MADs: ${normal} vs ${withOutlier}`);
+        });
+    });
+    describe('detectEWMADrift', () => {
+        it('returns false for insufficient data', () => {
+            assert.strictEqual(detectEWMADrift([1, COUNT_TWO, COUNT_THREE]), false);
+        });
+        it('returns false for stable series', () => {
+            assert.strictEqual(detectEWMADrift([TEST_SCORE_GOOD, TEST_STABLE_SERIES_HIGH, TEST_STABLE_SERIES_LOW, TEST_SCORE_GOOD, TEST_STABLE_SERIES_HIGHER, TEST_STABLE_SERIES_LOW, TEST_STABLE_SERIES_HIGH]), false);
+        });
+        it('detects drift in shifted series', () => {
+            // 10 periods at 0.8, then shift to 0.3
+            const values = [...Array(COUNT_TEN).fill(TEST_SCORE_GOOD), TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW];
+            assert.strictEqual(detectEWMADrift(values), true);
+        });
+        it('returns false for constant zero series (ER22 - MAD=0 fallback)', () => {
+            const values = Array(COUNT_TWENTY).fill(0);
+            assert.strictEqual(detectEWMADrift(values), false);
+        });
+        it('returns false for constant non-zero series (ER22)', () => {
+            const values = Array(COUNT_TWENTY).fill(TEST_SCORE_MID);
+            assert.strictEqual(detectEWMADrift(values), false);
+        });
+    });
+    describe('computeDegradationSignal', () => {
+        it('returns healthy for normal conditions', () => {
+            const result = computeDegradationSignal(DELTA, DELTA, 0, COUNT_HUNDRED);
+            assert.strictEqual(result.predictedStatus, 'healthy');
+            assert.strictEqual(result.varianceTrend, 'stable');
+            assert.strictEqual(result.ewmaDriftDetected, false);
+            assert.strictEqual(result.consecutiveBreaches, 0);
+            assert.strictEqual(result.confirmed, false);
+        });
+        it('includes featureVersion (FE7)', () => {
+            const result = computeDegradationSignal(DELTA, DELTA, 0, COUNT_HUNDRED);
+            assert.ok(typeof result.featureVersion === 'string');
+            assert.ok(result.featureVersion.length > 0);
+        });
+        it('detects increasing variance at 2x threshold (R5: was 1.5x)', () => {
+            // 1.8x ratio: should be stable (below 2.0 threshold)
+            const stable = computeDegradationSignal(TEST_VARIANCE_STABLE_INPUT, DELTA, 0, COUNT_HUNDRED);
+            assert.strictEqual(stable.varianceTrend, 'stable');
+            // 2.5x ratio: should be increasing
+            const increasing = computeDegradationSignal(TEST_VARIANCE_INCREASING_INPUT, DELTA, 0, COUNT_HUNDRED);
+            assert.strictEqual(increasing.varianceTrend, 'increasing');
+            assert.ok(increasing.varianceRatio >= VARIANCE_INCREASE_THRESHOLD);
+        });
+        it('detects decreasing variance', () => {
+            const result = computeDegradationSignal(TEST_VARIANCE_DECREASING_INPUT, DELTA, 0, COUNT_HUNDRED);
+            assert.strictEqual(result.varianceTrend, 'decreasing');
+        });
+        it('computes coverage dropout rate', () => {
+            const result = computeDegradationSignal(DELTA, DELTA, COUNT_TWENTY_FIVE, COUNT_HUNDRED);
+            assert.strictEqual(result.coverageDropoutRate, TEST_CDF_INTERPOLATION_MIN);
+        });
+        it('computes latency skew ratio', () => {
+            const result = computeDegradationSignal(DELTA, DELTA, 0, COUNT_HUNDRED, TEST_LATENCY_P95, TEST_LATENCY_P50);
+            assert.strictEqual(result.latencySkewRatio, COUNT_FIVE);
+        });
+        it('predicts warning with 1 active signal', () => {
+            // Use high enough variance to cross 2.0 threshold
+            const result = computeDegradationSignal(TEST_MINIMIZE_GOOD_INPUT, DELTA, 0, COUNT_HUNDRED);
+            assert.strictEqual(result.predictedStatus, 'warning');
+        });
+        it('predicts critical with 2+ active signals', () => {
+            const result = computeDegradationSignal(TEST_MINIMIZE_GOOD_INPUT, DELTA, COUNT_TWENTY_FIVE, COUNT_HUNDRED);
+            assert.strictEqual(result.predictedStatus, 'critical');
+        });
+        it('handles null stdDev gracefully', () => {
+            const result = computeDegradationSignal(null, null, 0, COUNT_HUNDRED);
+            assert.strictEqual(result.varianceRatio, 1);
+            assert.strictEqual(result.varianceTrend, 'stable');
+        });
+        it('handles zero total coverage cells', () => {
+            const result = computeDegradationSignal(DELTA, DELTA, 0, 0);
+            assert.strictEqual(result.coverageDropoutRate, 0);
+        });
+        it('detects EWMA drift from historical values', () => {
+            const driftingValues = [...Array(COUNT_TEN).fill(TEST_SCORE_GOOD), TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW];
+            const result = computeDegradationSignal(DELTA, DELTA, 0, COUNT_HUNDRED, null, null, {
+                historicalValues: driftingValues,
+            });
+            assert.strictEqual(result.ewmaDriftDetected, true);
+            assert.strictEqual(result.predictedStatus, 'warning');
+        });
+        it('tracks consecutive breaches for confirmation window', () => {
+            const warning = computeDegradationSignal(TEST_MINIMIZE_GOOD_INPUT, DELTA, 0, COUNT_HUNDRED, null, null, {
+                priorConsecutiveBreaches: 0,
+            });
+            assert.strictEqual(warning.consecutiveBreaches, 1);
+            assert.strictEqual(warning.confirmed, false);
+            const confirmed = computeDegradationSignal(TEST_MINIMIZE_GOOD_INPUT, DELTA, 0, COUNT_HUNDRED, null, null, {
+                priorConsecutiveBreaches: 1,
+            });
+            assert.strictEqual(confirmed.consecutiveBreaches, COUNT_TWO);
+            assert.strictEqual(confirmed.confirmed, true);
+        });
+        it('resets consecutive breaches on healthy period', () => {
+            const result = computeDegradationSignal(DELTA, DELTA, 0, COUNT_HUNDRED, null, null, {
+                priorConsecutiveBreaches: COUNT_FIVE,
+            });
+            assert.strictEqual(result.consecutiveBreaches, 0);
+            assert.strictEqual(result.confirmed, false);
+        });
+    });
+    // ============================================================================
+    // Correlation Matrix Tests
+    // ============================================================================
+    describe('computePearsonR', () => {
+        it('returns 1 for perfectly correlated series', () => {
+            const xs = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE];
+            const ys = [COUNT_TWO, COUNT_FOUR, COUNT_SIX, COUNT_EIGHT, COUNT_TEN];
+            assert.ok(Math.abs(computePearsonR(xs, ys) - 1) < TEST_DECIMAL_EPSILON);
+        });
+        it('returns -1 for perfectly inverse correlated series', () => {
+            const xs = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE];
+            const ys = [COUNT_TEN, COUNT_EIGHT, COUNT_SIX, COUNT_FOUR, COUNT_TWO];
+            assert.ok(Math.abs(computePearsonR(xs, ys) + 1) < TEST_DECIMAL_EPSILON);
+        });
+        it('returns ~0 for uncorrelated series', () => {
+            // Truly uncorrelated: no linear relationship
+            const xs = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT, COUNT_NINE, COUNT_TEN];
+            const ys = [COUNT_FIVE, COUNT_THREE, COUNT_SEVEN, 1, COUNT_NINE, COUNT_TWO, COUNT_EIGHT, COUNT_FOUR, COUNT_SIX, COUNT_FIVE]; // random-looking
+            const r = computePearsonR(xs, ys);
+            assert.ok(Math.abs(r) < TEST_SCORE_MID, `Expected |r| < 0.5, got ${r}`);
+        });
+        it('returns 0 for insufficient data (< 3)', () => {
+            assert.strictEqual(computePearsonR([1, COUNT_TWO], [COUNT_THREE, COUNT_FOUR]), 0);
+        });
+        it('returns 0 for zero variance', () => {
+            assert.strictEqual(computePearsonR([COUNT_FIVE, COUNT_FIVE, COUNT_FIVE], [1, COUNT_TWO, COUNT_THREE]), 0);
+        });
+    });
+    describe('pearsonPValue', () => {
+        it('returns null for insufficient data', () => {
+            assert.strictEqual(pearsonPValue(TEST_SCORE_MID, COUNT_TWO), null);
+        });
+        it('returns ~0 for perfect correlation', () => {
+            const p = pearsonPValue(TEST_PEARSON_NEAR_PERFECT, COUNT_HUNDRED);
+            assert.ok(p !== null && p < TEST_PVALUE_STRICT, `Expected p < 0.001, got ${p}`);
+        });
+        it('returns 1 for zero correlation', () => {
+            const p = pearsonPValue(0, COUNT_FIFTY);
+            assert.strictEqual(p, 1);
+        });
+        it('returns moderate p for weak correlation', () => {
+            const p = pearsonPValue(TEST_SCORE_LOW, COUNT_TEN);
+            assert.ok(p !== null && p > DELTA, `Expected p > 0.05, got ${p}`);
+        });
+        it('strong correlation with few points has moderate p', () => {
+            const p = pearsonPValue(TEST_SCORE_GOOD, COUNT_FIVE);
+            assert.ok(p !== null && p > TEST_DECIMAL_EPSILON && p < TEST_SCORE_LOW, `Expected 0.01 < p < 0.3, got ${p}`);
+        });
+        it('matches scipy two-tailed reference values', () => {
+            // scipy.stats.pearsonr reference values
+            const cases = [
+                [TEST_PEARSON_CASE_ONE_R, COUNT_TEN, TEST_PEARSON_CASE_ONE_P], // moderate r, decent n
+                [TEST_SCORE_MID, COUNT_TWENTY, TEST_PEARSON_CASE_TWO_P], // moderate r, larger n
+                [TEST_SCORE_LOW, COUNT_THIRTY, TEST_PEARSON_CASE_THREE_P], // weak r, large n
+                [-TEST_SCORE_GOOD, COUNT_TEN, TEST_PEARSON_CASE_FOUR_P], // strong negative r
+            ];
+            for (const [r, n, expected] of cases) {
+                const p = requireDefined(pearsonPValue(r, n), 'Expected p-value');
+                assert.ok(Math.abs(p - expected) < TEST_PEARSON_COMPARISON_TOLERANCE, `pearsonPValue(${r}, ${n}) = ${p}, expected ~${expected}`);
+            }
+        });
+    });
+    describe('benjaminiHochberg', () => {
+        it('returns empty for empty input', () => {
+            assert.deepStrictEqual(benjaminiHochberg([]), []);
+        });
+        it('rejects non-significant p-values', () => {
+            const result = benjaminiHochberg([TEST_SCORE_MID, TEST_SCORE_BASELINE, TEST_SCORE_GOOD], DELTA);
+            assert.deepStrictEqual(result, [false, false, false]);
+        });
+        it('accepts clearly significant p-values', () => {
+            const result = benjaminiHochberg([TEST_PVALUE_STRICT, TEST_PVALUE_CASE_MID, TEST_PVALUE_CASE_HIGH], DELTA);
+            assert.deepStrictEqual(result, [true, true, true]);
+        });
+        it('handles mixed significance with FDR control', () => {
+            // 5 tests: 2 real signals (p=0.001, 0.01), 3 noise (p=0.3, 0.5, 0.8)
+            const result = benjaminiHochberg([TEST_PVALUE_STRICT, TEST_SCORE_LOW, TEST_DECIMAL_EPSILON, TEST_SCORE_MID, TEST_SCORE_GOOD], DELTA);
+            // Indices 0 and 2 should be significant
+            assert.strictEqual(result[0], true);
+            assert.strictEqual(result[COUNT_TWO], true);
+            assert.strictEqual(result[1], false);
+            assert.strictEqual(result[COUNT_THREE], false);
+            assert.strictEqual(result[COUNT_FOUR], false);
+        });
+    });
+    describe('computeCorrelationMatrix', () => {
+        it('computes pairwise correlations with significance', () => {
+            const timeSeries = new Map([
+                ['relevance', [TEST_SCORE_GOOD, TEST_SCORE_PASSING, TEST_SCORE_BASELINE, TEST_SCORE_MID, TEST_SCORE_POOR]],
+                ['hallucination', [TEST_SCORE_WARNING, TEST_SCORE_VERY_LOW, TEST_SCORE_LOW, TEST_SCORE_POOR, TEST_SCORE_MID]],
+                ['coherence', [TEST_SCORE_HIGH, TEST_SCORE_STRONG, TEST_SCORE_GOOD, TEST_CDF_INTERPOLATION_INPUT, TEST_SCORE_PASSING]],
+            ]);
+            const results = computeCorrelationMatrix(timeSeries);
+            assert.strictEqual(results.length, COUNT_THREE);
+            // All results should have all fields
+            for (const r of results) {
+                assert.strictEqual(r.featureVersion, '3.1');
+                assert.strictEqual(r.causalConfidence, 'correlation');
+                assert.ok('significant' in r);
+                assert.ok('pValue' in r);
+                assert.ok('spearmanR' in r);
+                assert.ok('effectSize' in r);
+                assert.ok(r.spearmanR >= -1 && r.spearmanR <= 1, `spearmanR out of range: ${r.spearmanR}`);
+                assert.ok(r.effectSize >= 0, `effectSize should be non-negative: ${r.effectSize}`);
+            }
+        });
+        it('identifies known toxic combinations', () => {
+            const timeSeries = new Map([
+                ['hallucination', [TEST_SCORE_WARNING, TEST_SCORE_VERY_LOW, TEST_SCORE_LOW]],
+                ['relevance', [TEST_SCORE_HIGH, TEST_SCORE_GOOD, TEST_SCORE_PASSING]],
+            ]);
+            const knownCombos = new Set(['hallucination:relevance']);
+            const results = computeCorrelationMatrix(timeSeries, knownCombos);
+            assert.strictEqual(results.length, 1);
+            assert.strictEqual(results[0].isKnownToxicCombo, true);
+        });
+        it('computes co-occurrence rate from degraded periods', () => {
+            const timeSeries = new Map([
+                ['metricA', [TEST_SCORE_MID, TEST_SCORE_BASELINE, TEST_SCORE_PASSING]],
+                ['metricB', [TEST_SCORE_POOR, TEST_SCORE_MID, TEST_SCORE_BASELINE]],
+            ]);
+            const degraded = new Map([
+                ['metricA', [true, true, false]],
+                ['metricB', [true, false, false]],
+            ]);
+            const results = computeCorrelationMatrix(timeSeries, undefined, degraded);
+            assert.strictEqual(results.length, 1);
+            assert.ok(Math.abs(results[0].coOccurrenceRate - 1 / COUNT_THREE) < TEST_DECIMAL_EPSILON);
+        });
+        it('returns empty array for fewer than 2 metrics', () => {
+            const timeSeries = new Map([['only_one', [1, COUNT_TWO, COUNT_THREE]]]);
+            assert.strictEqual(computeCorrelationMatrix(timeSeries).length, 0);
+        });
+        it('handles empty time series arrays (ER22)', () => {
+            const timeSeries = new Map([
+                ['metricA', []],
+                ['metricB', []],
+            ]);
+            const results = computeCorrelationMatrix(timeSeries);
+            // Empty arrays should produce pearsonR=0
+            for (const r of results) {
+                assert.strictEqual(r.pearsonR, 0);
+            }
+        });
+        it('detects lagged correlations with maxLagSteps', () => {
+            // A leads B by 2 steps: A[i] correlates with B[i+2]
+            const a = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT, COUNT_NINE, COUNT_TEN];
+            const b = [0, 0, 1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT]; // b = a shifted right by 2
+            const timeSeries = new Map([['a', a], ['b', b]]);
+            // Without lag: weaker correlation
+            const noLag = computeCorrelationMatrix(timeSeries);
+            // With lag: should find stronger correlation at lag
+            const withLag = computeCorrelationMatrix(timeSeries, undefined, undefined, {
+                maxLagSteps: COUNT_THREE, lagStepHours: 1,
+            });
+            assert.strictEqual(withLag.length, 1);
+            assert.ok(Math.abs(withLag[0].pearsonR) >= Math.abs(noLag[0].pearsonR), `Expected lagged R (${withLag[0].pearsonR}) >= no-lag R (${noLag[0].pearsonR})`);
+        });
+        it('applies BH-FDR with custom q threshold', () => {
+            // Strongly correlated pairs
+            const timeSeries = new Map([
+                ['a', [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT, COUNT_NINE, COUNT_TEN]],
+                ['b', [COUNT_TWO, COUNT_FOUR, COUNT_SIX, COUNT_EIGHT, COUNT_TEN, TEST_SEQUENCE_TWELVE, COUNT_FOURTEEN, TEST_SEQUENCE_SIXTEEN, TEST_SEQUENCE_EIGHTEEN, COUNT_TWENTY]],
+                ['c', [COUNT_FIVE, COUNT_THREE, COUNT_SEVEN, 1, COUNT_NINE, COUNT_TWO, COUNT_EIGHT, COUNT_FOUR, COUNT_SIX, COUNT_FIVE]], // uncorrelated noise
+            ]);
+            const results = computeCorrelationMatrix(timeSeries, undefined, undefined, { fdrQ: DELTA });
+            // a:b should be significant (r ~ 1.0)
+            const ab = results.find(r => r.metricA === 'a' && r.metricB === 'b');
+            assert.ok(ab, 'a:b pair not found');
+            assert.strictEqual(requireDefined(ab).significant, true);
+        });
+    });
+    // ============================================================================
+    // Spearman Rank Correlation Tests
+    // ============================================================================
+    describe('computeSpearmanR', () => {
+        it('returns perfect correlation for monotonically increasing data', () => {
+            const r = computeSpearmanR([1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE], [COUNT_TEN, COUNT_TWENTY, COUNT_THIRTY, COUNT_FORTY, COUNT_FIFTY]);
+            assert.strictEqual(r, 1);
+        });
+        it('returns perfect negative correlation for monotonically decreasing data', () => {
+            const r = computeSpearmanR([1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE], [COUNT_FIFTY, COUNT_FORTY, COUNT_THIRTY, COUNT_TWENTY, COUNT_TEN]);
+            assert.strictEqual(r, -1);
+        });
+        it('handles tied values via fractional ranks', () => {
+            // Ties: [1,1,3] -> ranks [1.5, 1.5, 3]
+            const r = computeSpearmanR([1, 1, COUNT_THREE], [COUNT_TEN, COUNT_TEN, COUNT_THIRTY]);
+            assert.ok(r > TEST_SCORE_HIGH, `Expected strong positive Spearman, got ${r}`);
+        });
+        it('returns 0 for fewer than 3 data points', () => {
+            assert.strictEqual(computeSpearmanR([1, COUNT_TWO], [COUNT_THREE, COUNT_FOUR]), 0);
+        });
+        it('agrees with Pearson for linear relationships', () => {
+            const xs = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT];
+            const ys = xs.map(x => COUNT_TWO * x + 1);
+            const pearson = computePearsonR(xs, ys);
+            const spearman = computeSpearmanR(xs, ys);
+            assert.ok(Math.abs(pearson - spearman) < TEST_DECIMAL_EPSILON, `Pearson (${pearson}) and Spearman (${spearman}) should agree for linear data`);
+        });
+        it('handles non-linear monotonic relationships better than Pearson', () => {
+            // Exponential relationship: Spearman should be 1.0, Pearson < 1.0
+            const xs = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT];
+            const ys = xs.map(x => Math.exp(x));
+            const pearson = computePearsonR(xs, ys);
+            const spearman = computeSpearmanR(xs, ys);
+            assert.ok(spearman > pearson, `Spearman (${spearman}) should be >= Pearson (${pearson}) for monotonic non-linear`);
+        });
+    });
+    describe('effectSize in correlation matrix', () => {
+        it('reports large effect size for strongly correlated metrics', () => {
+            const timeSeries = new Map([
+                ['a', [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT, COUNT_NINE, COUNT_TEN]],
+                ['b', [COUNT_TWO, COUNT_FOUR, COUNT_SIX, COUNT_EIGHT, COUNT_TEN, TEST_SEQUENCE_TWELVE, COUNT_FOURTEEN, TEST_SEQUENCE_SIXTEEN, TEST_SEQUENCE_EIGHTEEN, COUNT_TWENTY]],
+            ]);
+            const results = computeCorrelationMatrix(timeSeries);
+            assert.ok(results[0].effectSize >= TEST_SCORE_GOOD, `Expected large effect size (>= 0.8), got ${results[0].effectSize}`);
+        });
+        it('reports small effect size for weakly correlated metrics', () => {
+            const timeSeries = new Map([
+                ['a', [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT, COUNT_NINE, COUNT_TEN]],
+                ['b', [COUNT_FIVE, COUNT_THREE, COUNT_SEVEN, 1, COUNT_NINE, COUNT_TWO, COUNT_EIGHT, COUNT_FOUR, COUNT_SIX, COUNT_FIVE]], // noisy
+            ]);
+            const results = computeCorrelationMatrix(timeSeries);
+            assert.ok(results[0].effectSize < TEST_SCORE_GOOD, `Expected small effect size, got ${results[0].effectSize}`);
+        });
+    });
+    // ============================================================================
+    // METRIC_SCALE_STRATEGY Tests
+    // ============================================================================
+    describe('METRIC_SCALE_STRATEGY', () => {
+        it('defines strategies for all 7 core metrics', () => {
+            const expected = ['relevance', 'faithfulness', 'coherence', 'hallucination', 'task_completion', 'tool_correctness', 'evaluation_latency'];
+            for (const metric of expected) {
+                assert.ok(metric in METRIC_SCALE_STRATEGY, `Missing strategy for ${metric}`);
+            }
+        });
+    });
+    // ============================================================================
+    // R4: Percentile Distribution Tests
+    // ============================================================================
+    describe('computePercentileDistribution', () => {
+        it('computes correct percentiles for sorted array', () => {
+            const scores = Array.from({ length: COUNT_HUNDRED }, (_, i) => i / TEST_PERCENTILE_DIVISOR_MAX_INDEX);
+            const dist = computePercentileDistribution(scores);
+            assert.ok(dist !== undefined);
+            assert.ok(Math.abs(requireDefined(dist).p50 - TEST_SCORE_MID) < TEST_CQI_CONTRIBUTION_TOLERANCE, `p50 expected ~0.5, got ${requireDefined(dist).p50}`);
+            assert.ok(requireDefined(dist).p10 < requireDefined(dist).p25, 'p10 < p25');
+            assert.ok(requireDefined(dist).p25 < requireDefined(dist).p50, 'p25 < p50');
+            assert.ok(requireDefined(dist).p50 < requireDefined(dist).p75, 'p50 < p75');
+            assert.ok(requireDefined(dist).p75 < requireDefined(dist).p90, 'p75 < p90');
+        });
+        it('returns undefined for fewer than 3 scores', () => {
+            assert.strictEqual(computePercentileDistribution([TEST_SCORE_MID, TEST_SCORE_BASELINE]), undefined);
+            assert.strictEqual(computePercentileDistribution([]), undefined);
+        });
+        it('handles unsorted input', () => {
+            const dist = computePercentileDistribution([TEST_SCORE_HIGH, TEST_SCORE_WARNING, TEST_SCORE_MID, TEST_SCORE_LOW, TEST_SCORE_PASSING]);
+            assert.ok(dist !== undefined);
+            assert.ok(requireDefined(dist).p10 <= requireDefined(dist).p90);
+        });
+        it('handles identical values', () => {
+            const dist = computePercentileDistribution([TEST_SCORE_MID, TEST_SCORE_MID, TEST_SCORE_MID, TEST_SCORE_MID]);
+            assert.ok(dist !== undefined);
+            assert.strictEqual(requireDefined(dist).p50, TEST_SCORE_MID);
+            assert.strictEqual(requireDefined(dist).p10, TEST_SCORE_MID);
+        });
+    });
+    describe('computePercentileRank', () => {
+        it('returns fractional rank for median value', () => {
+            const sorted = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE, COUNT_SIX, COUNT_SEVEN, COUNT_EIGHT, COUNT_NINE, COUNT_TEN];
+            // 4 values < 5, 5 values <= 5, rank = (4+5)/(2*10) = 0.45
+            const rank = computePercentileRank(COUNT_FIVE, sorted);
+            assert.strictEqual(rank, TEST_SCORE_BORDERLINE);
+        });
+        it('returns 1 for value above all', () => {
+            const sorted = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE];
+            assert.strictEqual(computePercentileRank(COUNT_TEN, sorted), 1);
+        });
+        it('returns 0 for value below all', () => {
+            const sorted = [1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE];
+            assert.strictEqual(computePercentileRank(0, sorted), 0);
+        });
+        it('returns 0.5 for empty array', () => {
+            assert.strictEqual(computePercentileRank(COUNT_FIVE, []), TEST_SCORE_MID);
+        });
+        it('returns ~0.5 for all-equal values (ER2 fix)', () => {
+            // All-equal: lower=0, upper=3, rank = (0+3)/(2*3) = 0.5
+            assert.strictEqual(computePercentileRank(TEST_SCORE_MID, [TEST_SCORE_MID, TEST_SCORE_MID, TEST_SCORE_MID]), TEST_SCORE_MID);
+            assert.strictEqual(computePercentileRank(1, [1, 1, 1, 1, 1]), TEST_SCORE_MID);
+        });
+        it('handles tied values at edges', () => {
+            // [1, 1, 2, 3]: value=1 → lower=0, upper=2, rank = (0+2)/(2*4) = 0.25
+            assert.strictEqual(computePercentileRank(1, [1, 1, COUNT_TWO, COUNT_THREE]), TEST_CDF_INTERPOLATION_MIN);
+            // [1, 2, 3, 3]: value=3 → lower=2, upper=4, rank = (2+4)/(2*4) = 0.75
+            assert.strictEqual(computePercentileRank(COUNT_THREE, [1, COUNT_TWO, COUNT_THREE, COUNT_THREE]), TEST_CDF_INTERPOLATION_INPUT);
+        });
+    });
+    describe('StreamingPercentile', () => {
+        it('produces accurate percentiles for 1000 uniform values', () => {
+            const sp = new StreamingPercentile();
+            const maxIndex = COUNT_THOUSAND - 1;
+            for (let i = 0; i < COUNT_THOUSAND; i++)
+                sp.add(i / maxIndex);
+            const dist = sp.distribution();
+            assert.ok(dist !== undefined);
+            assert.ok(Math.abs(requireDefined(dist).p50 - TEST_SCORE_MID) < DELTA, `p50 expected ~0.5, got ${requireDefined(dist).p50}`);
+            assert.ok(Math.abs(requireDefined(dist).p10 - TEST_SCORE_WARNING) < DELTA, `p10 expected ~0.1, got ${requireDefined(dist).p10}`);
+            assert.ok(Math.abs(requireDefined(dist).p90 - TEST_SCORE_HIGH) < DELTA, `p90 expected ~0.9, got ${requireDefined(dist).p90}`);
+        });
+        it('tracks count correctly', () => {
+            const sp = new StreamingPercentile();
+            sp.addAll([1, COUNT_TWO, COUNT_THREE, COUNT_FOUR, COUNT_FIVE]);
+            assert.strictEqual(sp.count(), COUNT_FIVE);
+        });
+        it('returns undefined distribution for fewer than 3 values', () => {
+            const sp = new StreamingPercentile();
+            sp.add(1);
+            sp.add(COUNT_TWO);
+            assert.strictEqual(sp.distribution(), undefined);
+        });
+        it('produces monotonic percentiles', () => {
+            const sp = new StreamingPercentile();
+            for (let i = 0; i < TEST_STREAMING_MONOTONIC_SAMPLE_SIZE; i++)
+                sp.add(Math.random());
+            const dist = requireDefined(sp.distribution(), 'Expected percentile distribution');
+            assert.ok(dist.p10 <= dist.p25, `p10 (${dist.p10}) <= p25 (${dist.p25})`);
+            assert.ok(dist.p25 <= dist.p50, `p25 (${dist.p25}) <= p50 (${dist.p50})`);
+            assert.ok(dist.p50 <= dist.p75, `p50 (${dist.p50}) <= p75 (${dist.p75})`);
+            assert.ok(dist.p75 <= dist.p90, `p75 (${dist.p75}) <= p90 (${dist.p90})`);
+        });
+        it('rejects NaN (ER12)', () => {
+            const sp = new StreamingPercentile();
+            assert.throws(() => sp.add(NaN), /must be finite/);
+        });
+        it('rejects Infinity (ER12)', () => {
+            const sp = new StreamingPercentile();
+            assert.throws(() => sp.add(Infinity), /must be finite/);
+            assert.throws(() => sp.add(-Infinity), /must be finite/);
+        });
+        it('handles empty percentile digest gracefully', () => {
+            const sp = new StreamingPercentile();
+            assert.strictEqual(sp.count(), 0);
+            assert.strictEqual(sp.distribution(), undefined);
+            assert.strictEqual(sp.percentile(50), 0); // Returns 0 for empty
+        });
+        it('handles single value correctly', () => {
+            const sp = new StreamingPercentile();
+            sp.add(42);
+            assert.strictEqual(sp.count(), 1);
+            assert.strictEqual(sp.distribution(), undefined); // Needs min 3 values
+            // DDSketch uses relative error; approximate match
+            assert.ok(Math.abs(sp.percentile(50) - 42) < 42 * 0.05, 'p50 should approximate 42');
+        });
+        it('addAll batches multiple values', () => {
+            const sp = new StreamingPercentile();
+            sp.addAll([1, 2, 3, 4, 5]);
+            assert.strictEqual(sp.count(), 5);
+            const dist = sp.distribution();
+            assert.ok(dist !== undefined);
+            assert.ok(dist.p50 > 0 && dist.p50 < 5);
+        });
+        it('addAll rejects NaN in batch', () => {
+            const sp = new StreamingPercentile();
+            assert.throws(() => sp.addAll([1, 2, NaN, 4]), /must be finite/);
+        });
+        it('addAll rejects Infinity in batch', () => {
+            const sp = new StreamingPercentile();
+            assert.throws(() => sp.addAll([1, Infinity]), /must be finite/);
+        });
+        it('maintains accuracy with many values', () => {
+            const sp = new StreamingPercentile();
+            for (let i = 0; i < 100; i++) {
+                sp.add(Math.random());
+            }
+            assert.strictEqual(sp.count(), 100);
+            const dist = sp.distribution();
+            assert.ok(dist !== undefined);
+            // Verify monotonicity is preserved even after compression
+            assert.ok(dist.p10 <= dist.p90);
+        });
+    });
+    // ============================================================================
+    // QM2: Derived Features Pipeline Tests
+    // ============================================================================
+    describe('computeDerivedFeatures', () => {
+        const metrics = [
+            makeMetricResult({ name: 'relevance', values: { avg: TEST_SCORE_STRONG, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            makeMetricResult({ name: 'faithfulness', values: { avg: 0.90, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED } }),
+            makeMetricResult({
+                name: 'hallucination',
+                values: { avg: DELTA, p50: null, p95: null, p99: null, min: null, max: null, count: COUNT_HUNDRED },
+                alerts: [{ severity: 'warning', message: '', aggregation: 'avg', threshold: TEST_SCORE_WARNING, actualValue: DELTA, direction: 'above' }],
+            }),
+        ];
+        it('computes CQI from metrics', () => {
+            const result = computeDerivedFeatures({ metrics });
+            assert.ok(result.cqi !== undefined);
+            assert.ok(requireDefined(result.cqi).value > 0);
+        });
+        it('computes CQI with custom weights (FE1)', () => {
+            const result = computeDerivedFeatures({
+                metrics,
+                cqiWeights: { relevance: TEST_SCORE_MID, faithfulness: TEST_SCORE_MID },
+            });
+            assert.ok(result.cqi !== undefined);
+            assert.strictEqual(requireDefined(result.cqi).contributions.length, COUNT_TWO);
+        });
+        it('computes coverage confidence when evaluationsPerInput provided', () => {
+            const metricsWithConf = metrics.map(m => ({
+                ...m,
+                confidence: { level: 'high', sampleCount: COUNT_HUNDRED, scoreStdDev: DELTA, evaluatorCount: 1, evaluatorAgreement: null },
+            }));
+            const evaluationsPerInput = new Map([
+                ['relevance', [COUNT_TWENTY, COUNT_TWENTY, COUNT_TWENTY, COUNT_TWENTY, COUNT_TWENTY]],
+                ['faithfulness', [COUNT_FIFTY, COUNT_FIFTY]],
+            ]);
+            const result = computeDerivedFeatures({
+                metrics: metricsWithConf,
+                evaluationsPerInput,
+            });
+            assert.ok(result.coverageConfidence.size >= COUNT_TWO);
+            assert.ok(result.coverageConfidence.has('relevance'));
+        });
+        it('computes correlation matrix when metricTimeSeries provided', () => {
+            const metricTimeSeries = new Map([
+                ['relevance', [TEST_SCORE_GOOD, TEST_SCORE_PASSING, TEST_SCORE_BASELINE, TEST_SCORE_MID, TEST_SCORE_POOR]],
+                ['hallucination', [TEST_SCORE_WARNING, TEST_SCORE_VERY_LOW, TEST_SCORE_LOW, TEST_SCORE_POOR, TEST_SCORE_MID]],
+            ]);
+            const result = computeDerivedFeatures({ metrics, metricTimeSeries });
+            assert.ok(result.correlations.length > 0);
+        });
+        it('returns empty correlations when no time series', () => {
+            const result = computeDerivedFeatures({ metrics });
+            assert.strictEqual(result.correlations.length, 0);
+        });
+        it('includes CQI sensitivity when CQI is computed', () => {
+            const result = computeDerivedFeatures({ metrics });
+            assert.ok(result.cqiSensitivity !== undefined);
+        });
+    });
+    // ==========================================================================
+    // R3: Granger Causality Tests
+    // ==========================================================================
+    describe('computeGrangerCausality', () => {
+        it('detects A->B causality with lagged linear relationship', () => {
+            // A leads B by 1 step: B[t] = 0.8 * A[t-1] + noise
+            const n = COUNT_SIXTY;
+            const a = [];
+            const b = [];
+            for (let i = 0; i < n; i++) {
+                a.push(Math.sin(i * TEST_SCORE_LOW) + (i % COUNT_THREE) * TEST_DECIMAL_EPSILON);
+                b.push(i > 0 ? TEST_SCORE_GOOD * a[i - 1] + TEST_SCORE_WARNING * Math.cos(i) : TEST_SCORE_MID);
+            }
+            const result = computeGrangerCausality(a, b, COUNT_TWO);
+            assert.ok(result !== undefined, 'should return a result');
+            assert.ok(requireDefined(result).fStatistic > 0, 'F-statistic should be positive');
+            assert.ok(requireDefined(result).lags >= 1, 'should use at least 1 lag');
+            assert.ok(['A->B', 'bidirectional'].includes(requireDefined(result).direction), `Expected A->B or bidirectional, got: ${requireDefined(result).direction}`);
+            assert.ok(requireDefined(result).pValue < TEST_SCORE_WARNING, `Expected significant p-value, got ${requireDefined(result).pValue}`);
+        });
+        it('returns undefined for insufficient data', () => {
+            const result = computeGrangerCausality([1, COUNT_TWO, COUNT_THREE], [COUNT_FOUR, COUNT_FIVE, COUNT_SIX], 1);
+            assert.strictEqual(result, undefined);
+        });
+        it('detects no causality for independent series', () => {
+            const n = 80;
+            const a = [];
+            const b = [];
+            for (let i = 0; i < n; i++) {
+                a.push(Math.sin(i * TEST_SCORE_MID));
+                b.push(Math.cos(i * TEST_SCORE_PASSING + COUNT_HUNDRED));
+            }
+            const result = computeGrangerCausality(a, b, COUNT_TWO);
+            assert.ok(result !== undefined);
+            // Independent deterministic series should show no significant causal direction
+            assert.strictEqual(requireDefined(result).direction, 'none', 'independent series should show no causal direction');
+        });
+        it('detects bidirectional causality for tightly coupled series', () => {
+            const n = 80;
+            const a = [TEST_SCORE_MID, TEST_SCORE_MID];
+            const b = [TEST_SCORE_MID, TEST_SCORE_MID];
+            for (let i = COUNT_TWO; i < n; i++) {
+                a.push(TEST_SCORE_BASELINE * a[i - 1] + TEST_SCORE_LOW * b[i - 1] + DELTA * Math.sin(i));
+                b.push(TEST_SCORE_MID * b[i - 1] + TEST_SCORE_POOR * a[i - 1] + DELTA * Math.cos(i));
+            }
+            const result = computeGrangerCausality(a, b, COUNT_TWO, TEST_SCORE_WARNING);
+            assert.ok(result !== undefined);
+            // With tight coupling, likely bidirectional or at least one direction
+            assert.ok(['A->B', 'B->A', 'bidirectional'].includes(requireDefined(result).direction), `expected causal direction, got: ${requireDefined(result).direction}`);
+        });
+        it('handles series with NaN values by treating as insufficient data', () => {
+            const a = [1, 2, NaN, 4, 5];
+            const b = [2, 3, 4, 5, 6];
+            const result = computeGrangerCausality(a, b, 1);
+            // NaN should make the test fail (return undefined)
+            assert.strictEqual(result, undefined);
+        });
+        it('returns valid pValue (0 <= p <= 1)', () => {
+            const n = 100;
+            const a = [];
+            const b = [];
+            for (let i = 0; i < n; i++) {
+                a.push(Math.sin(i * 0.05) + Math.random() * 0.1);
+                b.push(i > 0 ? 0.7 * a[i - 1] + Math.random() * 0.1 : 0.5);
+            }
+            const result = computeGrangerCausality(a, b, 2);
+            assert.ok(result !== undefined);
+            assert.ok(requireDefined(result).pValue >= 0 && requireDefined(result).pValue <= 1);
+        });
+    });
+    describe('computeCorrelationMatrix with Granger', () => {
+        it('runs Granger test when enabled and pairs are significant', () => {
+            const n = COUNT_SIXTY;
+            const series1 = [];
+            const series2 = [];
+            for (let i = 0; i < n; i++) {
+                series1.push(TEST_SCORE_MID + TEST_SCORE_LOW * Math.sin(i * TEST_SCORE_VERY_LOW));
+                series2.push(i > 0 ? TEST_SCORE_PASSING * series1[i - 1] + TEST_SCORE_WARNING : TEST_SCORE_MID);
+            }
+            const metricTimeSeries = new Map([
+                ['metricA', series1],
+                ['metricB', series2],
+            ]);
+            const results = computeCorrelationMatrix(metricTimeSeries, undefined, undefined, {
+                grangerConfig: { enabled: true, minSampleSize: COUNT_TWENTY },
+            });
+            assert.ok(results.length === 1);
+            const r = results[0];
+            // If significant, should have granger result
+            if (r.significant) {
+                assert.ok(r.granger !== undefined, 'significant pair should have Granger result');
+                assert.ok(requireDefined(r.granger).fStatistic >= 0, 'F-statistic should be non-negative');
+                assert.ok(['correlation', 'granger'].includes(r.causalConfidence));
+            }
+        });
+        it('skips Granger when disabled', () => {
+            const metricTimeSeries = new Map([
+                ['a', [TEST_SCORE_HIGH, TEST_SCORE_GOOD, TEST_SCORE_PASSING, TEST_SCORE_BASELINE, TEST_SCORE_MID]],
+                ['b', [TEST_SCORE_WARNING, TEST_SCORE_VERY_LOW, TEST_SCORE_LOW, TEST_SCORE_POOR, TEST_SCORE_MID]],
+            ]);
+            const results = computeCorrelationMatrix(metricTimeSeries);
+            assert.ok(results.length === 1);
+            assert.strictEqual(results[0].granger, undefined);
+            assert.strictEqual(results[0].causalConfidence, 'correlation');
+        });
+        it('skips Granger when sample size too small', () => {
+            const metricTimeSeries = new Map([
+                ['a', [TEST_SCORE_HIGH, TEST_SCORE_GOOD, TEST_SCORE_PASSING, TEST_SCORE_BASELINE, TEST_SCORE_MID]],
+                ['b', [TEST_SCORE_WARNING, TEST_SCORE_VERY_LOW, TEST_SCORE_LOW, TEST_SCORE_POOR, TEST_SCORE_MID]],
+            ]);
+            const results = computeCorrelationMatrix(metricTimeSeries, undefined, undefined, {
+                grangerConfig: { enabled: true, minSampleSize: COUNT_HUNDRED },
+            });
+            assert.ok(results.length === 1);
+            assert.strictEqual(results[0].granger, undefined);
+        });
+    });
+    // ==========================================================================
+    // R5: Degradation Backtesting Tests
+    // ==========================================================================
+    describe('injectDegradationScenario', () => {
+        it('injects variance spike at specified range', () => {
+            const base = Array.from({ length: COUNT_TEN }, () => ({
+                currentStdDev: DELTA, baselineStdDev: DELTA,
+                coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED,
+            }));
+            const result = injectDegradationScenario(base, 'variance_spike', TEST_VARIANCE_SPIKE_MULTIPLIER, COUNT_THREE, COUNT_FOUR);
+            assert.strictEqual(result[COUNT_TWO].currentStdDev, DELTA); // before injection
+            assert.ok(Math.abs(result[COUNT_THREE].currentStdDev - TEST_MINIMIZE_GOOD_INPUT) < TEST_ABSOLUTE_EPSILON, 'should be ~0.15'); // DELTA * 3.0
+            assert.ok(Math.abs(result[COUNT_SIX].currentStdDev - TEST_MINIMIZE_GOOD_INPUT) < TEST_ABSOLUTE_EPSILON, 'should be ~0.15'); // last injected
+            assert.strictEqual(result[COUNT_SEVEN].currentStdDev, DELTA); // after injection
+        });
+        it('injects coverage gap', () => {
+            const base = Array.from({ length: COUNT_TEN }, () => ({
+                currentStdDev: DELTA, baselineStdDev: DELTA,
+                coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED,
+            }));
+            const result = injectDegradationScenario(base, 'coverage_gap', TEST_SCORE_MID, COUNT_FIVE, COUNT_TWO);
+            assert.strictEqual(result[COUNT_FOUR].coverageGapCount, 0);
+            assert.strictEqual(result[COUNT_FIVE].coverageGapCount, COUNT_FIFTY); // 100 * 0.5
+            assert.strictEqual(result[COUNT_SIX].coverageGapCount, COUNT_FIFTY);
+            assert.strictEqual(result[COUNT_SEVEN].coverageGapCount, 0);
+        });
+        it('injects latency jump', () => {
+            const base = Array.from({ length: COUNT_TEN }, () => ({
+                currentStdDev: DELTA, baselineStdDev: DELTA,
+                coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED,
+                latencyP50: COUNT_TWO, latencyP95: COUNT_FOUR,
+            }));
+            const result = injectDegradationScenario(base, 'latency_jump', COUNT_FIVE, 0, COUNT_THREE);
+            assert.strictEqual(result[0].latencyP95, COUNT_TEN); // 2 * 5
+            assert.strictEqual(result[COUNT_TWO].latencyP95, COUNT_TEN);
+            assert.strictEqual(result[COUNT_THREE].latencyP95, COUNT_FOUR); // unaffected
+        });
+        it('does not mutate original array', () => {
+            const base = [{ currentStdDev: DELTA, baselineStdDev: DELTA, coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED }];
+            injectDegradationScenario(base, 'variance_spike', TEST_VARIANCE_SPIKE_MULTIPLIER, 0, 1);
+            assert.strictEqual(base[0].currentStdDev, DELTA);
+        });
+        it('preserves references for unmodified snapshots', () => {
+            const base = [
+                { currentStdDev: DELTA, baselineStdDev: DELTA, coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED },
+                { currentStdDev: DELTA, baselineStdDev: DELTA, coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED },
+                { currentStdDev: DELTA, baselineStdDev: DELTA, coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED },
+            ];
+            const result = injectDegradationScenario(base, 'variance_spike', TEST_VARIANCE_SPIKE_MULTIPLIER, 1, 1);
+            assert.strictEqual(result[0], base[0], 'Unmodified item before injection range should be same reference');
+            assert.notStrictEqual(result[1], base[1], 'Modified item should be a new object');
+            assert.strictEqual(result[2], base[2], 'Unmodified item after injection range should be same reference');
+        });
+        it('handles empty array safely', () => {
+            const result = injectDegradationScenario([], 'variance_spike', TEST_VARIANCE_SPIKE_MULTIPLIER, 0, 1);
+            assert.strictEqual(result.length, 0);
+        });
+        it('handles edge case where endIdx >= array length', () => {
+            const base = [
+                { currentStdDev: DELTA, baselineStdDev: DELTA, coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED },
+                { currentStdDev: DELTA, baselineStdDev: DELTA, coverageGapCount: 0, totalCoverageCells: COUNT_HUNDRED },
+            ];
+            const result = injectDegradationScenario(base, 'variance_spike', TEST_VARIANCE_SPIKE_MULTIPLIER, 0, 100); // beyond bounds
+            assert.strictEqual(result.length, COUNT_TWO);
+        });
+    });
+    // ==========================================================================
+    // R5 — Rolling Degradation Signal Tests
+    // ==========================================================================
+    describe('computeStdDev', () => {
+        it('computes sample standard deviation for known values', () => {
+            // [2, 4, 4, 4, 5, 5, 7, 9] → stdDev ≈ 2.138
+            const result = computeStdDev([COUNT_TWO, COUNT_FOUR, COUNT_FOUR, COUNT_FOUR, COUNT_FIVE, COUNT_FIVE, COUNT_SEVEN, COUNT_NINE]);
+            assert.ok(result !== null);
+            assert.ok(Math.abs(result - TEST_STD_DEV_REFERENCE_HIGH) < TEST_PVALUE_STRICT, `Expected ~2.138, got ${result}`);
+        });
+        it('returns null for single value', () => {
+            assert.strictEqual(computeStdDev([TEST_SCORE_MID]), null);
+        });
+        it('returns null for empty array', () => {
+            assert.strictEqual(computeStdDev([]), null);
+        });
+        it('returns 0 for identical values', () => {
+            assert.strictEqual(computeStdDev([TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD]), 0);
+        });
+        it('computes stdDev for two values', () => {
+            // [0, 1] → stdDev = sqrt(0.5) ≈ 0.707
+            const result = computeStdDev([0, 1]);
+            assert.ok(result !== null);
+            assert.ok(Math.abs(result - TEST_STD_DEV_REFERENCE_LOW) < TEST_PVALUE_STRICT);
+        });
+    });
+    describe('loadDegradationState / saveDegradationState', () => {
+        let tmpDir;
+        beforeEach(() => {
+            tmpDir = mkdtempSync(join(tmpdir(), 'degradation-state-'));
+        });
+        afterEach(() => {
+            rmSync(tmpDir, { recursive: true, force: true });
+        });
+        it('returns empty state on missing file', () => {
+            const state = loadDegradationState(tmpDir);
+            assert.strictEqual(state.lastRun, '');
+            assert.deepStrictEqual(state.breaches, {});
+        });
+        it('round-trips state correctly', () => {
+            const state = {
+                lastRun: '2026-03-01T00:00:00Z',
+                breaches: { relevance: COUNT_TWO, coherence: 0, hallucination: 1 },
+            };
+            saveDegradationState(tmpDir, state);
+            const loaded = loadDegradationState(tmpDir);
+            assert.strictEqual(loaded.lastRun, state.lastRun);
+            assert.deepStrictEqual(loaded.breaches, state.breaches);
+        });
+        it('returns empty state on malformed JSON', () => {
+            writeFileSync(join(tmpDir, '.degradation-state.json'), 'not json');
+            const state = loadDegradationState(tmpDir);
+            assert.strictEqual(state.lastRun, '');
+            assert.deepStrictEqual(state.breaches, {});
+        });
+        it('handles empty breach counts in saved state', () => {
+            const state = {
+                lastRun: '2026-03-01T00:00:00Z',
+                breaches: {}, // Empty breaches
+            };
+            saveDegradationState(tmpDir, state);
+            const loaded = loadDegradationState(tmpDir);
+            assert.deepStrictEqual(loaded.breaches, {});
+        });
+        it('persists complex breach data across save/load cycles', () => {
+            const original = {
+                lastRun: '2026-03-01T12:30:45Z',
+                breaches: {
+                    relevance: 5,
+                    faithfulness: 3,
+                    coherence: 0,
+                    hallucination: 2,
+                    task_completion: 1,
+                },
+            };
+            saveDegradationState(tmpDir, original);
+            const loaded = loadDegradationState(tmpDir);
+            assert.strictEqual(loaded.lastRun, original.lastRun);
+            assert.strictEqual(loaded.breaches.relevance, 5);
+            assert.strictEqual(loaded.breaches.task_completion, 1);
+        });
+    });
+    describe('loadCalibrationState / saveCalibrationState', () => {
+        let tmpDir;
+        beforeEach(() => {
+            tmpDir = mkdtempSync(join(tmpdir(), 'calibration-state-'));
+        });
+        afterEach(() => {
+            rmSync(tmpDir, { recursive: true, force: true });
+        });
+        it('returns null on missing file', () => {
+            const state = loadCalibrationState(tmpDir);
+            assert.strictEqual(state, null);
+        });
+        it('round-trips calibration state correctly', () => {
+            const dist = {
+                p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9
+            };
+            const state = {
+                lastCalibrated: '2026-03-01T00:00:00Z',
+                distributions: {
+                    relevance: {
+                        distribution: dist,
+                        sampleSize: 100,
+                        windowStart: '2026-03-01',
+                        windowEnd: '2026-03-07',
+                    },
+                },
+            };
+            saveCalibrationState(tmpDir, state);
+            const loaded = requireDefined(loadCalibrationState(tmpDir), 'Expected loaded calibration state');
+            assert.strictEqual(loaded.lastCalibrated, state.lastCalibrated);
+            assert.ok('relevance' in loaded.distributions);
+            const relevanceData = loaded.distributions.relevance;
+            assert.strictEqual(relevanceData.sampleSize, 100);
+        });
+        it('handles malformed JSON gracefully', () => {
+            writeFileSync(join(tmpDir, '.calibration-state.json'), '{invalid}');
+            const state = loadCalibrationState(tmpDir);
+            assert.strictEqual(state, null);
+        });
+        it('persists multiple metric distributions', () => {
+            const dist1 = { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 };
+            const dist2 = { p10: 0.05, p25: 0.2, p50: 0.45, p75: 0.8, p90: 0.95 };
+            const state = {
+                lastCalibrated: '2026-03-01T00:00:00Z',
+                distributions: {
+                    relevance: { distribution: dist1, sampleSize: 100, windowStart: '2026-03-01', windowEnd: '2026-03-07' },
+                    faithfulness: { distribution: dist2, sampleSize: 150, windowStart: '2026-03-01', windowEnd: '2026-03-07' },
+                },
+            };
+            saveCalibrationState(tmpDir, state);
+            const loaded = requireDefined(loadCalibrationState(tmpDir), 'Expected loaded calibration state');
+            assert.strictEqual(Object.keys(loaded.distributions).length, 2);
+            assert.ok('relevance' in loaded.distributions);
+            assert.ok('faithfulness' in loaded.distributions);
+        });
+    });
+    describe('computeRollingDegradationSignals', () => {
+        function makeBuckets(avgScores, scoresPerBucket = COUNT_TEN) {
+            return avgScores.map((avg, i) => ({
+                scores: avg === -1 ? [] : Array.from({ length: scoresPerBucket }, () => avg),
+                startTime: new Date(TEST_YEAR_2026, 0, 1 + i).toISOString(),
+                endTime: new Date(TEST_YEAR_2026, 0, COUNT_TWO + i).toISOString(),
+            }));
+        }
+        const emptyState = { lastRun: '', breaches: {} };
+        const window = { startDate: '2026-01-01T00:00:00Z', endDate: '2026-01-11T00:00:00Z' };
+        it('returns healthy for 10 stable-score buckets', () => {
+            const buckets = makeBuckets([TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD]);
+            const reports = computeRollingDegradationSignals({ relevance: buckets }, ['relevance'], emptyState, window);
+            assert.strictEqual(reports.length, 1);
+            assert.strictEqual(reports[0].signal.predictedStatus, 'healthy');
+            assert.strictEqual(reports[0].signal.confirmed, false);
+        });
+        it('detects variance spike with high stdDev in last buckets', () => {
+            // Baseline: stable at 0.8. Last bucket: scores spread from 0.1 to 0.9
+            const stableBuckets = makeBuckets([TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD]);
+            const spikeBucket = {
+                scores: [
+                    TEST_SCORE_WARNING,
+                    TEST_SCORE_VERY_LOW,
+                    TEST_SCORE_LOW,
+                    TEST_SCORE_POOR,
+                    TEST_SCORE_MID,
+                    TEST_SCORE_BASELINE,
+                    TEST_SCORE_PASSING,
+                    TEST_SCORE_GOOD,
+                    TEST_SCORE_HIGH,
+                    1,
+                ],
+                startTime: new Date(TEST_YEAR_2026, 0, COUNT_EIGHT).toISOString(),
+                endTime: new Date(TEST_YEAR_2026, 0, COUNT_NINE).toISOString(),
+            };
+            const buckets = [...stableBuckets, spikeBucket];
+            const reports = computeRollingDegradationSignals({ relevance: buckets }, ['relevance'], emptyState, window);
+            assert.strictEqual(reports.length, 1);
+            // Variance spike → at least warning
+            assert.ok(reports[0].signal.predictedStatus === 'warning' || reports[0].signal.predictedStatus === 'critical', `Expected warning or critical, got ${reports[0].signal.predictedStatus}`);
+        });
+        it('skips metrics with fewer than MIN_BUCKETS_FOR_SIGNAL non-empty buckets', () => {
+            const buckets = makeBuckets([TEST_SCORE_GOOD, TEST_SCORE_GOOD, -1, -1, -1, -1, -1, -1, -1, -1]);
+            const reports = computeRollingDegradationSignals({ relevance: buckets }, ['relevance'], emptyState, window);
+            assert.strictEqual(reports.length, 0);
+        });
+        it('handles all-identical scores (MAD=0 fallback path)', () => {
+            const buckets = makeBuckets([TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH, TEST_SCORE_HIGH]);
+            const reports = computeRollingDegradationSignals({ relevance: buckets }, ['relevance'], emptyState, window);
+            assert.strictEqual(reports.length, 1);
+            // All identical → stdDev is 0, varianceRatio defaults to 1 → healthy
+            assert.strictEqual(reports[0].signal.predictedStatus, 'healthy');
+        });
+        it('carries forward priorConsecutiveBreaches from state', () => {
+            // Use scores that create a mean drift: baseline stable at 0.8, then drop to 0.3
+            const buckets = makeBuckets([TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_LOW, TEST_SCORE_LOW, TEST_SCORE_LOW]);
+            const stateWithBreaches = {
+                lastRun: '2026-03-01T00:00:00Z',
+                breaches: { relevance: 1 },
+            };
+            const reports = computeRollingDegradationSignals({ relevance: buckets }, ['relevance'], stateWithBreaches, window);
+            assert.strictEqual(reports.length, 1);
+            // EWMA drift is reliably detected for this data (baseline=0.8, current drops to 0.3;
+            // MAD=0 fallback: |0.665 - 0.8| = 0.135 > 0.1 * 0.5 range = 0.05).
+            // With priorBreaches=1, consecutiveBreaches=2 => confirmed=true.
+            assert.strictEqual(reports[0].signal.predictedStatus, 'warning');
+            assert.strictEqual(reports[0].signal.consecutiveBreaches, COUNT_TWO);
+            assert.strictEqual(reports[0].signal.confirmed, true);
+        });
+        it('processes multiple metrics independently', () => {
+            const reports = computeRollingDegradationSignals({
+                relevance: makeBuckets([TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD]),
+                coherence: makeBuckets([TEST_SCORE_PASSING, TEST_SCORE_PASSING, TEST_SCORE_PASSING, TEST_SCORE_PASSING, TEST_SCORE_PASSING]),
+            }, ['relevance', 'coherence'], emptyState, window);
+            assert.strictEqual(reports.length, COUNT_TWO);
+            assert.strictEqual(reports[0].metricName, 'relevance');
+            assert.strictEqual(reports[1].metricName, 'coherence');
+        });
+        it('returns evaluation count across all buckets', () => {
+            const buckets = makeBuckets([TEST_SCORE_GOOD, TEST_SCORE_GOOD, TEST_SCORE_GOOD], COUNT_FIVE);
+            const reports = computeRollingDegradationSignals({ relevance: buckets }, ['relevance'], emptyState, window);
+            assert.strictEqual(reports[0].evaluationCount, COUNT_FIFTEEN); // 3 buckets × 5 scores
+        });
+        it('skips missing metrics gracefully', () => {
+            const reports = computeRollingDegradationSignals({}, ['nonexistent'], emptyState, window);
+            assert.strictEqual(reports.length, 0);
+        });
+    });
+    // ==========================================================================
+    // FE-R1: computePSI
+    // ==========================================================================
+    describe('computePSI', () => {
+        const PSI_SHIFTED_VALUE = 0.95;
+        const PSI_OUT_OF_RANGE_VALUE = 5.0;
+        /** Build an array of n values uniformly spread [0, 1) */
+        function uniform(n) {
+            return Array.from({ length: n }, (_, i) => i / n);
+        }
+        /** Build an array of n values all clustered near 1 (shifted distribution) */
+        function shifted(n) {
+            return Array.from({ length: n }, () => PSI_SHIFTED_VALUE);
+        }
+        it('returns psi=0 and drifted=false for identical distributions', () => {
+            const data = uniform(COUNT_HUNDRED);
+            const result = computePSI(data, data);
+            assert.strictEqual(result.psi, 0);
+            assert.strictEqual(result.drifted, false);
+        });
+        it('returns drifted=true when distribution has shifted significantly', () => {
+            const baseline = uniform(COUNT_HUNDRED);
+            const current = shifted(COUNT_HUNDRED);
+            const result = computePSI(baseline, current);
+            assert.ok(result.psi > PSI_RECALIBRATION_THRESHOLD, `expected psi > ${PSI_RECALIBRATION_THRESHOLD}, got ${result.psi}`);
+            assert.strictEqual(result.drifted, true);
+        });
+        it('returns { psi: 0, drifted: false } when expected array is too small', () => {
+            const small = uniform(MIN_QUANTILE_SAMPLE_SIZE - 1);
+            const large = uniform(COUNT_HUNDRED);
+            const result = computePSI(small, large);
+            assert.strictEqual(result.psi, 0);
+            assert.strictEqual(result.drifted, false);
+        });
+        it('returns { psi: 0, drifted: false } when actual array is too small', () => {
+            const large = uniform(COUNT_HUNDRED);
+            const small = uniform(MIN_QUANTILE_SAMPLE_SIZE - 1);
+            const result = computePSI(large, small);
+            assert.strictEqual(result.psi, 0);
+            assert.strictEqual(result.drifted, false);
+        });
+        it('clamps out-of-range values into the boundary bins without throwing', () => {
+            // Values > 1.0 (e.g. latency in seconds) map to the last bin via Math.min clamp
+            const outOfRange = Array.from({ length: COUNT_HUNDRED }, () => PSI_OUT_OF_RANGE_VALUE);
+            const baseline = uniform(COUNT_HUNDRED);
+            assert.doesNotThrow(() => computePSI(baseline, outOfRange));
+            const result = computePSI(baseline, outOfRange);
+            assert.ok(result.psi >= 0);
+        });
+        it('psi is non-negative for all valid inputs', () => {
+            const a = Array.from({ length: COUNT_HUNDRED }, () => Math.random());
+            const b = Array.from({ length: COUNT_HUNDRED }, () => Math.random());
+            const result = computePSI(a, b);
+            assert.ok(result.psi >= 0, `expected non-negative psi, got ${result.psi}`);
+        });
+    });
+    // ==========================================================================
+    // FE-R1: computeCalibrationDistributions
+    // ==========================================================================
+    describe('computeCalibrationDistributions', () => {
+        /** Build n scores uniformly spread [0, 1) */
+        function makeScores(n) {
+            return Array.from({ length: n }, (_, i) => i / n);
+        }
+        it('returns distribution for metric with >= 100 scores', () => {
+            const result = computeCalibrationDistributions({ relevance: makeScores(COUNT_HUNDRED) });
+            assert.ok(result['relevance'], 'expected distribution entry for relevance');
+            assert.strictEqual(result['relevance'].sampleSize, COUNT_HUNDRED);
+            const { p10, p25, p50, p75, p90 } = result['relevance'].distribution;
+            assert.ok(p10 < p25 && p25 < p50 && p50 < p75 && p75 < p90, 'percentiles should be monotonically increasing');
+        });
+        it('skips metric with fewer than MIN_QUANTILE_SAMPLE_SIZE scores', () => {
+            const result = computeCalibrationDistributions({ relevance: makeScores(MIN_QUANTILE_SAMPLE_SIZE - 1) });
+            assert.strictEqual(result['relevance'], undefined);
+        });
+        it('returns empty object for empty input', () => {
+            const result = computeCalibrationDistributions({});
+            assert.deepStrictEqual(result, {});
+        });
+        it('handles mixed metrics — only qualifying ones included', () => {
+            const result = computeCalibrationDistributions({
+                relevance: makeScores(COUNT_HUNDRED),
+                coherence: makeScores(MIN_QUANTILE_SAMPLE_SIZE - 1), // below threshold
+            });
+            assert.ok(result['relevance'], 'relevance should be included');
+            assert.strictEqual(result['coherence'], undefined, 'coherence should be excluded');
+        });
+        it('populates windowStart and windowEnd on each entry', () => {
+            const result = computeCalibrationDistributions({ relevance: makeScores(COUNT_HUNDRED) });
+            const entry = result['relevance'];
+            assert.ok(entry, 'expected entry');
+            assert.ok(entry.windowStart, 'expected windowStart');
+            assert.ok(entry.windowEnd, 'expected windowEnd');
+            assert.ok(new Date(entry.windowStart) < new Date(entry.windowEnd), 'windowStart should precede windowEnd');
+        });
+    });
+    // ==========================================================================
+    // FE-R1-PSI: shouldRecalibrate — PSI-based drift gating
+    // ==========================================================================
+    describe('shouldRecalibrate', () => {
+        /** Build n uniformly-spread scores in [0, 1) */
+        function makeUniformScores(n) {
+            return Array.from({ length: n }, (_, i) => i / n);
+        }
+        /** Build n scores tightly clustered near 0.9 (shifted distribution) */
+        function makeShiftedScores(n) {
+            return Array.from({ length: n }, (_, i) => 0.85 + (i / n) * 0.1);
+        }
+        const LARGE_SAMPLE = 200;
+        it('returns shouldWrite: true when previousState is null (first run)', () => {
+            const currentScores = { relevance: makeUniformScores(LARGE_SAMPLE) };
+            const result = shouldRecalibrate(null, currentScores);
+            assert.strictEqual(result.shouldWrite, true);
+        });
+        it('returns psiValues as empty object when previousState is null', () => {
+            const currentScores = { relevance: makeUniformScores(LARGE_SAMPLE) };
+            const result = shouldRecalibrate(null, currentScores);
+            assert.deepStrictEqual(result.psiValues, {});
+        });
+        it('returns shouldWrite: false when all metrics have PSI <= threshold (stable distribution)', () => {
+            const scores = makeUniformScores(LARGE_SAMPLE);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                rawScores: { relevance: scores },
+            };
+            // Same distribution — PSI should be ~0
+            const result = shouldRecalibrate(previousState, { relevance: scores });
+            assert.strictEqual(result.shouldWrite, false);
+        });
+        it('returns shouldWrite: true when any metric PSI exceeds threshold (shifted distribution)', () => {
+            const previousScores = makeUniformScores(LARGE_SAMPLE);
+            const currentScores = makeShiftedScores(LARGE_SAMPLE);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                rawScores: { relevance: previousScores },
+            };
+            const result = shouldRecalibrate(previousState, { relevance: currentScores });
+            assert.strictEqual(result.shouldWrite, true);
+        });
+        it('returns shouldWrite: true when one metric drifts even if another is stable', () => {
+            const stableScores = makeUniformScores(LARGE_SAMPLE);
+            const driftedScores = makeShiftedScores(LARGE_SAMPLE);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                    coherence: {
+                        distribution: { p10: 0.85, p25: 0.87, p50: 0.89, p75: 0.91, p90: 0.94 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                rawScores: {
+                    relevance: stableScores,
+                    coherence: driftedScores,
+                },
+            };
+            // relevance is stable, coherence has drifted back toward uniform
+            const result = shouldRecalibrate(previousState, {
+                relevance: stableScores,
+                coherence: stableScores,
+            });
+            assert.strictEqual(result.shouldWrite, true);
+        });
+        it('populates psiValues keyed by metric name when previousState has rawScores', () => {
+            const scores = makeUniformScores(LARGE_SAMPLE);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                rawScores: { relevance: scores },
+            };
+            const result = shouldRecalibrate(previousState, { relevance: scores });
+            assert.ok('relevance' in result.psiValues, 'expected psiValues to contain relevance key');
+            assert.ok(typeof result.psiValues['relevance'] === 'number', 'expected numeric PSI for relevance');
+        });
+        it('returns shouldWrite: true when previousState has no rawScores for a metric (cannot compare)', () => {
+            const currentScores = makeUniformScores(LARGE_SAMPLE);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                // rawScores absent
+            };
+            const result = shouldRecalibrate(previousState, { relevance: currentScores });
+            assert.strictEqual(result.shouldWrite, true);
+        });
+        it('returns shouldWrite: true and preserves psiValues when a new metric appears in currentScores', () => {
+            const stableScores = makeUniformScores(LARGE_SAMPLE);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                rawScores: { relevance: stableScores },
+            };
+            // 'coherence' is a new metric not in rawScores — should trigger write
+            // but preserve PSI computed for 'relevance'
+            const result = shouldRecalibrate(previousState, {
+                relevance: stableScores,
+                coherence: makeUniformScores(LARGE_SAMPLE),
+            });
+            assert.strictEqual(result.shouldWrite, true);
+            assert.ok('relevance' in result.psiValues, 'expected psiValues to contain relevance key');
+            assert.ok(typeof result.psiValues['relevance'] === 'number', 'expected numeric PSI for relevance');
+        });
+        it('returns shouldWrite: false when current scores are below MIN_QUANTILE_SAMPLE_SIZE (cannot compute PSI)', () => {
+            const tinyScores = makeUniformScores(MIN_QUANTILE_SAMPLE_SIZE - 1);
+            const previousState = {
+                lastCalibrated: '2026-03-10T00:00:00.000Z',
+                distributions: {
+                    relevance: {
+                        distribution: { p10: 0.1, p25: 0.25, p50: 0.5, p75: 0.75, p90: 0.9 },
+                        sampleSize: LARGE_SAMPLE,
+                        windowStart: '2026-02-08T00:00:00.000Z',
+                        windowEnd: '2026-03-10T00:00:00.000Z',
+                    },
+                },
+                rawScores: { relevance: makeUniformScores(LARGE_SAMPLE) },
+            };
+            // computePSI returns { psi: 0, drifted: false } for small samples — no drift detected
+            const result = shouldRecalibrate(previousState, { relevance: tinyScores });
+            assert.strictEqual(result.shouldWrite, false);
+        });
+    });
+    // ==========================================================================
+    // FE-R2: AHP-CRITIC CQI Weight Tuning
+    // ==========================================================================
+    // --- tunedCQIWeightsSchema ---
+    describe('tunedCQIWeightsSchema', () => {
+        it('validates a well-formed TunedCQIWeights object', () => {
+            const valid = {
+                featureVersion: '2.0',
+                weights: { relevance: 0.5, coherence: 0.5 },
+                ahpWeights: { relevance: 0.5, coherence: 0.5 },
+                criticWeights: { relevance: 0.5, coherence: 0.5 },
+                alpha: 0.5,
+                consistencyRatio: 0.03,
+                incidentCorrelations: { relevance: 0.2, coherence: 0.1 },
+            };
+            const result = tunedCQIWeightsSchema.safeParse(valid);
+            assert.ok(result.success, `Expected valid, got: ${JSON.stringify(result.error?.issues)}`);
+        });
+        it('accepts output of computeHybridCQIWeights', () => {
+            const ahp = { relevance: 0.6, coherence: 0.4 };
+            const critic = { relevance: 0.5, coherence: 0.5 };
+            const incidents = [];
+            const tuned = computeHybridCQIWeights(ahp, critic, incidents, ['relevance', 'coherence']);
+            const result = tunedCQIWeightsSchema.safeParse(tuned);
+            assert.ok(result.success, `Schema should accept computeHybridCQIWeights output, got: ${JSON.stringify(result.error?.issues)}`);
+        });
+        it('rejects missing required fields', () => {
+            const missing = {
+                featureVersion: '2.0',
+                weights: { relevance: 0.5 },
+            };
+            const result = tunedCQIWeightsSchema.safeParse(missing);
+            assert.ok(!result.success);
+        });
+        it('rejects weights outside 0-1 range', () => {
+            const invalid = {
+                featureVersion: '2.0',
+                weights: { relevance: 1.5 },
+                ahpWeights: { relevance: 0.5 },
+                criticWeights: { relevance: 0.5 },
+                alpha: 0.5,
+                consistencyRatio: 0,
+                incidentCorrelations: { relevance: 0 },
+            };
+            const result = tunedCQIWeightsSchema.safeParse(invalid);
+            assert.ok(!result.success);
+        });
+    });
+    // --- computeAHPWeights ---
+    describe('computeAHPWeights', () => {
+        const AHP_WEIGHT_TOLERANCE = 1e-6;
+        it('weights sum to 1.0 for two metrics with equal preference', () => {
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 1, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence']);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < AHP_WEIGHT_TOLERANCE, `weights sum ${sum} should be 1.0`);
+        });
+        it('returns equal weights when all comparisons have preference=1', () => {
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 1, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 1, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 1, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            const expectedWeight = 1 / 3;
+            for (const metric of ['relevance', 'coherence', 'completeness']) {
+                assert.ok(Math.abs((result.weights[metric] ?? 0) - expectedWeight) < AHP_WEIGHT_TOLERANCE, `${metric} weight ${result.weights[metric]} should be ~${expectedWeight}`);
+            }
+        });
+        it('strongly preferred metric gets highest weight', () => {
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 9, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 9, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 1, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            const relevanceWeight = result.weights['relevance'] ?? 0;
+            const coherenceWeight = result.weights['coherence'] ?? 0;
+            const completenessWeight = result.weights['completeness'] ?? 0;
+            assert.ok(relevanceWeight > coherenceWeight, 'relevance should outweigh coherence');
+            assert.ok(relevanceWeight > completenessWeight, 'relevance should outweigh completeness');
+        });
+        it('consistent comparisons produce CR < 0.1', () => {
+            // Perfectly consistent: A>B by 3, A>C by 9, B>C by 3 (3*3=9)
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 3, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 9, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 3, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            assert.ok(result.consistencyRatio < 0.1, `CR ${result.consistencyRatio} should be < 0.1`);
+        });
+        it('inconsistent comparisons produce CR > 0.1', () => {
+            // Contradictory: A>>B, B>>C, but C>>A (cycle)
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 9, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 9, preferred: 'A' },
+                { metricA: 'completeness', metricB: 'relevance', preference: 9, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            assert.ok(result.consistencyRatio > 0.1, `CR ${result.consistencyRatio} should be > 0.1`);
+        });
+        it('empty comparisons return equal weights', () => {
+            const result = computeAHPWeights([], ['relevance', 'coherence']);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < AHP_WEIGHT_TOLERANCE, `weights sum ${sum} should be 1.0`);
+            assert.ok(Math.abs((result.weights['relevance'] ?? 0) - 0.5) < AHP_WEIGHT_TOLERANCE, 'relevance weight should be 0.5 with empty comparisons');
+            assert.ok(Math.abs((result.weights['coherence'] ?? 0) - 0.5) < AHP_WEIGHT_TOLERANCE, 'coherence weight should be 0.5 with empty comparisons');
+        });
+        it('weights sum to 1.0 for four metrics', () => {
+            const metrics = ['relevance', 'coherence', 'completeness', 'groundedness'];
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 3, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 5, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'groundedness', preference: 7, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 3, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'groundedness', preference: 5, preferred: 'A' },
+                { metricA: 'completeness', metricB: 'groundedness', preference: 3, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, metrics);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < AHP_WEIGHT_TOLERANCE, `weights sum ${sum} should be 1.0`);
+        });
+        it('geometric means computation is stable (pipe refactoring)', () => {
+            // Test with standard AHP scale preferences (1, 3, 5, 7, 9)
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 3, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 5, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 3, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            const relevanceWeight = result.weights['relevance'] ?? 0;
+            const coherenceWeight = result.weights['coherence'] ?? 0;
+            const completenessWeight = result.weights['completeness'] ?? 0;
+            // Verify weights maintain expected ordering from preferences
+            assert.ok(relevanceWeight > coherenceWeight, 'relevance should outweigh coherence');
+            assert.ok(coherenceWeight > completenessWeight, 'coherence should outweigh completeness');
+            assert.ok(relevanceWeight > completenessWeight, 'relevance should outweigh completeness');
+        });
+        it('handles minimal preference values in geometric mean', () => {
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 1, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 1, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 1, preferred: 'A' },
+            ];
+            const result = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < AHP_WEIGHT_TOLERANCE, `equal preferences should produce sum=1.0, got ${sum}`);
+            const expectedWeight = 1 / 3;
+            for (const metric of ['relevance', 'coherence', 'completeness']) {
+                assert.ok(Math.abs((result.weights[metric] ?? 0) - expectedWeight) < AHP_WEIGHT_TOLERANCE, `metric ${metric} should have equal weight ~${expectedWeight}, got ${result.weights[metric]}`);
+            }
+        });
+        it('weights remain normalized across multiple invocations (consistency)', () => {
+            const comparisons = [
+                { metricA: 'relevance', metricB: 'coherence', preference: 3, preferred: 'A' },
+                { metricA: 'relevance', metricB: 'completeness', preference: 5, preferred: 'A' },
+                { metricA: 'coherence', metricB: 'completeness', preference: 3, preferred: 'A' },
+            ];
+            // Call multiple times to ensure consistency
+            const result1 = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            const result2 = computeAHPWeights(comparisons, ['relevance', 'coherence', 'completeness']);
+            for (const metric of ['relevance', 'coherence', 'completeness']) {
+                assert.strictEqual(result1.weights[metric], result2.weights[metric], `weight for ${metric} should be identical across calls`);
+            }
+            // Verify final sum is correct
+            const sum1 = Object.values(result1.weights).reduce((acc, v) => acc + v, 0);
+            const sum2 = Object.values(result2.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum1 - 1.0) < AHP_WEIGHT_TOLERANCE, `result1 should sum to 1.0`);
+            assert.ok(Math.abs(sum2 - 1.0) < AHP_WEIGHT_TOLERANCE, `result2 should sum to 1.0`);
+        });
+    });
+    // --- computeCRITICWeights ---
+    describe('computeCRITICWeights', () => {
+        const CRITIC_WEIGHT_TOLERANCE = 1e-6;
+        it('weights sum to 1.0', () => {
+            const history = {
+                relevance: [0.7, 0.8, 0.6, 0.9, 0.5],
+                coherence: [0.6, 0.7, 0.8, 0.5, 0.9],
+            };
+            const result = computeCRITICWeights(history);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < CRITIC_WEIGHT_TOLERANCE, `weights sum ${sum} should be 1.0`);
+        });
+        it('single metric returns weight of 1.0', () => {
+            const history = {
+                relevance: [0.7, 0.8, 0.6, 0.9, 0.5],
+            };
+            const result = computeCRITICWeights(history);
+            assert.ok(Math.abs((result.weights['relevance'] ?? 0) - 1.0) < CRITIC_WEIGHT_TOLERANCE, `single metric weight should be 1.0, got ${result.weights['relevance']}`);
+        });
+        it('uniform data produces equal weights', () => {
+            const history = {
+                relevance: [0.8, 0.8, 0.8, 0.8, 0.8],
+                coherence: [0.7, 0.7, 0.7, 0.7, 0.7],
+            };
+            const result = computeCRITICWeights(history);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < CRITIC_WEIGHT_TOLERANCE, `weights sum ${sum} should be 1.0`);
+        });
+        it('high-variance uncorrelated metric gets highest weight', () => {
+            // relevance has high variance, completeness is near-constant
+            const history = {
+                relevance: [0.1, 0.9, 0.2, 0.8, 0.3, 0.7, 0.1, 0.9],
+                completeness: [0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6],
+            };
+            const result = computeCRITICWeights(history);
+            assert.ok((result.weights['relevance'] ?? 0) > (result.weights['completeness'] ?? 0), `relevance weight ${result.weights['relevance']} should exceed completeness ${result.weights['completeness']}`);
+        });
+        it('perfectly correlated metrics produce lower weight than uncorrelated metrics', () => {
+            // metricA and metricB are identical (perfectly correlated)
+            // metricC is uncorrelated with same variance
+            const base = [0.1, 0.9, 0.2, 0.8, 0.3, 0.7, 0.15, 0.85];
+            const uncorrelated = [0.8, 0.2, 0.9, 0.1, 0.7, 0.3, 0.85, 0.15];
+            const history = {
+                metricA: base,
+                metricB: [...base],
+                metricC: uncorrelated,
+            };
+            const result = computeCRITICWeights(history);
+            const weightC = result.weights['metricC'] ?? 0;
+            const weightA = result.weights['metricA'] ?? 0;
+            assert.ok(weightC > weightA, `uncorrelated metricC weight ${weightC} should exceed correlated metricA weight ${weightA}`);
+        });
+        it('informationContent is present for each metric', () => {
+            const history = {
+                relevance: [0.7, 0.8, 0.6, 0.9, 0.5],
+                coherence: [0.6, 0.7, 0.8, 0.5, 0.9],
+            };
+            const result = computeCRITICWeights(history);
+            assert.ok('relevance' in result.informationContent, 'informationContent should contain relevance');
+            assert.ok('coherence' in result.informationContent, 'informationContent should contain coherence');
+            assert.strictEqual(typeof result.informationContent['relevance'], 'number');
+        });
+    });
+    // --- computeHybridCQIWeights ---
+    describe('computeHybridCQIWeights', () => {
+        const HYBRID_WEIGHT_TOLERANCE = 1e-6;
+        const metrics = ['relevance', 'coherence'];
+        const ahpWeights = { relevance: 0.7, coherence: 0.3 };
+        const criticWeights = { relevance: 0.4, coherence: 0.6 };
+        it('featureVersion is "2.0"', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics);
+            assert.strictEqual(result.featureVersion, '2.0');
+        });
+        it('alpha=1.0 produces weights equal to AHP weights', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics, 1.0);
+            assert.ok(Math.abs((result.weights['relevance'] ?? 0) - (ahpWeights['relevance'] ?? 0)) < HYBRID_WEIGHT_TOLERANCE, `relevance weight should match AHP: ${result.weights['relevance']} vs ${ahpWeights['relevance']}`);
+            assert.ok(Math.abs((result.weights['coherence'] ?? 0) - (ahpWeights['coherence'] ?? 0)) < HYBRID_WEIGHT_TOLERANCE, `coherence weight should match AHP: ${result.weights['coherence']} vs ${ahpWeights['coherence']}`);
+        });
+        it('alpha=0.0 produces weights equal to CRITIC weights', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics, 0.0);
+            assert.ok(Math.abs((result.weights['relevance'] ?? 0) - (criticWeights['relevance'] ?? 0)) < HYBRID_WEIGHT_TOLERANCE, `relevance weight should match CRITIC: ${result.weights['relevance']} vs ${criticWeights['relevance']}`);
+            assert.ok(Math.abs((result.weights['coherence'] ?? 0) - (criticWeights['coherence'] ?? 0)) < HYBRID_WEIGHT_TOLERANCE, `coherence weight should match CRITIC: ${result.weights['coherence']} vs ${criticWeights['coherence']}`);
+        });
+        it('alpha=0.5 produces midpoint blend of AHP and CRITIC weights', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics, 0.5);
+            const expectedRelevance = 0.5 * (ahpWeights['relevance'] ?? 0) + 0.5 * (criticWeights['relevance'] ?? 0);
+            const expectedCoherence = 0.5 * (ahpWeights['coherence'] ?? 0) + 0.5 * (criticWeights['coherence'] ?? 0);
+            assert.ok(Math.abs((result.weights['relevance'] ?? 0) - expectedRelevance) < HYBRID_WEIGHT_TOLERANCE, `relevance ${result.weights['relevance']} should be midpoint ${expectedRelevance}`);
+            assert.ok(Math.abs((result.weights['coherence'] ?? 0) - expectedCoherence) < HYBRID_WEIGHT_TOLERANCE, `coherence ${result.weights['coherence']} should be midpoint ${expectedCoherence}`);
+        });
+        it('default alpha is 0.5', () => {
+            const withDefault = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics);
+            const withExplicit = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics, 0.5);
+            assert.deepStrictEqual(withDefault.weights, withExplicit.weights);
+        });
+        it('weights sum to 1.0', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics, 0.5);
+            const sum = Object.values(result.weights).reduce((acc, v) => acc + v, 0);
+            assert.ok(Math.abs(sum - 1.0) < HYBRID_WEIGHT_TOLERANCE, `weights sum ${sum} should be 1.0`);
+        });
+        it('empty incidents produce incidentCorrelations of 0 for each metric', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics);
+            assert.ok('relevance' in result.incidentCorrelations, 'incidentCorrelations should include relevance');
+            assert.ok('coherence' in result.incidentCorrelations, 'incidentCorrelations should include coherence');
+            assert.strictEqual(result.incidentCorrelations['relevance'], 0);
+            assert.strictEqual(result.incidentCorrelations['coherence'], 0);
+        });
+        it('metric that drops before incidents gets higher correlation than stable metric', () => {
+            const incidents = [
+                {
+                    timestamp: '2026-03-10T00:00:00.000Z',
+                    metricScores: { relevance: 0.3, coherence: 0.75 },
+                    cqiValue: 0.4,
+                    severity: 'major',
+                },
+                {
+                    timestamp: '2026-03-15T00:00:00.000Z',
+                    metricScores: { relevance: 0.25, coherence: 0.78 },
+                    cqiValue: 0.35,
+                    severity: 'critical',
+                },
+            ];
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, incidents, metrics);
+            const relevanceCorr = result.incidentCorrelations['relevance'] ?? 0;
+            const coherenceCorr = result.incidentCorrelations['coherence'] ?? 0;
+            assert.ok(relevanceCorr > coherenceCorr, `relevance correlation ${relevanceCorr} should exceed coherence ${coherenceCorr} as relevance drops at incidents`);
+        });
+        it('returns ahpWeights and criticWeights fields on result', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics);
+            assert.deepStrictEqual(result.ahpWeights, ahpWeights);
+            assert.deepStrictEqual(result.criticWeights, criticWeights);
+        });
+        it('consistencyRatio field is present on result', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics);
+            assert.strictEqual(typeof result.consistencyRatio, 'number');
+        });
+        it('alpha field on result reflects the alpha used', () => {
+            const result = computeHybridCQIWeights(ahpWeights, criticWeights, [], metrics, 0.75);
+            assert.strictEqual(result.alpha, 0.75);
+        });
+    });
+    // --- computeTaPR ---
+    describe('computeTaPR', () => {
+        // Time constants (ms)
+        const T0 = 1_000_000;
+        const T1 = T0 + 1_000;
+        const T2 = T0 + 2_000;
+        const T3 = T0 + 3_000;
+        const T4 = T0 + 4_000;
+        const T5 = T0 + 5_000;
+        const T6 = T0 + 6_000;
+        const T7 = T0 + 7_000;
+        const T8 = T0 + 8_000;
+        const TAPR_TOLERANCE = 1e-9;
+        it('perfect detection: single detected range fully covering single incident → precision=1, recall=1, f1=1, detectionDelay=0', () => {
+            const detected = [{ start: T0, end: T4 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(Math.abs(result.precision - 1) < TAPR_TOLERANCE, `precision should be 1, got ${result.precision}`);
+            assert.ok(Math.abs(result.recall - 1) < TAPR_TOLERANCE, `recall should be 1, got ${result.recall}`);
+            assert.ok(Math.abs(result.f1 - 1) < TAPR_TOLERANCE, `f1 should be 1, got ${result.f1}`);
+            assert.ok(Math.abs(result.detectionDelay - 0) < TAPR_TOLERANCE, `detectionDelay should be 0, got ${result.detectionDelay}`);
+        });
+        it('no detections: recall=0, precision=0, f1=0', () => {
+            const detected = [];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.strictEqual(result.recall, 0, 'recall should be 0 with no detections');
+            assert.strictEqual(result.precision, 0, 'precision should be 0 with no detections');
+            assert.strictEqual(result.f1, 0, 'f1 should be 0 with no detections');
+        });
+        it('no incidents but detections: precision=0, recall=0, f1=0', () => {
+            const detected = [{ start: T0, end: T2 }];
+            const incidents = [];
+            const result = computeTaPR(detected, incidents);
+            assert.strictEqual(result.precision, 0, 'precision should be 0 when no incidents exist');
+            assert.strictEqual(result.recall, 0, 'recall should be 0 when no incidents exist');
+            assert.strictEqual(result.f1, 0, 'f1 should be 0 when no incidents exist');
+        });
+        it('partial overlap: precision and recall are strictly between 0 and 1', () => {
+            // Incident spans T0–T4 (4s), detection spans T2–T6 (4s), overlap T2–T4 (2s)
+            // Precision overlap ratio = 2s / 4s = 0.5
+            // Recall overlap ratio = 2s / 4s = 0.5
+            const detected = [{ start: T2, end: T6 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(result.precision > 0 && result.precision < 1, `precision ${result.precision} should be in (0,1)`);
+            assert.ok(result.recall > 0 && result.recall < 1, `recall ${result.recall} should be in (0,1)`);
+            assert.ok(result.f1 > 0 && result.f1 < 1, `f1 ${result.f1} should be in (0,1)`);
+        });
+        it('partial overlap: precision = overlap / detected duration', () => {
+            // Detection T2–T6 (4s), incident T0–T4 (4s), overlap T2–T4 = 2s
+            const DETECTED_DURATION_MS = T6 - T2; // 4000
+            const OVERLAP_MS = T4 - T2; // 2000
+            const EXPECTED_PRECISION = OVERLAP_MS / DETECTED_DURATION_MS; // 0.5
+            const detected = [{ start: T2, end: T6 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(Math.abs(result.precision - EXPECTED_PRECISION) < TAPR_TOLERANCE, `precision should be ${EXPECTED_PRECISION}, got ${result.precision}`);
+        });
+        it('partial overlap: recall = overlap / incident duration', () => {
+            // Detection T2–T6 (4s), incident T0–T4 (4s), overlap T2–T4 = 2s
+            const INCIDENT_DURATION_MS = T4 - T0; // 4000
+            const OVERLAP_MS = T4 - T2; // 2000
+            const EXPECTED_RECALL = OVERLAP_MS / INCIDENT_DURATION_MS; // 0.5
+            const detected = [{ start: T2, end: T6 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(Math.abs(result.recall - EXPECTED_RECALL) < TAPR_TOLERANCE, `recall should be ${EXPECTED_RECALL}, got ${result.recall}`);
+        });
+        it('detection delay: late detection (after incident start) equals gap between incident start and detection start', () => {
+            // Detection starts T2, incident starts T0 → delay = T2 - T0 = 2000ms
+            const EXPECTED_DELAY_MS = T2 - T0; // 2000
+            const detected = [{ start: T2, end: T6 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(Math.abs(result.detectionDelay - EXPECTED_DELAY_MS) < TAPR_TOLERANCE, `detectionDelay should be ${EXPECTED_DELAY_MS}ms (late detection), got ${result.detectionDelay}`);
+        });
+        it('detection delay: early detection (before incident start) yields detectionDelay=0 (no negative delay)', () => {
+            // Detection starts T0, incident starts T2 — detection was early.
+            // Implementation clamps via Math.max(0, ...), so exact 0 expected.
+            const detected = [{ start: T0, end: T4 }];
+            const incidents = [{ start: T2, end: T6 }];
+            const result = computeTaPR(detected, incidents);
+            assert.strictEqual(result.detectionDelay, 0, 'early detection should clamp detectionDelay to 0, not produce a negative value');
+        });
+        it('f1 is harmonic mean of precision and recall', () => {
+            const detected = [{ start: T2, end: T6 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            if (result.precision + result.recall > 0) {
+                const expectedF1 = 2 * result.precision * result.recall / (result.precision + result.recall);
+                assert.ok(Math.abs(result.f1 - expectedF1) < TAPR_TOLERANCE, `f1 ${result.f1} should equal harmonic mean ${expectedF1}`);
+            }
+        });
+        it('multiple incidents: incident with no overlapping detection is excluded from delay average', () => {
+            // Two incidents: T0–T2 detected by T0–T2 (delay=0), T5–T7 has no detection
+            // detectionDelay should only reflect the incident that was detected
+            const detected = [{ start: T0, end: T2 }];
+            const incidents = [
+                { start: T0, end: T2 }, // detected
+                { start: T5, end: T7 }, // missed
+            ];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(result.recall < 1, `recall ${result.recall} should be < 1 because second incident is missed`);
+            assert.ok(Math.abs(result.detectionDelay - 0) < TAPR_TOLERANCE, `detectionDelay should be 0 (only detected incident counted), got ${result.detectionDelay}`);
+        });
+        it('multiple incidents with partial coverage: recall < 1', () => {
+            // Three incidents; only first two are partially detected
+            const detected = [
+                { start: T0, end: T2 }, // overlaps incident 1 (T0–T3) partially
+                { start: T3, end: T5 }, // overlaps incident 2 (T3–T6) partially
+            ];
+            const incidents = [
+                { start: T0, end: T3 }, // partially detected
+                { start: T3, end: T6 }, // partially detected
+                { start: T6, end: T8 }, // fully missed
+            ];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(result.recall < 1, `recall ${result.recall} should be < 1 with partially-covered incidents`);
+            assert.ok(result.recall > 0, `recall ${result.recall} should be > 0 with some overlapping detections`);
+        });
+        it('empty inputs: precision=0, recall=0, f1=0', () => {
+            const result = computeTaPR([], []);
+            assert.strictEqual(result.precision, 0);
+            assert.strictEqual(result.recall, 0);
+            assert.strictEqual(result.f1, 0);
+        });
+        it('detection that only partially enters incident boundary: detection delay reflects first overlap point', () => {
+            // Detection T1–T5, incident T0–T2
+            // Detection starts after incident; delay = T1 - T0 = 1000ms
+            const EXPECTED_DELAY_MS = T1 - T0; // 1000
+            const detected = [{ start: T1, end: T5 }];
+            const incidents = [{ start: T0, end: T2 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(Math.abs(result.detectionDelay - EXPECTED_DELAY_MS) < TAPR_TOLERANCE, `detectionDelay should be ${EXPECTED_DELAY_MS}ms, got ${result.detectionDelay}`);
+        });
+        it('detection starting exactly at incident start: detectionDelay=0', () => {
+            const detected = [{ start: T0, end: T4 }];
+            const incidents = [{ start: T0, end: T4 }];
+            const result = computeTaPR(detected, incidents);
+            assert.strictEqual(result.detectionDelay, 0, 'detectionDelay should be 0 when detection starts at incident start');
+        });
+        it('detection half-inside incident boundary: precision reflects only overlapping portion', () => {
+            // Detection T0–T4 (4s), incident T2–T6 (4s), overlap T2–T4 = 2s
+            const DETECTED_DURATION_MS = T4 - T0; // 4000
+            const OVERLAP_MS = T4 - T2; // 2000
+            const EXPECTED_PRECISION = OVERLAP_MS / DETECTED_DURATION_MS; // 0.5
+            const detected = [{ start: T0, end: T4 }];
+            const incidents = [{ start: T2, end: T6 }];
+            const result = computeTaPR(detected, incidents);
+            assert.ok(Math.abs(result.precision - EXPECTED_PRECISION) < TAPR_TOLERANCE, `precision should be ${EXPECTED_PRECISION}, got ${result.precision}`);
+        });
+    });
+    // --- backtestDegradationConfig ---
+    describe('backtestDegradationConfig', () => {
+        // Timestamps: 1-second intervals starting at a fixed epoch
+        const BASE_TIME_MS = 1_700_000_000_000;
+        const STEP_MS = 1_000;
+        // Config constants
+        const PRODUCTION_VARIANCE_THRESHOLD = 2.0;
+        const PRODUCTION_COVERAGE_THRESHOLD = 0.3;
+        const PRODUCTION_LATENCY_SKEW_THRESHOLD = 3.0;
+        const PRODUCTION_CONFIRMATION_WINDOW = 2;
+        const PRODUCTION_EWMA_LAMBDA = 0.1;
+        const PRODUCTION_STABILITY_THRESHOLD = 2.0;
+        const SENSITIVE_VARIANCE_THRESHOLD = 1.05;
+        const SENSITIVE_COVERAGE_THRESHOLD = 0.01;
+        const SENSITIVE_LATENCY_SKEW_THRESHOLD = 1.1;
+        const SENSITIVE_CONFIRMATION_WINDOW = 1;
+        const CONSERVATIVE_VARIANCE_THRESHOLD = 10.0;
+        const CONSERVATIVE_COVERAGE_THRESHOLD = 0.95;
+        const CONSERVATIVE_LATENCY_SKEW_THRESHOLD = 20.0;
+        const CONSERVATIVE_CONFIRMATION_WINDOW = 5;
+        // Signal values
+        const NORMAL_STD_DEV = 0.05;
+        const DEGRADED_STD_DEV = 0.50;
+        const BASELINE_STD_DEV = 0.10;
+        const NORMAL_COVERAGE_GAPS = 0;
+        const DEGRADED_COVERAGE_GAPS = 50;
+        const TOTAL_COVERAGE_CELLS = 100;
+        const NORMAL_LATENCY_P95 = 0.2;
+        const NORMAL_LATENCY_P50 = 0.1;
+        const DEGRADED_LATENCY_P95 = 0.9;
+        // Series lengths
+        const SERIES_LENGTH_TWENTY = 20;
+        const SERIES_LENGTH_THIRTY = 30;
+        const DEGRADED_START_IDX = 8;
+        const DEGRADED_END_IDX = 16; // exclusive
+        const FLOAT_TOLERANCE = 1e-9;
+        function isoAt(offsetMs) {
+            return new Date(BASE_TIME_MS + offsetMs).toISOString();
+        }
+        function makePoint(degraded, ts) {
+            return {
+                timestamp: ts,
+                currentStdDev: degraded ? DEGRADED_STD_DEV : NORMAL_STD_DEV,
+                baselineStdDev: BASELINE_STD_DEV,
+                coverageGapCount: degraded ? DEGRADED_COVERAGE_GAPS : NORMAL_COVERAGE_GAPS,
+                totalCoverageCells: TOTAL_COVERAGE_CELLS,
+                latencyP95: degraded ? DEGRADED_LATENCY_P95 : NORMAL_LATENCY_P95,
+                latencyP50: NORMAL_LATENCY_P50,
+                historicalValues: degraded
+                    ? [0.8, 0.85, 0.9, 0.88, 0.91]
+                    : [0.5, 0.5, 0.51, 0.49, 0.5],
+            };
+        }
+        const productionConfig = {
+            varianceThreshold: PRODUCTION_VARIANCE_THRESHOLD,
+            coverageDropoutThreshold: PRODUCTION_COVERAGE_THRESHOLD,
+            latencySkewThreshold: PRODUCTION_LATENCY_SKEW_THRESHOLD,
+            confirmationWindow: PRODUCTION_CONFIRMATION_WINDOW,
+            ewmaLambda: PRODUCTION_EWMA_LAMBDA,
+            stabilityThreshold: PRODUCTION_STABILITY_THRESHOLD,
+        };
+        const sensitiveConfig = {
+            varianceThreshold: SENSITIVE_VARIANCE_THRESHOLD,
+            coverageDropoutThreshold: SENSITIVE_COVERAGE_THRESHOLD,
+            latencySkewThreshold: SENSITIVE_LATENCY_SKEW_THRESHOLD,
+            confirmationWindow: SENSITIVE_CONFIRMATION_WINDOW,
+            ewmaLambda: PRODUCTION_EWMA_LAMBDA,
+            stabilityThreshold: PRODUCTION_STABILITY_THRESHOLD,
+        };
+        const conservativeConfig = {
+            varianceThreshold: CONSERVATIVE_VARIANCE_THRESHOLD,
+            coverageDropoutThreshold: CONSERVATIVE_COVERAGE_THRESHOLD,
+            latencySkewThreshold: CONSERVATIVE_LATENCY_SKEW_THRESHOLD,
+            confirmationWindow: CONSERVATIVE_CONFIRMATION_WINDOW,
+            ewmaLambda: PRODUCTION_EWMA_LAMBDA,
+            stabilityThreshold: PRODUCTION_STABILITY_THRESHOLD,
+        };
+        it('production thresholds with known degradation period: detects true positives', () => {
+            const timeSeries = Array.from({ length: SERIES_LENGTH_TWENTY }, (_, i) => makePoint(i >= DEGRADED_START_IDX && i < DEGRADED_END_IDX, BASE_TIME_MS + i * STEP_MS));
+            const incidents = [{
+                    startTime: isoAt(DEGRADED_START_IDX * STEP_MS),
+                    endTime: isoAt((DEGRADED_END_IDX - 1) * STEP_MS),
+                    severity: 'major',
+                }];
+            const result = backtestDegradationConfig(productionConfig, timeSeries, incidents);
+            assert.ok(result.truePositives > 0, `expected truePositives > 0, got ${result.truePositives}`);
+            assert.strictEqual(result.config, productionConfig);
+        });
+        it('sensitive config yields high recall (low thresholds trigger on normal variance)', () => {
+            const timeSeries = Array.from({ length: SERIES_LENGTH_TWENTY }, (_, i) => makePoint(i >= DEGRADED_START_IDX && i < DEGRADED_END_IDX, BASE_TIME_MS + i * STEP_MS));
+            const incidents = [{
+                    startTime: isoAt(DEGRADED_START_IDX * STEP_MS),
+                    endTime: isoAt((DEGRADED_END_IDX - 1) * STEP_MS),
+                    severity: 'minor',
+                }];
+            const sensitiveResult = backtestDegradationConfig(sensitiveConfig, timeSeries, incidents);
+            const productionResult = backtestDegradationConfig(productionConfig, timeSeries, incidents);
+            assert.ok(sensitiveResult.pointRecall >= productionResult.pointRecall, `sensitive recall ${sensitiveResult.pointRecall} should be >= production recall ${productionResult.pointRecall}`);
+            assert.ok(sensitiveResult.falsePositives >= productionResult.falsePositives, `sensitive FPs ${sensitiveResult.falsePositives} should be >= production FPs ${productionResult.falsePositives}`);
+        });
+        it('conservative config yields high precision but low recall (high thresholds miss incidents)', () => {
+            const timeSeries = Array.from({ length: SERIES_LENGTH_TWENTY }, (_, i) => makePoint(i >= DEGRADED_START_IDX && i < DEGRADED_END_IDX, BASE_TIME_MS + i * STEP_MS));
+            const incidents = [{
+                    startTime: isoAt(DEGRADED_START_IDX * STEP_MS),
+                    endTime: isoAt((DEGRADED_END_IDX - 1) * STEP_MS),
+                    severity: 'critical',
+                }];
+            const result = backtestDegradationConfig(conservativeConfig, timeSeries, incidents);
+            assert.ok(result.falseNegatives > 0, `expected falseNegatives > 0 with conservative config, got ${result.falseNegatives}`);
+        });
+        it('no incidents: all detections are false positives, pointRecall is 0', () => {
+            // Degraded signal throughout — but zero labeled incidents
+            const timeSeries = Array.from({ length: SERIES_LENGTH_TWENTY }, (_, i) => makePoint(true, BASE_TIME_MS + i * STEP_MS));
+            const incidents = [];
+            const result = backtestDegradationConfig(sensitiveConfig, timeSeries, incidents);
+            assert.strictEqual(result.pointRecall, 0, `pointRecall should be 0 with no incidents, got ${result.pointRecall}`);
+            assert.strictEqual(result.falseNegatives, 0, `falseNegatives should be 0 with no incidents, got ${result.falseNegatives}`);
+        });
+        it('all timestamps degraded and fully covered by incidents: high TP, pointPrecision near 1', () => {
+            const timeSeries = Array.from({ length: SERIES_LENGTH_TWENTY }, (_, i) => makePoint(true, BASE_TIME_MS + i * STEP_MS));
+            const incidents = [{
+                    startTime: isoAt(0),
+                    endTime: isoAt((SERIES_LENGTH_TWENTY - 1) * STEP_MS),
+                    severity: 'critical',
+                }];
+            const result = backtestDegradationConfig(sensitiveConfig, timeSeries, incidents);
+            assert.ok(result.truePositives > 0, `truePositives should be > 0, got ${result.truePositives}`);
+            assert.ok(result.pointPrecision > 0.5, `pointPrecision should be near 1 when all detections are incident-covered, got ${result.pointPrecision}`);
+        });
+        it('empty time series returns all-zero counts and metrics', () => {
+            const result = backtestDegradationConfig(productionConfig, [], []);
+            assert.strictEqual(result.truePositives, 0);
+            assert.strictEqual(result.falsePositives, 0);
+            assert.strictEqual(result.falseNegatives, 0);
+            assert.strictEqual(result.trueNegatives, 0);
+            assert.ok(Math.abs(result.pointPrecision - 0) < FLOAT_TOLERANCE, `pointPrecision should be 0, got ${result.pointPrecision}`);
+            assert.ok(Math.abs(result.pointRecall - 0) < FLOAT_TOLERANCE, `pointRecall should be 0, got ${result.pointRecall}`);
+            assert.ok(Math.abs(result.pointF1 - 0) < FLOAT_TOLERANCE, `pointF1 should be 0, got ${result.pointF1}`);
+            assert.strictEqual(result.tapr.precision, 0);
+            assert.strictEqual(result.tapr.recall, 0);
+            assert.strictEqual(result.tapr.f1, 0);
+        });
+        it('result config field references the same config object passed in', () => {
+            const result = backtestDegradationConfig(productionConfig, [], []);
+            assert.strictEqual(result.config, productionConfig);
+        });
+        it('pointF1 is harmonic mean of pointPrecision and pointRecall when both > 0', () => {
+            const timeSeries = Array.from({ length: SERIES_LENGTH_THIRTY }, (_, i) => makePoint(i >= DEGRADED_START_IDX && i < DEGRADED_END_IDX, BASE_TIME_MS + i * STEP_MS));
+            const incidents = [{
+                    startTime: isoAt(DEGRADED_START_IDX * STEP_MS),
+                    endTime: isoAt((DEGRADED_END_IDX - 1) * STEP_MS),
+                    severity: 'major',
+                }];
+            const result = backtestDegradationConfig(productionConfig, timeSeries, incidents);
+            if (result.pointPrecision + result.pointRecall > 0) {
+                const expectedF1 = 2 * result.pointPrecision * result.pointRecall
+                    / (result.pointPrecision + result.pointRecall);
+                assert.ok(Math.abs(result.pointF1 - expectedF1) < FLOAT_TOLERANCE, `pointF1 ${result.pointF1} should equal harmonic mean ${expectedF1}`);
+            }
+        });
+    });
+    // --- sweepDegradationParams ---
+    describe('sweepDegradationParams', () => {
+        // Shared time series: 8 points — small to keep sweep fast once implemented
+        const SWEEP_BASE_TIME_MS = 1_700_000_000_000;
+        const SWEEP_STEP_MS = 1_000;
+        const SWEEP_SERIES_LENGTH = 8;
+        const SWEEP_DEGRADED_START_IDX = 3;
+        const SWEEP_DEGRADED_END_IDX = 7; // exclusive
+        const SWEEP_NORMAL_STD_DEV = 0.05;
+        const SWEEP_DEGRADED_STD_DEV = 0.50;
+        const SWEEP_BASELINE_STD_DEV = 0.10;
+        const SWEEP_NORMAL_COVERAGE_GAPS = 0;
+        const SWEEP_DEGRADED_COVERAGE_GAPS = 50;
+        const SWEEP_TOTAL_COVERAGE_CELLS = 100;
+        const SWEEP_NORMAL_LATENCY_P95 = 0.2;
+        const SWEEP_NORMAL_LATENCY_P50 = 0.1;
+        const SWEEP_DEGRADED_LATENCY_P95 = 0.9;
+        const EXPECTED_SWEEP_TOTAL = BACKTEST_SWEEP.varianceThreshold.length *
+            BACKTEST_SWEEP.coverageDropoutThreshold.length *
+            BACKTEST_SWEEP.ewmaLambda.length *
+            BACKTEST_SWEEP.confirmationWindow.length *
+            BACKTEST_SWEEP.stabilityThreshold.length;
+        const FIXED_LATENCY_SKEW_THRESHOLD = LATENCY_SKEW_SIGNAL_THRESHOLD;
+        function makeSweepPoint(degraded, ts) {
+            return {
+                timestamp: ts,
+                currentStdDev: degraded ? SWEEP_DEGRADED_STD_DEV : SWEEP_NORMAL_STD_DEV,
+                baselineStdDev: SWEEP_BASELINE_STD_DEV,
+                coverageGapCount: degraded ? SWEEP_DEGRADED_COVERAGE_GAPS : SWEEP_NORMAL_COVERAGE_GAPS,
+                totalCoverageCells: SWEEP_TOTAL_COVERAGE_CELLS,
+                latencyP95: degraded ? SWEEP_DEGRADED_LATENCY_P95 : SWEEP_NORMAL_LATENCY_P95,
+                latencyP50: SWEEP_NORMAL_LATENCY_P50,
+                historicalValues: degraded
+                    ? [0.8, 0.85, 0.9, 0.88, 0.91]
+                    : [0.5, 0.5, 0.51, 0.49, 0.5],
+            };
+        }
+        function isoSweepAt(offsetMs) {
+            return new Date(SWEEP_BASE_TIME_MS + offsetMs).toISOString();
+        }
+        const sweepTimeSeries = Array.from({ length: SWEEP_SERIES_LENGTH }, (_, i) => makeSweepPoint(i >= SWEEP_DEGRADED_START_IDX && i < SWEEP_DEGRADED_END_IDX, SWEEP_BASE_TIME_MS + i * SWEEP_STEP_MS));
+        const sweepIncidents = [{
+                startTime: isoSweepAt(SWEEP_DEGRADED_START_IDX * SWEEP_STEP_MS),
+                endTime: isoSweepAt((SWEEP_DEGRADED_END_IDX - 1) * SWEEP_STEP_MS),
+                severity: 'major',
+            }];
+        it('results.length equals total grid size (2500)', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            assert.strictEqual(sweep.results.length, EXPECTED_SWEEP_TOTAL);
+        });
+        it('currentConfigResult is populated and matches the production config values', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            assert.strictEqual(sweep.currentConfigResult.config.varianceThreshold, CURRENT_PRODUCTION_CONFIG.varianceThreshold);
+            assert.strictEqual(sweep.currentConfigResult.config.coverageDropoutThreshold, CURRENT_PRODUCTION_CONFIG.coverageDropoutThreshold);
+            assert.strictEqual(sweep.currentConfigResult.config.ewmaLambda, CURRENT_PRODUCTION_CONFIG.ewmaLambda);
+            assert.strictEqual(sweep.currentConfigResult.config.confirmationWindow, CURRENT_PRODUCTION_CONFIG.confirmationWindow);
+        });
+        it('bestByF1 has tapr.f1 >= currentConfigResult.tapr.f1', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            assert.ok(sweep.bestByF1.tapr.f1 >= sweep.currentConfigResult.tapr.f1, `bestByF1.tapr.f1 (${sweep.bestByF1.tapr.f1}) should be >= currentConfigResult.tapr.f1 (${sweep.currentConfigResult.tapr.f1})`);
+        });
+        it('bestByRecall has tapr.recall >= bestByF1.tapr.recall', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            assert.ok(sweep.bestByRecall.tapr.recall >= sweep.bestByF1.tapr.recall, `bestByRecall.tapr.recall (${sweep.bestByRecall.tapr.recall}) should be >= bestByF1.tapr.recall (${sweep.bestByF1.tapr.recall})`);
+        });
+        it('all results have valid config objects with fields from the sweep grid', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            for (const result of sweep.results) {
+                assert.ok(BACKTEST_SWEEP.varianceThreshold.includes(result.config.varianceThreshold), `varianceThreshold ${result.config.varianceThreshold} not in sweep grid`);
+                assert.ok(BACKTEST_SWEEP.coverageDropoutThreshold.includes(result.config.coverageDropoutThreshold), `coverageDropoutThreshold ${result.config.coverageDropoutThreshold} not in sweep grid`);
+                assert.ok(BACKTEST_SWEEP.confirmationWindow.includes(result.config.confirmationWindow), `confirmationWindow ${result.config.confirmationWindow} not in sweep grid`);
+            }
+        });
+        it('latencySkewThreshold is fixed at 3 for all configs (not swept)', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            for (const result of sweep.results) {
+                assert.strictEqual(result.config.latencySkewThreshold, FIXED_LATENCY_SKEW_THRESHOLD, `latencySkewThreshold should be ${FIXED_LATENCY_SKEW_THRESHOLD}, got ${result.config.latencySkewThreshold}`);
+            }
+        });
+        it('empty time series produces results where all metrics are zero', () => {
+            const sweep = sweepDegradationParams([], []);
+            for (const result of sweep.results) {
+                assert.strictEqual(result.tapr.f1, 0, 'tapr.f1 should be 0 for empty series');
+                assert.strictEqual(result.tapr.precision, 0, 'tapr.precision should be 0 for empty series');
+                assert.strictEqual(result.tapr.recall, 0, 'tapr.recall should be 0 for empty series');
+            }
+        });
+        it('currentConfigResult is included in sweep results array', () => {
+            const sweep = sweepDegradationParams(sweepTimeSeries, sweepIncidents);
+            const found = sweep.results.some(r => r.config.varianceThreshold === sweep.currentConfigResult.config.varianceThreshold &&
+                r.config.coverageDropoutThreshold === sweep.currentConfigResult.config.coverageDropoutThreshold &&
+                r.config.ewmaLambda === sweep.currentConfigResult.config.ewmaLambda &&
+                r.config.confirmationWindow === sweep.currentConfigResult.config.confirmationWindow);
+            assert.ok(found, 'currentConfigResult config should appear in sweep results');
+        });
+    });
+    // --- sweepWithCrossValidation (FU-FE-R5-LOO) ---
+    describe('sweepWithCrossValidation', () => {
+        const LOO_BASE_MS = 1_700_000_000_000;
+        const LOO_STEP_MS = 1_000;
+        const LOO_SERIES_LENGTH = 10;
+        const LOO_DEGRADED_START = 4;
+        const LOO_DEGRADED_END = 9; // exclusive
+        const LOO_NORMAL_STD_DEV = 0.05;
+        const LOO_DEGRADED_STD_DEV = 0.50;
+        const LOO_BASELINE_STD_DEV = 0.10;
+        const LOO_COVERAGE_CELLS = 100;
+        function makeLOOPoint(degraded, ts) {
+            return {
+                timestamp: ts,
+                currentStdDev: degraded ? LOO_DEGRADED_STD_DEV : LOO_NORMAL_STD_DEV,
+                baselineStdDev: LOO_BASELINE_STD_DEV,
+                coverageGapCount: degraded ? 50 : 0,
+                totalCoverageCells: LOO_COVERAGE_CELLS,
+                latencyP95: degraded ? 0.9 : 0.2,
+                latencyP50: 0.1,
+                historicalValues: degraded ? [0.8, 0.85, 0.9] : [0.5, 0.5, 0.51],
+            };
+        }
+        function isoLOOAt(offsetMs) {
+            return new Date(LOO_BASE_MS + offsetMs).toISOString();
+        }
+        const looTimeSeries = Array.from({ length: LOO_SERIES_LENGTH }, (_, i) => makeLOOPoint(i >= LOO_DEGRADED_START && i < LOO_DEGRADED_END, LOO_BASE_MS + i * LOO_STEP_MS));
+        const looIncidents = [
+            {
+                startTime: isoLOOAt(LOO_DEGRADED_START * LOO_STEP_MS),
+                endTime: isoLOOAt((LOO_DEGRADED_END - 1) * LOO_STEP_MS),
+                severity: 'major',
+            },
+            {
+                startTime: isoLOOAt((LOO_DEGRADED_START + 1) * LOO_STEP_MS),
+                endTime: isoLOOAt((LOO_DEGRADED_END - 2) * LOO_STEP_MS),
+                severity: 'minor',
+            },
+        ];
+        it('returns fullSweep and folds with correct counts', () => {
+            const result = sweepWithCrossValidation(looTimeSeries, looIncidents);
+            assert.ok(result.fullSweep, 'fullSweep should be present');
+            assert.strictEqual(result.folds.length, looIncidents.length, `folds.length should equal incident count (${looIncidents.length})`);
+        });
+        it('each fold holds out exactly one incident', () => {
+            const result = sweepWithCrossValidation(looTimeSeries, looIncidents);
+            for (let i = 0; i < looIncidents.length; i++) {
+                assert.strictEqual(result.folds[i].heldOutIncident.startTime, looIncidents[i].startTime, `fold ${i} should hold out incident ${i}`);
+            }
+        });
+        it('fullSweep matches standalone sweepDegradationParams on same inputs', () => {
+            const result = sweepWithCrossValidation(looTimeSeries, looIncidents);
+            const standalone = sweepDegradationParams(looTimeSeries, looIncidents);
+            assert.strictEqual(result.fullSweep.results.length, standalone.results.length, 'fullSweep result count should match standalone sweep');
+            assert.strictEqual(result.fullSweep.bestByF1.tapr.f1, standalone.bestByF1.tapr.f1, 'fullSweep bestByF1.tapr.f1 should match standalone sweep');
+        });
+        it('parameterStability fields are non-negative numbers', () => {
+            const result = sweepWithCrossValidation(looTimeSeries, looIncidents);
+            const ps = result.parameterStability;
+            assert.ok(ps.varianceThresholdStdDev >= 0, 'varianceThresholdStdDev should be non-negative');
+            assert.ok(ps.coverageDropoutThresholdStdDev >= 0, 'coverageDropoutThresholdStdDev should be non-negative');
+            assert.ok(ps.confirmationWindowStdDev >= 0, 'confirmationWindowStdDev should be non-negative');
+            assert.ok(isFinite(ps.varianceThresholdStdDev), 'varianceThresholdStdDev should be finite');
+            assert.ok(isFinite(ps.coverageDropoutThresholdStdDev), 'coverageDropoutThresholdStdDev should be finite');
+            assert.ok(isFinite(ps.confirmationWindowStdDev), 'confirmationWindowStdDev should be finite');
+        });
+        it('isStable is boolean', () => {
+            const result = sweepWithCrossValidation(looTimeSeries, looIncidents);
+            assert.ok(typeof result.isStable === 'boolean', 'isStable should be a boolean');
+        });
+        it('zero incidents: returns empty folds, parameterStability all 0, isStable vacuously true', () => {
+            const result = sweepWithCrossValidation(looTimeSeries, []);
+            assert.strictEqual(result.folds.length, 0, 'folds should be empty with no incidents');
+            // computeStdDev([]) returns null, nullish coalescing to 0
+            assert.strictEqual(result.parameterStability.varianceThresholdStdDev, 0);
+            assert.strictEqual(result.parameterStability.coverageDropoutThresholdStdDev, 0);
+            assert.strictEqual(result.parameterStability.confirmationWindowStdDev, 0);
+            // folds.every() on empty array is vacuously true
+            assert.strictEqual(result.isStable, true, 'isStable is vacuously true when there are no folds');
+        });
+        it('single incident: one fold trained on empty incidents, parameterStability all 0', () => {
+            const singleIncident = [looIncidents[0]];
+            const result = sweepWithCrossValidation(looTimeSeries, singleIncident);
+            assert.strictEqual(result.folds.length, 1, 'should have one fold for one incident');
+            assert.ok(result.folds[0].sweepResult.bestByF1, 'fold sweepResult should have bestByF1 when trained on empty incidents');
+            // computeStdDev of a single value returns null → 0
+            assert.strictEqual(result.parameterStability.varianceThresholdStdDev, 0, 'single fold => std dev is 0');
+            assert.strictEqual(result.parameterStability.coverageDropoutThresholdStdDev, 0, 'single fold => std dev is 0');
+            assert.strictEqual(result.parameterStability.confirmationWindowStdDev, 0, 'single fold => std dev is 0');
+        });
+    });
+    // --- computeTaPR stress tests (ST-FE-R5-TAPR) ---
+    describe('computeTaPR stress', () => {
+        const BASE = 1_700_000_000_000;
+        const HOUR_MS = 3_600_000;
+        const TOLERANCE = 1e-9;
+        it('precision and recall are always in [0,1] for 100 random-offset detected/incident pairs', () => {
+            for (let i = 0; i < 100; i++) {
+                const offset = i * HOUR_MS;
+                const detected = [{ start: BASE + offset, end: BASE + offset + HOUR_MS }];
+                const incidents = [{ start: BASE + offset + HOUR_MS / 4, end: BASE + offset + HOUR_MS * 3 / 4 }];
+                const r = computeTaPR(detected, incidents);
+                assert.ok(r.precision >= 0 && r.precision <= 1, `precision ${r.precision} out of [0,1] at i=${i}`);
+                assert.ok(r.recall >= 0 && r.recall <= 1, `recall ${r.recall} out of [0,1] at i=${i}`);
+                assert.ok(r.f1 >= 0 && r.f1 <= 1, `f1 ${r.f1} out of [0,1] at i=${i}`);
+                assert.ok(r.detectionDelay >= 0, `detectionDelay ${r.detectionDelay} is negative at i=${i}`);
+            }
+        });
+        it('overlapping incident windows: two overlapping incidents produce finite precision/recall/f1', () => {
+            // Two incidents that overlap in time
+            const detected = [{ start: BASE, end: BASE + 2 * HOUR_MS }];
+            const incidents = [
+                { start: BASE, end: BASE + HOUR_MS },
+                { start: BASE + HOUR_MS / 2, end: BASE + HOUR_MS + HOUR_MS / 2 },
+            ];
+            const r = computeTaPR(detected, incidents);
+            assert.ok(isFinite(r.precision), `precision should be finite, got ${r.precision}`);
+            assert.ok(isFinite(r.recall), `recall should be finite, got ${r.recall}`);
+            assert.ok(isFinite(r.f1), `f1 should be finite, got ${r.f1}`);
+            assert.ok(r.precision >= 0 && r.precision <= 1, `precision ${r.precision} out of bounds`);
+            assert.ok(r.recall >= 0 && r.recall <= 1, `recall ${r.recall} out of bounds`);
+        });
+        it('zero-duration detected ranges are skipped: does not produce NaN or divide-by-zero', () => {
+            // Mix of valid and zero-duration detected ranges
+            const detected = [
+                { start: BASE, end: BASE }, // zero-duration — should be skipped
+                { start: BASE, end: BASE + HOUR_MS }, // valid
+            ];
+            const incidents = [{ start: BASE, end: BASE + HOUR_MS }];
+            const r = computeTaPR(detected, incidents);
+            assert.ok(isFinite(r.precision), `precision should be finite, got ${r.precision}`);
+            assert.ok(isFinite(r.recall), `recall should be finite, got ${r.recall}`);
+        });
+        it('incident with identical start/end (zero-duration): recall skips zero-duration incidents', () => {
+            const detected = [{ start: BASE, end: BASE + HOUR_MS }];
+            const incidents = [
+                { start: BASE + 1000, end: BASE + 1000 }, // zero-duration incident
+                { start: BASE, end: BASE + HOUR_MS }, // valid
+            ];
+            const r = computeTaPR(detected, incidents);
+            assert.ok(isFinite(r.recall), `recall should be finite with zero-duration incident`);
+            assert.ok(r.recall >= 0 && r.recall <= 1, `recall ${r.recall} out of bounds`);
+        });
+        it('1000 non-overlapping detected ranges with 1 incident: precision stays in [0,1]', () => {
+            const SEGMENT_MS = 1_000;
+            const detectedRanges = Array.from({ length: 1_000 }, (_, i) => ({
+                start: BASE + i * 2 * SEGMENT_MS,
+                end: BASE + i * 2 * SEGMENT_MS + SEGMENT_MS,
+            }));
+            // Single incident covering only the first detected range
+            const incidents = [{ start: BASE, end: BASE + SEGMENT_MS }];
+            const r = computeTaPR(detectedRanges, incidents);
+            assert.ok(r.precision >= 0 && r.precision <= 1, `precision ${r.precision} out of [0,1] with 1000 ranges`);
+            assert.ok(r.recall >= 0 && r.recall <= 1, `recall ${r.recall} out of [0,1] with 1000 ranges`);
+            assert.ok(isFinite(r.f1), `f1 should be finite with 1000 detected ranges`);
+        });
+        it('detection delay is non-negative when detection starts after incident', () => {
+            const DELAY_MS = 5_000;
+            const detected = [{ start: BASE + DELAY_MS, end: BASE + 2 * HOUR_MS }];
+            const incidents = [{ start: BASE, end: BASE + HOUR_MS }];
+            const r = computeTaPR(detected, incidents);
+            assert.ok(r.detectionDelay >= 0, `detectionDelay ${r.detectionDelay} should be non-negative`);
+            assert.ok(Math.abs(r.detectionDelay - DELAY_MS) < TOLERANCE, `detectionDelay should be ~${DELAY_MS}ms, got ${r.detectionDelay}`);
+        });
+    });
+    // --- sweepDegradationParams stress tests (ST-FE-R5-SWEEP) ---
+    describe('sweepDegradationParams stress', () => {
+        const SWEEP_STRESS_BASE_MS = 1_700_000_000_000;
+        const HOUR_STEP_MS = 3_600_000;
+        const THIRTY_DAY_HOURS = 720;
+        const SWEEP_STRESS_TIMEOUT_MS = 30_000;
+        const INCIDENT_START_HOUR = 360;
+        const INCIDENT_END_HOUR = 380;
+        // Minimal point values for healthy/degraded signals
+        const HEALTHY_STD = 0.05;
+        const DEGRADED_STD = 0.50;
+        const BASELINE_STD = 0.10;
+        const NORMAL_GAPS = 0;
+        const DEGRADED_GAPS = 50;
+        const TOTAL_CELLS = 100;
+        const NORMAL_P95 = 0.2;
+        const NORMAL_P50 = 0.1;
+        const DEGRADED_P95 = 0.9;
+        function makeStressPoint(degraded, ts) {
+            return {
+                timestamp: ts,
+                currentStdDev: degraded ? DEGRADED_STD : HEALTHY_STD,
+                baselineStdDev: BASELINE_STD,
+                coverageGapCount: degraded ? DEGRADED_GAPS : NORMAL_GAPS,
+                totalCoverageCells: TOTAL_CELLS,
+                latencyP95: degraded ? DEGRADED_P95 : NORMAL_P95,
+                latencyP50: NORMAL_P50,
+                historicalValues: degraded ? [0.8, 0.85, 0.9] : [0.5, 0.5, 0.5],
+            };
+        }
+        const stressTimeSeries = Array.from({ length: THIRTY_DAY_HOURS }, (_, i) => makeStressPoint(i >= INCIDENT_START_HOUR && i < INCIDENT_END_HOUR, SWEEP_STRESS_BASE_MS + i * HOUR_STEP_MS));
+        const stressIncidents = [{
+                startTime: new Date(SWEEP_STRESS_BASE_MS + INCIDENT_START_HOUR * HOUR_STEP_MS).toISOString(),
+                endTime: new Date(SWEEP_STRESS_BASE_MS + (INCIDENT_END_HOUR - 1) * HOUR_STEP_MS).toISOString(),
+                severity: 'major',
+            }];
+        it('720-point (30-day) sweep completes within 30 seconds', () => {
+            const start = Date.now();
+            sweepDegradationParams(stressTimeSeries, stressIncidents);
+            const elapsed = Date.now() - start;
+            assert.ok(elapsed < SWEEP_STRESS_TIMEOUT_MS, `sweep took ${elapsed}ms, exceeds 30s threshold`);
+        });
+        it('sweep is deterministic: two calls with same input produce identical bestByF1 config', () => {
+            const sweep1 = sweepDegradationParams(stressTimeSeries, stressIncidents);
+            const sweep2 = sweepDegradationParams(stressTimeSeries, stressIncidents);
+            assert.strictEqual(sweep1.bestByF1.tapr.f1, sweep2.bestByF1.tapr.f1, 'bestByF1.tapr.f1 differs between runs');
+            assert.strictEqual(sweep1.bestByF1.config.varianceThreshold, sweep2.bestByF1.config.varianceThreshold, 'bestByF1 config varianceThreshold differs between runs');
+        });
+        it('no NaN or Infinity in any result metric field', () => {
+            const sweep = sweepDegradationParams(stressTimeSeries, stressIncidents);
+            for (const r of sweep.results) {
+                assert.ok(isFinite(r.tapr.precision), `tapr.precision is not finite: ${r.tapr.precision}`);
+                assert.ok(isFinite(r.tapr.recall), `tapr.recall is not finite: ${r.tapr.recall}`);
+                assert.ok(isFinite(r.tapr.f1), `tapr.f1 is not finite: ${r.tapr.f1}`);
+                assert.ok(isFinite(r.tapr.detectionDelay), `tapr.detectionDelay is not finite: ${r.tapr.detectionDelay}`);
+                assert.ok(isFinite(r.pointPrecision), `pointPrecision is not finite: ${r.pointPrecision}`);
+                assert.ok(isFinite(r.pointRecall), `pointRecall is not finite: ${r.pointRecall}`);
+                assert.ok(isFinite(r.pointF1), `pointF1 is not finite: ${r.pointF1}`);
+            }
+        });
+        it('CURRENT_PRODUCTION_CONFIG always appears in sweep results', () => {
+            const sweep = sweepDegradationParams(stressTimeSeries, stressIncidents);
+            const found = sweep.results.some(r => r.config.varianceThreshold === CURRENT_PRODUCTION_CONFIG.varianceThreshold &&
+                r.config.coverageDropoutThreshold === CURRENT_PRODUCTION_CONFIG.coverageDropoutThreshold &&
+                r.config.ewmaLambda === CURRENT_PRODUCTION_CONFIG.ewmaLambda &&
+                r.config.confirmationWindow === CURRENT_PRODUCTION_CONFIG.confirmationWindow);
+            assert.ok(found, 'CURRENT_PRODUCTION_CONFIG must appear in sweep results');
+        });
+    });
+    // --- backtestDegradationConfig stress tests (ST-FE-R5-BACKTEST) ---
+    describe('backtestDegradationConfig stress', () => {
+        const BT_BASE_MS = 1_700_000_000_000;
+        const BT_STEP_MS = 1_000;
+        const HEALTHY_STD = 0.05;
+        const DEGRADED_STD = 0.50;
+        const BASELINE_STD = 0.10;
+        const NORMAL_GAPS = 0;
+        const DEGRADED_GAPS = 50;
+        const TOTAL_CELLS = 100;
+        const NORMAL_P95 = 0.2;
+        const NORMAL_P50 = 0.1;
+        const DEGRADED_P95 = 0.9;
+        // Use production latency skew threshold (3 > healthy P95/P50 ratio of 2.0, so healthy data won't trigger)
+        const SENSITIVE_CONFIG = {
+            varianceThreshold: 1.05,
+            coverageDropoutThreshold: 0.01,
+            latencySkewThreshold: LATENCY_SKEW_SIGNAL_THRESHOLD,
+            confirmationWindow: 1,
+            ewmaLambda: 0.1,
+            stabilityThreshold: 2.0,
+        };
+        function makeBtPoint(degraded, ts) {
+            return {
+                timestamp: ts,
+                currentStdDev: degraded ? DEGRADED_STD : HEALTHY_STD,
+                baselineStdDev: BASELINE_STD,
+                coverageGapCount: degraded ? DEGRADED_GAPS : NORMAL_GAPS,
+                totalCoverageCells: TOTAL_CELLS,
+                latencyP95: degraded ? DEGRADED_P95 : NORMAL_P95,
+                latencyP50: NORMAL_P50,
+                historicalValues: [0.5, 0.5, 0.5, 0.5, 0.5],
+            };
+        }
+        it('all-healthy time series produces zero false positives with no incidents', () => {
+            const series = Array.from({ length: 20 }, (_, i) => makeBtPoint(false, BT_BASE_MS + i * BT_STEP_MS));
+            const r = backtestDegradationConfig(SENSITIVE_CONFIG, series, []);
+            assert.strictEqual(r.falsePositives, 0, `expected 0 FP for all-healthy series with no incidents, got ${r.falsePositives}`);
+            assert.strictEqual(r.falseNegatives, 0, `expected 0 FN with no incidents, got ${r.falseNegatives}`);
+        });
+        it('all-degraded time series with a covering incident produces zero false negatives', () => {
+            const SERIES_LEN = 20;
+            const CONFIRMATION_WINDOW = 1;
+            const config = { ...SENSITIVE_CONFIG, confirmationWindow: CONFIRMATION_WINDOW };
+            const series = Array.from({ length: SERIES_LEN }, (_, i) => makeBtPoint(true, BT_BASE_MS + i * BT_STEP_MS));
+            const incidents = [{
+                    startTime: new Date(BT_BASE_MS).toISOString(),
+                    endTime: new Date(BT_BASE_MS + (SERIES_LEN - 1) * BT_STEP_MS).toISOString(),
+                    severity: 'critical',
+                }];
+            const r = backtestDegradationConfig(config, series, incidents);
+            assert.strictEqual(r.falseNegatives, 0, `expected 0 FN for all-degraded series fully covered by incident, got ${r.falseNegatives}`);
+        });
+        it('single-point time series: returns valid result without throwing', () => {
+            const singlePoint = [makeBtPoint(false, BT_BASE_MS)];
+            const r = backtestDegradationConfig(SENSITIVE_CONFIG, singlePoint, []);
+            assert.ok(isFinite(r.pointF1), `pointF1 should be finite for single-point series`);
+            assert.ok(isFinite(r.tapr.f1), `tapr.f1 should be finite for single-point series`);
+        });
+        it('confirmation window larger than series length: all points unconfirmed → zero false positives', () => {
+            const SERIES_LEN = 5;
+            const config = {
+                ...SENSITIVE_CONFIG,
+                confirmationWindow: SERIES_LEN + 1, // larger than series
+            };
+            const series = Array.from({ length: SERIES_LEN }, (_, i) => makeBtPoint(true, BT_BASE_MS + i * BT_STEP_MS));
+            const r = backtestDegradationConfig(config, series, []);
+            assert.strictEqual(r.falsePositives, 0, `confirmationWindow > series length should produce 0 FP, got ${r.falsePositives}`);
+            assert.strictEqual(r.truePositives, 0, `confirmationWindow > series length should produce 0 TP, got ${r.truePositives}`);
+        });
+        it('flat historical values with EWMA drift detection: no NaN in results', () => {
+            const flatHistoryPoint = (ts) => ({
+                timestamp: ts,
+                currentStdDev: HEALTHY_STD,
+                baselineStdDev: BASELINE_STD,
+                coverageGapCount: NORMAL_GAPS,
+                totalCoverageCells: TOTAL_CELLS,
+                latencyP95: NORMAL_P95,
+                latencyP50: NORMAL_P50,
+                historicalValues: [0.5, 0.5, 0.5, 0.5, 0.5], // perfectly flat — no drift
+            });
+            const series = Array.from({ length: 10 }, (_, i) => flatHistoryPoint(BT_BASE_MS + i * BT_STEP_MS));
+            const r = backtestDegradationConfig(SENSITIVE_CONFIG, series, []);
+            assert.ok(isFinite(r.tapr.f1), `tapr.f1 should be finite with flat historical values`);
+            assert.ok(isFinite(r.pointPrecision), `pointPrecision should be finite with flat historical values`);
+            assert.ok(isFinite(r.pointRecall), `pointRecall should be finite with flat historical values`);
+        });
+    });
+});
+//# sourceMappingURL=quality-feature-engineering.test.js.map