dialectic 0.5.1 → 0.5.2

package/dist/commands/debate.spec.js

@@ -3,13 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const index_1 = require("../index");
+const dialectic_core_1 = require("dialectic-core");
+const debate_1 = require("./debate");
+const MOCK_SOLUTION_TEXT = 'Solution text';
 jest.mock('openai', () => {
     return {
         __esModule: true,
         default: class OpenAIMock {
             chat = {
                 completions: {
-                    create: async (_) => ({ choices: [{ message: { content: 'Solution text' } }] }),
+                    create: async (_) => ({ choices: [{ message: { content: MOCK_SOLUTION_TEXT } }] }),
                 },
             };
             constructor(_opts) { }
@@ -20,7 +27,11 @@ jest.mock('dialectic-core', () => {
     const actual = jest.requireActual('dialectic-core');
     return {
         ...actual,
-        loadEnvironmentFile: jest.fn()
+        loadEnvironmentFile: jest.fn().mockImplementation(() => {
+            return undefined;
+        }),
+        collectClarifications: jest.fn().mockResolvedValue([]),
+        generateDebateReport: jest.fn().mockImplementation(actual.generateDebateReport)
     };
 });
 jest.mock('readline', () => {
@@ -32,7 +43,7 @@ jest.mock('readline', () => {
             createInterface: () => ({
                 question: (_, cb) => {
                     const ans = currentIndex < mockAnswers.length ? mockAnswers[currentIndex++] : '';
-                    setImmediate(() => cb(String(ans)));
+                    Promise.resolve().then(() => cb(String(ans)));
                 },
                 close: () => { },
             })
@@ -43,13 +54,16 @@ jest.mock('readline', () => {
         }
     };
 });
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const index_1 = require("../index");
-const dialectic_core_1 = require("dialectic-core");
-const debate_1 = require("./debate");
 const mockedLoadEnvironmentFile = dialectic_core_1.loadEnvironmentFile;
+const mockedCollectClarifications = dialectic_core_1.collectClarifications;
+const mockedGenerateDebateReport = dialectic_core_1.generateDebateReport;
+function resetLoadEnvironmentFileMock() {
+    mockedLoadEnvironmentFile.mockClear();
+    mockedLoadEnvironmentFile.mockReturnValue(undefined);
+    mockedLoadEnvironmentFile.mockImplementation(() => {
+        return undefined;
+    });
+}
 const TEST_CONFIG_FILENAME = 'test-config.json';
 const TEST_AGENT_ID = 'test-agent';
 const TEST_AGENT_NAME = 'Test Agent';
@@ -101,8 +115,7 @@ describe('CLI debate command', () => {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
         stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
         stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        mockedLoadEnvironmentFile.mockClear();
-        mockedLoadEnvironmentFile.mockReturnValue(undefined);
+        resetLoadEnvironmentFileMock();
     });
     afterEach(() => {
         process.env = originalEnv;
@@ -118,8 +131,18 @@ describe('CLI debate command', () => {
     });
     it('prints only minimal solution to stdout (non-verbose)', async () => {
         process.env.OPENAI_API_KEY = 'test';
+        const capturedStdout = [];
+        const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            capturedStdout.push(String(chunk));
+            return true;
+        });
         await (0, index_1.runCli)(['debate', 'Design a rate limiting system']);
-        expect(stdoutSpy).toHaveBeenCalled();
+        const stdout = capturedStdout.join('');
+        expect(stdout).toContain(MOCK_SOLUTION_TEXT);
+        expect(stdout).not.toContain('Running debate (verbose)');
+        expect(stdout).not.toContain('Summary (verbose)');
+        expect(stdout).not.toMatch(/Round\s+\d+/);
+        stdoutWriteSpy.mockRestore();
     });
     it('prints verbose header and summary with metadata when --verbose', async () => {
         process.env.OPENAI_API_KEY = 'test';
@@ -136,7 +159,7 @@ describe('CLI debate command', () => {
         await (0, index_1.runCli)(['debate', 'Design X', '--rounds', '2', '--verbose']);
         const stdout = capturedStdout.join('');
         const stderr = capturedStderr.join('');
-        expect(stdout).toContain('Solution text');
+        expect(stdout).toContain(MOCK_SOLUTION_TEXT);
         expect(stderr).toContain('Running debate (verbose)');
         expect(stderr).toContain('Summary (verbose)');
         expect(stderr).toMatch(/Round\s+1/);
@@ -150,6 +173,136 @@ describe('CLI debate command', () => {
             .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
         expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: problem is required (provide <problem> or --problemDescription)'));
     });
+    describe('Output results', () => {
+        let tmpDir;
+        beforeEach(() => {
+            process.env.OPENAI_API_KEY = 'test';
+            tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'output-test-'));
+        });
+        afterEach(() => {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        });
+        it('should write JSON output when output path ends with .json', async () => {
+            const outputFile = path_1.default.join(tmpDir, 'result.json');
+            await (0, index_1.runCli)(['debate', 'Design a system', '--output', outputFile]);
+            expect(fs_1.default.existsSync(outputFile)).toBe(true);
+            const content = JSON.parse(fs_1.default.readFileSync(outputFile, 'utf-8'));
+            expect(content).toHaveProperty('id');
+            expect(content).toHaveProperty('problem');
+            expect(content).toHaveProperty('rounds');
+        });
+        it('should write text output when output path does not end with .json', async () => {
+            const outputFile = path_1.default.join(tmpDir, 'result.txt');
+            await (0, index_1.runCli)(['debate', 'Design a system', '--output', outputFile]);
+            expect(fs_1.default.existsSync(outputFile)).toBe(true);
+            const content = fs_1.default.readFileSync(outputFile, 'utf-8');
+            expect(content).toContain(MOCK_SOLUTION_TEXT);
+        });
+        it('should write to stdout when no output path is provided', async () => {
+            const capturedStdout = [];
+            const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+                capturedStdout.push(String(chunk));
+                return true;
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system']);
+            const stdout = capturedStdout.join('');
+            expect(stdout).toContain(MOCK_SOLUTION_TEXT);
+            stdoutWriteSpy.mockRestore();
+        });
+        it('should show verbose summary when no output path and verbose is true', async () => {
+            const capturedStderr = [];
+            const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+                capturedStderr.push(String(chunk));
+                return true;
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+            const stderr = capturedStderr.join('');
+            expect(stderr).toContain('Summary (verbose)');
+            stderrWriteSpy.mockRestore();
+        });
+        it('should not show verbose summary when output path is provided', async () => {
+            const outputFile = path_1.default.join(tmpDir, 'result.txt');
+            const capturedStderr = [];
+            const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+                capturedStderr.push(String(chunk));
+                return true;
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--output', outputFile, '--rounds', '1']);
+            const stderr = capturedStderr.join('');
+            expect(stderr).not.toContain('Summary (verbose)');
+            stderrWriteSpy.mockRestore();
+        });
+    });
+    describe('Problem description resolution', () => {
+        let tmpDir;
+        beforeEach(() => {
+            process.env.OPENAI_API_KEY = 'test';
+            tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'problem-test-'));
+        });
+        afterEach(() => {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        });
+        it('should use file when both problem string and --problemDescription are provided', async () => {
+            const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+            fs_1.default.writeFileSync(problemFile, 'Problem from file');
+            const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await (0, index_1.runCli)(['debate', 'Problem from string', '--problemDescription', problemFile, '--rounds', '1']);
+            expect(stdoutWriteSpy).toHaveBeenCalled();
+            stdoutWriteSpy.mockRestore();
+        });
+        it('should read problem from file when --problemDescription is provided', async () => {
+            const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+            const problemContent = 'Design a distributed cache system';
+            fs_1.default.writeFileSync(problemFile, problemContent);
+            await (0, index_1.runCli)(['debate', '--problemDescription', problemFile]);
+            expect(stdoutSpy).toHaveBeenCalled();
+        });
+        it('should error when problem file does not exist', async () => {
+            const nonExistentFile = path_1.default.join(tmpDir, 'nonexistent.txt');
+            await expect((0, index_1.runCli)(['debate', '--problemDescription', nonExistentFile]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+            expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: problem description file not found'));
+        });
+        it('should error when problem file path is a directory', async () => {
+            await expect((0, index_1.runCli)(['debate', '--problemDescription', tmpDir]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+            expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: problem description path is a directory'));
+        });
+        it('should error when problem file is empty', async () => {
+            const emptyFile = path_1.default.join(tmpDir, 'empty.txt');
+            fs_1.default.writeFileSync(emptyFile, '');
+            await expect((0, index_1.runCli)(['debate', '--problemDescription', emptyFile]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+            expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: problem description file is empty'));
+        });
+        it('should error when problem file is whitespace-only', async () => {
+            const whitespaceFile = path_1.default.join(tmpDir, 'whitespace.txt');
+            fs_1.default.writeFileSync(whitespaceFile, '   \n\t  ');
+            await expect((0, index_1.runCli)(['debate', '--problemDescription', whitespaceFile]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+            expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: problem description file is empty'));
+        });
+        it('should error when problem file read fails', async () => {
+            const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+            fs_1.default.writeFileSync(problemFile, 'Some content');
+            jest.spyOn(fs_1.default.promises, 'readFile').mockRejectedValueOnce(new Error('Permission denied'));
+            await expect((0, index_1.runCli)(['debate', '--problemDescription', problemFile]))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+            expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to read problem description file'));
+            jest.spyOn(fs_1.default.promises, 'readFile').mockRestore();
+        });
+        it('should trim whitespace from problem string', async () => {
+            const problemWithWhitespace = '   Design a system   \n\t  ';
+            await (0, index_1.runCli)(['debate', problemWithWhitespace]);
+            expect(stdoutSpy).toHaveBeenCalled();
+        });
+    });
     describe('environment file loading', () => {
         it('should call loadEnvironmentFile with default parameters', async () => {
             process.env.OPENAI_API_KEY = 'test';
@@ -207,6 +360,749 @@ describe('Configuration loading', () => {
             }
         }
     });
+    it('should use built-in defaults when agents array is empty', async () => {
+        let tmpDir;
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
+        try {
+            const configPath = getTestConfigPath(tmpDir);
+            const configContent = {
+                agents: [],
+                debate: createTestDebateConfig(),
+            };
+            fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+            const cfg = await (0, debate_1.loadConfig)(configPath);
+            expect(cfg.agents.length).toBeGreaterThan(0);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Config missing agents'));
+            consoleErrorSpy.mockRestore();
+        }
+        finally {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+    it('should use default judge when judge is missing', async () => {
+        let tmpDir;
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
+        try {
+            const configPath = getTestConfigPath(tmpDir);
+            const configContent = {
+                agents: [createTestAgentConfig()],
+                debate: createTestDebateConfig(),
+            };
+            fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+            const cfg = await (0, debate_1.loadConfig)(configPath);
+            expect(cfg.judge).toBeDefined();
+            expect(cfg.judge.id).toBeDefined();
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Config missing judge'));
+            consoleErrorSpy.mockRestore();
+        }
+        finally {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+    it('should use default debate when debate is missing', async () => {
+        let tmpDir;
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
+        try {
+            const configPath = getTestConfigPath(tmpDir);
+            const configContent = {
+                agents: [createTestAgentConfig()],
+                judge: {
+                    id: 'test-judge',
+                    name: 'Test Judge',
+                    role: 'generalist',
+                    model: 'gpt-4',
+                    provider: 'openai',
+                    temperature: 0.3,
+                },
+            };
+            fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+            const cfg = await (0, debate_1.loadConfig)(configPath);
+            expect(cfg.debate).toBeDefined();
+            expect(cfg.debate.rounds).toBeDefined();
+        }
+        finally {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+    it('should load config successfully when all fields are present', async () => {
+        let tmpDir;
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
+        try {
+            const configPath = getTestConfigPath(tmpDir);
+            const configContent = createTestConfigContent();
+            fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+            const cfg = await (0, debate_1.loadConfig)(configPath);
+            expect(cfg.agents).toBeDefined();
+            expect(cfg.agents.length).toBe(1);
+            expect(cfg.judge).toBeDefined();
+            expect(cfg.debate).toBeDefined();
+        }
+        finally {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+});
+describe('Debate config validation', () => {
+    const originalEnv = process.env;
+    let stderrWriteSpy;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        resetLoadEnvironmentFileMock();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        stderrWriteSpy.mockRestore();
+    });
+    it('should use options.rounds when provided', async () => {
+        const capturedStdout = [];
+        const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            capturedStdout.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '2']);
+        expect(stdoutWriteSpy).toHaveBeenCalled();
+        stdoutWriteSpy.mockRestore();
+    });
+    it('should use sysConfig.debate.rounds when options.rounds is not provided', async () => {
+        let tmpDir;
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
+        try {
+            const configPath = getTestConfigPath(tmpDir);
+            const configContent = createTestConfigContent(undefined, {
+                rounds: 5,
+            });
+            fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+            const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath]);
+            expect(stdoutWriteSpy).toHaveBeenCalled();
+            stdoutWriteSpy.mockRestore();
+        }
+        finally {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    });
+    it('should use DEFAULT_ROUNDS when neither options.rounds nor sysConfig.debate.rounds is provided', async () => {
+        const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await (0, index_1.runCli)(['debate', 'Design a system']);
+        expect(stdoutWriteSpy).toHaveBeenCalled();
+        stdoutWriteSpy.mockRestore();
+    });
+    it('should error when rounds is 0', async () => {
+        await expect((0, index_1.runCli)(['debate', 'Design a system', '--rounds', '0']))
+            .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+        expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: --rounds must be >= 1'));
+    });
+    it('should error when rounds is negative', async () => {
+        await expect((0, index_1.runCli)(['debate', 'Design a system', '--rounds', '-1']))
+            .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+        expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid arguments: --rounds must be >= 1'));
+    });
+});
+describe('Agent filtering', () => {
+    let tmpDir;
+    const originalEnv = process.env;
+    let stdoutSpy;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'agent-filter-test-'));
+        stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        resetLoadEnvironmentFileMock();
+    });
+    afterEach(() => {
+        try {
+            fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+        process.env = originalEnv;
+        stdoutSpy.mockRestore();
+    });
+    it('should filter agents by role when --agents is provided', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ id: 'arch1', role: 'architect' }),
+                createTestAgentConfig({ id: 'perf1', role: 'performance' }),
+                createTestAgentConfig({ id: 'sec1', role: 'security' }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--agents', 'architect,performance', '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toContain('architect');
+        expect(stderr).toContain('performance');
+        expect(stderr).not.toContain('sec1');
+        stderrWriteSpy.mockRestore();
+    });
+    it('should use all enabled agents when --agents is not provided', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ id: 'arch1', role: 'architect' }),
+                createTestAgentConfig({ id: 'perf1', role: 'performance' }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should filter out disabled agents', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ id: 'arch1', name: 'Architect Agent', role: 'architect', enabled: true }),
+                createTestAgentConfig({ id: 'perf1', name: 'Performance Agent', role: 'performance', enabled: false }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toContain('Architect Agent');
+        expect(stderr).not.toContain('Performance Agent');
+        stderrWriteSpy.mockRestore();
+    });
+    it('should default to built-in agents when no agents match filter', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ id: 'arch1', role: 'architect' }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--agents', 'nonexistent-role', '--rounds', '1']);
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No agents selected; defaulting to architect,performance.'));
+        consoleErrorSpy.mockRestore();
+    });
+    it('should default to built-in agents when filtered result is empty', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ id: 'arch1', role: 'architect', enabled: false }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No agents selected; defaulting to architect,performance.'));
+        consoleErrorSpy.mockRestore();
+    });
+});
+describe('Prompt resolution branches', () => {
+    let tmpDir;
+    const originalEnv = process.env;
+    let stdoutSpy;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'prompt-test-'));
+        stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        resetLoadEnvironmentFileMock();
+    });
+    afterEach(() => {
+        try {
+            fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+        process.env = originalEnv;
+        stdoutSpy.mockRestore();
+    });
+    it('should use file prompt when systemPromptPath is provided', async () => {
+        const promptFile = path_1.default.join(tmpDir, 'system-prompt.txt');
+        fs_1.default.writeFileSync(promptFile, 'Custom system prompt');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ systemPromptPath: promptFile }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toMatch(/System prompt: (file|.*\.txt)/);
+        stderrWriteSpy.mockRestore();
+    });
+    it('should use built-in prompt when systemPromptPath is not provided', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent();
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toContain('built-in default');
+        stderrWriteSpy.mockRestore();
+    });
+    it('should use file summary prompt when summaryPromptPath is provided', async () => {
+        const summaryPromptFile = path_1.default.join(tmpDir, 'summary-prompt.txt');
+        fs_1.default.writeFileSync(summaryPromptFile, 'Custom summary prompt');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ summaryPromptPath: summaryPromptFile }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should use built-in summary prompt when summaryPromptPath is not provided', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent();
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should include absPath in metadata when prompt file is used', async () => {
+        const promptFile = path_1.default.join(tmpDir, 'system-prompt.txt');
+        fs_1.default.writeFileSync(promptFile, 'Custom system prompt');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ systemPromptPath: promptFile }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+                systemPromptPath: promptFile,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1', '--output', path_1.default.join(tmpDir, 'result.json')]);
+        const resultFile = path_1.default.join(tmpDir, 'result.json');
+        if (fs_1.default.existsSync(resultFile)) {
+            const debateState = JSON.parse(fs_1.default.readFileSync(resultFile, 'utf-8'));
+            expect(debateState).toBeDefined();
+        }
+    });
+    it('should use configDir when provided', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const promptFile = 'system-prompt.txt';
+        const fullPromptPath = path_1.default.join(tmpDir, promptFile);
+        fs_1.default.writeFileSync(fullPromptPath, 'Custom system prompt');
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ systemPromptPath: promptFile }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should use process.cwd() when configDir is not provided', async () => {
+        await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+});
+describe('Tracing context', () => {
+    let tmpDir;
+    const originalEnv = process.env;
+    let stdoutSpy;
+    let consoleErrorSpy;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'tracing-test-'));
+        stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        resetLoadEnvironmentFileMock();
+    });
+    afterEach(() => {
+        try {
+            fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+        process.env = originalEnv;
+        stdoutSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+    });
+    it('should return undefined when trace is not LANGFUSE', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'none',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+        expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Langfuse tracing enabled'));
+    });
+    it('should initialize tracing when trace is LANGFUSE and config is valid', async () => {
+        process.env.LANGFUSE_SECRET_KEY = 'test-secret-key';
+        process.env.LANGFUSE_PUBLIC_KEY = 'test-public-key';
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'langfuse',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Langfuse tracing enabled'));
+    });
+    it('should handle tracing initialization errors gracefully', async () => {
+        delete process.env.LANGFUSE_SECRET_KEY;
+        delete process.env.LANGFUSE_PUBLIC_KEY;
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'langfuse',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Langfuse tracing initialization failed'));
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should include problemFileName in metadata when provided', async () => {
+        process.env.LANGFUSE_SECRET_KEY = 'test-secret-key';
+        process.env.LANGFUSE_PUBLIC_KEY = 'test-public-key';
+        const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+        fs_1.default.writeFileSync(problemFile, 'Design a system');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'langfuse',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', '--problemDescription', problemFile, '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should not include problemFileName in metadata when not provided', async () => {
+        process.env.LANGFUSE_SECRET_KEY = 'test-secret-key';
+        process.env.LANGFUSE_PUBLIC_KEY = 'test-public-key';
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'langfuse',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should include contextFileName in metadata when provided', async () => {
+        process.env.LANGFUSE_SECRET_KEY = 'test-secret-key';
+        process.env.LANGFUSE_PUBLIC_KEY = 'test-public-key';
+        const contextFile = path_1.default.join(tmpDir, 'context.txt');
+        fs_1.default.writeFileSync(contextFile, 'Additional context');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'langfuse',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextFile, '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+    it('should include judgeConfig in metadata when judge exists', async () => {
+        process.env.LANGFUSE_SECRET_KEY = 'test-secret-key';
+        process.env.LANGFUSE_PUBLIC_KEY = 'test-public-key';
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent(undefined, {
+            trace: 'langfuse',
+        });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+        expect(stdoutSpy).toHaveBeenCalled();
+    });
+});
+describe('Round summary output', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        resetLoadEnvironmentFileMock();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it('should output summaries when round has summaries', async () => {
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toMatch(/Round\s+\d+/);
+        stderrWriteSpy.mockRestore();
+    });
+    it('should output contributions when round has contributions', async () => {
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr.length).toBeGreaterThan(0);
+        stderrWriteSpy.mockRestore();
+    });
+    it('should handle contributions with metadata', async () => {
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toMatch(/latency=|tokens=/);
+        stderrWriteSpy.mockRestore();
+    });
+});
+describe('Verbose header branches', () => {
+    let tmpDir;
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'verbose-header-test-'));
+        resetLoadEnvironmentFileMock();
+    });
+    afterEach(() => {
+        try {
+            fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+        process.env = originalEnv;
+    });
+    it('should show file prompt source in verbose header when prompt is from file', async () => {
+        const promptFile = path_1.default.join(tmpDir, 'system-prompt.txt');
+        fs_1.default.writeFileSync(promptFile, 'Custom system prompt');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ systemPromptPath: promptFile }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+                systemPromptPath: promptFile,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toMatch(/System prompt: (file|.*system-prompt\.txt)/);
+        stderrWriteSpy.mockRestore();
+    });
+    it('should show built-in prompt source in verbose header when prompt is built-in', async () => {
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = createTestConfigContent();
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toContain('System prompt: built-in default');
+        stderrWriteSpy.mockRestore();
+    });
+    it('should show prompt path when available', async () => {
+        const promptFile = path_1.default.join(tmpDir, 'system-prompt.txt');
+        fs_1.default.writeFileSync(promptFile, 'Custom system prompt');
+        const configPath = getTestConfigPath(tmpDir);
+        const configContent = {
+            agents: [
+                createTestAgentConfig({ systemPromptPath: promptFile }),
+            ],
+            debate: createTestDebateConfig(),
+            judge: {
+                id: 'test-judge',
+                name: 'Test Judge',
+                role: 'generalist',
+                model: 'gpt-4',
+                provider: 'openai',
+                temperature: 0.3,
+                systemPromptPath: promptFile,
+            },
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).toMatch(/System prompt: (file|.*\.txt)/);
+        stderrWriteSpy.mockRestore();
+    });
+    it('should not show verbose header when verbose is false', async () => {
+        const capturedStderr = [];
+        const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+            capturedStderr.push(String(chunk));
+            return true;
+        });
+        await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+        const stderr = capturedStderr.join('');
+        expect(stderr).not.toContain('Running debate (verbose)');
+        expect(stderr).not.toContain('Active Agents:');
+        stderrWriteSpy.mockRestore();
+    });
+});
+describe('Error handling', () => {
+    const originalEnv = process.env;
+    let stderrWriteSpy;
+    let orchestratorSpy;
+    beforeEach(() => {
+        process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        mockedLoadEnvironmentFile.mockImplementation(() => undefined);
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        stderrWriteSpy.mockRestore();
+        if (orchestratorSpy) {
+            orchestratorSpy.mockRestore();
+            orchestratorSpy = undefined;
+        }
+    });
+    it('should use error code when error has code property', async () => {
+        orchestratorSpy = jest.spyOn(require('dialectic-core'), 'DebateOrchestrator').mockImplementation(function () {
+            throw Object.assign(new Error('Test error'), { code: dialectic_core_1.EXIT_INVALID_ARGS });
+        });
+        await expect((0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']))
+            .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+    });
+    it('should use EXIT_GENERAL_ERROR when error has no code property', async () => {
+        orchestratorSpy = jest.spyOn(require('dialectic-core'), 'DebateOrchestrator').mockImplementation(function () {
+            throw new Error('Test error without code');
+        });
+        await expect((0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']))
+            .rejects.toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+    });
+    it('should use error message when available', async () => {
+        const errorMessage = 'Custom error message';
+        orchestratorSpy = jest.spyOn(require('dialectic-core'), 'DebateOrchestrator').mockImplementation(function () {
+            throw Object.assign(new Error(errorMessage), { code: dialectic_core_1.EXIT_GENERAL_ERROR });
+        });
+        await expect((0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']))
+            .rejects.toThrow(errorMessage);
+        expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining(errorMessage));
+    });
+    it('should use "Unknown error" when error has no message', async () => {
+        const errorWithoutMessage = {};
+        errorWithoutMessage.code = dialectic_core_1.EXIT_GENERAL_ERROR;
+        orchestratorSpy = jest.spyOn(require('dialectic-core'), 'DebateOrchestrator').mockImplementation(function () {
+            throw errorWithoutMessage;
+        });
+        await expect((0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']))
+            .rejects.toThrow('Unknown error');
+        expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown error'));
+    });
 });
 describe('Summarization configuration loading', () => {
     let tmpDir;
@@ -319,15 +1215,16 @@ describe('CLI clarifications phase', () => {
         process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
         stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        mockedLoadEnvironmentFile.mockClear();
-        mockedLoadEnvironmentFile.mockReturnValue(undefined);
+        resetLoadEnvironmentFileMock();
+        mockedCollectClarifications.mockClear();
+        mockedCollectClarifications.mockResolvedValue([]);
+        mockReadlineWithAnswers([]);
     });
     afterEach(() => {
         process.env = originalEnv;
         consoleErrorSpy.mockRestore();
         stdoutSpy.mockRestore();
         jest.restoreAllMocks();
-        jest.resetModules();
     });
     function mockReadlineWithAnswers(answers) {
         const readlineMock = require('readline');
@@ -337,15 +1234,27 @@ describe('CLI clarifications phase', () => {
     }
     it('runs clarifications when --clarify and collects answers (including NA)', async () => {
         mockReadlineWithAnswers(['My answer', '']);
-        const spy = jest.spyOn(dialectic_core_1.RoleBasedAgent.prototype, 'askClarifyingQuestions')
-            .mockResolvedValueOnce({ questions: [{ id: 'q1', text: 'What is the SLA?' }] })
-            .mockResolvedValueOnce({ questions: [{ id: 'q1', text: 'Any data retention rules?' }] });
+        mockedCollectClarifications.mockResolvedValueOnce([
+            {
+                agentId: 'agent-architect',
+                agentName: 'System Architect',
+                role: 'architect',
+                items: [{ id: 'q1', question: 'What is the SLA?', answer: '' }]
+            },
+            {
+                agentId: 'agent-performance',
+                agentName: 'Performance Specialist',
+                role: 'performance',
+                items: [{ id: 'q2', question: 'Any data retention rules?', answer: '' }]
+            }
+        ]);
         const tmpReport = path_1.default.join(os_1.default.tmpdir(), `clarify-report-${Date.now()}.md`);
-        await (0, index_1.runCli)(['debate', 'Design Y', '--clarify', '--report', tmpReport]);
-        expect(spy).toHaveBeenCalled();
+        await (0, index_1.runCli)(['debate', 'Design Y', '--clarify', '--report', tmpReport, '--rounds', '1']);
+        expect(mockedCollectClarifications).toHaveBeenCalled();
         const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
         expect(content).toContain('## Clarifications');
         expect(content).toContain('Question (q1):');
+        expect(content).toContain('Question (q2):');
         expect(content).toContain('My answer');
         expect(content).toContain('\n```text\nNA\n```');
     });
@@ -356,14 +1265,221 @@ describe('CLI clarifications phase', () => {
         expect(spy).not.toHaveBeenCalled();
     });
     it('truncates questions per agent and warns', async () => {
-        const many = Array.from({ length: 7 }, (_, i) => ({ id: `q${i + 1}`, text: `Q${i + 1}` }));
-        const spy = jest.spyOn(dialectic_core_1.RoleBasedAgent.prototype, 'askClarifyingQuestions')
-            .mockResolvedValue({ questions: many });
+        const truncatedQuestions = Array.from({ length: 5 }, (_, i) => ({
+            id: `q${i + 1}`,
+            question: `Q${i + 1}`,
+            answer: ''
+        }));
+        mockedCollectClarifications.mockImplementationOnce((_problem, _agents, _maxPerAgent, warn) => {
+            warn('Agent Test Agent returned 7 questions; limited to 5.');
+            return Promise.resolve([{
+                    agentId: 'agent-architect',
+                    agentName: 'Test Agent',
+                    role: 'architect',
+                    items: truncatedQuestions
+                }]);
+        });
         mockReadlineWithAnswers(new Array(10).fill('A'));
         await (0, index_1.runCli)(['debate', 'Design W', '--clarify']);
-        expect(spy).toHaveBeenCalled();
+        expect(mockedCollectClarifications).toHaveBeenCalled();
         const stderr = (consoleErrorSpy.mock.calls.map(args => String(args[0])).join(''));
         expect(stderr).toMatch(/limited to 5/);
+        mockedCollectClarifications.mockClear();
+        mockedCollectClarifications.mockResolvedValue([]);
+    });
+    it('should skip groups with empty items array', async () => {
+        mockedCollectClarifications.mockResolvedValueOnce([
+            {
+                agentId: 'agent1',
+                agentName: 'Agent 1',
+                role: 'architect',
+                items: [],
+            },
+            {
+                agentId: 'agent2',
+                agentName: 'Agent 2',
+                role: 'performance',
+                items: [{ id: 'q1', question: 'Question 1', answer: '' }],
+            },
+        ]);
+        mockReadlineWithAnswers(['Answer 1']);
+        const tmpReport = path_1.default.join(os_1.default.tmpdir(), `clarify-report-${Date.now()}.md`);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--clarify', '--report', tmpReport, '--rounds', '1']);
+        const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
+        expect(content).toContain('Question (q1)');
+        expect(content).toContain('Answer 1');
+        mockedCollectClarifications.mockClear();
+        mockedCollectClarifications.mockResolvedValue([]);
+    });
+    it('should set answer to NA when user input is empty', async () => {
+        mockReadlineWithAnswers(['']);
+        mockedCollectClarifications.mockResolvedValueOnce([
+            {
+                agentId: 'agent-architect',
+                agentName: 'System Architect',
+                role: 'architect',
+                items: [{ id: 'q1', question: 'What is the requirement?', answer: '' }]
+            }
+        ]);
+        const tmpReport = path_1.default.join(os_1.default.tmpdir(), `clarify-report-${Date.now()}.md`);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--clarify', '--report', tmpReport, '--rounds', '1']);
+        const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
+        expect(content).toContain('\n```text\nNA\n```');
+        mockedCollectClarifications.mockClear();
+        mockedCollectClarifications.mockResolvedValue([]);
+    });
+    it('should set answer to user input when provided', async () => {
+        const userAnswer = 'The requirement is X';
+        mockReadlineWithAnswers([userAnswer]);
+        mockedCollectClarifications.mockResolvedValueOnce([
+            {
+                agentId: 'agent-architect',
+                agentName: 'System Architect',
+                role: 'architect',
+                items: [{ id: 'q1', question: 'What is the requirement?', answer: '' }]
+            }
+        ]);
+        const tmpReport = path_1.default.join(os_1.default.tmpdir(), `clarify-report-${Date.now()}.md`);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--clarify', '--report', tmpReport, '--rounds', '1']);
+        const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
+        expect(content).toContain(userAnswer);
+        mockedCollectClarifications.mockClear();
+        mockedCollectClarifications.mockResolvedValue([]);
+    });
+    describe('Report generation', () => {
+        let tmpDir;
+        const originalEnv = process.env;
+        beforeEach(() => {
+            process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+            tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'report-test-'));
+        });
+        afterEach(() => {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+            process.env = originalEnv;
+        });
+        it('should append .md extension when report path does not end with .md', async () => {
+            const reportPath = path_1.default.join(tmpDir, 'report');
+            await (0, index_1.runCli)(['debate', 'Design a system', '--report', reportPath, '--rounds', '1']);
+            const expectedPath = reportPath + '.md';
+            expect(fs_1.default.existsSync(expectedPath)).toBe(true);
+            const content = fs_1.default.readFileSync(expectedPath, 'utf-8');
+            expect(content).toContain('## Problem Description');
+        });
+        it('should not append .md extension when report path already ends with .md', async () => {
+            const reportPath = path_1.default.join(tmpDir, 'report.md');
+            await (0, index_1.runCli)(['debate', 'Design a system', '--report', reportPath, '--rounds', '1']);
+            expect(fs_1.default.existsSync(reportPath)).toBe(true);
+            const content = fs_1.default.readFileSync(reportPath, 'utf-8');
+            expect(content).toContain('## Problem Description');
+        });
+        it('should handle report generation errors gracefully', async () => {
+            const reportPath = path_1.default.join(tmpDir, 'report.md');
+            mockedGenerateDebateReport.mockImplementationOnce(() => {
+                throw new Error('Report generation failed');
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--report', reportPath, '--rounds', '1']);
+            const errorCalls = consoleErrorSpy.mock.calls.map(args => String(args[0])).join('');
+            expect(errorCalls).toMatch(/Failed to generate report/);
+            mockedGenerateDebateReport.mockImplementation(jest.requireActual('dialectic-core').generateDebateReport);
+        });
+    });
+    describe('Agent logger', () => {
+        const originalEnv = process.env;
+        beforeEach(() => {
+            process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+        });
+        afterEach(() => {
+            process.env = originalEnv;
+        });
+        it('should log when onlyVerbose is false', async () => {
+            const capturedStdout = [];
+            const stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+                capturedStdout.push(String(chunk));
+                return true;
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+            const stdout = capturedStdout.join('');
+            expect(stdout.length).toBeGreaterThan(0);
+            stdoutWriteSpy.mockRestore();
+        });
+        it('should log when onlyVerbose is true and verbose is true', async () => {
+            const capturedStderr = [];
+            const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+                capturedStderr.push(String(chunk));
+                return true;
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+            const stderr = capturedStderr.join('');
+            expect(stderr).toContain('Running debate (verbose)');
+            stderrWriteSpy.mockRestore();
+        });
+        it('should not log when onlyVerbose is true and verbose is false', async () => {
+            const capturedStderr = [];
+            const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+                capturedStderr.push(String(chunk));
+                return true;
+            });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+            const stderr = capturedStderr.join('');
+            expect(stderr).not.toContain('Running debate (verbose)');
+            stderrWriteSpy.mockRestore();
+        });
+    });
+    describe('Context file handling', () => {
+        let tmpDir;
+        const originalEnv = process.env;
+        beforeEach(() => {
+            process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+            tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'context-test-'));
+        });
+        afterEach(() => {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { }
+            process.env = originalEnv;
+        });
+        it('should return undefined when context file does not exist', async () => {
+            const nonExistentFile = path_1.default.join(tmpDir, 'nonexistent.txt');
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', nonExistentFile]);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Context file not found'));
+        });
+        it('should return undefined when context path is a directory', async () => {
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', tmpDir]);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Context path is a directory'));
+        });
+        it('should return undefined when context file is empty', async () => {
+            const emptyFile = path_1.default.join(tmpDir, 'empty.txt');
+            fs_1.default.writeFileSync(emptyFile, '');
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', emptyFile]);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Context file is empty'));
+        });
+        it('should truncate context file exceeding MAX_CONTEXT_LENGTH', async () => {
+            const longFile = path_1.default.join(tmpDir, 'long.txt');
+            const longContent = 'x'.repeat(6000);
+            fs_1.default.writeFileSync(longFile, longContent);
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', longFile]);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Context file exceeds 5000 characters'));
+        });
+        it('should return undefined when context file read fails', async () => {
+            const contextFile = path_1.default.join(tmpDir, 'context.txt');
+            fs_1.default.writeFileSync(contextFile, 'Some context');
+            jest.spyOn(fs_1.default.promises, 'readFile').mockRejectedValueOnce(new Error('Permission denied'));
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextFile]);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to read context file'));
+            jest.spyOn(fs_1.default.promises, 'readFile').mockRestore();
+        });
+        it('should return context content when file is valid', async () => {
+            const contextFile = path_1.default.join(tmpDir, 'context.txt');
+            const contextContent = 'Additional context information';
+            fs_1.default.writeFileSync(contextFile, contextContent);
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextFile]);
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context file not found'));
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context file is empty'));
+        });
     });
 });
 //# sourceMappingURL=debate.spec.js.map