agentic-qe 1.0.5 → 1.2.0

package/dist/cli/commands/init.js

@@ -44,7 +44,7 @@ const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 class InitCommand {
     static async execute(options) {
-        console.log(chalk_1.default.blue.bold('\n🚀 Initializing Agentic QE Fleet\n'));
+        console.log(chalk_1.default.blue.bold('\n🚀 Initializing Agentic QE Project (v1.2.0)\n'));
         try {
             // Parse options
             const maxAgents = parseInt(options.maxAgents);
@@ -84,8 +84,9 @@ class InitCommand {
                     timeout: 1800000
                 }
             };
-            // Interactive project setup if needed
-            if (!options.config) {
+            // Interactive project setup if needed (skip if --non-interactive or --yes)
+            const isNonInteractive = options.nonInteractive || options.yes;
+            if (!options.config && !isNonInteractive) {
                 const projectAnswers = await inquirer_1.default.prompt([
                     {
                         type: 'input',
@@ -138,6 +139,34 @@ class InitCommand {
                 if (fleetConfig.streaming) {
                     fleetConfig.streaming.enabled = projectAnswers.enableStreaming;
                 }
+                // Enable Phase 2 features by default (no questions)
+                options.enableLearning = true;
+                options.enablePatterns = true;
+                options.enableImprovement = true;
+            }
+            else {
+                // Non-interactive mode: use defaults or environment variables
+                fleetConfig.project = {
+                    name: process.env.AQE_PROJECT_NAME || path.basename(process.cwd()),
+                    path: process.cwd(),
+                    language: (process.env.AQE_LANGUAGE || 'typescript').toLowerCase()
+                };
+                // Use environment variables or defaults
+                if (fleetConfig.routing) {
+                    fleetConfig.routing.enabled = process.env.AQE_ROUTING_ENABLED === 'true' || false;
+                }
+                if (fleetConfig.streaming) {
+                    fleetConfig.streaming.enabled = process.env.AQE_STREAMING_ENABLED !== 'false';
+                }
+                // Use defaults if non-interactive
+                options.enableLearning = process.env.AQE_LEARNING_ENABLED !== 'false';
+                options.enablePatterns = process.env.AQE_PATTERNS_ENABLED !== 'false';
+                options.enableImprovement = process.env.AQE_IMPROVEMENT_ENABLED !== 'false';
+                console.log(chalk_1.default.gray('  ℹ️  Running in non-interactive mode with defaults'));
+                console.log(chalk_1.default.gray(`  • Project: ${fleetConfig.project.name}`));
+                console.log(chalk_1.default.gray(`  • Language: ${fleetConfig.project.language}`));
+                console.log(chalk_1.default.gray(`  • Routing: ${fleetConfig.routing?.enabled ? 'enabled' : 'disabled'}`));
+                console.log(chalk_1.default.gray(`  • Streaming: ${fleetConfig.streaming?.enabled ? 'enabled' : 'disabled'}`));
             }
             const spinner = (0, ora_1.default)('Setting up fleet infrastructure...').start();
             // Create directory structure
@@ -153,8 +182,28 @@ class InitCommand {
             spinner.text = 'Creating CLAUDE.md documentation...';
             // Create or update CLAUDE.md with agent documentation
             await this.createClaudeMd(fleetConfig);
+            // Initialize Claude Flow coordination
+            await this.initializeCoordination(fleetConfig);
+            // Phase 2: Initialize memory database FIRST (required for agents)
+            spinner.text = 'Initializing memory database...';
+            await this.initializeMemoryDatabase();
+            // Phase 2: Initialize pattern bank database
+            if (options.enablePatterns !== false) {
+                spinner.text = 'Initializing pattern bank database...';
+                await this.initializePatternDatabase(fleetConfig);
+            }
+            // Phase 2: Initialize learning system
+            if (options.enableLearning !== false) {
+                spinner.text = 'Initializing learning system...';
+                await this.initializeLearningSystem(fleetConfig);
+            }
+            // Phase 2: Initialize improvement loop
+            if (options.enableImprovement !== false) {
+                spinner.text = 'Setting up improvement loop...';
+                await this.initializeImprovementLoop(fleetConfig);
+            }
+            // Now spawn agents AFTER databases are initialized
             spinner.text = 'Spawning initial agents...';
-            // Spawn initial fleet agents
             await this.spawnInitialAgents(fleetConfig);
             spinner.succeed(chalk_1.default.green('Fleet initialization completed successfully!'));
             // Display summary
@@ -167,19 +216,25 @@ class InitCommand {
             // Show agent status
             const agentCount = await this.countAgentFiles('.claude/agents');
             console.log(chalk_1.default.gray(`  Agent Definitions: ${agentCount} agents ready`));
-            console.log(chalk_1.default.yellow('\n💡 Next Steps:'));
-            console.log(chalk_1.default.gray('  1. View agents: ls .claude/agents/'));
-            console.log(chalk_1.default.gray('  2. Generate tests: aqe test <module-name>'));
-            console.log(chalk_1.default.gray('  3. Run tests: aqe run tests --parallel'));
-            console.log(chalk_1.default.gray('  4. Monitor fleet: aqe status --verbose'));
-            // Initialize Claude Flow coordination
-            await this.initializeCoordination(fleetConfig);
+            // Create comprehensive config.json
+            spinner.text = 'Creating comprehensive configuration...';
+            await this.createComprehensiveConfig(fleetConfig, {
+                enableLearning: options.enableLearning !== false,
+                enablePatterns: options.enablePatterns !== false,
+                enableImprovement: options.enableImprovement !== false
+            });
+            spinner.succeed(chalk_1.default.green('Project initialization completed successfully!'));
+            // Display comprehensive summary
+            await this.displayComprehensiveSummary(fleetConfig, {
+                enableLearning: options.enableLearning !== false,
+                enablePatterns: options.enablePatterns !== false,
+                enableImprovement: options.enableImprovement !== false
+            });
         }
         catch (error) {
             console.error(chalk_1.default.red('❌ Initialization failed:'), error.message);
-            if (options.verbose) {
-                console.error(chalk_1.default.gray(error.stack));
-            }
+            console.error(chalk_1.default.gray('\nStack trace:'));
+            console.error(chalk_1.default.gray(error.stack));
             process.exit(1);
         }
     }
@@ -189,10 +244,18 @@ class InitCommand {
             '.agentic-qe/config',
             '.agentic-qe/logs',
             '.agentic-qe/data',
+            '.agentic-qe/data/learning', // Phase 2: Learning state
+            '.agentic-qe/data/patterns', // Phase 2: Pattern database
+            '.agentic-qe/data/improvement', // Phase 2: Improvement state
             '.agentic-qe/agents',
             '.agentic-qe/reports',
+            '.agentic-qe/scripts', // For coordination scripts
+            '.agentic-qe/state', // For state management
+            '.agentic-qe/state/coordination', // Coordination state
             '.claude', // For Claude Code integration
             '.claude/agents', // Where agent definitions live
+            '.claude/skills', // Where QE skill definitions live (17 QE skills only)
+            '.claude/commands', // Where AQE slash commands live (8 commands)
             'tests/unit',
             'tests/integration',
             'tests/e2e',
@@ -204,49 +267,109 @@ class InitCommand {
         }
         // Copy agent templates from agentic-qe package
         await this.copyAgentTemplates();
+        // Copy skill templates (only QE Fleet skills, not Claude Flow)
+        await this.copySkillTemplates();
+        // Copy command templates (8 AQE slash commands)
+        await this.copyCommandTemplates();
     }
     static async copyAgentTemplates() {
+        console.log(chalk_1.default.cyan('  🔍 Searching for agent templates...'));
         // Find the agentic-qe package location (handles both npm install and local dev)
         const possiblePaths = [
             path.join(__dirname, '../../../.claude/agents'), // From dist/cli/commands
             path.join(process.cwd(), 'node_modules/agentic-qe/.claude/agents'),
             path.join(process.cwd(), '../agentic-qe/.claude/agents') // Monorepo case
         ];
+        console.log(chalk_1.default.gray('  • Checking paths:'));
         let sourcePath = null;
         for (const p of possiblePaths) {
-            if (await fs.pathExists(p)) {
+            const exists = await fs.pathExists(p);
+            console.log(chalk_1.default.gray(`    ${exists ? '✓' : '✗'} ${p}`));
+            if (exists && !sourcePath) {
                 sourcePath = p;
-                break;
             }
         }
         if (!sourcePath) {
-            console.warn(chalk_1.default.yellow('⚠️  Could not find agent templates, creating basic agents'));
+            console.warn(chalk_1.default.yellow('  ⚠️  No agent templates found in package paths'));
+            console.warn(chalk_1.default.yellow('  ℹ️  Falling back to programmatic generation (all 18 agents)'));
             await this.createBasicAgents();
             return;
         }
-        // Copy all agent definition files
+        console.log(chalk_1.default.green(`  ✓ Found agent templates at: ${sourcePath}`));
+        // Count available templates
+        const availableFiles = await fs.readdir(sourcePath);
+        const templateFiles = availableFiles.filter(f => f.endsWith('.md'));
+        console.log(chalk_1.default.cyan(`  📦 Found ${templateFiles.length} agent templates to copy`));
+        // Copy all agent definition files individually (not directory copy)
         const targetPath = path.join(process.cwd(), '.claude/agents');
-        await fs.copy(sourcePath, targetPath, {
-            overwrite: false, // Don't overwrite existing agent definitions
-            filter: (src) => src.endsWith('.md') // Only copy markdown agent files
-        });
-        console.log(chalk_1.default.green(`✓ Copied ${await this.countAgentFiles(targetPath)} agent definitions`));
+        let copiedFiles = 0;
+        for (const templateFile of templateFiles) {
+            const sourceFile = path.join(sourcePath, templateFile);
+            const targetFile = path.join(targetPath, templateFile);
+            // Only copy if target doesn't exist
+            if (!await fs.pathExists(targetFile)) {
+                await fs.copy(sourceFile, targetFile);
+                copiedFiles++;
+            }
+        }
+        console.log(chalk_1.default.green(`  ✓ Copied ${copiedFiles} new agent definitions`));
+        const copiedCount = await this.countAgentFiles(targetPath);
+        console.log(chalk_1.default.cyan(`  📋 Total agents in target: ${copiedCount}`));
+        // Verify all 18 agents exist (17 QE agents + 1 base template generator)
+        const expectedAgents = 18;
+        if (copiedCount < expectedAgents) {
+            console.warn(chalk_1.default.yellow(`  ⚠️  Expected ${expectedAgents} agents, found ${copiedCount}`));
+            console.warn(chalk_1.default.yellow(`  ℹ️  Creating missing agents programmatically...`));
+            // Get list of files that actually exist in TARGET (not source!)
+            const targetFiles = await fs.readdir(targetPath);
+            const existingTargetFiles = targetFiles.filter(f => f.endsWith('.md'));
+            await this.createMissingAgents(targetPath, existingTargetFiles);
+        }
+        else {
+            console.log(chalk_1.default.green(`  ✓ All ${expectedAgents} agents present and ready`));
+        }
     }
     static async createBasicAgents() {
-        // Fallback: Create basic agent templates if package agents not found
-        const basicAgents = [
-            'qe-test-generator',
-            'qe-test-executor',
-            'qe-coverage-analyzer',
-            'qe-quality-gate',
-            'qe-performance-tester',
-            'qe-security-scanner'
-        ];
-        const targetPath = path.join(process.cwd(), '.claude/agents');
-        for (const agentName of basicAgents) {
-            const agentFile = path.join(targetPath, `${agentName}.md`);
-            const agentType = agentName.replace('qe-', '');
-            const content = `---
+        try {
+            console.log(chalk_1.default.cyan('  🛠️  Creating all agent definitions programmatically...'));
+            // ALL 18 AGENTS (17 QE agents + 1 base template generator)
+            const allAgents = [
+                // Core Testing (5)
+                'qe-test-generator',
+                'qe-test-executor',
+                'qe-coverage-analyzer',
+                'qe-quality-gate',
+                'qe-quality-analyzer',
+                // Performance & Security (2)
+                'qe-performance-tester',
+                'qe-security-scanner',
+                // Strategic Planning (3)
+                'qe-requirements-validator',
+                'qe-production-intelligence',
+                'qe-fleet-commander',
+                // Deployment (1)
+                'qe-deployment-readiness',
+                // Advanced Testing (4)
+                'qe-regression-risk-analyzer',
+                'qe-test-data-architect',
+                'qe-api-contract-validator',
+                'qe-flaky-test-hunter',
+                // Specialized (2)
+                'qe-visual-tester',
+                'qe-chaos-engineer'
+            ];
+            const targetPath = path.join(process.cwd(), '.claude/agents');
+            console.log(chalk_1.default.gray(`  • Creating ${allAgents.length} agent definition files...`));
+            for (const agentName of allAgents) {
+                // Defensive null check
+                if (!agentName || typeof agentName !== 'string') {
+                    console.warn(chalk_1.default.yellow(`⚠️  Skipping invalid agent name: ${agentName}`));
+                    continue;
+                }
+                const agentFile = path.join(targetPath, `${agentName}.md`);
+                const agentType = agentName.replace('qe-', '');
+                const skills = this.getAgentSkills(agentName);
+                const content = `---
 name: ${agentName}
 type: ${agentType}
 color: blue
@@ -254,13 +377,22 @@ priority: medium
 description: "Agentic QE Fleet ${agentType} agent"
 capabilities:
   - ${agentType}
+skills:
+${skills.map(s => `  - ${s}`).join('\n')}
 coordination:
   protocol: aqe-hooks
+learning:
+  enabled: true
+  observability:
+    - agent.getLearningStatus()
+    - agent.getLearnedPatterns()
+    - agent.recommendStrategy(state)
 metadata:
-  version: "1.0.5"
+  version: "1.1.0"
   framework: "agentic-qe"
   routing: "supported"
   streaming: "supported"
+  phase2: "q-learning-enabled"
 ---
 
 # ${agentName.toUpperCase()} Agent
@@ -272,6 +404,68 @@ This agent is part of the Agentic QE Fleet and specializes in ${agentType}.
 - AI-powered ${agentType}
 - Integration with Agentic QE Fleet
 - Native TypeScript coordination
+- **Q-Learning**: Learns from task execution automatically
+- **Pattern Bank**: Uses proven test patterns
+- **Improvement Loop**: Continuously optimizes strategies
+
+## 🧠 Q-Learning Integration (Phase 2)
+
+This agent automatically learns from EVERY task execution through Q-learning integration in \`BaseAgent.onPostTask()\`.
+
+### Observability Methods
+
+\`\`\`typescript
+// 1. Check learning status
+const status = agent.getLearningStatus();
+console.log(status);
+// {
+//   enabled: true,
+//   totalExperiences: 1247,
+//   explorationRate: 0.08,
+//   patterns: 34
+// }
+
+// 2. View learned patterns
+const patterns = agent.getLearnedPatterns();
+console.log(patterns[0]);
+// {
+//   state: { taskComplexity: 'high', ... },
+//   action: 'thorough-deep-analysis',
+//   qValue: 0.8734,
+//   successRate: 0.88
+// }
+
+// 3. Get strategy recommendations
+const recommendation = await agent.recommendStrategy({
+  taskComplexity: 'medium',
+  availableCapabilities: agent.capabilities
+});
+console.log(recommendation);
+// {
+//   action: 'balanced-coverage',
+//   confidence: 0.92,
+//   expectedQValue: 0.7845
+// }
+\`\`\`
+
+### CLI Commands
+
+\`\`\`bash
+# Check learning status
+aqe learn status --agent ${agentName}
+
+# View learned patterns
+aqe learn history --agent ${agentName} --limit 50
+
+# Export learning data
+aqe learn export --agent ${agentName} --output learning.json
+\`\`\`
+
+## Skills
+
+This agent can use the following Claude Code Skills:
+
+${this.getSkillDocumentation(agentName)}
 
 ## Coordination Protocol
 
@@ -402,10 +596,100 @@ for await (const event of agent.execute(params)) {
 }
 \\\`\\\`\\\`
 
+For full capabilities, install the complete agentic-qe package.
+`;
+                await fs.writeFile(agentFile, content);
+                console.log(chalk_1.default.gray(`    ✓ Created ${agentName}.md`));
+            }
+            const finalCount = await this.countAgentFiles(targetPath);
+            console.log(chalk_1.default.green(`  ✓ Successfully created ${finalCount} agent definitions`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('❌ Error in createBasicAgents:'), error.message);
+            console.error(chalk_1.default.gray('Stack trace:'), error.stack);
+            throw error;
+        }
+    }
+    static async createMissingAgents(targetPath, existingFiles) {
+        const allAgentNames = [
+            'qe-test-generator', 'qe-test-executor', 'qe-coverage-analyzer',
+            'qe-quality-gate', 'qe-quality-analyzer', 'qe-performance-tester',
+            'qe-security-scanner', 'qe-requirements-validator', 'qe-production-intelligence',
+            'qe-fleet-commander', 'qe-deployment-readiness', 'qe-regression-risk-analyzer',
+            'qe-test-data-architect', 'qe-api-contract-validator', 'qe-flaky-test-hunter',
+            'qe-visual-tester', 'qe-chaos-engineer'
+        ];
+        const existingAgentNames = existingFiles.map(f => f.replace('.md', ''));
+        const missingAgents = allAgentNames.filter(name => !existingAgentNames.includes(name));
+        if (missingAgents.length === 0) {
+            console.log(chalk_1.default.green('  ✓ No missing agents to create'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`  🛠️  Creating ${missingAgents.length} missing agents:`));
+        for (const agentName of missingAgents) {
+            console.log(chalk_1.default.gray(`    • ${agentName}`));
+        }
+        // Create missing agents using the same logic as createBasicAgents
+        for (const agentName of missingAgents) {
+            const agentFile = path.join(targetPath, `${agentName}.md`);
+            const agentType = agentName.replace('qe-', '');
+            const skills = this.getAgentSkills(agentName);
+            const content = `---
+name: ${agentName}
+type: ${agentType}
+color: blue
+priority: medium
+description: "Agentic QE Fleet ${agentType} agent"
+capabilities:
+  - ${agentType}
+skills:
+${skills.map(s => `  - ${s}`).join('\n')}
+coordination:
+  protocol: aqe-hooks
+learning:
+  enabled: true
+  observability:
+    - agent.getLearningStatus()
+    - agent.getLearnedPatterns()
+    - agent.recommendStrategy(state)
+metadata:
+  version: "1.1.0"
+  framework: "agentic-qe"
+  routing: "supported"
+  streaming: "supported"
+  phase2: "q-learning-enabled"
+---
+
+# ${agentName.toUpperCase()} Agent
+
+## Description
+This agent is part of the Agentic QE Fleet and specializes in ${agentType}.
+
+## Capabilities
+- AI-powered ${agentType}
+- Integration with Agentic QE Fleet
+- Native TypeScript coordination
+- **Q-Learning**: Learns from task execution automatically
+- **Pattern Bank**: Uses proven test patterns
+- **Improvement Loop**: Continuously optimizes strategies
+
+## Skills
+
+This agent can use the following Claude Code Skills:
+
+${this.getSkillDocumentation(agentName)}
+
+## Coordination Protocol
+
+This agent uses **AQE hooks** (Agentic QE native hooks) for coordination (zero external dependencies, 100-500x faster than external hooks).
+
 For full capabilities, install the complete agentic-qe package.
 `;
             await fs.writeFile(agentFile, content);
+            console.log(chalk_1.default.gray(`    ✓ Created ${agentName}.md`));
         }
+        const finalCount = await this.countAgentFiles(targetPath);
+        console.log(chalk_1.default.green(`  ✓ Total agent count: ${finalCount}`));
     }
     static async countAgentFiles(dirPath) {
         if (!await fs.pathExists(dirPath))
@@ -413,17 +697,258 @@ For full capabilities, install the complete agentic-qe package.
         const files = await fs.readdir(dirPath);
         return files.filter(f => f.endsWith('.md')).length;
     }
+    /**
+     * Copy only the 17 QE Fleet skills (filters out Claude Flow skills)
+     */
+    static async copySkillTemplates() {
+        console.log(chalk_1.default.cyan('  🎯 Initializing QE Fleet skills...'));
+        // Define the 17 QE Fleet skills (from SKILLS-MAPPING.md)
+        const QE_FLEET_SKILLS = [
+            // Core Quality Practices (5)
+            'holistic-testing-pact',
+            'context-driven-testing',
+            'agentic-quality-engineering',
+            'exploratory-testing-advanced',
+            'risk-based-testing',
+            // Development Methodologies (3)
+            'tdd-london-chicago',
+            'xp-practices',
+            'refactoring-patterns',
+            // Testing Specializations (4)
+            'api-testing-patterns',
+            'performance-testing',
+            'security-testing',
+            'test-automation-strategy',
+            // Communication & Process (3)
+            'technical-writing',
+            'bug-reporting-excellence',
+            'code-review-quality',
+            // Professional Skills (2)
+            'consultancy-practices',
+            'quality-metrics'
+        ];
+        // Find the agentic-qe package location
+        const possiblePaths = [
+            path.join(__dirname, '../../../.claude/skills'), // From dist/cli/commands
+            path.join(process.cwd(), 'node_modules/agentic-qe/.claude/skills'),
+            path.join(process.cwd(), '../agentic-qe/.claude/skills') // Monorepo case
+        ];
+        console.log(chalk_1.default.gray('  • Checking skill source paths:'));
+        let sourcePath = null;
+        for (const p of possiblePaths) {
+            const exists = await fs.pathExists(p);
+            console.log(chalk_1.default.gray(`    ${exists ? '✓' : '✗'} ${p}`));
+            if (exists && !sourcePath) {
+                sourcePath = p;
+            }
+        }
+        if (!sourcePath) {
+            console.warn(chalk_1.default.yellow('  ⚠️  No skill templates found in package paths'));
+            console.warn(chalk_1.default.yellow('  ℹ️  Skills can be added manually to .claude/skills/'));
+            return;
+        }
+        console.log(chalk_1.default.green(`  ✓ Found skill templates at: ${sourcePath}`));
+        // List all available skills
+        const availableDirs = await fs.readdir(sourcePath);
+        const availableSkills = availableDirs.filter(name => {
+            const skillPath = path.join(sourcePath, name);
+            try {
+                return fs.statSync(skillPath).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        console.log(chalk_1.default.cyan(`  📦 Found ${availableSkills.length} total skills in source`));
+        // Filter to only QE Fleet skills
+        const qeSkillsToConfig = availableSkills.filter(skill => QE_FLEET_SKILLS.includes(skill));
+        console.log(chalk_1.default.cyan(`  🎯 Filtering to ${qeSkillsToConfig.length} QE Fleet skills (excluding Claude Flow skills)`));
+        const targetPath = path.join(process.cwd(), '.claude/skills');
+        let copiedCount = 0;
+        // Copy each QE skill directory
+        for (const skillName of qeSkillsToConfig) {
+            const sourceSkillPath = path.join(sourcePath, skillName);
+            const targetSkillPath = path.join(targetPath, skillName);
+            // Skip if already exists
+            if (await fs.pathExists(targetSkillPath)) {
+                console.log(chalk_1.default.gray(`    • Skipped ${skillName} (already exists)`));
+                continue;
+            }
+            // Copy the entire skill directory
+            await fs.copy(sourceSkillPath, targetSkillPath);
+            copiedCount++;
+            console.log(chalk_1.default.gray(`    ✓ Copied ${skillName}`));
+        }
+        // Final count
+        const finalSkillCount = await this.countSkillDirs(targetPath);
+        if (copiedCount > 0) {
+            console.log(chalk_1.default.green(`  ✓ Copied ${copiedCount} new QE skills`));
+        }
+        else {
+            console.log(chalk_1.default.green('  ✓ All QE skills already present'));
+        }
+        console.log(chalk_1.default.cyan(`  📋 Total QE skills initialized: ${finalSkillCount}`));
+        // Verify we have exactly 17 QE skills
+        if (finalSkillCount === 17) {
+            console.log(chalk_1.default.green('  ✅ All 17 QE Fleet skills successfully initialized'));
+        }
+        else if (finalSkillCount < 17) {
+            console.warn(chalk_1.default.yellow(`  ⚠️  Expected 17 QE skills, found ${finalSkillCount}`));
+            const missingSkills = QE_FLEET_SKILLS.filter(skill => {
+                return !fs.existsSync(path.join(targetPath, skill));
+            });
+            console.warn(chalk_1.default.yellow(`  ℹ️  Missing skills: ${missingSkills.join(', ')}`));
+        }
+    }
+    /**
+     * Count skill directories in .claude/skills
+     */
+    static async countSkillDirs(dirPath) {
+        if (!await fs.pathExists(dirPath))
+            return 0;
+        const items = await fs.readdir(dirPath);
+        let count = 0;
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item);
+            try {
+                if (fs.statSync(itemPath).isDirectory()) {
+                    count++;
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return count;
+    }
+    /**
+     * Copy AQE slash command templates (8 commands)
+     */
+    static async copyCommandTemplates() {
+        console.log(chalk_1.default.cyan('  ⚡ Initializing AQE slash commands...'));
+        // Define the 8 AQE slash commands
+        const AQE_COMMANDS = [
+            'aqe-analyze.md',
+            'aqe-benchmark.md',
+            'aqe-chaos.md',
+            'aqe-execute.md',
+            'aqe-fleet-status.md',
+            'aqe-generate.md',
+            'aqe-optimize.md',
+            'aqe-report.md'
+        ];
+        // Find the agentic-qe package location
+        const possiblePaths = [
+            path.join(__dirname, '../../../.claude/commands'), // From dist/cli/commands
+            path.join(process.cwd(), 'node_modules/agentic-qe/.claude/commands'),
+            path.join(process.cwd(), '../agentic-qe/.claude/commands') // Monorepo case
+        ];
+        console.log(chalk_1.default.gray('  • Checking command source paths:'));
+        let sourcePath = null;
+        for (const p of possiblePaths) {
+            const exists = await fs.pathExists(p);
+            console.log(chalk_1.default.gray(`    ${exists ? '✓' : '✗'} ${p}`));
+            if (exists && !sourcePath) {
+                sourcePath = p;
+            }
+        }
+        if (!sourcePath) {
+            console.warn(chalk_1.default.yellow('  ⚠️  No command templates found in package paths'));
+            console.warn(chalk_1.default.yellow('  ℹ️  Commands can be added manually to .claude/commands/'));
+            return;
+        }
+        console.log(chalk_1.default.green(`  ✓ Found command templates at: ${sourcePath}`));
+        const targetPath = path.join(process.cwd(), '.claude/commands');
+        let copiedCount = 0;
+        // Copy each AQE command file
+        for (const commandFile of AQE_COMMANDS) {
+            const sourceFile = path.join(sourcePath, commandFile);
+            const targetFile = path.join(targetPath, commandFile);
+            // Skip if already exists or if source doesn't exist
+            if (await fs.pathExists(targetFile)) {
+                console.log(chalk_1.default.gray(`    • Skipped ${commandFile} (already exists)`));
+                continue;
+            }
+            if (!await fs.pathExists(sourceFile)) {
+                console.log(chalk_1.default.gray(`    • Skipped ${commandFile} (source not found)`));
+                continue;
+            }
+            // Copy the command file
+            await fs.copy(sourceFile, targetFile);
+            copiedCount++;
+            console.log(chalk_1.default.gray(`    ✓ Copied ${commandFile}`));
+        }
+        // Count final commands
+        const finalCommandCount = await this.countCommandFiles(targetPath);
+        if (copiedCount > 0) {
+            console.log(chalk_1.default.green(`  ✓ Copied ${copiedCount} new AQE commands`));
+        }
+        else {
+            console.log(chalk_1.default.green('  ✓ All AQE commands already present'));
+        }
+        console.log(chalk_1.default.cyan(`  📋 Total AQE commands initialized: ${finalCommandCount}`));
+        // Verify we have all 8 AQE commands
+        if (finalCommandCount >= 8) {
+            console.log(chalk_1.default.green('  ✅ All 8 AQE slash commands successfully initialized'));
+        }
+        else if (finalCommandCount < 8) {
+            console.warn(chalk_1.default.yellow(`  ⚠️  Expected 8 AQE commands, found ${finalCommandCount}`));
+        }
+    }
+    /**
+     * Count command files in .claude/commands
+     */
+    static async countCommandFiles(dirPath) {
+        if (!await fs.pathExists(dirPath))
+            return 0;
+        const items = await fs.readdir(dirPath);
+        return items.filter(f => f.startsWith('aqe-') && f.endsWith('.md')).length;
+    }
     static async writeFleetConfig(config) {
+        console.log(chalk_1.default.cyan('  📝 Writing fleet configuration...'));
+        // Sanitize config to remove undefined values that cause jsonfile errors
+        const sanitizedConfig = this.sanitizeConfig(config);
         const configPath = '.agentic-qe/config/fleet.json';
-        await fs.writeJson(configPath, config, { spaces: 2 });
+        await fs.writeJson(configPath, sanitizedConfig, { spaces: 2 });
+        console.log(chalk_1.default.gray(`    ✓ Wrote ${configPath}`));
         // Create agent configurations
-        const agentConfigs = this.generateAgentConfigs(config);
+        const agentConfigs = this.sanitizeConfig(this.generateAgentConfigs(config));
         await fs.writeJson('.agentic-qe/config/agents.json', agentConfigs, { spaces: 2 });
+        console.log(chalk_1.default.gray(`    ✓ Wrote .agentic-qe/config/agents.json`));
         // Create environment configurations
-        const envConfigs = this.generateEnvironmentConfigs(config.environments || []);
+        const envConfigs = this.sanitizeConfig(this.generateEnvironmentConfigs(config.environments || []));
         await fs.writeJson('.agentic-qe/config/environments.json', envConfigs, { spaces: 2 });
+        console.log(chalk_1.default.gray(`    ✓ Wrote .agentic-qe/config/environments.json`));
         // Create routing configuration (Phase 1 - v1.0.5)
         await this.writeRoutingConfig(config);
+        console.log(chalk_1.default.green('  ✓ Fleet configuration complete'));
+    }
+    /**
+     * Sanitize config object by removing undefined values and ensuring all properties are serializable
+     */
+    static sanitizeConfig(obj) {
+        if (obj === null || obj === undefined) {
+            return null;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.sanitizeConfig(item)).filter(item => item !== null && item !== undefined);
+        }
+        if (typeof obj === 'object') {
+            const sanitized = {};
+            for (const [key, value] of Object.entries(obj)) {
+                // Skip undefined values
+                if (value === undefined) {
+                    continue;
+                }
+                // Recursively sanitize nested objects
+                const sanitizedValue = this.sanitizeConfig(value);
+                if (sanitizedValue !== null && sanitizedValue !== undefined) {
+                    sanitized[key] = sanitizedValue;
+                }
+            }
+            return sanitized;
+        }
+        return obj;
     }
     static async writeRoutingConfig(config) {
         const routingConfig = {
@@ -527,6 +1052,7 @@ For full capabilities, install the complete agentic-qe package.
                     alerts: env === 'production'
                 }
             };
+            return configs;
         }, {});
     }
     static async setupClaudeFlowIntegration(config) {
@@ -576,6 +1102,9 @@ For full capabilities, install the complete agentic-qe package.
         await fs.writeJson('.agentic-qe/data/registry.json', agentRegistry, { spaces: 2 });
     }
     static async initializeCoordination(config) {
+        // Ensure config has required properties
+        const topology = config.topology || 'hierarchical';
+        const maxAgents = config.maxAgents || 10;
         // Create pre-execution coordination script (AQE native)
         const preExecutionScript = `#!/bin/bash
 # Agentic QE Fleet Pre-Execution Coordination
@@ -585,7 +1114,7 @@ For full capabilities, install the complete agentic-qe package.
 agentic-qe fleet status --json > /tmp/aqe-fleet-status-pre.json 2>/dev/null || true
 
 # Log coordination event
-echo "[AQE] Pre-execution coordination: Fleet topology=${config.topology}, Max agents=${config.maxAgents}" >> .agentic-qe/logs/coordination.log
+echo "[AQE] Pre-execution coordination: Fleet topology=${topology}, Max agents=${maxAgents}" >> .agentic-qe/logs/coordination.log
 
 # Store fleet config in coordination memory (via file-based state)
 mkdir -p .agentic-qe/state/coordination
@@ -879,9 +1408,106 @@ for await (const event of handler.execute(params)) {
 - ⚠️  Test generation (coming in v1.1.0)
 - ⚠️  Security scanning (coming in v1.1.0)
 
+## 🎯 Claude Code Skills Integration
+
+This fleet includes **17 specialized QE skills** that agents can use:
+
+### Quality Engineering Skills (10 skills)
+- **agentic-quality-engineering**: Using AI agents as force multipliers in quality work - autonomous testing systems, PACT principles, scaling quality engineering with intelligent agents
+- **api-testing-patterns**: Comprehensive API testing patterns including contract testing, REST/GraphQL testing, and integration testing
+- **bug-reporting-excellence**: Write high-quality bug reports that get fixed quickly - includes templates, examples, and best practices
+- **context-driven-testing**: Apply context-driven testing principles where practices are chosen based on project context, not universal "best practices"
+- **exploratory-testing-advanced**: Advanced exploratory testing techniques with Session-Based Test Management (SBTM), RST heuristics, and test tours
+- **holistic-testing-pact**: Apply the Holistic Testing Model evolved with PACT (Proactive, Autonomous, Collaborative, Targeted) principles
+- **tdd-london-chicago**: Apply both London and Chicago school TDD approaches - understanding different TDD philosophies and choosing the right testing style
+- **pair-programming**: AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring
+- **verification-quality**: Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold
+- **xp-practices**: Apply XP practices including pair programming, ensemble programming, continuous integration, and sustainable pace
+
+### AgentDB Skills (5 skills)
+- **agentdb-advanced**: Master advanced AgentDB features including QUIC synchronization, multi-database management, custom distance metrics, hybrid search
+- **agentdb-learning**: Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms (Decision Transformer, Q-Learning, SARSA, Actor-Critic)
+- **agentdb-memory-patterns**: Implement persistent memory patterns for AI agents using AgentDB (session memory, long-term storage, pattern learning)
+- **agentdb-optimization**: Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching
+- **agentdb-vector-search**: Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying
+
+### Using Skills
+
+#### Via CLI
+\\\`\\\`\\\`bash
+# List all available skills
+aqe skills list
+
+# Search for specific skills
+aqe skills search "testing"
+
+# Show skill details
+aqe skills show agentic-quality-engineering
+
+# Show skill statistics
+aqe skills stats
+\\\`\\\`\\\`
+
+#### Via Skill Tool in Claude Code
+\\\`\\\`\\\`javascript
+// Execute a skill
+Skill("agentic-quality-engineering")
+Skill("tdd-london-chicago")
+Skill("api-testing-patterns")
+\\\`\\\`\\\`
+
+#### Integration with Agents
+All QE agents automatically have access to relevant skills based on their specialization:
+- **Test generators** use: agentic-quality-engineering, api-testing-patterns, tdd-london-chicago
+- **Coverage analyzers** use: agentic-quality-engineering, quality-metrics, risk-based-testing
+- **Flaky test hunters** use: agentic-quality-engineering, exploratory-testing-advanced
+- **Performance testers** use: agentic-quality-engineering, performance-testing, quality-metrics
+- **Security scanners** use: agentic-quality-engineering, security-testing, risk-based-testing
+
+## 🧠 Q-Learning Integration (Phase 2)
+
+All agents automatically learn from task execution through Q-learning:
+
+### Observability
+\\\`\\\`\\\`bash
+# Check learning status
+aqe learn status --agent test-gen
+
+# View learned patterns
+aqe learn history --agent test-gen --limit 50
+
+# Export learning data
+aqe learn export --agent test-gen --output learning.json
+\\\`\\\`\\\`
+
+### Pattern Management
+\\\`\\\`\\\`bash
+# List test patterns
+aqe patterns list --framework jest
+
+# Search patterns
+aqe patterns search "api validation"
+
+# Extract patterns from tests
+aqe patterns extract ./tests --framework jest
+\\\`\\\`\\\`
+
+### Improvement Loop
+\\\`\\\`\\\`bash
+# Start continuous improvement
+aqe improve start
+
+# Check improvement status
+aqe improve status
+
+# Run single improvement cycle
+aqe improve cycle
+\\\`\\\`\\\`
+
 ## 📚 Documentation
 
 - **Agent Definitions**: \\\`.claude/agents/\\\` - ${agentCount} specialized QE agents
+- **Skills**: \\\`.claude/skills/\\\` - 17 specialized QE skills for agents
 - **Fleet Config**: \\\`.agentic-qe/config/fleet.json\\\`
 - **Routing Config**: \\\`.agentic-qe/config/routing.json\\\` (Multi-Model Router settings)
 - **AQE Hooks Config**: \\\`.agentic-qe/config/aqe-hooks.json\\\` (zero dependencies, 100-500x faster)
@@ -949,6 +1575,465 @@ tail -f .agentic-qe/logs/fleet.log
 `;
         await fs.writeFile(claudeMdPath, claudeMdContent);
     }
+    // ============================================================================
+    // Phase 2 Initialization Methods (v1.1.0)
+    // ============================================================================
+    /**
+     * Initialize Phase 2 Pattern Bank Database
+     */
+    static async initializePatternDatabase(config) {
+        const Database = (await Promise.resolve().then(() => __importStar(require('better-sqlite3')))).default;
+        const dbPath = path.join(process.cwd(), '.agentic-qe', 'patterns.db');
+        console.log(chalk_1.default.cyan('  📦 Initializing Pattern Bank database...'));
+        const db = new Database(dbPath);
+        // Enable WAL mode for better concurrency
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        db.pragma('cache_size = -64000'); // 64MB cache
+        // Read and execute the schema
+        const schemaPath = path.join(__dirname, '../../../docs/architecture/REASONING-BANK-SCHEMA.sql');
+        let schema;
+        if (await fs.pathExists(schemaPath)) {
+            schema = await fs.readFile(schemaPath, 'utf-8');
+        }
+        else {
+            // Fallback: inline schema if file not found
+            schema = this.getPatternBankSchema();
+        }
+        // Execute schema
+        db.exec(schema);
+        db.close();
+        console.log(chalk_1.default.green('  ✓ Pattern Bank initialized'));
+        console.log(chalk_1.default.gray(`    • Database: ${dbPath}`));
+        console.log(chalk_1.default.gray(`    • Framework: ${config.frameworks?.[0] || 'jest'}`));
+        console.log(chalk_1.default.gray(`    • Tables: test_patterns, pattern_usage, cross_project_mappings, pattern_similarity_index`));
+        console.log(chalk_1.default.gray(`    • Full-text search: enabled`));
+    }
+    /**
+     * Initialize Phase 2 Memory Database (SwarmMemoryManager)
+     */
+    static async initializeMemoryDatabase() {
+        const dbPath = path.join(process.cwd(), '.agentic-qe', 'memory.db');
+        console.log(chalk_1.default.cyan('  💾 Initializing Memory Manager database...'));
+        // Import SwarmMemoryManager dynamically
+        const { SwarmMemoryManager } = await Promise.resolve().then(() => __importStar(require('../../core/memory/SwarmMemoryManager')));
+        const memoryManager = new SwarmMemoryManager(dbPath);
+        await memoryManager.initialize();
+        // Verify tables created
+        const stats = await memoryManager.stats();
+        await memoryManager.close();
+        console.log(chalk_1.default.green('  ✓ Memory Manager initialized'));
+        console.log(chalk_1.default.gray(`    • Database: ${dbPath}`));
+        console.log(chalk_1.default.gray(`    • Tables: 12 tables (memory_entries, hints, events, workflow_state, patterns, etc.)`));
+        console.log(chalk_1.default.gray(`    • Access control: 5 levels (private, team, swarm, public, system)`));
+    }
+    /**
+     * Initialize Phase 2 Learning System
+     */
+    static async initializeLearningSystem(config) {
+        const learningConfig = {
+            enabled: true,
+            learningRate: 0.1,
+            discountFactor: 0.95,
+            explorationRate: 0.2,
+            explorationDecay: 0.995,
+            minExplorationRate: 0.01,
+            targetImprovement: 0.20, // 20% improvement goal
+            maxMemorySize: 100 * 1024 * 1024, // 100MB
+            batchSize: 32,
+            updateFrequency: 10,
+            replayBufferSize: 10000
+        };
+        // Store learning configuration
+        await fs.writeJson('.agentic-qe/config/learning.json', learningConfig, { spaces: 2 });
+        // Create learning database directory
+        await fs.ensureDir('.agentic-qe/data/learning');
+        // Create learning state placeholder
+        const learningState = {
+            initialized: true,
+            version: '1.1.0',
+            createdAt: new Date().toISOString(),
+            agents: {} // Will be populated as agents learn
+        };
+        await fs.writeJson('.agentic-qe/data/learning/state.json', learningState, { spaces: 2 });
+        console.log(chalk_1.default.green('  ✓ Learning system initialized'));
+        console.log(chalk_1.default.gray(`    • Q-learning algorithm (lr=${learningConfig.learningRate}, γ=${learningConfig.discountFactor})`));
+        console.log(chalk_1.default.gray(`    • Experience replay buffer: ${learningConfig.replayBufferSize} experiences`));
+        console.log(chalk_1.default.gray(`    • Target improvement: ${learningConfig.targetImprovement * 100}%`));
+    }
+    /**
+     * Get inline Pattern Bank schema (fallback if schema file not found)
+     */
+    static getPatternBankSchema() {
+        return `
+-- Enable WAL mode for better concurrent access
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+
+-- Core Pattern Storage
+CREATE TABLE IF NOT EXISTS test_patterns (
+    id TEXT PRIMARY KEY NOT NULL,
+    pattern_type TEXT NOT NULL,
+    framework TEXT NOT NULL,
+    language TEXT NOT NULL DEFAULT 'typescript',
+    code_signature_hash TEXT NOT NULL,
+    code_signature JSON NOT NULL,
+    test_template JSON NOT NULL,
+    metadata JSON NOT NULL,
+    version TEXT NOT NULL DEFAULT '1.0.0',
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    CHECK(pattern_type IN ('edge-case', 'integration', 'boundary', 'error-handling', 'unit', 'e2e', 'performance', 'security')),
+    CHECK(framework IN ('jest', 'mocha', 'cypress', 'vitest', 'playwright', 'ava', 'jasmine')),
+    CHECK(json_valid(code_signature)),
+    CHECK(json_valid(test_template)),
+    CHECK(json_valid(metadata))
+);
+
+CREATE INDEX IF NOT EXISTS idx_patterns_framework_type ON test_patterns(framework, pattern_type);
+CREATE INDEX IF NOT EXISTS idx_patterns_signature_hash ON test_patterns(code_signature_hash);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_patterns_dedup ON test_patterns(code_signature_hash, framework);
+
+-- Pattern Usage Tracking
+CREATE TABLE IF NOT EXISTS pattern_usage (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pattern_id TEXT NOT NULL,
+    project_id TEXT NOT NULL,
+    usage_count INTEGER NOT NULL DEFAULT 0,
+    success_count INTEGER NOT NULL DEFAULT 0,
+    failure_count INTEGER NOT NULL DEFAULT 0,
+    avg_execution_time REAL NOT NULL DEFAULT 0.0,
+    avg_coverage_gain REAL NOT NULL DEFAULT 0.0,
+    flaky_count INTEGER NOT NULL DEFAULT 0,
+    quality_score REAL NOT NULL DEFAULT 0.0,
+    first_used TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    last_used TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (pattern_id) REFERENCES test_patterns(id) ON DELETE CASCADE,
+    UNIQUE(pattern_id, project_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_usage_pattern ON pattern_usage(pattern_id);
+CREATE INDEX IF NOT EXISTS idx_usage_quality ON pattern_usage(quality_score DESC);
+
+-- Cross-Project Pattern Sharing
+CREATE TABLE IF NOT EXISTS cross_project_mappings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pattern_id TEXT NOT NULL,
+    source_framework TEXT NOT NULL,
+    target_framework TEXT NOT NULL,
+    transformation_rules JSON NOT NULL,
+    compatibility_score REAL NOT NULL DEFAULT 1.0,
+    project_count INTEGER NOT NULL DEFAULT 0,
+    success_rate REAL NOT NULL DEFAULT 0.0,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (pattern_id) REFERENCES test_patterns(id) ON DELETE CASCADE,
+    UNIQUE(pattern_id, source_framework, target_framework),
+    CHECK(json_valid(transformation_rules))
+);
+
+-- Pattern Similarity Index
+CREATE TABLE IF NOT EXISTS pattern_similarity_index (
+    pattern_a TEXT NOT NULL,
+    pattern_b TEXT NOT NULL,
+    similarity_score REAL NOT NULL,
+    structure_similarity REAL NOT NULL,
+    identifier_similarity REAL NOT NULL,
+    metadata_similarity REAL NOT NULL,
+    algorithm TEXT NOT NULL DEFAULT 'hybrid-tfidf',
+    last_computed TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (pattern_a, pattern_b),
+    FOREIGN KEY (pattern_a) REFERENCES test_patterns(id) ON DELETE CASCADE,
+    FOREIGN KEY (pattern_b) REFERENCES test_patterns(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_similarity_score ON pattern_similarity_index(similarity_score DESC);
+
+-- Full-Text Search
+CREATE VIRTUAL TABLE IF NOT EXISTS pattern_fts USING fts5(
+    pattern_id UNINDEXED,
+    pattern_name,
+    description,
+    tags,
+    framework,
+    pattern_type,
+    content='',
+    tokenize='porter ascii'
+);
+
+-- Schema Version
+CREATE TABLE IF NOT EXISTS schema_version (
+    version TEXT PRIMARY KEY,
+    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    description TEXT
+);
+
+INSERT OR IGNORE INTO schema_version (version, description)
+VALUES ('1.1.0', 'Initial QE ReasoningBank schema');
+`;
+    }
+    /**
+     * Initialize Phase 2 Improvement Loop
+     */
+    static async initializeImprovementLoop(config) {
+        const improvementConfig = {
+            enabled: true,
+            intervalMs: 3600000, // 1 hour
+            autoApply: false, // Requires user approval
+            enableABTesting: true,
+            strategies: {
+                parallelExecution: { enabled: true, weight: 0.8 },
+                adaptiveRetry: { enabled: true, maxRetries: 3 },
+                resourceOptimization: { enabled: true, adaptive: true }
+            },
+            thresholds: {
+                minImprovement: 0.05, // 5% minimum improvement to apply
+                maxFailureRate: 0.1, // 10% max failure rate
+                minConfidence: 0.8 // 80% confidence required
+            },
+            abTesting: {
+                sampleSize: 100,
+                significanceLevel: 0.05,
+                minSampleDuration: 3600000 // 1 hour
+            }
+        };
+        // Store improvement configuration
+        await fs.writeJson('.agentic-qe/config/improvement.json', improvementConfig, { spaces: 2 });
+        // Create improvement state
+        const improvementState = {
+            version: '1.1.0',
+            lastCycle: null,
+            activeCycles: 0,
+            totalImprovement: 0,
+            strategies: {}
+        };
+        await fs.writeJson('.agentic-qe/data/improvement/state.json', improvementState, { spaces: 2 });
+        console.log(chalk_1.default.green('  ✓ Improvement loop initialized'));
+        console.log(chalk_1.default.gray(`    • Cycle interval: ${improvementConfig.intervalMs / 3600000} hour(s)`));
+        console.log(chalk_1.default.gray(`    • A/B testing: enabled (sample size: ${improvementConfig.abTesting.sampleSize})`));
+        console.log(chalk_1.default.gray(`    • Auto-apply: ${improvementConfig.autoApply ? 'enabled' : 'disabled (requires approval)'}`));
+    }
+    /**
+     * Create comprehensive config.json with all Phase 1 and Phase 2 settings
+     */
+    static async createComprehensiveConfig(fleetConfig, options) {
+        const comprehensiveConfig = {
+            version: '1.1.0',
+            initialized: new Date().toISOString(),
+            // Phase 1: Multi-Model Router
+            phase1: {
+                routing: {
+                    enabled: fleetConfig.routing?.enabled || false,
+                    defaultModel: fleetConfig.routing?.defaultModel || 'claude-sonnet-4.5',
+                    costTracking: fleetConfig.routing?.enableCostTracking !== false,
+                    fallback: fleetConfig.routing?.enableFallback !== false,
+                    maxRetries: fleetConfig.routing?.maxRetries || 3,
+                    modelPreferences: {
+                        simple: 'gpt-3.5-turbo',
+                        medium: 'claude-haiku',
+                        complex: 'claude-sonnet-4.5',
+                        critical: 'gpt-4'
+                    },
+                    budgets: {
+                        daily: 50,
+                        monthly: 1000
+                    }
+                },
+                streaming: {
+                    enabled: fleetConfig.streaming?.enabled !== false,
+                    progressInterval: fleetConfig.streaming?.progressInterval || 2000,
+                    bufferEvents: fleetConfig.streaming?.bufferEvents || false,
+                    timeout: fleetConfig.streaming?.timeout || 1800000
+                }
+            },
+            // Phase 2: Learning, Patterns, and Improvement
+            phase2: {
+                learning: {
+                    enabled: options.enableLearning,
+                    learningRate: 0.1,
+                    discountFactor: 0.95,
+                    explorationRate: 0.2,
+                    targetImprovement: 0.20
+                },
+                patterns: {
+                    enabled: options.enablePatterns,
+                    dbPath: '.agentic-qe/data/patterns.db',
+                    minConfidence: 0.85,
+                    enableExtraction: true
+                },
+                improvement: {
+                    enabled: options.enableImprovement,
+                    intervalMs: 3600000,
+                    autoApply: false,
+                    enableABTesting: true
+                }
+            },
+            // Agent configurations
+            agents: {
+                testGenerator: {
+                    enablePatterns: options.enablePatterns,
+                    enableLearning: options.enableLearning
+                },
+                coverageAnalyzer: {
+                    enableLearning: options.enableLearning,
+                    targetImprovement: 0.20
+                },
+                flakyTestHunter: {
+                    enableML: true,
+                    enableLearning: options.enableLearning
+                },
+                defaultAgents: {
+                    enableLearning: options.enableLearning
+                }
+            },
+            // Fleet configuration
+            fleet: {
+                topology: fleetConfig.topology || 'hierarchical',
+                maxAgents: fleetConfig.maxAgents || 10,
+                testingFocus: fleetConfig.testingFocus || [],
+                environments: fleetConfig.environments || [],
+                frameworks: fleetConfig.frameworks || ['jest']
+            }
+        };
+        await fs.writeJson('.agentic-qe/config.json', comprehensiveConfig, { spaces: 2 });
+        console.log(chalk_1.default.green('  ✓ Comprehensive configuration created'));
+        console.log(chalk_1.default.gray(`    • Config file: .agentic-qe/config.json`));
+    }
+    /**
+     * Display comprehensive initialization summary
+     */
+    static async displayComprehensiveSummary(fleetConfig, options) {
+        console.log(chalk_1.default.yellow('\n📊 Initialization Summary:\n'));
+        // Multi-Model Router Summary
+        console.log(chalk_1.default.cyan('Multi-Model Router'));
+        console.log(chalk_1.default.gray(`  Status: ${fleetConfig.routing?.enabled ? '✅ Enabled' : '⚠️  Disabled (opt-in)'}`));
+        if (fleetConfig.routing?.enabled) {
+            console.log(chalk_1.default.gray('  • Cost optimization: 70-81% savings'));
+            console.log(chalk_1.default.gray('  • Fallback chains: enabled'));
+            console.log(chalk_1.default.gray('  • Budget tracking: daily $50, monthly $1000'));
+        }
+        console.log(chalk_1.default.cyan('\nStreaming'));
+        console.log(chalk_1.default.gray(`  Status: ${fleetConfig.streaming?.enabled !== false ? '✅ Enabled' : '⚠️  Disabled'}`));
+        console.log(chalk_1.default.gray('  • Real-time progress updates'));
+        console.log(chalk_1.default.gray('  • for-await-of compatible'));
+        // Learning System Summary
+        console.log(chalk_1.default.cyan('\nLearning System'));
+        console.log(chalk_1.default.gray(`  Status: ${options.enableLearning ? '✅ Enabled' : '⚠️  Disabled'}`));
+        if (options.enableLearning) {
+            console.log(chalk_1.default.gray('  • Q-learning (lr=0.1, γ=0.95)'));
+            console.log(chalk_1.default.gray('  • Experience replay (10,000 buffer)'));
+            console.log(chalk_1.default.gray('  • Target: 20% improvement'));
+        }
+        console.log(chalk_1.default.cyan('\nPattern Bank'));
+        console.log(chalk_1.default.gray(`  Status: ${options.enablePatterns ? '✅ Enabled' : '⚠️  Disabled'}`));
+        if (options.enablePatterns) {
+            console.log(chalk_1.default.gray('  • Pattern extraction: enabled'));
+            console.log(chalk_1.default.gray('  • Confidence threshold: 85%'));
+            console.log(chalk_1.default.gray('  • Template generation: enabled'));
+        }
+        console.log(chalk_1.default.cyan('\nImprovement Loop'));
+        console.log(chalk_1.default.gray(`  Status: ${options.enableImprovement ? '✅ Enabled' : '⚠️  Disabled'}`));
+        if (options.enableImprovement) {
+            console.log(chalk_1.default.gray('  • Cycle: 1 hour intervals'));
+            console.log(chalk_1.default.gray('  • A/B testing: enabled'));
+            console.log(chalk_1.default.gray('  • Auto-apply: OFF (requires approval)'));
+        }
+        // Agent Configuration
+        console.log(chalk_1.default.cyan('\nAgent Configuration:'));
+        console.log(chalk_1.default.gray('  • TestGeneratorAgent: Patterns + Learning'));
+        console.log(chalk_1.default.gray('  • CoverageAnalyzerAgent: Learning + 20% target'));
+        console.log(chalk_1.default.gray('  • FlakyTestHunterAgent: ML + Learning'));
+        console.log(chalk_1.default.gray('  • All agents: Learning enabled (opt-in)'));
+        // Fleet Configuration
+        console.log(chalk_1.default.cyan('\nFleet Configuration:'));
+        console.log(chalk_1.default.gray(`  Topology: ${fleetConfig.topology}`));
+        console.log(chalk_1.default.gray(`  Max Agents: ${fleetConfig.maxAgents}`));
+        console.log(chalk_1.default.gray(`  Frameworks: ${(fleetConfig.frameworks || ['jest']).join(', ')}`));
+        // Next Steps
+        console.log(chalk_1.default.yellow('\n💡 Next Steps:\n'));
+        console.log(chalk_1.default.gray('  1. Review configuration: .agentic-qe/config.json'));
+        console.log(chalk_1.default.gray('  2. Generate tests: aqe test generate src/'));
+        if (options.enableLearning) {
+            console.log(chalk_1.default.gray('  3. Check learning status: aqe learn status'));
+        }
+        if (fleetConfig.routing?.enabled) {
+            console.log(chalk_1.default.gray('  4. View routing dashboard: aqe routing dashboard'));
+        }
+        if (options.enablePatterns) {
+            console.log(chalk_1.default.gray('  5. List patterns: aqe patterns list'));
+        }
+        if (options.enableImprovement) {
+            console.log(chalk_1.default.gray('  6. Start improvement loop: aqe improve start'));
+        }
+        // Documentation
+        console.log(chalk_1.default.yellow('\n📚 Documentation:\n'));
+        console.log(chalk_1.default.gray('  • Getting Started: docs/GETTING-STARTED.md'));
+        if (options.enableLearning) {
+            console.log(chalk_1.default.gray('  • Learning System: docs/guides/LEARNING-SYSTEM-USER-GUIDE.md'));
+        }
+        if (options.enablePatterns) {
+            console.log(chalk_1.default.gray('  • Pattern Management: docs/guides/PATTERN-MANAGEMENT-USER-GUIDE.md'));
+        }
+        if (fleetConfig.routing?.enabled) {
+            console.log(chalk_1.default.gray('  • Cost Optimization: docs/guides/COST-OPTIMIZATION-GUIDE.md'));
+        }
+        // Performance Tips
+        console.log(chalk_1.default.yellow('\n⚡ Performance Tips:\n'));
+        console.log(chalk_1.default.gray('  • Learning improves over time (20% target in 100 tasks)'));
+        console.log(chalk_1.default.gray('  • Patterns increase test quality (85% confidence threshold)'));
+        if (fleetConfig.routing?.enabled) {
+            console.log(chalk_1.default.gray('  • Routing saves 70-81% on AI costs'));
+        }
+        console.log(chalk_1.default.gray('  • Improvement loop optimizes continuously (1 hour cycles)'));
+        console.log('');
+    }
+    /**
+     * Get relevant skills for an agent
+     */
+    static getAgentSkills(agentName) {
+        const skillMap = {
+            'qe-test-generator': ['agentic-quality-engineering', 'api-testing-patterns', 'tdd-london-chicago', 'test-automation-strategy'],
+            'qe-coverage-analyzer': ['agentic-quality-engineering', 'quality-metrics', 'risk-based-testing'],
+            'qe-flaky-test-hunter': ['agentic-quality-engineering', 'exploratory-testing-advanced', 'risk-based-testing'],
+            'qe-performance-tester': ['agentic-quality-engineering', 'performance-testing', 'quality-metrics'],
+            'qe-security-scanner': ['agentic-quality-engineering', 'security-testing', 'risk-based-testing'],
+            'qe-quality-gate': ['agentic-quality-engineering', 'quality-metrics', 'risk-based-testing'],
+            'qe-api-contract-validator': ['agentic-quality-engineering', 'api-testing-patterns'],
+            'qe-test-executor': ['agentic-quality-engineering', 'test-automation-strategy'],
+            'qe-requirements-validator': ['agentic-quality-engineering', 'context-driven-testing'],
+            'qe-quality-analyzer': ['agentic-quality-engineering', 'quality-metrics'],
+            'qe-visual-tester': ['agentic-quality-engineering', 'exploratory-testing-advanced'],
+            'qe-chaos-engineer': ['agentic-quality-engineering', 'risk-based-testing'],
+            'qe-production-intelligence': ['agentic-quality-engineering', 'context-driven-testing'],
+            'qe-fleet-commander': ['agentic-quality-engineering'],
+            'qe-deployment-readiness': ['agentic-quality-engineering', 'risk-based-testing', 'quality-metrics'],
+            'qe-regression-risk-analyzer': ['agentic-quality-engineering', 'risk-based-testing'],
+            'qe-test-data-architect': ['agentic-quality-engineering', 'test-automation-strategy']
+        };
+        return skillMap[agentName] || ['agentic-quality-engineering'];
+    }
+    /**
+     * Get skill documentation for agent
+     */
+    static getSkillDocumentation(agentName) {
+        const skills = this.getAgentSkills(agentName);
+        const skillDescriptions = {
+            'agentic-quality-engineering': 'AI agents as force multipliers in quality work (PACT principles)',
+            'api-testing-patterns': 'REST, GraphQL, contract testing patterns',
+            'tdd-london-chicago': 'Both TDD schools, when to use each approach',
+            'test-automation-strategy': 'When/how to automate effectively',
+            'quality-metrics': 'Meaningful metrics vs vanity metrics',
+            'risk-based-testing': 'Focus testing where failure hurts most',
+            'exploratory-testing-advanced': 'RST heuristics, SBTM, test tours',
+            'performance-testing': 'Load, stress, soak testing strategies',
+            'security-testing': 'OWASP Top 10, vulnerability patterns',
+            'context-driven-testing': 'RST techniques and contextual best practices'
+        };
+        return skills.map(skill => {
+            const description = skillDescriptions[skill] || 'Quality engineering expertise';
+            return `- **${skill}**: ${description}`;
+        }).join('\n');
+    }
 }
 exports.InitCommand = InitCommand;
 //# sourceMappingURL=init.js.map