fraim-framework 2.0.44 → 2.0.45

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

@@ -0,0 +1,328 @@
+"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-completeness-review'));
+            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: 'wait-for-pr-review',
+                status: 'complete',
+                issueNumber: '123',
+                evidence: { issueType: 'feature', prApproved: 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

@@ -0,0 +1,264 @@
+"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`);
+            }
+        });
+    });
+});