observability-toolkit 1.8.4 → 2.0.0

package/dist/lib/agent-as-judge.test.js

@@ -0,0 +1,816 @@
+/**
+ * Tests for Agent-as-Judge Implementation
+ */
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { 
+// Constants
+MAX_TRAJECTORY_LENGTH, MAX_CONCURRENT_EVALUATORS, MAX_CONSENSUS_ROUNDS, DEFAULT_CONVERGENCE_THRESHOLD, 
+// Error classes
+AgentEvalTimeoutError, 
+// Utilities
+withAgentTimeout, validateEvaluand, validateStepScore, validateToolVerification, verifyToolCall, verifyToolCalls, scoreStep, aggregateStepScores, analyzeTrajectory, calculateVariance, calculateMedian, collectiveConsensus, 
+// Classes
+ProceduralJudge, ReactiveJudge, } from './agent-as-judge.js';
+import { InputValidationError } from './input-validator.js';
+describe('agent-as-judge', () => {
+    // ============================================================================
+    // Timeout Protection Tests
+    // ============================================================================
+    describe('withAgentTimeout', () => {
+        it('should return result when function completes in time', async () => {
+            const result = await withAgentTimeout(() => Promise.resolve(42), 1000);
+            assert.equal(result, 42);
+        });
+        it('should throw AgentEvalTimeoutError when function times out', async () => {
+            await assert.rejects(withAgentTimeout(() => new Promise((resolve) => setTimeout(resolve, 200)), 50), AgentEvalTimeoutError);
+        });
+        it('should include timeout duration in error', async () => {
+            try {
+                await withAgentTimeout(() => new Promise((resolve) => setTimeout(resolve, 200)), 50);
+                assert.fail('Should have thrown');
+            }
+            catch (error) {
+                assert.ok(error instanceof AgentEvalTimeoutError);
+                assert.equal(error.timeoutMs, 50);
+                assert.ok(error.message.includes('50'));
+            }
+        });
+        it('should propagate function errors', async () => {
+            await assert.rejects(withAgentTimeout(() => Promise.reject(new Error('Test error')), 1000), { message: 'Test error' });
+        });
+    });
+    // ============================================================================
+    // Validation Tests
+    // ============================================================================
+    describe('validateEvaluand', () => {
+        it('should pass for valid evaluand', () => {
+            assert.doesNotThrow(() => validateEvaluand({ input: 'test input', output: 'test output' }));
+        });
+        it('should throw for empty input', () => {
+            assert.throws(() => validateEvaluand({ input: '', output: 'test' }), InputValidationError);
+        });
+        it('should throw for whitespace-only input', () => {
+            assert.throws(() => validateEvaluand({ input: '   ', output: 'test' }), InputValidationError);
+        });
+        it('should throw for empty output', () => {
+            assert.throws(() => validateEvaluand({ input: 'test', output: '' }), InputValidationError);
+        });
+        it('should throw for actions exceeding MAX_TRAJECTORY_LENGTH', () => {
+            const actions = Array(MAX_TRAJECTORY_LENGTH + 1).fill({
+                type: 'tool_call',
+                tool: 'test',
+            });
+            assert.throws(() => validateEvaluand({ input: 'test', output: 'test', actions }), InputValidationError);
+        });
+        it('should pass for actions at MAX_TRAJECTORY_LENGTH', () => {
+            const actions = Array(MAX_TRAJECTORY_LENGTH).fill({
+                type: 'tool_call',
+                tool: 'test',
+            });
+            assert.doesNotThrow(() => validateEvaluand({ input: 'test', output: 'test', actions }));
+        });
+    });
+    describe('validateStepScore', () => {
+        it('should pass for valid step score with number step', () => {
+            assert.doesNotThrow(() => validateStepScore({ step: 0, score: 0.5 }));
+        });
+        it('should pass for valid step score with string step', () => {
+            assert.doesNotThrow(() => validateStepScore({ step: 'step_1', score: 0.5 }));
+        });
+        it('should throw for step string exceeding 256 characters', () => {
+            assert.throws(() => validateStepScore({ step: 'a'.repeat(257), score: 0.5 }), InputValidationError);
+        });
+        it('should throw for negative step index', () => {
+            assert.throws(() => validateStepScore({ step: -1, score: 0.5 }), InputValidationError);
+        });
+        it('should throw for non-integer step index', () => {
+            assert.throws(() => validateStepScore({ step: 1.5, score: 0.5 }), InputValidationError);
+        });
+        it('should throw for score below 0', () => {
+            assert.throws(() => validateStepScore({ step: 0, score: -0.1 }), InputValidationError);
+        });
+        it('should throw for score above 1', () => {
+            assert.throws(() => validateStepScore({ step: 0, score: 1.1 }), InputValidationError);
+        });
+        it('should throw for NaN score', () => {
+            assert.throws(() => validateStepScore({ step: 0, score: NaN }), InputValidationError);
+        });
+        it('should throw for Infinity score', () => {
+            assert.throws(() => validateStepScore({ step: 0, score: Infinity }), InputValidationError);
+        });
+    });
+    describe('validateToolVerification', () => {
+        it('should pass for valid verification', () => {
+            assert.doesNotThrow(() => validateToolVerification({
+                toolName: 'search',
+                toolCorrect: true,
+                argsCorrect: true,
+                score: 0.8,
+            }));
+        });
+        it('should throw for empty tool name', () => {
+            assert.throws(() => validateToolVerification({
+                toolName: '',
+                toolCorrect: true,
+                argsCorrect: true,
+                score: 0.8,
+            }), InputValidationError);
+        });
+        it('should throw for non-boolean toolCorrect', () => {
+            assert.throws(() => validateToolVerification({
+                toolName: 'test',
+                toolCorrect: 'yes',
+                argsCorrect: true,
+                score: 0.8,
+            }), InputValidationError);
+        });
+        it('should throw for invalid score', () => {
+            assert.throws(() => validateToolVerification({
+                toolName: 'test',
+                toolCorrect: true,
+                argsCorrect: true,
+                score: 1.5,
+            }), InputValidationError);
+        });
+    });
+    // ============================================================================
+    // Tool Verification Tests
+    // ============================================================================
+    describe('verifyToolCall', () => {
+        it('should throw for null action (H1)', () => {
+            assert.throws(() => verifyToolCall(null), InputValidationError);
+        });
+        it('should throw for non-object action (H1)', () => {
+            assert.throws(() => verifyToolCall('string'), InputValidationError);
+        });
+        it('should verify correct tool selection', () => {
+            const action = { type: 'tool_call', tool: 'search' };
+            const result = verifyToolCall(action, 'search');
+            assert.equal(result.toolCorrect, true);
+            assert.equal(result.score, 1.0);
+        });
+        it('should detect incorrect tool selection', () => {
+            const action = { type: 'tool_call', tool: 'read' };
+            const result = verifyToolCall(action, 'search');
+            assert.equal(result.toolCorrect, false);
+            assert.equal(result.score, 0);
+        });
+        it('should verify correct arguments', () => {
+            const action = {
+                type: 'tool_call',
+                tool: 'search',
+                arguments: { query: 'test' },
+            };
+            const result = verifyToolCall(action, 'search', { query: 'test' });
+            assert.equal(result.argsCorrect, true);
+            assert.ok(result.score > 0.9); // tool + args correct
+        });
+        it('should detect incorrect arguments', () => {
+            const action = {
+                type: 'tool_call',
+                tool: 'search',
+                arguments: { query: 'wrong' },
+            };
+            const result = verifyToolCall(action, 'search', { query: 'test' });
+            assert.equal(result.argsCorrect, false);
+        });
+        it('should verify result correctness when provided', () => {
+            const action = {
+                type: 'tool_call',
+                tool: 'calc',
+                result: 42,
+            };
+            const result = verifyToolCall(action, 'calc', undefined, undefined, 42);
+            assert.equal(result.resultCorrect, true);
+        });
+        it('should include evidence in result', () => {
+            const action = {
+                type: 'tool_call',
+                tool: 'test',
+                arguments: { foo: 'bar' },
+            };
+            const result = verifyToolCall(action, 'expected', { baz: 'qux' });
+            assert.ok(result.evidence);
+            assert.deepEqual(result.evidence.actualTool, 'test');
+            assert.deepEqual(result.evidence.expectedTool, 'expected');
+        });
+    });
+    describe('verifyToolCalls', () => {
+        it('should verify multiple tool calls', () => {
+            const actions = [
+                { type: 'tool_call', tool: 'search', toolCallId: 'call_1' },
+                { type: 'reasoning', reasoning: 'thinking...' },
+                { type: 'tool_call', tool: 'read', toolCallId: 'call_2' },
+            ];
+            const expected = new Map([
+                ['call_1', { tool: 'search' }],
+                ['call_2', { tool: 'read' }],
+            ]);
+            const results = verifyToolCalls(actions, expected);
+            assert.equal(results.length, 2); // Only tool_call actions
+            assert.equal(results[0].toolCorrect, true);
+            assert.equal(results[1].toolCorrect, true);
+        });
+        it('should skip non-tool actions', () => {
+            const actions = [
+                { type: 'reasoning', reasoning: 'thinking' },
+                { type: 'response', reasoning: 'responding' },
+            ];
+            const results = verifyToolCalls(actions);
+            assert.equal(results.length, 0);
+        });
+        it('should respect MAX_TOOL_VERIFICATIONS limit', () => {
+            const actions = Array(1000).fill({
+                type: 'tool_call',
+                tool: 'test',
+            });
+            const results = verifyToolCalls(actions);
+            assert.ok(results.length <= 500); // MAX_TOOL_VERIFICATIONS
+        });
+    });
+    // ============================================================================
+    // Step Scoring Tests
+    // ============================================================================
+    describe('scoreStep', () => {
+        it('should create valid step score', () => {
+            const action = { type: 'tool_call', tool: 'search' };
+            const result = scoreStep(action, 0, { score: 0.8, explanation: 'Good' });
+            assert.equal(result.step, 0);
+            assert.equal(result.score, 0.8);
+            assert.equal(result.explanation, 'Good');
+        });
+        it('should clamp score to [0, 1]', () => {
+            const action = { type: 'tool_call', tool: 'test' };
+            const high = scoreStep(action, 0, { score: 1.5 });
+            assert.equal(high.score, 1);
+            const low = scoreStep(action, 0, { score: -0.5 });
+            assert.equal(low.score, 0);
+        });
+        it('should throw for NaN score (H4)', () => {
+            const action = { type: 'tool_call', tool: 'test' };
+            assert.throws(() => scoreStep(action, 0, { score: NaN }), InputValidationError);
+        });
+        it('should throw for string score (H4)', () => {
+            const action = { type: 'tool_call', tool: 'test' };
+            assert.throws(() => scoreStep(action, 0, { score: '0.5' }), InputValidationError);
+        });
+        it('should include action metadata in evidence', () => {
+            const action = {
+                type: 'tool_call',
+                tool: 'search',
+                reasoning: 'searching for data',
+            };
+            const result = scoreStep(action, 0, { score: 0.9 });
+            const evidence = result.evidence;
+            assert.equal(evidence.actionType, 'tool_call');
+            assert.equal(evidence.tool, 'search');
+            assert.equal(evidence.reasoning, 'searching for data');
+        });
+    });
+    describe('aggregateStepScores', () => {
+        it('should return 1 for empty array', () => {
+            const result = aggregateStepScores([]);
+            assert.equal(result, 1);
+        });
+        it('should calculate average correctly', () => {
+            const scores = [
+                { step: 0, score: 0.8 },
+                { step: 1, score: 0.6 },
+                { step: 2, score: 1.0 },
+            ];
+            const result = aggregateStepScores(scores, 'average');
+            // Use approximate comparison for floating point
+            assert.ok(Math.abs(result - 0.8) < 0.0001);
+        });
+        it('should calculate weighted average correctly', () => {
+            const scores = [
+                { step: 0, score: 1.0 },
+                { step: 1, score: 0.0 },
+            ];
+            const result = aggregateStepScores(scores, 'weighted', [3, 1]);
+            assert.equal(result, 0.75);
+        });
+        it('should throw for weighted without weights', () => {
+            const scores = [{ step: 0, score: 0.5 }];
+            assert.throws(() => aggregateStepScores(scores, 'weighted'), Error);
+        });
+        it('should throw for mismatched weights length', () => {
+            const scores = [
+                { step: 0, score: 0.5 },
+                { step: 1, score: 0.5 },
+            ];
+            assert.throws(() => aggregateStepScores(scores, 'weighted', [1]), Error);
+        });
+        it('should return 0 for all-zero weights', () => {
+            const scores = [{ step: 0, score: 0.8 }];
+            const result = aggregateStepScores(scores, 'weighted', [0]);
+            assert.equal(result, 0);
+        });
+        it('should throw on negative weights (L8)', () => {
+            const scores = [
+                { step: 0, score: 0.5 },
+                { step: 1, score: 0.8 },
+            ];
+            assert.throws(() => aggregateStepScores(scores, 'weighted', [1, -1]), /Invalid weight at index 1: -1\. Weights must be finite non-negative numbers/);
+        });
+        it('should throw on negative weight at index 0', () => {
+            const scores = [
+                { step: 0, score: 0.5 },
+                { step: 1, score: 0.8 },
+            ];
+            assert.throws(() => aggregateStepScores(scores, 'weighted', [-1, 1]), /Invalid weight at index 0: -1\. Weights must be finite non-negative numbers/);
+        });
+        it('should throw on NaN weight (M1)', () => {
+            const scores = [
+                { step: 0, score: 0.5 },
+                { step: 1, score: 0.8 },
+            ];
+            assert.throws(() => aggregateStepScores(scores, 'weighted', [1, NaN]), /Invalid weight at index 1: NaN\. Weights must be finite non-negative numbers/);
+        });
+        it('should throw on Infinity weight', () => {
+            const scores = [
+                { step: 0, score: 0.5 },
+                { step: 1, score: 0.8 },
+            ];
+            assert.throws(() => aggregateStepScores(scores, 'weighted', [1, Infinity]), /Invalid weight at index 1: Infinity\. Weights must be finite non-negative numbers/);
+        });
+        it('should throw on -Infinity weight', () => {
+            const scores = [
+                { step: 0, score: 0.5 },
+                { step: 1, score: 0.8 },
+            ];
+            assert.throws(() => aggregateStepScores(scores, 'weighted', [-Infinity, 1]), /Invalid weight at index 0: -Infinity\. Weights must be finite non-negative numbers/);
+        });
+        it('should calculate min correctly', () => {
+            const scores = [
+                { step: 0, score: 0.9 },
+                { step: 1, score: 0.3 },
+                { step: 2, score: 0.7 },
+            ];
+            const result = aggregateStepScores(scores, 'min');
+            assert.equal(result, 0.3);
+        });
+    });
+    // ============================================================================
+    // Trajectory Analysis Tests
+    // ============================================================================
+    describe('analyzeTrajectory', () => {
+        it('should calculate basic metrics', () => {
+            const evaluand = {
+                input: 'test',
+                output: 'result',
+                actions: [
+                    { type: 'tool_call', tool: 'search' },
+                    { type: 'reasoning', reasoning: 'thinking' },
+                    { type: 'tool_call', tool: 'read' },
+                ],
+            };
+            const result = analyzeTrajectory(evaluand);
+            assert.equal(result.length, 3);
+            assert.equal(result.toolCallCount, 2);
+            assert.equal(result.uniqueTools, 2);
+        });
+        it('should handle empty actions', () => {
+            const evaluand = { input: 'test', output: 'result' };
+            const result = analyzeTrajectory(evaluand);
+            assert.equal(result.length, 0);
+            assert.equal(result.toolCallCount, 0);
+        });
+        it('should calculate efficiency ratio', () => {
+            const evaluand = {
+                input: 'test',
+                output: 'result',
+                actions: Array(10).fill({ type: 'tool_call', tool: 'test' }),
+            };
+            const result = analyzeTrajectory(evaluand, 5);
+            assert.equal(result.efficiencyRatio, 0.5); // 5/10
+        });
+        it('should cap efficiency ratio at 1', () => {
+            const evaluand = {
+                input: 'test',
+                output: 'result',
+                actions: [{ type: 'tool_call', tool: 'test' }],
+            };
+            const result = analyzeTrajectory(evaluand, 10);
+            assert.equal(result.efficiencyRatio, 1);
+        });
+        it('should detect redundant actions', () => {
+            const evaluand = {
+                input: 'test',
+                output: 'result',
+                actions: [
+                    { type: 'tool_call', tool: 'search', arguments: { q: 'a' } },
+                    { type: 'tool_call', tool: 'search', arguments: { q: 'a' } }, // Duplicate
+                    { type: 'tool_call', tool: 'search', arguments: { q: 'b' } }, // Different args
+                ],
+            };
+            const result = analyzeTrajectory(evaluand);
+            assert.equal(result.redundantActions, 1);
+        });
+    });
+    // ============================================================================
+    // Statistical Functions Tests
+    // ============================================================================
+    describe('calculateVariance', () => {
+        it('should return 0 for empty array', () => {
+            assert.equal(calculateVariance([]), 0);
+        });
+        it('should return 0 for single value', () => {
+            assert.equal(calculateVariance([5]), 0);
+        });
+        it('should return 0 for identical values', () => {
+            assert.equal(calculateVariance([3, 3, 3, 3]), 0);
+        });
+        it('should calculate sample variance with Bessel correction (M7)', () => {
+            // Values: [2, 4, 4, 4, 5, 5, 7, 9], n=8, mean = 5
+            // Sum of squared diffs = (2-5)^2 + (4-5)^2*3 + (5-5)^2*2 + (7-5)^2 + (9-5)^2
+            //                      = 9 + 3 + 0 + 4 + 16 = 32
+            // Sample variance (Bessel's correction) = 32 / (n-1) = 32/7 ≈ 4.571
+            const result = calculateVariance([2, 4, 4, 4, 5, 5, 7, 9]);
+            assert.ok(Math.abs(result - 32 / 7) < 0.001, `Expected ~4.571, got ${result}`);
+        });
+        it('should calculate variance for two values', () => {
+            // Values: [2, 6], mean = 4
+            // Sum of squared diffs = (2-4)^2 + (6-4)^2 = 4 + 4 = 8
+            // Sample variance = 8 / (2-1) = 8
+            const result = calculateVariance([2, 6]);
+            assert.equal(result, 8);
+        });
+    });
+    describe('calculateMedian', () => {
+        it('should return 0 for empty array', () => {
+            assert.equal(calculateMedian([]), 0);
+        });
+        it('should return value for single element', () => {
+            assert.equal(calculateMedian([5]), 5);
+        });
+        it('should calculate median for odd count', () => {
+            assert.equal(calculateMedian([1, 3, 5]), 3);
+        });
+        it('should calculate median for even count', () => {
+            assert.equal(calculateMedian([1, 2, 3, 4]), 2.5);
+        });
+        it('should handle unsorted input', () => {
+            assert.equal(calculateMedian([5, 1, 3]), 3);
+        });
+    });
+    // ============================================================================
+    // Consensus Tests
+    // ============================================================================
+    describe('collectiveConsensus', () => {
+        const validEvaluand = { input: 'test', output: 'result' };
+        const config = {
+            rounds: 3,
+            convergenceThreshold: DEFAULT_CONVERGENCE_THRESHOLD,
+        };
+        it('should throw for invalid evaluand', async () => {
+            await assert.rejects(collectiveConsensus({ input: '', output: 'test' }, [], config), InputValidationError);
+        });
+        it('should throw for too many judges (H2)', async () => {
+            const judges = Array(MAX_CONCURRENT_EVALUATORS + 1).fill({
+                id: 'judge',
+                evaluate: async () => 0.5,
+            });
+            await assert.rejects(collectiveConsensus(validEvaluand, judges, config), InputValidationError);
+        });
+        it('should throw for empty judges array', async () => {
+            await assert.rejects(collectiveConsensus(validEvaluand, [], config), InputValidationError);
+        });
+        it('should throw for rounds < 1 (M9)', async () => {
+            const judges = [{ id: 'j1', evaluate: async () => 0.5 }];
+            await assert.rejects(collectiveConsensus(validEvaluand, judges, { ...config, rounds: 0 }), InputValidationError);
+        });
+        it('should reach consensus with agreeing judges', async () => {
+            const judges = [
+                { id: 'j1', evaluate: async () => 0.8 },
+                { id: 'j2', evaluate: async () => 0.82 },
+                { id: 'j3', evaluate: async () => 0.79 },
+            ];
+            const result = await collectiveConsensus(validEvaluand, judges, config);
+            assert.ok(result.converged);
+            assert.ok(result.finalScore > 0.7);
+        });
+        it('should handle disagreeing judges', async () => {
+            const judges = [
+                { id: 'j1', evaluate: async () => 0.2 },
+                { id: 'j2', evaluate: async () => 0.8 },
+            ];
+            const result = await collectiveConsensus(validEvaluand, judges, {
+                rounds: 2,
+                convergenceThreshold: 0.01, // Very tight
+            });
+            assert.equal(result.converged, false);
+        });
+        it('should handle judge failures gracefully (H3)', async () => {
+            const judges = [
+                { id: 'j1', evaluate: async () => 0.8 },
+                {
+                    id: 'j2',
+                    evaluate: async () => {
+                        throw new Error('Judge failed');
+                    },
+                },
+                { id: 'j3', evaluate: async () => 0.75 },
+            ];
+            const result = await collectiveConsensus(validEvaluand, judges, config);
+            // Should succeed with 2 working judges
+            assert.ok(result.finalScore > 0);
+        });
+        it('should throw when all judges fail (H3)', async () => {
+            const judges = [
+                {
+                    id: 'j1',
+                    evaluate: async () => {
+                        throw new Error('Failed 1');
+                    },
+                },
+                {
+                    id: 'j2',
+                    evaluate: async () => {
+                        throw new Error('Failed 2');
+                    },
+                },
+            ];
+            await assert.rejects(collectiveConsensus(validEvaluand, judges, config), /All judge evaluations failed/);
+        });
+        it('should respect MAX_CONSENSUS_ROUNDS', async () => {
+            let callCount = 0;
+            const judges = [
+                {
+                    id: 'j1',
+                    evaluate: async () => {
+                        callCount++;
+                        return 0.5;
+                    },
+                },
+            ];
+            await collectiveConsensus(validEvaluand, judges, {
+                rounds: 100, // Exceeds max
+                convergenceThreshold: 0.0001,
+            });
+            assert.ok(callCount <= MAX_CONSENSUS_ROUNDS);
+        });
+    });
+    // ============================================================================
+    // ProceduralJudge Tests
+    // ============================================================================
+    describe('ProceduralJudge', () => {
+        it('should execute all stages in order', async () => {
+            const executionOrder = [];
+            const stages = [
+                {
+                    name: 'stage1',
+                    evaluate: async () => {
+                        executionOrder.push('stage1');
+                        return { score: 0.8, explanation: 'Good' };
+                    },
+                },
+                {
+                    name: 'stage2',
+                    evaluate: async () => {
+                        executionOrder.push('stage2');
+                        return { score: 0.9, explanation: 'Great' };
+                    },
+                },
+            ];
+            const judge = new ProceduralJudge(stages);
+            const result = await judge.evaluate({
+                input: 'test',
+                output: 'result',
+            });
+            assert.deepEqual(executionOrder, ['stage1', 'stage2']);
+            assert.equal(result.stepScores.length, 2);
+        });
+        it('should support early termination', async () => {
+            const executionOrder = [];
+            const stages = [
+                {
+                    name: 'safety',
+                    evaluate: async () => {
+                        executionOrder.push('safety');
+                        return { score: 0.2, explanation: 'Failed safety' };
+                    },
+                },
+                {
+                    name: 'quality',
+                    evaluate: async () => {
+                        executionOrder.push('quality');
+                        return { score: 0.9, explanation: 'Good' };
+                    },
+                },
+            ];
+            const judge = new ProceduralJudge(stages, 'safety');
+            const result = await judge.evaluate({
+                input: 'test',
+                output: 'result',
+            });
+            assert.deepEqual(executionOrder, ['safety']);
+            assert.equal(result.overallScore, 0);
+            assert.ok(result.explanation.includes('Early termination'));
+        });
+        it('should pass context between stages', async () => {
+            let stage2Context = {};
+            const stages = [
+                {
+                    name: 'stage1',
+                    evaluate: async (_, ctx) => {
+                        ctx['data'] = 'from_stage1';
+                        return { score: 0.8, explanation: 'OK' };
+                    },
+                },
+                {
+                    name: 'stage2',
+                    evaluate: async (_, ctx) => {
+                        stage2Context = { ...ctx };
+                        return { score: 0.9, explanation: 'OK' };
+                    },
+                },
+            ];
+            const judge = new ProceduralJudge(stages);
+            await judge.evaluate({ input: 'test', output: 'result' });
+            assert.ok(stage2Context['stage1']);
+        });
+        it('should validate evaluand', async () => {
+            const judge = new ProceduralJudge([
+                { name: 'test', evaluate: async () => ({ score: 1, explanation: '' }) },
+            ]);
+            await assert.rejects(judge.evaluate({ input: '', output: 'test' }), InputValidationError);
+        });
+        describe('constructor validation (M8)', () => {
+            it('should throw on empty stages array', () => {
+                assert.throws(() => new ProceduralJudge([]), InputValidationError);
+            });
+            it('should throw on stage with empty name', () => {
+                assert.throws(() => new ProceduralJudge([
+                    { name: '', evaluate: async () => ({ score: 1, explanation: '' }) },
+                ]), InputValidationError);
+            });
+            it('should throw on stage with whitespace-only name', () => {
+                assert.throws(() => new ProceduralJudge([
+                    { name: '   ', evaluate: async () => ({ score: 1, explanation: '' }) },
+                ]), InputValidationError);
+            });
+            it('should throw on stage without evaluate function', () => {
+                assert.throws(
+                // @ts-expect-error - testing runtime validation
+                () => new ProceduralJudge([{ name: 'test' }]), InputValidationError);
+            });
+            it('should throw on invalid earlyTerminationOn stage name', () => {
+                assert.throws(() => new ProceduralJudge([{ name: 'stage1', evaluate: async () => ({ score: 1, explanation: '' }) }], 'nonexistent'), InputValidationError);
+            });
+            it('should accept valid stages with earlyTerminationOn', () => {
+                const judge = new ProceduralJudge([{ name: 'safety', evaluate: async () => ({ score: 1, explanation: '' }) }], 'safety');
+                assert.ok(judge);
+            });
+        });
+    });
+    // ============================================================================
+    // ReactiveJudge Tests
+    // ============================================================================
+    describe('ReactiveJudge', () => {
+        it('should route to selected specialists', async () => {
+            const executedSpecialists = [];
+            const router = async () => ['quality', 'safety'];
+            const specialists = new Map([
+                [
+                    'quality',
+                    async () => {
+                        executedSpecialists.push('quality');
+                        return { score: 0.9, explanation: 'Good quality' };
+                    },
+                ],
+                [
+                    'safety',
+                    async () => {
+                        executedSpecialists.push('safety');
+                        return { score: 1.0, explanation: 'Safe' };
+                    },
+                ],
+                [
+                    'style',
+                    async () => {
+                        executedSpecialists.push('style');
+                        return { score: 0.8, explanation: 'OK style' };
+                    },
+                ],
+            ]);
+            const judge = new ReactiveJudge(router, specialists);
+            const result = await judge.evaluate({
+                input: 'test',
+                output: 'result',
+            });
+            assert.deepEqual(executedSpecialists, ['quality', 'safety']);
+            assert.equal(result.stepScores.length, 2);
+        });
+        it('should trigger deep dive when needed', async () => {
+            const deepDiveTriggered = { value: false };
+            const router = async () => ['quality'];
+            const specialists = new Map([
+                [
+                    'quality',
+                    async () => ({
+                        score: 0.5,
+                        explanation: 'Needs investigation',
+                        needsDeepDive: true,
+                    }),
+                ],
+            ]);
+            const deepDiveSpecialists = new Map([
+                [
+                    'quality',
+                    async () => {
+                        deepDiveTriggered.value = true;
+                        return { score: 0.4, explanation: 'Deep analysis' };
+                    },
+                ],
+            ]);
+            const judge = new ReactiveJudge(router, specialists, deepDiveSpecialists);
+            const result = await judge.evaluate({
+                input: 'test',
+                output: 'result',
+            });
+            assert.equal(deepDiveTriggered.value, true);
+            assert.equal(result.stepScores.length, 2); // Regular + deep dive
+        });
+        it('should skip missing specialists', async () => {
+            const router = async () => ['missing', 'existing'];
+            const specialists = new Map([
+                ['existing', async () => ({ score: 0.8, explanation: 'OK' })],
+            ]);
+            const judge = new ReactiveJudge(router, specialists);
+            const result = await judge.evaluate({
+                input: 'test',
+                output: 'result',
+            });
+            assert.equal(result.stepScores.length, 1);
+        });
+        it('should validate evaluand', async () => {
+            const judge = new ReactiveJudge(async () => [], new Map());
+            await assert.rejects(judge.evaluate({ input: '', output: 'test' }), InputValidationError);
+        });
+    });
+    // ============================================================================
+    // AgentJudge Memory Tests (H5)
+    // ============================================================================
+    describe('AgentJudge memory management', () => {
+        class TestJudge extends ProceduralJudge {
+            // Expose protected methods for testing
+            testStore(key, value) {
+                this.storeInMemory(key, value);
+            }
+            testGet(key) {
+                return this.getFromMemory(key);
+            }
+            getMemorySize() {
+                return this.memory.size;
+            }
+        }
+        let judge;
+        beforeEach(() => {
+            judge = new TestJudge([
+                { name: 'test', evaluate: async () => ({ score: 1, explanation: '' }) },
+            ]);
+        });
+        it('should store and retrieve values', () => {
+            judge.testStore('key1', 'value1');
+            assert.equal(judge.testGet('key1'), 'value1');
+        });
+        it('should implement LRU - reading moves to end (H5)', () => {
+            // Fill nearly to capacity
+            for (let i = 0; i < 997; i++) {
+                judge.testStore(`fill_${i}`, i);
+            }
+            // Store 3 more items we care about
+            judge.testStore('key1', 'value1');
+            judge.testStore('key2', 'value2');
+            judge.testStore('key3', 'value3');
+            // Memory is now at 1000 - order is fill_0...fill_996, key1, key2, key3
+            // Read key1 - should move it to end (after key3)
+            judge.testGet('key1');
+            // Order is now: fill_0...fill_996, key2, key3, key1
+            // Store 1 more to trigger eviction of fill_0
+            judge.testStore('new_item', 'new');
+            // Order: fill_1...fill_996, key2, key3, key1, new_item
+            // key1 should still exist (was accessed recently), key2/key3 should exist
+            assert.equal(judge.testGet('key1'), 'value1');
+            assert.equal(judge.testGet('key2'), 'value2');
+            assert.equal(judge.testGet('key3'), 'value3');
+            // fill_0 should be evicted
+            assert.equal(judge.testGet('fill_0'), undefined);
+        });
+        it('should evict oldest on overflow', () => {
+            // Fill to capacity
+            for (let i = 0; i < 1000; i++) {
+                judge.testStore(`key_${i}`, i);
+            }
+            assert.equal(judge.getMemorySize(), 1000);
+            // Add one more
+            judge.testStore('new_key', 'new_value');
+            assert.equal(judge.getMemorySize(), 1000);
+            assert.equal(judge.testGet('key_0'), undefined); // First one evicted
+            assert.equal(judge.testGet('new_key'), 'new_value');
+        });
+    });
+});
+//# sourceMappingURL=agent-as-judge.test.js.map