fraim-framework 2.0.56 → 2.0.58

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

@@ -1,328 +0,0 @@
-"use strict";
-/**
- * Performance and load tests for AI Coach
- * Tests system behavior under various load conditions
- */
-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 fs_1 = require("fs");
-const path_1 = require("path");
-(0, node_test_1.describe)('AI Coach Performance Tests', () => {
-    let coach;
-    let fileIndex;
-    (0, node_test_1.before)(() => {
-        // Create a comprehensive file index
-        fileIndex = new Map();
-        const phaseFiles = [
-            'ai-manager-rules/shared-phases/submit-pr.md',
-            'ai-manager-rules/shared-phases/wait-for-pr-review.md',
-            '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',
-            'ai-manager-rules/spec-phases/spec-spec.md',
-            'ai-manager-rules/spec-phases/spec-completeness-review.md',
-            '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)('Response Time Performance', () => {
-        (0, node_test_1.it)('should respond to phase requests within reasonable time', async () => {
-            const testCases = [
-                { workflow: 'spec', phase: 'spec-spec' },
-                { workflow: 'design', phase: 'design-design' },
-                { workflow: 'implement', phase: 'implement-scoping' },
-                { workflow: 'implement', phase: 'implement-code' }
-            ];
-            for (const testCase of testCases) {
-                const startTime = Date.now();
-                const result = await coach.handleCoachingRequest({
-                    workflowType: testCase.workflow,
-                    currentPhase: testCase.phase,
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature' }
-                });
-                const duration = Date.now() - startTime;
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-                node_assert_1.default.ok(duration < 1000, `${testCase.workflow}/${testCase.phase} should respond within 1 second (took ${duration}ms)`);
-            }
-        });
-        (0, node_test_1.it)('should handle phase transitions efficiently', async () => {
-            const startTime = Date.now();
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'complete',
-                issueNumber: '123',
-                evidence: { issueType: 'feature', specComplete: true }
-            });
-            const duration = Date.now() - startTime;
-            node_assert_1.default.ok(result.includes('Next Phase: spec-competitor-analysis'));
-            node_assert_1.default.ok(duration < 1000, `Phase transition should complete within 1 second (took ${duration}ms)`);
-        });
-        (0, node_test_1.it)('should handle completion messages efficiently', async () => {
-            const startTime = Date.now();
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'retrospective',
-                status: 'complete',
-                issueNumber: '123',
-                evidence: { issueType: 'feature', retrospectiveComplete: true }
-            });
-            const duration = Date.now() - startTime;
-            node_assert_1.default.ok(result.includes('Spec Complete!'));
-            node_assert_1.default.ok(duration < 1000, `Completion message should generate within 1 second (took ${duration}ms)`);
-        });
-    });
-    (0, node_test_1.describe)('Load Testing', () => {
-        (0, node_test_1.it)('should handle 100 concurrent requests', async () => {
-            const concurrentRequests = 100;
-            const startTime = Date.now();
-            const requests = Array.from({ length: concurrentRequests }, (_, i) => coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: `${i}`,
-                evidence: { issueType: 'feature' }
-            }));
-            const results = await Promise.all(requests);
-            const duration = Date.now() - startTime;
-            // All requests should complete successfully
-            node_assert_1.default.strictEqual(results.length, concurrentRequests);
-            for (const result of results) {
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-            console.log(`${concurrentRequests} concurrent requests completed in ${duration}ms`);
-            node_assert_1.default.ok(duration < 10000, `${concurrentRequests} concurrent requests should complete within 10 seconds`);
-        });
-        (0, node_test_1.it)('should handle mixed workflow types under load', async () => {
-            const requestsPerWorkflow = 25;
-            const workflows = ['spec', 'design', 'implement'];
-            const phases = ['spec-spec', 'design-design', 'implement-scoping'];
-            const startTime = Date.now();
-            const allRequests = workflows.flatMap((workflow, workflowIndex) => Array.from({ length: requestsPerWorkflow }, (_, i) => coach.handleCoachingRequest({
-                workflowType: workflow,
-                currentPhase: phases[workflowIndex],
-                status: 'starting',
-                issueNumber: `${workflowIndex}-${i}`,
-                evidence: { issueType: 'feature' }
-            })));
-            const results = await Promise.all(allRequests);
-            const duration = Date.now() - startTime;
-            node_assert_1.default.strictEqual(results.length, requestsPerWorkflow * workflows.length);
-            for (const result of results) {
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-            console.log(`${results.length} mixed workflow requests completed in ${duration}ms`);
-            node_assert_1.default.ok(duration < 15000, 'Mixed workflow load test should complete within 15 seconds');
-        });
-        (0, node_test_1.it)('should handle sequential high-frequency requests', async () => {
-            const requestCount = 200;
-            const startTime = Date.now();
-            for (let i = 0; i < requestCount; i++) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: `${i}`,
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-            const duration = Date.now() - startTime;
-            const avgResponseTime = duration / requestCount;
-            console.log(`${requestCount} sequential requests completed in ${duration}ms (avg: ${avgResponseTime.toFixed(2)}ms per request)`);
-            node_assert_1.default.ok(avgResponseTime < 50, 'Average response time should be under 50ms per request');
-        });
-    });
-    (0, node_test_1.describe)('Memory Usage', () => {
-        (0, node_test_1.it)('should not leak memory during repeated operations', async () => {
-            const initialMemory = process.memoryUsage();
-            // Perform many operations
-            for (let i = 0; i < 1000; i++) {
-                await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: `${i}`,
-                    evidence: { issueType: 'feature' }
-                });
-                // Occasionally force garbage collection if available
-                if (i % 100 === 0 && global.gc) {
-                    global.gc();
-                }
-            }
-            const finalMemory = process.memoryUsage();
-            const memoryIncrease = finalMemory.heapUsed - initialMemory.heapUsed;
-            const memoryIncreaseMB = memoryIncrease / (1024 * 1024);
-            console.log(`Memory increase after 1000 operations: ${memoryIncreaseMB.toFixed(2)}MB`);
-            // Memory increase should be reasonable (less than 50MB)
-            node_assert_1.default.ok(memoryIncreaseMB < 50, 'Memory increase should be reasonable');
-        });
-        (0, node_test_1.it)('should handle large evidence objects efficiently', async () => {
-            const largeEvidence = {
-                issueType: 'feature',
-                largeArray: Array.from({ length: 10000 }, (_, i) => ({
-                    id: i,
-                    data: `data-${i}`,
-                    metadata: {
-                        timestamp: Date.now(),
-                        tags: [`tag-${i % 10}`, `category-${i % 5}`]
-                    }
-                }))
-            };
-            const startTime = Date.now();
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: largeEvidence
-            });
-            const duration = Date.now() - startTime;
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-            node_assert_1.default.ok(duration < 2000, `Large evidence handling should complete within 2 seconds (took ${duration}ms)`);
-        });
-    });
-    (0, node_test_1.describe)('File System Performance', () => {
-        (0, node_test_1.it)('should cache file reads efficiently', async () => {
-            // First request (cold cache)
-            const startTime1 = Date.now();
-            const result1 = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: { issueType: 'feature' }
-            });
-            const duration1 = Date.now() - startTime1;
-            // Second request (warm cache)
-            const startTime2 = Date.now();
-            const result2 = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '456',
-                evidence: { issueType: 'feature' }
-            });
-            const duration2 = Date.now() - startTime2;
-            node_assert_1.default.ok(typeof result1 === 'string');
-            node_assert_1.default.ok(typeof result2 === 'string');
-            console.log(`First request: ${duration1}ms, Second request: ${duration2}ms`);
-            // Second request should be faster or similar (file system caching)
-            // Allow some variance due to system factors
-            node_assert_1.default.ok(duration2 <= duration1 * 2, 'Subsequent requests should benefit from caching');
-        });
-        (0, node_test_1.it)('should handle multiple different phase files efficiently', async () => {
-            const phases = [
-                { workflow: 'spec', phase: 'spec-spec' },
-                { workflow: 'spec', phase: 'spec-completeness-review' },
-                { workflow: 'design', phase: 'design-design' },
-                { workflow: 'design', phase: 'design-completeness-review' },
-                { workflow: 'implement', phase: 'implement-scoping' },
-                { workflow: 'implement', phase: 'implement-code' }
-            ];
-            const startTime = Date.now();
-            for (const { workflow, phase } of phases) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: workflow,
-                    currentPhase: phase,
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-            const duration = Date.now() - startTime;
-            const avgTimePerFile = duration / phases.length;
-            console.log(`${phases.length} different phase files loaded in ${duration}ms (avg: ${avgTimePerFile.toFixed(2)}ms per file)`);
-            node_assert_1.default.ok(avgTimePerFile < 200, 'Average file load time should be under 200ms');
-        });
-    });
-    (0, node_test_1.describe)('Scalability Tests', () => {
-        (0, node_test_1.it)('should maintain performance with increasing request complexity', async () => {
-            const complexityLevels = [
-                { name: 'simple', evidence: { issueType: 'feature' } },
-                { name: 'medium', evidence: {
-                        issueType: 'feature',
-                        metadata: { tags: ['tag1', 'tag2'], priority: 'high' }
-                    } },
-                { name: 'complex', evidence: {
-                        issueType: 'feature',
-                        metadata: {
-                            tags: Array.from({ length: 100 }, (_, i) => `tag-${i}`),
-                            priority: 'high',
-                            history: Array.from({ length: 50 }, (_, i) => ({
-                                timestamp: Date.now() - i * 1000,
-                                action: `action-${i}`
-                            }))
-                        }
-                    } }
-            ];
-            for (const level of complexityLevels) {
-                const startTime = Date.now();
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: level.evidence
-                });
-                const duration = Date.now() - startTime;
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-                console.log(`${level.name} complexity request: ${duration}ms`);
-                node_assert_1.default.ok(duration < 1000, `${level.name} complexity should complete within 1 second`);
-            }
-        });
-        (0, node_test_1.it)('should handle burst traffic patterns', async () => {
-            // Simulate burst traffic: many requests in short time, then quiet period
-            const burstSize = 50;
-            const burstCount = 3;
-            for (let burst = 0; burst < burstCount; burst++) {
-                const startTime = Date.now();
-                const requests = Array.from({ length: burstSize }, (_, i) => coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: `burst-${burst}-${i}`,
-                    evidence: { issueType: 'feature' }
-                }));
-                const results = await Promise.all(requests);
-                const duration = Date.now() - startTime;
-                node_assert_1.default.strictEqual(results.length, burstSize);
-                for (const result of results) {
-                    node_assert_1.default.ok(typeof result === 'string');
-                    node_assert_1.default.ok(result.length > 0);
-                }
-                console.log(`Burst ${burst + 1}: ${burstSize} requests in ${duration}ms`);
-                node_assert_1.default.ok(duration < 5000, `Burst ${burst + 1} should complete within 5 seconds`);
-                // Brief pause between bursts
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-        });
-    });
-});

package/dist/tests/test-ai-coach-phase-content.js

@@ -1,264 +0,0 @@
-"use strict";
-/**
- * Tests for AI Coach phase content validation
- * Ensures all phase files have proper structure and required content
- */
-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 fs_1 = require("fs");
-const path_1 = require("path");
-(0, node_test_1.describe)('AI Coach Phase Content Validation', () => {
-    const registryPath = (0, path_1.join)(process.cwd(), 'registry', 'ai-manager-rules');
-    (0, node_test_1.describe)('Phase File Structure', () => {
-        (0, node_test_1.it)('should have all required phase directories', () => {
-            const requiredDirs = [
-                'implement-phases',
-                'spec-phases',
-                'design-phases',
-                'shared-phases'
-            ];
-            for (const dir of requiredDirs) {
-                const dirPath = (0, path_1.join)(registryPath, dir);
-                node_assert_1.default.ok((0, fs_1.existsSync)(dirPath), `Directory should exist: ${dir}`);
-            }
-        });
-        (0, node_test_1.it)('should have all required implement phase files', () => {
-            const implementPhasesDir = (0, path_1.join)(registryPath, 'implement-phases');
-            const requiredFiles = [
-                'implement-scoping.md',
-                'implement-repro.md',
-                'implement-spike.md',
-                'implement-code.md',
-                'implement-validate.md',
-                'implement-smoke.md',
-                'implement-regression.md',
-                'implement-completeness-review.md'
-            ];
-            for (const file of requiredFiles) {
-                const filePath = (0, path_1.join)(implementPhasesDir, file);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Implement phase file should exist: ${file}`);
-            }
-        });
-        (0, node_test_1.it)('should have all required spec phase files', () => {
-            const specPhasesDir = (0, path_1.join)(registryPath, 'spec-phases');
-            const requiredFiles = [
-                'spec-spec.md',
-                'spec-completeness-review.md'
-            ];
-            for (const file of requiredFiles) {
-                const filePath = (0, path_1.join)(specPhasesDir, file);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Spec phase file should exist: ${file}`);
-            }
-        });
-        (0, node_test_1.it)('should have all required design phase files', () => {
-            const designPhasesDir = (0, path_1.join)(registryPath, 'design-phases');
-            const requiredFiles = [
-                'design-design.md',
-                'design-completeness-review.md'
-            ];
-            for (const file of requiredFiles) {
-                const filePath = (0, path_1.join)(designPhasesDir, file);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Design phase file should exist: ${file}`);
-            }
-        });
-        (0, node_test_1.it)('should have all required shared phase files', () => {
-            const sharedPhasesDir = (0, path_1.join)(registryPath, 'shared-phases');
-            const requiredFiles = [
-                'submit-pr.md',
-                'wait-for-pr-review.md'
-            ];
-            for (const file of requiredFiles) {
-                const filePath = (0, path_1.join)(sharedPhasesDir, file);
-                node_assert_1.default.ok((0, fs_1.existsSync)(filePath), `Shared phase file should exist: ${file}`);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Phase File Content Structure', () => {
-        function validatePhaseFileContent(filePath, expectedPhase) {
-            const content = (0, fs_1.readFileSync)(filePath, 'utf8');
-            // Check required sections
-            node_assert_1.default.ok(content.includes('# Phase:'), `File should have phase header: ${filePath}`);
-            node_assert_1.default.ok(content.includes('## INTENT'), `File should have INTENT section: ${filePath}`);
-            node_assert_1.default.ok(content.includes('## OUTCOME'), `File should have OUTCOME section: ${filePath}`);
-            node_assert_1.default.ok(content.includes('## WORKFLOW') || content.includes('## PRINCIPLES'), `File should have WORKFLOW or PRINCIPLES section: ${filePath}`);
-            node_assert_1.default.ok(content.includes('## VALIDATION'), `File should have VALIDATION section: ${filePath}`);
-            // Check validation subsections
-            node_assert_1.default.ok(content.includes('### Phase Complete When:'), `File should have completion criteria: ${filePath}`);
-            node_assert_1.default.ok(content.includes('### Report Back:') || content.includes('### Phase Incomplete If:'), `File should have reporting instructions: ${filePath}`);
-            // Check for seekCoachingOnNextStep call
-            node_assert_1.default.ok(content.includes('seekCoachingOnNextStep'), `File should include seekCoachingOnNextStep call: ${filePath}`);
-            // Verify phase name in header matches expected
-            const headerMatch = content.match(/# Phase: (.+)/);
-            node_assert_1.default.ok(headerMatch, `File should have proper phase header: ${filePath}`);
-            const actualPhase = headerMatch[1].trim();
-            node_assert_1.default.ok(actualPhase.toLowerCase().includes(expectedPhase.toLowerCase()) ||
-                expectedPhase.toLowerCase().includes(actualPhase.toLowerCase()), `Phase header "${actualPhase}" should match expected "${expectedPhase}" in ${filePath}`);
-        }
-        (0, node_test_1.it)('should validate all implement phase files have proper structure', () => {
-            const implementPhasesDir = (0, path_1.join)(registryPath, 'implement-phases');
-            const files = (0, fs_1.readdirSync)(implementPhasesDir).filter(f => f.endsWith('.md'));
-            for (const file of files) {
-                const filePath = (0, path_1.join)(implementPhasesDir, file);
-                const expectedPhase = file.replace('.md', '');
-                validatePhaseFileContent(filePath, expectedPhase);
-            }
-        });
-        (0, node_test_1.it)('should validate all spec phase files have proper structure', () => {
-            const specPhasesDir = (0, path_1.join)(registryPath, 'spec-phases');
-            const files = (0, fs_1.readdirSync)(specPhasesDir).filter(f => f.endsWith('.md'));
-            for (const file of files) {
-                const filePath = (0, path_1.join)(specPhasesDir, file);
-                const expectedPhase = file.replace('.md', '');
-                validatePhaseFileContent(filePath, expectedPhase);
-            }
-        });
-        (0, node_test_1.it)('should validate all design phase files have proper structure', () => {
-            const designPhasesDir = (0, path_1.join)(registryPath, 'design-phases');
-            const files = (0, fs_1.readdirSync)(designPhasesDir).filter(f => f.endsWith('.md'));
-            for (const file of files) {
-                const filePath = (0, path_1.join)(designPhasesDir, file);
-                const expectedPhase = file.replace('.md', '');
-                validatePhaseFileContent(filePath, expectedPhase);
-            }
-        });
-        (0, node_test_1.it)('should validate shared phase files have proper structure', () => {
-            const sharedFiles = ['submit-pr.md', 'wait-for-pr-review.md'];
-            for (const file of sharedFiles) {
-                const filePath = (0, path_1.join)(registryPath, 'shared-phases', file);
-                const expectedPhase = file.replace('.md', '');
-                validatePhaseFileContent(filePath, expectedPhase);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Phase File Naming Consistency', () => {
-        (0, node_test_1.it)('should have consistent implement phase naming', () => {
-            const implementPhasesDir = (0, path_1.join)(registryPath, 'implement-phases');
-            const files = (0, fs_1.readdirSync)(implementPhasesDir).filter(f => f.endsWith('.md'));
-            for (const file of files) {
-                node_assert_1.default.ok(file.startsWith('implement-'), `Implement phase file should start with 'implement-': ${file}`);
-                node_assert_1.default.ok(file.endsWith('.md'), `Implement phase file should end with '.md': ${file}`);
-                // Check that phase name in file matches filename
-                const content = (0, fs_1.readFileSync)((0, path_1.join)(implementPhasesDir, file), 'utf8');
-                const expectedPhase = file.replace('.md', '');
-                // Allow for some flexibility in header format
-                const hasCorrectHeader = content.includes(`# Phase: ${expectedPhase}`) ||
-                    content.includes(`# Phase: Implement-`) ||
-                    content.includes(`# Phase: ${expectedPhase.replace('implement-', '').charAt(0).toUpperCase() + expectedPhase.replace('implement-', '').slice(1)}`);
-                node_assert_1.default.ok(hasCorrectHeader, `Phase file header should match filename for: ${file}`);
-            }
-        });
-        (0, node_test_1.it)('should have consistent spec phase naming', () => {
-            const specPhasesDir = (0, path_1.join)(registryPath, 'spec-phases');
-            const files = (0, fs_1.readdirSync)(specPhasesDir).filter(f => f.endsWith('.md'));
-            for (const file of files) {
-                node_assert_1.default.ok(file.startsWith('spec-'), `Spec phase file should start with 'spec-': ${file}`);
-                const content = (0, fs_1.readFileSync)((0, path_1.join)(specPhasesDir, file), 'utf8');
-                const expectedPhase = file.replace('.md', '');
-                const hasCorrectHeader = content.includes(`# Phase: ${expectedPhase}`) ||
-                    content.includes(`# Phase: Spec-`) ||
-                    content.includes(`# Phase: Spec `);
-                node_assert_1.default.ok(hasCorrectHeader, `Phase file header should match filename for: ${file}`);
-            }
-        });
-        (0, node_test_1.it)('should have consistent design phase naming', () => {
-            const designPhasesDir = (0, path_1.join)(registryPath, 'design-phases');
-            const files = (0, fs_1.readdirSync)(designPhasesDir).filter(f => f.endsWith('.md'));
-            for (const file of files) {
-                node_assert_1.default.ok(file.startsWith('design-'), `Design phase file should start with 'design-': ${file}`);
-                const content = (0, fs_1.readFileSync)((0, path_1.join)(designPhasesDir, file), 'utf8');
-                const expectedPhase = file.replace('.md', '');
-                const hasCorrectHeader = content.includes(`# Phase: ${expectedPhase}`) ||
-                    content.includes(`# Phase: Design-`) ||
-                    content.includes(`# Phase: Design `);
-                node_assert_1.default.ok(hasCorrectHeader, `Phase file header should match filename for: ${file}`);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Phase Content Quality', () => {
-        (0, node_test_1.it)('should have meaningful content in all phase files', () => {
-            const allDirs = ['implement-phases', 'spec-phases', 'design-phases', 'shared-phases'];
-            for (const dir of allDirs) {
-                const dirPath = (0, path_1.join)(registryPath, dir);
-                const files = (0, fs_1.readdirSync)(dirPath).filter(f => f.endsWith('.md'));
-                for (const file of files) {
-                    const filePath = (0, path_1.join)(dirPath, file);
-                    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
-                    // Check minimum content length
-                    node_assert_1.default.ok(content.length > 500, `Phase file should have substantial content: ${file}`);
-                    // Check for placeholder text
-                    node_assert_1.default.ok(!content.includes('TODO'), `Phase file should not contain TODO placeholders: ${file}`);
-                    node_assert_1.default.ok(!content.includes('FIXME'), `Phase file should not contain FIXME placeholders: ${file}`);
-                    node_assert_1.default.ok(!content.includes('[PLACEHOLDER]'), `Phase file should not contain placeholder text: ${file}`);
-                    // Check for proper seekCoachingOnNextStep usage
-                    const seekCalls = content.match(/seekCoachingOnNextStep/g);
-                    node_assert_1.default.ok(seekCalls && seekCalls.length >= 1, `Phase file should have at least one seekCoachingOnNextStep call: ${file}`);
-                    // Check that currentPhase parameter matches file
-                    const expectedPhase = file.replace('.md', '');
-                    const phaseParamMatch = content.match(/currentPhase:\s*["']([^"']+)["']/);
-                    if (phaseParamMatch) {
-                        const actualPhase = phaseParamMatch[1];
-                        node_assert_1.default.strictEqual(actualPhase, expectedPhase, `currentPhase parameter should match filename in ${file}`);
-                    }
-                }
-            }
-        });
-        (0, node_test_1.it)('should have consistent workflow type references', () => {
-            const workflowDirs = [
-                { dir: 'implement-phases', expectedWorkflow: 'implement' },
-                { dir: 'spec-phases', expectedWorkflow: 'spec' },
-                { dir: 'design-phases', expectedWorkflow: 'design' }
-            ];
-            for (const { dir, expectedWorkflow } of workflowDirs) {
-                const dirPath = (0, path_1.join)(registryPath, dir);
-                const files = (0, fs_1.readdirSync)(dirPath).filter(f => f.endsWith('.md'));
-                for (const file of files) {
-                    const filePath = (0, path_1.join)(dirPath, file);
-                    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
-                    // Check workflowType parameter in seekCoachingOnNextStep calls
-                    const workflowMatches = content.match(/workflowType:\s*["']([^"']+)["']/g);
-                    if (workflowMatches) {
-                        for (const match of workflowMatches) {
-                            const workflowType = match.match(/["']([^"']+)["']/)?.[1];
-                            node_assert_1.default.strictEqual(workflowType, expectedWorkflow, `workflowType should be "${expectedWorkflow}" in ${file}`);
-                        }
-                    }
-                }
-            }
-        });
-    });
-    (0, node_test_1.describe)('Shared Phase Consistency', () => {
-        (0, node_test_1.it)('should have only shared phases in shared-phases directory', () => {
-            // Check that submit-pr and wait-for-pr-review exist in shared-phases
-            const sharedSubmitPr = (0, path_1.join)(registryPath, 'shared-phases', 'submit-pr.md');
-            const sharedWaitForReview = (0, path_1.join)(registryPath, 'shared-phases', 'wait-for-pr-review.md');
-            node_assert_1.default.ok((0, fs_1.existsSync)(sharedSubmitPr), 'Shared submit-pr should exist');
-            node_assert_1.default.ok((0, fs_1.existsSync)(sharedWaitForReview), 'Shared wait-for-pr-review should exist');
-            // Check that no other directories have these files
-            const otherDirs = ['implement-phases', 'spec-phases', 'design-phases'];
-            for (const dir of otherDirs) {
-                const dirPath = (0, path_1.join)(registryPath, dir);
-                const submitPrFile = (0, path_1.join)(dirPath, 'submit-pr.md');
-                const waitForReviewFile = (0, path_1.join)(dirPath, 'wait-for-pr-review.md');
-                node_assert_1.default.ok(!(0, fs_1.existsSync)(submitPrFile), `submit-pr should not exist in ${dir} - should only be in shared-phases`);
-                node_assert_1.default.ok(!(0, fs_1.existsSync)(waitForReviewFile), `wait-for-pr-review should not exist in ${dir} - should only be in shared-phases`);
-            }
-        });
-        (0, node_test_1.it)('should have workflow-agnostic shared phase content', () => {
-            const sharedFiles = ['submit-pr.md', 'wait-for-pr-review.md'];
-            for (const file of sharedFiles) {
-                const filePath = (0, path_1.join)(registryPath, 'shared-phases', file);
-                const content = (0, fs_1.readFileSync)(filePath, 'utf8');
-                // Should contain generic workflow references
-                node_assert_1.default.ok(content.includes('{workflow_type}') || content.includes('workflow'), `${file} should reference workflows generically`);
-                // Should not contain workflow-specific content
-                node_assert_1.default.ok(!content.includes('implement-specific'), `${file} should not contain implement-specific content`);
-                node_assert_1.default.ok(!content.includes('spec-specific'), `${file} should not contain spec-specific content`);
-                node_assert_1.default.ok(!content.includes('design-specific'), `${file} should not contain design-specific content`);
-            }
-        });
-    });
-});