claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/commands/cfn-docker/CFN_DOCKER_LOOP.md

@@ -1,377 +0,0 @@
----
-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
-```

package/claude-assets/commands/cfn-docker/CFN_DOCKER_NATIVE.md

@@ -1,295 +0,0 @@
----
-description: "Execute CFN Loop with fully containerized coordinator using Docker-in-Docker (native container mode)"
-argument-hint: "[task-description] --mode=mvp|standard|enterprise"
-allowed-tools: ["Bash", "Read"]
----
-
-# CFN Docker Loop - Native Container Mode
-
-Execute CFN Loop with coordinator running as a Docker container (Docker-in-Docker).
-
-**Task Description:** $ARGUMENTS
-
-## Overview
-
-This command runs the CFN Docker v3 coordinator in a container instead of via Task() tool.
-
-**Benefits:**
-- ✅ Consistent execution model (coordinator + workers all containerized)
-- ✅ Resource isolation for coordinator
-- ✅ Can use cheaper models via custom routing
-- ✅ Portable across environments (CI/CD friendly)
-- ✅ Planning phase fully integrated
-
-**Architecture:**
-```
-Main Chat (docker run)
-    ↓
-cfn-coordinator:v3 (Docker container)
-    ↓ orchestrate.sh
-    ↓ spawn-agent.sh
-Worker Agents (Docker containers)
-```
-
-## Execution Steps
-
-### Step 1: Parse Arguments and Set Defaults
-
-```bash
-# Extract task description
-TASK_DESCRIPTION="$ARGUMENTS"
-
-# Generate unique task ID
-TASK_ID="task-$(date +%s)-$$"
-
-# Parse mode from arguments (default: standard)
-if [[ "$ARGUMENTS" =~ --mode=([a-z]+) ]]; then
-    MODE="${BASH_REMATCH[1]}"
-else
-    MODE="standard"
-fi
-
-echo "🚀 CFN Docker Loop - Native Container Mode"
-echo "   Task ID: ${TASK_ID}"
-echo "   Mode: ${MODE}"
-echo "   Description: ${TASK_DESCRIPTION}"
-```
-
-### Step 2: Ensure Redis is Running
-
-```bash
-# Check if Redis container exists
-if ! docker ps | grep -q cfn-redis; then
-    echo "📦 Starting Redis service..."
-    docker-compose up -d redis
-    sleep 3
-
-    # Verify Redis is responding
-    if ! docker exec cfn-redis redis-cli ping > /dev/null 2>&1; then
-        echo "❌ Redis failed to start"
-        exit 1
-    fi
-
-    echo "✅ Redis started successfully"
-else
-    echo "✅ Redis already running"
-fi
-```
-
-### Step 3: Build Coordinator Image (if needed)
-
-```bash
-# Check if coordinator image exists
-if ! docker images | grep -q "cfn-coordinator.*v3"; then
-    echo "🔨 Building CFN coordinator image..."
-    docker build -f docker/Dockerfile.coordinator -t cfn-coordinator:v3 .
-
-    if [[ $? -ne 0 ]]; then
-        echo "❌ Failed to build coordinator image"
-        exit 1
-    fi
-
-    echo "✅ Coordinator image built"
-else
-    echo "✅ Coordinator image exists"
-fi
-```
-
-### Step 4: Spawn Coordinator Container
-
-```bash
-echo "🐳 Spawning coordinator container..."
-
-docker run --rm \
-  --name "cfn-coordinator-${TASK_ID}" \
-  --network mcp-network \
-  --volume /var/run/docker.sock:/var/run/docker.sock \
-  --volume "$(pwd):/app/codebase:ro" \
-  --volume /tmp:/tmp \
-  --env ANTHROPIC_API_KEY="${ANTHROPIC_API_KEY}" \
-  --env CFN_REDIS_HOST=cfn-redis \
-  --env CFN_REDIS_PORT=6379 \
-  --env TASK_ID="${TASK_ID}" \
-  --env MODE="${MODE}" \
-  --env TASK_DESCRIPTION="${TASK_DESCRIPTION}" \
-  --env MEMORY_LIMIT="${MEMORY_LIMIT:-1g}" \
-  --env MAX_ITERATIONS="${MAX_ITERATIONS:-10}" \
-  --env GATE_THRESHOLD="${GATE_THRESHOLD:-0.75}" \
-  --env CONSENSUS_THRESHOLD="${CONSENSUS_THRESHOLD:-0.90}" \
-  --env NETWORK="mcp-network" \
-  --env CFN_CUSTOM_ROUTING="${CFN_CUSTOM_ROUTING:-false}" \
-  --env ZAI_API_KEY="${ZAI_API_KEY:-}" \
-  cfn-coordinator:v3
-
-COORDINATOR_EXIT_CODE=$?
-```
-
-### Step 5: Report Results
-
-```bash
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-if [[ $COORDINATOR_EXIT_CODE -eq 0 ]]; then
-    echo "✅ CFN Loop execution completed successfully"
-    echo "   Task ID: ${TASK_ID}"
-    echo "   Mode: ${MODE}"
-
-    # Check for planning artifacts
-    if [[ -f "/tmp/cfn-docker-plan-${TASK_ID}.json" ]]; then
-        ATOMIC_TASKS=$(jq -r '.atomic_tasks | length' "/tmp/cfn-docker-plan-${TASK_ID}.json" 2>/dev/null || echo "unknown")
-        echo "   Atomic Tasks: ${ATOMIC_TASKS}"
-    fi
-
-    # Check Redis for task state
-    echo ""
-    echo "📊 Task state stored in Redis:"
-    echo "   redis-cli HGETALL cfn_docker:task:${TASK_ID}"
-
-else
-    echo "❌ CFN Loop execution failed"
-    echo "   Exit code: ${COORDINATOR_EXIT_CODE}"
-    echo "   Task ID: ${TASK_ID}"
-    echo ""
-    echo "🔍 Debug steps:"
-    echo "   1. Check Redis: redis-cli HGETALL cfn_docker:task:${TASK_ID}"
-    echo "   2. Check planning file: cat /tmp/cfn-docker-plan-${TASK_ID}.json"
-    echo "   3. Check logs: docker logs cfn-coordinator-${TASK_ID} (if still running)"
-fi
-
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-```
-
-## Environment Variables
-
-### Required
-```bash
-ANTHROPIC_API_KEY     # API key for LLM calls (coordinator planning)
-```
-
-### Optional Configuration
-```bash
-MODE=standard         # mvp|standard|enterprise
-MEMORY_LIMIT=1g      # Worker agent memory limit
-MAX_ITERATIONS=10    # Maximum CFN Loop iterations
-GATE_THRESHOLD=0.75  # Loop 3 self-validation threshold
-CONSENSUS_THRESHOLD=0.90  # Loop 2 validator consensus threshold
-```
-
-### Optional Custom Routing
-```bash
-CFN_CUSTOM_ROUTING=true    # Enable Z.ai routing
-ZAI_API_KEY=xxx           # Z.ai API key
-ZAI_MODEL=glm-4.6         # Model for workers
-```
-
-## Examples
-
-### Basic Usage
-```bash
-/cfn-docker-native "Implement user authentication system"
-```
-
-### With Mode Selection
-```bash
-/cfn-docker-native "Build responsive dashboard UI" --mode=enterprise
-```
-
-### With Custom Routing (Cost Optimization)
-```bash
-export CFN_CUSTOM_ROUTING=true
-export ZAI_API_KEY="your-zai-key"
-/cfn-docker-native "Optimize database queries"
-```
-
-### For CI/CD
-```bash
-# In CI pipeline
-export ANTHROPIC_API_KEY="${SECRETS_ANTHROPIC_KEY}"
-/cfn-docker-native "Deploy to staging environment" --mode=standard
-```
-
-## Comparison: Native vs Task Mode
-
-| Aspect | Task Mode | Native Mode |
-|--------|-----------|-------------|
-| **Coordinator** | Task() tool (Main Chat context) | Docker container |
-| **Visibility** | Full (logs in Main Chat) | Reduced (docker logs) |
-| **Resource Isolation** | None | Full (memory limits) |
-| **Cost Optimization** | Standard | Can use cheaper models |
-| **CI/CD Friendly** | No | Yes |
-| **Debugging** | Easy | Moderate |
-| **Portability** | Requires Claude Code | Any Docker environment |
-| **Planning Phase** | ✅ Works | ✅ Works (via /tmp mount) |
-
-## Troubleshooting
-
-### Coordinator Container Won't Start
-```bash
-# Check if image exists
-docker images | grep cfn-coordinator
-
-# Rebuild if needed
-docker build -f Dockerfile.cfn-coordinator -t cfn-coordinator:v3 .
-
-# Check Docker socket permissions
-ls -la /var/run/docker.sock
-```
-
-### Planning File Not Generated
-```bash
-# Check planning file
-ls -la /tmp/cfn-docker-plan-*.json
-
-# Check coordinator logs
-docker logs cfn-coordinator-${TASK_ID}
-
-# Verify coordinator can write to /tmp
-docker run --rm -v /tmp:/tmp cfn-coordinator:v3 /bin/sh -c "touch /tmp/test && rm /tmp/test"
-```
-
-### Workers Not Spawning
-```bash
-# Check if coordinator can access Docker
-docker run --rm -v /var/run/docker.sock:/var/run/docker.sock cfn-coordinator:v3 /bin/sh -c "docker ps"
-
-# Check network exists
-docker network ls | grep mcp-network
-
-# Create network if needed
-docker network create mcp-network
-```
-
-### Redis Connection Issues
-```bash
-# Check Redis status
-docker ps | grep cfn-redis
-
-# Test connection from coordinator network
-docker run --rm --network mcp-network redis:7-alpine redis-cli -h cfn-redis ping
-```
-
-## Notes
-
-- **Docker-in-Docker:** Coordinator mounts `/var/run/docker.sock` to spawn workers
-- **Codebase Access:** Mounted read-only at `/app/codebase` for orchestrate.sh
-- **Planning Files:** Shared via `/tmp` volume mount
-- **Network:** All containers (coordinator + workers + Redis) use `mcp-network`
-- **Auto-cleanup:** Coordinator container removes itself on exit (--rm flag)
-
-## When to Use This Command
-
-**Use Native Mode When:**
-- Running in CI/CD pipelines
-- Want full resource isolation
-- Testing Docker-in-Docker setup
-- Cost optimization with custom routing
-- Need portable execution environment
-
-**Use Task Mode When:**
-- Developing/debugging coordinator logic
-- Want full visibility into execution
-- Need immediate log access
-- Rapid iteration on planning phase
-
-Both modes use the same planning phase implementation and produce identical results.