dialectic 0.5.2 → 0.7.0

package/dist/commands/eval.spec.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
-const index_1 = require("../index");
+const path_1 = __importDefault(require("path"));
 const dialectic_core_1 = require("dialectic-core");
+const index_1 = require("../index");
 const TEST_PROBLEM = 'Test problem';
 const TEST_SOLUTION = 'Test solution';
 const TEST_PROBLEM_SHORT = 'Test';
@@ -29,14 +29,14 @@ const MOCK_LATENCY_MS = 100;
 const TEMP_DIR_PREFIX = 'eval-test-';
 const mockCreateProvider = jest.fn();
 jest.mock('dialectic-core/providers/provider-factory', () => ({
-    createProvider: (...args) => mockCreateProvider(...args)
+    createProvider: (..._args) => mockCreateProvider(..._args)
 }));
 jest.mock('dialectic-core', () => {
     const actual = jest.requireActual('dialectic-core');
     return {
         ...actual,
         loadEnvironmentFile: jest.fn(),
-        createProvider: (...args) => mockCreateProvider(...args)
+        createProvider: (..._args) => mockCreateProvider(..._args)
     };
 });
 const mockedLoadEnvironmentFile = dialectic_core_1.loadEnvironmentFile;
@@ -104,7 +104,8 @@ describe('CLI eval command', () => {
         try {
             fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
         }
-        catch { }
+        catch {
+        }
     });
     describe('Required flags validation', () => {
         it('should reject when --config flag is missing', async () => {
@@ -376,6 +377,24 @@ describe('CLI eval command', () => {
             await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
             expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('[e1] Skipped due to error'));
         });
+        it('should handle evaluation result with empty rawText', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: '',
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('[e1] Invalid JSON output; skipping agent'));
+        });
+        it('should handle evaluation result with null rawText', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: null,
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('[e1] Invalid JSON output; skipping agent'));
+        });
     });
     describe('Score validation and clamping', () => {
         const SCORE_BELOW_MIN_1 = -5;
@@ -521,6 +540,50 @@ describe('CLI eval command', () => {
             const output = stdoutSpy.mock.calls.join('');
             expect(output).toContain('7.00');
         });
+        it('should handle missing evaluation object in parsed result', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: JSON.stringify({
+                    overall_summary: { overall_score: 8 }
+                }),
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            const output = stdoutSpy.mock.calls.join('');
+            expect(output).toContain('8.00');
+            expect(output).toContain('N/A');
+        });
+        it('should handle missing non_functional object in parsed result', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: JSON.stringify({
+                    evaluation: {
+                        functional_completeness: { score: 8 }
+                    },
+                    overall_summary: { overall_score: 8 }
+                }),
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            const output = stdoutSpy.mock.calls.join('');
+            expect(output).toContain('8.00');
+            expect(output).toContain('N/A');
+        });
+        it('should handle missing overall_summary object in parsed result', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: JSON.stringify({
+                    evaluation: {
+                        functional_completeness: { score: 8 }
+                    }
+                }),
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            const output = stdoutSpy.mock.calls.join('');
+            expect(output).toContain('8.00');
+            expect(output).toContain('N/A');
+        });
         it('should round to 2 decimal places', async () => {
             const evalSpy = jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate');
             evalSpy.mockResolvedValueOnce({
@@ -1115,6 +1178,38 @@ describe('CLI eval command', () => {
             expect(stderrSpy).toHaveBeenCalledWith(expect.stringMatching(/systemPrompt=.*built-in default/));
             expect(stderrSpy).toHaveBeenCalledWith(expect.stringMatching(/userPrompt=.*built-in default/));
         });
+        it('should log prompt sources in verbose mode (from file)', async () => {
+            const promptsDir = path_1.default.join(tmpDir, 'prompts');
+            fs_1.default.mkdirSync(promptsDir);
+            const systemPromptPath = path_1.default.join(promptsDir, 'system.md');
+            const userPromptPath = path_1.default.join(promptsDir, 'user.md');
+            fs_1.default.writeFileSync(systemPromptPath, 'Custom system prompt');
+            fs_1.default.writeFileSync(userPromptPath, 'Custom user prompt');
+            const configPathWithPrompts = path_1.default.join(tmpDir, 'config-with-prompts.json');
+            fs_1.default.writeFileSync(configPathWithPrompts, JSON.stringify({
+                agents: [{
+                        id: 'e1',
+                        name: 'E1',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        systemPromptPath: './prompts/system.md',
+                        userPromptPath: './prompts/user.md'
+                    }]
+            }));
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: JSON.stringify({
+                    evaluation: { functional_completeness: { score: 8 } },
+                    overall_summary: { overall_score: 8 }
+                }),
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPathWithPrompts, '--debate', debatePath, '--verbose']);
+            const stderrCalls = stderrSpy.mock.calls.map(c => String(c[0])).join('');
+            expect(stderrCalls).toContain('systemPrompt=');
+            expect(stderrCalls).toContain('userPrompt=');
+            expect(stderrCalls).not.toContain('built-in default');
+        });
         it('should not log verbose info when verbose flag is absent', async () => {
             jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
                 id: 'e1',
@@ -1168,7 +1263,7 @@ describe('CLI eval command', () => {
                 }),
                 resolvedSystemPrompt: ''
             };
-            fromConfigSpy.mockImplementation((_cfg, sysPrompt, _userPrompt) => {
+            fromConfigSpy.mockImplementation((_cfg, sysPrompt) => {
                 mockAgent.resolvedSystemPrompt = sysPrompt;
                 return mockAgent;
             });
@@ -1264,6 +1359,517 @@ describe('CLI eval command', () => {
             expect(output).toContain('5.00');
             expect(output).toContain('4.00');
         });
+        it('should handle requirements_fulfillment score', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: JSON.stringify({
+                    evaluation: {
+                        functional_completeness: { score: 8 },
+                        non_functional: {
+                            requirements_fulfillment: { score: 9 }
+                        }
+                    },
+                    overall_summary: { overall_score: 8 }
+                }),
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            const output = stdoutSpy.mock.calls.join('');
+            expect(output).toContain('9.00');
+        });
+    });
+    describe('Clarification formatting edge cases', () => {
+        let configPath;
+        let debatePath;
+        beforeEach(() => {
+            configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            setupMockProviderAndEvaluator();
+        });
+        it('should handle clarification item with missing id', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        role: 'architect',
+                        items: [
+                            { question: 'What is the scale?', answer: '1M users' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).not.toContain('What is the scale?');
+        });
+        it('should handle clarification item with missing question', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        role: 'architect',
+                        items: [
+                            { id: 'q1', answer: '1M users' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).not.toContain('q1');
+        });
+        it('should handle clarification item with missing answer', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        role: 'architect',
+                        items: [
+                            { id: 'q1', question: 'What is the scale?' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).not.toContain('What is the scale?');
+        });
+        it('should handle clarification group with missing agentName', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        role: 'architect',
+                        items: [
+                            { id: 'q1', question: 'What is the scale?', answer: '1M users' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).not.toContain('What is the scale?');
+        });
+        it('should handle clarification group with missing role', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        items: [
+                            { id: 'q1', question: 'What is the scale?', answer: '1M users' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).not.toContain('What is the scale?');
+        });
+        it('should handle clarification group with empty items array', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        role: 'architect',
+                        items: []
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).not.toContain('Architect');
+        });
+        it('should handle clarification group that becomes empty after filtering invalid items', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        role: 'architect',
+                        items: [
+                            { question: 'Invalid item without id', answer: 'answer' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            const markdown = call?.clarificationsMarkdown || '';
+            expect(markdown).toContain('### Architect (architect)');
+            expect(markdown).not.toContain('Invalid item without id');
+        });
+    });
+    describe('Config validation edge cases', () => {
+        let debatePath;
+        beforeEach(() => {
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(debatePath, JSON.stringify(createBasicDebateData()));
+        });
+        it('should reject config with agent that is null', async () => {
+            const configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [null]
+            }));
+            await expect((0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('agent must be an object'));
+        });
+        it('should reject config with agent that is a string', async () => {
+            const configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: ['invalid-agent']
+            }));
+            await expect((0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('agent must be an object'));
+        });
+        it('should reject config with agent that is a number', async () => {
+            const configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [123]
+            }));
+            await expect((0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+        });
+        it('should default provider to openai when provider is not a string', async () => {
+            const configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [{
+                        id: 'e1',
+                        name: 'E1',
+                        model: 'gpt-4',
+                        provider: 123
+                    }]
+            }));
+            setupMockProviderAndEvaluator();
+            mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(mockedCreateProvider).toHaveBeenCalledWith(PROVIDER_OPENAI);
+        });
+        it('should handle agent config with null/undefined id, name, model', async () => {
+            const configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [{
+                        id: null,
+                        name: undefined,
+                        model: null,
+                        provider: 'openai'
+                    }]
+            }));
+            setupMockProviderAndEvaluator();
+            mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stdoutSpy).toHaveBeenCalled();
+        });
+        it('should handle agent config with non-number timeout', async () => {
+            const configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [{
+                        id: 'e1',
+                        name: 'E1',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        timeout: 'invalid'
+                    }]
+            }));
+            setupMockProviderAndEvaluator();
+            mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stdoutSpy).toHaveBeenCalled();
+        });
+    });
+    describe('Error handling edge cases', () => {
+        let configPath;
+        let debatePath;
+        beforeEach(() => {
+            configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            fs_1.default.writeFileSync(debatePath, JSON.stringify(createBasicDebateData()));
+            setupMockProviderAndEvaluator();
+        });
+        it('should handle error without code property', async () => {
+            jest.spyOn(require('dialectic-core'), 'readJsonFile').mockImplementationOnce(() => {
+                throw new Error('Test error without code');
+            });
+            let caughtError;
+            try {
+                await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            }
+            catch (err) {
+                caughtError = err;
+                expect(err).toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+            }
+            expect(caughtError).toBeDefined();
+            expect(caughtError.message).toBe('Test error without code');
+            const stderrCalls = stderrSpy.mock.calls.map(c => String(c[0])).join('');
+            expect(stderrCalls).toContain('Test error without code');
+            jest.restoreAllMocks();
+        });
+        it('should handle error that is not an Error object', async () => {
+            jest.spyOn(require('dialectic-core'), 'readJsonFile').mockImplementationOnce(() => {
+                throw 'String error';
+            });
+            let caughtError;
+            try {
+                await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            }
+            catch (err) {
+                caughtError = err;
+                expect(err).toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+            }
+            expect(caughtError).toBeDefined();
+            expect(caughtError.message).toBe('Unknown error');
+            jest.restoreAllMocks();
+        });
+        it('should handle error when writeStderr throws', async () => {
+            jest.spyOn(require('dialectic-core'), 'writeStderr').mockImplementation(() => {
+                throw new Error('writeStderr failed');
+            });
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockRejectedValue(new Error('Test error'));
+            await expect((0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]))
+                .rejects.toThrow();
+            jest.restoreAllMocks();
+        });
+        it('should handle error with null message', async () => {
+            jest.spyOn(require('dialectic-core'), 'readJsonFile').mockImplementationOnce(() => {
+                const err = { code: dialectic_core_1.EXIT_INVALID_ARGS };
+                throw err;
+            });
+            try {
+                await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            }
+            catch {
+            }
+            const stderrCalls = stderrSpy.mock.calls.map(c => String(c[0])).join('');
+            expect(stderrCalls).toContain('Unknown error');
+            jest.restoreAllMocks();
+        });
+    });
+    describe('Path resolution', () => {
+        let configPath;
+        let debatePath;
+        const originalInitCwd = process.env.INIT_CWD;
+        beforeEach(() => {
+            configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            fs_1.default.writeFileSync(debatePath, JSON.stringify(createBasicDebateData()));
+            setupMockProviderAndEvaluator();
+            mockSuccessfulEvaluation();
+        });
+        afterEach(() => {
+            if (originalInitCwd) {
+                process.env.INIT_CWD = originalInitCwd;
+            }
+            else {
+                delete process.env.INIT_CWD;
+            }
+        });
+        it('should use INIT_CWD when available for relative paths', async () => {
+            const customInitCwd = path_1.default.join(os_1.default.tmpdir(), 'custom-init-cwd');
+            process.env.INIT_CWD = customInitCwd;
+            const customConfigPath = path_1.default.join(customInitCwd, CONFIG_FILE_NAME);
+            const customDebatePath = path_1.default.join(customInitCwd, DEBATE_FILE_NAME);
+            fs_1.default.mkdirSync(customInitCwd, { recursive: true });
+            fs_1.default.writeFileSync(customConfigPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            fs_1.default.writeFileSync(customDebatePath, JSON.stringify(createBasicDebateData()));
+            await (0, index_1.runCli)(['eval', '--config', CONFIG_FILE_NAME, '--debate', DEBATE_FILE_NAME]);
+            fs_1.default.rmSync(customInitCwd, { recursive: true, force: true });
+        });
+        it('should use process.cwd() when INIT_CWD is not set', async () => {
+            delete process.env.INIT_CWD;
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stdoutSpy).toHaveBeenCalled();
+        });
+        it('should handle absolute paths regardless of INIT_CWD', async () => {
+            process.env.INIT_CWD = '/some/other/path';
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stdoutSpy).toHaveBeenCalled();
+        });
+    });
+    describe('CSV escaping edge cases', () => {
+        let configPath;
+        let debatePath;
+        beforeEach(() => {
+            configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            fs_1.default.writeFileSync(debatePath, JSON.stringify(createBasicDebateData()));
+            setupMockProviderAndEvaluator();
+        });
+        it('should escape CSV values containing double quotes', async () => {
+            const outputPath = path_1.default.join(tmpDir, 'results.csv');
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: JSON.stringify({
+                    evaluation: { functional_completeness: { score: 8 } },
+                    overall_summary: { overall_score: 8 }
+                }),
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath, '--output', outputPath]);
+            const content = fs_1.default.readFileSync(outputPath, 'utf-8');
+            expect(content).toContain('debate');
+        });
+        it('should escape CSV values containing commas', async () => {
+            const outputPath = path_1.default.join(tmpDir, 'results.csv');
+            const debatePathWithComma = path_1.default.join(tmpDir, 'debate,with,commas.json');
+            try {
+                fs_1.default.writeFileSync(debatePathWithComma, JSON.stringify({
+                    problem: 'Test',
+                    finalSolution: { description: 'Solution' }
+                }));
+                jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                    id: 'e1',
+                    rawText: JSON.stringify({
+                        evaluation: { functional_completeness: { score: 8 } },
+                        overall_summary: { overall_score: 8 }
+                    }),
+                    latencyMs: 100
+                });
+                await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePathWithComma, '--output', outputPath]);
+                const content = fs_1.default.readFileSync(outputPath, 'utf-8');
+                expect(content).toMatch(/^"debate,with,commas",/);
+            }
+            catch {
+            }
+        });
+    });
+    describe('JSON parsing edge cases', () => {
+        let configPath;
+        let debatePath;
+        beforeEach(() => {
+            configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            fs_1.default.writeFileSync(debatePath, JSON.stringify(createBasicDebateData()));
+            setupMockProviderAndEvaluator();
+        });
+        it('should handle JSON parsing failure gracefully', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: '{ invalid json }',
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('[e1] Invalid JSON output; skipping agent'));
+        });
+        it('should handle text without JSON object', async () => {
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: 'This is just plain text with no JSON',
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('[e1] Invalid JSON output; skipping agent'));
+        });
+        it('should extract JSON from text with multiple JSON objects', async () => {
+            const responseWithMultipleJson = 'First: {"foo": "bar"}\n' +
+                'Second: {"evaluation":{"functional_completeness":{"score":8}},"overall_summary":{"overall_score":8}}\n' +
+                'Third: {"baz": "qux"}';
+            jest.spyOn(dialectic_core_1.EvaluatorAgent.prototype, 'evaluate').mockResolvedValue({
+                id: 'e1',
+                rawText: responseWithMultipleJson,
+                latencyMs: 100
+            });
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            const output = stdoutSpy.mock.calls.join('');
+            expect(output).toContain('N/A');
+        });
+    });
+    describe('Empty clarifications edge cases', () => {
+        let configPath;
+        let debatePath;
+        beforeEach(() => {
+            configPath = path_1.default.join(tmpDir, CONFIG_FILE_NAME);
+            debatePath = path_1.default.join(tmpDir, DEBATE_FILE_NAME);
+            fs_1.default.writeFileSync(configPath, JSON.stringify({
+                agents: [createBasicAgentConfig()]
+            }));
+            setupMockProviderAndEvaluator();
+            mockSuccessfulEvaluation();
+        });
+        it('should handle clarifications array that exists but is empty', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: []
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).toMatch(/```.*```/);
+        });
+        it('should handle clarifications with whitespace-only content', async () => {
+            fs_1.default.writeFileSync(debatePath, JSON.stringify({
+                ...createBasicDebateData(TEST_PROBLEM_SHORT, TEST_SOLUTION_SHORT),
+                clarifications: [
+                    {
+                        agentId: 'architect-1',
+                        agentName: 'Architect',
+                        role: 'architect',
+                        items: [
+                            { id: 'q1', question: '   ', answer: '   ' }
+                        ]
+                    }
+                ]
+            }));
+            const evaluateSpy = mockSuccessfulEvaluation();
+            await (0, index_1.runCli)(['eval', '--config', configPath, '--debate', debatePath]);
+            expect(evaluateSpy).toHaveBeenCalled();
+            const call = evaluateSpy.mock.calls[0]?.[0];
+            expect(call).toBeDefined();
+            expect(call?.clarificationsMarkdown).toContain('### Architect (architect)');
+            expect(call?.clarificationsMarkdown).toContain('q1');
+        });
     });
 });
 //# sourceMappingURL=eval.spec.js.map