claude-flow-novice 2.14.15 → 2.14.17

package/claude-assets/commands/cfn-loop-cli.md

@@ -15,7 +15,7 @@ Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task too
 ## What is CLI Mode?
 
 **CLI Mode Architecture v3.0 (Enhanced):**
-- Main Chat spawns **single coordinator agent** via Task()
+- Main Chat spawns **single coordinator agent**
 - Enhanced coordinator spawns **all workers via CLI** with protocol compliance
 - CLI agents use **Z.ai custom routing** (when enabled)
 - **Real-time monitoring** with automatic recovery from stuck agents
@@ -77,59 +77,16 @@ Savings: 64% with custom routing, 95-98% vs all-Task
 | Standard | ≥0.75 | ≥0.90 | 10 | 3-4 | Production features |
 | Enterprise | ≥0.85 | ≥0.95 | 15 | 5 | Security, compliance, critical systems |
 
-## 🚨 CRITICAL EXECUTION INSTRUCTIONS
+## How CLI Mode Works
 
-**THIS IS A SLASH COMMAND - MAIN CHAT EXECUTES THIS DIRECTLY**
+1. **Main Chat** spawns a single `cfn-v3-coordinator` agent
+2. **Coordinator** orchestrates the entire CFN Loop workflow
+3. **Loop 3** agents implement the solution and validate against quality gates
+4. **Loop 2** agents review and provide validation feedback
+5. **Product Owner** makes the final decision on deliverables
+6. **Background execution** with Redis coordination for scalability
 
-**DO NOT manually spawn Task() agents for CFN Loop workflows**
-**DO NOT spawn cfn-v3-coordinator manually**
-**DO NOT spawn Loop 3 agents (backend-dev, researcher, etc.)**
-**DO NOT spawn Loop 2 agents (reviewer, tester, etc.)**
-**DO NOT spawn product-owner**
-
-**Main Chat simply executes the slash command - everything else is automatic**
-
----
-
-## How This Command Works:
-
-When Main Chat executes `/cfn-loop-cli "task description"`, this slash command:
-
-1. **Automatically spawns cfn-v3-coordinator** with proper parameters
-2. **Coordinator invokes enhanced orchestrator** with monitoring v3.0
-3. **Orchestrator spawns all agents via CLI** (background execution)
-4. **Handles complete CFN Loop workflow** with real-time monitoring
-5. **Returns structured result** to Main Chat when complete
-
-## Enhanced Features v3.0:
-
-- ✅ **Real-time monitoring** with automatic stuck agent recovery
-- ✅ **Process health checking** and dead process cleanup
-- ✅ **Protocol compliance** preventing "consensus on vapor" anti-patterns
-- ✅ **Progress visibility** with detailed timestamped reports
-- ✅ **95-98% cost savings** with Z.ai routing optimization
-- ✅ **Background execution** with Redis persistence
-
-## Main Chat Execution Rules
-
-**THIS SLASH COMMAND HANDLES EVERYTHING AUTOMATICALLY**
-
-**Main Chat simply executes:**
-```bash
-/cfn-loop-cli "Task description" --mode=standard
-```
-
-**The slash command automatically:**
-- ✅ Spawns coordinator with proper parameters
-- ✅ Handles all agent spawning via CLI
-- ✅ Manages complete CFN Loop workflow
-- ✅ Returns structured result when complete
-
-**Main Chat should NOT:**
-- ❌ Manually spawn any Task() agents for CFN Loop
-- ❌ Ask about retry/iteration decisions (handled automatically)
-- ❌ Monitor agent progress (slash command handles this)
-- ❌ Coordinate between agents (built-in coordination)
+The coordinator handles all agent spawning internally using optimized CLI processes.
 
 ## CLI Mode Benefits
 
@@ -186,6 +143,33 @@ When Main Chat executes `/cfn-loop-cli "task description"`, this slash command:
 - Will force ITERATE if git diff shows zero changes
 - Check coordinator output for validation failures
 
+**Web Portal Access:**
+- Monitor real-time agent progress at http://localhost:3000
+- View detailed execution logs and health status
+- Track iteration progress and confidence scores
+
+## Usage Examples
+
+**Simple API Development:**
+```bash
+/cfn-loop-cli "Build REST API with user authentication"
+```
+
+**Complex Feature with High Quality Requirements:**
+```bash
+/cfn-loop-cli "Implement payment processing with PCI compliance" --mode=enterprise --max-iterations=15
+```
+
+**Quick Prototype:**
+```bash
+/cfn-loop-cli "Build MVP landing page" --mode=mvp
+```
+
+**Infrastructure Deployment:**
+```bash
+/cfn-loop-cli "Set up CI/CD pipeline for microservices"
+```
+
 ## Related Commands
 
 - **Task Mode**: `/cfn-loop-task` (debugging, full visibility)
@@ -201,4 +185,127 @@ When Main Chat executes `/cfn-loop-cli "task description"`, this slash command:
 
 ---
 
-**Version:** 1.0.0 (2025-10-31) - CLI mode: production execution, cost-optimized, background processing
+## 🚨 EXECUTION INSTRUCTIONS (Internal Use)
+
+**Main Chat: Execute this Task() call after slash command processing:**
+
+```javascript
+Task("cfn-v3-coordinator", `
+  CFN LOOP CLI MODE v3.0 - PRODUCTION EXECUTION WITH ENHANCED MONITORING
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  TASK SPECIFICATION
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Task Description: $ARGUMENTS
+  Task ID: cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}
+  Mode: ${mode.toUpperCase()}
+
+  Enhanced Monitoring: Real-time agent tracking, automatic recovery, protocol compliance
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  SUCCESS CRITERIA
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Acceptance Criteria:
+  - [ ] Core functionality implemented
+  - [ ] All tests pass with >80% coverage
+  - [ ] Security review completed
+  - [ ] Documentation updated
+  - [ ] No regression in existing features
+
+  Quality Gates (${mode.toUpperCase()} MODE):
+  - Loop 3 Gate Threshold: ${mode === 'enterprise' ? 0.85 : mode === 'standard' ? 0.75 : 0.70}
+  - Loop 2 Consensus Threshold: ${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+  - Max Iterations: ${maxIterations}
+
+  Definition of Done:
+  - Consensus ≥ threshold achieved
+  - All acceptance criteria met
+  - Product Owner approval received
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ENHANCED ORCHESTRATION CONFIGURATION v3.0
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Mode: ${mode.toUpperCase()}
+  Enhanced Features: Real-time monitoring, automatic recovery, protocol compliance
+
+  Loop 3 Agents (Implementation) - SELECT BASED ON TASK:
+  Examples:
+  - Backend API: backend-dev, researcher, devops
+  - Full-Stack: backend-dev, react-frontend-engineer, devops
+  - Infrastructure: devops, rust-developer, researcher
+  - Security: security-specialist, backend-dev, researcher
+
+  Loop 2 Agents (Validation) - SCALE BY COMPLEXITY:
+  Simple (1-2 files): reviewer, tester
+  Standard (3-5 files): reviewer, tester, architect, security-specialist
+  Complex (>5 files): +code-analyzer, +performance-benchmarker
+
+  Product Owner: product-owner
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  EXECUTION INSTRUCTIONS (Enhanced v3.0)
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  1. INVOKE ENHANCED ORCHESTRATOR (CLI spawning with monitoring):
+
+     TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
+     MODE="${mode}"
+     LOOP3_AGENTS="backend-dev,researcher,devops"  # Customize for task
+     LOOP2_AGENTS="reviewer,tester,architect,security-specialist"  # Scale by complexity
+
+     ./.claude/skills/cfn-loop-orchestration/orchestrate.sh \\
+       --task-id "$TASK_ID" \\
+       --mode "$MODE" \\
+       --loop3-agents "$LOOP3_AGENTS" \\
+       --loop2-agents "$LOOP2_AGENTS" \\
+       --product-owner "product-owner" \\
+       --max-iterations ${maxIterations}
+
+  2. ENHANCED ORCHESTRATOR HANDLES v3.0:
+     - ✅ Spawns all agents via CLI (background) with protocol compliance
+     - ✅ Real-time agent progress monitoring and stuck detection
+     - ✅ Automatic recovery from dead processes
+     - ✅ Enhanced context validation prevents "consensus on vapor"
+     - ✅ Loop 3: Gate check (≥threshold) → PASS/ITERATE with health verification
+     - ✅ Loop 2: Consensus check (≥threshold) → COMPLETE/ITERATE
+     - ✅ Product Owner: PROCEED/ITERATE/ABORT decision with deliverable validation
+     - ✅ Git commit/push on PROCEED
+     - ✅ Returns structured result to Main Chat
+
+  3. RETURN STRUCTURED RESULT:
+     {
+       "taskId": "cfn-cli-XXXXX",
+       "status": "complete|failed",
+       "iterations": {"loop3": N, "loop2": M},
+       "finalConsensus": 0.XX,
+       "acceptanceCriteria": {
+         "met": [...],
+         "pending": [...]
+       },
+       "deliverables": [...],
+       "enhancedMonitoring": {
+         "agentHealth": "healthy|recovered",
+         "processRecovery": true,
+         "protocolCompliance": true
+       },
+       "recommendations": [...]
+     }
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  CRITICAL ENHANCED RULES v3.0
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - ✅ USE enhanced orchestration script with real-time monitoring
+  - ✅ ALL agents run in background via npx claude-flow-novice (enhanced v3.0)
+  - ✅ USE Redis BLPOP for loop dependencies (zero-token coordination)
+  - ✅ AGENTS use Z.ai routing automatically (when enabled)
+  - ✅ ENFORCE protocol compliance (prevent "consensus on vapor")
+  - ✅ MONITOR agent health and auto-recover stuck processes
+  - ✅ RETURN structured result with enhanced monitoring data
+`, "cfn-v3-coordinator")
+```
+
+**Version:** 3.0.0 (2025-11-05) - Enhanced CLI mode: production execution with real-time monitoring, automatic recovery, and protocol compliance

package/dist/agent/skill-mcp-selector.js

@@ -0,0 +1,459 @@
+/**
+ * Skill-based MCP Selection System
+ * Automatically selects MCP servers based on agent skills and requirements
+ */ const fs = require('fs').promises;
+const path = require('path');
+const AgentTokenManager = require('../cli/agent-token-manager.js');
+let SkillMCPSelector = class SkillMCPSelector {
+    constructor(options = {}){
+        this.tokenManager = new AgentTokenManager(options);
+        this.agentConfigPath = options.agentConfigPath || './config/agent-whitelist.json';
+        this.skillConfigPath = options.skillConfigPath || './config/skill-requirements.json';
+        this.mcpServersPath = options.mcpServersPath || './config/mcp-servers.json';
+        this.agentWhitelist = new Map();
+        this.skillRequirements = new Map();
+        this.mcpServers = new Map();
+    }
+    async initialize() {
+        await this.tokenManager.initialize();
+        await this.loadConfigurations();
+        console.log('[SkillMCPSelector] Initialized successfully');
+    }
+    async loadConfigurations() {
+        // Load agent whitelist
+        const agentConfig = await this.loadJson(this.agentConfigPath);
+        this.agentWhitelist.clear();
+        for (const agent of agentConfig.agents){
+            this.agentWhitelist.set(agent.type, agent);
+        }
+        // Load skill requirements
+        const skillConfig = await this.loadJson(this.skillConfigPath);
+        this.skillRequirements.clear();
+        for (const [tool, requirements] of Object.entries(skillConfig.tools)){
+            this.skillRequirements.set(tool, requirements);
+        }
+        // Load MCP server configurations
+        try {
+            const mcpConfig = await this.loadJson(this.mcpServersPath);
+            for (const [name, config] of Object.entries(mcpConfig.servers)){
+                this.mcpServers.set(name, config);
+            }
+        } catch (error) {
+            console.warn('[SkillMCPSelector] MCP servers config not found, using defaults');
+            this.initializeDefaultMCPServers();
+        }
+    }
+    async loadJson(filePath) {
+        const resolvedPath = path.resolve(filePath);
+        const content = await fs.readFile(resolvedPath, 'utf8');
+        return JSON.parse(content);
+    }
+    initializeDefaultMCPServers() {
+        // Default MCP server configurations
+        const defaultServers = {
+            'playwright': {
+                name: 'playwright',
+                displayName: 'Playwright Browser Automation',
+                description: 'Browser automation and screenshot capabilities',
+                containerImage: 'claude-flow-novice:mcp-playwright',
+                tools: [
+                    'take_screenshot',
+                    'search_google',
+                    'navigate_and_interact'
+                ],
+                skills: [
+                    'browser-automation',
+                    'screenshot-capture',
+                    'web-interaction'
+                ],
+                resourceRequirements: {
+                    memoryMB: 1024,
+                    cpuUnits: 2
+                }
+            },
+            'redis': {
+                name: 'redis',
+                displayName: 'Redis Database',
+                description: 'Redis key-value store operations',
+                containerImage: 'claude-flow-novice:mcp-redis',
+                tools: [
+                    'redis_get',
+                    'redis_set',
+                    'redis_keys'
+                ],
+                skills: [
+                    'redis-operations',
+                    'cache-management'
+                ],
+                resourceRequirements: {
+                    memoryMB: 256,
+                    cpuUnits: 1
+                }
+            },
+            'postgres': {
+                name: 'postgres',
+                displayName: 'PostgreSQL Database',
+                description: 'PostgreSQL database operations',
+                containerImage: 'claude-flow-novice:mcp-postgres',
+                tools: [
+                    'postgres_query',
+                    'postgres_schema',
+                    'postgres_migrate'
+                ],
+                skills: [
+                    'database-design',
+                    'sql-operations'
+                ],
+                resourceRequirements: {
+                    memoryMB: 512,
+                    cpuUnits: 2
+                }
+            },
+            'security-scanner': {
+                name: 'security-scanner',
+                displayName: 'Security Scanner',
+                description: 'Security vulnerability scanning and analysis',
+                containerImage: 'claude-flow-novice:mcp-security',
+                tools: [
+                    'security_scan',
+                    'vulnerability_check',
+                    'compliance_validate'
+                ],
+                skills: [
+                    'security-auditing',
+                    'vulnerability-scanning'
+                ],
+                resourceRequirements: {
+                    memoryMB: 1536,
+                    cpuUnits: 4
+                }
+            }
+        };
+        for (const [name, config] of Object.entries(defaultServers)){
+            this.mcpServers.set(name, config);
+        }
+    }
+    /**
+   * Determine which MCP servers an agent needs based on their skills
+   */ selectMCPServers(agentType, agentSkills = null) {
+        const agentConfig = this.agentWhitelist.get(agentType);
+        if (!agentConfig) {
+            throw new Error(`Unknown agent type: ${agentType}`);
+        }
+        // Use provided skills or fall back to agent config
+        const skills = agentSkills || agentConfig.skills;
+        // Determine required MCP servers based on skills
+        const requiredMCPServers = new Set();
+        const skillToMCPServerMap = this.getSkillToMCPServerMapping();
+        // Map skills to required MCP servers
+        for (const skill of skills){
+            if (skillToMCPServerMap.has(skill)) {
+                const servers = skillToMCPServerMap.get(skill);
+                servers.forEach((server)=>requiredMCPServers.add(server));
+            }
+        }
+        // Add explicitly allowed MCP servers from agent config
+        if (agentConfig.allowedMcpServers) {
+            agentConfig.allowedMcpServers.forEach((server)=>requiredMCPServers.add(server));
+        }
+        // Convert to array and sort by priority
+        const selectedServers = Array.from(requiredMCPServers).filter((server)=>this.mcpServers.has(server)).sort((a, b)=>{
+            const priorityA = this.mcpServers.get(a).priority || 999;
+            const priorityB = this.mcpServers.get(b).priority || 999;
+            return priorityA - priorityB;
+        });
+        return {
+            agentType,
+            agentSkills: skills,
+            selectedMCPServers,
+            serverDetails: selectedServers.map((server)=>this.mcpServers.get(server)),
+            totalMemoryRequired: selectedServers.reduce((sum, server)=>sum + (this.mcpServers.get(server).resourceRequirements?.memoryMB || 512), 0),
+            totalCPURequired: selectedServers.reduce((sum, server)=>sum + (this.mcpServers.get(server).resourceRequirements?.cpuUnits || 1), 0)
+        };
+    }
+    /**
+   * Get mapping from skills to required MCP servers
+   */ getSkillToMCPServerMapping() {
+        const skillMap = new Map();
+        // Build mapping from MCP server configurations
+        for (const [serverName, serverConfig] of this.mcpServers.entries()){
+            for (const skill of serverConfig.skills || []){
+                if (!skillMap.has(skill)) {
+                    skillMap.set(skill, new Set());
+                }
+                skillMap.get(skill).add(serverName);
+            }
+        }
+        // Also add mappings from tool requirements
+        for (const [toolName, toolConfig] of this.skillRequirements.entries()){
+            for (const skill of toolConfig.requiredSkills || []){
+                // Find MCP servers that provide this tool
+                for (const [serverName, serverConfig] of this.mcpServers.entries()){
+                    if (serverConfig.tools?.includes(toolName)) {
+                        if (!skillMap.has(skill)) {
+                            skillMap.set(skill, new Set());
+                        }
+                        skillMap.get(skill).add(serverName);
+                    }
+                }
+            }
+        }
+        return skillMap;
+    }
+    /**
+   * Generate tokens for selected MCP servers
+   */ async generateMCPTokens(agentType, selectedServers, options = {}) {
+        const tokens = [];
+        for (const serverName of selectedServers){
+            try {
+                const serverConfig = this.mcpServers.get(serverName);
+                if (!serverConfig) {
+                    console.warn(`[SkillMCPSelector] Server configuration not found: ${serverName}`);
+                    continue;
+                }
+                // Generate server-specific token
+                const tokenData = await this.tokenManager.registerAgentToken(agentType, {
+                    expiresIn: options.expiresIn || '24h',
+                    description: `Token for ${serverConfig.displayName}`,
+                    createdBy: 'skill-mcp-selector',
+                    mcpServer: serverName
+                });
+                tokens.push({
+                    serverName,
+                    displayName: serverConfig.displayName,
+                    token: tokenData.token,
+                    expiresAt: tokenData.expiresAt,
+                    containerImage: serverConfig.containerImage,
+                    connectionInfo: this.generateConnectionInfo(serverName, serverConfig, tokenData.token)
+                });
+                console.log(`[SkillMCPSelector] Generated token for ${agentType} → ${serverName}`);
+            } catch (error) {
+                console.error(`[SkillMCPSelector] Failed to generate token for ${serverName}:`, error);
+            }
+        }
+        return tokens;
+    }
+    /**
+   * Generate connection information for MCP server
+   */ generateConnectionInfo(serverName, serverConfig, token) {
+        const baseInfo = {
+            serverName,
+            token,
+            authentication: {
+                type: 'token-based',
+                header: 'x-agent-token',
+                agentTypeHeader: 'x-agent-type'
+            }
+        };
+        // Add server-specific connection details
+        if (serverConfig.connectionType === 'docker') {
+            return {
+                ...baseInfo,
+                type: 'docker-container',
+                containerName: `mcp-${serverName}`,
+                containerImage: serverConfig.containerImage,
+                dockerArgs: [
+                    'run',
+                    '--rm',
+                    '--init',
+                    '--name',
+                    `mcp-${serverName}`,
+                    '--memory',
+                    `${serverConfig.resourceRequirements?.memoryMB || 512}m`,
+                    '--cpus',
+                    `${serverConfig.resourceRequirements?.cpuUnits || 1}`,
+                    '-e',
+                    `MCP_SERVER=${serverName}`,
+                    '-e',
+                    `MCP_AUTH_REQUIRED=true`,
+                    '-e',
+                    `MCP_REDIS_URL=${process.env.MCP_REDIS_URL || 'redis://localhost:6379'}`,
+                    serverConfig.containerImage,
+                    'node',
+                    `/app/mcp-${serverName}-server.js`
+                ]
+            };
+        } else {
+            return {
+                ...baseInfo,
+                type: 'http-endpoint',
+                url: serverConfig.url || `http://localhost:${3000 + this.mcpServers.size}`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-agent-token': token,
+                    'x-agent-type': 'dynamic'
+                }
+            };
+        }
+    }
+    /**
+   * Get complete MCP configuration for an agent
+   */ async getAgentMCPConfiguration(agentType, agentSkills = null, options = {}) {
+        try {
+            // Select required MCP servers
+            const selection = this.selectMCPServers(agentType, agentSkills);
+            // Generate tokens for selected servers
+            const tokens = await this.generateMCPTokens(agentType, selection.selectedMCPServers, options);
+            return {
+                agentType,
+                agentSkills: selection.agentSkills,
+                mcpConfiguration: {
+                    mcpServers: tokens.reduce((config, tokenInfo)=>{
+                        config[tokenInfo.serverName] = {
+                            command: 'docker',
+                            args: tokenInfo.connectionInfo.dockerArgs,
+                            env: {
+                                'MCP_SERVER': tokenInfo.serverName,
+                                'MCP_AUTH_REQUIRED': 'true',
+                                'AGENT_TOKEN': tokenInfo.token
+                            }
+                        };
+                        return config;
+                    }, {})
+                },
+                selection,
+                tokens,
+                resourceSummary: {
+                    totalMemoryMB: selection.totalMemoryRequired,
+                    totalCPUUnits: selection.totalCPUUnits,
+                    serverCount: selection.selectedMCPServers.length
+                }
+            };
+        } catch (error) {
+            console.error(`[SkillMCPSelector] Failed to get MCP configuration for ${agentType}:`, error);
+            throw error;
+        }
+    }
+    /**
+   * Generate Docker Compose configuration for agent with MCP servers
+   */ async generateDockerComposeConfiguration(agentType, agentSkills = null, options = {}) {
+        const config = await this.getAgentMCPConfiguration(agentType, agentSkills, options);
+        const dockerCompose = {
+            version: '3.8',
+            services: {},
+            networks: {
+                'mcp-network': {
+                    driver: 'bridge'
+                }
+            }
+        };
+        // Add agent service
+        dockerCompose.services[`${agentType}-agent`] = {
+            image: 'claude-flow-novice:agent-container',
+            container_name: `agent-${agentType}-${Date.now()}`,
+            networks: [
+                'mcp-network'
+            ],
+            environment: {
+                'AGENT_TYPE': agentType,
+                'AGENT_MODE': 'containerized',
+                'MCP_AUTH_ENABLED': 'true',
+                'REDIS_URL': process.env.MCP_REDIS_URL || 'redis://redis:6379'
+            },
+            volumes: [
+                '${PWD}/.claude:/app/.claude:ro',
+                '${PWD}/screenshots:/app/screenshots'
+            ],
+            mem_limit: `${config.resourceSummary.totalMemoryMB + 512}m`,
+            depends_on: config.selection.selectedMCPServers.map((server)=>`mcp-${server}`).join(' ')
+        };
+        // Add MCP server services
+        for (const tokenInfo of config.tokens){
+            const serverName = `mcp-${tokenInfo.serverName}`;
+            const serverConfig = this.mcpServers.get(tokenInfo.serverName);
+            dockerCompose.services[serverName] = {
+                image: tokenInfo.containerImage,
+                container_name: `${serverName}-${Date.now()}`,
+                networks: [
+                    'mcp-network'
+                ],
+                environment: {
+                    'MCP_SERVER': tokenInfo.serverName,
+                    'MCP_AUTH_REQUIRED': 'true',
+                    'MCP_REDIS_URL': process.env.MCP_REDIS_URL || 'redis://redis:6379',
+                    'AGENT_TOKEN': tokenInfo.token
+                },
+                volumes: [
+                    '${PWD}/screenshots:/app/screenshots'
+                ],
+                mem_limit: `${serverConfig.resourceRequirements?.memoryMB || 512}m`,
+                cpus: `${(serverConfig.resourceRequirements?.cpuUnits || 1) / 4}`
+            };
+        }
+        // Add Redis service if not present
+        if (!dockerCompose.services.redis) {
+            dockerCompose.services.redis = {
+                image: 'redis:7-alpine',
+                container_name: 'mcp-redis',
+                networks: [
+                    'mcp-network'
+                ],
+                volumes: [
+                    'redis-data:/data'
+                ],
+                mem_limit: '256m'
+            };
+            dockerCompose.volumes = {
+                'redis-data': {}
+            };
+        }
+        return dockerCompose;
+    }
+    /**
+   * Get statistics about skill-MCP mappings
+   */ getStatistics() {
+        const skillMap = this.getSkillToMCPServerMapping();
+        return {
+            totalAgents: this.agentWhitelist.size,
+            totalMCPServers: this.mcpServers.size,
+            totalSkills: skillMap.size,
+            agentTypes: Array.from(this.agentWhitelist.keys()),
+            mcpServerNames: Array.from(this.mcpServers.keys()),
+            skillCoverage: Array.from(skillMap.entries()).map(([skill, servers])=>({
+                    skill,
+                    requiredServers: Array.from(servers),
+                    serverCount: servers.size
+                }))
+        };
+    }
+    /**
+   * Validate agent-MCP configuration
+   */ validateConfiguration(agentType, mcpConfiguration) {
+        const agentConfig = this.agentWhitelist.get(agentType);
+        if (!agentConfig) {
+            return {
+                valid: false,
+                errors: [
+                    `Unknown agent type: ${agentType}`
+                ]
+            };
+        }
+        const errors = [];
+        const warnings = [];
+        // Check required MCP servers
+        const requiredServers = agentConfig.allowedMcpServers || [];
+        const configuredServers = Object.keys(mcpConfiguration.mcpServers || {});
+        for (const server of requiredServers){
+            if (!configuredServers.includes(server)) {
+                errors.push(`Required MCP server missing: ${server}`);
+            }
+        }
+        // Check for unauthorized servers
+        for (const server of configuredServers){
+            if (!requiredServers.includes(server)) {
+                warnings.push(`Potentially unauthorized MCP server: ${server}`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    async shutdown() {
+        await this.tokenManager.shutdown();
+    }
+};
+module.exports = SkillMCPSelector;
+
+//# sourceMappingURL=skill-mcp-selector.js.map