opencode-conductor-cdd-plugin 1.0.0-beta.18 → 1.0.0-beta.19

package/dist/utils/documentGeneration.js

@@ -0,0 +1,301 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { validateSelection, parseSelection } from './interactiveMenu.js';
+// Constants
+const MAX_QUESTIONS = 5;
+const MAX_REVISION_ATTEMPTS = 3;
+const STATE_FILE_PATH = 'conductor-cdd/setup_state.json';
+const CHECKPOINT_MAP = {
+    product: '2.1_product_guide',
+    guidelines: '2.2_product_guidelines',
+    'tech-stack': '2.3_tech_stack',
+    styleguides: '2.4_code_styleguides',
+    workflow: '2.5_workflow',
+};
+/**
+ * Present questions sequentially to the user
+ * Stops after maxQuestions or when option E is selected
+ */
+export async function presentQuestionsSequentially(questions, responder, options = {}) {
+    const { maxQuestions = MAX_QUESTIONS, customInputPrompt } = options;
+    const session = {
+        section: questions[0]?.section || 'product',
+        questionsAsked: [],
+        answers: [],
+        autoGenerateRequested: false,
+        startTime: new Date().toISOString(),
+        endTime: '',
+    };
+    for (let i = 0; i < Math.min(questions.length, maxQuestions); i++) {
+        const question = questions[i];
+        session.questionsAsked.push(question);
+        // Get user response
+        let selections;
+        let isValid = false;
+        // Keep asking until valid response
+        while (!isValid) {
+            selections = await responder(question, i + 1);
+            isValid = validateSelection(selections.join(','), question.type);
+        }
+        const parsedSelections = parseSelection(selections.join(','), question.type);
+        // Map selections to actual option text
+        const selectedOptions = parsedSelections.map(letter => {
+            const index = letter.charCodeAt(0) - 'A'.charCodeAt(0);
+            return question.options[index];
+        });
+        const answer = {
+            questionId: question.id,
+            selections: parsedSelections,
+            selectedOptions,
+            timestamp: new Date().toISOString(),
+        };
+        // Handle option D (custom input)
+        if (parsedSelections.includes('D') && customInputPrompt) {
+            answer.customText = await customInputPrompt(question);
+        }
+        session.answers.push(answer);
+        // Handle option E (auto-generate) - stop asking questions
+        if (parsedSelections.includes('E')) {
+            session.autoGenerateRequested = true;
+            session.autoGenerateAtQuestion = i;
+            break;
+        }
+    }
+    session.endTime = new Date().toISOString();
+    return session;
+}
+/**
+ * Draft document content from user's selected answers
+ * CRITICAL: Only use selected options, ignore questions and unselected options
+ */
+export function draftDocumentFromAnswers(session, analysis) {
+    const sections = [];
+    let inferredFromContext = session.autoGenerateRequested;
+    // Build content from selected answers
+    for (const answer of session.answers) {
+        if (answer.customText) {
+            // Option D: Use custom text directly
+            sections.push(answer.customText);
+        }
+        else {
+            // Options A, B, C: Use selected option text
+            for (const option of answer.selectedOptions) {
+                // Skip option D (Custom) and option E (Auto-generate)
+                if (!option.includes('custom') && !option.includes('Auto-generate')) {
+                    sections.push(option);
+                }
+            }
+        }
+    }
+    // If auto-generate was requested, infer additional content from context
+    if (session.autoGenerateRequested) {
+        sections.push(...inferAdditionalContent(session, analysis));
+    }
+    // Generate document structure based on section type
+    const content = formatDocumentContent(session.section, sections, analysis);
+    return {
+        content,
+        inferredFromContext,
+        sectionsIncluded: sections,
+        wordCount: content.split(/\s+/).length,
+    };
+}
+/**
+ * Infer additional content when auto-generate is requested
+ */
+function inferAdditionalContent(session, analysis) {
+    const inferred = [];
+    // Use codebase analysis - check both languages and frameworks
+    const hasCodebaseData = Object.keys(analysis.languages).length > 0 ||
+        analysis.frameworks.frontend.length > 0 ||
+        analysis.frameworks.backend.length > 0;
+    if (hasCodebaseData) {
+        // Infer from detected technologies
+        const languages = Object.keys(analysis.languages);
+        if (languages.length > 0) {
+            inferred.push(`Technologies: ${languages.join(', ')}`);
+        }
+        if (analysis.frameworks.frontend.length > 0) {
+            inferred.push(`Frontend: ${analysis.frameworks.frontend.join(', ')}`);
+        }
+        if (analysis.frameworks.backend.length > 0) {
+            inferred.push(`Backend: ${analysis.frameworks.backend.join(', ')}`);
+        }
+        if (analysis.databases.length > 0) {
+            inferred.push(`Databases: ${analysis.databases.join(', ')}`);
+        }
+        if (analysis.architecture.length > 0 && !analysis.architecture.includes('unknown')) {
+            inferred.push(`Architecture: ${analysis.architecture.join(', ')}`);
+        }
+    }
+    // Infer from previous answers in session
+    for (const answer of session.answers) {
+        for (const option of answer.selectedOptions) {
+            if (!option.includes('Auto-generate') && !option.includes('custom')) {
+                // Use selected options as context for inference
+                inferred.push(option);
+            }
+        }
+    }
+    return inferred;
+}
+/**
+ * Format document content based on section type
+ */
+function formatDocumentContent(section, contentSections, analysis) {
+    const lines = [];
+    // Ensure minimum content for greenfield projects
+    const hasContent = contentSections.length > 0;
+    if (!hasContent) {
+        contentSections.push('To be defined during project setup.');
+    }
+    // Section-specific formatting
+    switch (section) {
+        case 'product':
+            lines.push('# Product Guide', '');
+            lines.push('## Overview', '');
+            lines.push(...contentSections);
+            if (analysis.projectGoal) {
+                lines.push('', `## Project Goal`, '', analysis.projectGoal);
+            }
+            break;
+        case 'guidelines':
+            lines.push('# Product Guidelines', '');
+            lines.push('## Guidelines', '');
+            lines.push(...contentSections);
+            break;
+        case 'tech-stack':
+            lines.push('# Tech Stack', '');
+            lines.push('## Technologies', '');
+            lines.push(...contentSections);
+            break;
+        case 'styleguides':
+            lines.push('# Code Style Guides', '');
+            lines.push('## Style Guidelines', '');
+            lines.push(...contentSections);
+            break;
+        case 'workflow':
+            lines.push('# Workflow', '');
+            lines.push('## Development Workflow', '');
+            lines.push(...contentSections);
+            break;
+        default:
+            lines.push('# Document', '');
+            lines.push(...contentSections);
+    }
+    return lines.join('\n');
+}
+/**
+ * Save document to file and update state
+ */
+export async function saveDocumentState(state) {
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(state.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Save document to file
+        fs.writeFileSync(state.filePath, state.content, 'utf-8');
+        // Compute state file path from outputPath (e.g., /path/to/conductor-cdd/product.md → /path/to/conductor-cdd/setup_state.json)
+        const stateFilePath = path.join(path.dirname(state.filePath), 'setup_state.json');
+        // Update state file
+        let setupState = {};
+        if (fs.existsSync(stateFilePath)) {
+            const existingState = fs.readFileSync(stateFilePath, 'utf-8');
+            setupState = JSON.parse(existingState);
+        }
+        const previousCheckpoints = setupState.last_successful_step
+            ? [setupState.last_successful_step]
+            : [];
+        setupState.last_successful_step = state.checkpoint;
+        setupState[`${state.section}_timestamp`] = state.timestamp || new Date().toISOString();
+        fs.writeFileSync(stateFilePath, JSON.stringify(setupState, null, 2), 'utf-8');
+        return {
+            success: true,
+            stateFile: stateFilePath,
+            checkpoint: state.checkpoint,
+            filePath: state.filePath,
+            previousCheckpoints,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Orchestrate full document generation workflow
+ */
+export async function generateDocument(options) {
+    const { section, questions, analysis, responder, approvalFlow, outputPath, maxRevisions = MAX_REVISION_ATTEMPTS, customInputPrompt } = options;
+    try {
+        // Validate questions array
+        if (!questions || questions.length === 0) {
+            return {
+                success: false,
+                error: `No questions generated for section: ${section}`,
+            };
+        }
+        // Step 1: Present questions sequentially
+        const session = await presentQuestionsSequentially(questions, responder, {
+            customInputPrompt,
+        });
+        // Step 2: Draft document from answers
+        let draft = draftDocumentFromAnswers(session, analysis);
+        let revisionCount = 0;
+        let approved = false;
+        let finalContent = draft.content;
+        // Step 3: Approval/revision loop
+        while (!approved && revisionCount < maxRevisions) {
+            const approvalResult = await approvalFlow(draft);
+            if (approvalResult.approved) {
+                approved = true;
+                finalContent = approvalResult.finalContent || draft.content;
+            }
+            else {
+                // Revise based on guidance
+                revisionCount++;
+                if (revisionCount >= maxRevisions) {
+                    return {
+                        success: false,
+                        error: `Max revision attempts (${maxRevisions}) exceeded`,
+                        revisionCount,
+                    };
+                }
+                // Re-draft with revision guidance
+                // In real implementation, this would incorporate the revision guidance
+                draft = draftDocumentFromAnswers(session, analysis);
+            }
+        }
+        // Step 4: Save document and update state
+        const checkpoint = CHECKPOINT_MAP[section];
+        const saveResult = await saveDocumentState({
+            section,
+            checkpoint,
+            content: finalContent,
+            filePath: outputPath,
+            timestamp: new Date().toISOString(),
+        });
+        if (!saveResult.success) {
+            return {
+                success: false,
+                error: `Failed to save document: ${saveResult.error}`,
+            };
+        }
+        return {
+            success: true,
+            checkpoint,
+            autoGenerated: session.autoGenerateRequested,
+            revisionCount,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}

package/dist/utils/documentGeneration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/documentGeneration.test.js

@@ -0,0 +1,380 @@
+import { describe, it, expect, vi } from 'vitest';
+import { generateDocument, presentQuestionsSequentially, draftDocumentFromAnswers, saveDocumentState, } from './documentGeneration.js';
+describe('documentGeneration', () => {
+    const mockAnalysis = {
+        languages: {
+            'TypeScript': 60,
+            'JavaScript': 40,
+        },
+        frameworks: {
+            frontend: ['React', 'Next.js'],
+            backend: ['Express'],
+        },
+        databases: ['PostgreSQL'],
+        manifests: [{
+                type: 'package.json',
+                path: '/package.json',
+                metadata: { name: 'test-project', version: '1.0.0' },
+                dependencies: { 'react': '^18.0.0' },
+            }],
+        architecture: ['MVC'],
+        projectGoal: 'E-commerce platform',
+    };
+    const mockQuestions = [
+        {
+            id: 'product-1',
+            text: 'What is the primary purpose?',
+            type: 'exclusive',
+            section: 'product',
+            options: ['E-commerce', 'Social media', 'Dashboard', 'Custom', 'Auto-generate'],
+        },
+        {
+            id: 'product-2',
+            text: 'Who are the target users?',
+            type: 'exclusive',
+            section: 'product',
+            options: ['Developers', 'End users', 'Businesses', 'Custom', 'Auto-generate'],
+        },
+    ];
+    describe('presentQuestionsSequentially', () => {
+        it('should present questions one at a time up to max 5', async () => {
+            const questions = Array.from({ length: 7 }, (_, i) => ({
+                id: `q-${i}`,
+                text: `Question ${i}`,
+                type: 'exclusive',
+                section: 'product',
+                options: ['A', 'B', 'C', 'D', 'E'],
+            }));
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B'])
+                .mockResolvedValueOnce(['C'])
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B']);
+            const session = await presentQuestionsSequentially(questions, mockResponder, { maxQuestions: 5 });
+            expect(session.questionsAsked).toHaveLength(5);
+            expect(session.answers).toHaveLength(5);
+            expect(mockResponder).toHaveBeenCalledTimes(5);
+        });
+        it('should stop early if user selects option E (auto-generate)', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['E']); // Option E selected
+            const session = await presentQuestionsSequentially(mockQuestions, mockResponder);
+            expect(session.questionsAsked).toHaveLength(2);
+            expect(session.answers).toHaveLength(2);
+            expect(session.autoGenerateRequested).toBe(true);
+            expect(session.autoGenerateAtQuestion).toBe(1); // 0-based index
+        });
+        it('should handle option D (custom input) by prompting for text', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['D']); // Option D selected
+            const mockCustomInputPrompt = vi.fn()
+                .mockResolvedValueOnce('Custom purpose text');
+            const session = await presentQuestionsSequentially(mockQuestions.slice(0, 1), mockResponder, { customInputPrompt: mockCustomInputPrompt });
+            expect(session.answers[0].selections).toEqual(['D']);
+            expect(session.answers[0].customText).toBe('Custom purpose text');
+            expect(mockCustomInputPrompt).toHaveBeenCalledTimes(1);
+        });
+        it('should handle additive questions with multiple selections', async () => {
+            const additiveQuestion = {
+                id: 'features-1',
+                text: 'What features are needed?',
+                type: 'additive',
+                section: 'product',
+                options: ['Auth', 'Dashboard', 'API', 'Custom', 'Auto-generate'],
+            };
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A', 'B', 'C']); // Multiple selections
+            const session = await presentQuestionsSequentially([additiveQuestion], mockResponder);
+            expect(session.answers[0].selections).toEqual(['A', 'B', 'C']);
+            expect(session.answers[0].selectedOptions).toEqual(['Auth', 'Dashboard', 'API']);
+        });
+        it('should reject invalid selections and re-prompt', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['F']) // Invalid
+                .mockResolvedValueOnce(['A']); // Valid
+            const session = await presentQuestionsSequentially(mockQuestions.slice(0, 1), mockResponder);
+            expect(mockResponder).toHaveBeenCalledTimes(2);
+            expect(session.answers[0].selections).toEqual(['A']);
+        });
+        it('should track question history and timestamps', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B']);
+            const session = await presentQuestionsSequentially(mockQuestions, mockResponder);
+            expect(session.questionsAsked).toHaveLength(2);
+            expect(session.answers[0].timestamp).toBeDefined();
+            expect(session.answers[1].timestamp).toBeDefined();
+        });
+    });
+    describe('draftDocumentFromAnswers', () => {
+        it('should generate document content from selected answers only', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 2),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                    {
+                        questionId: 'product-2',
+                        selections: ['B'],
+                        selectedOptions: ['End users'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('E-commerce');
+            expect(draft.content).toContain('End users');
+            expect(draft.content).not.toContain('Social media'); // Unselected option
+            expect(draft.content).not.toContain('Developers'); // Unselected option
+        });
+        it('should ignore unselected options from questions', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            // Should NOT contain unselected options B, C
+            expect(draft.content).not.toContain('Social media');
+            expect(draft.content).not.toContain('Dashboard');
+            // Should NOT contain the option letters
+            expect(draft.content).not.toMatch(/\bA\)/);
+            expect(draft.content).not.toMatch(/\bB\)/);
+            expect(draft.content).not.toMatch(/\bC\)/);
+        });
+        it('should incorporate custom text from option D', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['D'],
+                        selectedOptions: ['Custom'],
+                        customText: 'A platform for managing IoT devices',
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('A platform for managing IoT devices');
+        });
+        it('should infer additional content when auto-generate was requested', () => {
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: true,
+                autoGenerateAtQuestion: 0,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('E-commerce');
+            // Should infer additional sections based on context
+            expect(draft.content.length).toBeGreaterThan(100);
+            expect(draft.inferredFromContext).toBe(true);
+        });
+        it('should use codebase analysis to enhance brownfield documents', () => {
+            const session = {
+                section: 'tech-stack',
+                questionsAsked: [],
+                answers: [],
+                autoGenerateRequested: true,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, mockAnalysis);
+            expect(draft.content).toContain('TypeScript');
+            expect(draft.content).toContain('React');
+            expect(draft.content).toContain('Next.js');
+            expect(draft.content).toContain('PostgreSQL');
+        });
+        it('should generate comprehensive content for greenfield projects', () => {
+            const greenfieldAnalysis = {
+                languages: {},
+                frameworks: { frontend: [], backend: [] },
+                databases: [],
+                manifests: [],
+                architecture: [],
+            };
+            const session = {
+                section: 'product',
+                questionsAsked: mockQuestions.slice(0, 1),
+                answers: [
+                    {
+                        questionId: 'product-1',
+                        selections: ['A'],
+                        selectedOptions: ['E-commerce'],
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+                autoGenerateRequested: false,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+            };
+            const draft = draftDocumentFromAnswers(session, greenfieldAnalysis);
+            expect(draft.content).toContain('E-commerce');
+            expect(draft.content.length).toBeGreaterThan(30);
+        });
+    });
+    describe('saveDocumentState', () => {
+        it('should create state file with correct checkpoint structure', async () => {
+            const result = await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: '# Product Guide\n\nContent here',
+                filePath: 'conductor-cdd/product.md',
+            });
+            expect(result.success).toBe(true);
+            expect(result.stateFile).toContain('setup_state.json');
+            expect(result.checkpoint).toBe('2.1_product_guide');
+        });
+        it('should update existing state file without overwriting other checkpoints', async () => {
+            // First save
+            await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: 'Content 1',
+                filePath: 'conductor-cdd/product.md',
+            });
+            // Second save
+            const result = await saveDocumentState({
+                section: 'guidelines',
+                checkpoint: '2.2_product_guidelines',
+                content: 'Content 2',
+                filePath: 'conductor-cdd/guidelines.md',
+            });
+            expect(result.success).toBe(true);
+            expect(result.previousCheckpoints).toContain('2.1_product_guide');
+        });
+        it('should save document to correct file path', async () => {
+            const result = await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: '# Product Guide\n\nTest content',
+                filePath: 'conductor-cdd/product.md',
+            });
+            expect(result.success).toBe(true);
+            expect(result.filePath).toContain('product.md');
+        });
+        it('should handle file system errors gracefully', async () => {
+            const result = await saveDocumentState({
+                section: 'product',
+                checkpoint: '2.1_product_guide',
+                content: 'Content',
+                filePath: '/invalid/path/that/does/not/exist/file.md',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('generateDocument', () => {
+        it('should orchestrate full document generation workflow', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A'])
+                .mockResolvedValueOnce(['B']);
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValueOnce({ approved: true, finalContent: '# Final content' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions,
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.1_product_guide');
+            expect(mockResponder).toHaveBeenCalled();
+            expect(mockApprovalFlow).toHaveBeenCalled();
+        });
+        it('should handle auto-generate early exit', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['E']); // Auto-generate immediately
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValueOnce({ approved: true, finalContent: '# Auto-generated content' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions,
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(true);
+            expect(result.autoGenerated).toBe(true);
+            expect(mockResponder).toHaveBeenCalledTimes(1); // Stopped after E
+        });
+        it('should handle approval rejection and revision loop', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']);
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValueOnce({ approved: false, revisionGuidance: 'Add more details' })
+                .mockResolvedValueOnce({ approved: true, finalContent: '# Revised content' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions.slice(0, 1),
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(true);
+            expect(result.revisionCount).toBe(1);
+            expect(mockApprovalFlow).toHaveBeenCalledTimes(2);
+        });
+        it('should fail after max revision attempts', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']);
+            const mockApprovalFlow = vi.fn()
+                .mockResolvedValue({ approved: false, revisionGuidance: 'Still not good' });
+            const options = {
+                section: 'product',
+                questions: mockQuestions.slice(0, 1),
+                analysis: mockAnalysis,
+                responder: mockResponder,
+                approvalFlow: mockApprovalFlow,
+                outputPath: 'conductor-cdd/product.md',
+                maxRevisions: 3,
+            };
+            const result = await generateDocument(options);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('revision');
+            expect(mockApprovalFlow).toHaveBeenCalledTimes(3);
+        });
+    });
+});