dialectic 0.5.2 → 0.7.0

package/dist/commands/debate.spec.js

@@ -1,13 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const index_1 = require("../index");
+const dialecticCore = __importStar(require("dialectic-core"));
 const dialectic_core_1 = require("dialectic-core");
+const indexModule = __importStar(require("../index"));
+const index_1 = require("../index");
 const debate_1 = require("./debate");
 const MOCK_SOLUTION_TEXT = 'Solution text';
 jest.mock('openai', () => {
@@ -16,10 +51,11 @@ jest.mock('openai', () => {
         default: class OpenAIMock {
             chat = {
                 completions: {
-                    create: async (_) => ({ choices: [{ message: { content: MOCK_SOLUTION_TEXT } }] }),
+                    create: async () => ({ choices: [{ message: { content: MOCK_SOLUTION_TEXT } }] }),
                 },
             };
-            constructor(_opts) { }
+            constructor() {
+            }
         },
     };
 });
@@ -31,25 +67,29 @@ jest.mock('dialectic-core', () => {
             return undefined;
         }),
         collectClarifications: jest.fn().mockResolvedValue([]),
-        generateDebateReport: jest.fn().mockImplementation(actual.generateDebateReport)
+        generateDebateReport: jest.fn().mockImplementation(actual.generateDebateReport),
+        validateLangfuseConfig: jest.fn().mockImplementation(actual.validateLangfuseConfig),
+        createTracingContext: jest.fn().mockImplementation(actual.createTracingContext),
+        logWarning: jest.fn().mockImplementation(actual.logWarning),
     };
 });
+let mockAnswers = [];
+let currentIndex = 0;
 jest.mock('readline', () => {
-    let mockAnswers = [];
-    let currentIndex = 0;
     return {
         __esModule: true,
         default: {
             createInterface: () => ({
-                question: (_, cb) => {
+                question: (_prompt, cb) => {
                     const ans = currentIndex < mockAnswers.length ? mockAnswers[currentIndex++] : '';
-                    Promise.resolve().then(() => cb(String(ans)));
+                    cb(String(ans));
+                },
+                close: () => {
                 },
-                close: () => { },
             })
         },
         __setMockAnswers: (answers) => {
-            mockAnswers = answers;
+            mockAnswers = [...answers];
             currentIndex = 0;
         }
     };
@@ -183,7 +223,8 @@ describe('CLI debate command', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            catch {
+            }
         });
         it('should write JSON output when output path ends with .json', async () => {
             const outputFile = path_1.default.join(tmpDir, 'result.json');
@@ -246,15 +287,14 @@ describe('CLI debate command', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            catch {
+            }
         });
-        it('should use file when both problem string and --problemDescription are provided', async () => {
+        it('should error 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();
+            await expect((0, index_1.runCli)(['debate', 'Problem from string', '--problemDescription', problemFile, '--rounds', '1']))
+                .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
         });
         it('should read problem from file when --problemDescription is provided', async () => {
             const problemFile = path_1.default.join(tmpDir, 'problem.txt');
@@ -361,8 +401,7 @@ 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-'));
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
         try {
             const configPath = getTestConfigPath(tmpDir);
             const configContent = {
@@ -380,12 +419,12 @@ describe('Configuration loading', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            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-'));
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
         try {
             const configPath = getTestConfigPath(tmpDir);
             const configContent = {
@@ -404,12 +443,12 @@ describe('Configuration loading', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            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-'));
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
         try {
             const configPath = getTestConfigPath(tmpDir);
             const configContent = {
@@ -432,12 +471,12 @@ describe('Configuration loading', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            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-'));
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
         try {
             const configPath = getTestConfigPath(tmpDir);
             const configContent = createTestConfigContent();
@@ -452,7 +491,8 @@ describe('Configuration loading', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            catch {
+            }
         }
     });
 });
@@ -479,8 +519,7 @@ describe('Debate config validation', () => {
         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-'));
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'config-test-'));
         try {
             const configPath = getTestConfigPath(tmpDir);
             const configContent = createTestConfigContent(undefined, {
@@ -496,7 +535,8 @@ describe('Debate config validation', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            catch {
+            }
         }
     });
     it('should use DEFAULT_ROUNDS when neither options.rounds nor sysConfig.debate.rounds is provided', async () => {
@@ -530,7 +570,8 @@ describe('Agent filtering', () => {
         try {
             fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
         }
-        catch { }
+        catch {
+        }
         process.env = originalEnv;
         stdoutSpy.mockRestore();
     });
@@ -674,7 +715,8 @@ describe('Prompt resolution branches', () => {
         try {
             fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
         }
-        catch { }
+        catch {
+        }
         process.env = originalEnv;
         stdoutSpy.mockRestore();
     });
@@ -821,7 +863,8 @@ describe('Tracing context', () => {
         try {
             fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
         }
-        catch { }
+        catch {
+        }
         process.env = originalEnv;
         stdoutSpy.mockRestore();
         consoleErrorSpy.mockRestore();
@@ -886,14 +929,14 @@ describe('Tracing context', () => {
     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 contextDir = path_1.default.join(tmpDir, 'context');
+        fs_1.default.mkdirSync(contextDir, { recursive: true });
         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']);
+        await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextDir, '--config', configPath, '--rounds', '1']);
         expect(stdoutSpy).toHaveBeenCalled();
     });
     it('should include judgeConfig in metadata when judge exists', async () => {
@@ -963,7 +1006,8 @@ describe('Verbose header branches', () => {
         try {
             fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
         }
-        catch { }
+        catch {
+        }
         process.env = originalEnv;
     });
     it('should show file prompt source in verbose header when prompt is from file', async () => {
@@ -1071,37 +1115,38 @@ describe('Error handling', () => {
         }
     });
     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);
+        const testError = Object.assign(new Error('Test error'), { code: dialectic_core_1.EXIT_INVALID_ARGS });
+        const errorWithCode = testError;
+        const code = (errorWithCode && typeof errorWithCode.code === 'number')
+            ? errorWithCode.code
+            : dialectic_core_1.EXIT_GENERAL_ERROR;
+        expect(code).toBe(dialectic_core_1.EXIT_INVALID_ARGS);
+        expect(testError.message).toBe('Test error');
     });
     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);
+        const testError = new Error('Test error without code');
+        const errorWithCode = testError;
+        const code = (errorWithCode && typeof errorWithCode.code === 'number')
+            ? errorWithCode.code
+            : dialectic_core_1.EXIT_GENERAL_ERROR;
+        expect(code).toBe(dialectic_core_1.EXIT_GENERAL_ERROR);
+        expect(testError.message).toBe('Test error without code');
     });
     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));
+        const testError = Object.assign(new Error(errorMessage), { code: dialectic_core_1.EXIT_GENERAL_ERROR });
+        const message = testError?.message || 'Unknown error';
+        expect(message).toBe(errorMessage);
+        expect(testError.code).toBe(dialectic_core_1.EXIT_GENERAL_ERROR);
     });
     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'));
+        const message = (errorWithoutMessage && typeof errorWithoutMessage === 'object' && 'message' in errorWithoutMessage && typeof errorWithoutMessage.message === 'string')
+            ? errorWithoutMessage.message
+            : 'Unknown error';
+        expect(message).toBe('Unknown error');
+        expect(errorWithoutMessage.code).toBe(dialectic_core_1.EXIT_GENERAL_ERROR);
     });
 });
 describe('Summarization configuration loading', () => {
@@ -1113,7 +1158,8 @@ describe('Summarization configuration loading', () => {
         try {
             fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
         }
-        catch { }
+        catch {
+        }
     });
     it('should load default summarization config when not specified', async () => {
         const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
@@ -1218,6 +1264,8 @@ describe('CLI clarifications phase', () => {
         resetLoadEnvironmentFileMock();
         mockedCollectClarifications.mockClear();
         mockedCollectClarifications.mockResolvedValue([]);
+        mockAnswers = [];
+        currentIndex = 0;
         mockReadlineWithAnswers([]);
     });
     afterEach(() => {
@@ -1227,12 +1275,20 @@ describe('CLI clarifications phase', () => {
         jest.restoreAllMocks();
     });
     function mockReadlineWithAnswers(answers) {
-        const readlineMock = require('readline');
-        if (readlineMock.__setMockAnswers) {
-            readlineMock.__setMockAnswers(answers);
+        const readlineModule = require('readline');
+        if (readlineModule.__setMockAnswers) {
+            readlineModule.__setMockAnswers(answers);
+        }
+        else {
+            mockAnswers = [...answers];
+            currentIndex = 0;
         }
     }
     it('runs clarifications when --clarify and collects answers (including NA)', async () => {
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'clarify-na-'));
+        const configPath = path_1.default.join(tmpDir, 'debate-config.json');
+        const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
         mockReadlineWithAnswers(['My answer', '']);
         mockedCollectClarifications.mockResolvedValueOnce([
             {
@@ -1249,7 +1305,7 @@ describe('CLI clarifications phase', () => {
             }
         ]);
         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']);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--config', configPath, '--clarify', '--report', tmpReport, '--rounds', '1']);
         expect(mockedCollectClarifications).toHaveBeenCalled();
         const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
         expect(content).toContain('## Clarifications');
@@ -1265,6 +1321,10 @@ describe('CLI clarifications phase', () => {
         expect(spy).not.toHaveBeenCalled();
     });
     it('truncates questions per agent and warns', async () => {
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'clarify-trunc-'));
+        const configPath = path_1.default.join(tmpDir, 'debate-config.json');
+        const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
         const truncatedQuestions = Array.from({ length: 5 }, (_, i) => ({
             id: `q${i + 1}`,
             question: `Q${i + 1}`,
@@ -1280,7 +1340,7 @@ describe('CLI clarifications phase', () => {
                 }]);
         });
         mockReadlineWithAnswers(new Array(10).fill('A'));
-        await (0, index_1.runCli)(['debate', 'Design W', '--clarify']);
+        await (0, index_1.runCli)(['debate', 'Design W', '--config', configPath, '--clarify']);
         expect(mockedCollectClarifications).toHaveBeenCalled();
         const stderr = (consoleErrorSpy.mock.calls.map(args => String(args[0])).join(''));
         expect(stderr).toMatch(/limited to 5/);
@@ -1288,6 +1348,10 @@ describe('CLI clarifications phase', () => {
         mockedCollectClarifications.mockResolvedValue([]);
     });
     it('should skip groups with empty items array', async () => {
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'clarify-empty-'));
+        const configPath = path_1.default.join(tmpDir, 'debate-config.json');
+        const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
         mockedCollectClarifications.mockResolvedValueOnce([
             {
                 agentId: 'agent1',
@@ -1304,7 +1368,7 @@ describe('CLI clarifications phase', () => {
         ]);
         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']);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--config', configPath, '--clarify', '--report', tmpReport, '--rounds', '1']);
         const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
         expect(content).toContain('Question (q1)');
         expect(content).toContain('Answer 1');
@@ -1312,6 +1376,10 @@ describe('CLI clarifications phase', () => {
         mockedCollectClarifications.mockResolvedValue([]);
     });
     it('should set answer to NA when user input is empty', async () => {
+        const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'clarify-na-input-'));
+        const configPath = path_1.default.join(tmpDir, 'debate-config.json');
+        const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
         mockReadlineWithAnswers(['']);
         mockedCollectClarifications.mockResolvedValueOnce([
             {
@@ -1322,13 +1390,17 @@ describe('CLI clarifications phase', () => {
             }
         ]);
         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']);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--config', configPath, '--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 tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'clarify-user-input-'));
+        const configPath = path_1.default.join(tmpDir, 'debate-config.json');
+        const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
         const userAnswer = 'The requirement is X';
         mockReadlineWithAnswers([userAnswer]);
         mockedCollectClarifications.mockResolvedValueOnce([
@@ -1340,7 +1412,7 @@ describe('CLI clarifications phase', () => {
             }
         ]);
         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']);
+        await (0, index_1.runCli)(['debate', 'Design Y', '--config', configPath, '--clarify', '--report', tmpReport, '--rounds', '1']);
         const content = fs_1.default.readFileSync(tmpReport, 'utf-8');
         expect(content).toContain(userAnswer);
         mockedCollectClarifications.mockClear();
@@ -1357,7 +1429,8 @@ describe('CLI clarifications phase', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            catch {
+            }
             process.env = originalEnv;
         });
         it('should append .md extension when report path does not end with .md', async () => {
@@ -1428,9 +1501,10 @@ describe('CLI clarifications phase', () => {
             stderrWriteSpy.mockRestore();
         });
     });
-    describe('Context file handling', () => {
+    describe('Context directory handling', () => {
         let tmpDir;
         const originalEnv = process.env;
+        const originalCwd = process.cwd();
         beforeEach(() => {
             process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
             tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'context-test-'));
@@ -1439,46 +1513,1667 @@ describe('CLI clarifications phase', () => {
             try {
                 fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch { }
+            catch {
+            }
             process.env = originalEnv;
+            process.chdir(originalCwd);
+        });
+        it('should accept a valid directory path', async () => {
+            const contextDir = path_1.default.join(tmpDir, 'context');
+            fs_1.default.mkdirSync(contextDir, { recursive: true });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextDir]);
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context directory not found'));
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context path is not a directory'));
+        });
+        it('should throw error when context directory does not exist', async () => {
+            const nonExistentDir = path_1.default.join(tmpDir, 'nonexistent');
+            await expect((0, index_1.runCli)(['debate', 'Design a system', '--context', nonExistentDir]))
+                .rejects.toMatchObject({
+                code: dialectic_core_1.EXIT_INVALID_ARGS,
+                message: expect.stringContaining('Context directory not found')
+            });
         });
-        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 throw error when context path is a file (not a directory)', async () => {
+            const contextFile = path_1.default.join(tmpDir, 'context.txt');
+            fs_1.default.writeFileSync(contextFile, 'Some content');
+            await expect((0, index_1.runCli)(['debate', 'Design a system', '--context', contextFile]))
+                .rejects.toMatchObject({
+                code: dialectic_core_1.EXIT_INVALID_ARGS,
+                message: expect.stringContaining('Context path is not a directory')
+            });
         });
-        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 default to current working directory when context is not provided', async () => {
+            process.chdir(tmpDir);
+            await (0, index_1.runCli)(['debate', 'Design a system']);
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context 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 resolve relative paths relative to current working directory', async () => {
+            const baseDir = path_1.default.join(tmpDir, 'base');
+            const nestedDir = path_1.default.join(baseDir, 'nested');
+            fs_1.default.mkdirSync(nestedDir, { recursive: true });
+            process.chdir(baseDir);
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', 'nested']);
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context directory not found'));
         });
-        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 accept absolute paths', async () => {
+            const contextDir = path_1.default.join(tmpDir, 'context');
+            fs_1.default.mkdirSync(contextDir, { recursive: true });
+            await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextDir]);
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Context directory not found'));
         });
-        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();
+    });
+    describe('Additional coverage tests for full coverage', () => {
+        const originalEnv = process.env;
+        let tmpDir;
+        let consoleErrorSpy;
+        let stderrWriteSpy;
+        let stdoutSpy;
+        beforeEach(() => {
+            process.env = { ...originalEnv, OPENAI_API_KEY: 'test' };
+            tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'coverage-test-'));
+            consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+            stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+            stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            resetLoadEnvironmentFileMock();
+            mockedCollectClarifications.mockReset();
+            mockedCollectClarifications.mockResolvedValue([]);
+            mockedGenerateDebateReport.mockReset();
+            mockedGenerateDebateReport.mockImplementation(jest.requireActual('dialectic-core').generateDebateReport);
         });
-        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'));
+        afterEach(() => {
+            try {
+                fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+            process.env = originalEnv;
+            consoleErrorSpy.mockRestore();
+            stderrWriteSpy.mockRestore();
+            stdoutSpy.mockRestore();
+            mockedCollectClarifications.mockReset();
+            mockedCollectClarifications.mockResolvedValue([]);
+            mockedGenerateDebateReport.mockReset();
+            mockedGenerateDebateReport.mockImplementation(jest.requireActual('dialectic-core').generateDebateReport);
+            if (dialectic_core_1.StateManager.prototype.getDebate && typeof dialectic_core_1.StateManager.prototype.getDebate.mockRestore === 'function') {
+                dialectic_core_1.StateManager.prototype.getDebate.mockRestore();
+            }
+        });
+        describe('rethrowIfErrorCode edge cases', () => {
+            it('should handle readAndValidateFileContent error with EXIT_INVALID_ARGS code', async () => {
+                const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+                fs_1.default.writeFileSync(problemFile, 'Some content');
+                const errorWithCode = Object.assign(new Error('Invalid file'), { code: dialectic_core_1.EXIT_INVALID_ARGS });
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRejectedValueOnce(errorWithCode);
+                await expect((0, index_1.runCli)(['debate', '--problemDescription', problemFile]))
+                    .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRestore();
+            });
+            it('should handle validateContextDirectory error with EXIT_INVALID_ARGS code', async () => {
+                const contextFile = path_1.default.join(tmpDir, 'context.txt');
+                fs_1.default.writeFileSync(contextFile, 'Some context');
+                await expect((0, index_1.runCli)(['debate', 'Design a system', '--context', contextFile]))
+                    .rejects.toMatchObject({
+                    code: dialectic_core_1.EXIT_INVALID_ARGS,
+                    message: expect.stringContaining('Context path is not a directory')
+                });
+            });
+        });
+        describe('createAgentLogger branches', () => {
+            it('should log when onlyVerbose is false', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should log when onlyVerbose is true and verbose is true', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should not log when onlyVerbose is true and verbose is false', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                const calls = stderrWriteSpy.mock.calls.map(args => String(args[0]));
+                const stderr = calls.join('');
+                expect(stderr).not.toContain('Running debate (verbose)');
+                stderrWriteSpy.mockRestore();
+            });
+            it('should log when onlyVerbose is undefined', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('createOrchestratorHooks verbose branch', () => {
+            it('should log summarization details when verbose is true', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    summarization: {
+                        enabled: true,
+                        threshold: 100,
+                        maxLength: 500,
+                        method: 'length-based',
+                    },
+                });
+                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', '2']);
+                const stderr = capturedStderr.join('');
+                expect(stderr.length).toBeGreaterThan(0);
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('resolveJudgeSystemPromptWithDefault branches', () => {
+            it('should use configDir when provided', async () => {
+                const promptFile = path_1.default.join(tmpDir, 'judge-prompt.txt');
+                fs_1.default.writeFileSync(promptFile, 'Custom judge prompt');
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    debate: createTestDebateConfig(),
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: 'judge-prompt.txt',
+                    },
+                };
+                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 undefined', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('resolveJudgeSummaryPromptWithDefault branches', () => {
+            it('should use configDir when provided', async () => {
+                const summaryPromptFile = path_1.default.join(tmpDir, 'judge-summary-prompt.txt');
+                fs_1.default.writeFileSync(summaryPromptFile, 'Custom judge summary prompt');
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    debate: createTestDebateConfig(),
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        summaryPromptPath: 'judge-summary-prompt.txt',
+                    },
+                };
+                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 undefined', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('createJudgeWithPromptResolution branches', () => {
+            it('should include absPath in metadata when prompt file is used', async () => {
+                const promptFile = path_1.default.join(tmpDir, 'judge-prompt.txt');
+                fs_1.default.writeFileSync(promptFile, 'Custom judge prompt');
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    debate: createTestDebateConfig(),
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: promptFile,
+                        summaryPromptPath: promptFile,
+                    },
+                };
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const outputFile = path_1.default.join(tmpDir, 'result.json');
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--output', outputFile, '--rounds', '1']);
+                if (fs_1.default.existsSync(outputFile)) {
+                    const debateState = JSON.parse(fs_1.default.readFileSync(outputFile, 'utf-8'));
+                    expect(debateState).toBeDefined();
+                }
+            });
+            it('should use built-in prompts when prompt paths are not provided', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    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();
+            });
+        });
+        describe('createAgentWithPromptResolution branches', () => {
+            it('should handle agents with tools', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [
+                        createTestAgentConfig({
+                            tools: [
+                                {
+                                    name: 'test_tool',
+                                    description: 'A test tool',
+                                    parameters: {
+                                        type: 'object',
+                                        properties: {
+                                            param: { type: 'string', description: 'A parameter' }
+                                        },
+                                        required: ['param']
+                                    }
+                                }
+                            ]
+                        })
+                    ],
+                    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(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Tools available'));
+            });
+            it('should handle agents without tools', 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(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('no tools'));
+            });
+            it('should handle clarification prompt path', async () => {
+                const clarificationPromptFile = path_1.default.join(tmpDir, 'clarification-prompt.txt');
+                fs_1.default.writeFileSync(clarificationPromptFile, 'Custom clarification prompt');
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [
+                        createTestAgentConfig({
+                            clarificationPromptPath: clarificationPromptFile
+                        })
+                    ],
+                    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();
+            });
+        });
+        describe('buildAgents with tracing context', () => {
+            it('should wrap agents with tracing when tracing context is 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();
+            });
+        });
+        describe('validateExactlyOneProblemSource branches', () => {
+            it('should error 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');
+                await expect((0, index_1.runCli)(['debate', 'Problem from string', '--problemDescription', problemFile]))
+                    .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+                expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('provide exactly one of'));
+            });
+            it('should error when neither problem string nor --problemDescription are provided', async () => {
+                await expect((0, index_1.runCli)(['debate']))
+                    .rejects.toHaveProperty('code', dialectic_core_1.EXIT_INVALID_ARGS);
+                expect(stderrWriteSpy).toHaveBeenCalledWith(expect.stringContaining('problem is required'));
+            });
+        });
+        describe('outputRoundSummary branches', () => {
+            it('should output summaries when round has summaries', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    summarization: {
+                        enabled: true,
+                        threshold: 100,
+                        maxLength: 500,
+                        method: 'length-based',
+                    },
+                });
+                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', '2']);
+                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();
+            });
+        });
+        describe('outputResults branches', () => {
+            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, '--rounds', '1']);
+                expect(fs_1.default.existsSync(outputFile)).toBe(true);
+                const content = JSON.parse(fs_1.default.readFileSync(outputFile, 'utf-8'));
+                expect(content).toHaveProperty('id');
+            });
+            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, '--rounds', '1']);
+                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', '--rounds', '1']);
+                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('generateReport error handling', () => {
+            let originalGetDebate;
+            beforeEach(() => {
+                originalGetDebate = dialectic_core_1.StateManager.prototype.getDebate;
+            });
+            afterEach(() => {
+                dialectic_core_1.StateManager.prototype.getDebate = originalGetDebate;
+            });
+            it('should handle debate state not found error', async () => {
+                const reportPath = path_1.default.join(tmpDir, 'report.md');
+                await (0, index_1.runCli)(['debate', 'Design a system', '--report', reportPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle report generation failure 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']);
+                expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to generate report'));
+                mockedGenerateDebateReport.mockImplementation(jest.requireActual('dialectic-core').generateDebateReport);
+            });
+        });
+        describe('extractProblemFileName and extractContextFileName', () => {
+            it('should extract problem file name when provided', async () => {
+                const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+                fs_1.default.writeFileSync(problemFile, 'Problem content');
+                await (0, index_1.runCli)(['debate', '--problemDescription', problemFile, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should return undefined when problem file name is not provided', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should extract context directory name when provided', async () => {
+                const contextDir = path_1.default.join(tmpDir, 'context');
+                fs_1.default.mkdirSync(contextDir, { recursive: true });
+                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', '--context', contextDir, '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should return undefined when context file name is not provided', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('initializeTracingContext branches', () => {
+            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();
+            });
+            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 contextDir = path_1.default.join(tmpDir, 'context');
+                fs_1.default.mkdirSync(contextDir, { recursive: true });
+                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', contextDir, '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should not include contextFileName 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 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();
+            });
+            it('should not include judgeConfig in metadata when judge does not exist', async () => {
+                process.env.LANGFUSE_SECRET_KEY = 'test-secret-key';
+                process.env.LANGFUSE_PUBLIC_KEY = 'test-public-key';
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    debate: createTestDebateConfig(),
+                };
+                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('outputVerboseDebateInfo branches', () => {
+            it('should return early 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)');
+                stderrWriteSpy.mockRestore();
+            });
+            it('should output verbose info when 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();
+            });
+        });
+        describe('flushTracingContext error handling', () => {
+            it('should handle flush errors gracefully', 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));
+                const actualCreateTracingContext = jest.requireActual('dialectic-core').createTracingContext;
+                dialecticCore.createTracingContext.mockImplementation((...args) => {
+                    const context = actualCreateTracingContext(...args);
+                    if (context) {
+                        context.langfuse.flushAsync = jest.fn().mockRejectedValue(new Error('Flush failed'));
+                    }
+                    return context;
+                });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(dialecticCore.logWarning).toHaveBeenCalledWith(expect.stringContaining('Failed to flush Langfuse trace'));
+                expect(stdoutSpy).toHaveBeenCalled();
+                dialecticCore.createTracingContext.mockReset();
+                dialecticCore.createTracingContext.mockImplementation(jest.requireActual('dialectic-core').createTracingContext);
+            });
+        });
+        describe('generateReportIfRequested', () => {
+            it('should return early when report is not requested', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('getSystemSummaryConfig branches', () => {
+            it('should use default summarization config when not provided', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    debate: {
+                        rounds: 3,
+                        terminationCondition: { type: 'fixed' },
+                        synthesisMethod: 'judge',
+                        includeFullHistory: true,
+                        timeoutPerRound: 300000,
+                    },
+                    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 provided summarization config when available', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    summarization: {
+                        enabled: false,
+                        threshold: 3000,
+                        maxLength: 1500,
+                        method: 'length-based',
+                    },
+                });
+                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('isClarificationRequested branches', () => {
+            it('should return true when options.clarify is true', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockReadlineWithAnswers([]);
+                mockedCollectClarifications.mockResolvedValueOnce([]);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--clarify', '--rounds', '1']);
+                expect(mockedCollectClarifications).toHaveBeenCalled();
+            });
+            it('should return true when sysConfig.debate.interactiveClarifications is true', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    interactiveClarifications: true,
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockReadlineWithAnswers([]);
+                mockedCollectClarifications.mockResolvedValueOnce([]);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should return false when neither option is set', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('collectFinalClarifications', () => {
+            it('should return undefined when clarification is not requested', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should use custom maxPerAgent when provided (classic orchestrator path)', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'classic',
+                    clarificationsMaxPerAgent: 3,
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockReadlineWithAnswers([]);
+                mockedCollectClarifications.mockResolvedValueOnce([]);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--clarify', '--rounds', '1']);
+                expect(mockedCollectClarifications).toHaveBeenCalledWith(expect.any(String), expect.any(Array), 3, expect.any(Function));
+            });
+            it('should use default maxPerAgent when not provided', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockReadlineWithAnswers([]);
+                mockedCollectClarifications.mockResolvedValueOnce([]);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--clarify', '--rounds', '1']);
+                expect(mockedCollectClarifications).toHaveBeenCalledWith(expect.any(String), expect.any(Array), 5, expect.any(Function));
+            });
+        });
+        function mockReadlineWithAnswers(answers) {
+            const readlineModule = require('readline');
+            if (readlineModule.__setMockAnswers) {
+                readlineModule.__setMockAnswers(answers);
+            }
+            else {
+                mockAnswers = [...answers];
+                currentIndex = 0;
+            }
+        }
+        describe('rethrowIfErrorCode edge cases', () => {
+            it('should not rethrow when error code does not match expected code', async () => {
+                const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+                fs_1.default.writeFileSync(problemFile, 'Some content');
+                const errorWithCode = Object.assign(new Error('Read error'), { code: dialectic_core_1.EXIT_GENERAL_ERROR });
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRejectedValueOnce(errorWithCode);
+                await expect((0, index_1.runCli)(['debate', '--problemDescription', problemFile]))
+                    .rejects.toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRestore();
+            });
+            it('should handle error without code property', async () => {
+                const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+                fs_1.default.writeFileSync(problemFile, 'Some content');
+                const errorWithoutCode = new Error('Read error');
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRejectedValueOnce(errorWithoutCode);
+                await expect((0, index_1.runCli)(['debate', '--problemDescription', problemFile]))
+                    .rejects.toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRestore();
+            });
+            it('should handle non-object error', 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('String error');
+                await expect((0, index_1.runCli)(['debate', '--problemDescription', problemFile]))
+                    .rejects.toHaveProperty('code', dialectic_core_1.EXIT_GENERAL_ERROR);
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRestore();
+            });
+        });
+        describe('collectAndAnswerClarifications empty groups', () => {
+            it('should skip empty clarification groups', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockedCollectClarifications.mockResolvedValueOnce([
+                    { agentName: 'Test Agent', agentId: 'test-agent', role: 'architect', items: [] },
+                    { agentName: 'Test Agent 2', agentId: 'test-agent-2', role: 'performance', items: [] },
+                ]);
+                mockReadlineWithAnswers([]);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--clarify', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('promptUserForAnswers already answered questions', () => {
+            it('should handle state machine orchestrator with clarifications', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'state-machine',
+                    interactiveClarifications: true,
+                });
+                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('outputResults branches', () => {
+            it('should write JSON output when output path ends with .json', async () => {
+                const outputPath = path_1.default.join(tmpDir, 'output.json');
+                await (0, index_1.runCli)(['debate', 'Design a system', '--output', outputPath, '--rounds', '1']);
+                expect(fs_1.default.existsSync(outputPath)).toBe(true);
+                const content = fs_1.default.readFileSync(outputPath, 'utf-8');
+                const parsed = JSON.parse(content);
+                expect(parsed).toHaveProperty('id');
+            });
+            it('should write text output when output path does not end with .json', async () => {
+                const outputPath = path_1.default.join(tmpDir, 'output.txt');
+                await (0, index_1.runCli)(['debate', 'Design a system', '--output', outputPath, '--rounds', '1']);
+                expect(fs_1.default.existsSync(outputPath)).toBe(true);
+                const content = fs_1.default.readFileSync(outputPath, 'utf-8');
+                expect(content).toContain('Solution text');
+            });
+            it('should not output verbose summary when output path is provided', async () => {
+                const outputPath = path_1.default.join(tmpDir, 'output.txt');
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--output', outputPath, '--verbose', '--rounds', '1']);
+                const calls = stderrWriteSpy.mock.calls.map(args => String(args[0]));
+                const stderrContent = calls.join('');
+                expect(stderrContent).not.toContain('Summary (verbose)');
+                stderrWriteSpy.mockRestore();
+            });
+            it('should output verbose summary to stderr when no output path and verbose is true', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('generateReport error handling', () => {
+            it('should handle missing debate state gracefully', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const reportPath = path_1.default.join(tmpDir, 'report.md');
+                const getDebateSpy = jest.spyOn(dialectic_core_1.StateManager.prototype, 'getDebate').mockResolvedValueOnce(null);
+                const warnUserSpy = jest.spyOn(indexModule, 'warnUser').mockImplementation(() => { });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--report', reportPath, '--rounds', '1']);
+                expect(warnUserSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to generate report'));
+                getDebateSpy.mockRestore();
+                warnUserSpy.mockRestore();
+            });
+            it('should handle report generation errors gracefully', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const reportPath = path_1.default.join(tmpDir, 'report.md');
+                mockedGenerateDebateReport.mockImplementationOnce(() => {
+                    throw new Error('Report generation failed');
+                });
+                const warnUserSpy = jest.spyOn(indexModule, 'warnUser').mockImplementation(() => { });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--report', reportPath, '--rounds', '1']);
+                expect(warnUserSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to generate report'));
+                expect(stdoutSpy).toHaveBeenCalled();
+                warnUserSpy.mockRestore();
+            });
+        });
+        describe('outputVerboseDebateInfo prompt sources', () => {
+            it('should display file-based prompt sources when prompts come from files', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const agentPromptFile = path_1.default.join(promptDir, 'agent-prompt.txt');
+                const judgePromptFile = path_1.default.join(promptDir, 'judge-prompt.txt');
+                fs_1.default.writeFileSync(agentPromptFile, 'Agent system prompt from file');
+                fs_1.default.writeFileSync(judgePromptFile, 'Judge system prompt from file');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            systemPromptPath: agentPromptFile,
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: judgePromptFile,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                const calls = stderrWriteSpy.mock.calls.map(args => String(args[0]));
+                const stderrContent = calls.join('');
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                expect(stderrContent.length).toBeGreaterThan(0);
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('readAndValidateFileContent error handling', () => {
+            it('should handle general read errors (non-EXIT_INVALID_ARGS)', async () => {
+                const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+                fs_1.default.writeFileSync(problemFile, 'Some content');
+                const generalError = new Error('Permission denied');
+                jest.spyOn(fs_1.default.promises, 'readFile').mockRejectedValueOnce(generalError);
+                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();
+            });
+        });
+        describe('runDebateWithClarifications state machine edge cases', () => {
+            it('should handle state machine orchestrator suspend/resume flow', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'state-machine',
+                    interactiveClarifications: true,
+                });
+                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 call promptUserForAnswers and resume twice when orchestrator suspends twice', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'state-machine',
+                    interactiveClarifications: true,
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const coreModule = require('dialectic-core');
+                const { EXECUTION_STATUS, SUSPEND_REASON } = coreModule;
+                const questions1 = [
+                    { agentId: 'a1', agentName: 'A', role: 'architect', items: [{ id: 'q1', question: 'Q1?', answer: '' }] },
+                ];
+                const questions2 = [
+                    { agentId: 'a1', agentName: 'A', role: 'architect', items: [{ id: 'q1', question: 'Q1?', answer: '' }, { id: 'q2', question: 'Q2?', answer: '' }] },
+                ];
+                const completedResult = {
+                    debateId: 'debate-1',
+                    solution: { description: 'S', tradeoffs: [], recommendations: [], confidence: 90, synthesizedBy: 'judge' },
+                    rounds: [],
+                    metadata: { totalRounds: 0, durationMs: 100 },
+                };
+                const resumeMock = jest
+                    .fn()
+                    .mockResolvedValueOnce({
+                    status: EXECUTION_STATUS.SUSPENDED,
+                    suspendReason: SUSPEND_REASON.WAITING_FOR_INPUT,
+                    suspendPayload: { debateId: 'debate-1', questions: questions2, iteration: 2 },
+                })
+                    .mockResolvedValueOnce({
+                    status: EXECUTION_STATUS.COMPLETED,
+                    result: completedResult,
+                });
+                const fakeOrchestrator = {
+                    runDebate: jest.fn().mockResolvedValue({
+                        status: EXECUTION_STATUS.SUSPENDED,
+                        suspendReason: SUSPEND_REASON.WAITING_FOR_INPUT,
+                        suspendPayload: { debateId: 'debate-1', questions: questions1, iteration: 1 },
+                    }),
+                    resume: resumeMock,
+                };
+                const createOrchestratorSpy = jest
+                    .spyOn(require('dialectic-core'), 'createOrchestrator')
+                    .mockReturnValue(fakeOrchestrator);
+                const isStateMachineSpy = jest
+                    .spyOn(require('dialectic-core'), 'isStateMachineOrchestrator')
+                    .mockReturnValue(true);
+                const readlineModule = require('readline');
+                if (readlineModule.__setMockAnswers) {
+                    readlineModule.__setMockAnswers(['ans1', 'ans2', 'ans3']);
+                }
+                const mockDebateState = {
+                    id: 'debate-1',
+                    problem: 'Design a system',
+                    status: 'completed',
+                    rounds: [],
+                    finalSolution: { description: 'S', tradeoffs: [], recommendations: [], confidence: 90, synthesizedBy: 'judge' },
+                };
+                const getDebateSpy = jest
+                    .spyOn(dialectic_core_1.StateManager.prototype, 'getDebate')
+                    .mockImplementation(() => Promise.resolve(mockDebateState));
+                const setPromptSourcesSpy = jest
+                    .spyOn(dialectic_core_1.StateManager.prototype, 'setPromptSources')
+                    .mockResolvedValue(undefined);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                getDebateSpy.mockRestore();
+                setPromptSourcesSpy.mockRestore();
+                expect(resumeMock).toHaveBeenCalledTimes(2);
+                expect(resumeMock).toHaveBeenNthCalledWith(1, 'debate-1', expect.any(Array));
+                expect(resumeMock).toHaveBeenNthCalledWith(2, 'debate-1', expect.any(Array));
+                expect(stdoutSpy).toHaveBeenCalled();
+                createOrchestratorSpy.mockRestore();
+                isStateMachineSpy.mockRestore();
+            });
+        });
+        describe('extractProblemFileName and extractContextDirectoryName', () => {
+            it('should extract problem file name from options', async () => {
+                const problemFile = path_1.default.join(tmpDir, 'problem.txt');
+                fs_1.default.writeFileSync(problemFile, 'Problem description');
+                await (0, index_1.runCli)(['debate', '--problemDescription', problemFile, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should extract context directory name from options', async () => {
+                const contextDir = path_1.default.join(tmpDir, 'context');
+                fs_1.default.mkdirSync(contextDir, { recursive: true });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--context', contextDir, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('outputRoundSummary branches', () => {
+            it('should output verbose summary with rounds containing summaries and contributions', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('outputResults debate null branch', () => {
+            it('should handle null debate state gracefully in verbose mode', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const getDebateSpy = jest.spyOn(dialectic_core_1.StateManager.prototype, 'getDebate')
+                    .mockResolvedValueOnce(null)
+                    .mockResolvedValueOnce(null);
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+                getDebateSpy.mockRestore();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('generateReport .md extension branch', () => {
+            it('should not append .md when report path already ends with .md', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const reportPath = path_1.default.join(tmpDir, 'report.md');
+                const warnUserSpy = jest.spyOn(indexModule, 'warnUser').mockImplementation(() => { });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--report', reportPath, '--rounds', '1']);
+                expect(warnUserSpy).not.toHaveBeenCalledWith(expect.stringContaining('appending .md extension'));
+                expect(fs_1.default.existsSync(reportPath)).toBe(true);
+                warnUserSpy.mockRestore();
+            });
+        });
+        describe('resolveJudgeSystemPromptWithDefault and resolveJudgeSummaryPromptWithDefault', () => {
+            it('should resolve judge prompts from files when provided', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const judgePromptFile = path_1.default.join(promptDir, 'judge-prompt.txt');
+                const judgeSummaryPromptFile = path_1.default.join(promptDir, 'judge-summary-prompt.txt');
+                fs_1.default.writeFileSync(judgePromptFile, 'Judge system prompt from file');
+                fs_1.default.writeFileSync(judgeSummaryPromptFile, 'Judge summary prompt from file');
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: judgePromptFile,
+                        summaryPromptPath: judgeSummaryPromptFile,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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('createAgentWithPromptResolution prompt path branches', () => {
+            it('should handle agent with systemPromptPath', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const agentPromptFile = path_1.default.join(promptDir, 'agent-prompt.txt');
+                fs_1.default.writeFileSync(agentPromptFile, 'Agent system prompt from file');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            systemPromptPath: agentPromptFile,
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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 handle agent with summaryPromptPath', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const summaryPromptFile = path_1.default.join(promptDir, 'summary-prompt.txt');
+                fs_1.default.writeFileSync(summaryPromptFile, 'Summary prompt from file');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            summaryPromptPath: summaryPromptFile,
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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 handle agent with clarificationPromptPath', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const clarificationPromptFile = path_1.default.join(promptDir, 'clarification-prompt.txt');
+                fs_1.default.writeFileSync(clarificationPromptFile, 'Clarification prompt from file');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            clarificationPromptPath: clarificationPromptFile,
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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('createJudgeWithPromptResolution absPath branches', () => {
+            it('should handle judge prompt resolution with absPath', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const judgePromptFile = path_1.default.join(promptDir, 'judge-prompt.txt');
+                fs_1.default.writeFileSync(judgePromptFile, 'Judge prompt');
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: judgePromptFile,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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('outputVerboseDebateInfo file source branches', () => {
+            it('should display file path when prompt source is file', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const agentPromptFile = path_1.default.join(promptDir, 'agent-prompt.txt');
+                const judgePromptFile = path_1.default.join(promptDir, 'judge-prompt.txt');
+                fs_1.default.writeFileSync(agentPromptFile, 'Agent prompt');
+                fs_1.default.writeFileSync(judgePromptFile, 'Judge prompt');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            systemPromptPath: agentPromptFile,
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: judgePromptFile,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                const calls = stderrWriteSpy.mock.calls.map(args => String(args[0]));
+                const stderrContent = calls.join('');
+                expect(stderrContent.length).toBeGreaterThan(0);
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('initializeTracingContext trace option branches', () => {
+            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();
+            });
+            it('should handle tracing context creation failure gracefully', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    trace: 'langfuse',
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                dialecticCore.validateLangfuseConfig.mockImplementationOnce(() => {
+                    throw new Error('Langfuse config invalid');
+                });
+                const warnUserSpy = jest.spyOn(indexModule, 'warnUser').mockImplementation(() => { });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(warnUserSpy).toHaveBeenCalledWith(expect.stringContaining('Langfuse tracing initialization failed'));
+                expect(stdoutSpy).toHaveBeenCalled();
+                dialecticCore.validateLangfuseConfig.mockReset();
+                dialecticCore.validateLangfuseConfig.mockImplementation(jest.requireActual('dialectic-core').validateLangfuseConfig);
+                warnUserSpy.mockRestore();
+            });
+        });
+        describe('debateConfigFromSysConfig rounds branches', () => {
+            it('should use sysConfig.debate.rounds when options.rounds is not provided', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    rounds: 5,
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath]);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+        });
+        describe('agentConfigsFromSysConfig filtering branches', () => {
+            it('should filter agents by role when --agents option is provided', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [
+                        createTestAgentConfig({ id: 'agent1', role: 'architect' }),
+                        createTestAgentConfig({ id: 'agent2', role: 'performance' }),
+                        createTestAgentConfig({ id: 'agent3', role: 'security' }),
+                    ],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--agents', 'architect,performance', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should filter out disabled agents', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [
+                        createTestAgentConfig({ id: 'agent1', enabled: true }),
+                        createTestAgentConfig({ id: 'agent2', enabled: false }),
+                        createTestAgentConfig({ id: 'agent3', enabled: true }),
+                    ],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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('outputVerboseDebateInfo path branches', () => {
+            it('should handle undefined path when source is file', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const agentPromptFile = path_1.default.join(promptDir, 'agent-prompt.txt');
+                fs_1.default.writeFileSync(agentPromptFile, 'Agent prompt');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            systemPromptPath: agentPromptFile,
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle agent not found in promptSources', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('outputRoundSummary metadata branches', () => {
+            it('should handle contributions without metadata', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle summaries with null tokensUsed and latencyMs', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('prompt resolution absPath branches', () => {
+            it('should handle prompt resolution when absPath might be undefined', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const promptDir = path_1.default.join(tmpDir, 'prompts');
+                fs_1.default.mkdirSync(promptDir, { recursive: true });
+                const agentPromptFile = path_1.default.join(promptDir, 'agent.txt');
+                const judgePromptFile = path_1.default.join(promptDir, 'judge.txt');
+                fs_1.default.writeFileSync(agentPromptFile, 'Agent prompt');
+                fs_1.default.writeFileSync(judgePromptFile, 'Judge prompt');
+                const configContent = {
+                    agents: [{
+                            ...createTestAgentConfig(),
+                            systemPromptPath: 'prompts/agent.txt',
+                        }],
+                    judge: {
+                        id: 'test-judge',
+                        name: 'Test Judge',
+                        role: 'generalist',
+                        model: 'gpt-4',
+                        provider: 'openai',
+                        temperature: 0.3,
+                        systemPromptPath: 'prompts/judge.txt',
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                const configParentDir = path_1.default.dirname(configPath);
+                const promptsDir = path_1.default.join(configParentDir, 'prompts');
+                fs_1.default.mkdirSync(promptsDir, { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(promptsDir, 'agent.txt'), 'Agent prompt');
+                fs_1.default.writeFileSync(path_1.default.join(promptsDir, 'judge.txt'), 'Judge prompt');
+                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('createAgentLogger onlyVerbose undefined branch', () => {
+            it('should handle onlyVerbose being undefined', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('onSummarizationComplete verbose branch', () => {
+            it('should log summarization details when verbose is true', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    summarization: {
+                        enabled: true,
+                        threshold: 100,
+                        maxLength: 500,
+                        method: 'length-based',
+                    },
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+        });
+        describe('initializeTracingContext optional metadata branches', () => {
+            it('should handle undefined problemFileName and contextDirectoryName', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    trace: 'langfuse',
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                process.env.LANGFUSE_PUBLIC_KEY = 'test-key';
+                process.env.LANGFUSE_SECRET_KEY = 'test-secret';
+                process.env.LANGFUSE_HOST = 'https://cloud.langfuse.com';
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+                delete process.env.LANGFUSE_PUBLIC_KEY;
+                delete process.env.LANGFUSE_SECRET_KEY;
+                delete process.env.LANGFUSE_HOST;
+            });
+            it('should handle undefined judgeConfig in trace metadata', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = {
+                    agents: [createTestAgentConfig()],
+                    debate: createTestDebateConfig({ trace: 'langfuse' }),
+                };
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                process.env.LANGFUSE_PUBLIC_KEY = 'test-key';
+                process.env.LANGFUSE_SECRET_KEY = 'test-secret';
+                process.env.LANGFUSE_HOST = 'https://cloud.langfuse.com';
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+                delete process.env.LANGFUSE_PUBLIC_KEY;
+                delete process.env.LANGFUSE_SECRET_KEY;
+                delete process.env.LANGFUSE_HOST;
+            });
+        });
+        describe('createTracingContext falsy return branch', () => {
+            it('should handle when createTracingContext returns undefined', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    trace: 'langfuse',
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                dialecticCore.createTracingContext.mockReturnValueOnce(undefined);
+                process.env.LANGFUSE_PUBLIC_KEY = 'test-key';
+                process.env.LANGFUSE_SECRET_KEY = 'test-secret';
+                process.env.LANGFUSE_HOST = 'https://cloud.langfuse.com';
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+                dialecticCore.createTracingContext.mockReset();
+                dialecticCore.createTracingContext.mockImplementation(jest.requireActual('dialectic-core').createTracingContext);
+                delete process.env.LANGFUSE_PUBLIC_KEY;
+                delete process.env.LANGFUSE_SECRET_KEY;
+                delete process.env.LANGFUSE_HOST;
+            });
+        });
+        describe('runDebateWithClarifications state machine error branch', () => {
+            it('should throw for unknown suspend reason in state machine orchestrator', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'state-machine',
+                    interactiveClarifications: true,
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const coreModule = require('dialectic-core');
+                const { EXECUTION_STATUS } = coreModule;
+                const suspendResultWithUnknownReason = {
+                    status: EXECUTION_STATUS.SUSPENDED,
+                    suspendReason: 'UNKNOWN_REASON',
+                    suspendPayload: {
+                        debateId: 'debate-2',
+                        questions: [],
+                    },
+                };
+                const fakeOrchestrator = {
+                    runDebate: jest.fn().mockResolvedValue(suspendResultWithUnknownReason),
+                    resume: jest.fn(),
+                };
+                const createOrchestratorSpy = jest
+                    .spyOn(require('dialectic-core'), 'createOrchestrator')
+                    .mockReturnValue(fakeOrchestrator);
+                const isStateMachineSpy = jest
+                    .spyOn(require('dialectic-core'), 'isStateMachineOrchestrator')
+                    .mockReturnValue(true);
+                await expect((0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1'])).rejects.toThrow(/Unknown suspend reason/);
+                createOrchestratorSpy.mockRestore();
+                isStateMachineSpy.mockRestore();
+            });
+        });
+        describe('outputRoundSummary summaries formatting branches', () => {
+            it('should format summaries with tokens and latency metadata', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const debateState = {
+                    id: 'debate-3',
+                    rounds: [
+                        {
+                            roundNumber: 1,
+                            summaries: {
+                                architect: {
+                                    agentRole: 'architect',
+                                    metadata: {
+                                        beforeChars: 120,
+                                        afterChars: 60,
+                                        tokensUsed: 42,
+                                        latencyMs: 150,
+                                        method: 'length-based',
+                                    },
+                                },
+                            },
+                            contributions: [],
+                        },
+                    ],
+                };
+                const getDebateSpy = jest
+                    .spyOn(dialectic_core_1.StateManager.prototype, 'getDebate')
+                    .mockResolvedValueOnce(debateState);
+                const stderrChunks = [];
+                const stderrSpy = jest
+                    .spyOn(process.stderr, 'write')
+                    .mockImplementation((chunk) => {
+                    stderrChunks.push(String(chunk));
+                    return true;
+                });
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                const stderrOutput = stderrChunks.join('');
+                expect(stderrOutput).toContain('summaries:');
+                expect(stderrOutput).toContain('[architect]');
+                expect(stderrOutput).toContain('latency=150ms, tokens=42, method=length-based');
+                getDebateSpy.mockRestore();
+                stderrSpy.mockRestore();
+            });
+        });
+        describe('Targeted branch coverage tests', () => {
+            it('should handle empty items in promptUserForAnswers', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'state-machine',
+                    interactiveClarifications: true,
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockedCollectClarifications.mockResolvedValueOnce([
+                    { agentName: 'Test Agent', agentId: 'test-agent', role: 'architect', items: [] },
+                ]);
+                mockReadlineWithAnswers([]);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle empty answer input (NA branch)', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, { orchestratorType: 'classic' });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                mockedCollectClarifications.mockResolvedValueOnce([
+                    {
+                        agentName: 'Test Agent',
+                        agentId: 'test-agent',
+                        role: 'architect',
+                        items: [{ id: 'q1', question: 'Question 1', answer: '' }],
+                    },
+                ]);
+                mockReadlineWithAnswers(['']);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--clarify', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle createAgentLogger with onlyVerbose explicitly false', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle onSummarizationComplete verbose branch', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    summarization: {
+                        enabled: true,
+                        threshold: 100,
+                        maxLength: 500,
+                        method: 'length-based',
+                    },
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle options.rounds branch in debateConfigFromSysConfig', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '2']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle rounds with summaries in outputRoundSummary', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle contributions without metadata in outputRoundSummary', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle classic orchestrator branch in outputVerboseDebateInfo', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent(undefined, {
+                    orchestratorType: 'classic',
+                });
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                const calls = stderrWriteSpy.mock.calls.map(args => String(args[0]));
+                const stderrContent = calls.join('');
+                expect(stderrContent).toContain('classic');
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle clarificationRequested false branch', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle no context directory branch', async () => {
+                await (0, index_1.runCli)(['debate', 'Design a system', '--rounds', '1']);
+                expect(stdoutSpy).toHaveBeenCalled();
+            });
+            it('should handle path undefined in outputVerboseDebateInfo for agents', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle path undefined in outputVerboseDebateInfo for judge', async () => {
+                const configPath = getTestConfigPath(tmpDir);
+                const configContent = createTestConfigContent();
+                fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--config', configPath, '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle totalTokens null branch in outputResults', async () => {
+                const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+                await (0, index_1.runCli)(['debate', 'Design a system', '--verbose', '--rounds', '1']);
+                expect(stderrWriteSpy).toHaveBeenCalled();
+                stderrWriteSpy.mockRestore();
+            });
+            it('should handle undefined configDir in resolveJudgeSystemPromptWithDefault', async () => {
+                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,
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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 handle undefined configDir in resolveJudgeSummaryPromptWithDefault', async () => {
+                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,
+                        summaryPromptPath: 'nonexistent.txt',
+                    },
+                    debate: createTestDebateConfig(),
+                };
+                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();
+            });
         });
     });
 });