observability-toolkit 2.0.0 → 2.1.1

package/dist/lib/quality/quality-metrics.test.js

@@ -0,0 +1,2766 @@
+/**
+ * Tests for Quality Metrics Dashboard Helpers
+ */
+import { describe, it, afterEach } from 'vitest';
+import * as assert from 'node:assert';
+import { QUALITY_METRICS, computeAggregations, checkAlertThresholds, determineHealthStatus, computeQualityMetric, computeDashboardSummary, computeRoleView, computeTrend, computeConfidence, computeMetricDetail, toEvaluationDetail, applySeverityContext, evaluateHandoffs, computeTurnLevelResults, computeMultiAgentEvaluation, evaluateSLA, evaluateSLAs, registerQualityMetric, unregisterQualityMetric, getAllQualityMetrics, getQualityMetric, clearCustomMetrics, formatMetricValue, createMetricConfig, DEFAULT_CORRELATION_RULES, registerCorrelationRule, unregisterCorrelationRule, getCorrelationRules, clearCorrelationRules, evaluateCorrelationRules, computePipelineView, computeCoverageHeatmap, checkDivergenceAlert, hasQualityMetric, roundTo, sortAlertsBySeverity, SCORE_PRECISION, PERCENT_PRECISION, slaWindowFormatSchema, } from './quality-metrics.js';
+import { TREND_MIN_SAMPLE_SIZE, DEFAULT_BIN_COUNT, DEFAULT_ENTROPY_THRESHOLD, } from './quality-constants.js';
+import { TEST_DECIMAL_EPSILON, TEST_PERCENTILE_P99, 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_PASSING, TEST_SCORE_POOR, TEST_SCORE_STRONG, TEST_SCORE_VERY_LOW, TEST_SCORE_WARNING, } from './quality-test-constants.js';
+import { DEFAULT_LIMIT_10, SAMPLE_SIZE_100, COUNT_EIGHT, COUNT_FIFTEEN, COUNT_FIFTY, COUNT_FIVE, COUNT_FOUR, COUNT_HUNDRED, COUNT_NINE, COUNT_NINETY, COUNT_SIXTY, COUNT_TEN, COUNT_THREE, COUNT_THIRTY, COUNT_THOUSAND, COUNT_TWO, COUNT_TWO_HUNDRED, COUNT_TWENTY, COUNT_TWENTY_FIVE, DELTA, VALUE_FORTY_TWO, } from '../../test-helpers/test-constants.js';
+import { requireDefined } from '../../test-helpers/assertions.js';
+const TEST_OUT_OF_RANGE_SCORE_HIGH = 1.5;
+const TEST_HALLUCINATION_NONCOMPLIANT_SCORE = TEST_SCORE_WARNING + DELTA;
+const TEST_RELEVANCE_MARGIN_SCORE = 0.88;
+const TEST_STEP_TWO_HUNDREDTHS = TEST_DECIMAL_EPSILON * COUNT_TWO;
+const TEST_STEP_THREE_HUNDREDTHS = TEST_DECIMAL_EPSILON * COUNT_THREE;
+const TEST_P95_LOWER_BOUND = TEST_SCORE_EXCELLENT - TEST_DECIMAL_EPSILON;
+const TEST_P95_UPPER_BOUND = TEST_SCORE_EXCELLENT + TEST_DECIMAL_EPSILON;
+const TEST_P99_LOWER_BOUND = TEST_SCORE_EXCELLENT + TEST_STEP_THREE_HUNDREDTHS;
+const TEST_SINGLE_VALUE_SCORE = TEST_SCORE_PASSING + DELTA;
+const TEST_AVG_EXPECTED_LOWER_BOUND = TEST_SCORE_STRONG - TEST_DECIMAL_EPSILON;
+const TEST_AVG_EXPECTED_UPPER_BOUND = TEST_SCORE_STRONG + TEST_DECIMAL_EPSILON;
+const TEST_TOTAL_EVALUATION_COUNT_MIN = SAMPLE_SIZE_100 + COUNT_TWENTY_FIVE;
+const TEST_FORMATTED_SCORE_INPUT = 0.8567;
+const TEST_FORMATTED_SECONDS_INPUT = 3.456;
+const TEST_TINY_SCORE_1 = 0.00001;
+const TEST_TINY_SCORE_2 = 0.00002;
+const TEST_TINY_SCORE_3 = 0.00003;
+const TEST_INTERPOLATED_P95_EXPECTED = 0.87;
+const makeBaseResult = (name, overrides = {}) => ({
+    name,
+    displayName: name,
+    values: {
+        avg: overrides.avg ?? null,
+        min: null, max: null,
+        count: DEFAULT_LIMIT_10,
+        p50: overrides.p50 ?? null,
+        p95: null, p99: null,
+    },
+    sampleCount: DEFAULT_LIMIT_10,
+    alerts: [],
+    status: (overrides.avg ?? overrides.p50) === null ? 'no_data' : 'healthy',
+});
+describe('quality-metrics', () => {
+    afterEach(() => {
+        clearCustomMetrics();
+        clearCorrelationRules();
+    });
+    // ==========================================================================
+    // QUALITY_METRICS
+    // ==========================================================================
+    describe('QUALITY_METRICS', () => {
+        it('includes relevance metric', () => {
+            assert.ok(QUALITY_METRICS.relevance);
+            assert.strictEqual(QUALITY_METRICS.relevance.name, 'relevance');
+            assert.ok(QUALITY_METRICS.relevance.alerts.length > 0);
+        });
+        it('includes task_completion metric', () => {
+            assert.ok(QUALITY_METRICS.task_completion);
+            assert.strictEqual(QUALITY_METRICS.task_completion.name, 'task_completion');
+        });
+        it('includes tool_correctness metric', () => {
+            assert.ok(QUALITY_METRICS.tool_correctness);
+            assert.strictEqual(QUALITY_METRICS.tool_correctness.unit, 'rate');
+        });
+        it('includes hallucination metric', () => {
+            assert.ok(QUALITY_METRICS.hallucination);
+            const alert = QUALITY_METRICS.hallucination.alerts[0];
+            assert.strictEqual(alert.direction, 'above');
+        });
+        it('includes evaluation_latency metric', () => {
+            assert.ok(QUALITY_METRICS.evaluation_latency);
+            assert.strictEqual(QUALITY_METRICS.evaluation_latency.unit, 'seconds');
+        });
+        it('all metrics have remediation hints', () => {
+            for (const [name, config] of Object.entries(QUALITY_METRICS)) {
+                assert.ok(config.remediationHints, `${name} missing remediationHints`);
+                assert.ok(requireDefined(config.remediationHints).length > 0, `${name} has empty remediationHints`);
+            }
+        });
+        it('all metrics have required fields', () => {
+            for (const [name, config] of Object.entries(QUALITY_METRICS)) {
+                assert.ok(config.name, `${name} missing name`);
+                assert.ok(config.displayName, `${name} missing displayName`);
+                assert.ok(config.description, `${name} missing description`);
+                assert.ok(config.aggregations.length > 0, `${name} missing aggregations`);
+                assert.ok(config.range, `${name} missing range`);
+                assert.ok(config.unit, `${name} missing unit`);
+            }
+        });
+    });
+    // ==========================================================================
+    // computeAggregations
+    // ==========================================================================
+    describe('computeAggregations', () => {
+        it('computes avg correctly', () => {
+            const result = computeAggregations([TEST_SCORE_GOOD, TEST_SCORE_HIGH, TEST_SCORE_PASSING], ['avg']);
+            assert.strictEqual(result.avg, TEST_SCORE_GOOD);
+        });
+        it('computes min and max', () => {
+            const result = computeAggregations([TEST_SCORE_MID, TEST_SCORE_GOOD, TEST_SCORE_LOW, TEST_SCORE_HIGH], ['min', 'max']);
+            assert.strictEqual(result.min, TEST_SCORE_LOW);
+            assert.strictEqual(result.max, TEST_SCORE_HIGH);
+        });
+        it('computes count', () => {
+            const result = computeAggregations([TEST_SCORE_MID, TEST_SCORE_BASELINE, TEST_SCORE_PASSING, TEST_SCORE_GOOD], ['count']);
+            assert.strictEqual(result.count, COUNT_FOUR);
+        });
+        it('computes p50 (median)', () => {
+            const result = computeAggregations([TEST_SCORE_WARNING, TEST_SCORE_VERY_LOW, TEST_SCORE_LOW, TEST_SCORE_POOR, TEST_SCORE_MID], ['p50']);
+            assert.strictEqual(result.p50, TEST_SCORE_LOW);
+        });
+        it('computes p50 with even count', () => {
+            const result = computeAggregations([TEST_SCORE_VERY_LOW, TEST_SCORE_POOR, TEST_SCORE_BASELINE, TEST_SCORE_GOOD], ['p50']);
+            // R-7 interpolation: rank = TEST_SCORE_MID * 3 = 1.5
+            // Interpolate between index 1 (TEST_SCORE_POOR) and index 2 (TEST_SCORE_BASELINE)
+            assert.strictEqual(result.p50, TEST_SCORE_MID);
+        });
+        it('computes p95', () => {
+            const scores = Array.from({ length: COUNT_HUNDRED }, (_, i) => i / COUNT_HUNDRED);
+            const result = computeAggregations(scores, ['p95']);
+            assert.ok(requireDefined(result.p95) >= TEST_P95_LOWER_BOUND && requireDefined(result.p95) <= TEST_P95_UPPER_BOUND);
+        });
+        it('computes p99', () => {
+            const scores = Array.from({ length: COUNT_HUNDRED }, (_, i) => i / COUNT_HUNDRED);
+            const result = computeAggregations(scores, ['p99']);
+            assert.ok(requireDefined(result.p99) >= TEST_P99_LOWER_BOUND);
+        });
+        it('handles empty array', () => {
+            const result = computeAggregations([], ['avg', 'p50', 'count']);
+            assert.strictEqual(result.avg, null);
+            assert.strictEqual(result.p50, null);
+            assert.strictEqual(result.count, null);
+        });
+        it('handles single value', () => {
+            const result = computeAggregations([TEST_SINGLE_VALUE_SCORE], ['avg', 'min', 'max', 'p50']);
+            assert.strictEqual(result.avg, TEST_SINGLE_VALUE_SCORE);
+            assert.strictEqual(result.min, TEST_SINGLE_VALUE_SCORE);
+            assert.strictEqual(result.max, TEST_SINGLE_VALUE_SCORE);
+            assert.strictEqual(result.p50, TEST_SINGLE_VALUE_SCORE);
+        });
+        it('computes multiple aggregations', () => {
+            const result = computeAggregations([TEST_SCORE_MID, TEST_SCORE_BASELINE, TEST_SCORE_PASSING, TEST_SCORE_GOOD, TEST_SCORE_HIGH], ['avg', 'min', 'max', 'p50', 'count']);
+            assert.strictEqual(result.avg, TEST_SCORE_PASSING);
+            assert.strictEqual(result.min, TEST_SCORE_MID);
+            assert.strictEqual(result.max, TEST_SCORE_HIGH);
+            assert.strictEqual(result.p50, TEST_SCORE_PASSING);
+            assert.strictEqual(result.count, COUNT_FIVE);
+        });
+        it('filters out NaN and Infinity scores', () => {
+            const result = computeAggregations([TEST_SCORE_MID, NaN, TEST_SCORE_PASSING, Infinity, -Infinity, TEST_SCORE_HIGH], ['avg', 'count', 'min', 'max']);
+            assert.strictEqual(result.count, COUNT_THREE); // Only TEST_SCORE_MID, TEST_SCORE_PASSING, TEST_SCORE_HIGH are valid
+            assert.strictEqual(result.min, TEST_SCORE_MID);
+            assert.strictEqual(result.max, TEST_SCORE_HIGH);
+            assert.strictEqual(result.avg, TEST_SCORE_PASSING);
+        });
+        it('returns null aggregations when all scores are NaN/Infinity', () => {
+            const result = computeAggregations([NaN, Infinity, -Infinity], ['avg', 'count']);
+            assert.strictEqual(result.avg, null);
+            assert.strictEqual(result.count, null);
+        });
+    });
+    // ==========================================================================
+    // checkAlertThresholds
+    // ==========================================================================
+    describe('checkAlertThresholds', () => {
+        const thresholds = [
+            { aggregation: 'p50', value: TEST_SCORE_PASSING, direction: 'below', severity: 'warning', message: 'Low p50: {value}' },
+            { aggregation: 'avg', value: TEST_SCORE_WARNING, direction: 'above', severity: 'critical', message: 'High avg: {value}' },
+        ];
+        it('triggers below threshold alert', () => {
+            // avg=DELTA is below the TEST_SCORE_WARNING 'above' threshold, so only p50 alert should trigger
+            const values = { avg: DELTA, min: null, max: null, count: COUNT_TEN, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, 1);
+            assert.strictEqual(alerts[0].severity, 'warning');
+            assert.strictEqual(alerts[0].direction, 'below');
+            assert.strictEqual(alerts[0].actualValue, TEST_SCORE_ADEQUATE);
+        });
+        it('triggers above threshold alert', () => {
+            const values = { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_GOOD, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, 1);
+            assert.strictEqual(alerts[0].severity, 'critical');
+            assert.strictEqual(alerts[0].direction, 'above');
+        });
+        it('triggers multiple alerts', () => {
+            const values = { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_MID, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, COUNT_TWO);
+            // Critical should come first (sorted by severity)
+            assert.strictEqual(alerts[0].severity, 'critical');
+            assert.strictEqual(alerts[1].severity, 'warning');
+        });
+        it('returns empty array when no alerts triggered', () => {
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_GOOD, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('handles null values', () => {
+            const values = { avg: null, min: null, max: null, count: null, p50: null, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('formats message with value', () => {
+            // Only trigger the p50 below threshold
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            // The message should contain the formatted value
+            assert.ok(alerts[0].message.includes('0.65'));
+        });
+        it('populates affectedCount from options.sampleCount', () => {
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds, { sampleCount: VALUE_FORTY_TWO });
+            assert.strictEqual(alerts[0].affectedCount, VALUE_FORTY_TWO);
+        });
+        it('falls back to values.count when sampleCount not provided', () => {
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts[0].affectedCount, COUNT_TEN);
+        });
+        it('appends sample count to alert message', () => {
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds, { sampleCount: COUNT_FIFTEEN });
+            assert.ok(alerts[0].message.includes(`(n=${COUNT_FIFTEEN} evaluations)`));
+        });
+        it('includes remediationHints when provided', () => {
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const hints = ['Fix your prompts', 'Add more context'];
+            const alerts = checkAlertThresholds(values, thresholds, { remediationHints: hints });
+            assert.deepStrictEqual(alerts[0].remediationHints, hints);
+        });
+        it('omits remediationHints when not provided', () => {
+            const values = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_ADEQUATE, p95: null, p99: null };
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts[0].remediationHints, undefined);
+        });
+    });
+    // ==========================================================================
+    // checkDivergenceAlert
+    // ==========================================================================
+    describe('checkDivergenceAlert', () => {
+        const divergenceThreshold = {
+            type: 'divergence',
+            entropyThreshold: TEST_SCORE_BASELINE,
+            bins: DEFAULT_LIMIT_10,
+            severity: 'warning',
+            message: 'Score distribution is bimodal (entropy {entropy})',
+        };
+        it('returns null for uniform scores (high entropy)', () => {
+            // Uniform distribution across [0, 1] — entropy near 1.0
+            const scores = Array.from({ length: SAMPLE_SIZE_100 }, (_, i) => i / TEST_PERCENTILE_P99);
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.strictEqual(alert, null);
+        });
+        it('triggers for bimodal scores (low entropy)', () => {
+            // Bimodal: half at 0, half at 1
+            const scores = [...Array(COUNT_FIFTY).fill(0), ...Array(COUNT_FIFTY).fill(1)];
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.ok(alert, 'Expected divergence alert for bimodal data');
+            assert.strictEqual(alert.severity, 'warning');
+            assert.strictEqual(alert.direction, 'below');
+            assert.strictEqual(alert.aggregation, 'count');
+            assert.ok(alert.divergenceDetails);
+            assert.strictEqual(requireDefined(alert.divergenceDetails).bins, COUNT_TEN);
+            assert.ok(requireDefined(alert.divergenceDetails).entropy < TEST_SCORE_BASELINE);
+            assert.strictEqual(requireDefined(alert.divergenceDetails).histogram.length, COUNT_TEN);
+            assert.strictEqual(alert.affectedCount, COUNT_HUNDRED);
+        });
+        it('returns null for insufficient data (< 10 scores)', () => {
+            const scores = [0, 0, 0, 1, 1, 1]; // only 6 scores
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.strictEqual(alert, null);
+        });
+        it('replaces {entropy} placeholder in message', () => {
+            const scores = [...Array(COUNT_FIFTY).fill(0), ...Array(COUNT_FIFTY).fill(1)];
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.ok(alert);
+            assert.ok(!alert.message.includes('{entropy}'));
+            assert.ok(alert.message.includes('entropy'));
+        });
+        it('returns null for exactly 10 uniform scores', () => {
+            const scores = Array.from({ length: COUNT_TEN }, (_, i) => i / COUNT_NINE);
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.strictEqual(alert, null);
+        });
+        it('returns null for empty scores', () => {
+            const alert = checkDivergenceAlert([], divergenceThreshold);
+            assert.strictEqual(alert, null);
+        });
+        it('triggers for all-identical scores (entropy = 0)', () => {
+            const scores = Array(COUNT_TWENTY).fill(TEST_SCORE_MID);
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.ok(alert, 'All identical scores should have entropy 0 and trigger alert');
+            assert.strictEqual(requireDefined(requireDefined(alert).divergenceDetails).entropy, 0);
+        });
+        it('filters out NaN and out-of-range scores', () => {
+            // 8 valid scores (< 10 min) + junk — should return null
+            const 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,
+                NaN,
+                -1,
+                TEST_OUT_OF_RANGE_SCORE_HIGH,
+                Infinity,
+            ];
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.strictEqual(alert, null); // only 8 valid scores, below MIN_DIVERGENCE_SAMPLES
+        });
+        it('affectedCount reflects valid scores only', () => {
+            // 50 valid + 5 invalid
+            const scores = [
+                ...Array(COUNT_TWENTY_FIVE).fill(0),
+                ...Array(COUNT_TWENTY_FIVE).fill(1),
+                NaN,
+                -TEST_SCORE_WARNING,
+                TEST_OUT_OF_RANGE_SCORE_HIGH,
+                Infinity,
+                -Infinity,
+            ];
+            const alert = checkDivergenceAlert(scores, divergenceThreshold);
+            assert.ok(alert);
+            assert.strictEqual(requireDefined(alert).affectedCount, COUNT_FIFTY); // not 55
+        });
+    });
+    // ==========================================================================
+    // checkAlertThresholds with divergence
+    // ==========================================================================
+    describe('checkAlertThresholds with divergence alerts', () => {
+        it('handles mixed value and divergence thresholds', () => {
+            const values = { avg: TEST_SCORE_MID, min: null, max: null, count: SAMPLE_SIZE_100, p50: TEST_SCORE_MID, p95: null, p99: null };
+            const mixed = [
+                { aggregation: 'p50', value: TEST_SCORE_GOOD, direction: 'below', severity: 'warning', message: 'p50 low ({value})' },
+                { type: 'divergence', entropyThreshold: TEST_SCORE_BASELINE, bins: DEFAULT_LIMIT_10, severity: 'warning', message: 'Bimodal (entropy {entropy})' },
+            ];
+            const bimodalScores = [...Array(COUNT_FIFTY).fill(0), ...Array(COUNT_FIFTY).fill(1)];
+            const alerts = checkAlertThresholds(values, mixed, { scores: bimodalScores });
+            // Both should fire: value alert (p50=0.5 < TEST_SCORE_GOOD) and divergence alert
+            assert.strictEqual(alerts.length, COUNT_TWO);
+        });
+        it('skips divergence alerts when scores not provided', () => {
+            const values = { avg: TEST_SCORE_HIGH, min: null, max: null, count: SAMPLE_SIZE_100, p50: TEST_SCORE_HIGH, p95: null, p99: null };
+            const thresholds = [
+                { type: 'divergence', entropyThreshold: TEST_SCORE_BASELINE, bins: DEFAULT_LIMIT_10, severity: 'warning', message: 'Bimodal' },
+            ];
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('backward compatible with old-style AlertThreshold (no type field)', () => {
+            const values = { avg: TEST_SCORE_MID, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_MID, p95: null, p99: null };
+            const oldStyle = [
+                { aggregation: 'p50', value: TEST_SCORE_GOOD, direction: 'below', severity: 'warning', message: 'Low ({value})' },
+            ];
+            const alerts = checkAlertThresholds(values, oldStyle);
+            assert.strictEqual(alerts.length, 1);
+            assert.strictEqual(alerts[0].direction, 'below');
+        });
+    });
+    // ==========================================================================
+    // QUALITY_METRICS divergence alerts (faithfulness, relevance, coherence, task_completion)
+    // ==========================================================================
+    const DIVERGENCE_METRICS = ['faithfulness', 'relevance', 'coherence', 'task_completion'];
+    for (const metricName of DIVERGENCE_METRICS) {
+        describe(`QUALITY_METRICS.${metricName} divergence alert`, () => {
+            it('includes a divergence alert threshold', () => {
+                const metric = QUALITY_METRICS[metricName];
+                const divergence = metric.alerts.find(a => 'type' in a && a.type === 'divergence');
+                assert.ok(divergence, `Expected divergence alert in ${metricName} metric`);
+                assert.strictEqual(divergence.entropyThreshold, TEST_SCORE_MID);
+                assert.strictEqual(divergence.bins, DEFAULT_BIN_COUNT);
+                assert.strictEqual(divergence.severity, 'warning');
+            });
+            it('fires divergence alert via computeQualityMetric with bimodal data', () => {
+                const bimodalEvals = [
+                    ...Array.from({ length: COUNT_FIFTY }, () => ({
+                        evaluationName: metricName, scoreValue: 0.0, timestamp: '2026-01-01T00:00:00Z',
+                    })),
+                    ...Array.from({ length: COUNT_FIFTY }, () => ({
+                        evaluationName: metricName, scoreValue: 1.0, timestamp: '2026-01-01T00:00:00Z',
+                    })),
+                ];
+                const result = computeQualityMetric(bimodalEvals, QUALITY_METRICS[metricName]);
+                const divergenceAlert = result.alerts.find(a => a.divergenceDetails != null);
+                assert.ok(divergenceAlert, `Expected divergence alert for bimodal ${metricName} data`);
+                assert.ok(requireDefined(divergenceAlert.divergenceDetails).entropy < TEST_SCORE_MID);
+            });
+            it(`does not fire divergence alert for uniform data`, () => {
+                const uniformEvals = Array.from({ length: SAMPLE_SIZE_100 }, (_, i) => ({
+                    evaluationName: metricName, scoreValue: i / TEST_PERCENTILE_P99, timestamp: '2026-01-01T00:00:00Z',
+                }));
+                const result = computeQualityMetric(uniformEvals, QUALITY_METRICS[metricName]);
+                const divergenceAlert = result.alerts.find(a => a.divergenceDetails != null);
+                assert.strictEqual(divergenceAlert, undefined);
+            });
+        });
+    }
+    // ==========================================================================
+    // MetricConfigBuilder.divergenceAlert
+    // ==========================================================================
+    describe('MetricConfigBuilder.divergenceAlert', () => {
+        it('adds divergence alert via builder', () => {
+            const config = createMetricConfig('test_div')
+                .displayName('Test Divergence')
+                .description('Testing divergence builder')
+                .divergenceAlert(TEST_SCORE_MID, 'warning')
+                .build();
+            const divAlert = config.alerts.find(a => 'type' in a && a.type === 'divergence');
+            assert.ok(divAlert);
+            assert.strictEqual(divAlert.entropyThreshold, TEST_SCORE_MID);
+            assert.strictEqual(divAlert.bins, DEFAULT_BIN_COUNT);
+            assert.strictEqual(divAlert.severity, 'warning');
+        });
+        it('supports custom bins and message', () => {
+            const config = createMetricConfig('test_div2')
+                .displayName('Test Divergence 2')
+                .description('Testing custom bins')
+                .divergenceAlert(TEST_SCORE_PASSING, 'critical', 'Custom msg (entropy {entropy})', COUNT_TWENTY)
+                .build();
+            const divAlert = config.alerts.find(a => 'type' in a && a.type === 'divergence');
+            assert.ok(divAlert);
+            assert.strictEqual(divAlert.bins, COUNT_TWENTY);
+            assert.ok(divAlert.message.includes('Custom msg'));
+        });
+    });
+    // ==========================================================================
+    // Constants exported
+    // ==========================================================================
+    describe('divergence constants', () => {
+        it('exports DEFAULT_BIN_COUNT', () => {
+            assert.strictEqual(DEFAULT_BIN_COUNT, COUNT_TEN);
+        });
+        it('exports DEFAULT_ENTROPY_THRESHOLD', () => {
+            assert.strictEqual(DEFAULT_ENTROPY_THRESHOLD, TEST_SCORE_BASELINE);
+        });
+    });
+    // ==========================================================================
+    // determineHealthStatus
+    // ==========================================================================
+    describe('determineHealthStatus', () => {
+        it('returns no_data when no data', () => {
+            assert.strictEqual(determineHealthStatus([], false), 'no_data');
+        });
+        it('returns healthy when no alerts', () => {
+            assert.strictEqual(determineHealthStatus([], true), 'healthy');
+        });
+        it('returns warning when warning alerts', () => {
+            const alerts = [
+                { severity: 'warning', message: 'test', aggregation: 'avg', threshold: TEST_SCORE_PASSING, actualValue: TEST_SCORE_BASELINE, direction: 'below' }
+            ];
+            assert.strictEqual(determineHealthStatus(alerts, true), 'warning');
+        });
+        it('returns critical when critical alerts', () => {
+            const alerts = [
+                { severity: 'warning', message: 'test', aggregation: 'avg', threshold: TEST_SCORE_PASSING, actualValue: TEST_SCORE_BASELINE, direction: 'below' },
+                { severity: 'critical', message: 'test', aggregation: 'p50', threshold: TEST_SCORE_MID, actualValue: TEST_SCORE_POOR, direction: 'below' },
+            ];
+            assert.strictEqual(determineHealthStatus(alerts, true), 'critical');
+        });
+    });
+    // ==========================================================================
+    // computeQualityMetric
+    // ==========================================================================
+    describe('computeQualityMetric', () => {
+        const config = QUALITY_METRICS.relevance;
+        it('computes metric from evaluations', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH },
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.strictEqual(result.name, 'relevance');
+            assert.strictEqual(result.sampleCount, COUNT_THREE);
+            assert.ok(requireDefined(result.values.avg) >= TEST_AVG_EXPECTED_LOWER_BOUND && requireDefined(result.values.avg) <= TEST_AVG_EXPECTED_UPPER_BOUND);
+            assert.strictEqual(result.status, 'healthy');
+        });
+        it('handles empty evaluations', () => {
+            const result = computeQualityMetric([], config);
+            assert.strictEqual(result.sampleCount, 0);
+            assert.strictEqual(result.status, 'no_data');
+        });
+        it('triggers alerts for low scores', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_POOR },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_MID },
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_BORDERLINE },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.ok(result.alerts.length > 0);
+            assert.strictEqual(result.status, 'critical');
+        });
+        it('filters evaluations without scoreValue', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance' }, // No scoreValue
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: undefined },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.strictEqual(result.sampleCount, 1);
+        });
+        it('includes period if provided', () => {
+            const period = { start: '2026-01-01T00:00:00Z', end: '2026-01-02T00:00:00Z' };
+            const result = computeQualityMetric([], config, period);
+            assert.deepStrictEqual(result.period, period);
+        });
+        it('populates worstExplanation with lowest-scoring evaluation', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, explanation: 'Good answer' },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW, explanation: 'Off-topic', traceId: 'trace-123' },
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.ok(result.worstExplanation);
+            assert.strictEqual(result.worstExplanation.score, TEST_SCORE_LOW);
+            assert.strictEqual(result.worstExplanation.explanation, 'Off-topic');
+            assert.strictEqual(result.worstExplanation.traceId, 'trace-123');
+            assert.strictEqual(result.worstExplanation.timestamp, '2026-01-01T00:01:00Z');
+        });
+        it('returns undefined worstExplanation for empty evaluations', () => {
+            const result = computeQualityMetric([], config);
+            assert.strictEqual(result.worstExplanation, undefined);
+        });
+        it('populates affectedCount and remediationHints on triggered alerts', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_POOR },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.ok(result.alerts.length > 0);
+            assert.strictEqual(result.alerts[0].affectedCount, COUNT_TWO);
+            assert.ok(Array.isArray(result.alerts[0].remediationHints));
+            assert.ok(requireDefined(result.alerts[0].remediationHints).length > 0);
+        });
+        it('alert messages include sample count', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.ok(result.alerts.length > 0);
+            assert.ok(result.alerts[0].message.includes('(n=1 evaluations)'));
+        });
+        it('handles worstExplanation with missing optional fields', () => {
+            const evaluations = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_MID },
+            ];
+            const result = computeQualityMetric(evaluations, config);
+            assert.ok(result.worstExplanation);
+            assert.strictEqual(result.worstExplanation.score, TEST_SCORE_MID);
+            assert.strictEqual(result.worstExplanation.explanation, undefined);
+            assert.strictEqual(result.worstExplanation.traceId, undefined);
+        });
+    });
+    // ==========================================================================
+    // computeDashboardSummary
+    // ==========================================================================
+    describe('computeDashboardSummary', () => {
+        it('computes summary for multiple metrics', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+                    ]],
+                ['task_completion', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'task_completion', scoreValue: TEST_SCORE_HIGH },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            assert.strictEqual(summary.overallStatus, 'healthy');
+            assert.ok(summary.metrics.length > 0);
+            assert.ok(summary.timestamp);
+        });
+        it('detects worst status as overall', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            // Low relevance should trigger critical
+            assert.strictEqual(summary.overallStatus, 'critical');
+        });
+        it('collects all alerts with metric names', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            const relevanceAlerts = summary.alerts.filter(a => a.metricName === 'relevance');
+            assert.ok(relevanceAlerts.length > 0);
+        });
+        it('counts metrics by status', () => {
+            const evaluationsByMetric = new Map();
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            assert.strictEqual(summary.summary.totalMetrics, Object.keys(QUALITY_METRICS).length);
+            assert.strictEqual(summary.summary.noDataMetrics, Object.keys(QUALITY_METRICS).length);
+        });
+        it('populates relatedMetrics on alerts when multiple metrics are alerting', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+                ['faithfulness', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'faithfulness', scoreValue: TEST_SCORE_POOR },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            const relevanceAlerts = summary.alerts.filter(a => a.metricName === 'relevance');
+            assert.ok(relevanceAlerts.length > 0);
+            assert.ok(requireDefined(relevanceAlerts[0].relatedMetrics).includes('faithfulness'));
+            assert.ok(!requireDefined(relevanceAlerts[0].relatedMetrics).includes('relevance'));
+        });
+        it('sets relatedMetrics to empty array when only one metric is alerting', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+                ['faithfulness', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'faithfulness', scoreValue: TEST_SCORE_EXCELLENT },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            const relevanceAlerts = summary.alerts.filter(a => a.metricName === 'relevance');
+            assert.ok(relevanceAlerts.length > 0);
+            assert.deepStrictEqual(relevanceAlerts[0].relatedMetrics, []);
+        });
+        it('handles relatedMetrics when one metric triggers multiple alerts', () => {
+            // relevance has two thresholds (warning at TEST_SCORE_PASSING, critical at 0.5)
+            // score of 0.3 triggers both
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+                ['faithfulness', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'faithfulness', scoreValue: TEST_SCORE_POOR },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            const relevanceAlerts = summary.alerts.filter(a => a.metricName === 'relevance');
+            assert.ok(relevanceAlerts.length >= COUNT_TWO, `Expected >=2 relevance alerts, got ${relevanceAlerts.length}`);
+            for (const alert of relevanceAlerts) {
+                assert.ok(requireDefined(alert.relatedMetrics).includes('faithfulness'));
+                assert.ok(!requireDefined(alert.relatedMetrics).includes('relevance'));
+            }
+        });
+        it('includes custom metrics', () => {
+            const customMetrics = {
+                custom_metric: {
+                    name: 'custom_metric',
+                    displayName: 'Custom Metric',
+                    description: 'A custom metric',
+                    aggregations: ['avg'],
+                    alerts: [],
+                    range: { min: 0, max: 1 },
+                    unit: 'score',
+                },
+            };
+            const summary = computeDashboardSummary(new Map(), customMetrics);
+            const hasCustom = summary.metrics.some(m => m.name === 'custom_metric');
+            assert.ok(hasCustom);
+        });
+    });
+    // ==========================================================================
+    // Cross-Metric Correlation
+    // ==========================================================================
+    describe('DEFAULT_CORRELATION_RULES', () => {
+        it('defines 3 default rules', () => {
+            assert.strictEqual(DEFAULT_CORRELATION_RULES.length, COUNT_THREE);
+        });
+        it('each rule has at least 2 conditions', () => {
+            for (const rule of DEFAULT_CORRELATION_RULES) {
+                assert.ok(rule.conditions.length >= COUNT_TWO, `${rule.name} has fewer than 2 conditions`);
+            }
+        });
+        it('content_quality_crisis targets relevance and hallucination', () => {
+            const rule = DEFAULT_CORRELATION_RULES.find(r => r.name === 'content_quality_crisis');
+            assert.ok(rule);
+            assert.strictEqual(rule.severity, 'critical');
+            const metricNames = rule.conditions.map(c => c.metric);
+            assert.ok(metricNames.includes('relevance'));
+            assert.ok(metricNames.includes('hallucination'));
+        });
+    });
+    describe('evaluateCorrelationRules', () => {
+        it('fires compound alert when all conditions match', () => {
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_MID, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_BASELINE, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+                { name: 'hallucination', displayName: 'Hallucination', values: { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            const crisis = alerts.find(a => a.metricName === 'content_quality_crisis');
+            assert.ok(crisis, 'Expected content_quality_crisis compound alert');
+            assert.strictEqual(crisis.isCompound, true);
+            assert.strictEqual(crisis.severity, 'critical');
+            assert.ok(requireDefined(crisis.relatedMetrics).includes('relevance'));
+            assert.ok(requireDefined(crisis.relatedMetrics).includes('hallucination'));
+        });
+        it('does not fire when only some conditions match', () => {
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_HIGH, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_HIGH, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'healthy' },
+                { name: 'hallucination', displayName: 'Hallucination', values: { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            const crisis = alerts.find(a => a.metricName === 'content_quality_crisis');
+            assert.strictEqual(crisis, undefined);
+        });
+        it('does not fire when metric data is missing', () => {
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: null, min: null, max: null, count: null, p50: null, p95: null, p99: null }, sampleCount: 0, alerts: [], status: 'no_data' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('does not fire when metric value is NaN', () => {
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: NaN, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+                { name: 'hallucination', displayName: 'Hallucination', values: { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            const crisis = alerts.find(a => a.metricName === 'content_quality_crisis');
+            assert.strictEqual(crisis, undefined);
+        });
+        it('does not fire at exact threshold boundary (strict inequality)', () => {
+            // Correlation uses strict < and > to match checkAlertThresholds behavior
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_PASSING, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_PASSING, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'healthy' },
+                { name: 'hallucination', displayName: 'Hallucination', values: { avg: TEST_SCORE_WARNING, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'healthy' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            // p50=TEST_SCORE_PASSING is NOT < TEST_SCORE_PASSING, and avg=TEST_SCORE_WARNING is NOT > TEST_SCORE_WARNING
+            const crisis = alerts.find(a => a.metricName === 'content_quality_crisis');
+            assert.strictEqual(crisis, undefined);
+        });
+        it('returns empty array when results are empty', () => {
+            const alerts = evaluateCorrelationRules([], DEFAULT_CORRELATION_RULES);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('compound alert uses first condition metadata', () => {
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_MID, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_BASELINE, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+                { name: 'hallucination', displayName: 'Hallucination', values: { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            const crisis = requireDefined(alerts.find(a => a.metricName === 'content_quality_crisis'), 'Expected content_quality_crisis alert');
+            // First condition is relevance.p50 < TEST_SCORE_PASSING
+            assert.strictEqual(crisis.aggregation, 'p50');
+            assert.strictEqual(crisis.threshold, TEST_SCORE_PASSING);
+            assert.strictEqual(crisis.direction, 'below');
+        });
+        it('fires multiple compound alerts when multiple rules match', () => {
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_MID, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_BASELINE, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+                { name: 'hallucination', displayName: 'Hallucination', values: { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+                { name: 'faithfulness', displayName: 'Faithfulness', values: { avg: TEST_SCORE_MID, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_PASSING, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+                { name: 'coherence', displayName: 'Coherence', values: { avg: TEST_SCORE_MID, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_PASSING, p95: null, p99: null }, sampleCount: DEFAULT_LIMIT_10, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, DEFAULT_CORRELATION_RULES);
+            assert.ok(alerts.length >= COUNT_TWO, `Expected >=2 compound alerts, got ${alerts.length}`);
+        });
+        it('evaluates custom rule with >2 conditions', () => {
+            const rule = {
+                name: 'triple_threat',
+                displayName: 'Triple Threat',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'faithfulness', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'critical',
+                explanation: 'Three metrics failing simultaneously',
+            };
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_LOW, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+                { name: 'coherence', displayName: 'Coherence', values: { avg: TEST_SCORE_POOR, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+                { name: 'faithfulness', displayName: 'Faithfulness', values: { avg: TEST_SCORE_VERY_LOW, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, [rule]);
+            assert.strictEqual(alerts.length, 1);
+            assert.strictEqual(alerts[0].metricName, 'triple_threat');
+        });
+        it('does not fire when condition references null aggregation value', () => {
+            const rule = {
+                name: 'null_test',
+                displayName: 'Null Test',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'p95', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should not fire when p95 is null',
+            };
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_LOW, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+                { name: 'coherence', displayName: 'Coherence', values: { avg: TEST_SCORE_POOR, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, [rule]);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('preserves severity ordering when multiple rules fire', () => {
+            const warningRule = {
+                name: 'warn_rule',
+                displayName: 'Warning Rule',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Warning level',
+            };
+            const criticalRule = {
+                name: 'crit_rule',
+                displayName: 'Critical Rule',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'faithfulness', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'critical',
+                explanation: 'Critical level',
+            };
+            const results = [
+                { name: 'relevance', displayName: 'Relevance', values: { avg: TEST_SCORE_LOW, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+                { name: 'coherence', displayName: 'Coherence', values: { avg: TEST_SCORE_POOR, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+                { name: 'faithfulness', displayName: 'Faithfulness', values: { avg: TEST_SCORE_VERY_LOW, min: null, max: null, count: COUNT_FIVE, p50: null, p95: null, p99: null }, sampleCount: 5, alerts: [], status: 'warning' },
+            ];
+            const alerts = evaluateCorrelationRules(results, [warningRule, criticalRule]);
+            assert.strictEqual(alerts.length, COUNT_TWO);
+            const severities = alerts.map(a => a.severity);
+            assert.ok(severities.includes('warning'));
+            assert.ok(severities.includes('critical'));
+        });
+    });
+    // ==========================================================================
+    // Temporal MetricCondition (window + sustainedPeriods)
+    // ==========================================================================
+    describe('evaluateCorrelationRules temporal conditions', () => {
+        const makeResult = (name, avg) => makeBaseResult(name, { avg });
+        it('window condition checks value from matching previous-period result', () => {
+            const rule = {
+                name: 'window_test',
+                displayName: 'Window Test',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '7d rolling' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Test window condition',
+            };
+            // Current: relevance=TEST_SCORE_HIGH (above threshold), coherence=0.3 (below threshold)
+            const current = [makeResult('relevance', TEST_SCORE_HIGH), makeResult('coherence', TEST_SCORE_LOW)];
+            // Previous 7d: relevance=0.3 (below threshold)
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 1, 'Expected window condition to match against previous-period value');
+            assert.strictEqual(alerts[0].metricName, 'window_test');
+        });
+        it('window condition falls back to current results when window not found', () => {
+            const rule = {
+                name: 'fallback_test',
+                displayName: 'Fallback Test',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '30d rolling' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Test fallback to current',
+            };
+            // Current: relevance=0.3 (below), coherence=0.3 (below)
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            // Only 7d window available — 30d not found
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_HIGH)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            // Falls back to current relevance=0.3 which is < 0.5
+            assert.strictEqual(alerts.length, 1, 'Expected fallback to current results');
+        });
+        it('window condition does not fire when previous value is above threshold', () => {
+            const rule = {
+                name: 'no_fire_test',
+                displayName: 'No Fire Test',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '7d rolling' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should not fire',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_HIGH)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            // Window relevance=TEST_SCORE_HIGH is NOT < 0.5
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('sustainedPeriods requires condition to hold in N previous periods', () => {
+            const rule = {
+                name: 'sustained_test',
+                displayName: 'Sustained Test',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 2 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'critical',
+                explanation: 'Sustained violation',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_POOR)] },
+                { window: '14d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 1, 'Expected sustained condition to fire with 2 matching periods');
+        });
+        it('sustainedPeriods does not fire when insufficient previous periods', () => {
+            const rule = {
+                name: 'insufficient_periods',
+                displayName: 'Insufficient',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 3 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Need 3 periods',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            // Only 2 previous periods, need 3
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_POOR)] },
+                { window: '14d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('sustainedPeriods does not fire when a period breaks the streak', () => {
+            const rule = {
+                name: 'broken_streak',
+                displayName: 'Broken Streak',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 2 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Streak broken',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            // First previous period: relevance=TEST_SCORE_GOOD (above threshold — breaks streak)
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_GOOD)] },
+                { window: '14d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 0, 'Streak broken by first period');
+        });
+        it('sustainedPeriods does not fire when current period does not match', () => {
+            const rule = {
+                name: 'current_fails',
+                displayName: 'Current Fails',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 1 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Current must match too',
+            };
+            // Current relevance=TEST_SCORE_HIGH (above threshold)
+            const current = [makeResult('relevance', TEST_SCORE_HIGH), makeResult('coherence', TEST_SCORE_LOW)];
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('sustainedPeriods does not fire without previousResults', () => {
+            const rule = {
+                name: 'no_history',
+                displayName: 'No History',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 1 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'No previous data',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            const alerts = evaluateCorrelationRules(current, [rule]);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('mixed temporal and non-temporal conditions in same rule', () => {
+            const rule = {
+                name: 'mixed_rule',
+                displayName: 'Mixed Rule',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '7d rolling' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Mixed temporal and point-in-time',
+            };
+            // Current: relevance=TEST_SCORE_HIGH (healthy), coherence=0.3 (below)
+            // Previous 7d: relevance=0.3 (below)
+            const current = [makeResult('relevance', TEST_SCORE_HIGH), makeResult('coherence', TEST_SCORE_LOW)];
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 1, 'Window condition uses previous, non-temporal uses current');
+        });
+        it('backward compatible: no previousResults means all conditions use current results', () => {
+            // Existing default rules should work exactly as before
+            const current = [
+                makeResult('relevance', TEST_SCORE_MID),
+                makeResult('hallucination', TEST_HALLUCINATION_NONCOMPLIANT_SCORE),
+            ];
+            // Override p50 for relevance to trigger content_quality_crisis
+            current[0].values.p50 = TEST_SCORE_BASELINE;
+            const alerts = evaluateCorrelationRules(current, DEFAULT_CORRELATION_RULES);
+            const crisis = alerts.find(a => a.metricName === 'content_quality_crisis');
+            assert.ok(crisis, 'Default rules still work without previousResults');
+        });
+        it('registers temporal condition via Zod schema validation', () => {
+            const rule = {
+                name: 'temporal_validated',
+                displayName: 'Temporal Validated',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '30d rolling' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 3 },
+                ],
+                severity: 'warning',
+                explanation: 'Validates temporal fields pass schema',
+            };
+            registerCorrelationRule(rule);
+            const all = getCorrelationRules();
+            assert.ok(all.some(r => r.name === 'temporal_validated'));
+        });
+        it('rejects invalid window value via Zod schema', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'bad_window',
+                displayName: 'Bad Window',
+                conditions: [
+                    // Intentionally bypass static typing to verify runtime schema validation rejects invalid window strings.
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: 'invalid' },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should fail validation',
+            }));
+        });
+        it('sustainedPeriods does not fire with empty previousResults array', () => {
+            const rule = {
+                name: 'empty_array',
+                displayName: 'Empty Array',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 1 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Empty previous results array',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            const alerts = evaluateCorrelationRules(current, [rule], []);
+            assert.strictEqual(alerts.length, 0, 'Empty array has 0 entries < sustainedPeriods=1');
+        });
+        it('sustainedPeriods takes precedence over window when both set', () => {
+            const rule = {
+                name: 'both_set',
+                displayName: 'Both Set',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '7d rolling', sustainedPeriods: 1 },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'sustainedPeriods should take precedence',
+            };
+            // Current: relevance=0.3 (matches), coherence=0.3 (matches)
+            // Previous 7d: relevance=0.3 (matches for sustained)
+            const current = [makeResult('relevance', TEST_SCORE_LOW), makeResult('coherence', TEST_SCORE_LOW)];
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            // sustainedPeriods branch fires (current + 1 previous match)
+            assert.strictEqual(alerts.length, 1);
+        });
+        it('alert message annotates temporal condition sources', () => {
+            const rule = {
+                name: 'annotated_msg',
+                displayName: 'Annotated',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', window: '7d rolling' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Check message annotation',
+            };
+            const current = [makeResult('relevance', TEST_SCORE_HIGH), makeResult('coherence', TEST_SCORE_LOW)];
+            const previous = [
+                { window: '7d rolling', results: [makeResult('relevance', TEST_SCORE_LOW)] },
+            ];
+            const alerts = evaluateCorrelationRules(current, [rule], previous);
+            assert.strictEqual(alerts.length, 1);
+            assert.ok(alerts[0].message.includes('[7d rolling]'), 'Expected window annotation in message');
+        });
+        it('rejects sustainedPeriods of 0 via Zod schema', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'bad_sustained',
+                displayName: 'Bad Sustained',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: 0 },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should fail validation',
+            }));
+        });
+    });
+    describe('registerCorrelationRule', () => {
+        it('registers a custom correlation rule', () => {
+            const rule = {
+                name: 'custom_rule',
+                displayName: 'Custom Rule',
+                conditions: [
+                    { metric: 'relevance', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'coherence', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Test rule',
+            };
+            registerCorrelationRule(rule);
+            const all = getCorrelationRules();
+            assert.ok(all.some(r => r.name === 'custom_rule'));
+        });
+        it('throws on duplicate rule name', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'content_quality_crisis',
+                displayName: 'Dup',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Dup',
+            }));
+        });
+        it('rejects rule with fewer than 2 conditions', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'bad_rule',
+                displayName: 'Bad',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Test',
+            }));
+        });
+        it('rejects rule with empty explanation', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'bad_rule',
+                displayName: 'Bad',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: '',
+            }));
+        });
+        it('rejects condition with NaN value', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'nan_value',
+                displayName: 'NaN Value',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: NaN, direction: 'below' },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should fail validation',
+            }));
+        });
+        it('rejects condition with Infinity value', () => {
+            assert.throws(() => registerCorrelationRule({
+                name: 'inf_value',
+                displayName: 'Infinity Value',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: Infinity, direction: 'below' },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should fail validation',
+            }));
+        });
+        it('rejects sustainedPeriods exceeding max allowed', () => {
+            const MAX_SUSTAINED_PERIODS = 12;
+            assert.throws(() => registerCorrelationRule({
+                name: 'over_sustained',
+                displayName: 'Over Sustained',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below', sustainedPeriods: MAX_SUSTAINED_PERIODS + 1 },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Should fail validation',
+            }));
+        });
+        it('unregisters a custom rule', () => {
+            registerCorrelationRule({
+                name: 'to_remove',
+                displayName: 'Remove',
+                conditions: [
+                    { metric: 'a', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                    { metric: 'b', aggregation: 'avg', value: TEST_SCORE_MID, direction: 'below' },
+                ],
+                severity: 'warning',
+                explanation: 'Test',
+            });
+            assert.strictEqual(unregisterCorrelationRule('to_remove'), true);
+            assert.strictEqual(unregisterCorrelationRule('to_remove'), false);
+        });
+    });
+    describe('computeDashboardSummary with correlation', () => {
+        it('includes compound alerts in dashboard alerts', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+                ['hallucination', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'hallucination', scoreValue: 0.25 },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            const compoundAlerts = summary.alerts.filter(a => a.isCompound);
+            assert.ok(compoundAlerts.length > 0, 'Expected compound alerts');
+            assert.strictEqual(compoundAlerts[0].severity, 'critical');
+        });
+        it('compound alerts can upgrade overall status', () => {
+            // Create a scenario where individual metrics are only 'warning' but compound rule fires as 'critical'
+            // relevance p50 < TEST_SCORE_PASSING triggers warning, hallucination avg > TEST_SCORE_WARNING triggers warning
+            // Together they should fire content_quality_crisis as critical
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_ADEQUATE },
+                    ]],
+                ['hallucination', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'hallucination', scoreValue: 0.12 },
+                    ]],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric);
+            // Content quality crisis should fire as critical
+            const compoundAlerts = summary.alerts.filter(a => a.isCompound);
+            assert.ok(compoundAlerts.some(a => a.severity === 'critical'));
+            assert.strictEqual(summary.overallStatus, 'critical');
+        });
+    });
+    // ==========================================================================
+    // Multi-Agent Explainability (R5)
+    // ==========================================================================
+    describe('evaluateHandoffs', () => {
+        it('detects handoffs between agents', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH, explanation: 'Good start' },
+                { step: 1, score: TEST_SCORE_GOOD, explanation: 'Handoff to planner' },
+                { step: 2, score: TEST_SCORE_PASSING, explanation: 'Planning' },
+            ];
+            const agentMap = new Map([[0, 'router'], [1, 'planner'], [COUNT_TWO, 'planner']]);
+            const handoffs = evaluateHandoffs(steps, agentMap);
+            assert.strictEqual(handoffs.length, 1);
+            assert.strictEqual(handoffs[0].sourceAgent, 'router');
+            assert.strictEqual(handoffs[0].targetAgent, 'planner');
+            assert.strictEqual(handoffs[0].correctTarget, true);
+        });
+        it('returns empty for single agent', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_GOOD },
+            ];
+            const agentMap = new Map([[0, 'agent'], [1, 'agent']]);
+            const handoffs = evaluateHandoffs(steps, agentMap);
+            assert.strictEqual(handoffs.length, 0);
+        });
+        it('returns empty without agent map', () => {
+            const steps = [{ step: 0, score: TEST_SCORE_HIGH }];
+            const handoffs = evaluateHandoffs(steps);
+            assert.strictEqual(handoffs.length, 0);
+        });
+        it('marks low-score handoff as incorrect target', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_VERY_LOW },
+            ];
+            const agentMap = new Map([[0, 'a'], [1, 'b']]);
+            const handoffs = evaluateHandoffs(steps, agentMap);
+            assert.strictEqual(handoffs[0].correctTarget, false);
+            assert.strictEqual(handoffs[0].contextPreserved, false);
+        });
+        it('uses custom thresholds when provided', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_BASELINE },
+            ];
+            const agentMap = new Map([[0, 'a'], [1, 'b']]);
+            const thresholds = { correctTarget: TEST_SCORE_PASSING, contextPreserved: TEST_SCORE_HIGH };
+            const handoffs = evaluateHandoffs(steps, agentMap, thresholds);
+            assert.strictEqual(handoffs[0].correctTarget, false); // TEST_SCORE_BASELINE < TEST_SCORE_PASSING
+            assert.strictEqual(handoffs[0].contextPreserved, false); // TEST_SCORE_BASELINE < TEST_SCORE_HIGH
+        });
+        it('applies default thresholds when none provided', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: 0.55 },
+            ];
+            const agentMap = new Map([[0, 'a'], [1, 'b']]);
+            const handoffs = evaluateHandoffs(steps, agentMap);
+            assert.strictEqual(handoffs[0].correctTarget, true); // 0.55 >= 0.5
+            assert.strictEqual(handoffs[0].contextPreserved, false); // 0.55 < TEST_SCORE_PASSING
+        });
+    });
+    describe('computeTurnLevelResults', () => {
+        it('maps step scores to turn results', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_MID },
+                { step: 2, score: TEST_SCORE_WARNING },
+            ];
+            const turns = computeTurnLevelResults(steps);
+            assert.strictEqual(turns.length, COUNT_THREE);
+            assert.strictEqual(turns[0].taskProgress, 1); // TEST_SCORE_HIGH >= TEST_SCORE_GOOD
+            assert.strictEqual(turns[1].taskProgress, TEST_SCORE_MID); // 0.5 >= 0.5
+            assert.strictEqual(turns[2].hasError, true); // TEST_SCORE_WARNING < 0.3
+        });
+        it('includes agent names from map', () => {
+            const steps = [{ step: 0, score: TEST_SCORE_GOOD }];
+            const agentMap = new Map([[0, 'researcher']]);
+            const turns = computeTurnLevelResults(steps, agentMap);
+            assert.strictEqual(turns[0].agentName, 'researcher');
+        });
+        it('skips named steps (non-numeric)', () => {
+            const steps = [
+                { step: 'planning', score: TEST_SCORE_HIGH },
+                { step: 0, score: TEST_SCORE_GOOD },
+            ];
+            const turns = computeTurnLevelResults(steps);
+            assert.strictEqual(turns.length, 1);
+            assert.strictEqual(turns[0].turnIndex, 0);
+        });
+    });
+    describe('computeMultiAgentEvaluation', () => {
+        it('aggregates handoffs and turns', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_GOOD },
+                { step: 2, score: TEST_SCORE_PASSING },
+            ];
+            const agentMap = new Map([[0, 'router'], [1, 'planner'], [COUNT_TWO, 'executor']]);
+            const result = computeMultiAgentEvaluation(steps, agentMap);
+            assert.strictEqual(result.totalTurns, COUNT_THREE);
+            assert.ok(result.handoffScore !== null);
+            assert.ok(result.avgTurnRelevance !== null);
+            assert.strictEqual(result.handoffs.length, COUNT_TWO); // router->planner, planner->executor
+        });
+        it('computes error propagation turns', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_VERY_LOW }, // error
+                { step: 2, score: TEST_SCORE_LOW },
+                { step: 3, score: TEST_SCORE_WARNING }, // error
+            ];
+            const result = computeMultiAgentEvaluation(steps);
+            assert.strictEqual(result.errorPropagationTurns, COUNT_TWO); // 2 turns after first error
+        });
+        it('handles empty step scores', () => {
+            const result = computeMultiAgentEvaluation([]);
+            assert.strictEqual(result.totalTurns, 0);
+            assert.strictEqual(result.handoffScore, null);
+            assert.strictEqual(result.avgTurnRelevance, null);
+            assert.strictEqual(result.conversationCompleteness, null);
+            assert.strictEqual(result.errorPropagationTurns, 0);
+        });
+        it('conversation completeness uses last turn', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_MID },
+                { step: 1, score: TEST_SCORE_HIGH }, // taskProgress = 1
+            ];
+            const result = computeMultiAgentEvaluation(steps);
+            assert.strictEqual(result.conversationCompleteness, 1);
+        });
+        it('treats agentMap with all-same agents as single-agent (no handoffs)', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_GOOD },
+            ];
+            // All steps mapped to same agent - should produce no handoffs
+            const agentMap = new Map([[0, 'only_agent'], [1, 'only_agent']]);
+            const result = computeMultiAgentEvaluation(steps, agentMap);
+            assert.strictEqual(result.handoffs.length, 0);
+            assert.strictEqual(result.handoffScore, null);
+        });
+        it('passes custom handoff thresholds through', () => {
+            const steps = [
+                { step: 0, score: TEST_SCORE_HIGH },
+                { step: 1, score: TEST_SCORE_BASELINE },
+            ];
+            const agentMap = new Map([[0, 'a'], [1, 'b']]);
+            const result = computeMultiAgentEvaluation(steps, agentMap, undefined, { correctTarget: TEST_SCORE_GOOD, contextPreserved: TEST_SCORE_HIGH });
+            assert.strictEqual(result.handoffs[0].correctTarget, false); // TEST_SCORE_BASELINE < TEST_SCORE_GOOD
+            assert.strictEqual(result.handoffs[0].contextPreserved, false); // TEST_SCORE_BASELINE < TEST_SCORE_HIGH
+        });
+    });
+    // ==========================================================================
+    // Role-Specific Views (G7)
+    // ==========================================================================
+    describe('computeRoleView', () => {
+        function makeDashboard() {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_LOW },
+                    ]],
+                ['faithfulness', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'faithfulness', scoreValue: TEST_SCORE_HIGH },
+                    ]],
+            ]);
+            return computeDashboardSummary(evaluationsByMetric);
+        }
+        it('creates executive view with status summary', () => {
+            const dashboard = makeDashboard();
+            const view = computeRoleView(dashboard, 'executive');
+            assert.strictEqual(view.role, 'executive');
+            assert.ok(view.summary);
+            assert.ok(view.metricStatuses.length > 0);
+            assert.ok('alertCounts' in view);
+            assert.strictEqual(typeof view.alertCounts.critical, 'number');
+        });
+        it('creates operator view with prioritized alerts', () => {
+            const dashboard = makeDashboard();
+            const view = computeRoleView(dashboard, 'operator');
+            assert.strictEqual(view.role, 'operator');
+            assert.ok(Array.isArray(view.prioritizedAlerts));
+            assert.ok(Array.isArray(view.alertingMetrics));
+            assert.ok(Array.isArray(view.degradingTrends));
+            // Alerts should be sorted critical-first
+            if (view.prioritizedAlerts.length >= COUNT_TWO) {
+                const severityOrder = { critical: 0, warning: 1, info: 2 };
+                for (let i = 1; i < view.prioritizedAlerts.length; i++) {
+                    assert.ok(severityOrder[view.prioritizedAlerts[i].severity] >=
+                        severityOrder[view.prioritizedAlerts[i - 1].severity]);
+                }
+            }
+        });
+        it('creates auditor view with full provenance', () => {
+            const dashboard = makeDashboard();
+            const view = computeRoleView(dashboard, 'auditor');
+            assert.strictEqual(view.role, 'auditor');
+            assert.ok(view.metrics.length > 0);
+            assert.ok(view.alerts.length >= 0);
+            assert.ok(view.timestamp);
+            assert.strictEqual(typeof view.totalEvaluationCount, 'number');
+        });
+        it('operator view filters to alerting metrics only', () => {
+            const dashboard = makeDashboard();
+            const view = computeRoleView(dashboard, 'operator');
+            for (const metric of view.alertingMetrics) {
+                assert.ok(metric.alerts.length > 0, `${metric.name} should have alerts`);
+            }
+        });
+        it('executive view includes topIssues sorted by severity', () => {
+            const dashboard = makeDashboard();
+            const view = computeRoleView(dashboard, 'executive');
+            assert.ok(Array.isArray(view.topIssues));
+            assert.ok(view.topIssues.length <= COUNT_FIVE); // default limit
+            // Should be sorted worst-first
+            if (view.topIssues.length >= COUNT_TWO) {
+                const statusOrder = { critical: 0, warning: 1, no_data: 2, healthy: 3 };
+                for (let i = 1; i < view.topIssues.length; i++) {
+                    assert.ok((statusOrder[view.topIssues[i].status] ?? COUNT_THREE) >=
+                        (statusOrder[view.topIssues[i - 1].status] ?? COUNT_THREE));
+                }
+            }
+        });
+        it('executive view respects configurable topIssuesLimit', () => {
+            const dashboard = makeDashboard();
+            const view = computeRoleView(dashboard, 'executive', { topIssuesLimit: 2 });
+            assert.ok(view.topIssues.length <= COUNT_TWO);
+        });
+        it('operator view filters out info-level alerts', () => {
+            const dashboard = makeDashboard();
+            // Add an info alert
+            dashboard.alerts.push({
+                severity: 'info', message: 'Info alert', aggregation: 'avg',
+                threshold: TEST_SCORE_MID, actualValue: TEST_SCORE_BASELINE, direction: 'below', metricName: 'test',
+            });
+            const view = computeRoleView(dashboard, 'operator');
+            for (const alert of view.prioritizedAlerts) {
+                assert.notStrictEqual(alert.severity, 'info');
+            }
+        });
+        it('operator view filters by minActionableSampleCount', () => {
+            const dashboard = makeDashboard();
+            // All existing alerts should have affectedCount from computeQualityMetric
+            const view = computeRoleView(dashboard, 'operator', { minActionableSampleCount: COUNT_THOUSAND });
+            // With very high threshold, alerts with low affectedCount should be filtered
+            for (const alert of view.prioritizedAlerts) {
+                if (alert.affectedCount !== undefined) {
+                    assert.ok(alert.affectedCount >= COUNT_THOUSAND);
+                }
+            }
+        });
+        it('executive view includes SLA summary when available', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+                    ]],
+            ]);
+            const slas = [
+                { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' },
+            ];
+            const dashboard = computeDashboardSummary(evaluationsByMetric, undefined, undefined, slas);
+            const view = computeRoleView(dashboard, 'executive');
+            assert.strictEqual(view.slaCompliantCount, 1);
+            assert.strictEqual(view.slaTotalCount, 1);
+        });
+    });
+    // ==========================================================================
+    // Progressive Disclosure (G3)
+    // ==========================================================================
+    describe('computeMetricDetail', () => {
+        const config = QUALITY_METRICS.relevance;
+        it('includes score distribution with 10 buckets by default', () => {
+            const evals = Array.from({ length: COUNT_TWENTY }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: i / COUNT_TWENTY,
+            }));
+            const detail = computeMetricDetail(evals, config);
+            assert.strictEqual(detail.scoreDistribution.length, COUNT_TEN);
+            const totalCount = detail.scoreDistribution.reduce((s, b) => s + b.count, 0);
+            assert.strictEqual(totalCount, COUNT_TWENTY);
+        });
+        it('supports configurable bucket count', () => {
+            const evals = Array.from({ length: COUNT_TWENTY }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: i / COUNT_TWENTY,
+            }));
+            const detail = computeMetricDetail(evals, config, { bucketCount: COUNT_FIVE });
+            assert.strictEqual(detail.scoreDistribution.length, COUNT_FIVE);
+            const totalCount = detail.scoreDistribution.reduce((s, b) => s + b.count, 0);
+            assert.strictEqual(totalCount, COUNT_TWENTY);
+        });
+        it('clamps bucket count to valid range (2-100)', () => {
+            const evals = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_MID },
+            ];
+            const detailLow = computeMetricDetail(evals, config, { bucketCount: 1 });
+            assert.strictEqual(detailLow.scoreDistribution.length, COUNT_TWO); // clamped to min 2
+            const detailHigh = computeMetricDetail(evals, config, { bucketCount: COUNT_TWO_HUNDRED });
+            assert.strictEqual(detailHigh.scoreDistribution.length, COUNT_HUNDRED); // clamped to max 100
+        });
+        it('includes worst evaluations sorted ascending', () => {
+            const evals = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH, explanation: 'Great' },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_VERY_LOW, explanation: 'Bad' },
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_MID, explanation: 'Ok' },
+            ];
+            const detail = computeMetricDetail(evals, config);
+            assert.strictEqual(detail.worstEvaluations[0].scoreValue, TEST_SCORE_VERY_LOW);
+            assert.strictEqual(detail.worstEvaluations[0].explanation, 'Bad');
+        });
+        it('includes best evaluations sorted descending', () => {
+            const evals = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_VERY_LOW },
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_MID },
+            ];
+            const detail = computeMetricDetail(evals, config);
+            assert.strictEqual(detail.bestEvaluations[0].scoreValue, TEST_SCORE_HIGH);
+        });
+        it('respects topN parameter', () => {
+            const evals = Array.from({ length: COUNT_TWENTY }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: i / COUNT_TWENTY,
+            }));
+            const detail = computeMetricDetail(evals, config, { topN: 3 });
+            assert.strictEqual(detail.worstEvaluations.length, COUNT_THREE);
+            assert.strictEqual(detail.bestEvaluations.length, COUNT_THREE);
+        });
+        it('inherits base QualityMetricResult fields', () => {
+            const evals = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD },
+            ];
+            const detail = computeMetricDetail(evals, config);
+            assert.strictEqual(detail.name, 'relevance');
+            assert.strictEqual(detail.sampleCount, 1);
+            assert.ok(detail.values.avg !== null);
+        });
+        it('handles empty evaluations', () => {
+            const detail = computeMetricDetail([], config);
+            assert.strictEqual(detail.scoreDistribution.length, COUNT_TEN);
+            assert.strictEqual(detail.worstEvaluations.length, 0);
+            assert.strictEqual(detail.bestEvaluations.length, 0);
+        });
+    });
+    describe('toEvaluationDetail', () => {
+        it('converts EvaluationResult to EvaluationDetailResult', () => {
+            const eval_ = {
+                timestamp: '2026-01-01T00:00:00Z',
+                evaluationName: 'relevance',
+                scoreValue: TEST_SCORE_STRONG,
+                scoreLabel: 'pass',
+                explanation: 'Good match',
+                evaluator: 'gpt-4',
+                evaluatorType: 'llm',
+                traceId: 'trace-123',
+                spanId: 'span-456',
+                sessionId: 'sess-789',
+            };
+            const detail = toEvaluationDetail(eval_);
+            assert.strictEqual(detail.evaluationName, 'relevance');
+            assert.strictEqual(detail.scoreValue, TEST_SCORE_STRONG);
+            assert.strictEqual(detail.explanation, 'Good match');
+            assert.strictEqual(detail.traceId, 'trace-123');
+            assert.strictEqual(detail.timestamp, '2026-01-01T00:00:00Z');
+        });
+        it('handles optional fields as undefined', () => {
+            const eval_ = {
+                timestamp: '2026-01-01T00:00:00Z',
+                evaluationName: 'relevance',
+            };
+            const detail = toEvaluationDetail(eval_);
+            assert.strictEqual(detail.scoreValue, undefined);
+            assert.strictEqual(detail.explanation, undefined);
+            assert.strictEqual(detail.traceId, undefined);
+        });
+    });
+    // ==========================================================================
+    // Contextual Severity (G5)
+    // ==========================================================================
+    describe('applySeverityContext', () => {
+        const makeAlerts = () => [
+            { severity: 'info', message: 'Info', aggregation: 'avg', threshold: TEST_SCORE_MID, actualValue: TEST_SCORE_POOR, direction: 'below' },
+            { severity: 'warning', message: 'Warning', aggregation: 'p50', threshold: TEST_SCORE_PASSING, actualValue: TEST_SCORE_BASELINE, direction: 'below' },
+            { severity: 'critical', message: 'Critical', aggregation: 'p50', threshold: TEST_SCORE_MID, actualValue: TEST_SCORE_LOW, direction: 'below' },
+        ];
+        it('suppresses info alerts when suppressInfo is true', () => {
+            const result = applySeverityContext(makeAlerts(), { suppressInfo: true });
+            assert.strictEqual(result.length, COUNT_TWO);
+            assert.ok(result.every(a => a.severity !== 'info'));
+        });
+        it('escalates warnings to critical when escalateWarnings is true', () => {
+            const result = applySeverityContext(makeAlerts(), { escalateWarnings: true });
+            assert.strictEqual(result.length, COUNT_THREE);
+            const severities = result.map(a => a.severity);
+            assert.ok(!severities.includes('warning'));
+            assert.strictEqual(severities.filter(s => s === 'critical').length, COUNT_TWO);
+        });
+        it('suppresses all alerts when below minSampleCount', () => {
+            const result = applySeverityContext(makeAlerts(), { minSampleCount: COUNT_TEN }, COUNT_FIVE);
+            assert.strictEqual(result.length, 0);
+        });
+        it('keeps alerts when at or above minSampleCount', () => {
+            const result = applySeverityContext(makeAlerts(), { minSampleCount: COUNT_TEN }, COUNT_TEN);
+            assert.strictEqual(result.length, COUNT_THREE);
+        });
+        it('applies multiple context rules together', () => {
+            const result = applySeverityContext(makeAlerts(), {
+                suppressInfo: true,
+                escalateWarnings: true,
+            });
+            assert.strictEqual(result.length, COUNT_TWO);
+            assert.ok(result.every(a => a.severity === 'critical'));
+        });
+        it('returns original alerts with empty context', () => {
+            const result = applySeverityContext(makeAlerts(), {});
+            assert.strictEqual(result.length, COUNT_THREE);
+        });
+        it('does not mutate original alerts', () => {
+            const alerts = makeAlerts();
+            const original = alerts.map(a => ({ ...a }));
+            applySeverityContext(alerts, { escalateWarnings: true });
+            assert.deepStrictEqual(alerts, original);
+        });
+        it('applies rules when environment pattern matches exactly', () => {
+            const result = applySeverityContext(makeAlerts(), { environment: 'production', escalateWarnings: true }, undefined, 'production');
+            assert.ok(result.every(a => a.severity !== 'warning'));
+        });
+        it('skips rules when environment pattern does not match', () => {
+            const result = applySeverityContext(makeAlerts(), { environment: 'production', escalateWarnings: true }, undefined, 'staging');
+            // Rules not applied - warning should still be present
+            assert.ok(result.some(a => a.severity === 'warning'));
+            assert.strictEqual(result.length, COUNT_THREE);
+        });
+        it('supports glob wildcard pattern matching', () => {
+            const result = applySeverityContext(makeAlerts(), { environment: 'prod*', escalateWarnings: true }, undefined, 'production');
+            assert.ok(result.every(a => a.severity !== 'warning'));
+        });
+        it('supports single-character wildcard (?)', () => {
+            const result = applySeverityContext(makeAlerts(), { environment: 'staging-?', suppressInfo: true }, undefined, 'staging-a');
+            assert.ok(result.every(a => a.severity !== 'info'));
+        });
+        it('matches case-insensitively', () => {
+            const result = applySeverityContext(makeAlerts(), { environment: 'PRODUCTION', escalateWarnings: true }, undefined, 'production');
+            assert.ok(result.every(a => a.severity !== 'warning'));
+        });
+        it('applies rules when no currentEnvironment provided (no filtering)', () => {
+            const result = applySeverityContext(makeAlerts(), { environment: 'production', escalateWarnings: true });
+            // No currentEnvironment => rules apply regardless
+            assert.ok(result.every(a => a.severity !== 'warning'));
+        });
+        it('rejects overly long environment patterns (ReDoS protection)', () => {
+            const longPattern = 'a'.repeat(COUNT_TWO_HUNDRED) + '*';
+            const result = applySeverityContext(makeAlerts(), { environment: longPattern, escalateWarnings: true }, undefined, 'production');
+            // Pattern too long => no match => rules not applied => original alerts returned
+            assert.ok(result.some(a => a.severity === 'warning'));
+            assert.strictEqual(result.length, COUNT_THREE);
+        });
+    });
+    // ==========================================================================
+    // SLA Tracking (G11)
+    // ==========================================================================
+    describe('evaluateSLA', () => {
+        const makeResult = (name, p50) => makeBaseResult(name, { p50 });
+        it('reports compliant SLA (above direction)', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_STRONG)]);
+            assert.strictEqual(result.compliant, true);
+            assert.strictEqual(result.actualValue, TEST_SCORE_STRONG);
+            assert.ok(requireDefined(result.gap) > 0);
+        });
+        it('reports non-compliant SLA (above direction)', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_ADEQUATE)]);
+            assert.strictEqual(result.compliant, false);
+            assert.ok(requireDefined(result.gap) < 0);
+        });
+        it('reports compliant SLA (below direction)', () => {
+            const sla = { metric: 'hallucination', aggregation: 'p50', target: TEST_SCORE_WARNING, direction: 'below' };
+            const result = evaluateSLA(sla, [makeResult('hallucination', DELTA)]);
+            assert.strictEqual(result.compliant, true);
+            assert.ok(requireDefined(result.gap) > 0);
+        });
+        it('reports non-compliant SLA (below direction)', () => {
+            const sla = { metric: 'hallucination', aggregation: 'p50', target: TEST_SCORE_WARNING, direction: 'below' };
+            const result = evaluateSLA(sla, [makeResult('hallucination', TEST_HALLUCINATION_NONCOMPLIANT_SCORE)]);
+            assert.strictEqual(result.compliant, false);
+            assert.ok(requireDefined(result.gap) < 0);
+        });
+        it('handles missing metric data with metric_not_found status', () => {
+            const sla = { metric: 'unknown', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_STRONG)]);
+            assert.strictEqual(result.compliant, false);
+            assert.strictEqual(result.status, 'metric_not_found');
+            assert.strictEqual(result.actualValue, null);
+            assert.strictEqual(result.gap, null);
+        });
+        it('handles null aggregation value with no_data status', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', null)]);
+            assert.strictEqual(result.compliant, false);
+            assert.strictEqual(result.status, 'no_data');
+            assert.strictEqual(result.actualValue, null);
+        });
+        it('returns compliant status when SLA is met', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_HIGH)]);
+            assert.strictEqual(result.status, 'compliant');
+        });
+        it('returns non_compliant status when SLA is not met', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_BASELINE)]);
+            assert.strictEqual(result.status, 'non_compliant');
+        });
+        it('computes marginPercent', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_RELEVANCE_MARGIN_SCORE)]);
+            assert.ok(result.marginPercent !== null);
+            assert.strictEqual(result.marginPercent, COUNT_TEN); // 0.08 / TEST_SCORE_GOOD = 10%
+        });
+        it('exactly at target is compliant for above direction', () => {
+            const sla = { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_GOOD)]);
+            assert.strictEqual(result.compliant, true);
+        });
+        it('accepts recognized SLA window formats', () => {
+            // Type-level enforcement: SLAWindowFormat only allows recognized formats
+            const sla = {
+                metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above',
+                window: '30d rolling',
+            };
+            const result = evaluateSLA(sla, [makeResult('relevance', TEST_SCORE_STRONG)]);
+            assert.strictEqual(result.sla.window, '30d rolling');
+            assert.strictEqual(result.compliant, true);
+        });
+        it('slaWindowFormatSchema includes all recognized window formats', () => {
+            assert.ok(slaWindowFormatSchema.options.length >= COUNT_TEN);
+            assert.ok(slaWindowFormatSchema.options.includes('30d rolling'));
+            assert.ok(slaWindowFormatSchema.options.includes('calendar month'));
+            assert.ok(slaWindowFormatSchema.options.includes('calendar year'));
+        });
+    });
+    describe('evaluateSLAs', () => {
+        const makeResult = (name, p50) => makeBaseResult(name, { p50 });
+        it('evaluates multiple SLAs', () => {
+            const slas = [
+                { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' },
+                { metric: 'coherence', aggregation: 'p50', target: TEST_SCORE_PASSING, direction: 'above' },
+            ];
+            const result = evaluateSLAs(slas, [makeResult('relevance', TEST_SCORE_HIGH), makeResult('coherence', TEST_SCORE_BASELINE)]);
+            assert.strictEqual(result.noSLAsConfigured, false);
+            assert.strictEqual(result.results.length, COUNT_TWO);
+            assert.strictEqual(result.results[0].compliant, true);
+            assert.strictEqual(result.results[1].compliant, false);
+        });
+        it('returns structured empty result when no SLAs configured', () => {
+            const result = evaluateSLAs([], [makeResult('relevance', TEST_SCORE_HIGH)]);
+            assert.strictEqual(result.noSLAsConfigured, true);
+            assert.strictEqual(result.results.length, 0);
+        });
+    });
+    describe('computeDashboardSummary with SLAs', () => {
+        it('includes SLA compliance when definitions provided', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+                    ]],
+            ]);
+            const slas = [
+                { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above' },
+            ];
+            const summary = computeDashboardSummary(evaluationsByMetric, undefined, undefined, slas);
+            assert.ok(summary.slaCompliance);
+            assert.strictEqual(requireDefined(summary.slaCompliance).length, 1);
+            assert.strictEqual(requireDefined(summary.slaCompliance)[0].compliant, true);
+        });
+        it('omits SLA compliance when no definitions', () => {
+            const summary = computeDashboardSummary(new Map());
+            assert.strictEqual(summary.slaCompliance, undefined);
+        });
+        it('includes trends when previousPeriodValues provided', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-02T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+                    ]],
+            ]);
+            const previousPeriodValues = new Map([
+                ['relevance', { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.70, p95: null, p99: null }],
+            ]);
+            const summary = computeDashboardSummary(evaluationsByMetric, undefined, undefined, undefined, previousPeriodValues);
+            const relevanceMetric = summary.metrics.find(m => m.name === 'relevance');
+            assert.ok(relevanceMetric?.trend);
+            assert.strictEqual(requireDefined(requireDefined(relevanceMetric).trend).direction, 'improving');
+        });
+    });
+    describe('MetricConfigBuilder.sla', () => {
+        it('creates an SLA definition from builder', () => {
+            const sla = createMetricConfig('test_sla')
+                .displayName('Test SLA')
+                .description('Test')
+                .sla('p50', TEST_SCORE_GOOD, 'above', '30d rolling');
+            assert.strictEqual(sla.metric, 'test_sla');
+            assert.strictEqual(sla.aggregation, 'p50');
+            assert.strictEqual(sla.target, TEST_SCORE_GOOD);
+            assert.strictEqual(sla.direction, 'above');
+            assert.strictEqual(sla.window, '30d rolling');
+        });
+    });
+    // ==========================================================================
+    // Confidence Indicators (R3)
+    // ==========================================================================
+    describe('computeConfidence', () => {
+        it('returns low confidence for small sample (<10)', () => {
+            const evals = Array.from({ length: COUNT_FIVE }, (_, i) => ({
+                timestamp: `2026-01-01T00:0${i}:00Z`, evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD,
+            }));
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.level, 'low');
+            assert.strictEqual(confidence.sampleCount, COUNT_FIVE);
+        });
+        it('returns high confidence for large consistent sample', () => {
+            const evals = Array.from({ length: COUNT_SIXTY }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD + (i % COUNT_THREE) * TEST_DECIMAL_EPSILON,
+            }));
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.level, 'high');
+            assert.strictEqual(confidence.sampleCount, COUNT_SIXTY);
+            assert.ok(confidence.scoreStdDev !== null &&
+                confidence.scoreStdDev < TEST_HALLUCINATION_NONCOMPLIANT_SCORE);
+        });
+        it('returns medium confidence for moderate sample', () => {
+            const evals = Array.from({ length: COUNT_TWENTY_FIVE }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: TEST_SCORE_MID + (i % COUNT_FIVE) * DELTA,
+            }));
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.level, 'medium');
+        });
+        it('returns low confidence for high variance scores', () => {
+            const evals = Array.from({ length: COUNT_TWENTY }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: i % COUNT_TWO === 0 ? TEST_SCORE_WARNING : TEST_SCORE_HIGH,
+            }));
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.level, 'low');
+            assert.ok(confidence.scoreStdDev !== null && confidence.scoreStdDev > TEST_SCORE_LOW);
+        });
+        it('computes evaluator agreement for multiple judges', () => {
+            const evals = [
+                ...Array.from({ length: 30 }, (_, i) => ({
+                    timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                    evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG, evaluator: 'judge-a',
+                })),
+                ...Array.from({ length: 30 }, (_, i) => ({
+                    timestamp: `2026-01-01T00:01:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                    evaluationName: 'relevance', scoreValue: 0.83, evaluator: 'judge-b',
+                })),
+            ];
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.evaluatorCount, COUNT_TWO);
+            assert.ok(confidence.evaluatorAgreement !== null);
+            assert.ok(requireDefined(confidence.evaluatorAgreement) > TEST_SCORE_HIGH); // High agreement
+        });
+        it('computes range-aware evaluator agreement for non-[0,1] metrics', () => {
+            // Two judges scoring latency (0-60s range) with means 10s and 12s
+            const evals = [
+                ...Array.from({ length: 30 }, (_, i) => ({
+                    timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                    evaluationName: 'evaluation_latency', scoreValue: COUNT_TEN, evaluator: 'judge-a',
+                })),
+                ...Array.from({ length: 30 }, (_, i) => ({
+                    timestamp: `2026-01-01T00:01:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                    evaluationName: 'evaluation_latency', scoreValue: 12, evaluator: 'judge-b',
+                })),
+            ];
+            // With [0,60] range, max stddev = 30, so 1s difference is very small
+            const confidence = computeConfidence(evals, undefined, { min: 0, max: COUNT_SIXTY });
+            assert.ok(confidence.evaluatorAgreement !== null);
+            assert.ok(requireDefined(confidence.evaluatorAgreement) > TEST_SCORE_EXCELLENT, `Expected high agreement for small diff in wide range, got ${confidence.evaluatorAgreement}`);
+            // Same data with default [0,1] range would show lower agreement
+            const defaultConf = computeConfidence(evals);
+            assert.ok(defaultConf.evaluatorAgreement !== null);
+            // stddev of [10, 12] = ~1.41, /0.5 = 2.83, 1 - 2.83 = clamped to 0
+            assert.strictEqual(defaultConf.evaluatorAgreement, 0);
+        });
+        it('returns null agreement for single evaluator', () => {
+            const evals = Array.from({ length: COUNT_TEN }, (_, i) => ({
+                timestamp: `2026-01-01T00:0${i}:00Z`, evaluationName: 'relevance',
+                scoreValue: TEST_SCORE_GOOD, evaluator: 'judge-a',
+            }));
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.evaluatorCount, 1);
+            assert.strictEqual(confidence.evaluatorAgreement, null);
+        });
+        it('filters evaluations without scores', () => {
+            const evals = [
+                { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD },
+                { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance' }, // no score
+                { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: undefined },
+            ];
+            const confidence = computeConfidence(evals);
+            assert.strictEqual(confidence.sampleCount, 1);
+        });
+        it('uses custom thresholds when provided', () => {
+            // 8 samples: normally "low" (default threshold is 10), but with custom threshold of 5 it's "medium"
+            const evals = Array.from({ length: 8 }, (_, i) => ({
+                timestamp: `2026-01-01T00:0${i}:00Z`, evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD,
+            }));
+            const defaultConf = computeConfidence(evals);
+            assert.strictEqual(defaultConf.level, 'low');
+            const customConf = computeConfidence(evals, { lowSampleThreshold: COUNT_FIVE });
+            assert.strictEqual(customConf.level, 'medium');
+        });
+        it('custom high thresholds raise the bar for high confidence', () => {
+            const evals = Array.from({ length: COUNT_SIXTY }, (_, i) => ({
+                timestamp: `2026-01-01T00:00:${String(i).padStart(COUNT_TWO, '0')}Z`,
+                evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD + (i % COUNT_THREE) * TEST_DECIMAL_EPSILON,
+            }));
+            const defaultConf = computeConfidence(evals);
+            assert.strictEqual(defaultConf.level, 'high');
+            const strictConf = computeConfidence(evals, { highSampleThreshold: COUNT_HUNDRED });
+            assert.strictEqual(strictConf.level, 'medium'); // 60 < 100
+        });
+    });
+    describe('computeQualityMetric with confidence', () => {
+        it('includes confidence when evaluations have scores', () => {
+            const evaluations = Array.from({ length: COUNT_FIFTEEN }, (_, i) => ({
+                timestamp: `2026-01-01T00:0${i}:00Z`, evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG,
+            }));
+            const result = computeQualityMetric(evaluations, QUALITY_METRICS.relevance);
+            assert.ok(result.confidence);
+            assert.strictEqual(result.confidence.sampleCount, COUNT_FIFTEEN);
+        });
+        it('omits confidence when no scored evaluations', () => {
+            const result = computeQualityMetric([], QUALITY_METRICS.relevance);
+            assert.strictEqual(result.confidence, undefined);
+        });
+    });
+    // ==========================================================================
+    // Trend Analysis (G4)
+    // ==========================================================================
+    describe('computeTrend', () => {
+        it('detects improving trend for below-direction metric', () => {
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_STRONG, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_PASSING, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance);
+            assert.ok(trend);
+            assert.strictEqual(trend.direction, 'improving');
+            assert.ok(Math.abs(trend.delta - TEST_HALLUCINATION_NONCOMPLIANT_SCORE) < TEST_DECIMAL_EPSILON);
+            assert.strictEqual(trend.aggregation, 'p50');
+            assert.strictEqual(trend.currentValue, TEST_SCORE_STRONG);
+            assert.strictEqual(trend.previousValue, TEST_SCORE_PASSING);
+            assert.ok(requireDefined(trend.percentChange) > 0);
+        });
+        it('detects degrading trend for below-direction metric', () => {
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_BASELINE, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.80, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance);
+            assert.ok(trend);
+            assert.strictEqual(trend.direction, 'degrading');
+            assert.ok(trend.delta < 0);
+        });
+        it('detects improving trend for above-direction metric (hallucination)', () => {
+            const current = { avg: DELTA, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const previous = { avg: 0.15, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.hallucination);
+            assert.ok(trend);
+            assert.strictEqual(trend.direction, 'improving'); // Decrease in hallucination is good
+            assert.ok(trend.delta < 0);
+        });
+        it('detects degrading trend for above-direction metric', () => {
+            const current = { avg: 0.20, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const previous = { avg: 0.08, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.hallucination);
+            assert.ok(trend);
+            assert.strictEqual(trend.direction, 'degrading');
+        });
+        it('detects stable trend for tiny changes', () => {
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.8005, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.8001, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance);
+            assert.ok(trend);
+            assert.strictEqual(trend.direction, 'stable');
+        });
+        it('returns undefined when current value is null', () => {
+            const current = { avg: null, min: null, max: null, count: null, p50: null, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.80, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance);
+            assert.strictEqual(trend, undefined);
+        });
+        it('returns undefined when previous value is null', () => {
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.80, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: null, p50: null, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance);
+            assert.strictEqual(trend, undefined);
+        });
+        it('handles zero previous value (null percentChange)', () => {
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.50, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance);
+            assert.ok(trend);
+            assert.strictEqual(trend.percentChange, null);
+        });
+        it('uses range-aware stability threshold for latency metric', () => {
+            // evaluation_latency has range 0-60, so stability threshold = 60 * 0.001 = 0.06
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: 5.02, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: 5.0, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.evaluation_latency);
+            assert.ok(trend);
+            assert.strictEqual(trend.direction, 'stable'); // 0.02 < 0.06 threshold
+        });
+        it('uses avg aggregation when config has no alerts', () => {
+            const config = {
+                name: 'test', displayName: 'Test', description: 'Test',
+                aggregations: ['avg'], alerts: [], range: { min: 0, max: 1 }, unit: 'score',
+            };
+            const current = { avg: TEST_SCORE_HIGH, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const previous = { avg: TEST_SCORE_PASSING, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const trend = computeTrend(current, previous, config);
+            assert.ok(trend);
+            assert.strictEqual(trend.aggregation, 'avg');
+        });
+        it('sets lowSampleWarning when sample count is below TREND_MIN_SAMPLE_SIZE', () => {
+            const current = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: TEST_SCORE_STRONG, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.70, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance, COUNT_FIFTEEN);
+            assert.ok(trend);
+            assert.strictEqual(trend.lowSampleWarning, true);
+        });
+        it('does not set lowSampleWarning when sample count meets minimum', () => {
+            const current = { avg: null, min: null, max: null, count: 50, p50: TEST_SCORE_STRONG, p95: null, p99: null };
+            const previous = { avg: null, min: null, max: null, count: 50, p50: 0.70, p95: null, p99: null };
+            const trend = computeTrend(current, previous, QUALITY_METRICS.relevance, COUNT_FIFTY);
+            assert.ok(trend);
+            assert.strictEqual(trend.lowSampleWarning, undefined);
+        });
+        it('exports TREND_MIN_SAMPLE_SIZE constant', () => {
+            assert.strictEqual(typeof TREND_MIN_SAMPLE_SIZE, 'number');
+            assert.strictEqual(TREND_MIN_SAMPLE_SIZE, COUNT_THIRTY);
+        });
+    });
+    describe('computeQualityMetric with trend', () => {
+        it('includes trend when previousValues provided', () => {
+            const evaluations = [
+                { timestamp: '2026-01-02T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+            ];
+            const previousValues = { avg: null, min: null, max: null, count: DEFAULT_LIMIT_10, p50: 0.70, p95: null, p99: null };
+            const result = computeQualityMetric(evaluations, QUALITY_METRICS.relevance, undefined, previousValues);
+            assert.ok(result.trend);
+            assert.strictEqual(result.trend.direction, 'improving');
+        });
+        it('omits trend when previousValues not provided', () => {
+            const evaluations = [
+                { timestamp: '2026-01-02T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_STRONG },
+            ];
+            const result = computeQualityMetric(evaluations, QUALITY_METRICS.relevance);
+            assert.strictEqual(result.trend, undefined);
+        });
+    });
+    // ==========================================================================
+    // Metric Registration
+    // ==========================================================================
+    describe('registerQualityMetric', () => {
+        it('registers a custom metric', () => {
+            const config = {
+                name: 'custom_test',
+                displayName: 'Custom Test',
+                description: 'Test metric',
+                aggregations: ['avg'],
+                alerts: [],
+                range: { min: 0, max: 1 },
+                unit: 'score',
+            };
+            registerQualityMetric(config);
+            const all = getAllQualityMetrics();
+            assert.ok(all.custom_test);
+        });
+        it('rejects NaN/Infinity in alert threshold values', () => {
+            const config = {
+                name: 'nan_test', displayName: 'NaN Test', description: 'Test',
+                aggregations: ['avg'],
+                alerts: [{ aggregation: 'avg', value: NaN, direction: 'below', severity: 'warning', message: 'test' }],
+                range: { min: 0, max: 1 }, unit: 'score',
+            };
+            assert.throws(() => registerQualityMetric(config));
+        });
+        it('rejects Infinity in range values', () => {
+            const config = {
+                name: 'inf_test', displayName: 'Inf Test', description: 'Test',
+                aggregations: ['avg'], alerts: [],
+                range: { min: 0, max: Infinity }, unit: 'score',
+            };
+            assert.throws(() => registerQualityMetric(config));
+        });
+        it('throws if metric already exists', () => {
+            const config = {
+                name: 'relevance', // Already exists in QUALITY_METRICS
+                displayName: 'Duplicate',
+                description: 'Test',
+                aggregations: ['avg'],
+                alerts: [],
+                range: { min: 0, max: 1 },
+                unit: 'score',
+            };
+            assert.throws(() => registerQualityMetric(config));
+        });
+    });
+    describe('unregisterQualityMetric', () => {
+        it('removes a custom metric', () => {
+            const config = {
+                name: 'to_remove',
+                displayName: 'To Remove',
+                description: 'Test',
+                aggregations: ['avg'],
+                alerts: [],
+                range: { min: 0, max: 1 },
+                unit: 'score',
+            };
+            registerQualityMetric(config);
+            const removed = unregisterQualityMetric('to_remove');
+            assert.strictEqual(removed, true);
+            assert.strictEqual(getQualityMetric('to_remove'), undefined);
+        });
+        it('returns false for non-existent metric', () => {
+            assert.strictEqual(unregisterQualityMetric('nonexistent'), false);
+        });
+    });
+    describe('getQualityMetric', () => {
+        it('returns built-in metric', () => {
+            const metric = getQualityMetric('relevance');
+            assert.ok(metric);
+            assert.strictEqual(metric.name, 'relevance');
+        });
+        it('returns custom metric', () => {
+            registerQualityMetric({
+                name: 'custom_get_test',
+                displayName: 'Test',
+                description: 'Test',
+                aggregations: ['avg'],
+                alerts: [],
+                range: { min: 0, max: 1 },
+                unit: 'score',
+            });
+            const metric = getQualityMetric('custom_get_test');
+            assert.ok(metric);
+        });
+        it('returns undefined for unknown metric', () => {
+            assert.strictEqual(getQualityMetric('unknown'), undefined);
+        });
+    });
+    // ==========================================================================
+    // Utility Functions
+    // ==========================================================================
+    describe('formatMetricValue', () => {
+        it('formats score', () => {
+            assert.strictEqual(formatMetricValue(TEST_FORMATTED_SCORE_INPUT, 'score'), '0.8567');
+        });
+        it('formats percentage', () => {
+            assert.strictEqual(formatMetricValue(TEST_SCORE_STRONG, 'percentage'), '85.0%');
+        });
+        it('formats rate', () => {
+            assert.strictEqual(formatMetricValue(TEST_SCORE_EXCELLENT, 'rate'), '95.0%');
+        });
+        it('formats seconds', () => {
+            assert.strictEqual(formatMetricValue(TEST_FORMATTED_SECONDS_INPUT, 'seconds'), '3.46s');
+        });
+        it('handles null', () => {
+            assert.strictEqual(formatMetricValue(null, 'score'), 'N/A');
+        });
+    });
+    describe('MetricConfigBuilder', () => {
+        it('builds a metric config', () => {
+            const config = createMetricConfig('test_builder')
+                .displayName('Test Builder')
+                .description('A test metric')
+                .aggregations('avg', 'p50', 'p95')
+                .range(0, COUNT_HUNDRED)
+                .unit('percentage')
+                .alertBelow('p50', COUNT_FIFTY, 'warning')
+                .alertAbove('avg', COUNT_NINETY, 'info')
+                .build();
+            assert.strictEqual(config.name, 'test_builder');
+            assert.strictEqual(config.displayName, 'Test Builder');
+            assert.strictEqual(config.description, 'A test metric');
+            assert.deepStrictEqual(config.aggregations, ['avg', 'p50', 'p95']);
+            assert.deepStrictEqual(config.range, { min: 0, max: COUNT_HUNDRED });
+            assert.strictEqual(config.unit, 'percentage');
+            assert.strictEqual(config.alerts.length, COUNT_TWO);
+        });
+        it('supports remediationHints method', () => {
+            const config = createMetricConfig('hint_test')
+                .displayName('Hint Test')
+                .description('Test metric with hints')
+                .remediationHints('Fix prompt', 'Add context')
+                .alertBelow('avg', TEST_SCORE_MID, 'warning')
+                .build();
+            assert.deepStrictEqual(config.remediationHints, ['Fix prompt', 'Add context']);
+        });
+        it('uses defaults for missing fields', () => {
+            const config = createMetricConfig('minimal').build();
+            assert.strictEqual(config.name, 'minimal');
+            assert.strictEqual(config.displayName, 'minimal');
+            assert.ok(config.description);
+        });
+    });
+    // ==========================================================================
+    // Full Pipeline Integration Test (Backlog #8)
+    // ==========================================================================
+    describe('full pipeline integration: dashboard + trends + SLAs + confidence', () => {
+        it('exercises computeDashboardSummary with all v2.2 features end-to-end', () => {
+            // Setup: realistic evaluation data for 3 metrics
+            const relevanceEvals = Array.from({ length: COUNT_SIXTY }, (_, i) => ({
+                timestamp: `2026-02-01T${String(Math.floor(i / COUNT_SIXTY)).padStart(COUNT_TWO, '0')}:${String(i % COUNT_SIXTY).padStart(COUNT_TWO, '0')}:00Z`,
+                evaluationName: 'relevance',
+                scoreValue: TEST_SINGLE_VALUE_SCORE + (i % COUNT_TEN) * TEST_STEP_TWO_HUNDREDTHS,
+                evaluator: i % COUNT_TWO === 0 ? 'judge-a' : 'judge-b',
+            }));
+            const hallucinationEvals = Array.from({ length: 40 }, (_, i) => ({
+                timestamp: `2026-02-01T${String(Math.floor(i / COUNT_SIXTY)).padStart(COUNT_TWO, '0')}:${String(i % COUNT_SIXTY).padStart(COUNT_TWO, '0')}:00Z`,
+                evaluationName: 'hallucination',
+                scoreValue: TEST_STEP_THREE_HUNDREDTHS + (i % COUNT_FIVE) * TEST_DECIMAL_EPSILON,
+                evaluator: 'judge-a',
+            }));
+            const coherenceEvals = Array.from({ length: COUNT_TWENTY_FIVE }, (_, i) => ({
+                timestamp: `2026-02-01T00:${String(i).padStart(COUNT_TWO, '0')}:00Z`,
+                evaluationName: 'coherence',
+                scoreValue: TEST_SCORE_ADEQUATE + (i % COUNT_EIGHT) * TEST_STEP_THREE_HUNDREDTHS,
+            }));
+            const evaluationsByMetric = new Map([
+                ['relevance', relevanceEvals],
+                ['hallucination', hallucinationEvals],
+                ['coherence', coherenceEvals],
+            ]);
+            // Previous period values for trend comparison
+            const previousPeriodValues = new Map([
+                ['relevance', { avg: null, min: null, max: null, count: COUNT_FIFTY, p50: TEST_SCORE_PASSING, p95: null, p99: null }],
+                ['hallucination', { avg: 0.10, min: null, max: null, count: 30, p50: null, p95: null, p99: null }],
+                ['coherence', { avg: null, min: null, max: null, count: COUNT_TWENTY, p50: TEST_SCORE_BASELINE, p95: null, p99: null }],
+            ]);
+            // SLA definitions
+            const slas = [
+                { metric: 'relevance', aggregation: 'p50', target: TEST_SCORE_GOOD, direction: 'above', window: '30d rolling' },
+                { metric: 'hallucination', aggregation: 'avg', target: TEST_SCORE_WARNING, direction: 'below' },
+                { metric: 'coherence', aggregation: 'p50', target: TEST_SCORE_HIGH, direction: 'above' },
+            ];
+            // Execute full pipeline
+            const dashboard = computeDashboardSummary(evaluationsByMetric, undefined, undefined, slas, previousPeriodValues);
+            // --- Verify dashboard structure ---
+            assert.ok(dashboard.overallStatus);
+            assert.ok(['healthy', 'warning', 'critical', 'no_data'].includes(dashboard.overallStatus));
+            // All 9 pre-defined QUALITY_METRICS are included; 3 have data, 6 have no_data
+            assert.strictEqual(dashboard.metrics.length, COUNT_NINE);
+            assert.strictEqual(dashboard.summary.totalMetrics, COUNT_NINE);
+            assert.ok(dashboard.timestamp);
+            // --- Verify trends populated ---
+            const relevanceResult = requireDefined(dashboard.metrics.find(m => m.name === 'relevance'), 'Expected relevance metric result');
+            const hallucinationResult = requireDefined(dashboard.metrics.find(m => m.name === 'hallucination'), 'Expected hallucination metric result');
+            const coherenceResult = requireDefined(dashboard.metrics.find(m => m.name === 'coherence'), 'Expected coherence metric result');
+            assert.ok(relevanceResult.trend, 'Relevance should have trend');
+            assert.ok(hallucinationResult.trend, 'Hallucination should have trend');
+            assert.ok(coherenceResult.trend, 'Coherence should have trend');
+            // Relevance improved (current ~0.84 vs previous 0.70)
+            assert.strictEqual(requireDefined(relevanceResult.trend).direction, 'improving');
+            // Hallucination improved (current ~0.05 vs previous 0.10)
+            assert.strictEqual(requireDefined(hallucinationResult.trend).direction, 'improving');
+            // --- Verify confidence populated ---
+            assert.ok(relevanceResult.confidence, 'Relevance should have confidence');
+            assert.strictEqual(requireDefined(relevanceResult.confidence).evaluatorCount, COUNT_TWO);
+            assert.ok(requireDefined(relevanceResult.confidence).evaluatorAgreement !== null);
+            // 60 samples with low variance should be high confidence
+            assert.strictEqual(requireDefined(relevanceResult.confidence).level, 'high');
+            assert.ok(hallucinationResult.confidence);
+            assert.ok(coherenceResult.confidence);
+            // Coherence has 25 samples = medium confidence
+            assert.strictEqual(requireDefined(coherenceResult.confidence).level, 'medium');
+            // --- Verify SLA compliance ---
+            assert.ok(dashboard.slaCompliance);
+            assert.strictEqual(requireDefined(dashboard.slaCompliance).length, COUNT_THREE);
+            const relevanceSLA = requireDefined(requireDefined(dashboard.slaCompliance).find(s => s.sla.metric === 'relevance'), 'Expected relevance SLA');
+            const hallucinationSLA = requireDefined(requireDefined(dashboard.slaCompliance).find(s => s.sla.metric === 'hallucination'), 'Expected hallucination SLA');
+            const coherenceSLA = requireDefined(requireDefined(dashboard.slaCompliance).find(s => s.sla.metric === 'coherence'), 'Expected coherence SLA');
+            assert.ok(relevanceSLA.actualValue !== null);
+            assert.ok(hallucinationSLA.compliant); // hallucination avg ~0.05 < TEST_SCORE_WARNING target
+            assert.strictEqual(coherenceSLA.compliant, false); // coherence p50 ~0.74 < TEST_SCORE_HIGH target
+            // --- Verify role views work with full data ---
+            const execView = computeRoleView(dashboard, 'executive');
+            assert.strictEqual(execView.role, 'executive');
+            assert.ok(execView.topIssues.length > 0);
+            assert.strictEqual(execView.slaTotalCount, COUNT_THREE);
+            const opView = computeRoleView(dashboard, 'operator');
+            assert.strictEqual(opView.role, 'operator');
+            assert.ok(Array.isArray(opView.prioritizedAlerts));
+            assert.ok(Array.isArray(opView.degradingTrends));
+            const audView = computeRoleView(dashboard, 'auditor');
+            assert.strictEqual(audView.role, 'auditor');
+            assert.strictEqual(audView.metrics.length, Object.keys(QUALITY_METRICS).length);
+            assert.ok(audView.totalEvaluationCount >= TEST_TOTAL_EVALUATION_COUNT_MIN); // 60 + 40 + 25
+            // --- Verify severity context works in pipeline ---
+            const prodContext = {
+                environment: 'prod*',
+                escalateWarnings: true,
+                suppressInfo: true,
+            };
+            const contextAlerts = applySeverityContext(dashboard.alerts.map(a => ({ ...a })), prodContext, relevanceResult.sampleCount, 'production');
+            // All info alerts should be filtered, warnings escalated
+            assert.ok(contextAlerts.every(a => a.severity !== 'info'));
+            assert.ok(contextAlerts.every(a => a.severity !== 'warning'));
+        });
+    });
+    // ==========================================================================
+    // Edge Case Tests (v2.4)
+    // ==========================================================================
+    describe('edge cases', () => {
+        it('computeAggregations handles empty aggregation list', () => {
+            const result = computeAggregations([TEST_SCORE_MID, TEST_SCORE_PASSING, TEST_SCORE_HIGH], []);
+            // Count is always computed when scores exist, rest should be null
+            assert.strictEqual(result.count, COUNT_THREE);
+            assert.strictEqual(result.avg, null);
+            assert.strictEqual(result.p50, null);
+        });
+        it('applySeverityContext matches unicode environment patterns', () => {
+            const alerts = [{
+                    severity: 'warning', message: 'test', aggregation: 'avg',
+                    threshold: TEST_SCORE_MID, actualValue: TEST_SCORE_POOR, direction: 'below',
+                }];
+            const context = {
+                environment: 'prod-日本*',
+                escalateWarnings: true,
+            };
+            // Should match unicode pattern
+            const result = applySeverityContext(alerts, context, COUNT_HUNDRED, 'prod-日本-east');
+            assert.ok(result.every(a => a.severity === 'critical'));
+        });
+        it('applySeverityContext handles unicode environment that does not match', () => {
+            const alerts = [{
+                    severity: 'warning', message: 'test', aggregation: 'avg',
+                    threshold: TEST_SCORE_MID, actualValue: TEST_SCORE_POOR, direction: 'below',
+                }];
+            const context = {
+                environment: 'prod-日本*',
+                escalateWarnings: true,
+            };
+            // Different unicode prefix should not match
+            const result = applySeverityContext(alerts, context, COUNT_HUNDRED, 'prod-中国-east');
+            assert.ok(result.every(a => a.severity === 'warning'));
+        });
+        it('computeAggregations handles floating-point boundary at exact 0 and 1', () => {
+            const result = computeAggregations([0, 1], ['avg', 'min', 'max', 'p50']);
+            assert.strictEqual(result.avg, TEST_SCORE_MID);
+            assert.strictEqual(result.min, 0);
+            assert.strictEqual(result.max, 1);
+            assert.strictEqual(result.p50, TEST_SCORE_MID);
+        });
+        it('computeAggregations handles very small floating-point differences', () => {
+            // Values that differ by less than score precision
+            const result = computeAggregations([TEST_TINY_SCORE_1, TEST_TINY_SCORE_2, TEST_TINY_SCORE_3], ['avg', 'p50']);
+            assert.strictEqual(result.avg, 0); // Rounds to 0 at 4 decimal places
+        });
+        it('checkAlertThresholds handles threshold at exact boundary value', () => {
+            const values = { avg: TEST_SCORE_PASSING, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null };
+            const thresholds = [
+                { aggregation: 'avg', value: TEST_SCORE_PASSING, direction: 'below', severity: 'warning', message: 'test {value}' },
+            ];
+            // avg = TEST_SCORE_PASSING is NOT below TEST_SCORE_PASSING (strict inequality), so no alert
+            const alerts = checkAlertThresholds(values, thresholds);
+            assert.strictEqual(alerts.length, 0);
+        });
+        it('evaluateSLA handles zero target value', () => {
+            const sla = { metric: 'hallucination', aggregation: 'avg', target: 0, direction: 'below' };
+            const results = [{
+                    name: 'hallucination', displayName: 'Hallucination', sampleCount: DEFAULT_LIMIT_10,
+                    values: { avg: 0, min: null, max: null, count: DEFAULT_LIMIT_10, p50: null, p95: null, p99: null },
+                    alerts: [], status: 'healthy',
+                }];
+            const result = evaluateSLA(sla, results);
+            assert.strictEqual(result.compliant, true);
+            assert.strictEqual(result.marginPercent, null); // target is 0, cannot compute %
+        });
+        it('computeAggregations percentile filtering with mixed valid/NaN/Infinity', () => {
+            // Mixed data: 3 valid, 1 NaN, 1 Infinity, 1 -Infinity
+            const scores = [TEST_SCORE_LOW, NaN, TEST_SCORE_BASELINE, Infinity, TEST_SCORE_HIGH, -Infinity];
+            const result = computeAggregations(scores, ['avg', 'min', 'max', 'p50', 'p95', 'count']);
+            // Only [0.3, TEST_SCORE_BASELINE, TEST_SCORE_HIGH] should survive filtering (6 input -> 3 valid)
+            assert.strictEqual(result.count, COUNT_THREE);
+            assert.strictEqual(result.min, TEST_SCORE_LOW);
+            assert.strictEqual(result.max, TEST_SCORE_HIGH);
+            assert.strictEqual(result.avg, TEST_SCORE_BASELINE);
+            assert.strictEqual(result.p50, TEST_SCORE_BASELINE);
+            // p95: rank = 0.95 * (3-1) = 1.9; lerp(sorted[1]=TEST_SCORE_BASELINE, sorted[2]=TEST_SCORE_HIGH, TEST_SCORE_HIGH) = 0.87
+            assert.strictEqual(result.p95, TEST_INTERPOLATED_P95_EXPECTED);
+        });
+        it('SLAComplianceResult invariant: compliant === (status === compliant)', () => {
+            const slas = [
+                { metric: 'relevance', aggregation: 'avg', target: TEST_SCORE_GOOD, direction: 'above' },
+                { metric: 'hallucination', aggregation: 'avg', target: TEST_SCORE_WARNING, direction: 'below' },
+                { metric: 'missing_metric', aggregation: 'avg', target: TEST_SCORE_MID, direction: 'above' },
+                { metric: 'coherence', aggregation: 'avg', target: TEST_SCORE_MID, direction: 'above' }, // null agg -> no_data
+                { metric: 'relevance', aggregation: 'avg', target: TEST_SCORE_HIGH, direction: 'above' }, // exact boundary
+            ];
+            const results = [
+                {
+                    name: 'relevance', displayName: 'Relevance', sampleCount: 50,
+                    values: { avg: TEST_SCORE_HIGH, min: null, max: null, count: 50, p50: null, p95: null, p99: null },
+                    alerts: [], status: 'healthy',
+                },
+                {
+                    name: 'hallucination', displayName: 'Hallucination', sampleCount: 50,
+                    values: { avg: 0.15, min: null, max: null, count: 50, p50: null, p95: null, p99: null },
+                    alerts: [], status: 'warning',
+                },
+                {
+                    name: 'coherence', displayName: 'Coherence', sampleCount: 0,
+                    values: { avg: null, min: null, max: null, count: null, p50: null, p95: null, p99: null },
+                    alerts: [], status: 'no_data',
+                },
+            ];
+            for (const sla of slas) {
+                const result = evaluateSLA(sla, results);
+                assert.strictEqual(result.compliant, result.status === 'compliant', `Invariant violated for ${sla.metric}: compliant=${result.compliant}, status=${result.status}`);
+            }
+        });
+        it('NaN filtering + SLA evaluation e2e: all-NaN scores -> null aggs -> no_data', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: NaN },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: NaN },
+                        { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: NaN },
+                    ]],
+            ]);
+            const dashboard = computeDashboardSummary(evaluationsByMetric);
+            const relevance = requireDefined(dashboard.metrics.find(m => m.name === 'relevance'), 'Expected relevance metric result');
+            // All NaN scores should result in no_data
+            assert.strictEqual(relevance.status, 'no_data');
+            assert.strictEqual(relevance.sampleCount, 0);
+            assert.strictEqual(relevance.values.avg, null);
+            assert.strictEqual(relevance.values.p50, null);
+            // SLA against this metric should return no_data status
+            const sla = { metric: 'relevance', aggregation: 'avg', target: TEST_SCORE_GOOD, direction: 'above' };
+            const slaResult = evaluateSLA(sla, dashboard.metrics);
+            assert.strictEqual(slaResult.status, 'no_data');
+            assert.strictEqual(slaResult.compliant, false);
+            assert.strictEqual(slaResult.actualValue, null);
+        });
+    });
+    // ==========================================================================
+    // Pipeline Visualization (G8)
+    // ==========================================================================
+    describe('computePipelineView', () => {
+        it('computes 4 pipeline stages from evaluation data', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH },
+                        { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_PASSING },
+                    ]],
+                ['hallucination', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'hallucination', scoreValue: DELTA },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'hallucination', scoreValue: 0.08 },
+                    ]],
+            ]);
+            const dashboard = computeDashboardSummary(evaluationsByMetric);
+            const pipeline = computePipelineView(evaluationsByMetric, dashboard);
+            assert.strictEqual(pipeline.stages.length, COUNT_FOUR);
+            assert.strictEqual(pipeline.stages[0].name, 'ingested');
+            assert.strictEqual(pipeline.stages[0].entryCount, COUNT_FIVE); // 3 + 2 total
+            assert.strictEqual(pipeline.stages[1].name, 'scored');
+            assert.strictEqual(pipeline.stages[2].name, 'evaluated');
+            assert.strictEqual(pipeline.stages[3].name, 'alerted');
+        });
+        it('computes drop-off within stages', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance' }, // no scoreValue
+                    ]],
+            ]);
+            const dashboard = computeDashboardSummary(evaluationsByMetric);
+            const pipeline = computePipelineView(evaluationsByMetric, dashboard);
+            assert.strictEqual(pipeline.dropoffs.length, COUNT_FOUR); // one per stage
+            // Ingested stage: 2 entry, 1 exit (undefined score filtered)
+            const ingestedDropoff = requireDefined(pipeline.dropoffs.find(d => d.stage === 'ingested'), 'Expected ingested dropoff');
+            assert.strictEqual(ingestedDropoff.dropped, 1);
+            assert.strictEqual(ingestedDropoff.dropoffPercent, COUNT_FIFTY);
+        });
+        it('handles empty evaluation map', () => {
+            const evaluationsByMetric = new Map();
+            const dashboard = computeDashboardSummary(evaluationsByMetric);
+            const pipeline = computePipelineView(evaluationsByMetric, dashboard);
+            assert.strictEqual(pipeline.stages[0].entryCount, 0);
+            assert.strictEqual(pipeline.overallConversionPercent, 0);
+        });
+        it('computes overall conversion rate', () => {
+            const evaluationsByMetric = new Map([
+                ['hallucination', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'hallucination', scoreValue: TEST_SCORE_LOW },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'hallucination', scoreValue: 0.25 },
+                    ]],
+            ]);
+            const dashboard = computeDashboardSummary(evaluationsByMetric);
+            const pipeline = computePipelineView(evaluationsByMetric, dashboard);
+            // If hallucination triggers alerts, alerted count > 0
+            assert.ok(pipeline.overallConversionPercent >= 0);
+            assert.ok(pipeline.overallConversionPercent <= COUNT_HUNDRED);
+        });
+    });
+    // ==========================================================================
+    // Coverage Heatmap (G9)
+    // ==========================================================================
+    describe('computeCoverageHeatmap', () => {
+        it('computes coverage matrix from evaluation data', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, traceId: 'trace-1' },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH, traceId: 'trace-2' },
+                    ]],
+                ['hallucination', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'hallucination', scoreValue: DELTA, traceId: 'trace-1' },
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric);
+            assert.strictEqual(heatmap.metrics.length, COUNT_TWO);
+            assert.strictEqual(heatmap.inputs.length, COUNT_TWO);
+            assert.strictEqual(heatmap.cells.length, COUNT_FOUR); // 2 metrics x 2 inputs
+        });
+        it('identifies coverage gaps', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, traceId: 'trace-1' },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH, traceId: 'trace-2' },
+                    ]],
+                ['hallucination', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'hallucination', scoreValue: DELTA, traceId: 'trace-1' },
+                        // Missing trace-2 for hallucination
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric);
+            // hallucination is missing trace-2
+            const hallucinationGap = heatmap.gaps.find(g => g.metric === 'hallucination');
+            assert.ok(hallucinationGap);
+            assert.ok(requireDefined(hallucinationGap).missingInputs.includes('trace-2'));
+            assert.strictEqual(requireDefined(hallucinationGap).coveragePercent, COUNT_FIFTY);
+        });
+        it('computes overall coverage percentage', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, traceId: 'trace-1' },
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric);
+            // 1 metric, 1 input, fully covered
+            assert.strictEqual(heatmap.overallCoveragePercent, COUNT_HUNDRED);
+        });
+        it('handles empty evaluation map', () => {
+            const evaluationsByMetric = new Map();
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric);
+            assert.strictEqual(heatmap.metrics.length, 0);
+            assert.strictEqual(heatmap.inputs.length, 0);
+            assert.strictEqual(heatmap.cells.length, 0);
+            assert.strictEqual(heatmap.overallCoveragePercent, 0);
+        });
+        it('supports sessionId as input key', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, sessionId: 'session-a' },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH, sessionId: 'session-b' },
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric, { inputKey: 'sessionId' });
+            assert.strictEqual(heatmap.inputs.length, COUNT_TWO);
+            assert.ok(heatmap.inputs.includes('session-a'));
+            assert.ok(heatmap.inputs.includes('session-b'));
+        });
+        it('supports legacy string inputKey argument', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, sessionId: 'session-a' },
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric, 'sessionId');
+            assert.ok(heatmap.inputs.includes('session-a'));
+        });
+        it('count=1 is covered with default threshold', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, traceId: 'trace-1' },
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric);
+            const cell = requireDefined(heatmap.cells.find(c => c.metric === 'relevance' && c.input === 'trace-1'), 'Expected relevance heatmap cell for trace-1');
+            assert.strictEqual(cell.status, 'covered');
+            assert.strictEqual(cell.count, 1);
+        });
+        it('supports configurable coverage thresholds', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, traceId: 'trace-1' },
+                        { timestamp: '2026-01-01T00:01:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_HIGH, traceId: 'trace-1' },
+                        { timestamp: '2026-01-01T00:02:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_PASSING, traceId: 'trace-2' },
+                    ]],
+            ]);
+            // Require 2+ for 'covered', 1 for 'partial'
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric, { coveredThreshold: 2, partialThreshold: 0 });
+            const cell1 = requireDefined(heatmap.cells.find(c => c.input === 'trace-1'), 'Expected heatmap cell for trace-1');
+            const cell2 = requireDefined(heatmap.cells.find(c => c.input === 'trace-2'), 'Expected heatmap cell for trace-2');
+            assert.strictEqual(cell1.status, 'covered'); // count=2 >= 2
+            assert.strictEqual(cell2.status, 'partial'); // count=1 > 0 but < 2
+        });
+        it('assigns missing status for missing trace coverage', () => {
+            const evaluationsByMetric = new Map([
+                ['relevance', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'relevance', scoreValue: TEST_SCORE_GOOD, traceId: 'trace-1' },
+                    ]],
+                ['faithfulness', [
+                        { timestamp: '2026-01-01T00:00:00Z', evaluationName: 'faithfulness', scoreValue: TEST_SCORE_HIGH, traceId: 'trace-2' },
+                    ]],
+            ]);
+            const heatmap = computeCoverageHeatmap(evaluationsByMetric);
+            // relevance missing trace-2, faithfulness missing trace-1
+            const relevanceTrace2 = heatmap.cells.find(c => c.metric === 'relevance' && c.input === 'trace-2');
+            assert.ok(relevanceTrace2);
+            assert.strictEqual(requireDefined(relevanceTrace2).status, 'missing');
+            assert.strictEqual(requireDefined(relevanceTrace2).count, 0);
+        });
+    });
+    // ==========================================================================
+    // roundTo
+    // ==========================================================================
+    describe('roundTo', () => {
+        it('rounds to specified decimal places', () => {
+            assert.strictEqual(roundTo(TEST_FORMATTED_SCORE_INPUT, SCORE_PRECISION), 0.8567);
+            assert.strictEqual(roundTo(TEST_FORMATTED_SECONDS_INPUT, PERCENT_PRECISION), 3.46);
+        });
+        it('rounds to zero decimal places', () => {
+            assert.strictEqual(roundTo(TEST_FORMATTED_SECONDS_INPUT, 0), COUNT_THREE);
+        });
+        it('handles NaN and Infinity', () => {
+            assert.ok(Number.isNaN(roundTo(NaN, SCORE_PRECISION)));
+            assert.strictEqual(roundTo(Infinity, SCORE_PRECISION), Infinity);
+            assert.strictEqual(roundTo(-Infinity, SCORE_PRECISION), -Infinity);
+        });
+    });
+    // ==========================================================================
+    // sortAlertsBySeverity
+    // ==========================================================================
+    describe('sortAlertsBySeverity', () => {
+        it('sorts critical before warning before info', () => {
+            const alerts = [
+                { severity: 'info', id: 1 },
+                { severity: 'critical', id: 2 },
+                { severity: 'warning', id: 3 },
+            ];
+            const sorted = sortAlertsBySeverity(alerts);
+            assert.deepStrictEqual(sorted.map(a => a.severity), ['critical', 'warning', 'info']);
+        });
+        it('returns a new array without mutating the original', () => {
+            const alerts = [
+                { severity: 'info' },
+                { severity: 'critical' },
+            ];
+            const sorted = sortAlertsBySeverity(alerts);
+            assert.notStrictEqual(sorted, alerts);
+            assert.strictEqual(alerts[0]?.severity, 'info'); // unchanged
+        });
+        it('handles empty array', () => {
+            assert.deepStrictEqual(sortAlertsBySeverity([]), []);
+        });
+    });
+    // ==========================================================================
+    // hasQualityMetric
+    // ==========================================================================
+    describe('hasQualityMetric', () => {
+        it('returns true for built-in metrics', () => {
+            assert.strictEqual(hasQualityMetric('relevance'), true);
+            assert.strictEqual(hasQualityMetric('hallucination'), true);
+        });
+        it('returns false for unknown metrics', () => {
+            assert.strictEqual(hasQualityMetric('nonexistent_metric'), false);
+        });
+        it('returns true for registered custom metrics', () => {
+            registerQualityMetric({
+                name: 'custom_has_test',
+                displayName: 'Custom',
+                description: 'Test',
+                aggregations: ['avg'],
+                alerts: [],
+                range: { min: 0, max: 1 },
+                unit: 'score',
+            });
+            assert.strictEqual(hasQualityMetric('custom_has_test'), true);
+        });
+        it('returns false after unregistering a custom metric', () => {
+            registerQualityMetric({
+                name: 'temp_has_metric',
+                displayName: 'Temp',
+                description: 'Test',
+                aggregations: ['avg'],
+                alerts: [],
+                range: { min: 0, max: 1 },
+                unit: 'score',
+            });
+            unregisterQualityMetric('temp_has_metric');
+            assert.strictEqual(hasQualityMetric('temp_has_metric'), false);
+        });
+    });
+});
+//# sourceMappingURL=quality-metrics.test.js.map