claude-flow-novice/.claude/cfn-extras/commands/cfn-docker/CFN_DOCKER_LOOP.md

Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture Includes Local RuVector Accelerator and all CFN skills for complete functionality.

---
description: "Execute container-based CFN Loop with skill-based MCP isolation and resource management"
argument-hint: "[task-description] --mode=mvp|standard|enterprise --memory-limit=1g --network=mcp-network"
allowed-tools: ["Bash", "Read", "TodoWrite", "Task"]
---

# CFN Docker Loop - Container-Based Agent Orchestration

Execute container-based CFN Loop with skill-based MCP isolation, resource management, and cost optimization.

**Task Description:** $ARGUMENTS

## Usage Modes

### Task Mode (Debugging/Development)
```bash
/cfn-docker-loop-task "Implement user authentication" --mode=standard
```
- Main Chat spawns all agents via Task()
- Full visibility into agent execution
- Higher cost but complete debugging capability
- Use for development, testing, and learning

### CLI Mode (Production)
```bash
/cfn-docker-loop-cli "Implement user authentication" --mode=standard
```
- Main Chat spawns only cfn-docker-v3-coordinator
- Coordinator spawns agents via CLI (95% cost savings)
- Use for production, long tasks, cost-sensitive workloads

## Execution Modes

### MVP Mode (Quick Execution)
- **Iterations:** 3
- **Gate Threshold:** 0.70
- **Consensus Threshold:** 0.80
- **Validators:** 2
- **Use Case:** Rapid prototyping, simple tasks

### Standard Mode (Balanced)
- **Iterations:** 10
- **Gate Threshold:** 0.75
- **Consensus Threshold:** 0.90
- **Validators:** 3
- **Use Case:** Most production tasks, balanced quality/speed

### Enterprise Mode (Thorough)
- **Iterations:** 15
- **Gate Threshold:** 0.85
- **Consensus Threshold:** 0.95
- **Validators:** 5
- **Use Case:** Critical systems, high-quality requirements

## Command Options

```bash
# Basic execution
/cfn-docker-loop "Implement user authentication"

# Mode selection
/cfn-docker-loop "Implement user authentication" --mode=standard

# Resource constraints
/cfn-docker-loop "Analyze security vulnerabilities" --mode=enterprise --memory-limit=2g

# Network configuration
/cfn-docker-loop "Build responsive UI" --network=frontend-network

# Custom agent selection
/cfn-docker-loop "Optimize database queries" --agents=backend-developer,database-specialist

# Context file
/cfn-docker-loop "Migrate user data" --context-file migration-context.json

# Task vs CLI mode selection
/cfn-docker-loop-task "Debug authentication issue" --mode=mvp --verbose
/cfn-docker-loop-cli "Process user payments" --mode=enterprise --timeout=1800
```

## Architecture Overview

```
Main Chat
    ↓ (Task tool)
cfn-docker-v3-coordinator
    ↓ (orchestration)
CFN Docker Loop Orchestration
    ↓ (Redis coordination)
CFN Docker Redis Coordination
    ↓ (agent spawning)
CFN Docker Agent Spawning
    ↓ (container execution)
Docker Containers (Agents)
    ↓ (MCP selection)
CFN Docker Skill MCP Selection
    ↓ (authenticated access)
MCP Servers (Playwright, Redis, Security)
```

## Key Features

### 🐳 Container-Based Isolation
- All agents run in isolated Docker containers
- Memory limits prevent WSL2 crashes
- Resource controls ensure fair usage
- Complete agent lifecycle management

### 🔐 Skill-Based MCP Security
- Dynamic MCP server selection based on agent skills
- Token-based authentication for MCP access
- 50%+ memory savings vs monolithic approach
- Enterprise-grade security controls

### 💰 Cost Optimization
- **95% cost savings** vs Task-based spawning
- Custom routing with Z.ai when enabled
- Resource-efficient container utilization
- Pay only for required MCP servers

### 🔄 Swarm Recovery
- Redis persistence for crash recovery
- State survives interruptions
- Automatic agent respawning on failure
- Complete task context preservation

## Workflow Execution

### 1. Task Analysis
- Parse task description for requirements
- Select appropriate agent types
- Determine required skills and MCP servers
- Create execution context

### 2. Loop 3: Implementation
- Spawn 3 specialized implementer agents
- Parallel execution in isolated containers
- Agent-specific MCP server access
- Confidence scoring and reporting

### 3. Gate Check
- Collect confidence scores from implementers
- Compare against gate threshold
- Decision: proceed to validation or iterate
- Adaptive agent selection for iterations

### 4. Loop 2: Validation
- Spawn 2-5 validator agents (reviewers, testers, security)
- Sequential validation to prevent conflicts
- Comprehensive code review and testing
- Consensus collection and analysis

### 5. Product Owner Decision
- Final decision based on consensus and deliverables
- PROCEED: Implementation complete
- ITERATE: More work needed with specific feedback
- ABORT: Task not feasible or requirements unclear

## Resource Management

### Memory Optimization
| Agent Type | Default Memory | MCP Servers | Savings |
|------------|---------------|-------------|---------|
| **Frontend Engineer** | 1GB | Playwright | 50% |
| **Backend Developer** | 768MB | Redis/Postgres | 62% |
| **Security Specialist** | 1.5GB | Security Scanner | 25% |

### Network Configuration
- **Isolated Networks**: Separate Docker networks for security
- **MCP Communication**: Local networking for fast MCP access
- **Service Discovery**: Automatic MCP server discovery
- **Connection Reuse**: Persistent connections for performance

### Resource Monitoring
- **Real-time Monitoring**: Memory, CPU, network usage tracking
- **Alert Management**: Automatic alerts for resource issues
- **Performance Metrics**: Detailed performance analytics
- **Cost Tracking**: Per-task cost analysis and optimization

## Security Architecture

### Multi-Layer Protection
1. **Container Isolation**: Agents run in isolated Docker containers
2. **Token Authentication**: MCP servers require valid agent tokens
3. **Skill-Based Authorization**: Tools require specific agent skills
4. **Rate Limiting**: Per-agent request limits for resource protection
5. **Audit Logging**: Full request/response logging for compliance
6. **Network Segmentation**: Isolated networks for different agent types

### Access Control Flow
```
Agent Request → Token Validation → Skill Check → Rate Limit → Tool Access
```

## Integration with Existing Systems

### Hello World Test Compatibility
- **Enhanced Layer 0**: MCP tool validation with authentication
- **Enhanced Layer 5**: Container-based agent spawning
- **Enhanced Layer 6**: MCP-enabled agent coordination
- **Enhanced Layer 7**: Container-aware error handling

### CFN Loop Consistency
- Same CFN Loop execution model as standard CFN
- Compatible consensus validation and decision flow
- Drop-in replacement with enhanced capabilities
- Backward compatible with existing workflows

## Error Handling and Recovery

### Container Failure Recovery
- **Automatic Restart**: Containers restart on failure
- **State Preservation**: Agent state stored in Redis
- **Graceful Degradation**: Fallback to direct tool access
- **Manual Intervention**: Manual override capabilities

### Swarm Recovery
- **State Persistence**: Complete state stored in Redis
- **Crash Recovery**: Automatic recovery from interruptions
- **Agent Respawning**: Fresh agents spawned on recovery
- **Context Restoration**: Full task context preserved

## Performance Metrics

### Resource Efficiency
- **Memory Savings**: 50-75% reduction vs monolithic approach
- **Startup Time**: 30% faster with selective MCP loading
- **Network Traffic**: 60% reduction with local MCP communication
- **CPU Efficiency**: 40% improvement with targeted tool loading

### Scalability Improvements
- **Concurrent Agents**: 10x increase in concurrent agent capacity
- **Resource Contention**: Eliminated through container isolation
- **WSL2 Stability**: 100% reduction in crash incidents
- **Cost Efficiency**: 95%+ cost reduction vs Task-based spawning

## Monitoring and Observability

### Real-time Monitoring
```bash
# Monitor task progress
/cfn-docker-monitor --task-id task-authentication

# Resource usage dashboard
/cfn-docker-stats --agent-id agent-frontend-001

# MCP server status
/cfn-docker-mcp-status --servers playwright,redis
```

### Performance Analytics
```bash
# Task performance report
/cfn-docker-performance --task-id task-authentication --report

# Agent efficiency metrics
/cfn-docker-agent-metrics --agent-id agent-backend-001 --duration 1h

# Cost analysis
/cfn-docker-cost-analysis --task-id task-authentication --breakdown
```

## Best Practices

### Task Design
- **Clear Requirements**: Specific, measurable acceptance criteria
- **Appropriate Mode**: Choose MVP/Standard/Enterprise based on complexity
- **Resource Planning**: Estimate memory and CPU requirements
- **Success Criteria**: Define clear success metrics

### Agent Selection
- **Skill Matching**: Select agents with relevant domain expertise
- **Diverse Perspectives**: Include different agent types for coverage
- **Performance History**: Consider past agent performance
- **Resource Optimization**: Balance capability with resource usage

### Security Considerations
- **Principle of Least Privilege**: Agents only access required MCP servers
- **Token Management**: Use appropriate token expiration times
- **Audit Trail**: Enable comprehensive logging for compliance
- **Network Isolation**: Use isolated networks for sensitive tasks

## Troubleshooting

### Common Issues
1. **Container Won't Start**: Check Docker daemon and resource limits
2. **MCP Connection Failed**: Verify network configuration and token validity
3. **Memory Issues**: Monitor usage and adjust memory limits
4. **Agent Timeout**: Increase timeout or optimize task complexity

### Debug Commands
```bash
# Debug container creation
/cfn-docker-debug --task-id task-authentication --component containers

# Debug MCP connectivity
/cfn-docker-debug --task-id task-authentication --component mcp

# Debug agent communication
/cfn-docker-debug --task-id task-authentication --component coordination

# Full system health check
/cfn-docker-health-check --verbose
```

## Configuration

### Environment Variables
```bash
# Redis Configuration
CFN_DOCKER_REDIS_HOST=localhost
CFN_DOCKER_REDIS_PORT=6379
CFN_DOCKER_REDIS_TTL=3600

# Docker Configuration
CFN_DOCKER_NETWORK=mcp-network
CFN_DOCKER_MEMORY_LIMIT=1g
CFN_DOCKER_CPU_LIMIT=1.0

# MCP Configuration
CFN_DOCKER_MCP_AUTH_REQUIRED=true
CFN_DOCKER_MCP_TOKEN_EXPIRY=24h

# Performance Configuration
CFN_DOCKER_MAX_CONCURRENT_AGENTS=5
CFN_DOCKER_LOOP_TIMEOUT=600
```

### Configuration Files
- **Agent Configuration**: `config/agent-whitelist.json`
- **Skill Requirements**: `config/skill-requirements.json`
- **MCP Servers**: `config/mcp-servers.json`
- **Loop Configuration**: `config/loop-config.json`

## Advanced Usage

### Custom Agent Workflows
```bash
# Custom agent selection with specific skills
/cfn-docker-loop "Implement ML pipeline" \
  --agents=backend-developer,data-scientist,ml-engineer \
  --skills=python,machine-learning,data-processing

# Custom MCP server configuration
/cfn-docker-loop "Process satellite imagery" \
  --mcp-servers=ml-pipeline, image-processor, data-storage \
  --memory-limit=4g
```

### Multi-Task Coordination
```bash
# Execute multiple related tasks
/cfn-docker-batch \
  --tasks "auth-service,user-profiles,notifications" \
  --mode=standard \
  --shared-context

# Epic-level execution
/cfn-docker-epic "Build e-commerce platform" \
  --sprints "auth,catalog,checkout,admin" \
  --mode=enterprise
```

### Integration with External Systems
```bash
# CI/CD pipeline integration
/cfn-docker-loop "Deploy to production" \
  --mode=enterprise \
  --integration=github-actions \
  --deployment-target=aws-eks

# Database migration
/cfn-docker-loop "Migrate to PostgreSQL" \
  --context-file migration-plan.json \
  --rollback-enabled \
  --validation-required
```