fraim-framework 2.0.56 → 2.0.58

package/dist/tests/test-ai-coach-workflows.js

@@ -1,514 +0,0 @@
-"use strict";
-/**
- * Comprehensive tests for AI Coach and stepwise workflows
- * Tests the complete phase-based workflow system including:
- * - Phase loading and validation
- * - Phase transitions and flow logic
- * - Workflow completion and error handling
- * - File path resolution and content loading
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_test_1 = require("node:test");
-const node_assert_1 = __importDefault(require("node:assert"));
-const ai_manager_js_1 = require("../src/ai-manager/ai-manager.js");
-const phase_flow_js_1 = require("../src/ai-manager/phase-flow.js");
-const fs_1 = require("fs");
-const path_1 = require("path");
-(0, node_test_1.describe)('AI Coach and Stepwise Workflows', () => {
-    let coach;
-    let fileIndex;
-    (0, node_test_1.before)(() => {
-        // Create a comprehensive file index for testing
-        fileIndex = new Map();
-        // Add all phase files to the index
-        const phaseFiles = [
-            // Shared phases
-            'ai-manager-rules/shared-phases/wait-for-pr-review.md',
-            // Implement phases
-            'ai-manager-rules/implement-phases/implement-scoping.md',
-            'ai-manager-rules/implement-phases/implement-repro.md',
-            'ai-manager-rules/implement-phases/implement-spike.md',
-            'ai-manager-rules/implement-phases/implement-code.md',
-            'ai-manager-rules/implement-phases/implement-validate.md',
-            'ai-manager-rules/implement-phases/implement-smoke.md',
-            'ai-manager-rules/implement-phases/implement-regression.md',
-            'ai-manager-rules/implement-phases/implement-completeness-review.md',
-            // Spec phases
-            'ai-manager-rules/spec-phases/spec-spec.md',
-            'ai-manager-rules/spec-phases/spec-completeness-review.md',
-            // Design phases
-            'ai-manager-rules/design-phases/design-design.md',
-            'ai-manager-rules/design-phases/design-completeness-review.md'
-        ];
-        phaseFiles.forEach(path => {
-            const fullPath = (0, path_1.join)(process.cwd(), 'registry', path);
-            if ((0, fs_1.existsSync)(fullPath)) {
-                fileIndex.set(path, { fullPath });
-            }
-        });
-        coach = new ai_manager_js_1.AICoach(fileIndex);
-    });
-    (0, node_test_1.describe)('Phase Flow Logic', () => {
-        (0, node_test_1.it)('should return correct next phase for implement bug workflow', () => {
-            const phases = ['implement-scoping', 'implement-repro', 'implement-code', 'implement-validate', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            for (let i = 0; i < phases.length - 1; i++) {
-                const nextPhase = (0, phase_flow_js_1.getNextPhase)(phases[i], 'implement', 'bug');
-                node_assert_1.default.strictEqual(nextPhase, phases[i + 1], `Next phase after ${phases[i]} should be ${phases[i + 1]}`);
-            }
-            // Last phase should return null
-            const lastPhase = (0, phase_flow_js_1.getNextPhase)('retrospective', 'implement', 'bug');
-            node_assert_1.default.strictEqual(lastPhase, null, 'retrospective phase should return null as next phase');
-        });
-        (0, node_test_1.it)('should return correct next phase for implement feature workflow', () => {
-            const phases = ['implement-scoping', 'implement-spike', 'implement-code', 'implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            for (let i = 0; i < phases.length - 1; i++) {
-                const nextPhase = (0, phase_flow_js_1.getNextPhase)(phases[i], 'implement', 'feature');
-                node_assert_1.default.strictEqual(nextPhase, phases[i + 1], `Next phase after ${phases[i]} should be ${phases[i + 1]}`);
-            }
-            // Last phase should return null
-            const lastPhase = (0, phase_flow_js_1.getNextPhase)('retrospective', 'implement', 'feature');
-            node_assert_1.default.strictEqual(lastPhase, null, 'retrospective phase should return null as next phase');
-        });
-        (0, node_test_1.it)('should return correct next phase for spec workflow', () => {
-            const phases = ['spec-spec', 'spec-competitor-analysis', 'spec-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            for (let i = 0; i < phases.length - 1; i++) {
-                const nextPhase = (0, phase_flow_js_1.getNextPhase)(phases[i], 'spec');
-                node_assert_1.default.strictEqual(nextPhase, phases[i + 1], `Next phase after ${phases[i]} should be ${phases[i + 1]}`);
-            }
-            // Last phase should return null
-            const lastPhase = (0, phase_flow_js_1.getNextPhase)('retrospective', 'spec');
-            node_assert_1.default.strictEqual(lastPhase, null, 'retrospective phase should return null as next phase');
-        });
-        (0, node_test_1.it)('should return correct next phase for design workflow', () => {
-            const phases = ['design-design', 'design-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            for (let i = 0; i < phases.length - 1; i++) {
-                const nextPhase = (0, phase_flow_js_1.getNextPhase)(phases[i], 'design');
-                node_assert_1.default.strictEqual(nextPhase, phases[i + 1], `Next phase after ${phases[i]} should be ${phases[i + 1]}`);
-            }
-            // Last phase should return null
-            const lastPhase = (0, phase_flow_js_1.getNextPhase)('retrospective', 'design');
-            node_assert_1.default.strictEqual(lastPhase, null, 'retrospective phase should return null as next phase');
-        });
-        (0, node_test_1.it)('should validate phases correctly for each workflow type', () => {
-            // Test implement workflow phases
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('implement-scoping', 'implement', 'bug'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('implement-repro', 'implement', 'bug'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('implement-spike', 'implement', 'feature'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('spec-spec', 'implement', 'bug'), false);
-            // Test spec workflow phases
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('spec-spec', 'spec'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('spec-completeness-review', 'spec'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('implement-scoping', 'spec'), false);
-            // Test design workflow phases
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('design-design', 'design'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('design-completeness-review', 'design'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('spec-spec', 'design'), false);
-            // Test finalize phase (no longer valid - replaced with submit-pr and wait-for-pr-review)
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'implement', 'bug'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'implement', 'bug'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'spec'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'spec'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('submit-pr', 'design'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('wait-for-pr-review', 'design'), true);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('finalize', 'implement', 'bug'), false);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('finalize', 'spec'), false);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.isPhaseValidForWorkflow)('finalize', 'design'), false);
-        });
-        (0, node_test_1.it)('should return correct phases for each workflow type', () => {
-            const bugPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('implement', 'bug');
-            const expectedBugPhases = ['implement-scoping', 'implement-repro', 'implement-code', 'implement-validate', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            node_assert_1.default.deepStrictEqual(bugPhases, expectedBugPhases);
-            const featurePhases = (0, phase_flow_js_1.getPhasesForWorkflow)('implement', 'feature');
-            const expectedFeaturePhases = ['implement-scoping', 'implement-spike', 'implement-code', 'implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            node_assert_1.default.deepStrictEqual(featurePhases, expectedFeaturePhases);
-            const specPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('spec');
-            const expectedSpecPhases = ['spec-spec', 'spec-competitor-analysis', 'spec-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            node_assert_1.default.deepStrictEqual(specPhases, expectedSpecPhases);
-            const designPhases = (0, phase_flow_js_1.getPhasesForWorkflow)('design');
-            const expectedDesignPhases = ['design-design', 'design-completeness-review', 'submit-pr', 'wait-for-pr-review', 'retrospective'];
-            node_assert_1.default.deepStrictEqual(designPhases, expectedDesignPhases);
-        });
-        (0, node_test_1.it)('should throw error for invalid workflow types', () => {
-            node_assert_1.default.throws(() => {
-                (0, phase_flow_js_1.getNextPhase)('implement-scoping', 'invalid');
-            }, /Unknown workflow type/);
-            node_assert_1.default.throws(() => {
-                (0, phase_flow_js_1.getPhasesForWorkflow)('invalid');
-            }, /Unknown workflow type/);
-        });
-        (0, node_test_1.it)('should throw error for invalid phases', () => {
-            node_assert_1.default.throws(() => {
-                (0, phase_flow_js_1.getNextPhase)('invalid-phase', 'implement', 'bug');
-            }, /Invalid phase/);
-        });
-    });
-    (0, node_test_1.describe)('AI Coach Phase Loading', () => {
-        (0, node_test_1.it)('should load implement phase instructions correctly', async () => {
-            const phases = ['implement-scoping', 'implement-repro', 'implement-code', 'implement-validate'];
-            for (const phase of phases) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'implement',
-                    currentPhase: phase,
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'bug' }
-                });
-                node_assert_1.default.ok(result.includes('Phase:'), `Phase instructions should contain 'Phase:' for ${phase}`);
-                node_assert_1.default.ok(result.includes('INTENT'), `Phase instructions should contain 'INTENT' for ${phase}`);
-                node_assert_1.default.ok(result.includes('OUTCOME'), `Phase instructions should contain 'OUTCOME' for ${phase}`);
-                node_assert_1.default.ok(!result.includes('**Error**'), `Phase instructions should not contain errors for ${phase}`);
-            }
-        });
-        (0, node_test_1.it)('should load spec phase instructions correctly', async () => {
-            const phases = ['spec-spec', 'spec-completeness-review'];
-            for (const phase of phases) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: phase,
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(result.includes('Phase:'), `Phase instructions should contain 'Phase:' for ${phase}`);
-                node_assert_1.default.ok(result.includes('INTENT'), `Phase instructions should contain 'INTENT' for ${phase}`);
-                node_assert_1.default.ok(result.includes('OUTCOME'), `Phase instructions should contain 'OUTCOME' for ${phase}`);
-                node_assert_1.default.ok(!result.includes('**Error**'), `Phase instructions should not contain errors for ${phase}`);
-            }
-        });
-        (0, node_test_1.it)('should load design phase instructions correctly', async () => {
-            const phases = ['design-design', 'design-completeness-review'];
-            for (const phase of phases) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'design',
-                    currentPhase: phase,
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(result.includes('Phase:'), `Phase instructions should contain 'Phase:' for ${phase}`);
-                node_assert_1.default.ok(result.includes('INTENT'), `Phase instructions should contain 'INTENT' for ${phase}`);
-                node_assert_1.default.ok(result.includes('OUTCOME'), `Phase instructions should contain 'OUTCOME' for ${phase}`);
-                node_assert_1.default.ok(!result.includes('**Error**'), `Phase instructions should not contain errors for ${phase}`);
-            }
-        });
-        (0, node_test_1.it)('should load shared wait-for-pr-review phase for all workflows', async () => {
-            const workflows = ['implement', 'spec', 'design'];
-            for (const workflow of workflows) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: workflow,
-                    currentPhase: 'wait-for-pr-review',
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(result.includes('Phase:'), `wait-for-pr-review phase should load for ${workflow} workflow`);
-                node_assert_1.default.ok(result.includes('INTENT'), `wait-for-pr-review phase should contain INTENT for ${workflow} workflow`);
-                node_assert_1.default.ok(result.includes('OUTCOME'), `wait-for-pr-review phase should contain OUTCOME for ${workflow} workflow`);
-                node_assert_1.default.ok(!result.includes('**Error**'), `wait-for-pr-review phase should not contain errors for ${workflow} workflow`);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Phase Transitions', () => {
-        (0, node_test_1.it)('should provide next phase instructions when phase is complete', async () => {
-            // Test spec workflow transition
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'complete',
-                issueNumber: '123',
-                evidence: { issueType: 'feature', specComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Phase Complete!'), 'Should indicate phase completion');
-            node_assert_1.default.ok(result.includes('Next Phase: spec-competitor-analysis'), 'Should provide next phase instructions');
-            node_assert_1.default.ok(result.includes('Phase: spec-competitor-analysis'), 'Should include next phase content');
-        });
-        (0, node_test_1.it)('should provide completion message for wait-for-pr-review phase', async () => {
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'retrospective',
-                status: 'complete',
-                issueNumber: '123',
-                evidence: { issueType: 'feature', retrospectiveComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Spec Complete!'), 'Should show workflow completion message');
-            node_assert_1.default.ok(result.includes('Congratulations!'), 'Should include congratulations');
-            node_assert_1.default.ok(result.includes('What You\'ve Accomplished'), 'Should list accomplishments');
-        });
-        (0, node_test_1.it)('should handle incomplete phase status with help message', async () => {
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'implement',
-                currentPhase: 'implement-code',
-                status: 'incomplete',
-                issueNumber: '123',
-                evidence: { issueType: 'bug' },
-                findings: { uncertainties: ['Tests are failing', 'Build errors'] }
-            });
-            node_assert_1.default.ok(result.includes('🤝 AI Coach Assistance'), 'Should show assistance header');
-            node_assert_1.default.ok(result.includes('Incomplete - Need Help'), 'Should indicate incomplete status');
-            node_assert_1.default.ok(result.includes('Tests are failing'), 'Should list specific uncertainties');
-            node_assert_1.default.ok(result.includes('Build errors'), 'Should list all uncertainties');
-            node_assert_1.default.ok(result.includes('Complete Phase Guidance'), 'Should provide complete guidance');
-        });
-    });
-    (0, node_test_1.describe)('Error Handling', () => {
-        (0, node_test_1.it)('should reject invalid workflow types', async () => {
-            try {
-                await coach.handleCoachingRequest({
-                    workflowType: 'invalid',
-                    currentPhase: 'some-phase',
-                    status: 'starting',
-                    issueNumber: '123'
-                });
-                node_assert_1.default.fail('Should have thrown error for invalid workflow type');
-            }
-            catch (error) {
-                node_assert_1.default.ok(error instanceof Error);
-                node_assert_1.default.ok(error.message.includes('Invalid workflow type'));
-            }
-        });
-        (0, node_test_1.it)('should reject invalid phases for workflow types', async () => {
-            try {
-                await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'implement-scoping',
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.fail('Should have thrown error for invalid phase');
-            }
-            catch (error) {
-                node_assert_1.default.ok(error instanceof Error);
-                node_assert_1.default.ok(error.message.includes('Invalid phase'));
-            }
-        });
-        (0, node_test_1.it)('should provide helpful error when using wrong phase for issue type', async () => {
-            try {
-                await coach.handleCoachingRequest({
-                    workflowType: 'implement',
-                    currentPhase: 'implement-repro', // Bug phase
-                    status: 'complete',
-                    issueNumber: '123',
-                    findings: {
-                        issueType: 'feature' // But specified as feature
-                    }
-                });
-                node_assert_1.default.fail('Should have thrown error for wrong phase');
-            }
-            catch (error) {
-                node_assert_1.default.ok(error instanceof Error);
-                node_assert_1.default.ok(error.message.includes('Invalid Phase for Issue Type'), `Error message should mention invalid phase for issue type. Got: ${error.message}`);
-                node_assert_1.default.ok(error.message.includes('implement-repro'), `Error message should mention the invalid phase. Got: ${error.message}`);
-                node_assert_1.default.ok(error.message.includes('feature'), `Error message should mention the issue type. Got: ${error.message}`);
-                node_assert_1.default.ok(error.message.includes('implement-spike'), `Error message should show valid phases for features. Got: ${error.message}`);
-            }
-        });
-        (0, node_test_1.it)('should provide helpful error when issueType is missing for implement workflow', async () => {
-            try {
-                await coach.handleCoachingRequest({
-                    workflowType: 'implement',
-                    currentPhase: 'implement-repro', // This phase is only valid for bugs
-                    status: 'complete',
-                    issueNumber: '123'
-                    // Missing issueType in evidence/findings - will default to 'feature'
-                });
-                node_assert_1.default.fail('Should have thrown error for missing issue type');
-            }
-            catch (error) {
-                node_assert_1.default.ok(error instanceof Error);
-                node_assert_1.default.ok(error.message.includes('Missing Required Field: issueType'), `Error message should mention missing issueType. Got: ${error.message}`);
-                node_assert_1.default.ok(error.message.includes('findings: {'), `Error message should show correct format. Got: ${error.message}`);
-                node_assert_1.default.ok(error.message.includes('issueType: "bug"'), `Error message should show example. Got: ${error.message}`);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Workflow Accomplishments', () => {
-        (0, node_test_1.it)('should show correct accomplishments for each workflow type', async () => {
-            const workflows = [
-                { type: 'spec', expectedText: '**Specification**: Created comprehensive feature specification' },
-                { type: 'design', expectedText: '**Design**: Created technical design and architecture' },
-                { type: 'implement', expectedText: '**Scoping**: Understood requirements and issue type' }
-            ];
-            for (const workflow of workflows) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: workflow.type,
-                    currentPhase: 'retrospective',
-                    status: 'complete',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature', retrospectiveComplete: true }
-                });
-                node_assert_1.default.ok(result.includes(workflow.expectedText), `${workflow.type} workflow should show correct accomplishments`);
-            }
-        });
-    });
-    (0, node_test_1.describe)('File Path Resolution', () => {
-        (0, node_test_1.it)('should resolve phase file paths correctly', () => {
-            // Test that all expected phase files exist
-            const expectedFiles = [
-                'registry/ai-manager-rules/shared-phases/wait-for-pr-review.md',
-                'registry/ai-manager-rules/implement-phases/implement-scoping.md',
-                'registry/ai-manager-rules/implement-phases/implement-code.md',
-                'registry/ai-manager-rules/spec-phases/spec-spec.md',
-                'registry/ai-manager-rules/spec-phases/spec-completeness-review.md',
-                'registry/ai-manager-rules/design-phases/design-design.md',
-                'registry/ai-manager-rules/design-phases/design-completeness-review.md'
-            ];
-            for (const filePath of expectedFiles) {
-                const fullPath = (0, path_1.join)(process.cwd(), filePath);
-                node_assert_1.default.ok((0, fs_1.existsSync)(fullPath), `Phase file should exist: ${filePath}`);
-                // Verify file has content
-                const content = (0, fs_1.readFileSync)(fullPath, 'utf8');
-                node_assert_1.default.ok(content.length > 0, `Phase file should have content: ${filePath}`);
-                node_assert_1.default.ok(content.includes('# Phase:'), `Phase file should have proper header: ${filePath}`);
-            }
-        });
-        (0, node_test_1.it)('should have consistent phase file naming', () => {
-            const implementPhases = [
-                'implement-scoping', 'implement-repro', 'implement-spike', 'implement-code',
-                'implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review'
-            ];
-            for (const phase of implementPhases) {
-                const filePath = (0, path_1.join)(process.cwd(), 'registry/ai-manager-rules/implement-phases', `${phase}.md`);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Implement phase file should exist: ${phase}.md`);
-            }
-            const specPhases = ['spec-spec', 'spec-completeness-review'];
-            for (const phase of specPhases) {
-                const filePath = (0, path_1.join)(process.cwd(), 'registry/ai-manager-rules/spec-phases', `${phase}.md`);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Spec phase file should exist: ${phase}.md`);
-            }
-            const designPhases = ['design-design', 'design-completeness-review'];
-            for (const phase of designPhases) {
-                const filePath = (0, path_1.join)(process.cwd(), 'registry/ai-manager-rules/design-phases', `${phase}.md`);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Design phase file should exist: ${phase}.md`);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Integration Tests', () => {
-        (0, node_test_1.it)('should complete full spec workflow', async () => {
-            const issueNumber = '123';
-            const workflowType = 'spec';
-            // Start with spec phase
-            let result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber,
-                evidence: { issueType: 'feature' }
-            });
-            node_assert_1.default.ok(result.includes('Phase: Spec-Spec'), 'Should start with spec phase');
-            // Complete spec phase
-            result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'spec-spec',
-                status: 'complete',
-                issueNumber,
-                evidence: { issueType: 'feature', specComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Next Phase: spec-competitor-analysis'), 'Should transition to competitor analysis');
-            // Complete competitor analysis
-            result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'spec-competitor-analysis',
-                status: 'complete',
-                issueNumber,
-                evidence: { issueType: 'feature', competitorAnalysisComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Next Phase: spec-completeness-review'), 'Should transition to completeness review');
-            // Complete completeness review
-            result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'spec-completeness-review',
-                status: 'complete',
-                issueNumber,
-                evidence: { issueType: 'feature', reviewComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Next Phase: submit-pr'), 'Should transition to submit-pr');
-            // Complete submit-pr
-            result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'submit-pr',
-                status: 'complete',
-                issueNumber,
-                evidence: { issueType: 'feature', prSubmitted: true }
-            });
-            node_assert_1.default.ok(result.includes('Next Phase: wait-for-pr-review'), 'Should transition to wait-for-pr-review');
-            // Complete wait-for-pr-review
-            result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'wait-for-pr-review',
-                status: 'complete',
-                issueNumber,
-                evidence: { issueType: 'feature', prApproved: true }
-            });
-            node_assert_1.default.ok(result.includes('Next Phase: retrospective'), 'Should transition to retrospective');
-            // Complete retrospective
-            result = await coach.handleCoachingRequest({
-                workflowType,
-                currentPhase: 'retrospective',
-                status: 'complete',
-                issueNumber,
-                evidence: { issueType: 'feature', retrospectiveComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Spec Complete!'), 'Should show completion message');
-        });
-        (0, node_test_1.it)('should complete full implement bug workflow', async () => {
-            const issueNumber = '456';
-            const workflowType = 'implement';
-            const issueType = 'bug';
-            // Test key phases in bug workflow including retrospective
-            const phases = ['implement-scoping', 'implement-repro', 'implement-code', 'wait-for-pr-review', 'retrospective'];
-            for (let i = 0; i < phases.length; i++) {
-                const phase = phases[i];
-                const isLast = i === phases.length - 1;
-                const result = await coach.handleCoachingRequest({
-                    workflowType,
-                    currentPhase: phase,
-                    status: 'complete',
-                    issueNumber,
-                    evidence: { issueType },
-                    findings: { issueType }
-                });
-                if (isLast) {
-                    node_assert_1.default.ok(result.includes('Implement Complete!'), 'Should show completion for final phase');
-                }
-                else {
-                    node_assert_1.default.ok(result.includes('Next Phase:'), `Should show next phase after ${phase}`);
-                }
-            }
-        });
-        (0, node_test_1.it)('should handle workflow with help requests', async () => {
-            // Start phase
-            let result = await coach.handleCoachingRequest({
-                workflowType: 'design',
-                currentPhase: 'design-design',
-                status: 'starting',
-                issueNumber: '789',
-                evidence: { issueType: 'feature' }
-            });
-            node_assert_1.default.ok(result.includes('Phase: Design-Design'), 'Should provide initial instructions');
-            // Request help
-            result = await coach.handleCoachingRequest({
-                workflowType: 'design',
-                currentPhase: 'design-design',
-                status: 'incomplete',
-                issueNumber: '789',
-                evidence: { issueType: 'feature' },
-                findings: { uncertainties: ['Not sure about database schema', 'API design unclear'] }
-            });
-            node_assert_1.default.ok(result.includes('🤝 AI Coach Assistance'), 'Should provide help');
-            node_assert_1.default.ok(result.includes('Not sure about database schema'), 'Should include specific uncertainties');
-            // Complete after help
-            result = await coach.handleCoachingRequest({
-                workflowType: 'design',
-                currentPhase: 'design-design',
-                status: 'complete',
-                issueNumber: '789',
-                evidence: { issueType: 'feature', designComplete: true }
-            });
-            node_assert_1.default.ok(result.includes('Next Phase: design-completeness-review'), 'Should proceed to next phase');
-        });
-    });
-});